// re-create packetizer object
//
// _p : initialz packetizer object
// _n : number of uncoded intput bytes
// _crc : error-detecting scheme
// _fec0 : inner forward error-correction code
// _fec1 : outer forward error-correction code
packetizer packetizer_recreate(packetizer _p,
unsigned int _n,
int _crc,
int _fec0,
int _fec1)
{
if (_p == NULL) {
// packetizer was never created
return packetizer_create(_n, _crc, _fec0, _fec1);
}
// check values
if (_p->msg_len == _n &&
_p->check == _crc &&
_p->plan[0].fs == _fec0 &&
_p->plan[1].fs == _fec1 )
{
// no change; return input pointer
return _p;
} else {
// something has changed; destroy old object and create new one
// TODO : rather than completely destroying object, only change values that are necessary
packetizer_destroy(_p);
return packetizer_create(_n,_crc,_fec0,_fec1);
}
}
bpacketsync bpacketsync_create(unsigned int _m,
bpacketsync_callback _callback,
void * _userdata)
{
// create bpacketsync object
bpacketsync q = (bpacketsync) malloc(sizeof(struct bpacketsync_s));
q->callback = _callback;
q->userdata = _userdata;
// default values
q->dec_msg_len = 1;
q->crc = LIQUID_CRC_NONE;
q->fec0 = LIQUID_FEC_NONE;
q->fec1 = LIQUID_FEC_NONE;
// implied values
q->g = 0;
q->pnsequence_len = 8;
// derived values
q->enc_msg_len = packetizer_compute_enc_msg_len(q->dec_msg_len,
q->crc,
q->fec0,
q->fec1);
q->header_len = packetizer_compute_enc_msg_len(6, LIQUID_CRC_16, LIQUID_FEC_NONE, LIQUID_FEC_HAMMING128);
// arrays
q->pnsequence = (unsigned char*) malloc((q->pnsequence_len)*sizeof(unsigned char*));
q->payload_enc = (unsigned char*) malloc((q->enc_msg_len)*sizeof(unsigned char*));
q->payload_dec = (unsigned char*) malloc((q->dec_msg_len)*sizeof(unsigned char*));
// create m-sequence generator
// TODO : configure sequence from generator polynomial
q->ms = msequence_create_default(6);
// create header packet encoder
q->p_header = packetizer_create(6, LIQUID_CRC_16, LIQUID_FEC_NONE, LIQUID_FEC_HAMMING128);
assert(q->header_len == packetizer_get_enc_msg_len(q->p_header));
// create payload packet encoder
q->p_payload = packetizer_create(q->dec_msg_len,
q->crc,
q->fec0,
q->fec1);
// create binary sequence objects
q->bpn = bsequence_create(q->pnsequence_len*8);
q->brx = bsequence_create(q->pnsequence_len*8);
// assemble semi-static framing structures
bpacketsync_assemble_pnsequence(q);
// reset synchronizer
bpacketsync_reset(q);
return q;
}
// create gmskframegen object
gmskframegen gmskframegen_create()
{
gmskframegen q = (gmskframegen) malloc(sizeof(struct gmskframegen_s));
// set internal properties
q->k = 2; // samples/symbol
q->m = 3; // filter delay (symbols)
q->BT = 0.5f; // filter bandwidth-time product
// internal/derived values
q->preamble_len = 63; // number of preamble symbols
q->payload_len = 0; // number of payload symbols
q->tail_len = 2*q->m; // number of tail symbols (flush interp)
// create modulator
q->mod = gmskmod_create(q->k, q->m, q->BT);
// preamble objects/arrays
q->ms_preamble = msequence_create(6, 0x6d, 1);
// header objects/arrays
q->header_dec = (unsigned char*)malloc(GMSKFRAME_H_DEC*sizeof(unsigned char));
q->header_enc = (unsigned char*)malloc(GMSKFRAME_H_ENC*sizeof(unsigned char));
q->header_len = GMSKFRAME_H_ENC * 8;
q->p_header = packetizer_create(GMSKFRAME_H_DEC,
GMSKFRAME_H_CRC,
GMSKFRAME_H_FEC,
LIQUID_FEC_NONE);
// payload objects/arrays
q->dec_msg_len = 0;
q->check = LIQUID_CRC_32;
q->fec0 = LIQUID_FEC_NONE;
q->fec1 = LIQUID_FEC_NONE;
q->p_payload = packetizer_create(q->dec_msg_len,
q->check,
q->fec0,
q->fec1);
q->enc_msg_len = packetizer_get_enc_msg_len(q->p_payload);
q->payload_len = 8*q->enc_msg_len;
// allocate memory for encoded packet
q->payload_enc = (unsigned char*) malloc(q->enc_msg_len*sizeof(unsigned char));
// reset framing object
gmskframegen_reset(q);
// return object
return q;
}
// create bpacketgen object
// _m : p/n sequence length (ignored)
// _dec_msg_len : decoded message length (original uncoded data)
// _crc : data validity check (e.g. cyclic redundancy check)
// _fec0 : inner forward error-correction code scheme
// _fec1 : outer forward error-correction code scheme
bpacketgen bpacketgen_create(unsigned int _m,
unsigned int _dec_msg_len,
int _crc,
int _fec0,
int _fec1)
{
// validate input
// create bpacketgen object
bpacketgen q = (bpacketgen) malloc(sizeof(struct bpacketgen_s));
q->dec_msg_len = _dec_msg_len;
q->crc = _crc;
q->fec0 = _fec0;
q->fec1 = _fec1;
// implied values
q->g = 0;
q->pnsequence_len = 8;
// derived values
q->enc_msg_len = packetizer_compute_enc_msg_len(q->dec_msg_len,
q->crc,
q->fec0,
q->fec1);
q->header_len = packetizer_compute_enc_msg_len(6, LIQUID_CRC_16, LIQUID_FEC_NONE, LIQUID_FEC_HAMMING128);
bpacketgen_compute_packet_len(q);
// arrays
q->pnsequence = (unsigned char*) malloc((q->pnsequence_len)*sizeof(unsigned char*));
// create m-sequence generator
// TODO : configure sequence from generator polynomial
q->ms = msequence_create_default(6);
// create header packet encoder
q->p_header = packetizer_create(6, LIQUID_CRC_16, LIQUID_FEC_NONE, LIQUID_FEC_HAMMING128);
assert(q->header_len == packetizer_get_enc_msg_len(q->p_header));
// create payload packet encoder
q->p_payload = packetizer_create(q->dec_msg_len,
q->crc,
q->fec0,
q->fec1);
// assemble semi-static framing structures
bpacketgen_assemble_header(q);
bpacketgen_assemble_pnsequence(q);
return q;
}
// create ofdmflexframesync object
// _M : number of subcarriers
// _cp_len : length of cyclic prefix [samples]
// _taper_len : taper length (OFDM symbol overlap)
// _p : subcarrier allocation (PILOT/NULL/DATA) [size: _M x 1]
// _callback : user-defined callback function
// _userdata : user-defined data structure passed to callback
ofdmflexframesync ofdmflexframesync_create(unsigned int _M,
unsigned int _cp_len,
unsigned int _taper_len,
unsigned char * _p,
framesync_callback _callback,
void * _userdata)
{
ofdmflexframesync q = (ofdmflexframesync) malloc(sizeof(struct ofdmflexframesync_s));
// validate input
if (_M < 8) {
fprintf(stderr,"warning: ofdmflexframesync_create(), less than 8 subcarriers\n");
} else if (_M % 2) {
fprintf(stderr,"error: ofdmflexframesync_create(), number of subcarriers must be even\n");
exit(1);
} else if (_cp_len > _M) {
fprintf(stderr,"error: ofdmflexframesync_create(), cyclic prefix length cannot exceed number of subcarriers\n");
exit(1);
}
// set internal properties
q->M = _M;
q->cp_len = _cp_len;
q->taper_len = _taper_len;
q->callback = _callback;
q->userdata = _userdata;
// allocate memory for subcarrier allocation IDs
q->p = (unsigned char*) malloc((q->M)*sizeof(unsigned char));
if (_p == NULL) {
// initialize default subcarrier allocation
ofdmframe_init_default_sctype(q->M, q->p);
} else {
// copy user-defined subcarrier allocation
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);
// create internal framing object
q->fs = ofdmframesync_create(_M, _cp_len, _taper_len, _p, ofdmflexframesync_internal_callback, (void*)q);
// create header objects
q->mod_header = modem_create(OFDMFLEXFRAME_H_MOD);
q->p_header = packetizer_create(OFDMFLEXFRAME_H_DEC,
OFDMFLEXFRAME_H_CRC,
OFDMFLEXFRAME_H_FEC,
LIQUID_FEC_NONE);
assert(packetizer_get_enc_msg_len(q->p_header)==OFDMFLEXFRAME_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_len = 1;
q->check = LIQUID_CRC_NONE;
q->fec0 = LIQUID_FEC_NONE;
q->fec1 = LIQUID_FEC_NONE;
// create payload objects (initally QPSK, etc but overridden by received properties)
q->mod_payload = modem_create(q->ms_payload);
q->p_payload = packetizer_create(q->payload_len, q->check, q->fec0, q->fec1);
q->payload_enc_len = packetizer_get_enc_msg_len(q->p_payload);
q->payload_enc = (unsigned char*) malloc(q->payload_enc_len*sizeof(unsigned char));
q->payload_dec = (unsigned char*) malloc(q->payload_len*sizeof(unsigned char));
q->payload_mod_len = 0;
// reset state
ofdmflexframesync_reset(q);
// return object
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;
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;
}
int main(int argc, char*argv[]) {
// options
unsigned int n=8; // original data message length
crc_scheme check = LIQUID_CRC_32; // data integrity check
fec_scheme fec0 = LIQUID_FEC_HAMMING74; // inner code
fec_scheme fec1 = LIQUID_FEC_NONE; // outer code
// read command-line options
int dopt;
while((dopt = getopt(argc,argv,"uhn:v:c:k:")) != EOF){
switch (dopt) {
case 'h':
case 'u': usage(); return 0;
case 'n':
n = atoi(optarg);
if (n < 1) {
printf("error: packet length must be positive\n");
usage();
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;
unsigned int k = packetizer_compute_enc_msg_len(n,check,fec0,fec1);
packetizer p = packetizer_create(n,check,fec0,fec1);
packetizer_print(p);
// initialize arrays
unsigned char msg_org[n]; // original message
unsigned char msg_enc[k]; // encoded message
unsigned char msg_rec[8*k]; // recieved message (soft bits)
unsigned char msg_dec[n]; // decoded message
int crc_pass;
// initialize original data message
for (i=0; i<n; i++)
msg_org[i] = rand() % 256;
// encode packet
packetizer_encode(p,msg_org,msg_enc);
// convert to soft bits and add 'noise'
for (i=0; i<k; i++) {
msg_rec[8*i+0] = (msg_enc[i] & 0x80) ? 255 : 0;
msg_rec[8*i+1] = (msg_enc[i] & 0x40) ? 255 : 0;
msg_rec[8*i+2] = (msg_enc[i] & 0x20) ? 255 : 0;
msg_rec[8*i+3] = (msg_enc[i] & 0x10) ? 255 : 0;
msg_rec[8*i+4] = (msg_enc[i] & 0x08) ? 255 : 0;
msg_rec[8*i+5] = (msg_enc[i] & 0x04) ? 255 : 0;
msg_rec[8*i+6] = (msg_enc[i] & 0x02) ? 255 : 0;
msg_rec[8*i+7] = (msg_enc[i] & 0x01) ? 255 : 0;
}
// flip first bit (ensure error)
msg_rec[0] = 255 - msg_rec[0];
// add noise (but not so much that it would cause a bit error)
for (i=0; i<8*k; i++) {
int soft_bit = msg_rec[i] + (int)(20*randnf());
if (soft_bit > 255) soft_bit = 255;
if (soft_bit < 0) soft_bit = 0;
msg_rec[i] = soft_bit;
}
// decode packet
crc_pass =
packetizer_decode_soft(p,msg_rec,msg_dec);
// clean up allocated objects
packetizer_destroy(p);
// print results
printf("original message: [%3u] ",n);
for (i=0; i<n; i++)
printf(" %.2X", (unsigned int) (msg_org[i]));
printf("\n");
printf("encoded message: [%3u] ",k);
for (i=0; i<k; i++)
printf(" %.2X", (unsigned int) (msg_enc[i]));
printf("\n");
#if 0
printf("received message: [%3u] ",k);
for (i=0; i<k; i++)
printf("%c%.2X", msg_rec[i]==msg_enc[i] ? ' ' : '*', (unsigned int) (msg_rec[i]));
printf("\n");
#endif
//if (verbose) {
if (1) {
// print expanded result (print each soft bit value)
for (i=0; i<k; i++) {
unsigned char msg_cor_hard = 0x00;
printf("%5u: ", i);
unsigned int j;
for (j=0; j<8; j++) {
msg_cor_hard |= (msg_rec[8*i+j] > 127) ? 1<<(8-j-1) : 0;
unsigned int bit_enc = (msg_enc[i] >> (8-j-1)) & 0x01;
unsigned int bit_rec = (msg_rec[8*i+j] > 127) ? 1 : 0;
//printf("%1u %3u (%1u) %c", bit_enc, msg_rec[i], bit_rec, bit_enc != bit_rec ? '*' : ' ');
printf("%4u%c", msg_rec[8*i+j], bit_enc != bit_rec ? '*' : ' ');
}
printf(" : %c%.2X\n", msg_cor_hard==msg_enc[i] ? ' ' : '*', (unsigned int) (msg_cor_hard));
}
} // verbose
printf("decoded message: [%3u] ",n);
for (i=0; i<n; i++)
printf("%c%.2X", msg_dec[i] == msg_org[i] ? ' ' : '*', (unsigned int) (msg_dec[i]));
printf("\n");
printf("\n");
// count bit errors
unsigned int num_sym_errors=0;
unsigned int num_bit_errors=0;
for (i=0; i<n; i++) {
num_sym_errors += (msg_org[i] == msg_dec[i]) ? 0 : 1;
num_bit_errors += count_bit_errors(msg_org[i], msg_dec[i]);
}
//printf("number of symbol errors detected: %d\n", num_errors_detected);
printf("number of symbol errors received: %4u / %4u\n", num_sym_errors, n);
printf("number of bit errors received: %4u / %4u\n", num_bit_errors, n*8);
if (crc_pass)
printf("(crc passed)\n");
else
printf("(crc failed)\n");
return 0;
}
// create OFDM flexible framing generator 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]
// _fgprops : frame properties (modulation scheme, etc.)
ofdmflexframegen ofdmflexframegen_create(unsigned int _M,
unsigned int _cp_len,
unsigned int _taper_len,
unsigned char * _p,
ofdmflexframegenprops_s * _fgprops)
{
// validate input
if (_M < 2) {
fprintf(stderr,"error: ofdmflexframegen_create(), number of subcarriers must be at least 2\n");
exit(1);
} else if (_M % 2) {
fprintf(stderr,"error: ofdmflexframegen_create(), number of subcarriers must be even\n");
exit(1);
}
ofdmflexframegen q = (ofdmflexframegen) malloc(sizeof(struct ofdmflexframegen_s));
q->M = _M; // number of subcarriers
q->cp_len = _cp_len; // cyclic prefix length
q->taper_len = _taper_len; // taper length
// allocate memory for transform buffers
q->X = (float complex*) malloc((q->M)*sizeof(float complex));
// allocate memory for subcarrier allocation IDs
q->p = (unsigned char*) malloc((q->M)*sizeof(unsigned char));
if (_p == NULL) {
// initialize default subcarrier allocation
ofdmframe_init_default_sctype(q->M, q->p);
} else {
// copy user-defined subcarrier allocation
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);
// create internal OFDM frame generator object
q->fg = ofdmframegen_create(q->M, q->cp_len, q->taper_len, q->p);
// create header objects
q->mod_header = modem_create(OFDMFLEXFRAME_H_MOD);
q->p_header = packetizer_create(OFDMFLEXFRAME_H_DEC,
OFDMFLEXFRAME_H_CRC,
OFDMFLEXFRAME_H_FEC,
LIQUID_FEC_NONE);
assert(packetizer_get_enc_msg_len(q->p_header)==OFDMFLEXFRAME_H_ENC);
// compute number of header symbols
div_t d = div(OFDMFLEXFRAME_H_SYM, q->M_data);
q->num_symbols_header = d.quot + (d.rem ? 1 : 0);
// initial memory allocation for payload
q->payload_dec_len = 1;
q->p_payload = packetizer_create(q->payload_dec_len,
LIQUID_CRC_NONE,
LIQUID_FEC_NONE,
LIQUID_FEC_NONE);
q->payload_enc_len = packetizer_get_enc_msg_len(q->p_payload);
q->payload_enc = (unsigned char*) malloc(q->payload_enc_len*sizeof(unsigned char));
q->payload_mod_len = 1;
q->payload_mod = (unsigned char*) malloc(q->payload_mod_len*sizeof(unsigned char));
// create payload modem (initially QPSK, overridden by properties)
q->mod_payload = modem_create(LIQUID_MODEM_QPSK);
// initialize properties
ofdmflexframegen_setprops(q, _fgprops);
// reset
ofdmflexframegen_reset(q);
// return pointer to main object
return q;
}
