//
// test phase-locked loop
// _type : NCO type (e.g. LIQUID_NCO)
// _phase_offset : initial phase offset
// _freq_offset : initial frequency offset
// _pll_bandwidth : bandwidth of phase-locked loop
// _num_iterations : number of iterations to run
// _tol : error tolerance
void nco_crcf_pll_test(int _type,
float _phase_offset,
float _freq_offset,
float _pll_bandwidth,
unsigned int _num_iterations,
float _tol)
{
// objects
nco_crcf nco_tx = nco_crcf_create(_type);
nco_crcf nco_rx = nco_crcf_create(_type);
// initialize objects
nco_crcf_set_phase(nco_tx, _phase_offset);
nco_crcf_set_frequency(nco_tx, _freq_offset);
nco_crcf_pll_set_bandwidth(nco_rx, _pll_bandwidth);
// run loop
unsigned int i;
float phase_error;
float complex r, v;
for (i=0; i<_num_iterations; i++) {
// received complex signal
nco_crcf_cexpf(nco_tx,&r);
nco_crcf_cexpf(nco_rx,&v);
// error estimation
phase_error = cargf(r*conjf(v));
// update pll
nco_crcf_pll_step(nco_rx, phase_error);
// update nco objects
nco_crcf_step(nco_tx);
nco_crcf_step(nco_rx);
}
// ensure phase of oscillators is locked
float nco_tx_phase = nco_crcf_get_phase(nco_tx);
float nco_rx_phase = nco_crcf_get_phase(nco_rx);
CONTEND_DELTA(nco_tx_phase, nco_rx_phase, _tol);
// ensure frequency of oscillators is locked
float nco_tx_freq = nco_crcf_get_frequency(nco_tx);
float nco_rx_freq = nco_crcf_get_frequency(nco_rx);
CONTEND_DELTA(nco_tx_freq, nco_rx_freq, _tol);
// clean it up
nco_crcf_destroy(nco_tx);
nco_crcf_destroy(nco_rx);
}
SpectrumVisualProcessor::SpectrumVisualProcessor() : outputBuffers("SpectrumVisualProcessorBuffers") {
lastInputBandwidth = 0;
lastBandwidth = 0;
lastDataSize = 0;
resampler = nullptr;
resamplerRatio = 0;
fftInput = nullptr;
fftOutput = nullptr;
fftInData = nullptr;
fftLastData = nullptr;
fftPlan = nullptr;
is_view.store(false);
fftSize.store(0);
centerFreq.store(0);
bandwidth.store(0);
hideDC.store(false);
freqShifter = nco_crcf_create(LIQUID_NCO);
shiftFrequency = 0;
fft_ceil_ma = fft_ceil_maa = 100.0;
fft_floor_ma = fft_floor_maa = 0.0;
desiredInputSize.store(0);
fft_average_rate = 0.65f;
scaleFactor.store(1.0);
fftSizeChanged.store(false);
newFFTSize.store(0);
lastView = false;
peakHold.store(false);
peakReset.store(false);
}
void autotest_nco_crcf_mix_block_up()
{
// options
unsigned int buf_len = 4096;
float phase = 0.7123f;
float freq = 0; //0.1324f;
float tol = 1e-2f;
// create object
nco_crcf nco = nco_crcf_create(LIQUID_NCO);
nco_crcf_set_phase (nco, phase);
nco_crcf_set_frequency(nco, freq);
// generate signal
float complex buf_0[buf_len];
float complex buf_1[buf_len];
unsigned int i;
for (i=0; i<buf_len; i++)
buf_0[i] = cexpf(_Complex_I*2*M_PI*randf());
// mix signal
nco_crcf_mix_block_up(nco, buf_0, buf_1, buf_len);
// compare result to expected
float phi = phase;
for (i=0; i<buf_len; i++) {
float complex v = buf_0[i] * cexpf(_Complex_I*phi);
CONTEND_DELTA( crealf(buf_1[i]), crealf(v), tol);
CONTEND_DELTA( cimagf(buf_1[i]), cimagf(v), tol);
phi += freq;
}
// destroy object
nco_crcf_destroy(nco);
}
ModemKit *ModemFMStereo::buildKit(long long sampleRate, int audioSampleRate) {
ModemKitFMStereo *kit = new ModemKitFMStereo;
kit->audioResampleRatio = double(audioSampleRate) / double(sampleRate);
kit->sampleRate = sampleRate;
kit->audioSampleRate = audioSampleRate;
float As = 60.0f; // stop-band attenuation [dB]
kit->audioResampler = msresamp_rrrf_create(kit->audioResampleRatio, As);
kit->stereoResampler = msresamp_rrrf_create(kit->audioResampleRatio, As);
// Stereo filters / shifters
double firStereoCutoff = 16000.0 / double(audioSampleRate);
// filter transition
float ft = 1000.0f / double(audioSampleRate);
// fractional timing offset
float mu = 0.0f;
if (firStereoCutoff < 0) {
firStereoCutoff = 0;
}
if (firStereoCutoff > 0.5) {
firStereoCutoff = 0.5;
}
unsigned int h_len = estimate_req_filter_len(ft, As);
float *h = new float[h_len];
liquid_firdes_kaiser(h_len, firStereoCutoff, As, mu, h);
kit->firStereoLeft = firfilt_rrrf_create(h, h_len);
kit->firStereoRight = firfilt_rrrf_create(h, h_len);
// stereo pilot filter
float bw = float(sampleRate);
if (bw < 100000.0) {
bw = 100000.0;
}
unsigned int order = 5; // filter order
float f0 = ((float) 19000 / bw);
float fc = ((float) 19500 / bw);
float Ap = 1.0f;
kit->iirStereoPilot = iirfilt_crcf_create_prototype(LIQUID_IIRDES_CHEBY2, LIQUID_IIRDES_BANDPASS, LIQUID_IIRDES_SOS, order, fc, f0, Ap, As);
kit->firStereoR2C = firhilbf_create(5, 60.0f);
kit->firStereoC2R = firhilbf_create(5, 60.0f);
kit->stereoPilot = nco_crcf_create(LIQUID_VCO);
nco_crcf_reset(kit->stereoPilot);
nco_crcf_pll_set_bandwidth(kit->stereoPilot, 0.25f);
return kit;
}
int main (int argc, char ** argv) {
w=windowcf_create(SPECTRUM_FFT_LENGTH);
wchA = windowcf_create(TRACK_LENGTH);
wchB = windowcf_create(TRACK_LENGTH);
wchC = windowcf_create(TRACK_LENGTH);
wchA_filtered = windowcf_create(TRACK_LENGTH);
wchB_filtered = windowcf_create(TRACK_LENGTH);
wchC_filtered = windowcf_create(TRACK_LENGTH);
wmag_buffer = windowf_create(TRACK_LENGTH);
nco = nco_crcf_create(LIQUID_NCO);
std::cout << "hydromath daemon is beginning..." << std::endl;
std::cout << "NOTE: if this is symhydromath you must pass in a matfile" << std::endl;
std::cout << argv[1] << std::endl;
shm_init();
shm_getg(hydrophones_results_track, shm_results_track);
shm_getg(hydrophones_results_spectrum, shm_results_spectrum);
//shm_results_track.tracked_ping_count=0;
shm_results_track.tracked_ping_time=0;
if (argc > 1) {
udp_init(argv[1]);
}
else {
udp_init("");
}
//std::thread track_thread(direction_loop);
//
//std::thread spectrum_thread(spectrum_loop);
track_sample_idx = 0;
while (loop(&spt) == 0) {
shm_getg(hydrophones_settings, shm_settings);
for (int i = 0; i < 3*CHANNEL_DEPTH; i+=3) {
windowcf_push(w, std::complex<float>(spt.data[i+1],0)); //This uses channel B
windowcf_push(wchA, std::complex<float>(spt.data[i],0));
windowcf_push(wchB, std::complex<float>(spt.data[i+1],0));
windowcf_push(wchC, std::complex<float>(spt.data[i+2],0));
}
current_sample_count+=CHANNEL_DEPTH;
do_spectrum();
do_track();
}
printf("loop done %li =ci\n",current_sample_count/CHANNEL_DEPTH);
return 0;
}
quiet_beacon_encoder *quiet_beacon_encoder_create(float sample_rate, float target_freq, float gain) {
quiet_beacon_encoder *e = calloc(1, sizeof(quiet_beacon_encoder));
float omega = (target_freq/sample_rate) * 2 * M_PI;
e->nco = nco_crcf_create(LIQUID_NCO);
nco_crcf_set_phase(e->nco, 0.0f);
nco_crcf_set_frequency(e->nco, omega);
e->gain = gain;
return e;
}
//
// test nco block mixing
//
void autotest_nco_block_mixing()
{
// frequency, phase
float f = 0.1f;
float phi = M_PI;
// error tolerance (high for NCO)
float tol = 0.05f;
unsigned int i;
// number of samples
unsigned int num_samples = 1024;
// store samples
float complex * x = (float complex*)malloc(num_samples*sizeof(float complex));
float complex * y = (float complex*)malloc(num_samples*sizeof(float complex));
// generate complex sin/cos
for (i=0; i<num_samples; i++)
x[i] = cexpf(_Complex_I*(f*i + phi));
// initialize nco object
nco_crcf p = nco_crcf_create(LIQUID_NCO);
nco_crcf_set_frequency(p, f);
nco_crcf_set_phase(p, phi);
// mix signal back to zero phase (in pieces)
unsigned int num_remaining = num_samples;
i = 0;
while (num_remaining > 0) {
unsigned int n = 7 < num_remaining ? 7 : num_remaining;
nco_crcf_mix_block_down(p, &x[i], &y[i], n);
i += n;
num_remaining -= n;
}
// assert mixer output is correct
for (i=0; i<num_samples; i++) {
CONTEND_DELTA( crealf(y[i]), 1.0f, tol );
CONTEND_DELTA( cimagf(y[i]), 0.0f, tol );
}
// free those buffers
free(x);
free(y);
// destroy NCO object
nco_crcf_destroy(p);
}
// create WLAN framing synchronizer object
// _callback : user-defined callback function
// _userdata : user-defined data structure
wlanframesync wlanframesync_create(wlanframesync_callback _callback,
void * _userdata)
{
// allocate main object memory
wlanframesync q = (wlanframesync) malloc(sizeof(struct wlanframesync_s));
// set callback data
q->callback = _callback;
q->userdata = _userdata;
// create transform object
q->X = (float complex*) malloc(64*sizeof(float complex));
q->x = (float complex*) malloc(64*sizeof(float complex));
q->fft = FFT_CREATE_PLAN(64, q->x, q->X, FFT_DIR_FORWARD, FFT_METHOD);
// create input buffer the length of the transform
q->input_buffer = windowcf_create(80);
// synchronizer objects
q->nco_rx = nco_crcf_create(LIQUID_VCO);
q->ms_pilot = wlan_lfsr_create(7, 0x91, 0x7f);
q->mod_scheme = WLAN_MODEM_BPSK;
// set initial properties
q->rate = WLANFRAME_RATE_6;
q->length = 100;
q->seed = 0x5d;
// allocate memory for encoded message
q->enc_msg_len = wlan_packet_compute_enc_msg_len(q->rate, q->length);
q->msg_enc = (unsigned char*) malloc(q->enc_msg_len*sizeof(unsigned char));
// allocate memory for decoded message
q->dec_msg_len = 1;
q->msg_dec = (unsigned char*) malloc(q->dec_msg_len*sizeof(unsigned char));
// reset object
wlanframesync_reset(q);
#if DEBUG_WLANFRAMESYNC
// debugging structures
q->debug_enabled = 0;
q->agc_rx = NULL;
q->debug_x = NULL;
q->debug_rssi = NULL;
q->debug_framesyms = NULL;
#endif
// return object
return q;
}
DemodulatorPreThread::DemodulatorPreThread() : IOThread(), iqResampler(NULL), iqResampleRatio(1), audioResampler(NULL), stereoResampler(NULL), audioResampleRatio(1), firStereoLeft(NULL), firStereoRight(NULL), iirStereoPilot(NULL), iqInputQueue(NULL), iqOutputQueue(NULL), threadQueueNotify(NULL), commandQueue(NULL)
{
initialized.store(false);
freqShifter = nco_crcf_create(LIQUID_VCO);
shiftFrequency = 0;
workerQueue = new DemodulatorThreadWorkerCommandQueue;
workerResults = new DemodulatorThreadWorkerResultQueue;
workerThread = new DemodulatorWorkerThread();
workerThread->setInputQueue("WorkerCommandQueue",workerQueue);
workerThread->setOutputQueue("WorkerResultQueue",workerResults);
}
DemodulatorPreThread::DemodulatorPreThread(DemodulatorThreadInputQueue* iqInputQueue, DemodulatorThreadPostInputQueue* iqOutputQueue,
DemodulatorThreadControlCommandQueue *threadQueueControl, DemodulatorThreadCommandQueue* threadQueueNotify) :
iqInputQueue(iqInputQueue), iqOutputQueue(iqOutputQueue), terminated(false), initialized(false), audioResampler(NULL), stereoResampler(NULL), iqResampleRatio(
1), audioResampleRatio(1), firStereoRight(NULL), firStereoLeft(NULL), iirStereoPilot(NULL), iqResampler(NULL), commandQueue(NULL), threadQueueNotify(threadQueueNotify), threadQueueControl(
threadQueueControl) {
freqShifter = nco_crcf_create(LIQUID_VCO);
shiftFrequency = 0;
workerQueue = new DemodulatorThreadWorkerCommandQueue;
workerResults = new DemodulatorThreadWorkerResultQueue;
workerThread = new DemodulatorWorkerThread(workerQueue, workerResults);
t_Worker = new std::thread(&DemodulatorWorkerThread::threadMain, workerThread);
}
//
// test floating point precision nco
//
void autotest_nco_basic() {
nco_crcf p = nco_crcf_create(LIQUID_NCO);
unsigned int i; // loop index
float s, c; // sine/cosine result
float tol=1e-4f; // error tolerance
float f=0.0f; // frequency to test
nco_crcf_set_phase( p, 0.0f);
CONTEND_DELTA( nco_crcf_cos(p), 1.0f, tol );
CONTEND_DELTA( nco_crcf_sin(p), 0.0f, tol );
nco_crcf_sincos(p, &s, &c);
CONTEND_DELTA( s, 0.0f, tol );
CONTEND_DELTA( c, 1.0f, tol );
nco_crcf_set_phase(p, M_PI/2);
CONTEND_DELTA( nco_crcf_cos(p), 0.0f, tol );
CONTEND_DELTA( nco_crcf_sin(p), 1.0f, tol );
nco_crcf_sincos(p, &s, &c);
CONTEND_DELTA( s, 1.0f, tol );
CONTEND_DELTA( c, 0.0f, tol );
// cycle through one full period in 64 steps
nco_crcf_set_phase(p, 0.0f);
f = 2.0f * M_PI / 64.0f;
nco_crcf_set_frequency(p, f);
for (i=0; i<128; i++) {
nco_crcf_sincos(p, &s, &c);
CONTEND_DELTA( s, sinf(i*f), tol );
CONTEND_DELTA( c, cosf(i*f), tol );
nco_crcf_step(p);
}
// double frequency: cycle through one full period in 32 steps
nco_crcf_set_phase(p, 0.0f);
f = 2.0f * M_PI / 32.0f;
nco_crcf_set_frequency(p, f);
for (i=0; i<128; i++) {
nco_crcf_sincos(p, &s, &c);
CONTEND_DELTA( s, sinf(i*f), tol );
CONTEND_DELTA( c, cosf(i*f), tol );
nco_crcf_step(p);
}
// destroy NCO object
nco_crcf_destroy(p);
}
SpectrumVisualProcessor::SpectrumVisualProcessor() : lastInputBandwidth(0), lastBandwidth(0), fftwInput(NULL), fftwOutput(NULL), fftInData(NULL), fftLastData(NULL), lastDataSize(0), fftw_plan(NULL), resampler(NULL), resamplerRatio(0) {
is_view.store(false);
fftSize.store(0);
centerFreq.store(0);
bandwidth.store(0);
hideDC.store(false);
freqShifter = nco_crcf_create(LIQUID_NCO);
shiftFrequency = 0;
fft_ceil_ma = fft_ceil_maa = 100.0;
fft_floor_ma = fft_floor_maa = 0.0;
desiredInputSize.store(0);
fft_average_rate = 0.65;
scaleFactor.store(1.0);
}
void PfbSynthesizerComponent::initialize()
{
// design custom filterbank channelizer
unsigned int m = 7; // prototype filter delay
float As = 60.0f; // stop-band attenuation
channelizer = firpfbch_crcf_create_kaiser(LIQUID_SYNTHESIZER, nChans_x, m, As);
// create NCO to center spectrum
float offset = -0.5f*(float)(nChans_x-1) / (float)nChans_x * 2 * M_PI;
nco = nco_crcf_create(LIQUID_VCO);
nco_crcf_set_frequency(nco, offset);
//Set up our input and output buffers
buf.resize(nChans_x);
bufIt = buf.begin();
outBuf.resize(nChans_x);
}
int main() {
// create the NCO object
nco_crcf p = nco_crcf_create(LIQUID_NCO);
nco_crcf_set_phase(p, 0.0f);
nco_crcf_set_frequency(p, M_PI/10);
unsigned int i;
float s, c;
for (i=0; i<11; i++) {
nco_crcf_sincos(p, &s, &c);
printf(" %3u : %8.5f + j %8.5f\n",
i, c, s);
nco_crcf_step(p);
}
// clean up allocated memory
nco_crcf_destroy(p);
printf("done.\n");
return 0;
}
// autotest helper function
// _theta : input phase
// _cos : expected output: cos(_theta)
// _sin : expected output: sin(_theta)
// _type : NCO type (e.g. LIQUID_NCO)
// _tol : error tolerance
void nco_crcf_phase_test(float _theta,
float _cos,
float _sin,
int _type,
float _tol)
{
// create object
nco_crcf nco = nco_crcf_create(_type);
// set phase
nco_crcf_set_phase(nco, _theta);
// compute cosine and sine outputs
float c = nco_crcf_cos(nco);
float s = nco_crcf_sin(nco);
// run tests
CONTEND_DELTA( c, _cos, _tol );
CONTEND_DELTA( s, _sin, _tol );
// destroy object
nco_crcf_destroy(nco);
}
// create ampmodem object
// _m : modulation index
// _fc : carrier frequency
// _type : AM type (e.g. LIQUID_AMPMODEM_DSB)
// _suppressed_carrier : carrier suppression flag
ampmodem ampmodem_create(float _m,
float _fc,
liquid_ampmodem_type _type,
int _suppressed_carrier)
{
ampmodem q = (ampmodem) malloc(sizeof(struct ampmodem_s));
q->type = _type;
q->m = _m;
q->fc = _fc;
q->suppressed_carrier = (_suppressed_carrier == 0) ? 0 : 1;
// create nco, pll objects
q->oscillator = nco_crcf_create(LIQUID_NCO);
nco_crcf_set_frequency(q->oscillator, 2*M_PI*q->fc);
nco_crcf_pll_set_bandwidth(q->oscillator,0.05f);
// suppressed carrier
q->ssb_alpha = 0.01f;
q->ssb_q_hat = 0.0f;
// single side-band
q->hilbert = firhilbf_create(9, 60.0f);
// double side-band
ampmodem_reset(q);
// debugging
#if DEBUG_AMPMODEM
q->debug_x = windowcf_create(DEBUG_AMPMODEM_BUFFER_LEN);
q->debug_phase_error = windowf_create(DEBUG_AMPMODEM_BUFFER_LEN);
q->debug_freq_error = windowf_create(DEBUG_AMPMODEM_BUFFER_LEN);
#endif
return q;
}
demodulator *demodulator_create(const demodulator_options *opt) {
if (!opt) {
return NULL;
}
demodulator *d = malloc(sizeof(demodulator));
d->opt = *opt;
d->nco = nco_crcf_create(LIQUID_NCO);
nco_crcf_set_phase(d->nco, 0.0f);
nco_crcf_set_frequency(d->nco, opt->center_rads);
if (opt->samples_per_symbol > 1) {
d->decim = firdecim_crcf_create_prototype(opt->shape, opt->samples_per_symbol,
opt->symbol_delay, opt->excess_bw, 0);
} else {
d->opt.samples_per_symbol = 1;
d->opt.symbol_delay = 0;
d->decim = NULL;
}
return d;
}
//
// test nco mixing
//
void autotest_nco_mixing() {
// frequency, phase
float f = 0.1f;
float phi = M_PI;
// error tolerance (high for NCO)
float tol = 0.05f;
// initialize nco object
nco_crcf p = nco_crcf_create(LIQUID_NCO);
nco_crcf_set_frequency(p, f);
nco_crcf_set_phase(p, phi);
unsigned int i;
float nco_i, nco_q;
for (i=0; i<64; i++) {
// generate sin/cos
nco_crcf_sincos(p, &nco_q, &nco_i);
// mix back to zero phase
complex float nco_cplx_in = nco_i + _Complex_I*nco_q;
complex float nco_cplx_out;
nco_crcf_mix_down(p, nco_cplx_in, &nco_cplx_out);
// assert mixer output is correct
CONTEND_DELTA(crealf(nco_cplx_out), 1.0f, tol);
CONTEND_DELTA(cimagf(nco_cplx_out), 0.0f, tol);
//printf("%3u : %12.8f + j*%12.8f\n", i, crealf(nco_cplx_out), cimagf(nco_cplx_out));
// step nco
nco_crcf_step(p);
}
// destroy NCO object
nco_crcf_destroy(p);
}
// create fskmod object (frequency modulator)
// _m : bits per symbol, _m > 0
// _k : samples/symbol, _k >= 2^_m
// _bandwidth : total signal bandwidth, (0,0.5)
fskmod fskmod_create(unsigned int _m,
unsigned int _k,
float _bandwidth)
{
// validate input
if (_m == 0) {
fprintf(stderr,"error: fskmod_create(), bits/symbol must be greater than 0\n");
exit(1);
} else if (_k < 2 || _k > 2048) {
fprintf(stderr,"error: fskmod_create(), samples/symbol must be in [2^_m, 2048]\n");
exit(1);
} else if (_bandwidth <= 0.0f || _bandwidth >= 0.5f) {
fprintf(stderr,"error: fskmod_create(), bandwidth must be in (0,0.5)\n");
exit(1);
}
// create main object memory
fskmod q = (fskmod) malloc(sizeof(struct fskmod_s));
// set basic internal properties
q->m = _m; // bits per symbol
q->k = _k; // samples per symbol
q->bandwidth = _bandwidth; // signal bandwidth
// derived values
q->M = 1 << q->m; // constellation size
q->M2 = 0.5f*(float)(q->M-1); // (M-1)/2
q->oscillator = nco_crcf_create(LIQUID_VCO);
// reset modem object
fskmod_reset(q);
// return main object
return q;
}
int main() {
// spectral periodogram options
unsigned int nfft=256; // spectral periodogram FFT size
unsigned int num_samples = 2001; // number of samples
float beta = 10.0f; // Kaiser-Bessel window parameter
// allocate memory for data arrays
float complex x[num_samples]; // input signal
float complex X[nfft]; // output spectrum
float psd[nfft]; // power spectral density
unsigned int ramp = num_samples/20 < 10 ? 10 : num_samples/20;
// create spectral periodogram
unsigned int window_size = nfft/2; // spgram window size
unsigned int delay = nfft/8; // samples between transforms
spgram q = spgram_create_kaiser(nfft, window_size, beta);
unsigned int i;
// generate signal
nco_crcf nco = nco_crcf_create(LIQUID_VCO);
for (i=0; i<num_samples; i++) {
nco_crcf_set_frequency(nco, 0.1f*(1.2f+sinf(0.007f*i)) );
nco_crcf_cexpf(nco, &x[i]);
nco_crcf_step(nco);
}
nco_crcf_destroy(nco);
// add soft ramping functions
for (i=0; i<ramp; i++) {
x[i] *= 0.5f - 0.5f*cosf(M_PI*(float)i / (float)ramp);
x[num_samples-ramp+i-1] *= 0.5f - 0.5f*cosf(M_PI*(float)(ramp-i-1) / (float)ramp);
}
//
// export output file(s)
//
FILE * fid;
//
// export time-doman data
//
fid = fopen(OUTPUT_FILENAME_TIME,"w");
fprintf(fid,"# %s : auto-generated file\n", OUTPUT_FILENAME_TIME);
for (i=0; i<num_samples; i++)
fprintf(fid,"%12u %12.8f %12.8f\n", i, crealf(x[i]), cimagf(x[i]));
fclose(fid);
printf("results written to %s.\n", OUTPUT_FILENAME_TIME);
//
// export freq-doman data
//
fid = fopen(OUTPUT_FILENAME_FREQ,"w");
fprintf(fid,"# %s : auto-generated file\n", OUTPUT_FILENAME_FREQ);
unsigned int t=0;
for (i=0; i<num_samples; i++) {
// push sample into periodogram
spgram_push(q, &x[i], 1);
if ( ((i+1)%delay)==0 ) {
// compute spectral periodogram output
spgram_execute(q, X);
unsigned int k;
// compute PSD and FFT shift
for (k=0; k<nfft; k++)
psd[k] = 20*log10f( cabsf(X[(k+nfft/2)%nfft]) );
#if 1
for (k=0; k<nfft; k++)
fprintf(fid,"%12u %12.8f %12.8f\n", t, (float)k/(float)nfft - 0.5f, psd[k]);
#else
for (k=0; k<nfft; k++)
fprintf(fid,"%12.8f ", psd[k]);
#endif
fprintf(fid,"\n");
t++;
}
}
// destroy spectral periodogram object
spgram_destroy(q);
fclose(fid);
printf("results written to %s.\n", OUTPUT_FILENAME_FREQ);
printf("done.\n");
return 0;
}
ofdmoqamframe64sync ofdmoqamframe64sync_create(unsigned int _m,
float _beta,
ofdmoqamframe64sync_callback _callback,
void * _userdata)
{
ofdmoqamframe64sync q = (ofdmoqamframe64sync) malloc(sizeof(struct ofdmoqamframe64sync_s));
q->num_subcarriers = 64;
// validate input
if (_m < 1) {
fprintf(stderr,"error: ofdmoqamframe64sync_create(), filter delay must be > 0\n");
exit(1);
} else if (_beta < 0.0f) {
fprintf(stderr,"error: ofdmoqamframe64sync_create(), filter excess bandwidth must be > 0\n");
exit(1);
}
q->m = _m;
q->beta = _beta;
// synchronizer parameters
q->rxx_thresh = 0.60f; // auto-correlation threshold
q->rxy_thresh = 0.60f; // cross-correlation threshold
q->zeta = 64.0f/sqrtf(52.0f); // scaling factor
// create analysis filter banks
q->ca0 = firpfbch_create(q->num_subcarriers, q->m, q->beta, 0.0f /*dt*/,FIRPFBCH_ROOTNYQUIST,0/*gradient*/);
q->ca1 = firpfbch_create(q->num_subcarriers, q->m, q->beta, 0.0f /*dt*/,FIRPFBCH_ROOTNYQUIST,0/*gradient*/);
q->X0 = (float complex*) malloc((q->num_subcarriers)*sizeof(float complex));
q->X1 = (float complex*) malloc((q->num_subcarriers)*sizeof(float complex));
q->Y0 = (float complex*) malloc((q->num_subcarriers)*sizeof(float complex));
q->Y1 = (float complex*) malloc((q->num_subcarriers)*sizeof(float complex));
// allocate memory for PLCP arrays
q->S0 = (float complex*) malloc((q->num_subcarriers)*sizeof(float complex));
q->S1 = (float complex*) malloc((q->num_subcarriers)*sizeof(float complex));
q->S2 = (float complex*) malloc((q->num_subcarriers)*sizeof(float complex));
ofdmoqamframe64_init_S0(q->S0);
ofdmoqamframe64_init_S1(q->S1);
ofdmoqamframe64_init_S2(q->S2);
unsigned int i;
for (i=0; i<q->num_subcarriers; i++) {
q->S0[i] *= q->zeta;
q->S1[i] *= q->zeta;
q->S2[i] *= q->zeta;
}
q->S1a = (float complex*) malloc((q->num_subcarriers)*sizeof(float complex));
q->S1b = (float complex*) malloc((q->num_subcarriers)*sizeof(float complex));
// set pilot sequence
q->ms_pilot = msequence_create_default(8);
q->x_phase[0] = -21.0f;
q->x_phase[1] = -7.0f;
q->x_phase[2] = 7.0f;
q->x_phase[3] = 21.0f;
// create NCO for pilots
q->nco_pilot = nco_crcf_create(LIQUID_VCO);
q->pll_pilot = pll_create();
pll_set_bandwidth(q->pll_pilot,0.01f);
pll_set_damping_factor(q->pll_pilot,4.0f);
// create agc | signal detection object
q->sigdet = agc_crcf_create();
agc_crcf_set_bandwidth(q->sigdet,0.1f);
// create NCO for CFO compensation
q->nco_rx = nco_crcf_create(LIQUID_VCO);
// create auto-correlator objects
q->autocorr_length = OFDMOQAMFRAME64SYNC_AUTOCORR_LEN;
q->autocorr_delay = q->num_subcarriers / 4;
q->autocorr = autocorr_cccf_create(q->autocorr_length, q->autocorr_delay);
// create cross-correlator object
q->hxy = (float complex*) malloc((q->num_subcarriers)*sizeof(float complex));
ofdmoqam cs = ofdmoqam_create(q->num_subcarriers,q->m,q->beta,
0.0f, // dt
OFDMOQAM_SYNTHESIZER,
0); // gradient
for (i=0; i<2*(q->m); i++)
ofdmoqam_execute(cs,q->S1,q->hxy);
// time reverse, complex conjugate (same as fftshift for
// this particular sequence)
memmove(q->X0, q->hxy, 64*sizeof(float complex));
for (i=0; i<64; i++)
q->hxy[i] = conjf(q->X0[64-i-1]);
// fftshift
//fft_shift(q->hxy,64);
q->crosscorr = firfilt_cccf_create(q->hxy, q->num_subcarriers);
ofdmoqam_destroy(cs);
// input buffer
q->input_buffer = windowcf_create((q->num_subcarriers));
// gain
q->g = 1.0f;
q->G0 = (float complex*) malloc((q->num_subcarriers)*sizeof(float complex));
q->G1 = (float complex*) malloc((q->num_subcarriers)*sizeof(float complex));
q->G = (float complex*) malloc((q->num_subcarriers)*sizeof(float complex));
q->data = (float complex*) malloc((q->num_subcarriers)*sizeof(float complex));
// reset object
ofdmoqamframe64sync_reset(q);
#if DEBUG_OFDMOQAMFRAME64SYNC
q->debug_x = windowcf_create(DEBUG_OFDMOQAMFRAME64SYNC_BUFFER_LEN);
q->debug_rxx= windowcf_create(DEBUG_OFDMOQAMFRAME64SYNC_BUFFER_LEN);
q->debug_rxy= windowcf_create(DEBUG_OFDMOQAMFRAME64SYNC_BUFFER_LEN);
q->debug_framesyms= windowcf_create(DEBUG_OFDMOQAMFRAME64SYNC_BUFFER_LEN);
q->debug_pilotphase= windowf_create(DEBUG_OFDMOQAMFRAME64SYNC_BUFFER_LEN);
q->debug_pilotphase_hat= windowf_create(DEBUG_OFDMOQAMFRAME64SYNC_BUFFER_LEN);
q->debug_rssi= windowf_create(DEBUG_OFDMOQAMFRAME64SYNC_BUFFER_LEN);
#endif
q->callback = _callback;
q->userdata = _userdata;
return q;
}
int main() {
// options
unsigned int num_channels=8; // number of channels
unsigned int m=2; // filter delay
float As=-60; // stop-band attenuation
unsigned int num_frames=25; // number of frames
// create objects
firpfbch_crcf c = firpfbch_crcf_create_kaiser(LIQUID_ANALYZER, num_channels, m, As);
//firpfbch_crcf_print(c);
FILE*fid = fopen(OUTPUT_FILENAME,"w");
fprintf(fid,"%% %s: auto-generated file\n\n", OUTPUT_FILENAME);
fprintf(fid,"clear all;\nclose all;\n\n");
fprintf(fid,"num_channels=%u;\n", num_channels);
fprintf(fid,"num_frames=%u;\n", num_frames);
fprintf(fid,"x = zeros(1,%u);\n", num_channels * num_frames);
fprintf(fid,"y = zeros(%u,%u);\n", num_channels, num_frames);
unsigned int i, j, n=0;
float complex x[num_channels]; // time-domain input
float complex y[num_channels]; // channelized output
// create nco: sweeps entire range of frequencies over the evaluation interval
nco_crcf nco_tx = nco_crcf_create(LIQUID_VCO);
nco_crcf_set_frequency(nco_tx, 0.0f);
float df = 2*M_PI/(num_channels*num_frames);
printf("fr/ch:");
for (j=0; j<num_channels; j++) printf("%3u",j);
printf("\n");
for (i=0; i<num_frames; i++) {
// generate frame of data
for (j=0; j<num_channels; j++) {
nco_crcf_cexpf(nco_tx, &x[j]);
nco_crcf_adjust_frequency(nco_tx, df);
nco_crcf_step(nco_tx);
}
// execute analysis filter bank
firpfbch_crcf_analyzer_execute(c, x, y);
printf("%4u : ", i);
for (j=0; j<num_channels; j++) {
if (cabsf(y[j]) > num_channels / 4)
printf(" x ");
else
printf(" . ");
}
printf("\n");
// write output to file
for (j=0; j<num_channels; j++) {
// frequency data
fprintf(fid,"y(%4u,%4u) = %12.4e + j*%12.4e;\n", j+1, i+1, crealf(y[j]), cimagf(y[j]));
// time data
fprintf(fid,"x(%4u) = %12.4e + j*%12.4e;\n", n+1, crealf(x[j]), cimag(x[j]));
n++;
}
}
// destroy objects
nco_crcf_destroy(nco_tx);
firpfbch_crcf_destroy(c);
// plot results
fprintf(fid,"\n\n");
fprintf(fid,"figure;\n");
fprintf(fid,"subplot(2,1,1);\n");
fprintf(fid," plot(1:length(x),real(x),1:length(x),imag(x));\n");
fprintf(fid," xlabel('time');\n");
fprintf(fid," ylabel('signal');\n");
fprintf(fid,"subplot(2,1,2);\n");
fprintf(fid," plot(20*log10(abs(y.')/num_channels));\n");
fprintf(fid," xlabel('time (decimated)');\n");
fprintf(fid," ylabel('channelized energy [dB]');\n");
fprintf(fid,"n=min(num_channels,8);\n");
fprintf(fid,"figure;\n");
fprintf(fid,"for i=1:n\n");
fprintf(fid," subplot(n,1,i);\n");
fprintf(fid," plot(1:num_frames,real(y(i,:)),1:num_frames,imag(y(i,:)));\n");
fprintf(fid," axis off;\n");
fprintf(fid," ylabel(num2str(i));\n");
fprintf(fid,"end;\n");
fclose(fid);
printf("results written to %s\n", OUTPUT_FILENAME);
printf("done.\n");
return 0;
}
int main(int argc, char*argv[]) {
srand( time(NULL) );
// parameters
float phase_offset = M_PI/10;
float frequency_offset = 0.001f;
float SNRdB = 30.0f;
float pll_bandwidth = 0.02f;
modulation_scheme ms = LIQUID_MODEM_QPSK;
unsigned int n=256; // number of iterations
int dopt;
while ((dopt = getopt(argc,argv,"uhs:b:n:P:F:m:")) != EOF) {
switch (dopt) {
case 'u':
case 'h': usage(); return 0;
case 's': SNRdB = atof(optarg); break;
case 'b': pll_bandwidth = atof(optarg); break;
case 'n': n = atoi(optarg); break;
case 'P': phase_offset = atof(optarg); break;
case 'F': frequency_offset= atof(optarg); break;
case 'm':
ms = liquid_getopt_str2mod(optarg);
if (ms == LIQUID_MODEM_UNKNOWN) {
fprintf(stderr,"error: %s, unknown/unsupported modulation scheme \"%s\"\n", argv[0], optarg);
return 1;
}
break;
default:
exit(1);
}
}
unsigned int d=n/32; // print every "d" lines
FILE * fid = fopen(OUTPUT_FILENAME,"w");
fprintf(fid, "%% %s : auto-generated file\n", OUTPUT_FILENAME);
fprintf(fid, "clear all;\n");
fprintf(fid, "phi=zeros(1,%u);\n",n);
fprintf(fid, "r=zeros(1,%u);\n",n);
// objects
nco_crcf nco_tx = nco_crcf_create(LIQUID_VCO);
nco_crcf nco_rx = nco_crcf_create(LIQUID_VCO);
modem mod = modem_create(ms);
modem demod = modem_create(ms);
unsigned int bps = modem_get_bps(mod);
// initialize objects
nco_crcf_set_phase(nco_tx, phase_offset);
nco_crcf_set_frequency(nco_tx, frequency_offset);
nco_crcf_pll_set_bandwidth(nco_rx, pll_bandwidth);
float noise_power = powf(10.0f, -SNRdB/20.0f);
// print parameters
printf("PLL example :\n");
printf("modem : %u-%s\n", 1<<bps, modulation_types[ms].name);
printf("frequency offset: %6.3f, phase offset: %6.3f, SNR: %6.2fdB, pll b/w: %6.3f\n",
frequency_offset, phase_offset, SNRdB, pll_bandwidth);
// run loop
unsigned int i, M=1<<bps, sym_in, sym_out, num_errors=0;
float phase_error;
float complex x, r, v, noise;
for (i=0; i<n; i++) {
// generate random symbol
sym_in = rand() % M;
// modulate
modem_modulate(mod, sym_in, &x);
// channel
//r = nco_crcf_cexpf(nco_tx);
nco_crcf_mix_up(nco_tx, x, &r);
// add complex white noise
crandnf(&noise);
r += noise * noise_power;
//
//v = nco_crcf_cexpf(nco_rx);
nco_crcf_mix_down(nco_rx, r, &v);
// demodulate
modem_demodulate(demod, v, &sym_out);
num_errors += count_bit_errors(sym_in, sym_out);
// error estimation
//phase_error = cargf(r*conjf(v));
phase_error = modem_get_demodulator_phase_error(demod);
// perfect error estimation
//phase_error = nco_tx->theta - nco_rx->theta;
// print every line in a format that octave can read
fprintf(fid, "phi(%u) = %10.6E;\n", i+1, phase_error);
fprintf(fid, "r(%u) = %10.6E + j*%10.6E;\n",
i+1, crealf(v), cimagf(v));
if ((i+1)%d == 0 || i==n-1) {
printf(" %4u: e_hat : %6.3f, phase error : %6.3f, freq error : %6.3f\n",
i+1, // iteration
phase_error, // estimated phase error
nco_crcf_get_phase(nco_tx) - nco_crcf_get_phase(nco_rx),// true phase error
nco_crcf_get_frequency(nco_tx) - nco_crcf_get_frequency(nco_rx)// true frequency error
);
}
// update tx nco object
nco_crcf_step(nco_tx);
// update pll
nco_crcf_pll_step(nco_rx, phase_error);
// update rx nco object
nco_crcf_step(nco_rx);
}
fprintf(fid, "figure;\n");
fprintf(fid, "plot(1:length(phi),phi,'LineWidth',2,'Color',[0 0.25 0.5]);\n");
fprintf(fid, "xlabel('Symbol Index');\n");
fprintf(fid, "ylabel('Phase Error [radians]');\n");
fprintf(fid, "grid on;\n");
fprintf(fid, "t0 = round(0.25*length(r));\n");
fprintf(fid, "figure;\n");
fprintf(fid, "plot(r(1:t0),'x','Color',[0.6 0.6 0.6],r(t0:end),'x','Color',[0 0.25 0.5]);\n");
fprintf(fid, "grid on;\n");
fprintf(fid, "axis([-1.5 1.5 -1.5 1.5]);\n");
fprintf(fid, "axis('square');\n");
fprintf(fid, "xlabel('In-Phase');\n");
fprintf(fid, "ylabel('Quadrature');\n");
fprintf(fid, "legend(['first 25%%'],['last 75%%'],1);\n");
fclose(fid);
printf("results written to %s.\n",OUTPUT_FILENAME);
nco_crcf_destroy(nco_tx);
nco_crcf_destroy(nco_rx);
modem_destroy(mod);
modem_destroy(demod);
printf("bit errors: %u / %u\n", num_errors, bps*n);
printf("done.\n");
return 0;
}
int main()
{
// spectral periodogram options
unsigned int nfft = 1200; // spectral periodogram FFT size
unsigned int num_samples = 64000; // number of samples
float fc = 0.20f; // carrier (relative to sampling rate)
// create objects
iirfilt_crcf filter_tx = iirfilt_crcf_create_lowpass(15, 0.05);
nco_crcf mixer_tx = nco_crcf_create(LIQUID_VCO);
nco_crcf mixer_rx = nco_crcf_create(LIQUID_VCO);
iirfilt_crcf filter_rx = iirfilt_crcf_create_lowpass(7, 0.2);
// set carrier frequencies
nco_crcf_set_frequency(mixer_tx, fc * 2*M_PI);
nco_crcf_set_frequency(mixer_rx, fc * 2*M_PI);
// create objects for measuring power spectral density
spgramcf spgram_tx = spgramcf_create_default(nfft);
spgramf spgram_dac = spgramf_create_default(nfft);
spgramcf spgram_rx = spgramcf_create_default(nfft);
// run through loop one step at a time
unsigned int i;
for (i=0; i<num_samples; i++) {
// STEP 1: generate input signal (filtered noise with offset tone)
float complex v1 = (randnf() + randnf()*_Complex_I) + 3.0f*cexpf(-_Complex_I*0.2f*i);
iirfilt_crcf_execute(filter_tx, v1, &v1);
// save spectrum
spgramcf_push(spgram_tx, v1);
// STEP 2: mix signal up and save real part (DAC output)
nco_crcf_mix_up(mixer_tx, v1, &v1);
float v2 = crealf(v1);
nco_crcf_step(mixer_tx);
// save spectrum
spgramf_push(spgram_dac, v2);
// STEP 3: mix signal down and filter off image
float complex v3;
nco_crcf_mix_down(mixer_rx, v2, &v3);
iirfilt_crcf_execute(filter_rx, v3, &v3);
nco_crcf_step(mixer_rx);
// save spectrum
spgramcf_push(spgram_rx, v3);
}
// compute power spectral density output
float psd_tx [nfft];
float psd_dac [nfft];
float psd_rx [nfft];
spgramcf_get_psd(spgram_tx, psd_tx);
spgramf_get_psd( spgram_dac, psd_dac);
spgramcf_get_psd(spgram_rx, psd_rx);
// destroy objects
spgramcf_destroy(spgram_tx);
spgramf_destroy(spgram_dac);
spgramcf_destroy(spgram_rx);
iirfilt_crcf_destroy(filter_tx);
nco_crcf_destroy(mixer_tx);
nco_crcf_destroy(mixer_rx);
iirfilt_crcf_destroy(filter_rx);
//
// export output file
//
FILE * fid = fopen(OUTPUT_FILENAME,"w");
fprintf(fid,"%% %s : auto-generated file\n", OUTPUT_FILENAME);
fprintf(fid,"clear all;\n");
fprintf(fid,"close all;\n\n");
fprintf(fid,"nfft = %u;\n", nfft);
fprintf(fid,"f = [0:(nfft-1)]/nfft - 0.5;\n");
fprintf(fid,"psd_tx = zeros(1,nfft);\n");
fprintf(fid,"psd_dac= zeros(1,nfft);\n");
fprintf(fid,"psd_rx = zeros(1,nfft);\n");
for (i=0; i<nfft; i++) {
fprintf(fid,"psd_tx (%6u) = %12.4e;\n", i+1, psd_tx [i]);
fprintf(fid,"psd_dac(%6u) = %12.4e;\n", i+1, psd_dac[i]);
fprintf(fid,"psd_rx (%6u) = %12.4e;\n", i+1, psd_rx [i]);
}
fprintf(fid,"figure;\n");
fprintf(fid,"hold on;\n");
fprintf(fid," plot(f, psd_tx, '-', 'LineWidth',1.5,'Color',[0.7 0.7 0.7]);\n");
fprintf(fid," plot(f, psd_dac, '-', 'LineWidth',1.5,'Color',[0.0 0.5 0.3]);\n");
fprintf(fid," plot(f, psd_rx, '-', 'LineWidth',1.5,'Color',[0.0 0.3 0.5]);\n");
fprintf(fid,"hold off;\n");
fprintf(fid,"xlabel('Normalized Frequency [f/F_s]');\n");
fprintf(fid,"ylabel('Power Spectral Density [dB]');\n");
fprintf(fid,"grid on;\n");
fprintf(fid,"axis([-0.5 0.5 -100 60]);\n");
fprintf(fid,"legend('transmit (complex)','DAC output (real)','receive (complex)','location','northeast');\n");
fclose(fid);
printf("results written to %s.\n", OUTPUT_FILENAME);
printf("done.\n");
return 0;
}
int main(int argc, char*argv[])
{
srand(time(NULL));
// options
unsigned int M = 64; // number of subcarriers
unsigned int cp_len = 16; // cyclic prefix length
unsigned int taper_len = 4; // taper length
unsigned int payload_len = 120; // length of payload (bytes)
modulation_scheme ms = LIQUID_MODEM_QPSK;
fec_scheme fec0 = LIQUID_FEC_NONE;
fec_scheme fec1 = LIQUID_FEC_HAMMING128;
crc_scheme check = LIQUID_CRC_32;
float noise_floor = -30.0f; // noise floor [dB]
float SNRdB = 20.0f; // signal-to-noise ratio [dB]
float dphi = 0.02f; // carrier frequency offset
int debug_enabled = 0; // enable debugging?
// get options
int dopt;
while((dopt = getopt(argc,argv,"uhds:F:M:C:n:m:v:c:k:")) != EOF){
switch (dopt) {
case 'u':
case 'h': usage(); return 0;
case 'd': debug_enabled = 1; break;
case 's': SNRdB = atof(optarg); break;
case 'F': dphi = atof(optarg); break;
case 'M': M = atoi(optarg); break;
case 'C': cp_len = atoi(optarg); break;
case 'n': payload_len = atol(optarg); break;
case 'm':
ms = liquid_getopt_str2mod(optarg);
if (ms == LIQUID_MODEM_UNKNOWN) {
fprintf(stderr,"error: %s, unknown/unsupported mod. scheme: %s\n", argv[0], optarg);
exit(-1);
}
break;
case 'v':
// data integrity check
check = liquid_getopt_str2crc(optarg);
if (check == LIQUID_CRC_UNKNOWN) {
fprintf(stderr,"error: unknown/unsupported CRC scheme \"%s\"\n\n",optarg);
exit(1);
}
break;
case 'c':
// inner FEC scheme
fec0 = liquid_getopt_str2fec(optarg);
if (fec0 == LIQUID_FEC_UNKNOWN) {
fprintf(stderr,"error: unknown/unsupported inner FEC scheme \"%s\"\n\n",optarg);
exit(1);
}
break;
case 'k':
// outer FEC scheme
fec1 = liquid_getopt_str2fec(optarg);
if (fec1 == LIQUID_FEC_UNKNOWN) {
fprintf(stderr,"error: unknown/unsupported outer FEC scheme \"%s\"\n\n",optarg);
exit(1);
}
break;
default:
exit(-1);
}
}
unsigned int i;
// TODO : validate options
// derived values
unsigned int frame_len = M + cp_len;
float complex buffer[frame_len]; // time-domain buffer
float nstd = powf(10.0f, noise_floor/20.0f);
float gamma = powf(10.0f, (SNRdB + noise_floor)/20.0f);
// allocate memory for header, payload
unsigned char header[8];
unsigned char payload[payload_len];
// initialize subcarrier allocation
unsigned char p[M];
ofdmframe_init_default_sctype(M, p);
// create frame generator
ofdmflexframegenprops_s fgprops;
ofdmflexframegenprops_init_default(&fgprops);
fgprops.check = check;
fgprops.fec0 = fec0;
fgprops.fec1 = fec1;
fgprops.mod_scheme = ms;
ofdmflexframegen fg = ofdmflexframegen_create(M, cp_len, taper_len, p, &fgprops);
// create frame synchronizer
ofdmflexframesync fs = ofdmflexframesync_create(M, cp_len, taper_len, p, callback, (void*)payload);
if (debug_enabled)
ofdmflexframesync_debug_enable(fs);
// initialize header/payload and assemble frame
for (i=0; i<8; i++)
header[i] = i & 0xff;
for (i=0; i<payload_len; i++)
payload[i] = rand() & 0xff;
ofdmflexframegen_assemble(fg, header, payload, payload_len);
ofdmflexframegen_print(fg);
ofdmflexframesync_print(fs);
// initialize frame synchronizer with noise
for (i=0; i<1000; i++) {
float complex noise = nstd*( randnf() + _Complex_I*randnf())*M_SQRT1_2;
ofdmflexframesync_execute(fs, &noise, 1);
}
// generate frame, push through channel
int last_symbol=0;
nco_crcf nco = nco_crcf_create(LIQUID_VCO);
nco_crcf_set_frequency(nco, dphi);
while (!last_symbol) {
// generate symbol
last_symbol = ofdmflexframegen_writesymbol(fg, buffer);
// apply channel
for (i=0; i<frame_len; i++) {
float complex noise = nstd*( randnf() + _Complex_I*randnf())*M_SQRT1_2;
buffer[i] *= gamma;
buffer[i] += noise;
nco_crcf_mix_up(nco, buffer[i], &buffer[i]);
nco_crcf_step(nco);
}
// receive symbol
ofdmflexframesync_execute(fs, buffer, frame_len);
}
nco_crcf_destroy(nco);
// export debugging file
if (debug_enabled)
ofdmflexframesync_debug_print(fs, "ofdmflexframesync_debug.m");
// destroy objects
ofdmflexframegen_destroy(fg);
ofdmflexframesync_destroy(fs);
printf("done.\n");
return 0;
}
int main(int argc, char*argv[])
{
// options
unsigned int sequence_len = 80; // number of sync symbols
unsigned int k = 2; // samples/symbol
unsigned int m = 7; // filter delay [symbols]
float beta = 0.3f; // excess bandwidth factor
int ftype = LIQUID_FIRFILT_ARKAISER;
float gamma = 10.0f; // channel gain
float tau = -0.3f; // fractional sample timing offset
float dphi = -0.01f; // carrier frequency offset
float phi = 0.5f; // carrier phase offset
float SNRdB = 20.0f; // signal-to-noise ratio [dB]
float threshold = 0.5f; // detection threshold
int dopt;
while ((dopt = getopt(argc,argv,"hn:k:m:b:F:T:S:t:")) != EOF) {
switch (dopt) {
case 'h': usage(); return 0;
case 'n': sequence_len = atoi(optarg); break;
case 'k': k = atoi(optarg); break;
case 'm': m = atoi(optarg); break;
case 'b': beta = atof(optarg); break;
case 'F': dphi = atof(optarg); break;
case 'T': tau = atof(optarg); break;
case 'S': SNRdB = atof(optarg); break;
case 't': threshold = atof(optarg); break;
default:
exit(1);
}
}
unsigned int i;
// validate input
if (tau < -0.5f || tau > 0.5f) {
fprintf(stderr,"error: %s, fractional sample offset must be in [-0.5,0.5]\n", argv[0]);
exit(1);
}
// generate synchronization sequence (QPSK symbols)
float complex sequence[sequence_len];
for (i=0; i<sequence_len; i++) {
sequence[i] = (rand() % 2 ? 1.0f : -1.0f) * M_SQRT1_2 +
(rand() % 2 ? 1.0f : -1.0f) * M_SQRT1_2 * _Complex_I;
}
//
float tau_hat = 0.0f;
float gamma_hat = 0.0f;
float dphi_hat = 0.0f;
float phi_hat = 0.0f;
int frame_detected = 0;
// create detector
qdetector_cccf q = qdetector_cccf_create_linear(sequence, sequence_len, ftype, k, m, beta);
qdetector_cccf_set_threshold(q, threshold);
qdetector_cccf_print(q);
//
unsigned int seq_len = qdetector_cccf_get_seq_len(q);
unsigned int buf_len = qdetector_cccf_get_buf_len(q);
unsigned int num_samples = 2*buf_len; // double buffer length to ensure detection
unsigned int num_symbols = buf_len;
// arrays
float complex y[num_samples]; // received signal
float complex syms_rx[num_symbols]; // recovered symbols
// get pointer to sequence and generate full sequence
float complex * v = (float complex*) qdetector_cccf_get_sequence(q);
unsigned int filter_delay = 15;
firfilt_crcf filter = firfilt_crcf_create_kaiser(2*filter_delay+1, 0.4f, 60.0f, -tau);
float nstd = 0.1f;
for (i=0; i<num_samples; i++) {
// add delay
firfilt_crcf_push(filter, i < seq_len ? v[i] : 0);
firfilt_crcf_execute(filter, &y[i]);
// channel gain
y[i] *= gamma;
// carrier offset
y[i] *= cexpf(_Complex_I*(dphi*i + phi));
// noise
y[i] += nstd*(randnf() + _Complex_I*randnf())*M_SQRT1_2;
}
firfilt_crcf_destroy(filter);
// run detection on sequence
for (i=0; i<num_samples; i++) {
v = qdetector_cccf_execute(q,y[i]);
if (v != NULL) {
printf("\nframe detected!\n");
frame_detected = 1;
// get statistics
tau_hat = qdetector_cccf_get_tau(q);
gamma_hat = qdetector_cccf_get_gamma(q);
dphi_hat = qdetector_cccf_get_dphi(q);
phi_hat = qdetector_cccf_get_phi(q);
break;
}
}
unsigned int num_syms_rx = 0; // output symbol counter
unsigned int counter = 0; // decimation counter
if (frame_detected) {
// recover symbols
firfilt_crcf mf = firfilt_crcf_create_rnyquist(ftype, k, m, beta, tau_hat);
firfilt_crcf_set_scale(mf, 1.0f / (float)(k*gamma_hat));
nco_crcf nco = nco_crcf_create(LIQUID_VCO);
nco_crcf_set_frequency(nco, dphi_hat);
nco_crcf_set_phase (nco, phi_hat);
for (i=0; i<buf_len; i++) {
//
float complex sample;
nco_crcf_mix_down(nco, v[i], &sample);
nco_crcf_step(nco);
// apply decimator
firfilt_crcf_push(mf, sample);
counter++;
if (counter == k-1)
firfilt_crcf_execute(mf, &syms_rx[num_syms_rx++]);
counter %= k;
}
nco_crcf_destroy(nco);
firfilt_crcf_destroy(mf);
}
// destroy objects
qdetector_cccf_destroy(q);
// print results
printf("\n");
printf("frame detected : %s\n", frame_detected ? "yes" : "no");
printf(" gamma hat : %8.3f, actual=%8.3f (error=%8.3f)\n", gamma_hat, gamma, gamma_hat - gamma);
printf(" tau hat : %8.3f, actual=%8.3f (error=%8.3f) samples\n", tau_hat, tau, tau_hat - tau );
printf(" dphi hat : %8.5f, actual=%8.5f (error=%8.5f) rad/sample\n", dphi_hat, dphi, dphi_hat - dphi );
printf(" phi hat : %8.5f, actual=%8.5f (error=%8.5f) radians\n", phi_hat, phi, phi_hat - phi );
printf(" symbols rx : %u\n", num_syms_rx);
printf("\n");
//
// export results
//
FILE * fid = fopen(OUTPUT_FILENAME,"w");
fprintf(fid,"%% %s : auto-generated file\n", OUTPUT_FILENAME);
fprintf(fid,"clear all\n");
fprintf(fid,"close all\n");
fprintf(fid,"sequence_len= %u;\n", sequence_len);
fprintf(fid,"num_samples = %u;\n", num_samples);
fprintf(fid,"y = zeros(1,num_samples);\n");
for (i=0; i<num_samples; i++)
fprintf(fid,"y(%4u) = %12.8f + j*%12.8f;\n", i+1, crealf(y[i]), cimagf(y[i]));
fprintf(fid,"num_syms_rx = %u;\n", num_syms_rx);
fprintf(fid,"syms_rx = zeros(1,num_syms_rx);\n");
for (i=0; i<num_syms_rx; i++)
fprintf(fid,"syms_rx(%4u) = %12.8f + j*%12.8f;\n", i+1, crealf(syms_rx[i]), cimagf(syms_rx[i]));
fprintf(fid,"t=[0:(num_samples-1)];\n");
fprintf(fid,"figure;\n");
fprintf(fid,"subplot(4,1,1);\n");
fprintf(fid," plot(t,real(y), t,imag(y));\n");
fprintf(fid," grid on;\n");
fprintf(fid," xlabel('time');\n");
fprintf(fid," ylabel('received signal');\n");
fprintf(fid,"subplot(4,1,2:4);\n");
fprintf(fid," plot(real(syms_rx), imag(syms_rx), 'x');\n");
fprintf(fid," axis([-1 1 -1 1]*1.5);\n");
fprintf(fid," axis square;\n");
fprintf(fid," grid on;\n");
fprintf(fid," xlabel('real');\n");
fprintf(fid," ylabel('imag');\n");
fclose(fid);
printf("results written to '%s'\n", OUTPUT_FILENAME);
return 0;
}
// create OFDM framing synchronizer object
// _M : number of subcarriers, >10 typical
// _cp_len : cyclic prefix length
// _taper_len : taper length (OFDM symbol overlap)
// _p : subcarrier allocation (null, pilot, data), [size: _M x 1]
// _callback : user-defined callback function
// _userdata : user-defined data pointer
ofdmframesync ofdmframesync_create(unsigned int _M,
unsigned int _cp_len,
unsigned int _taper_len,
unsigned char * _p,
ofdmframesync_callback _callback,
void * _userdata)
{
ofdmframesync q = (ofdmframesync) malloc(sizeof(struct ofdmframesync_s));
// validate input
if (_M < 8) {
fprintf(stderr,"warning: ofdmframesync_create(), less than 8 subcarriers\n");
} else if (_M % 2) {
fprintf(stderr,"error: ofdmframesync_create(), number of subcarriers must be even\n");
exit(1);
} else if (_cp_len > _M) {
fprintf(stderr,"error: ofdmframesync_create(), cyclic prefix length cannot exceed number of subcarriers\n");
exit(1);
}
q->M = _M;
q->cp_len = _cp_len;
// derived values
q->M2 = _M/2;
// subcarrier allocation
q->p = (unsigned char*) malloc((q->M)*sizeof(unsigned char));
if (_p == NULL) {
ofdmframe_init_default_sctype(q->M, q->p);
} else {
memmove(q->p, _p, q->M*sizeof(unsigned char));
}
// validate and count subcarrier allocation
ofdmframe_validate_sctype(q->p, q->M, &q->M_null, &q->M_pilot, &q->M_data);
if ( (q->M_pilot + q->M_data) == 0) {
fprintf(stderr,"error: ofdmframesync_create(), must have at least one enabled subcarrier\n");
exit(1);
} else if (q->M_data == 0) {
fprintf(stderr,"error: ofdmframesync_create(), must have at least one data subcarriers\n");
exit(1);
} else if (q->M_pilot < 2) {
fprintf(stderr,"error: ofdmframesync_create(), must have at least two pilot subcarriers\n");
exit(1);
}
// create transform object
q->X = (float complex*) malloc((q->M)*sizeof(float complex));
q->x = (float complex*) malloc((q->M)*sizeof(float complex));
q->fft = FFT_CREATE_PLAN(q->M, q->x, q->X, FFT_DIR_FORWARD, FFT_METHOD);
// create input buffer the length of the transform
q->input_buffer = windowcf_create(q->M + q->cp_len);
// allocate memory for PLCP arrays
q->S0 = (float complex*) malloc((q->M)*sizeof(float complex));
q->s0 = (float complex*) malloc((q->M)*sizeof(float complex));
q->S1 = (float complex*) malloc((q->M)*sizeof(float complex));
q->s1 = (float complex*) malloc((q->M)*sizeof(float complex));
ofdmframe_init_S0(q->p, q->M, q->S0, q->s0, &q->M_S0);
ofdmframe_init_S1(q->p, q->M, q->S1, q->s1, &q->M_S1);
// compute scaling factor
q->g_data = sqrtf(q->M) / sqrtf(q->M_pilot + q->M_data);
q->g_S0 = sqrtf(q->M) / sqrtf(q->M_S0);
q->g_S1 = sqrtf(q->M) / sqrtf(q->M_S1);
// gain
q->g0 = 1.0f;
q->G0 = (float complex*) malloc((q->M)*sizeof(float complex));
q->G1 = (float complex*) malloc((q->M)*sizeof(float complex));
q->G = (float complex*) malloc((q->M)*sizeof(float complex));
q->B = (float complex*) malloc((q->M)*sizeof(float complex));
q->R = (float complex*) malloc((q->M)*sizeof(float complex));
#if 1
memset(q->G0, 0x00, q->M*sizeof(float complex));
memset(q->G1, 0x00, q->M*sizeof(float complex));
memset(q->G , 0x00, q->M*sizeof(float complex));
memset(q->B, 0x00, q->M*sizeof(float complex));
#endif
// timing backoff
q->backoff = q->cp_len < 2 ? q->cp_len : 2;
float phi = (float)(q->backoff)*2.0f*M_PI/(float)(q->M);
unsigned int i;
for (i=0; i<q->M; i++)
q->B[i] = liquid_cexpjf(i*phi);
// set callback data
q->callback = _callback;
q->userdata = _userdata;
//
// synchronizer objects
//
// numerically-controlled oscillator
q->nco_rx = nco_crcf_create(LIQUID_NCO);
// set pilot sequence
q->ms_pilot = msequence_create_default(8);
#if OFDMFRAMESYNC_ENABLE_SQUELCH
// coarse detection
q->squelch_threshold = -25.0f;
q->squelch_enabled = 0;
#endif
// reset object
ofdmframesync_reset(q);
#if DEBUG_OFDMFRAMESYNC
q->debug_enabled = 0;
q->debug_objects_created = 0;
q->debug_x = NULL;
q->debug_rssi = NULL;
q->debug_framesyms =NULL;
q->G_hat = NULL;
q->px = NULL;
q->py = NULL;
q->debug_pilot_0 = NULL;
q->debug_pilot_1 = NULL;
#endif
// return object
return q;
}
// create flexframesync object
// _callback : callback function invoked when frame is received
// _userdata : user-defined data object passed to callback
flexframesync flexframesync_create(framesync_callback _callback,
void * _userdata)
{
flexframesync q = (flexframesync) malloc(sizeof(struct flexframesync_s));
q->callback = _callback;
q->userdata = _userdata;
unsigned int i;
// generate p/n sequence
msequence ms = msequence_create(6, 0x005b, 1);
for (i=0; i<64; i++)
q->preamble_pn[i] = (msequence_advance(ms)) ? 1.0f : -1.0f;
msequence_destroy(ms);
// interpolate p/n sequence with matched filter
q->k = 2; // samples/symbol
q->m = 7; // filter delay (symbols)
q->beta = 0.25f; // excess bandwidth factor
float complex seq[q->k*64];
firinterp_crcf interp = firinterp_crcf_create_rnyquist(LIQUID_FIRFILT_ARKAISER,q->k,q->m,q->beta,0);
for (i=0; i<64+q->m; i++) {
// compensate for filter delay
if (i < q->m) firinterp_crcf_execute(interp, q->preamble_pn[i], &seq[0]);
else firinterp_crcf_execute(interp, q->preamble_pn[i%64], &seq[q->k*(i-q->m)]);
}
firinterp_crcf_destroy(interp);
// create frame detector
float threshold = 0.4f; // detection threshold
float dphi_max = 0.05f; // maximum carrier offset allowable
q->frame_detector = detector_cccf_create(seq, q->k*64, threshold, dphi_max);
q->buffer = windowcf_create(q->k*(64+q->m));
// create symbol timing recovery filters
q->npfb = 32; // number of filters in the bank
q->mf = firpfb_crcf_create_rnyquist(LIQUID_FIRFILT_ARKAISER, q->npfb,q->k,q->m,q->beta);
q->dmf = firpfb_crcf_create_drnyquist(LIQUID_FIRFILT_ARKAISER,q->npfb,q->k,q->m,q->beta);
// create down-coverters for carrier phase tracking
q->nco_coarse = nco_crcf_create(LIQUID_NCO);
q->nco_fine = nco_crcf_create(LIQUID_VCO);
nco_crcf_pll_set_bandwidth(q->nco_fine, 0.05f);
// create header objects
q->demod_header = modem_create(LIQUID_MODEM_BPSK);
q->p_header = packetizer_create(FLEXFRAME_H_DEC,
FLEXFRAME_H_CRC,
FLEXFRAME_H_FEC0,
FLEXFRAME_H_FEC1);
assert(packetizer_get_enc_msg_len(q->p_header)==FLEXFRAME_H_ENC);
// frame properties (default values to be overwritten when frame
// header is received and properly decoded)
q->ms_payload = LIQUID_MODEM_QPSK;
q->bps_payload = 2;
q->payload_dec_len = 1;
q->check = LIQUID_CRC_NONE;
q->fec0 = LIQUID_FEC_NONE;
q->fec1 = LIQUID_FEC_NONE;
// create payload objects (overridden by received properties)
q->demod_payload = modem_create(LIQUID_MODEM_QPSK);
q->p_payload = packetizer_create(q->payload_dec_len, q->check, q->fec0, q->fec1);
q->payload_enc_len = packetizer_get_enc_msg_len(q->p_payload);
q->payload_mod_len = 4 * q->payload_enc_len;
q->payload_mod = (unsigned char*) malloc(q->payload_mod_len*sizeof(unsigned char));
q->payload_enc = (unsigned char*) malloc(q->payload_enc_len*sizeof(unsigned char));
q->payload_dec = (unsigned char*) malloc(q->payload_dec_len*sizeof(unsigned char));
#if DEBUG_FLEXFRAMESYNC
// set debugging flags, objects to NULL
q->debug_enabled = 0;
q->debug_objects_created = 0;
q->debug_x = NULL;
#endif
// reset state
flexframesync_reset(q);
return q;
}
// create GMSK frame synchronizer
// _callback : callback function
// _userdata : user data pointer passed to callback function
gmskframesync gmskframesync_create(framesync_callback _callback,
void * _userdata)
{
gmskframesync q = (gmskframesync) malloc(sizeof(struct gmskframesync_s));
q->callback = _callback;
q->userdata = _userdata;
q->k = 2; // samples/symbol
q->m = 3; // filter delay (symbols)
q->BT = 0.5f; // filter bandwidth-time product
#if GMSKFRAMESYNC_PREFILTER
// create default low-pass Butterworth filter
q->prefilter = iirfilt_crcf_create_lowpass(3, 0.5f*(1 + q->BT) / (float)(q->k));
#endif
unsigned int i;
// frame detector
q->preamble_len = 63;
q->preamble_pn = (float*)malloc(q->preamble_len*sizeof(float));
q->preamble_rx = (float*)malloc(q->preamble_len*sizeof(float));
float complex preamble_samples[q->preamble_len*q->k];
msequence ms = msequence_create(6, 0x6d, 1);
gmskmod mod = gmskmod_create(q->k, q->m, q->BT);
for (i=0; i<q->preamble_len + q->m; i++) {
unsigned char bit = msequence_advance(ms);
// save p/n sequence
if (i < q->preamble_len)
q->preamble_pn[i] = bit ? 1.0f : -1.0f;
// modulate/interpolate
if (i < q->m) gmskmod_modulate(mod, bit, &preamble_samples[0]);
else gmskmod_modulate(mod, bit, &preamble_samples[(i-q->m)*q->k]);
}
gmskmod_destroy(mod);
msequence_destroy(ms);
#if 0
// print sequence
for (i=0; i<q->preamble_len*q->k; i++)
printf("preamble(%3u) = %12.8f + j*%12.8f;\n", i+1, crealf(preamble_samples[i]), cimagf(preamble_samples[i]));
#endif
// create frame detector
float threshold = 0.5f; // detection threshold
float dphi_max = 0.05f; // maximum carrier offset allowable
q->frame_detector = detector_cccf_create(preamble_samples, q->preamble_len*q->k, threshold, dphi_max);
q->buffer = windowcf_create(q->k*(q->preamble_len+q->m));
// create symbol timing recovery filters
q->npfb = 32; // number of filters in the bank
q->mf = firpfb_rrrf_create_rnyquist( LIQUID_FIRFILT_GMSKRX,q->npfb,q->k,q->m,q->BT);
q->dmf = firpfb_rrrf_create_drnyquist(LIQUID_FIRFILT_GMSKRX,q->npfb,q->k,q->m,q->BT);
// create down-coverters for carrier phase tracking
q->nco_coarse = nco_crcf_create(LIQUID_NCO);
// create/allocate header objects/arrays
q->header_mod = (unsigned char*)malloc(GMSKFRAME_H_SYM*sizeof(unsigned char));
q->header_enc = (unsigned char*)malloc(GMSKFRAME_H_ENC*sizeof(unsigned char));
q->header_dec = (unsigned char*)malloc(GMSKFRAME_H_DEC*sizeof(unsigned char));
q->p_header = packetizer_create(GMSKFRAME_H_DEC,
GMSKFRAME_H_CRC,
GMSKFRAME_H_FEC,
LIQUID_FEC_NONE);
// create/allocate payload objects/arrays
q->payload_dec_len = 1;
q->check = LIQUID_CRC_32;
q->fec0 = LIQUID_FEC_NONE;
q->fec1 = LIQUID_FEC_NONE;
q->p_payload = packetizer_create(q->payload_dec_len,
q->check,
q->fec0,
q->fec1);
q->payload_enc_len = packetizer_get_enc_msg_len(q->p_payload);
q->payload_dec = (unsigned char*) malloc(q->payload_dec_len*sizeof(unsigned char));
q->payload_enc = (unsigned char*) malloc(q->payload_enc_len*sizeof(unsigned char));
#if DEBUG_GMSKFRAMESYNC
// debugging structures
q->debug_enabled = 0;
q->debug_objects_created = 0;
q->debug_x = NULL;
q->debug_fi = NULL;
q->debug_mf = NULL;
q->debug_framesyms = NULL;
#endif
// reset synchronizer
gmskframesync_reset(q);
// return synchronizer object
return q;
}
// create flexframesync object
// _callback : callback function invoked when frame is received
// _userdata : user-defined data object passed to callback
flexframesync flexframesync_create(framesync_callback _callback,
void * _userdata)
{
flexframesync q = (flexframesync) malloc(sizeof(struct flexframesync_s));
q->callback = _callback;
q->userdata = _userdata;
q->m = 7; // filter delay (symbols)
q->beta = 0.3f; // excess bandwidth factor
unsigned int i;
// generate p/n sequence
q->preamble_pn = (float complex*) malloc(64*sizeof(float complex));
q->preamble_rx = (float complex*) malloc(64*sizeof(float complex));
msequence ms = msequence_create(7, 0x0089, 1);
for (i=0; i<64; i++) {
q->preamble_pn[i] = (msequence_advance(ms) ? M_SQRT1_2 : -M_SQRT1_2) +
(msequence_advance(ms) ? M_SQRT1_2 : -M_SQRT1_2)*_Complex_I;
}
msequence_destroy(ms);
// create frame detector
unsigned int k = 2; // samples/symbol
q->detector = qdetector_cccf_create_linear(q->preamble_pn, 64, LIQUID_FIRFILT_ARKAISER, k, q->m, q->beta);
qdetector_cccf_set_threshold(q->detector, 0.5f);
// create symbol timing recovery filters
q->npfb = 32; // number of filters in the bank
q->mf = firpfb_crcf_create_rnyquist(LIQUID_FIRFILT_ARKAISER, q->npfb,k,q->m,q->beta);
#if FLEXFRAMESYNC_ENABLE_EQ
// create equalizer
unsigned int p = 3;
q->equalizer = eqlms_cccf_create_lowpass(2*k*p+1, 0.4f);
eqlms_cccf_set_bw(q->equalizer, 0.05f);
#endif
// create down-coverters for carrier phase tracking
q->mixer = nco_crcf_create(LIQUID_NCO);
q->pll = nco_crcf_create(LIQUID_NCO);
nco_crcf_pll_set_bandwidth(q->pll, 1e-4f); // very low bandwidth
// header demodulator/decoder
q->header_dec = (unsigned char *) malloc(FLEXFRAME_H_DEC*sizeof(unsigned char));
q->header_decoder = qpacketmodem_create();
qpacketmodem_configure(q->header_decoder,
FLEXFRAME_H_DEC,
FLEXFRAME_H_CRC,
FLEXFRAME_H_FEC0,
FLEXFRAME_H_FEC1,
LIQUID_MODEM_QPSK);
q->header_mod_len = qpacketmodem_get_frame_len(q->header_decoder);
q->header_mod = (float complex*) malloc(q->header_mod_len*sizeof(float complex));
// header pilot synchronizer
q->header_pilotsync = qpilotsync_create(q->header_mod_len, 16);
q->header_sym_len = qpilotsync_get_frame_len(q->header_pilotsync);
q->header_sym = (float complex*) malloc(q->header_sym_len*sizeof(float complex));
// payload demodulator for phase recovery
q->payload_demod = modem_create(LIQUID_MODEM_QPSK);
// create payload demodulator/decoder object
q->payload_dec_len = 64;
int check = LIQUID_CRC_24;
int fec0 = LIQUID_FEC_NONE;
int fec1 = LIQUID_FEC_GOLAY2412;
int mod_scheme = LIQUID_MODEM_QPSK;
q->payload_decoder = qpacketmodem_create();
qpacketmodem_configure(q->payload_decoder, q->payload_dec_len, check, fec0, fec1, mod_scheme);
//qpacketmodem_print(q->payload_decoder);
//assert( qpacketmodem_get_frame_len(q->payload_decoder)==600 );
q->payload_sym_len = qpacketmodem_get_frame_len(q->payload_decoder);
// allocate memory for payload symbols and recovered data bytes
q->payload_sym = (float complex*) malloc(q->payload_sym_len*sizeof(float complex));
q->payload_dec = (unsigned char*) malloc(q->payload_dec_len*sizeof(unsigned char));
// reset global data counters
flexframesync_reset_framedatastats(q);
#if DEBUG_FLEXFRAMESYNC
// set debugging flags, objects to NULL
q->debug_enabled = 0;
q->debug_objects_created = 0;
q->debug_qdetector_flush = 0;
q->debug_x = NULL;
#endif
// reset state and return
flexframesync_reset(q);
return q;
}
