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

Polyphase Channelizer Viewer is fully functional again, now using the

Browse Source 
TestTuner and TestTunerController implementations.  This implementation
only has support for channels that are completely centered within a
channelizer output.  Two output slice stitching to form a composite
channel will be implemented next.

Initial profiling indicates that the FFT function within the polyphase
channelizer is now the dominant processing workload - 28% cpu loading
when channelizing a 10 MHz sample rate input into 800 channels running
at 25.0 kHz each.  This is ideal for offloading to an OpenCL kernel and
running on a GPU.
This commit is contained in:
Denny
2018-01-19 12:44:31 -05:00
parent 32ab0598e8
commit b6f282a85a
9 changed files with 208 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/main/java/io/github/dsheirer/source/tuner/TunerController.java
View File

@@ -161,12 +161,12 @@ public abstract class TunerController implements Tunable, ISourceEventProcessor,
return mFrequencyController.getMaximumFrequency();
}
private long getMinTunedFrequency() throws SourceException
public long getMinTunedFrequency() throws SourceException
{
return mFrequencyController.getFrequency() - (getUsableBandwidth() / 2);
}
private long getMaxTunedFrequency() throws SourceException
public long getMaxTunedFrequency() throws SourceException
{
return mFrequencyController.getFrequency() + (getUsableBandwidth() / 2);
}

67
src/main/java/io/github/dsheirer/source/tuner/test/SampleGenerator.java
View File

@@ -36,6 +36,7 @@ public class SampleGenerator
private int mSweepUpdateInterval;
private long mInterval;
private int mSamplesPerInterval;
private boolean mReuseBuffers;
private ScheduledFuture<?> mScheduledFuture;
/**
@@ -49,17 +50,17 @@ public class SampleGenerator
* @param sweepUpdateRate to turn on sweeping of the tone frequency where the frequency is incremented by the
* rate specified at each interval, resetting to 1 Hz after reaching/exceeding the highest frequency.
*/
public SampleGenerator(int sampleRate, long frequency, long interval, int sweepUpdateRate)
public SampleGenerator(int sampleRate, long frequency, long interval, int sweepUpdateRate, boolean reuseBuffers)
{
if(Math.abs(sweepUpdateRate) >= sampleRate)
{
throw new IllegalArgumentException("Sweep update rate cannot be greater than sample rate");
}
mLog.debug("Sample Generator - Sample Rate:" + sampleRate + " Frequency:" + frequency);
mOscillator = new LowPhaseNoiseOscillator(sampleRate, frequency);
mInterval = interval;
mSweepUpdateInterval = sweepUpdateRate;
mReuseBuffers = reuseBuffers;
updateSamplesPerInterval();
}
@@ -73,9 +74,9 @@ public class SampleGenerator
* @param frequency of the tone produced by the generator
* @param interval in milliseconds for generating samples
*/
public SampleGenerator(int sampleRate, long frequency, long interval)
public SampleGenerator(int sampleRate, long frequency, long interval, boolean reuseBuffers)
{
this(sampleRate, frequency, interval, 0);
this(sampleRate, frequency, interval, 0, reuseBuffers);
}
/**
@@ -84,8 +85,6 @@ public class SampleGenerator
private void updateSamplesPerInterval()
{
mSamplesPerInterval = (int)((double)mOscillator.getSampleRate() * ((double)mInterval / 1000.0));
mLog.debug("Sample Generator - " + mSamplesPerInterval + " samples every " + mInterval + "ms");
}
/**
@@ -175,35 +174,65 @@ public class SampleGenerator
updateSamplesPerInterval();
}
public double getSampleRate()
{
return mOscillator.getSampleRate();
}
/**
* Generates a complex sample buffer and distributes the buffer to a registered listener
*/
public class Generator implements Runnable
{
private int mTriggerInterval = 0;
private long mOscillatorFrequency = 1;
private ComplexBuffer mReusableBuffer;
@Override
public void run()
{
if(mComplexBufferBroadcaster.hasListeners())
{
float[] samples = mOscillator.generate(mSamplesPerInterval);
if(mReuseBuffers)
{
if(mReusableBuffer == null ||
mReusableBuffer.getSamples().length != mSamplesPerInterval ||
mOscillatorFrequency != mOscillator.getFrequency())
{
mOscillatorFrequency = mOscillator.getFrequency();
mReusableBuffer = new TimestampedComplexBuffer(mOscillator.generate(mSamplesPerInterval));
}
mComplexBufferBroadcaster.receive(new TimestampedComplexBuffer(samples));
mComplexBufferBroadcaster.receive(mReusableBuffer);
}
else
{
float[] samples = mOscillator.generate(mSamplesPerInterval);
mComplexBufferBroadcaster.receive(new TimestampedComplexBuffer(samples));
}
if(mSweepUpdateInterval != 0)
{
long updatedFrequency = mOscillator.getFrequency() + mSweepUpdateInterval;
mTriggerInterval++;
if(updatedFrequency > mOscillator.getSampleRate() / 2)
if(mTriggerInterval >= 10)
{
mOscillator.setFrequency(mOscillator.getSampleRate() / -2);
}
else if(updatedFrequency < mOscillator.getSampleRate() / -2)
{
mOscillator.setFrequency(mOscillator.getSampleRate() / 2);
}
else
{
mOscillator.setFrequency(updatedFrequency);
mTriggerInterval = 0;
long updatedFrequency = mOscillator.getFrequency() + mSweepUpdateInterval;
if(updatedFrequency > mOscillator.getSampleRate() / 2)
{
mOscillator.setFrequency(mOscillator.getSampleRate() / -2);
}
else if(updatedFrequency < mOscillator.getSampleRate() / -2)
{
mOscillator.setFrequency(mOscillator.getSampleRate() / 2);
}
else
{
mOscillator.setFrequency(updatedFrequency);
}
}
}
}

48
src/main/java/io/github/dsheirer/source/tuner/test/TestTunerController.java
View File

@@ -30,17 +30,18 @@ public class TestTunerController extends TunerController
{
private final static Logger mLog = LoggerFactory.getLogger(TestTunerController.class);
public static final long MINIMUM_FREQUENCY = 1000000l; //1 MHz
public static final long MAXIMUM_FREQUENCY = 10000000000l; //10 GHz
public static final long DEFAULT_CENTER_FREQUENCY = 100000000; //100 MHz
public static final int DEFAULT_SAMPLE_RATE = 100000; //25 kHz
public static final int DC_NOISE_BANDWIDTH = 0; // +/-5 kHz
public static final double USABLE_BANDWIDTH = 1.00; //100% usable bandwidth
public static final long MINIMUM_FREQUENCY = 1l;
public static final long MAXIMUM_FREQUENCY = 1000000000l;
public static final int SAMPLE_RATE = 225000;
public static final int DC_NOISE_BANDWIDTH = 0;
public static final double USABLE_BANDWIDTH = 1.00;
public static final int SPECTRAL_FRAME_RATE = 20;
public static final long SAMPLE_GENERATION_INTERVAL = 1000 / SPECTRAL_FRAME_RATE;
private SampleGenerator mSampleGenerator;
private long mReferenceFrequency = DEFAULT_CENTER_FREQUENCY;
private boolean mReuseBuffers = true;
private long mFrequency = 100000000l;
/**
* Tuner controller testing implementation.
@@ -50,15 +51,14 @@ public class TestTunerController extends TunerController
super(MINIMUM_FREQUENCY, MAXIMUM_FREQUENCY, DC_NOISE_BANDWIDTH, USABLE_BANDWIDTH);
int sweepRate = 0; //Hz per interval
mSampleGenerator = new SampleGenerator(DEFAULT_SAMPLE_RATE, 12500, SAMPLE_GENERATION_INTERVAL, sweepRate);
long initialToneFrequency = SAMPLE_RATE / 2 + 100;
mSampleGenerator = new SampleGenerator(SAMPLE_RATE, initialToneFrequency, SAMPLE_GENERATION_INTERVAL,
sweepRate, mReuseBuffers);
try
{
mLog.debug("Setting frequency to:" + DEFAULT_CENTER_FREQUENCY);
mFrequencyController.setFrequency(DEFAULT_CENTER_FREQUENCY);
mLog.debug("Setting sample rate of freq controller to: " + DEFAULT_SAMPLE_RATE);
mFrequencyController.setSampleRate(DEFAULT_SAMPLE_RATE);
mFrequencyController.setFrequency(mFrequency);
mFrequencyController.setSampleRate(SAMPLE_RATE);
}
catch(Exception e)
{
@@ -91,7 +91,7 @@ public class TestTunerController extends TunerController
@Override
public long getTunedFrequency() throws SourceException
{
return mReferenceFrequency;
return mFrequency;
}
/**
@@ -102,26 +102,26 @@ public class TestTunerController extends TunerController
@Override
public void setTunedFrequency(long frequency) throws SourceException
{
mReferenceFrequency = frequency;
mFrequency = frequency;
}
/**
* Sets the tone frequency for the sample generator. The tone frequency is offset from the center tuned frequency.
* @param toneFrequency
* Sets the tone output of the frequency generator
* @param frequency in the range: 0 <> Sample Rate
*/
public void setToneFrequency(long toneFrequency)
public void setToneFrequency(long frequency)
{
long frequency = toneFrequency - mReferenceFrequency;
mSampleGenerator.setFrequency(frequency);
}
/**
* Current tone frequency for this test controller.
* @return
* Frequency of the tone being generated
*
* @return tone frequency in range: 0 <> Sample Rate
*/
public long getToneFrequency()
{
return mReferenceFrequency + mSampleGenerator.getFrequency();
return mSampleGenerator.getFrequency();
}
/**
@@ -130,7 +130,7 @@ public class TestTunerController extends TunerController
@Override
public double getCurrentSampleRate()
{
return mFrequencyController.getSampleRate();
return mSampleGenerator.getSampleRate();
}
/**
@@ -138,6 +138,6 @@ public class TestTunerController extends TunerController
*/
public void setSampleRate(int sampleRate) throws SourceException
{
mFrequencyController.setSampleRate(sampleRate);
mSampleGenerator.setSampleRate(sampleRate);
}
}