BSYNC() BSYNC(_create)(unsigned int _n, TC * _v)
{
BSYNC() fs = (BSYNC()) malloc(sizeof(struct BSYNC(_s)));
fs->n = _n;
fs->sync_i = bsequence_create(fs->n);
#ifdef TC_COMPLEX
fs->sync_q = bsequence_create(fs->n);
#endif
fs->sym_i = bsequence_create(fs->n);
#ifdef TI_COMPLEX
fs->sym_q = bsequence_create(fs->n);
#endif
unsigned int i;
for (i=0; i<fs->n; i++) {
bsequence_push(fs->sync_i, crealf(_v[i])>0);
#ifdef TC_COMPLEX
bsequence_push(fs->sync_q, cimagf(_v[i])>0);
#endif
}
return fs;
}
/* _m : number of correlators */
BPRESYNC() BPRESYNC(_create)(TC * _v,
unsigned int _n,
float _dphi_max,
unsigned int _m)
{
// validate input
if (_n < 1) {
fprintf(stderr, "error: bpresync_%s_create(), invalid input length\n", EXTENSION_FULL);
exit(1);
} else if (_m == 0) {
fprintf(stderr, "error: bpresync_%s_create(), number of correlators must be at least 1\n", EXTENSION_FULL);
exit(1);
}
// allocate main object memory and initialize
BPRESYNC() _q = (BPRESYNC()) malloc(sizeof(struct BPRESYNC(_s)));
_q->n = _n;
_q->m = _m;
_q->n_inv = 1.0f / (float)(_q->n);
unsigned int i;
// create internal receive buffers
_q->rx_i = bsequence_create(_q->n);
_q->rx_q = bsequence_create(_q->n);
// create internal array of frequency offsets
_q->dphi = (float*) malloc( _q->m*sizeof(float) );
// create internal synchronizers
_q->sync_i = (bsequence*) malloc( _q->m*sizeof(bsequence) );
_q->sync_q = (bsequence*) malloc( _q->m*sizeof(bsequence) );
for (i=0; i<_q->m; i++) {
_q->sync_i[i] = bsequence_create(_q->n);
_q->sync_q[i] = bsequence_create(_q->n);
// generate signal with frequency offset
_q->dphi[i] = (float)i / (float)(_q->m-1)*_dphi_max;
unsigned int k;
for (k=0; k<_q->n; k++) {
TC v_prime = _v[k] * cexpf(-_Complex_I*k*_q->dphi[i]);
bsequence_push(_q->sync_i[i], crealf(v_prime)>0);
bsequence_push(_q->sync_q[i], cimagf(v_prime)>0);
}
}
// allocate memory for cross-correlation
_q->rxy = (float*) malloc( _q->m*sizeof(float) );
// reset object
BPRESYNC(_reset)(_q);
return _q;
}
// TODO : test this method
BSYNC() BSYNC(_create_msequence)(unsigned int _g,
unsigned int _k)
{
// validate input
if (_k == 0) {
fprintf(stderr,"bsync_xxxt_create_msequence(), samples/symbol must be greater than zero\n");
exit(1);
}
unsigned int m = liquid_msb_index(_g) - 1;
// create/initialize msequence
msequence ms = msequence_create(m, _g, 1);
BSYNC() fs = (BSYNC()) malloc(sizeof(struct BSYNC(_s)));
unsigned int n = msequence_get_length(ms);
fs->sync_i = bsequence_create(n * _k);
#ifdef TC_COMPLEX
fs->sync_q = bsequence_create(n * _k);
#endif
fs->sym_i = bsequence_create(n * _k);
#ifdef TI_COMPLEX
fs->sym_q = bsequence_create(n * _k);
#endif
msequence_reset(ms);
#if 0
bsequence_init_msequence(fs->sync_i,ms);
#ifdef TC_COMPLEX
msequence_reset(ms);
bsequence_init_msequence(fs->sync_q,ms);
#endif
#else
unsigned int i;
unsigned int j;
for (i=0; i<n; i++) {
unsigned int bit = msequence_advance(ms);
for (j=0; j<_k; j++) {
bsequence_push(fs->sync_i, bit);
#ifdef TC_COMPLEX
bsequence_push(fs->sync_q, bit);
#endif
}
}
#endif
msequence_destroy(ms);
fs->n = _k*n;
return fs;
}
void bpacketsync_assemble_pnsequence(bpacketsync _q)
{
// reset m-sequence generator
msequence_reset(_q->ms);
unsigned int i;
for (i=0; i<8*_q->pnsequence_len; i++)
bsequence_push(_q->bpn, msequence_advance(_q->ms));
}
// initialize a bsequence object on an msequence object
// _bs : bsequence object
// _ms : msequence object
void bsequence_init_msequence(bsequence _bs,
msequence _ms)
{
#if 0
if (_ms->n > LIQUID_MAX_MSEQUENCE_LENGTH) {
fprintf(stderr,"error: bsequence_init_msequence(), msequence length exceeds maximum\n");
exit(1);
}
#endif
// clear binary sequence
bsequence_clear(_bs);
unsigned int i;
for (i=0; i<(_ms->n); i++)
bsequence_push(_bs, msequence_advance(_ms));
}
void bpacketsync_execute_seekpn(bpacketsync _q,
unsigned char _bit)
{
// push bit into correlator
bsequence_push(_q->brx, _bit);
// compute p/n sequence correlation
int rxy = bsequence_correlate(_q->bpn, _q->brx);
float r = 2.0f*(float)rxy / (float)(_q->pnsequence_len*8) - 1.0f;
// check threshold
if ( fabsf(r) > 0.8f ) {
#if DEBUG_BPACKETSYNC
printf("p/n sequence found!, rxy = %8.4f\n", r);
#endif
// flip polarity of bits if correlation is negative
_q->byte_mask = r > 0 ? 0x00 : 0xff;
// switch operational mode
_q->state = BPACKETSYNC_STATE_RXHEADER;
}
}
int main(int argc, char*argv[]) {
// options
unsigned int m=5; // shift register length, n=2^m - 1
char filename[64] = ""; // output filename
int dopt;
while ((dopt = getopt(argc,argv,"uhm:f:")) != EOF) {
switch (dopt) {
case 'u':
case 'h': usage(); return 0;
case 'm': m = atoi(optarg); break;
case 'f':
// copy output filename string
strncpy(filename,optarg,64);
filename[63] = '\0';
break;
default:
exit(1);
}
}
// ensure output filename is set
if (strcmp(filename,"")==0) {
fprintf(stderr,"error: %s, filename not set\n", argv[0]);
exit(1);
}
// validate m
if (m < 2) {
fprintf(stderr,"error: %s, m is out of range\n", argv[0]);
exit(1);
}
// create and initialize m-sequence
msequence ms = msequence_create_default(m);
msequence_print(ms);
unsigned int n = msequence_get_length(ms);
unsigned int sequence[n]; // sequence
signed int rxx[n]; // auto-correlation
// initialize sequence
unsigned int i;
for (i=0; i<n; i++)
sequence[i] = msequence_advance(ms);
// reset sequence
msequence_reset(ms);
// create and initialize first binary sequence on m-sequence
bsequence bs1 = bsequence_create(n);
bsequence_init_msequence(bs1, ms);
// create and initialize second binary sequence on same m-sequence
bsequence bs2 = bsequence_create(n);
bsequence_init_msequence(bs2, ms);
// when sequences are aligned, autocorrelation is equal to length
unsigned int k=0;
rxx[k++] = 2*bsequence_correlate(bs1, bs2) - n;
// when sequences are misaligned, autocorrelation is equal to -1
for (i=0; i<n-1; i++) {
bsequence_push(bs2, msequence_advance(ms));
rxx[k++] = 2*bsequence_correlate(bs1, bs2)-n;
}
// clean up memory
bsequence_destroy(bs1);
bsequence_destroy(bs2);
msequence_destroy(ms);
//
// generate auto-correlation plot
//
// open output file
FILE * fid = fopen(filename,"w");
if (fid == NULL) {
fprintf(stderr,"error: %s, could not open file \"%s\" for writing.\n", argv[0], filename);
exit(1);
}
// print header
fprintf(fid,"# %s : auto-generated file (do not edit)\n", filename);
fprintf(fid,"# invoked as :");
for (i=0; i<argc; i++)
fprintf(fid," %s",argv[i]);
fprintf(fid,"reset\n");
fprintf(fid,"set terminal postscript eps enhanced color solid rounded\n");
fprintf(fid,"set xrange [-1:%u];\n", n+1);
fprintf(fid,"set size ratio 0.3\n");
fprintf(fid,"set xlabel 'delay (number of samples)'\n");
fprintf(fid,"set nokey # disable legned\n");
//fprintf(fid,"set grid xtics ytics\n");
//fprintf(fid,"set grid linetype 1 linecolor rgb '%s' lw 1\n", LIQUID_DOC_COLOR_GRID);
fprintf(fid,"set multiplot layout 2,1 scale 1.0,1.0\n");
fprintf(fid,"# sequence\n");
fprintf(fid,"set ylabel 'sequence'\n");
fprintf(fid,"set yrange [-0.1:1.1]\n");
fprintf(fid,"plot '-' using 1:2 with steps linetype 1 linewidth 4 linecolor rgb '%s'\n",LIQUID_DOC_COLOR_BLUE);
for (i=0; i<n; i++) {
fprintf(fid," %6u %6u\n", i, sequence[i]);
}
fprintf(fid,"e\n");
fprintf(fid,"# auto-correlation\n");
fprintf(fid,"set ylabel 'auto-correlation'\n");
fprintf(fid,"set yrange [%f:1.1]\n", -5.0f / (float)n);
fprintf(fid,"plot '-' using 1:2 with lines linetype 1 linewidth 4 linecolor rgb '%s'\n",LIQUID_DOC_COLOR_GREEN);
for (i=0; i<n; i++) {
fprintf(fid," %6u %12.4e\n", i, (float)rxx[i] / (float)n);
}
fprintf(fid,"e\n");
fprintf(fid,"unset multiplot\n");
// close output file
fclose(fid);
printf("results written to %s.\n", filename);
return 0;
}
