//
// AUTOTEST: encode, modulate, demodulate, decode header
//
void autotest_flexframe_decode_header()
{
unsigned int i;
// create flexframegen object
flexframegenprops_s fgprops;
fgprops.rampup_len = 16;
fgprops.phasing_len = 50;
fgprops.payload_len = 64;
fgprops.check = LIQUID_CRC_NONE;
fgprops.fec0 = LIQUID_FEC_NONE;
fgprops.fec1 = LIQUID_FEC_NONE;
fgprops.mod_scheme = LIQUID_MODEM_PSK8;
fgprops.rampdn_len = 16;
flexframegen fg = flexframegen_create(&fgprops);
if (liquid_autotest_verbose)
flexframegen_print(fg);
// create flexframesync object
//flexframesyncprops_s fsprops;
flexframesync fs = flexframesync_create(NULL,NULL,NULL);
// initialize header, payload
unsigned char header[14];
for (i=0; i<14; i++)
header[i] = i;
// internal test : encode/decode header
/*
float complex header_modulated[128];
flexframegen_encode_header(fg, header);
flexframegen_modulate_header(fg, header_modulated);
flexframesync_demodulate_header(fs, header_modulated);
flexframesync_decode_header(fs, NULL);
*/
flexframegen_destroy(fg);
flexframesync_destroy(fs);
}
int main(int argc, char *argv[])
{
//srand( time(NULL) );
// options
modulation_scheme ms = LIQUID_MODEM_QPSK; // mod. scheme
crc_scheme check = LIQUID_CRC_32; // data validity check
fec_scheme fec0 = LIQUID_FEC_NONE; // fec (inner)
fec_scheme fec1 = LIQUID_FEC_NONE; // fec (outer)
unsigned int payload_len = 120; // payload length
int debug_enabled = 0; // enable debugging?
float noise_floor = -60.0f; // noise floor
float SNRdB = 20.0f; // signal-to-noise ratio
float dphi = 0.01f; // carrier frequency offset
// get options
int dopt;
while((dopt = getopt(argc,argv,"uhs:F:n:m:v:c:k:d")) != EOF){
switch (dopt) {
case 'u':
case 'h': usage(); return 0;
case 's': SNRdB = atof(optarg); break;
case 'F': dphi = atof(optarg); break;
case 'n': payload_len = atol(optarg); break;
case 'm': ms = liquid_getopt_str2mod(optarg); break;
case 'v': check = liquid_getopt_str2crc(optarg); break;
case 'c': fec0 = liquid_getopt_str2fec(optarg); break;
case 'k': fec1 = liquid_getopt_str2fec(optarg); break;
case 'd': debug_enabled = 1; break;
default:
exit(-1);
}
}
// derived values
unsigned int i;
float nstd = powf(10.0f, noise_floor/20.0f); // noise std. dev.
float gamma = powf(10.0f, (SNRdB+noise_floor)/20.0f); // channel gain
// create flexframegen object
flexframegenprops_s fgprops;
flexframegenprops_init_default(&fgprops);
fgprops.mod_scheme = ms;
fgprops.check = check;
fgprops.fec0 = fec0;
fgprops.fec1 = fec1;
flexframegen fg = flexframegen_create(&fgprops);
// frame data (header and payload)
unsigned char header[14];
unsigned char payload[payload_len];
// create flexframesync object
flexframesync fs = flexframesync_create(callback,NULL);
if (debug_enabled)
flexframesync_debug_enable(fs);
// initialize header, payload
for (i=0; i<14; i++)
header[i] = i;
for (i=0; i<payload_len; i++)
payload[i] = rand() & 0xff;
// assemble the frame
flexframegen_assemble(fg, header, payload, payload_len);
flexframegen_print(fg);
// generate the frame in blocks
unsigned int buf_len = 256;
float complex x[buf_len];
float complex y[buf_len];
int frame_complete = 0;
float phi = 0.0f;
while (!frame_complete) {
// write samples to buffer
frame_complete = flexframegen_write_samples(fg, x, buf_len);
// add noise and push through synchronizer
for (i=0; i<buf_len; i++) {
// apply channel gain and carrier offset to input
y[i] = gamma * x[i] * cexpf(_Complex_I*phi);
phi += dphi;
// add noise
y[i] += nstd*( randnf() + _Complex_I*randnf())*M_SQRT1_2;
}
// run through frame synchronizer
flexframesync_execute(fs, y, buf_len);
}
// export debugging file
if (debug_enabled)
flexframesync_debug_print(fs, "flexframesync_debug.m");
flexframesync_print(fs);
// destroy allocated objects
flexframegen_destroy(fg);
flexframesync_destroy(fs);
printf("done.\n");
return 0;
}