gnuradio.analog: Synchronizers

gnuradio.analog.pll_carriertracking_cc(float loop_bw, float max_freq, float min_freq) → pll_carriertracking_cc_sptr

Implements a PLL which locks to the input frequency and outputs the input signal mixed with that carrier.

Input stream 0: complex Output stream 0: complex

This PLL locks onto a [possibly noisy] reference carrier on the input and outputs that signal, downconverted to DC

All settings max_freq and min_freq are in terms of radians per sample, NOT HERTZ. The loop bandwidth determins the lock range and should be set around pi/200 2pi/100.

Constructor Specific Documentation:

Parameters:

• loop_bw –
• max_freq –
• min_freq –

pll_carriertracking_cc_sptr.active_thread_priority(pll_carriertracking_cc_sptr self) → int

pll_carriertracking_cc_sptr.advance_loop(pll_carriertracking_cc_sptr self, float error)

pll_carriertracking_cc_sptr.declare_sample_delay(pll_carriertracking_cc_sptr self, int which, int delay)

declare_sample_delay(pll_carriertracking_cc_sptr self, unsigned int delay)

pll_carriertracking_cc_sptr.frequency_limit(pll_carriertracking_cc_sptr self)

pll_carriertracking_cc_sptr.get_alpha(pll_carriertracking_cc_sptr self) → float

pll_carriertracking_cc_sptr.get_beta(pll_carriertracking_cc_sptr self) → float

pll_carriertracking_cc_sptr.get_damping_factor(pll_carriertracking_cc_sptr self) → float

pll_carriertracking_cc_sptr.get_frequency(pll_carriertracking_cc_sptr self) → float

pll_carriertracking_cc_sptr.get_loop_bandwidth(pll_carriertracking_cc_sptr self) → float

pll_carriertracking_cc_sptr.get_max_freq(pll_carriertracking_cc_sptr self) → float

pll_carriertracking_cc_sptr.get_min_freq(pll_carriertracking_cc_sptr self) → float

pll_carriertracking_cc_sptr.get_phase(pll_carriertracking_cc_sptr self) → float

pll_carriertracking_cc_sptr.lock_detector(pll_carriertracking_cc_sptr self) → bool

pll_carriertracking_cc_sptr.message_subscribers(pll_carriertracking_cc_sptr self, swig_int_ptr which_port) → swig_int_ptr

pll_carriertracking_cc_sptr.min_noutput_items(pll_carriertracking_cc_sptr self) → int

pll_carriertracking_cc_sptr.pc_input_buffers_full_avg(pll_carriertracking_cc_sptr self, int which) → float

pc_input_buffers_full_avg(pll_carriertracking_cc_sptr self) -> pmt_vector_float

pll_carriertracking_cc_sptr.pc_noutput_items_avg(pll_carriertracking_cc_sptr self) → float

pll_carriertracking_cc_sptr.pc_nproduced_avg(pll_carriertracking_cc_sptr self) → float

pll_carriertracking_cc_sptr.pc_output_buffers_full_avg(pll_carriertracking_cc_sptr self, int which) → float

pc_output_buffers_full_avg(pll_carriertracking_cc_sptr self) -> pmt_vector_float

pll_carriertracking_cc_sptr.pc_throughput_avg(pll_carriertracking_cc_sptr self) → float

pll_carriertracking_cc_sptr.pc_work_time_avg(pll_carriertracking_cc_sptr self) → float

pll_carriertracking_cc_sptr.pc_work_time_total(pll_carriertracking_cc_sptr self) → float

pll_carriertracking_cc_sptr.phase_wrap(pll_carriertracking_cc_sptr self)

pll_carriertracking_cc_sptr.sample_delay(pll_carriertracking_cc_sptr self, int which) → unsigned int

pll_carriertracking_cc_sptr.set_alpha(pll_carriertracking_cc_sptr self, float alpha)

pll_carriertracking_cc_sptr.set_beta(pll_carriertracking_cc_sptr self, float beta)

pll_carriertracking_cc_sptr.set_damping_factor(pll_carriertracking_cc_sptr self, float df)

pll_carriertracking_cc_sptr.set_frequency(pll_carriertracking_cc_sptr self, float freq)

pll_carriertracking_cc_sptr.set_lock_threshold(pll_carriertracking_cc_sptr self, float arg2) → float

pll_carriertracking_cc_sptr.set_loop_bandwidth(pll_carriertracking_cc_sptr self, float bw)

pll_carriertracking_cc_sptr.set_max_freq(pll_carriertracking_cc_sptr self, float freq)

pll_carriertracking_cc_sptr.set_min_freq(pll_carriertracking_cc_sptr self, float freq)

pll_carriertracking_cc_sptr.set_min_noutput_items(pll_carriertracking_cc_sptr self, int m)

pll_carriertracking_cc_sptr.set_phase(pll_carriertracking_cc_sptr self, float phase)

pll_carriertracking_cc_sptr.set_thread_priority(pll_carriertracking_cc_sptr self, int priority) → int

pll_carriertracking_cc_sptr.squelch_enable(pll_carriertracking_cc_sptr self, bool arg2) → bool

pll_carriertracking_cc_sptr.thread_priority(pll_carriertracking_cc_sptr self) → int

pll_carriertracking_cc_sptr.update_gains(pll_carriertracking_cc_sptr self)

gnuradio.analog.pll_freqdet_cf(float loop_bw, float max_freq, float min_freq) → pll_freqdet_cf_sptr

Implements a PLL which locks to the input frequency and outputs an estimate of that frequency. Useful for FM Demod.

Input stream 0: complex Output stream 0: float

This PLL locks onto a [possibly noisy] reference carrier on the input and outputs an estimate of that frequency in radians per sample. All settings max_freq and min_freq are in terms of radians per sample, NOT HERTZ. The loop bandwidth determins the lock range and should be set around pi/200 2pi/100.

Constructor Specific Documentation:

Parameters:

• loop_bw –
• max_freq –
• min_freq –

pll_freqdet_cf_sptr.active_thread_priority(pll_freqdet_cf_sptr self) → int

pll_freqdet_cf_sptr.advance_loop(pll_freqdet_cf_sptr self, float error)

pll_freqdet_cf_sptr.declare_sample_delay(pll_freqdet_cf_sptr self, int which, int delay)

declare_sample_delay(pll_freqdet_cf_sptr self, unsigned int delay)

pll_freqdet_cf_sptr.frequency_limit(pll_freqdet_cf_sptr self)

pll_freqdet_cf_sptr.get_alpha(pll_freqdet_cf_sptr self) → float

pll_freqdet_cf_sptr.get_beta(pll_freqdet_cf_sptr self) → float

pll_freqdet_cf_sptr.get_damping_factor(pll_freqdet_cf_sptr self) → float

pll_freqdet_cf_sptr.get_frequency(pll_freqdet_cf_sptr self) → float

pll_freqdet_cf_sptr.get_loop_bandwidth(pll_freqdet_cf_sptr self) → float

pll_freqdet_cf_sptr.get_max_freq(pll_freqdet_cf_sptr self) → float

pll_freqdet_cf_sptr.get_min_freq(pll_freqdet_cf_sptr self) → float

pll_freqdet_cf_sptr.get_phase(pll_freqdet_cf_sptr self) → float

pll_freqdet_cf_sptr.message_subscribers(pll_freqdet_cf_sptr self, swig_int_ptr which_port) → swig_int_ptr

pll_freqdet_cf_sptr.min_noutput_items(pll_freqdet_cf_sptr self) → int

pll_freqdet_cf_sptr.pc_input_buffers_full_avg(pll_freqdet_cf_sptr self, int which) → float

pc_input_buffers_full_avg(pll_freqdet_cf_sptr self) -> pmt_vector_float

pll_freqdet_cf_sptr.pc_noutput_items_avg(pll_freqdet_cf_sptr self) → float

pll_freqdet_cf_sptr.pc_nproduced_avg(pll_freqdet_cf_sptr self) → float

pll_freqdet_cf_sptr.pc_output_buffers_full_avg(pll_freqdet_cf_sptr self, int which) → float

pc_output_buffers_full_avg(pll_freqdet_cf_sptr self) -> pmt_vector_float

pll_freqdet_cf_sptr.pc_throughput_avg(pll_freqdet_cf_sptr self) → float

pll_freqdet_cf_sptr.pc_work_time_avg(pll_freqdet_cf_sptr self) → float

pll_freqdet_cf_sptr.pc_work_time_total(pll_freqdet_cf_sptr self) → float

pll_freqdet_cf_sptr.phase_wrap(pll_freqdet_cf_sptr self)

pll_freqdet_cf_sptr.sample_delay(pll_freqdet_cf_sptr self, int which) → unsigned int

pll_freqdet_cf_sptr.set_alpha(pll_freqdet_cf_sptr self, float alpha)

pll_freqdet_cf_sptr.set_beta(pll_freqdet_cf_sptr self, float beta)

pll_freqdet_cf_sptr.set_damping_factor(pll_freqdet_cf_sptr self, float df)

pll_freqdet_cf_sptr.set_frequency(pll_freqdet_cf_sptr self, float freq)

pll_freqdet_cf_sptr.set_loop_bandwidth(pll_freqdet_cf_sptr self, float bw)

pll_freqdet_cf_sptr.set_max_freq(pll_freqdet_cf_sptr self, float freq)

pll_freqdet_cf_sptr.set_min_freq(pll_freqdet_cf_sptr self, float freq)

pll_freqdet_cf_sptr.set_min_noutput_items(pll_freqdet_cf_sptr self, int m)

pll_freqdet_cf_sptr.set_phase(pll_freqdet_cf_sptr self, float phase)

pll_freqdet_cf_sptr.set_thread_priority(pll_freqdet_cf_sptr self, int priority) → int

pll_freqdet_cf_sptr.thread_priority(pll_freqdet_cf_sptr self) → int

pll_freqdet_cf_sptr.update_gains(pll_freqdet_cf_sptr self)

gnuradio.analog.pll_refout_cc(float loop_bw, float max_freq, float min_freq) → pll_refout_cc_sptr

Implements a PLL which locks to the input frequency and outputs a carrier.

Input stream 0: complex Output stream 0: complex

This PLL locks onto a [possibly noisy] reference carrier on the input and outputs a clean version which is phase and frequency aligned to it.

All settings max_freq and min_freq are in terms of radians per sample, NOT HERTZ. The loop bandwidth determins the lock range and should be set around pi/200 2pi/100.

Constructor Specific Documentation:

Parameters:

• loop_bw –
• max_freq –
• min_freq –

pll_refout_cc_sptr.active_thread_priority(pll_refout_cc_sptr self) → int

pll_refout_cc_sptr.advance_loop(pll_refout_cc_sptr self, float error)

pll_refout_cc_sptr.declare_sample_delay(pll_refout_cc_sptr self, int which, int delay)

declare_sample_delay(pll_refout_cc_sptr self, unsigned int delay)

pll_refout_cc_sptr.frequency_limit(pll_refout_cc_sptr self)

pll_refout_cc_sptr.get_alpha(pll_refout_cc_sptr self) → float

pll_refout_cc_sptr.get_beta(pll_refout_cc_sptr self) → float

pll_refout_cc_sptr.get_damping_factor(pll_refout_cc_sptr self) → float

pll_refout_cc_sptr.get_frequency(pll_refout_cc_sptr self) → float

pll_refout_cc_sptr.get_loop_bandwidth(pll_refout_cc_sptr self) → float

pll_refout_cc_sptr.get_max_freq(pll_refout_cc_sptr self) → float

pll_refout_cc_sptr.get_min_freq(pll_refout_cc_sptr self) → float

pll_refout_cc_sptr.get_phase(pll_refout_cc_sptr self) → float

pll_refout_cc_sptr.message_subscribers(pll_refout_cc_sptr self, swig_int_ptr which_port) → swig_int_ptr

pll_refout_cc_sptr.min_noutput_items(pll_refout_cc_sptr self) → int

pll_refout_cc_sptr.pc_input_buffers_full_avg(pll_refout_cc_sptr self, int which) → float

pc_input_buffers_full_avg(pll_refout_cc_sptr self) -> pmt_vector_float

pll_refout_cc_sptr.pc_noutput_items_avg(pll_refout_cc_sptr self) → float

pll_refout_cc_sptr.pc_nproduced_avg(pll_refout_cc_sptr self) → float

pll_refout_cc_sptr.pc_output_buffers_full_avg(pll_refout_cc_sptr self, int which) → float

pc_output_buffers_full_avg(pll_refout_cc_sptr self) -> pmt_vector_float

pll_refout_cc_sptr.pc_throughput_avg(pll_refout_cc_sptr self) → float

pll_refout_cc_sptr.pc_work_time_avg(pll_refout_cc_sptr self) → float

pll_refout_cc_sptr.pc_work_time_total(pll_refout_cc_sptr self) → float

pll_refout_cc_sptr.phase_wrap(pll_refout_cc_sptr self)

pll_refout_cc_sptr.sample_delay(pll_refout_cc_sptr self, int which) → unsigned int

pll_refout_cc_sptr.set_alpha(pll_refout_cc_sptr self, float alpha)

pll_refout_cc_sptr.set_beta(pll_refout_cc_sptr self, float beta)

pll_refout_cc_sptr.set_damping_factor(pll_refout_cc_sptr self, float df)

pll_refout_cc_sptr.set_frequency(pll_refout_cc_sptr self, float freq)

pll_refout_cc_sptr.set_loop_bandwidth(pll_refout_cc_sptr self, float bw)

pll_refout_cc_sptr.set_max_freq(pll_refout_cc_sptr self, float freq)

pll_refout_cc_sptr.set_min_freq(pll_refout_cc_sptr self, float freq)

pll_refout_cc_sptr.set_min_noutput_items(pll_refout_cc_sptr self, int m)

pll_refout_cc_sptr.set_phase(pll_refout_cc_sptr self, float phase)

pll_refout_cc_sptr.set_thread_priority(pll_refout_cc_sptr self, int priority) → int

pll_refout_cc_sptr.thread_priority(pll_refout_cc_sptr self) → int

pll_refout_cc_sptr.update_gains(pll_refout_cc_sptr self)