Frequency Lock Loop using band-edge filters.
The frequency lock loop derives a band-edge filter that covers the upper and lower bandwidths of a digitally-modulated signal. The bandwidth range is determined by the excess bandwidth (e.g., rolloff factor) of the modulated signal. The placement in frequency of the band-edges is determined by the oversampling ratio (number of samples per symbol) and the excess bandwidth. The size of the filters should be fairly large so as to average over a number of symbols.
The FLL works by filtering the upper and lower band edges into x_u(t) and x_l(t), respectively. These are combined to form cc(t) = x_u(t) + x_l(t) and ss(t) = x_u(t) - x_l(t). Combining these to form the signal e(t) = Re{cc(t) imes ss(t)^*} (where ^* is the complex conjugate) provides an error signal at the DC term that is directly proportional to the carrier frequency. We then make a second-order loop using the error signal that is the running average of e(t).
In practice, the above equation can be simplified by just comparing the absolute value squared of the output of both filters: abs(x_l(t))^2 - abs(x_u(t))^2 = norm(x_l(t)) - norm(x_u(t)).
In theory, the band-edge filter is the derivative of the matched filter in frequency, (H_be(f) = frac{H(f)}{df}). In practice, this comes down to a quarter sine wave at the point of the matched filter’s rolloff (if it’s a raised-cosine, the derivative of a cosine is a sine). Extend this sine by another quarter wave to make a half wave around the band-edges is equivalent in time to the sum of two sinc functions. The baseband filter fot the band edges is therefore derived from this sum of sincs. The band edge filters are then just the baseband signal modulated to the correct place in frequency. All of these calculations are done in the ‘design_filter’ function.
Note
We use FIR filters here because the filters have to have a flat phase response over the entire frequency range to allow their comparisons to be valid.
It is very important that the band edge filters be the derivatives of the pulse shaping filter, and that they be linear phase. Otherwise, the variance of the error will be very large.
Constructor Specific Documentation:
Make an FLL block.
| Parameters: |
|
|---|
declare_sample_delay(fll_band_edge_cc_sptr self, unsigned int delay)
Returns the number of taps of the filter.
pc_input_buffers_full_avg(fll_band_edge_cc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(fll_band_edge_cc_sptr self) -> pmt_vector_float
Print the taps to screen.
Returns the rolloff factor used for the filter.
Returns the number of sampler per symbol used for the filter.
Set the number of taps in the filter.
This sets the number of taps in the band-edge filters. Setting this will force a recalculation of the filter taps.
This should be about the same number of taps used in the transmitter’s shaping filter and also not very large. A large number of taps will result in a large delay between input and frequency estimation, and so will not be as accurate. Between 30 and 70 taps is usual.
Set the rolloff factor of the shaping filter.
This sets the rolloff factor that is used in the pulse shaping filter and is used to calculate the filter taps. Changing this will force a recalculation of the filter taps.
This should be the same value that is used in the transmitter’s pulse shaping filter. It must be between 0 and 1 and is usually between 0.2 and 0.5 (where 0.22 and 0.35 are commonly used values).
Set the number of samples per symbol.
Set’s the number of samples per symbol the system should use. This value is uesd to calculate the filter taps and will force a recalculation.
Implements a kurtosis-based adaptive equalizer on complex stream.
Warning
This block does not yet work.
“Y. Guo, J. Zhao, Y. Sun, “Sign kurtosis maximization based blind equalization algorithm,” IEEE Conf. on Control, Automation, Robotics and Vision, Vol. 3, Dec. 2004, pp. 2052 - 2057.”
Constructor Specific Documentation:
| Parameters: |
|
|---|
declare_sample_delay(kurtotic_equalizer_cc_sptr self, unsigned int delay)
pc_input_buffers_full_avg(kurtotic_equalizer_cc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(kurtotic_equalizer_cc_sptr self) -> pmt_vector_float
Least-Mean-Square Decision Directed Equalizer (complex in/out)
This block implements an LMS-based decision-directed equalizer. It uses a set of weights, w, to correlate against the inputs, u, and a decisions is then made from this output. The error in the decision is used to update the weight vector.
y[n] = conj(w[n]) u[n] d[n] = decision(y[n]) e[n] = d[n] - y[n] w[n+1] = w[n] + mu u[n] conj(e[n])
Where mu is a gain value (between 0 and 1 and usualy small, around 0.001 - 0.01.
This block uses the digital_constellation object for making the decision from y[n]. Create the constellation object for whatever constellation is to be used and pass in the object. In Python, you can use something like:
self.constellation = digital.constellation_qpsk()
To create a QPSK constellation (see the digital_constellation block for more details as to what constellations are available or how to create your own). You then pass the object to this block as an sptr, or using “self.constellation.base()”.
The theory for this algorithm can be found in Chapter 9 of: S. Haykin, Adaptive Filter Theory, Upper Saddle River, NJ: Prentice Hall, 1996.
Constructor Specific Documentation:
Make an LMS decision-directed equalizer
| Parameters: |
|
|---|
declare_sample_delay(lms_dd_equalizer_cc_sptr self, unsigned int delay)
pc_input_buffers_full_avg(lms_dd_equalizer_cc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(lms_dd_equalizer_cc_sptr self) -> pmt_vector_float
This block takes care of receiving M-PSK modulated signals through phase, frequency, and symbol synchronization.
It performs carrier frequency and phase locking as well as symbol timing recovery. It works with (D)BPSK, (D)QPSK, and (D)8PSK as tested currently. It should also work for OQPSK and PI/4 DQPSK.
The phase and frequency synchronization are based on a Costas loop that finds the error of the incoming signal point compared to its nearest constellation point. The frequency and phase of the NCO are updated according to this error. There are optimized phase error detectors for BPSK and QPSK, but 8PSK is done using a brute-force computation of the constellation points to find the minimum.
The symbol synchronization is done using a modified Mueller and Muller circuit from the paper:
“G. R. Danesfahani, T. G. Jeans, “Optimisation of modified Mueller and Muller algorithm,” Electronics Letters, Vol. 31, no. 13, 22 June 1995, pp. 1032 - 1033.”
This circuit interpolates the downconverted sample (using the NCO developed by the Costas loop) every mu samples, then it finds the sampling error based on this and the past symbols and the decision made on the samples. Like the phase error detector, there are optimized decision algorithms for BPSK and QPKS, but 8PSK uses another brute force computation against all possible symbols. The modifications to the M&M used here reduce self-noise.
Constructor Specific Documentation:
Make a M-PSK receiver block.
The constructor also chooses which phase detector and decision maker to use in the work loop based on the value of M.
| Parameters: |
|
|---|
declare_sample_delay(mpsk_receiver_cc_sptr self, unsigned int delay)
Returns mu gain factor.
Returns omega gain factor.
Returns the relative omega limit.
Returns the modulation order (M) currently set.
Returns current value of mu.
Returns current value of omega.
pc_input_buffers_full_avg(mpsk_receiver_cc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(mpsk_receiver_cc_sptr self) -> pmt_vector_float
Sets value for mu gain factor.
Sets value for omega gain factor.
Sets the relative omega limit and resets omega min/max values.
Sets the modulation order (M) currently.
Sets value of mu.
Sets value of omega and its min and max values.
Sets value of theta.
Returns current value of theta.
A block for computing SNR of a signal.
This block can be used to monitor and retrieve estimations of the signal SNR. It is designed to work in a flowgraph and passes all incoming data along to its output.
The block is designed for use with M-PSK signals especially. The type of estimator is specified as the parameter in the constructor. The estimators tend to trade off performance for accuracy, although experimentation should be done to figure out the right approach for a given implementation. Further, the current set of estimators are designed and proven theoretically under AWGN conditions; some amount of error should be assumed and/or estimated for real channel conditions.
Constructor Specific Documentation:
Factory function returning shared pointer of this class
| Parameters: |
|
|---|
Get the running-average coefficient.
declare_sample_delay(mpsk_snr_est_cc_sptr self, unsigned int delay)
pc_input_buffers_full_avg(mpsk_snr_est_cc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(mpsk_snr_est_cc_sptr self) -> pmt_vector_float
Set the running-average coefficient.
Set the number of samples between SNR tags.
Set type of estimator to use.
Return the estimated signal-to-noise ratio in decibels.
Return how many samples between SNR tags.
Mueller and M?ller (M&M) based clock recovery block with complex input, complex output.
This implements the Mueller and M?ller (M&M) discrete-time error-tracking synchronizer.
The complex version here is based on: Modified Mueller and Muller clock recovery circuit:
Constructor Specific Documentation:
Make a M&M clock recovery block.
| Parameters: |
|
|---|
declare_sample_delay(clock_recovery_mm_cc_sptr self, unsigned int delay)
pc_input_buffers_full_avg(clock_recovery_mm_cc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(clock_recovery_mm_cc_sptr self) -> pmt_vector_float
Mueller and M?ller (M&M) based clock recovery block with float input, float output.
This implements the Mueller and M?ller (M&M) discrete-time error-tracking synchronizer.
See “Digital Communication Receivers: Synchronization, Channel Estimation and Signal Processing” by Heinrich Meyr, Marc Moeneclaey, & Stefan Fechtel. ISBN 0-471-50275-8.
Constructor Specific Documentation:
Make a M&M clock recovery block.
| Parameters: |
|
|---|
declare_sample_delay(clock_recovery_mm_ff_sptr self, unsigned int delay)
pc_input_buffers_full_avg(clock_recovery_mm_ff_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(clock_recovery_mm_ff_sptr self) -> pmt_vector_float
Constellation Decoder.
Decode a constellation’s points from a complex space to (unpacked) bits based on the map of the object.
Constructor Specific Documentation:
Make constellation decoder block.
| Parameters: | constellation – A constellation derived from class ‘constellation’. Use base() method to get a shared pointer to this base class type. |
|---|
declare_sample_delay(constellation_decoder_cb_sptr self, unsigned int delay)
pc_input_buffers_full_avg(constellation_decoder_cb_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(constellation_decoder_cb_sptr self) -> pmt_vector_float
This block makes hard decisions about the received symbols (using a constellation object) and also fine tunes phase synchronization.
The phase and frequency synchronization are based on a Costas loop that finds the error of the incoming signal point compared to its nearest constellation point. The frequency and phase of the NCO are updated according to this error.
Constructor Specific Documentation:
Constructs a constellation receiver that (phase/fine freq) synchronizes and decodes constellation points specified by a constellation object.
| Parameters: |
|
|---|
declare_sample_delay(constellation_receiver_cb_sptr self, unsigned int delay)
pc_input_buffers_full_avg(constellation_receiver_cb_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(constellation_receiver_cb_sptr self) -> pmt_vector_float
Examine input for specified access code, one bit at a time.
input: stream of bits, 1 bit per input byte (data in LSB) output: stream of bits, 2 bits per output byte (data in LSB, flag in next higher bit)
Each output byte contains two valid bits, the data bit, and the flag bit. The LSB (bit 0) is the data bit, and is the original input data, delayed 64 bits. Bit 1 is the flag bit and is 1 if the corresponding data bit is the first data bit following the access code. Otherwise the flag bit is 0.
Constructor Specific Documentation:
Make a correlate_access_code block.
| Parameters: |
|
|---|
declare_sample_delay(correlate_access_code_bb_sptr self, unsigned int delay)
pc_input_buffers_full_avg(correlate_access_code_bb_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(correlate_access_code_bb_sptr self) -> pmt_vector_float
Set a new access code.
A Costas loop carrier recovery module.
The Costas loop locks to the center frequency of a signal and downconverts it to baseband.
More details can be found online:
J. Feigin, “Practical Costas loop design: Designing a simple and inexpensive BPSK Costas loop carrier recovery circuit,” RF signal processing, pp. 20-36, 2002.
The Costas loop can have two output streams:
Constructor Specific Documentation:
Make a Costas loop carrier recovery block.
| Parameters: |
|
|---|
declare_sample_delay(costas_loop_cc_sptr self, unsigned int delay)
Returns the current value of the loop error.
pc_input_buffers_full_avg(costas_loop_cc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(costas_loop_cc_sptr self) -> pmt_vector_float
Implements constant modulus adaptive filter on complex stream.
The error value and tap update equations (for p=2) can be found in:
D. Godard, “Self-Recovering Equalization and Carrier Tracking in Two-Dimensional Data Communication Systems,” IEEE Transactions on Communications, Vol. 28, No. 11, pp. 1867 - 1875, 1980.
Constructor Specific Documentation:
Make a CMA Equalizer block
| Parameters: |
|
|---|
declare_sample_delay(cma_equalizer_cc_sptr self, unsigned int delay)
pc_input_buffers_full_avg(cma_equalizer_cc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(cma_equalizer_cc_sptr self) -> pmt_vector_float
Slice float binary symbol producing 1 bit output.
Constructor Specific Documentation:
Make binary symbol slicer block.
declare_sample_delay(binary_slicer_fb_sptr self, unsigned int delay)
pc_input_buffers_full_avg(binary_slicer_fb_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(binary_slicer_fb_sptr self) -> pmt_vector_float
Make GMSK modulator block.
The type is GAUSSIAN and the modulation index for GMSK is 0.5. This are populated automatically by this factory function.
Return the value of beta for the modulator.
Make GMSK modulator block.
The type is GAUSSIAN and the modulation index for GMSK is 0.5. This are populated automatically by this factory function.
Return the number of samples per symbol.
Return the phase response FIR taps.
A probe for computing SNR of a signal.
This is a probe block (a sink) that can be used to monitor and retrieve estimations of the signal SNR. This probe is designed for use with M-PSK signals especially. The type of estimator is specified as the parameter in the constructor. The estimators tend to trade off performance for accuracy, although experimentation should be done to figure out the right approach for a given implementation. Further, the current set of estimators are designed and proven theoretically under AWGN conditions; some amount of error should be assumed and/or estimated for real channel conditions.
Constructor Specific Documentation:
Make an MPSK SNR probe.
Parameters:
| Parameters: |
|
|---|
Get the running-average coefficient.
declare_sample_delay(probe_mpsk_snr_est_c_sptr self, unsigned int delay)
Return how many samples between SNR messages.
pc_input_buffers_full_avg(probe_mpsk_snr_est_c_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(probe_mpsk_snr_est_c_sptr self) -> pmt_vector_float
Set the running-average coefficient.
Set the number of samples between SNR messages.
Set type of estimator to use.
Return the estimated signal-to-noise ratio in decibels.
Generic CPM modulator.
Examples:
The input of this block are symbols from an M-ary alphabet +/-1, +/-3, ..., +/-(M-1). Usually, M = 2 and therefore, the valid inputs are +/-1. The modulator will silently accept any other inputs, though. The output is the phase-modulated signal.
Constructor Specific Documentation:
Make CPM modulator block.
| Parameters: |
|
|---|
Return the value of beta for the modulator.
Make GMSK modulator block.
The type is GAUSSIAN and the modulation index for GMSK is 0.5. This are populated automatically by this factory function.
Return the number of samples per symbol.
Return the phase response FIR taps.
Galois LFSR pseudo-random source.
Constructor Specific Documentation:
Make a Galois LFSR pseudo-random source block.
| Parameters: |
|
|---|
declare_sample_delay(glfsr_source_b_sptr self, unsigned int delay)
pc_input_buffers_full_avg(glfsr_source_b_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(glfsr_source_b_sptr self) -> pmt_vector_float
Galois LFSR pseudo-random source generating float outputs -1.0 - 1.0.
Constructor Specific Documentation:
Make a Galois LFSR pseudo-random source block.
| Parameters: |
|
|---|
declare_sample_delay(glfsr_source_f_sptr self, unsigned int delay)
pc_input_buffers_full_avg(glfsr_source_f_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(glfsr_source_f_sptr self) -> pmt_vector_float
Given a stream of bits and access_code flags, assemble packets.
input: stream of bytes from digital_correlate_access_code_bb output: none. Pushes assembled packet into target queue
The framer expects a fixed length header of 2 16-bit shorts containing the payload length, followed by the payload. If the 2 16-bit shorts are not identical, this packet is ignored. Better algs are welcome.
The input data consists of bytes that have two bits used. Bit 0, the LSB, contains the data bit. Bit 1 if set, indicates that the corresponding bit is the the first bit of the packet. That is, this bit is the first one after the access code.
Constructor Specific Documentation:
Make a framer_sink_1 block.
| Parameters: | target_queue – The message queue where frames go. |
|---|
declare_sample_delay(framer_sink_1_sptr self, unsigned int delay)
pc_input_buffers_full_avg(framer_sink_1_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(framer_sink_1_sptr self) -> pmt_vector_float
Given a stream of bits and access_code flags, assemble packets.
input: stream of bytes from digital_correlate_access_code_bb output: none. Pushes assembled packet into target queue
The framer expects a fixed length header of 2 16-bit shorts containing the payload length, followed by the payload. If the 2 16-bit shorts are not identical, this packet is ignored. Better algs are welcome.
The input data consists of bytes that have two bits used. Bit 0, the LSB, contains the data bit. Bit 1 if set, indicates that the corresponding bit is the the first bit of the packet. That is, this bit is the first one after the access code.
Constructor Specific Documentation:
Make a framer_sink_1 block.
| Parameters: | target_queue – The message queue where frames go. |
|---|
declare_sample_delay(framer_sink_1_sptr self, unsigned int delay)
pc_input_buffers_full_avg(framer_sink_1_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(framer_sink_1_sptr self) -> pmt_vector_float
Scramble an input stream using an LFSR.
This block scrambles up to 8 bits per byte of the input data stream, starting at the LSB.
The scrambler works by XORing the incoming bit stream by the output of the LFSR. Optionally, after bits have been processed, the shift register is reset to the value. This allows processing fixed length vectors of samples.
Alternatively, the LFSR can be reset using a reset tag to scramble variable length vectors. However, it cannot be reset between bytes.
For details on configuring the LFSR, see gr::digital::lfsr.
Constructor Specific Documentation:
Create additive scrambler.
| Parameters: |
|
|---|
declare_sample_delay(additive_scrambler_bb_sptr self, unsigned int delay)
pc_input_buffers_full_avg(additive_scrambler_bb_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(additive_scrambler_bb_sptr self) -> pmt_vector_float
Descramber an input stream using an LFSR.
Descramble an input stream using an LFSR. This block works on the LSB only of the input data stream, i.e., on an “unpacked binary” stream, and produces the same format on its output.
Constructor Specific Documentation:
Make a descrambler block.
| Parameters: |
|
|---|
declare_sample_delay(descrambler_bb_sptr self, unsigned int delay)
pc_input_buffers_full_avg(descrambler_bb_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(descrambler_bb_sptr self) -> pmt_vector_float
Differential encoder: y[0] = (x[0] - x[-1]) % M.
Uses current and previous symbols and the alphabet modulus to perform differential decoding.
Constructor Specific Documentation:
Make a differntial decoder block.
| Parameters: | modulus – Modulus of code’s alphabet |
|---|
declare_sample_delay(diff_decoder_bb_sptr self, unsigned int delay)
pc_input_buffers_full_avg(diff_decoder_bb_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(diff_decoder_bb_sptr self) -> pmt_vector_float
Differential decoder: y[0] = (x[0] + y[-1]) % M.
Uses current and previous symbols and the alphabet modulus to perform differential encoding.
Constructor Specific Documentation:
Make a differntial encoder block.
| Parameters: | modulus – Modulus of code’s alphabet |
|---|
declare_sample_delay(diff_encoder_bb_sptr self, unsigned int delay)
pc_input_buffers_full_avg(diff_encoder_bb_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(diff_encoder_bb_sptr self) -> pmt_vector_float
output[i] = map[input[i]]
This block maps an incoming signal to the value in the map. The block expects that the incoming signal has a maximum value of len(map)-1.
-> output[i] = map[input[i]]
Constructor Specific Documentation:
Make a map block.
| Parameters: | map – a vector of integers that maps x to map[x]. |
|---|
declare_sample_delay(map_bb_sptr self, unsigned int delay)
Apply element-wise to the elements of list and returns a list of the results, in order.
must be a list. The dynamic order in which is applied to the elements of is unspecified.
pc_input_buffers_full_avg(map_bb_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(map_bb_sptr self) -> pmt_vector_float
Scramble an input stream using an LFSR.
This block works on the LSB only of the input data stream, i.e., on an “unpacked binary” stream, and produces the same format on its output.
Constructor Specific Documentation:
Make a scramber block.
| Parameters: |
|
|---|
declare_sample_delay(scrambler_bb_sptr self, unsigned int delay)
pc_input_buffers_full_avg(scrambler_bb_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(scrambler_bb_sptr self) -> pmt_vector_float
PN code sequential search correlator.
Receives complex baseband signal, outputs complex correlation against reference PN code, one sample per PN code period. The PN sequence is generated using a GLFSR.
Constructor Specific Documentation:
Make PN code sequential search correlator block.
| Parameters: |
|
|---|
declare_sample_delay(pn_correlator_cc_sptr self, unsigned int delay)
pc_input_buffers_full_avg(pn_correlator_cc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(pn_correlator_cc_sptr self) -> pmt_vector_float
add sync field, seq number and command field to payload
Takes in enough samples to create a full output frame. The frame is prepended with the GRSF_SYNC (defind in simple_framer_sync.h) and an 8-bit sequence number.
Constructor Specific Documentation:
Make a simple_framer block.
| Parameters: | payload_bytesize – The size of the payload in bytes. |
|---|
declare_sample_delay(simple_framer_sptr self, unsigned int delay)
pc_input_buffers_full_avg(simple_framer_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(simple_framer_sptr self) -> pmt_vector_float
Map a stream of unpacked symbol indexes to stream of float or complex constellation points in D dimensions (D = 1 by default)
The combination of gr::blocks::packed_to_unpacked_XX followed by gr::digital::chunks_to_symbols_XY handles the general case of mapping from a stream of bytes or shorts into arbitrary float or complex symbols.
Constructor Specific Documentation:
Make a chunks-to-symbols block.
| Parameters: |
|
|---|
declare_sample_delay(chunks_to_symbols_bc_sptr self, unsigned int delay)
pc_input_buffers_full_avg(chunks_to_symbols_bc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(chunks_to_symbols_bc_sptr self) -> pmt_vector_float
Map a stream of unpacked symbol indexes to stream of float or complex constellation points in D dimensions (D = 1 by default)
The combination of gr::blocks::packed_to_unpacked_XX followed by gr::digital::chunks_to_symbols_XY handles the general case of mapping from a stream of bytes or shorts into arbitrary float or complex symbols.
Constructor Specific Documentation:
Make a chunks-to-symbols block.
| Parameters: |
|
|---|
declare_sample_delay(chunks_to_symbols_bf_sptr self, unsigned int delay)
pc_input_buffers_full_avg(chunks_to_symbols_bf_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(chunks_to_symbols_bf_sptr self) -> pmt_vector_float
Map a stream of unpacked symbol indexes to stream of float or complex constellation points in D dimensions (D = 1 by default)
The combination of gr::blocks::packed_to_unpacked_XX followed by gr::digital::chunks_to_symbols_XY handles the general case of mapping from a stream of bytes or shorts into arbitrary float or complex symbols.
Constructor Specific Documentation:
Make a chunks-to-symbols block.
| Parameters: |
|
|---|
declare_sample_delay(chunks_to_symbols_ic_sptr self, unsigned int delay)
pc_input_buffers_full_avg(chunks_to_symbols_ic_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(chunks_to_symbols_ic_sptr self) -> pmt_vector_float
Map a stream of unpacked symbol indexes to stream of float or complex constellation points in D dimensions (D = 1 by default)
The combination of gr::blocks::packed_to_unpacked_XX followed by gr::digital::chunks_to_symbols_XY handles the general case of mapping from a stream of bytes or shorts into arbitrary float or complex symbols.
Constructor Specific Documentation:
Make a chunks-to-symbols block.
| Parameters: |
|
|---|
declare_sample_delay(chunks_to_symbols_if_sptr self, unsigned int delay)
pc_input_buffers_full_avg(chunks_to_symbols_if_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(chunks_to_symbols_if_sptr self) -> pmt_vector_float
Map a stream of unpacked symbol indexes to stream of float or complex constellation points in D dimensions (D = 1 by default)
The combination of gr::blocks::packed_to_unpacked_XX followed by gr::digital::chunks_to_symbols_XY handles the general case of mapping from a stream of bytes or shorts into arbitrary float or complex symbols.
Constructor Specific Documentation:
Make a chunks-to-symbols block.
| Parameters: |
|
|---|
declare_sample_delay(chunks_to_symbols_sc_sptr self, unsigned int delay)
pc_input_buffers_full_avg(chunks_to_symbols_sc_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(chunks_to_symbols_sc_sptr self) -> pmt_vector_float
Map a stream of unpacked symbol indexes to stream of float or complex constellation points in D dimensions (D = 1 by default)
The combination of gr::blocks::packed_to_unpacked_XX followed by gr::digital::chunks_to_symbols_XY handles the general case of mapping from a stream of bytes or shorts into arbitrary float or complex symbols.
Constructor Specific Documentation:
Make a chunks-to-symbols block.
| Parameters: |
|
|---|
declare_sample_delay(chunks_to_symbols_sf_sptr self, unsigned int delay)
pc_input_buffers_full_avg(chunks_to_symbols_sf_sptr self) -> pmt_vector_float
pc_output_buffers_full_avg(chunks_to_symbols_sf_sptr self) -> pmt_vector_float
Hierarchical block for RRC-filtered differential generic demodulation.
The input is the complex modulated signal at baseband. The output is a stream of bits packed 1 bit per byte (LSB)
| Parameters: |
|
|---|
Adds generic demodulation options to the standard parser
Given command line options, create dictionary suitable for passing to __init__
Hierarchical block for RRC-filtered differential generic modulation.
The input is a byte stream (unsigned char) and the output is the complex modulated signal at baseband.
| Parameters: |
|
|---|
Adds generic modulation options to the standard parser
Given command line options, create dictionary suitable for passing to __init__
Hierarchical block for RRC-filtered DBPSK demodulation.
The input is the complex modulated signal at baseband and the output is a stream of bits packed 1 bit per byte (LSB)
| Parameters: |
|
|---|
Hierarchical block for RRC-filtered DBPSK modulation.
The input is a byte stream (unsigned char) and the output is the complex modulated signal at baseband.
| Parameters: |
|
|---|
Hierarchical block for RRC-filtered DQPSK demodulation.
The input is the complex modulated signal at baseband and the output is a stream of bits packed 1 bit per byte (LSB)
| Parameters: |
|
|---|
Hierarchical block for RRC-filtered DQPSK modulation.
The input is a byte stream (unsigned char) and the output is the complex modulated signal at baseband.
| Parameters: |
|
|---|
Hierarchical block for Gaussian Minimum Shift Key (GMSK) demodulation.
The input is the complex modulated signal at baseband. The output is a stream of bits packed 1 bit per byte (the LSB)
| Parameters: |
|
|---|
Adds GMSK demodulation-specific options to the standard parser
Given command line options, create dictionary suitable for passing to __init__
Hierarchical block for Gaussian Minimum Shift Key (GMSK) modulation.
The input is a byte stream (unsigned char) and the output is the complex modulated signal at baseband.
| Parameters: |
|
|---|
Adds GMSK modulation-specific options to the standard parser
Given command line options, create dictionary suitable for passing to __init__
Hierarchical block for RRC-filtered BPSK demodulation.
The input is the complex modulated signal at baseband and the output is a stream of bits packed 1 bit per byte (LSB)
| Parameters: |
|
|---|
Hierarchical block for RRC-filtered BPSK modulation.
The input is a byte stream (unsigned char) and the output is the complex modulated signal at baseband.
| Parameters: |
|
|---|
Hierarchical block for RRC-filtered PSK modulation.
The input is a byte stream (unsigned char) and the output is the complex modulated signal at baseband.
| Parameters: |
|
|---|
Hierarchical block for RRC-filtered PSK modulation.
The input is a byte stream (unsigned char) and the output is the complex modulated signal at baseband.
| Parameters: |
|
|---|
Hierarchical block for RRC-filtered QAM modulation.
The input is a byte stream (unsigned char) and the output is the complex modulated signal at baseband.
| Parameters: |
|
|---|
Hierarchical block for RRC-filtered QAM modulation.
The input is a byte stream (unsigned char) and the output is the complex modulated signal at baseband.
| Parameters: |
|
|---|
Hierarchical block for RRC-filtered QPSK demodulation.
The input is the complex modulated signal at baseband and the output is a stream of bits packed 1 bit per byte (LSB)
| Parameters: |
|
|---|
Hierarchical block for RRC-filtered QPSK modulation.
The input is a byte stream (unsigned char) and the output is the complex modulated signal at baseband.
| Parameters: |
|
|---|
Hierarchical block for Continuous Phase modulation.
The input is a byte stream (unsigned char) representing packed bits and the output is the complex modulated signal at baseband.
See Proakis for definition of generic CPM signals: s(t)=exp(j phi(t)) phi(t)= 2 pi h int_0^t f(t’) dt’ f(t)=sum_k a_k g(t-kT) (normalizing assumption: int_0^infty g(t) dt = 1/2)
| Parameters: |
|
|---|
Adds CPM modulation-specific options to the standard parser
Given command line options, create dictionary suitable for passing to __init__
Wrap an arbitrary digital modulator in our packet handling framework.
Send packets by calling send_pkt
Send the payload.
| Parameters: | payload – data to send (string) |
|---|
Wrap an arbitrary digital demodulator in our packet handling framework.
The input is complex baseband. When packets are demodulated, they are passed to the app via the callback.
alias of make
alias of make
alias of make
alias of make
alias of make
Modulates an OFDM stream. Based on the options fft_length, occupied_tones, and cp_length, this block creates OFDM symbols using a specified modulation option.
Send packets by calling send_pkt
Adds OFDM-specific options to the Options Parser
Send the payload.
| Parameters: | payload – data to send (string) |
|---|
Demodulates a received OFDM stream. Based on the options fft_length, occupied_tones, and cp_length, this block performs synchronization, FFT, and demodulation of incoming OFDM symbols and passes packets up the a higher layer.
The input is complex baseband. When packets are demodulated, they are passed to the app via the callback.
Adds OFDM-specific options to the Options Parser
Performs receiver synchronization on OFDM symbols.
The receiver performs channel filtering as well as symbol, frequency, and phase synchronization. The synchronization routines are available in three flavors: preamble correlator (Schmidl and Cox), modifid preamble correlator with autocorrelation (not yet working), and cyclic prefix correlator (Van de Beeks).
alias of make