X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=gnuradio-core%2Fsrc%2Flib%2Ffilter%2Fgr_pfb_clock_sync_ccf.cc;h=56ad24ffcf64ed6814e61c34a183da2291d2361f;hb=1bce7d89c205502ed933add1a5e97c86db0b0d80;hp=79779c91cf6ad206e425077c64194f21a0cb970b;hpb=294be2757673d2be26cdb8a51acecfbc36f6b2fb;p=debian%2Fgnuradio diff --git a/gnuradio-core/src/lib/filter/gr_pfb_clock_sync_ccf.cc b/gnuradio-core/src/lib/filter/gr_pfb_clock_sync_ccf.cc index 79779c91..56ad24ff 100644 --- a/gnuradio-core/src/lib/filter/gr_pfb_clock_sync_ccf.cc +++ b/gnuradio-core/src/lib/filter/gr_pfb_clock_sync_ccf.cc @@ -33,37 +33,44 @@ #include #include -gr_pfb_clock_sync_ccf_sptr gr_make_pfb_clock_sync_ccf (float sps, float gain, +gr_pfb_clock_sync_ccf_sptr gr_make_pfb_clock_sync_ccf (double sps, float gain, const std::vector &taps, unsigned int filter_size, - float init_phase) + float init_phase, + float max_rate_deviation) { return gr_pfb_clock_sync_ccf_sptr (new gr_pfb_clock_sync_ccf (sps, gain, taps, filter_size, - init_phase)); + init_phase, + max_rate_deviation)); } - -gr_pfb_clock_sync_ccf::gr_pfb_clock_sync_ccf (float sps, float gain, +int ios[] = {sizeof(gr_complex), sizeof(float), sizeof(float), sizeof(float)}; +std::vector iosig(ios, ios+sizeof(ios)/sizeof(int)); +gr_pfb_clock_sync_ccf::gr_pfb_clock_sync_ccf (double sps, float gain, const std::vector &taps, unsigned int filter_size, - float init_phase) + float init_phase, + float max_rate_deviation) : gr_block ("pfb_clock_sync_ccf", gr_make_io_signature (1, 1, sizeof(gr_complex)), - gr_make_io_signature2 (1, 2, sizeof(gr_complex), sizeof(float))), - d_updated (false), d_sps(sps) + gr_make_io_signaturev (1, 4, iosig)), + d_updated (false), d_nfilters(filter_size), + d_max_dev(max_rate_deviation), d_start_count(0) { d_nfilters = filter_size; + d_sps = floor(sps); // Store the last filter between calls to work // The accumulator keeps track of overflow to increment the stride correctly. // set it here to the fractional difference based on the initial phaes // assert(init_phase <= 2*M_PI); - set_gain(gain); + set_alpha(gain); + set_beta(0.25*gain*gain); d_k = d_nfilters / 2; - d_rate = 0; - d_start_count = 0; - + d_rate = (sps-floor(sps))*(double)d_nfilters; + printf("RATE: %f\n", d_rate); + d_filtnum = (int)floor(d_k); d_filters = std::vector(d_nfilters); d_diff_filters = std::vector(d_nfilters); @@ -94,7 +101,7 @@ gr_pfb_clock_sync_ccf::set_taps (const std::vector &newtaps, std::vector< std::vector > &ourtaps, std::vector &ourfilter) { - unsigned int i,j; + int i,j; unsigned int ntaps = newtaps.size(); d_taps_per_filter = (unsigned int)ceil((double)ntaps/(double)d_nfilters); @@ -113,13 +120,15 @@ gr_pfb_clock_sync_ccf::set_taps (const std::vector &newtaps, // Partition the filter for(i = 0; i < d_nfilters; i++) { // Each channel uses all d_taps_per_filter with 0's if not enough taps to fill out - ourtaps[i] = std::vector(d_taps_per_filter, 0); + //ourtaps[i] = std::vector(d_taps_per_filter, 0); + ourtaps[d_nfilters-1-i] = std::vector(d_taps_per_filter, 0); for(j = 0; j < d_taps_per_filter; j++) { - ourtaps[i][j] = tmp_taps[i + j*d_nfilters]; // add taps to channels in reverse order + ourtaps[d_nfilters - 1 - i][j] = tmp_taps[i + j*d_nfilters]; } // Build a filter for each channel and add it's taps to it - ourfilter[i]->set_taps(ourtaps[i]); + //ourfilter[i]->set_taps(ourtaps[i]); + ourfilter[i]->set_taps(ourtaps[d_nfilters-1-i]); } // Set the history to ensure enough input items for each filter @@ -154,26 +163,30 @@ void gr_pfb_clock_sync_ccf::print_taps() { unsigned int i, j; + printf("[ "); for(i = 0; i < d_nfilters; i++) { - printf("filter[%d]: [%.4e, ", i, d_taps[i][0]); + printf("[%.4e, ", d_taps[i][0]); for(j = 1; j < d_taps_per_filter-1; j++) { printf("%.4e,", d_taps[i][j]); } - printf("%.4e]\n", d_taps[i][j]); + printf("%.4e],", d_taps[i][j]); } + printf(" ]\n"); } void gr_pfb_clock_sync_ccf::print_diff_taps() { unsigned int i, j; + printf("[ "); for(i = 0; i < d_nfilters; i++) { - printf("filter[%d]: [%.4e, ", i, d_dtaps[i][0]); + printf("[%.4e, ", d_dtaps[i][0]); for(j = 1; j < d_taps_per_filter-1; j++) { printf("%.4e,", d_dtaps[i][j]); } - printf("%.4e]\n", d_dtaps[i][j]); + printf("%.4e],", d_dtaps[i][j]); } + printf(" ]\n"); } @@ -224,50 +237,66 @@ gr_pfb_clock_sync_ccf::general_work (int noutput_items, // We need this many to process one output int nrequired = ninput_items[0] - d_taps_per_filter; - int i = 0, count = d_start_count; - float error = 0; + int i = 0, count = (int)floor(d_sample_num); + float error, error_r, error_i; // produce output as long as we can and there are enough input samples while((i < noutput_items) && (count < nrequired)) { - int filtnum = (int)d_k; - out[i] = d_filters[filtnum]->filter(&in[count]); - error = (out[i] * d_diff_filters[filtnum]->filter(&in[count])).real(); + d_filtnum = (int)floor(d_k); - d_k = d_k + d_alpha*error + d_rate; - d_rate = d_rate + d_beta*error; - while(d_k >= d_nfilters) { + // Keep the current filter number in [0, d_nfilters] + // If we've run beyond the last filter, wrap around and go to next sample + // If we've go below 0, wrap around and go to previous sample + while(d_filtnum >= d_nfilters) { d_k -= d_nfilters; - count++; + d_filtnum -= d_nfilters; + d_sample_num += 1.0; } - while(d_k < 0) { + while(d_filtnum < 0) { d_k += d_nfilters; - count--; + d_filtnum += d_nfilters; + d_sample_num -= 1.0; } + + out[i] = d_filters[d_filtnum]->filter(&in[count]); + gr_complex diff = d_diff_filters[d_filtnum]->filter(&in[count]); + error_r = out[i].real() * diff.real(); + error_i = out[i].imag() * diff.imag(); + error = error_i + error_r; + + d_k = d_k + d_alpha*error + d_rate; + d_rate = d_rate + d_beta*error; + + // Keep our rate within a good range + d_rate = gr_branchless_clip(d_rate, d_max_dev); i++; - count += d_sps; + d_sample_num += d_sps; + count = (int)floor(d_sample_num); if(output_items.size() > 2) { err[i] = error; outrate[i] = d_rate; outk[i] = d_k; } - - //printf("error: %f k: %f rate: %f\n", - // error, d_k, d_rate); } // Set the start index at the next entrance to the work function // if we stop because we run out of input items, jump ahead in the // next call to work. Otherwise, we can start at zero. + /* if(count > nrequired) { - d_start_count = count - (nrequired); + //d_start_count = count - (nrequired); + d_sample_num -= nrequired; consume_each(ninput_items[0]-d_taps_per_filter); } else { - d_start_count = 0; + d_sample_num -= floor(d_sample_num); consume_each(count); } - + */ + d_sample_num -= floor(d_sample_num); + consume_each(count); + return i; }