// destroy frame synchronizer object, freeing all internal memory
void flexframesync_destroy(flexframesync _q)
{
#if DEBUG_FLEXFRAMESYNC
// clean up debug objects (if created)
if (_q->debug_objects_created) {
windowcf_destroy(_q->debug_x);
}
#endif
// destroy synchronization objects
detector_cccf_destroy(_q->frame_detector); // frame detector
windowcf_destroy(_q->buffer); // p/n sample buffer
firpfb_crcf_destroy(_q->mf); // matched filter
firpfb_crcf_destroy(_q->dmf); // derivative matched filter
nco_crcf_destroy(_q->nco_coarse); // coarse NCO
nco_crcf_destroy(_q->nco_fine); // fine-tuned NCO
modem_destroy(_q->demod_header); // header demodulator
packetizer_destroy(_q->p_header); // header packetizer
modem_destroy(_q->demod_payload); // payload demodulator
packetizer_destroy(_q->p_payload); // payload decoder
// free buffers and arrays
free(_q->payload_mod); //
free(_q->payload_enc); //
free(_q->payload_dec); //
// free main object memory
free(_q);
}
// destroy bpacketgen object, freeing all internally-allocated memory
void bpacketgen_destroy(bpacketgen _q)
{
// free arrays
free(_q->pnsequence);
// destroy internal objects
msequence_destroy(_q->ms);
packetizer_destroy(_q->p_header);
packetizer_destroy(_q->p_payload);
// free main object memory
free(_q);
}
// 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);
}
}
void ofdmflexframesync_destroy(ofdmflexframesync _q)
{
// destroy internal objects
ofdmframesync_destroy(_q->fs);
packetizer_destroy(_q->p_header);
modem_destroy(_q->mod_header);
packetizer_destroy(_q->p_payload);
modem_destroy(_q->mod_payload);
// free internal buffers/arrays
free(_q->p);
free(_q->payload_enc);
free(_q->payload_dec);
// free main object memory
free(_q);
}
void bpacketsync_destroy(bpacketsync _q)
{
// free arrays
free(_q->pnsequence);
free(_q->payload_enc);
free(_q->payload_dec);
// destroy internal objects
msequence_destroy(_q->ms);
packetizer_destroy(_q->p_header);
packetizer_destroy(_q->p_payload);
bsequence_destroy(_q->bpn);
bsequence_destroy(_q->brx);
// free main object memory
free(_q);
}
void ofdmflexframegen_destroy(ofdmflexframegen _q)
{
// destroy internal objects
ofdmframegen_destroy(_q->fg); // OFDM frame generator
packetizer_destroy(_q->p_header); // header packetizer
modem_destroy(_q->mod_header); // header modulator
packetizer_destroy(_q->p_payload); // payload packetizer
modem_destroy(_q->mod_payload); // payload modulator
// free buffers/arrays
free(_q->payload_enc); // encoded payload bytes
free(_q->payload_mod); // modulated payload symbols
free(_q->X); // frequency-domain buffer
free(_q->p); // subcarrier allocation
// free main object memory
free(_q);
}
// destroy gmskframegen object
void gmskframegen_destroy(gmskframegen _q)
{
// destroy gmsk modulator
gmskmod_destroy(_q->mod);
// destroy/free preamble objects/arrays
msequence_destroy(_q->ms_preamble);
// destroy/free header objects/arrays
free(_q->header_dec);
free(_q->header_enc);
packetizer_destroy(_q->p_header);
// destroy/free payload objects/arrays
free(_q->payload_enc);
packetizer_destroy(_q->p_payload);
// free main object memory
free(_q);
}
// destroy frame synchronizer object, freeing all internal memory
void gmskframesync_destroy(gmskframesync _q)
{
#if DEBUG_GMSKFRAMESYNC
// destroy debugging objects
if (_q->debug_objects_created) {
windowcf_destroy(_q->debug_x);
windowf_destroy(_q->debug_fi);
windowf_destroy(_q->debug_mf);
windowf_destroy( _q->debug_framesyms);
}
#endif
// destroy synchronizer objects
#if GMSKFRAMESYNC_PREFILTER
iirfilt_crcf_destroy(_q->prefilter);// pre-demodulator filter
#endif
firpfb_rrrf_destroy(_q->mf); // matched filter
firpfb_rrrf_destroy(_q->dmf); // derivative matched filter
nco_crcf_destroy(_q->nco_coarse); // coarse NCO
// preamble
detector_cccf_destroy(_q->frame_detector);
windowcf_destroy(_q->buffer);
free(_q->preamble_pn);
free(_q->preamble_rx);
// header
packetizer_destroy(_q->p_header);
free(_q->header_mod);
free(_q->header_enc);
free(_q->header_dec);
// payload
packetizer_destroy(_q->p_payload);
free(_q->payload_enc);
free(_q->payload_dec);
// free main object memory
free(_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;
}
