int main(int argc, char*argv[])
{
// options
int ftype = LIQUID_FIRFILT_ARKAISER;
int ms = LIQUID_MODEM_QPSK;
unsigned int k = 2; // samples per symbol
unsigned int m = 7; // filter delay (symbols)
float beta = 0.20f; // filter excess bandwidth factor
unsigned int num_symbols = 4000; // number of data symbols
unsigned int hc_len = 4; // channel filter length
float noise_floor = -60.0f; // noise floor [dB]
float SNRdB = 30.0f; // signal-to-noise ratio [dB]
float bandwidth = 0.02f; // loop filter bandwidth
float tau = -0.2f; // fractional symbol offset
float rate = 1.001f; // sample rate offset
float dphi = 0.01f; // carrier frequency offset [radians/sample]
float phi = 2.1f; // carrier phase offset [radians]
unsigned int nfft = 2400; // spectral periodogram FFT size
unsigned int num_samples = 200000; // number of samples
int dopt;
while ((dopt = getopt(argc,argv,"hk:m:b:s:w:n:t:r:")) != EOF) {
switch (dopt) {
case 'h': usage(); return 0;
case 'k': k = atoi(optarg); break;
case 'm': m = atoi(optarg); break;
case 'b': beta = atof(optarg); break;
case 's': SNRdB = atof(optarg); break;
case 'w': bandwidth = atof(optarg); break;
case 'n': num_symbols = atoi(optarg); break;
case 't': tau = atof(optarg); break;
case 'r': rate = atof(optarg); break;
default:
exit(1);
}
}
// validate input
if (k < 2) {
fprintf(stderr,"error: k (samples/symbol) must be greater than 1\n");
exit(1);
} else if (m < 1) {
fprintf(stderr,"error: m (filter delay) must be greater than 0\n");
exit(1);
} else if (beta <= 0.0f || beta > 1.0f) {
fprintf(stderr,"error: beta (excess bandwidth factor) must be in (0,1]\n");
exit(1);
} else if (bandwidth <= 0.0f) {
fprintf(stderr,"error: timing PLL bandwidth must be greater than 0\n");
exit(1);
} else if (num_symbols == 0) {
fprintf(stderr,"error: number of symbols must be greater than 0\n");
exit(1);
} else if (tau < -1.0f || tau > 1.0f) {
fprintf(stderr,"error: timing phase offset must be in [-1,1]\n");
exit(1);
} else if (rate > 1.02f || rate < 0.98f) {
fprintf(stderr,"error: timing rate offset must be in [1.02,0.98]\n");
exit(1);
}
unsigned int i;
// buffers
unsigned int buf_len = 400; // buffer size
float complex x [buf_len]; // original signal
float complex y [buf_len*2]; // channel output (larger to accommodate resampler)
float complex syms[buf_len]; // recovered symbols
// window for saving last few symbols
windowcf sym_buf = windowcf_create(buf_len);
// create stream generator
symstreamcf gen = symstreamcf_create_linear(ftype,k,m,beta,ms);
// create channel emulator and add impairments
channel_cccf channel = channel_cccf_create();
channel_cccf_add_awgn (channel, noise_floor, SNRdB);
channel_cccf_add_carrier_offset(channel, dphi, phi);
channel_cccf_add_multipath (channel, NULL, hc_len);
channel_cccf_add_resamp (channel, 0.0f, rate);
// create symbol tracking synchronizer
symtrack_cccf symtrack = symtrack_cccf_create(ftype,k,m,beta,ms);
symtrack_cccf_set_bandwidth(symtrack,0.05f);
// create spectral periodogram for estimating spectrum
spgramcf periodogram = spgramcf_create_default(nfft);
unsigned int total_samples = 0;
unsigned int ny;
unsigned int total_symbols = 0;
while (total_samples < num_samples)
{
// write samples to buffer
symstreamcf_write_samples(gen, x, buf_len);
// apply channel
channel_cccf_execute(channel, x, buf_len, y, &ny);
// push resulting sample through periodogram
spgramcf_write(periodogram, y, ny);
// run resulting stream through synchronizer
unsigned int num_symbols_sync;
symtrack_cccf_execute_block(symtrack, y, ny, syms, &num_symbols_sync);
total_symbols += num_symbols_sync;
// write resulting symbols to window buffer for plotting
windowcf_write(sym_buf, syms, num_symbols_sync);
// accumulated samples
total_samples += buf_len;
}
printf("total samples: %u\n", total_samples);
printf("total symbols: %u\n", total_symbols);
// write accumulated power spectral density estimate
float psd[nfft];
spgramcf_get_psd(periodogram, psd);
//
// export output file
//
FILE * fid = fopen(OUTPUT_FILENAME,"w");
fprintf(fid,"%% %s, auto-generated file\n\n", OUTPUT_FILENAME);
fprintf(fid,"clear all;\n");
fprintf(fid,"close all;\n");
// read buffer and write last symbols to file
float complex * rc;
windowcf_read(sym_buf, &rc);
fprintf(fid,"syms = zeros(1,%u);\n", buf_len);
for (i=0; i<buf_len; i++)
fprintf(fid,"syms(%3u) = %12.8f + j*%12.8f;\n", i+1, crealf(rc[i]), cimagf(rc[i]));
// power spectral density estimate
fprintf(fid,"nfft = %u;\n", nfft);
fprintf(fid,"f=[0:(nfft-1)]/nfft - 0.5;\n");
fprintf(fid,"psd = zeros(1,nfft);\n");
for (i=0; i<nfft; i++)
fprintf(fid,"psd(%3u) = %12.8f;\n", i+1, psd[i]);
fprintf(fid,"figure('Color','white','position',[500 500 1400 400]);\n");
fprintf(fid,"subplot(1,3,1);\n");
fprintf(fid,"plot(real(syms),imag(syms),'x','MarkerSize',4);\n");
fprintf(fid," axis square;\n");
fprintf(fid," grid on;\n");
fprintf(fid," axis([-1 1 -1 1]*1.6);\n");
fprintf(fid," xlabel('In-phase');\n");
fprintf(fid," ylabel('Quadrature');\n");
fprintf(fid," title('Last %u symbols');\n", buf_len);
fprintf(fid,"subplot(1,3,2:3);\n");
fprintf(fid," plot(f, psd, 'LineWidth',1.5,'Color',[0 0.5 0.2]);\n");
fprintf(fid," grid on;\n");
fprintf(fid," pmin = 10*floor(0.1*min(psd - 5));\n");
fprintf(fid," pmax = 10*ceil (0.1*max(psd + 5));\n");
fprintf(fid," axis([-0.5 0.5 pmin pmax]);\n");
fprintf(fid," xlabel('Normalized Frequency [f/F_s]');\n");
fprintf(fid," ylabel('Power Spectral Density [dB]');\n");
fclose(fid);
printf("results written to %s.\n", OUTPUT_FILENAME);
// destroy objects
symstreamcf_destroy (gen);
spgramcf_destroy (periodogram);
channel_cccf_destroy (channel);
symtrack_cccf_destroy(symtrack);
windowcf_destroy (sym_buf);
// clean it up
printf("done.\n");
return 0;
}
// main program
int main (int argc, char **argv)
{
// command-line options
int verbose = 1;
int ppm_error = 0;
int gain = 0;
unsigned int nfft = 64;
float offset = -65.0f;
float scale = 5.0f;
float fft_rate = 10.0f;
float rx_resamp_rate;
float bandwidth = 800e3f;
unsigned int logsize = 4096;
char filename[256] = "rtl_asgram.dat";
int r, n_read;
uint32_t frequency = 100000000;
uint32_t samp_rate = DEFAULT_SAMPLE_RATE;
uint32_t out_block_size = DEFAULT_BUF_LENGTH;
uint8_t *buffer;
int dev_index = 0;
int dev_given = 0;
struct sigaction sigact;
normalizer_t *norm;
//
int d;
while ((d = getopt(argc,argv,"hf:b:B:G:n:p:s:o:r:L:F:")) != EOF) {
switch (d) {
case 'h':
usage();
return 0;
case 'f':
frequency = atof(optarg);
break;
case 'b':
bandwidth = atof(optarg);
break;
case 'B':
out_block_size = (uint32_t)atof(optarg);
break;
case 'G':
gain = (int)(atof(optarg) * 10);
break;
case 'n':
nfft = atoi(optarg);
break;
case 'o':
offset = atof(optarg);
break;
case 'p':
ppm_error = atoi(optarg);
break;
case 's':
samp_rate = (uint32_t)atofs(optarg);
break;
case 'r':
fft_rate = atof(optarg);
break;
case 'L':
logsize = atoi(optarg);
break;
case 'F':
strncpy(filename,optarg,255);
break;
case 'd':
dev_index = verbose_device_search(optarg);
dev_given = 1;
break;
default:
usage();
return 1;
}
}
// validate parameters
if (fft_rate <= 0.0f || fft_rate > 100.0f) {
fprintf(stderr,"error: %s, fft rate must be in (0, 100) Hz\n", argv[0]);
exit(1);
}
if (!dev_given) {
dev_index = verbose_device_search("0");
}
if (dev_index < 0) {
exit(1);
}
r = rtlsdr_open(&dev, (uint32_t)dev_index);
if (r < 0) {
fprintf(stderr, "Failed to open rtlsdr device #%d.\n", dev_index);
exit(1);
}
sigact.sa_handler = sighandler;
sigemptyset(&sigact.sa_mask);
sigact.sa_flags = 0;
sigaction(SIGINT, &sigact, NULL);
sigaction(SIGTERM, &sigact, NULL);
sigaction(SIGQUIT, &sigact, NULL);
sigaction(SIGPIPE, &sigact, NULL);
/* Set the sample rate */
verbose_set_sample_rate(dev, samp_rate);
/* Set the frequency */
verbose_set_frequency(dev, frequency);
if (0 == gain) {
/* Enable automatic gain */
verbose_auto_gain(dev);
} else {
/* Enable manual gain */
gain = nearest_gain(dev, gain);
verbose_gain_set(dev, gain);
}
verbose_ppm_set(dev, ppm_error);
rx_resamp_rate = bandwidth/samp_rate;
printf("frequency : %10.4f [MHz]\n", frequency*1e-6f);
printf("bandwidth : %10.4f [kHz]\n", bandwidth*1e-3f);
printf("sample rate : %10.4f kHz = %10.4f kHz * %8.6f\n",
samp_rate * 1e-3f,
bandwidth * 1e-3f,
1.0f / rx_resamp_rate);
printf("verbosity : %s\n", (verbose?"enabled":"disabled"));
unsigned int i;
// add arbitrary resampling component
msresamp_crcf resamp = msresamp_crcf_create(rx_resamp_rate, 60.0f);
assert(resamp);
// create buffer for sample logging
windowcf log = windowcf_create(logsize);
// create ASCII spectrogram object
float maxval;
float maxfreq;
char ascii[nfft+1];
ascii[nfft] = '\0'; // append null character to end of string
asgram q = asgram_create(nfft);
asgram_set_scale(q, offset, scale);
// assemble footer
unsigned int footer_len = nfft + 16;
char footer[footer_len+1];
for (i=0; i<footer_len; i++)
footer[i] = ' ';
footer[1] = '[';
footer[nfft/2 + 3] = '+';
footer[nfft + 4] = ']';
sprintf(&footer[nfft+6], "%8.3f MHz", frequency*1e-6f);
unsigned int msdelay = 1000 / fft_rate;
// create/initialize Hamming window
float w[nfft];
for (i=0; i<nfft; i++)
w[i] = hamming(i,nfft);
//allocate recv buffer
buffer = malloc(out_block_size * sizeof(uint8_t));
assert(buffer);
// create buffer for arbitrary resamper output
int b_len = ((int)(out_block_size * rx_resamp_rate) + 64) >> 1;
complex float buffer_resamp[b_len];
debug("resamp_buffer_len: %d", b_len);
// timer to control asgram output
timer t1 = timer_create();
timer_tic(t1);
norm = normalizer_create();
verbose_reset_buffer(dev);
while (!do_exit) {
// grab data from device
r = rtlsdr_read_sync(dev, buffer, out_block_size, &n_read);
if (r < 0) {
fprintf(stderr, "WARNING: sync read failed.\n");
break;
}
if ((bytes_to_read > 0) && (bytes_to_read < (uint32_t)n_read)) {
n_read = bytes_to_read;
do_exit = 1;
}
// push data through arbitrary resampler and give to frame synchronizer
// TODO : apply bandwidth-dependent gain
for (i=0; i<n_read/2; i++) {
// grab sample from usrp buffer
complex float rtlsdr_sample = normalizer_normalize(norm, *((uint16_t*)buffer+i));
// push through resampler (one at a time)
unsigned int nw;
msresamp_crcf_execute(resamp, &rtlsdr_sample, 1, buffer_resamp, &nw);
// push resulting samples into asgram object
asgram_push(q, buffer_resamp, nw);
// write samples to log
windowcf_write(log, buffer_resamp, nw);
}
if ((uint32_t)n_read < out_block_size) {
fprintf(stderr, "Short read, samples lost, exiting!\n");
break;
}
if (bytes_to_read > 0)
bytes_to_read -= n_read;
if (timer_toc(t1) > msdelay*1e-3f) {
// reset timer
timer_tic(t1);
// run the spectrogram
asgram_execute(q, ascii, &maxval, &maxfreq);
// print the spectrogram
printf(" > %s < pk%5.1fdB [%5.2f]\n", ascii, maxval, maxfreq);
printf("%s\r", footer);
fflush(stdout);
}
}
// try to write samples to file
FILE * fid = fopen(filename,"w");
if (fid != NULL) {
// write header
fprintf(fid, "# %s : auto-generated file\n", filename);
fprintf(fid, "#\n");
fprintf(fid, "# num_samples : %u\n", logsize);
fprintf(fid, "# frequency : %12.8f MHz\n", frequency*1e-6f);
fprintf(fid, "# bandwidth : %12.8f kHz\n", bandwidth*1e-3f);
// save results to file
complex float * rc; // read pointer
windowcf_read(log, &rc);
for (i=0; i<logsize; i++)
fprintf(fid, "%12.4e %12.4e\n", crealf(rc[i]), cimagf(rc[i]));
// close it up
fclose(fid);
printf("results written to '%s'\n", filename);
} else {
fprintf(stderr,"error: %s, could not open '%s' for writing\n", argv[0], filename);
}
// destroy objects
normalizer_destroy(&norm);
msresamp_crcf_destroy(resamp);
windowcf_destroy(log);
asgram_destroy(q);
timer_destroy(t1);
rtlsdr_close(dev);
free (buffer);
return 0;
}