+file(GLOB yml_files "*.yml")

+ ${yml_files}

+'[Core]':

+- Error Coding:

+ - Decoders:

+ - variable_cc_decoder_def

+ - variable_repetition_decoder_def

+ - variable_ldpc_decoder_def

+ - variable_ldpc_bit_flip_decoder_def

+ - variable_tpc_decoder_def

+ - variable_dummy_decoder_def

+ - variable_polar_decoder_sc_def

+ - variable_polar_decoder_sc_list_def

+ - variable_polar_decoder_sc_systematic_def

+ - Encoders:

+ - variable_cc_encoder_def

+ - variable_ccsds_encoder_def

+ - variable_repetition_encoder_def

+ - variable_tpc_encoder_def

+ - variable_ldpc_encoder_def

+ - variable_ldpc_encoder_G_def

+ - variable_ldpc_encoder_H_def

+ - variable_polar_encoder_def

+ - variable_polar_encoder_systematic_def

+ - variable_dummy_encoder_def

+ - fec_extended_encoder

+ - fec_extended_async_encoder

+ - fec_extended_tagged_encoder

+ - fec_extended_decoder

+ - fec_extended_tagged_decoder

+ - fec_generic_encoder

+ - fec_generic_decoder

+ - fec_tagged_encoder

+ - fec_tagged_decoder

+ - fec_async_encoder

+ - fec_async_decoder

+ - fec_decode_ccsds_27_fb

+ - fec_encode_ccsds_27_bb

+ - fec_puncture_xx

+ - fec_depuncture_bb

+ - fec_ber_bf

+ - fec_bercurve_generator

+ - variable_polar_code_configurator

+ - variable_ldpc_H_matrix_def

+ - variable_ldpc_G_matrix_def

+id: fec_async_decoder

+label: FEC Async Decoder

+

+parameters:

+- id: decoder

+ label: Decoder Obj.

+ dtype: raw

+- id: mtu

+ label: MTU (bytes)

+ dtype: int

+ default: '1500'

+- id: packed

+ label: Packed

+ dtype: enum

+ default: 'False'

+ options: ['False', 'True']

+ option_labels: ['No', 'Yes']

+ hide: part

+- id: rev_pack

+ label: Rev. Packing

+ dtype: enum

+ default: 'True'

+ options: ['True', 'False']

+ option_labels: ['Yes', 'No']

+ hide: ${ ('part' if packed == 'True' else 'all') }

+

+inputs:

+- domain: message

+ id: in

+ optional: true

+

+outputs:

+- domain: message

+ id: out

+ optional: true

+

+templates:

+ imports: from gnuradio import fec

+ make: fec.async_decoder(${decoder}, ${packed}, ${rev_pack}, ${mtu})

+

+documentation: ""

+

+file_format: 1

+id: fec_async_encoder

+label: FEC Async Encoder

+

+parameters:

+- id: encoder

+ label: Encoder Obj.

+ dtype: raw

+- id: mtu

+ label: MTU (bytes)

+ dtype: int

+ default: '1500'

+- id: packed

+ label: Packed

+ dtype: enum

+ default: 'False'

+ options: ['False', 'True']

+ option_labels: ['No', 'Yes']

+ hide: part

+- id: rev_unpack

+ label: Rev. Unpacking

+ dtype: enum

+ default: 'True'

+ options: ['True', 'False']

+ option_labels: ['Yes', 'No']

+ hide: ${ ('part' if packed == 'True' else 'all') }

+- id: rev_pack

+ label: Rev. Packing

+ dtype: enum

+ default: 'True'

+ options: ['True', 'False']

+ option_labels: ['Yes', 'No']

+ hide: ${ ('part' if packed == 'True' else 'all') }

+

+inputs:

+- domain: message

+ id: in

+ optional: true

+

+outputs:

+- domain: message

+ id: out

+ optional: true

+

+templates:

+ imports: from gnuradio import fec

+ make: fec.async_encoder(${encoder}, ${packed}, ${rev_unpack}, ${rev_pack}, ${mtu})

+

+documentation: ""

+

+file_format: 1

+id: fec_ber_bf

+label: BER

+

+parameters:

+- id: test_mode

+ label: Test Mode

+ dtype: enum

+ default: 'False'

+ options: ['False', 'True']

+- id: berminerrors

+ label: BER Min. Errors

+ dtype: int

+ default: '100'

+ hide: ${ ('part' if test_mode else 'all') }

+- id: berlimit

+ label: BER Limit

+ dtype: float

+ default: '-7.0'

+ hide: ${ ('part' if test_mode else 'all') }

+

+inputs:

+- label: in0

+ domain: stream

+ dtype: byte

+- label: in1

+ domain: stream

+ dtype: byte

+

+outputs:

+- domain: stream

+ dtype: float

+

+templates:

+ imports: from gnuradio import fec

+ make: fec.ber_bf(${test_mode}, ${berminerrors}, ${berlimit})

+

+file_format: 1

+id: fec_bercurve_generator

+label: BER Curve Gen.

+

+parameters:

+- id: esno

+ label: Es/N0

+ dtype: raw

+ default: numpy.arange(0.0, 4.0, .5)

+ hide: part

+- id: samp_rate

+ label: Sample Rate

+ dtype: float

+ default: '3200000'

+- id: encoder_list

+ label: Encoder list

+ dtype: raw

+ default: '0'

+- id: decoder_list

+ label: Decoder list

+ dtype: raw

+ default: '0'

+- id: puncpat

+ label: Puncture Pat.

+ dtype: string

+ default: '''11'''

+- id: threadtype

+ label: Threading Type

+ dtype: enum

+ options: ['"capillary"', '"ordinary"', '"none"']

+ option_labels: [Capillary, Ordinary, None]

+ hide: part

+- id: seed

+ label: Noise Seed

+ dtype: int

+ default: '0'

+ hide: part

+

+outputs:

+- domain: stream

+ dtype: byte

+ multiplicity: ${ len(esno)*2 }

+

+templates:

+ imports: |-

+ from gnuradio import fec

+ import numpy

+ make: "fec.bercurve_generator(\n\t${encoder_list}, \\#size\n\t${decoder_list},\

+ \ \\#name\n\t${esno}, \\#range of esnos\n\t${samp_rate}, \\#throttle\n \

+ \ ${threadtype}, \\#threading mode\n\t${puncpat}, \\#puncture pattern\n\

+ \ ${seed} \\# noise gen. seed\n)\n "

+

+documentation: |-

+ Note that this block tries to launch many parallel codes to run simultaneously. Thus, it requires that the definitions for each encoder and decoder (specified in the "Encoder list" and "Decoder list") be configured with a parallelism > 0. If the parallelism for one of the encoder or decoder definition blocks is configured to 0, you will likely see an error like:

+

+ generic_decoder=decoder_list[i],

+ TypeError: 'generic_decoder_sptr' object does not support indexing

+

+ or

+

+ generic_encoder=encoder_list[i],

+ TypeError: 'generic_encoder_sptr' object does not support indexing

+

+file_format: 1

+id: fec_encode_ccsds_27_bb

+label: Encode CCSDS 27

+

+inputs:

+- domain: stream

+ dtype: byte

+

+outputs:

+- domain: stream

+ dtype: byte

+

+templates:

+ imports: from gnuradio import fec

+ make: fec.encode_ccsds_27_bb()

+

+file_format: 1

+id: fec_decode_ccsds_27_fb

+label: Decode CCSDS 27

+

+inputs:

+- domain: stream

+ dtype: float

+

+outputs:

+- domain: stream

+ dtype: byte

+

+templates:

+ imports: from gnuradio import fec

+ make: fec.decode_ccsds_27_fb()

+

+file_format: 1

+id: fec_generic_decoder

+label: FEC Decoder

+

+parameters:

+- id: decoder

+ label: Decoder Object

+ dtype: raw

+ default: decoder_variable

+- id: itype

+ label: Input Type

+ dtype: enum

+ options: [complex, float, int, short, byte]

+ option_attributes:

+ size: [gr.sizeof_gr_complex, gr.sizeof_float, gr.sizeof_int, gr.sizeof_short,

+ gr.sizeof_char]

+ hide: part

+- id: otype

+ label: Output Type

+ dtype: enum

+ options: [complex, float, int, short, byte]

+ option_attributes:

+ size: [gr.sizeof_gr_complex, gr.sizeof_float, gr.sizeof_int, gr.sizeof_short,

+ gr.sizeof_char]

+ hide: part

+

+inputs:

+- domain: stream

+ dtype: ${ itype }

+

+outputs:

+- domain: stream

+ dtype: ${ otype }

+

+templates:

+ imports: from gnuradio import fec

+ make: fec.decoder(${decoder}, ${itype.size}, ${otype.size})

+

+documentation: |-

+ This is a GNU Radio adaptor for any FEC decoder following the generic_decoder API in the fec module. Input and output are flexible to accomodate decoders that, say, modulate their encoded results into complex or float types.

+

+file_format: 1

+id: fec_depuncture_bb

+label: Depuncture

+

+parameters:

+- id: puncsize

+ label: Puncture Size

+ dtype: int

+- id: puncpat

+ label: Puncture Pattern

+ dtype: int

+- id: delay

+ label: Delay

+ dtype: int

+ default: '0'

+- id: sym

+ label: Symbol

+ dtype: int

+ default: '127'

+ hide: part

+

+inputs:

+- domain: stream

+ dtype: byte

+

+outputs:

+- domain: stream

+ dtype: byte

+

+templates:

+ imports: from gnuradio import fec

+ make: fec.depuncture_bb(${puncsize}, ${puncpat}, ${delay}, ${sym})

+

+file_format: 1

+id: fec_generic_encoder

+label: FEC Encoder

+

+parameters:

+- id: encoder

+ label: Constituent Encoder

+ dtype: raw

+ default: encoder_variable

+- id: itype

+ label: Input Type

+ dtype: enum

+ options: [complex, float, int, short, byte]

+ option_attributes:

+ size: [gr.sizeof_gr_complex, gr.sizeof_float, gr.sizeof_int, gr.sizeof_short,

+ gr.sizeof_char]

+ hide: part

+- id: otype

+ label: Output Type

+ dtype: enum

+ options: [complex, float, int, short, byte]

+ option_attributes:

+ size: [gr.sizeof_gr_complex, gr.sizeof_float, gr.sizeof_int, gr.sizeof_short,

+ gr.sizeof_char]

+ hide: part

+

+inputs:

+- domain: stream

+ dtype: ${ itype }

+

+outputs:

+- domain: stream

+ dtype: ${ otype }

+

+templates:

+ imports: from gnuradio import fec

+ make: fec.encoder(${encoder}, ${itype.size}, ${otype.size})

+

+documentation: |-

+ This is a GNU Radio adaptor for any FEC encoder following the generic_encoder API in the fec module. Input and output are flexible to accomodate encoders that, say, modulate their encoded results into complex or float types.

+

+file_format: 1

+id: fec_extended_async_encoder

+label: FEC Extended Async Encoder

+

+parameters:

+- id: encoder_list

+ label: Encoder Objects

+ dtype: raw

+ default: encoder_variable

+- id: puncpat

+ label: Puncture Pattern

+ dtype: string

+ default: '''11'''

+

+inputs:

+- domain: message

+ id: in

+ optional: true

+

+outputs:

+- domain: message

+ id: out

+ optional: true

+

+templates:

+ imports: from gnuradio import fec

+ make: fec.extended_async_encoder(encoder_obj_list=${encoder_list}, puncpat=${puncpat})

+

+documentation: ""

+

+file_format: 1

+id: fec_extended_decoder

+label: FEC Extended Decoder

+

+parameters:

+- id: value

+ label: fake val

+ dtype: string

+ default: fec_extended_decoder

+ hide: all

+- id: decoder_list

+ label: Decoder Objects

+ dtype: raw

+ default: decoder_variable

+- id: threadtype

+ label: Threading Type

+ dtype: enum

+ options: [capillary, ordinary, none]

+ option_attributes:

+ arg: ['''capillary''', '''ordinary''', ' None']

+- id: ann

+ label: Annihilator

+ dtype: raw

+ default: None

+- id: puncpat

+ label: Puncture Pattern

+ dtype: string

+ default: '''11'''

+

+inputs:

+- domain: stream

+ dtype: float

+

+outputs:

+- domain: stream

+ dtype: byte

+

+templates:

+ imports: from gnuradio import fec

+ make: fec.extended_decoder(decoder_obj_list=${decoder_list}, threading=${threadtype.arg},

+ ann=${ann}, puncpat=${puncpat}, integration_period=10000)

+

+documentation: ""

+

+file_format: 1

+id: fec_extended_encoder

+label: FEC Extended Encoder

+

+parameters:

+- id: encoder_list

+ label: Encoder Objects

+ dtype: raw

+ default: encoder_variable

+- id: threadtype

+ label: Threading Type

+ dtype: enum

+ options: [capillary, ordinary, none]

+ option_attributes:

+ arg: ['''capillary''', '''ordinary''', ' None']

+- id: puncpat

+ label: Puncture Pattern

+ dtype: string

+ default: '''11'''

+

+inputs:

+- domain: stream

+ dtype: byte

+

+outputs:

+- domain: stream

+ dtype: byte

+

+templates:

+ imports: from gnuradio import fec

+ make: fec.extended_encoder(encoder_obj_list=${encoder_list}, threading=${threadtype.arg},

+ puncpat=${puncpat})

+

+documentation: ""

+

+file_format: 1

+id: fec_extended_tagged_decoder

+label: FEC Extended Tagged Decoder

+

+parameters:

+- id: value

+ label: fake val

+ dtype: string

+ default: fec_extended_decoder

+ hide: all

+- id: decoder_list

+ label: Decoder Objects

+ dtype: raw

+ default: decoder_variable

+- id: mtu

+ label: MTU (bytes)

+ dtype: int

+ default: '1500'

+- id: ann

+ label: Annihilator

+ dtype: raw

+ default: None

+- id: puncpat

+ label: Puncture Pattern

+ dtype: string

+ default: '''11'''

+- id: lentagname

+ label: Length Tag Name

+ dtype: string

+ default: None

+

+inputs:

+- domain: stream

+ dtype: float

+

+outputs:

+- domain: stream

+ dtype: byte

+

+templates:

+ imports: from gnuradio import fec

+ make: self.${id} = ${id} = fec.extended_tagged_decoder(decoder_obj_list=${decoder_list},

+ ann=${ann}, puncpat=${puncpat}, integration_period=10000, lentagname=${lentagname},

+ mtu=${mtu})

+

+documentation: ""

+

+file_format: 1

+id: fec_extended_tagged_encoder

+label: FEC Extended Tagged Encoder

+

+parameters:

+- id: encoder_list

+ label: Encoder Objects

+ dtype: raw

+ default: encoder_variable

+- id: mtu

+ label: MTU (bytes)

+ dtype: int

+ default: '1500'

+- id: puncpat

+ label: Puncture Pattern

+ dtype: string

+ default: '''11'''

+- id: lentagname

+ label: Length Tag Name

+ dtype: string

+ default: None

+

+inputs:

+- domain: stream

+ dtype: byte

+

+outputs:

+- domain: stream

+ dtype: byte

+

+templates:

+ imports: from gnuradio import fec

+ make: fec.extended_tagged_encoder(encoder_obj_list=${encoder_list}, puncpat=${puncpat},

+ lentagname=${lentagname}, mtu=${mtu})

+

+documentation: ""

+

+file_format: 1

+id: fec_puncture_xx

+label: Puncture

+

+parameters:

+- id: type

+ label: Type

+ dtype: enum

+ options: [byte, float]

+ option_attributes:

+ fcn: [bb, ff]

+ hide: part

+- id: puncsize

+ label: Puncture Size

+ dtype: int

+- id: puncpat

+ label: Puncture Pattern

+ dtype: int

+- id: delay

+ label: Delay

+ dtype: int

+ default: '0'

+

+inputs:

+- domain: stream

+ dtype: ${ type }

+

+outputs:

+- domain: stream

+ dtype: ${ type }

+

+templates:

+ imports: from gnuradio import fec

+ make: fec.puncture_${type.fcn}(${puncsize}, ${puncpat}, ${delay})

+

+file_format: 1

+id: fec_tagged_decoder

+label: FEC Tagged Decoder

+

+parameters:

+- id: decoder

+ label: Constituent Decoder

+ dtype: raw

+ default: decoder_variable

+- id: mtu

+ label: MTU (bytes)

+ dtype: int

+ default: '1500'

+- id: itype

+ label: Input Type

+ dtype: enum

+ options: [byte, float]

+ option_attributes:

+ size: [gr.sizeof_char, gr.sizeof_float]

+ hide: part

+- id: otype

+ label: Output Type

+ dtype: enum

+ options: [byte, float]

+ option_attributes:

+ size: [gr.sizeof_char, gr.sizeof_float]

+ hide: part

+- id: lentagname

+ label: Length Tag Name

+ dtype: string

+ default: '"pkt_len"'

+

+inputs:

+- domain: stream

+ dtype: ${ itype }

+

+outputs:

+- domain: stream

+ dtype: ${ otype }

+

+templates:

+ imports: from gnuradio import fec

+ make: fec.tagged_decoder(${decoder}, ${itype.size}, ${otype.size}, ${lentagname},

+ ${mtu})

+

+documentation: ""

+

+file_format: 1

+id: fec_tagged_encoder

+label: FEC Tagged Encoder

+

+parameters:

+- id: encoder

+ label: Constituent Encoder

+ dtype: raw

+ default: encoder_variable

+- id: mtu

+ label: MTU (bytes)

+ dtype: int

+ default: '1500'

+- id: itype

+ label: Input Type

+ dtype: enum

+ options: [byte, float]

+ option_attributes:

+ size: [gr.sizeof_char, gr.sizeof_float]

+ hide: part

+- id: otype

+ label: Output Type

+ dtype: enum

+ options: [byte, float]

+ option_attributes:

+ size: [gr.sizeof_char, gr.sizeof_float]

+ hide: part

+- id: lentagname

+ label: Length Tag Name

+ dtype: string

+ default: '"pkt_len"'

+

+inputs:

+- domain: stream

+ dtype: ${ itype }

+

+outputs:

+- domain: stream

+ dtype: ${ otype }

+

+templates:

+ imports: from gnuradio import fec

+ make: fec.tagged_encoder(${encoder}, ${itype.size}, ${otype.size}, ${lentagname},

+ ${mtu})

+

+documentation: ""

+

+file_format: 1

+id: variable_ldpc_decoder_def

+label: LDPC Decoder Definition

+

+parameters:

+- id: value

+ label: Ignore Me

+ dtype: raw

+ default: '"ok"'

+ hide: all

+- id: ndim

+ label: Parallelism

+ dtype: enum

+ default: '0'

+ options: ['0', '1', '2']

+- id: dim1

+ label: Dimension 1

+ dtype: int

+ default: '4'

+ hide: ${ ('none' if (int(ndim) >= 1) else 'all') }

+- id: dim2

+ label: Dimension 2

+ dtype: int

+ default: '4'

+ hide: ${ ('none' if (int(ndim) >= 2) else 'all') }

+- id: file

+ label: AList File

+ dtype: file_open

+- id: sigma

+ label: Sigma

+ dtype: float

+ default: '0.5'

+- id: max_iter

+ label: Max Iterations

+ dtype: int

+ default: '50'

+value: ${ value }

+

+templates:

+ imports: from gnuradio import fec

+ var_make: "\n% if int(ndim)==0 #:\nself.${id} = ${id} = fec.ldpc_decoder.make(${file},\

+ \ ${sigma}, ${max_iter}); \n% elif int(ndim)==1 #:\nself.${id} = ${id} = map(\

+ \ (lambda a: fec.ldpc_decoder.make(${file}, ${sigma}, ${max_iter})), range(0,${dim1})\

+ \ ); \n% else:\nself.${id} = ${id} = map( (lambda b: map( ( lambda a: fec.ldpc_decoder.make(${file},\

+ \ ${sigma}, ${max_iter})), range(0,${dim2}) ) ), range(0,${dim1})); \n% endif"

+

+documentation: |-

+ This is a soft-decision decoder that uses belief propagation (also known as message passing) that is described at:

+

+ www.cs.toronto.edu/~radford/ftp/LDPC-2012-02-11/decoding.html

+

+ Designed for a memoryless AWGN channel, it assumes a noise variance of the value specified for sigma.

+

+file_format: 1

+id: variable_ldpc_encoder_def

+label: LDPC Encoder Definition

+

+parameters:

+- id: value

+ label: Ignore Me

+ dtype: raw

+ default: '"ok"'

+ hide: all

+- id: ndim

+ label: Parallelism

+ dtype: enum

+ default: '0'

+ options: ['0', '1', '2']

+- id: dim1

+ label: Dimension 1

+ dtype: int

+ default: '1'

+ hide: ${ ('none' if (int(ndim) >= 1) else 'all') }

+- id: dim2

+ label: Dimension 2

+ dtype: int

+ default: '4'

+ hide: ${ ('none' if (int(ndim) >= 2) else 'all') }

+- id: file

+ label: AList File

+ dtype: file_open

+value: ${ fec.ldpc_encoder_make(file) }

+

+templates:

+ imports: from gnuradio import fec

+ var_make: "\n% if int(ndim)==0 #:\nself.${id} = ${id} = fec.ldpc_encoder_make(${file});\

+ \ \n% elif int(ndim)==1 #:\nself.${id} = ${id} = map( (lambda a: fec.ldpc_encoder_make(${file})),\

+ \ range(0,${dim1}) ); \n% else:\nself.${id} = ${id} = map( (lambda b: map(\

+ \ ( lambda a: fec.ldpc_encoder_make(${file})), range(0,${dim2}) ) ), range(0,${dim1}));\

+ \ \n% endif"

+

+file_format: 1

+id: variable_tpc_decoder_def

+label: TPC Decoder Definition

+

+parameters:

+- id: value

+ label: Ignore Me

+ dtype: raw

+ default: '"ok"'

+ hide: all

+- id: ndim

+ label: Parallelism

+ dtype: enum

+ default: '0'

+ options: ['0', '1', '2']

+- id: dim1

+ label: Dimension 1

+ dtype: int

+ default: '4'

+ hide: ${ ('none' if (int(ndim) >= 1) else 'all') }

+- id: dim2

+ label: Dimension 2

+ dtype: int

+ default: '4'

+ hide: ${ ('none' if (int(ndim) >= 2) else 'all') }

+- id: row_poly

+ label: Row Encoder Polynomials

+ dtype: int_vector

+ default: '[3]'

+- id: col_poly

+ label: Column Encoder Polynomials

+ dtype: int_vector

+ default: '[43]'

+- id: krow

+ label: K Row

+ dtype: int

+ default: '26'

+- id: kcol

+ label: K Col

+ dtype: int

+ default: '6'

+- id: bval

+ label: B

+ dtype: int

+ default: '9'

+- id: qval

+ label: Q

+ dtype: int

+ default: '3'

+- id: max_iter

+ label: NUM Turbo Iterations

+ dtype: int

+ default: '6'

+- id: decoder_type

+ label: Decoder Type

+ dtype: enum

+ options: ['0', '1', '2', '3', '4']

+ option_labels: [Linear LOG-MAP, MAX LOG-MAP, Constant LOG-MAP, LOG-MAP (LUT Correction

+ Factor), LOG-MAP (C Correction Factor)]

+value: ${ value }

+

+templates:

+ imports: from gnuradio import fec

+ var_make: "\n% if int(ndim)==0 #:\nself.${id} = ${id} = fec.tpc_decoder_make(${row_poly},\

+ \ ${col_poly}, ${krow}, ${kcol}, ${bval}, ${qval}, ${max_iter}, ${decoder_type});\

+ \ \n% elif int(ndim)==1 #:\nself.${id} = ${id} = map( (lambda a: fec.tpc_decoder_make(${row_poly},\

+ \ ${col_poly}, ${krow}, ${kcol}, ${bval}, ${qval}, ${max_iter}, ${decoder_type})),\

+ \ range(0,${dim1}) ); \n% else:\nself.${id} = ${id} = map( (lambda b: map(\

+ \ ( lambda a: fec.tpc_decoder_make(${row_poly}, ${col_poly}, ${krow}, ${kcol},\

+ \ ${bval}, ${qval}, ${max_iter}, ${decoder_type})), range(0,${dim2}) ) ),\

+ \ range(0,${dim1})); \n% endif"

+

+documentation: |-

+ This instantiates a 1-dim array or 2-dim array fo Turbo Product Encoders (TPC).

+ Restrictions: B and Q must be carefully chosen such that when the matrices are setup,

+ and the first B outputs are removed, they (the first B outputs) are all 0's.

+

+file_format: 1

+id: variable_tpc_encoder_def

+label: TPC Encoder Definition

+

+parameters:

+- id: value

+ label: Ignore Me

+ dtype: raw

+ default: '"ok"'

+ hide: all

+- id: ndim

+ label: Parallelism

+ dtype: enum

+ default: '0'

+ options: ['0', '1', '2']

+- id: dim1

+ label: Dimension 1

+ dtype: int

+ default: '4'

+ hide: ${ ('none' if (int(ndim) >= 1) else 'all') }

+- id: dim2

+ label: Dimension 2

+ dtype: int

+ default: '4'

+ hide: ${ ('none' if (int(ndim) >= 2) else 'all') }

+- id: row_poly

+ label: Row Encoder Polynomials

+ dtype: int_vector

+ default: '[3]'

+- id: col_poly

+ label: Column Encoder Polynomials

+ dtype: int_vector

+ default: '[43]'

+- id: krow

+ label: K Row

+ dtype: int

+ default: '26'

+- id: kcol

+ label: K Col

+ dtype: int

+ default: '6'

+- id: bval

+ label: B

+ dtype: int

+ default: '9'

+- id: qval

+ label: Q

+ dtype: int

+ default: '3'

+value: ${ value }

+

+templates:

+ imports: from gnuradio import fec

+ var_make: "\n% if int(ndim)==0 #:\nself.${id} = ${id} = fec.tpc_encoder_make(${row_poly},\

+ \ ${col_poly}, ${krow}, ${kcol}, ${bval}, ${qval}); \n% elif int(ndim)==1\

+ \ #:\nself.${id} = ${id} = map( (lambda a: fec.tpc_encoder_make(${row_poly},\

+ \ ${col_poly}, ${krow}, ${kcol}, ${bval}, ${qval})), range(0,${dim1}) ); \n\

+ % else:\nself.${id} = ${id} = map( (lambda b: map( ( lambda a: fec.tpc_encoder_make(${row_poly},\

+ \ ${col_poly}, ${krow}, ${kcol}, ${bval}, ${qval})), range(0,${dim2}) ) ),\

+ \ range(0,${dim1})); \n% endif"

+

+documentation: |-

+ This instantiates a 1-dim array or 2-dim array fo Turbo Product Encoders (TPC).

+ Restrictions: B and Q must be carefully chosen such that when the matrices are setup,

+ and the first B outputs are removed, they (the first B outputs) are all 0's.

+

+file_format: 1

+id: variable_cc_decoder_def

+label: CC Decoder Definition

+

+parameters:

+- id: value

+ label: Ignore Me

+ dtype: raw

+ default: '"ok"'

+ hide: all

+- id: ndim

+ label: Parallelism

+ dtype: enum

+ default: '0'

+ options: ['0', '1', '2']

+- id: dim1

+ label: Dimension 1

+ dtype: int

+ default: '1'

+ hide: ${ ('none' if (int(ndim) >= 1) else 'all') }

+- id: dim2

+ label: Dimension 2

+ dtype: int

+ default: '1'

+ hide: ${ ('none' if (int(ndim) >= 2) else 'all') }

+- id: framebits

+ label: Frame Bits

+ dtype: int

+ default: '2048'

+- id: k

+ label: Constraint Length (K)

+ dtype: int

+ default: '7'

+- id: rate

+ label: Rate Inverse (1/R) (1/2) --> 2

+ dtype: int

+ default: '2'

+- id: polys

+ label: Polynomials

+ dtype: int_vector

+ default: '[79,109]'

+- id: state_start

+ label: Start State

+ dtype: int

+ default: '0'

+- id: state_end

+ label: End State

+ dtype: int

+ default: '-1'

+- id: mode

+ label: Streaming Behavior

+ dtype: enum

+ options: [fec.CC_STREAMING, fec.CC_TERMINATED, fec.CC_TAILBITING, fec.CC_TRUNCATED]

+ option_labels: [Streaming, Terminated, Tailbiting, Truncated]

+- id: padding

+ label: Byte Padding

+ dtype: enum

+ default: 'False'

+ options: ['False', 'True']

+ option_labels: ['No', 'Yes']

+value: ${ fec.cc_decoder.make(framebits, k, rate, polys, state_start, state_end, mode,

+ padding) }

+

+templates:

+ imports: from gnuradio import fec

+ var_make: "\n% if int(ndim)==0 #:\nself.${id} = ${id} = fec.cc_decoder.make(${framebits},\

+ \ ${k}, ${rate}, ${polys}, ${state_start}, ${state_end}, ${mode}, ${padding})\n\

+ % elif int(ndim)==1 #:\nself.${id} = ${id} = map( (lambda a: fec.cc_decoder.make(${framebits},\

+ \ ${k}, ${rate}, ${polys}, ${state_start}, ${state_end}, ${mode}, ${padding})),\

+ \ range(0,${dim1}) ); \n% else:\nself.${id} = ${id} = map( (lambda b: map(\

+ \ ( lambda a: fec.cc_decoder.make(${framebits}, ${k}, ${rate}, ${polys}, ${state_start},\

+ \ ${state_end}, ${mode}, ${padding})), range(0,${dim2}) ) ), range(0,${dim1}));\

+ \ \n% endif\n "

+

+documentation: ""

+

+file_format: 1

+id: variable_cc_encoder_def

+label: CC Encoder Definition

+

+parameters:

+- id: ndim

+ label: Parallelism

+ dtype: enum

+ default: '0'

+ options: ['0', '1', '2']

+- id: dim1

+ label: Dimension 1

+ dtype: int

+ default: '1'

+ hide: ${ ('none' if (int(ndim) >= 1) else 'all') }

+- id: dim2

+ label: Dimension 2

+ dtype: int

+ default: '1'

+ hide: ${ ('none' if (int(ndim) >= 2) else 'all') }

+- id: framebits

+ label: Frame Bits

+ dtype: int

+ default: '2048'

+- id: k

+ label: Constraint Length (K)

+ dtype: int

+ default: '7'

+- id: rate

+ label: Rate Inverse (1/R) (1/2) --> 2

+ dtype: int

+ default: '2'

+- id: polys

+ label: Polynomials

+ dtype: int_vector

+ default: '[79,109]'

+- id: state_start

+ label: Start State

+ dtype: int

+ default: '0'

+- id: mode

+ label: Streaming Behavior

+ dtype: enum

+ options: [fec.CC_STREAMING, fec.CC_TERMINATED, fec.CC_TAILBITING, fec.CC_TRUNCATED]

+ option_labels: [Streaming, Terminated, Tailbiting, Truncated]

+- id: padding

+ label: Byte Padding

+ dtype: enum

+ default: 'False'

+ options: ['False', 'True']

+ option_labels: ['No', 'Yes']

+value: ${ fec.cc_encoder_make(framebits, k, rate, polys, state_start, mode, padding)

+ }

+

+templates:

+ imports: from gnuradio import fec

+ var_make: "\n% if int(ndim)==0 #:\nself.${id} = ${id} = fec.cc_encoder_make(${framebits},\

+ \ ${k}, ${rate}, ${polys}, ${state_start}, ${mode}, ${padding})\n% elif int(ndim)==1\

+ \ #:\nself.${id} = ${id} = map( (lambda a: fec.cc_encoder_make(${framebits},\

+ \ ${k}, ${rate}, ${polys}, ${state_start}, ${mode}, ${padding})), range(0,${dim1})\

+ \ ); \n% else:\nself.${id} = ${id} = map( (lambda b: map( ( lambda a: fec.cc_encoder_make(${framebits},\

+ \ ${k}, ${rate}, ${polys}, ${state_start}, ${mode}, ${padding})), range(0,${dim2})\

+ \ ) ), range(0,${dim1})); \n% endif\n "

+

+documentation: ""

+

+file_format: 1

+id: variable_ccsds_encoder_def

+label: CCSDS Encoder Definition

+

+parameters:

+- id: ndim

+ label: Parallelism

+ dtype: enum

+ default: '0'

+ options: ['0', '1', '2']

+- id: dim1

+ label: Dimension 1

+ dtype: int

+ default: '1'

+ hide: ${ ('none' if (int(ndim) >= 1) else 'all') }

+- id: dim2

+ label: Dimension 2

+ dtype: int

+ default: '1'

+ hide: ${ ('none' if (int(ndim) >= 2) else 'all') }

+- id: framebits

+ label: Frame Bits

+ dtype: int

+ default: '2048'

+- id: state_start

+ label: Start State

+ dtype: int

+ default: '0'

+- id: mode

+ label: Streaming Behavior

+ dtype: enum

+ options: [fec.CC_STREAMING, fec.CC_TERMINATED, fec.CC_TAILBITING, fec.CC_TRUNCATED]

+ option_labels: [Streaming, Terminated, Tailbiting, Truncated]

+value: ${ fec.ccsds_encoder_make(framebits, state_start, mode) }

+

+templates:

+ imports: from gnuradio import fec

+ var_make: "\n% if int(ndim)==0 #:\nself.${id} = ${id} = fec.ccsds_encoder_make(${framebits},\

+ \ ${state_start}, ${mode})\n% elif int(ndim)==1 #:\nself.${id} = ${id} = map(\

+ \ (lambda a: fec.ccsds_encoder_make(${framebits}, ${state_start}, ${mode})),\

+ \ range(0,${dim1}) ); \n% else:\nself.${id} = ${id} = map( (lambda b: map(\

+ \ ( lambda a: fec.ccsds_encoder_make(${framebits}, ${state_start}, ${mode})),\

+ \ range(0,${dim2}) ) ), range(0,${dim1})); \n% endif\n "

+

+documentation: ""

+

+file_format: 1

+id: variable_dummy_decoder_def

+label: Dummy Decoder Definition

+

+parameters:

+- id: value

+ label: Ignore Me

+ dtype: raw

+ default: '"ok"'

+ hide: all

+- id: ndim

+ label: Parallelism

+ dtype: enum

+ options: ['0', '1', '2']

+- id: dim1

+ label: Dimension 1

+ dtype: int

+ default: '1'

+ hide: ${ ('none' if (int(ndim) >= 1) else 'all') }

+- id: dim2

+ label: Dimension 2

+ dtype: int

+ default: '1'

+ hide: ${ ('none' if (int(ndim) >= 2) else 'all') }

+- id: framebits

+ label: Frame Bits

+ dtype: int

+ default: '2048'

+value: ${ fec.dummy_decoder.make(framebits) }

+

+templates:

+ imports: from gnuradio import fec

+ var_make: "\n% if int(ndim)==0 #:\nself.${id} = ${id} = fec.dummy_decoder.make(${framebits})\n\

+ % elif int(ndim)==1 #:\nself.${id} = ${id} = map((lambda a: fec.dummy_decoder.make(${framebits})),\

+ \ range(0,${dim1})) \n% else:\nself.${id} = ${id} = map((lambda b: map((lambda\

+ \ a: fec.dummy_decoder.make(${framebits})), range(0,${dim2}))), range(0,${dim1}))\

+ \ \n% endif\n "

+

+documentation: ""

+

+file_format: 1

+id: variable_dummy_encoder_def

+label: Dummy Encoder Definition

+

+parameters:

+- id: ndim

+ label: Parallelism

+ dtype: enum

+ default: '0'

+ options: ['0', '1', '2']

+- id: dim1

+ label: Dimension 1

+ dtype: int

+ default: '1'

+ hide: ${ ('none' if (int(ndim) >= 1) else 'all') }

+- id: dim2

+ label: Dimension 2

+ dtype: int

+ default: '1'

+ hide: ${ ('none' if (int(ndim) >= 2) else 'all') }

+- id: framebits

+ label: Frame Bits

+ dtype: int

+ default: '2048'

+value: ${ fec.dummy_encoder_make(framebits) }

+

+templates:

+ imports: from gnuradio import fec

+ var_make: "\n% if int(ndim)==0 #:\nself.${id} = ${id} = fec.dummy_encoder_make(${framebits})\n\

+ % elif int(ndim)==1 #:\nself.${id} = ${id} = map((lambda a: fec.dummy_encoder_make(${framebits})),\

+ \ range(0,${dim1})) \n% else:\nself.${id} = ${id} = map((lambda b: map((lambda\

+ \ a: fec.dummy_encoder_make(${framebits})), range(0,${dim2}))), range(0,${dim1}))\

+ \ \n% endif\n "

+

+documentation: ""

+

+file_format: 1

+id: variable_ldpc_G_matrix_def

+label: LDPC Generator Matrix

+

+parameters:

+- id: value

+ label: Ignore Me

+ dtype: raw

+ default: '"ok"'

+ hide: all

+- id: filename

+ label: File

+ dtype: file_open

+value: ${ value }

+

+templates:

+ imports: from gnuradio import fec

+ var_make: self.${id} = ${id} = fec.ldpc_G_matrix(${filename})

+

+documentation: |-

+ This block creates a LDPC Generator Matrix variable.

+

+ This variable can be used by:

+ 1) LDPC Encoder Definition (via Generator) block

+ 2) LDPC Bit Flip Decoder Definition block

+

+ Provide an alist file, which contains a Generator matrix, G, in the standard format G = [I P], where I is an identity matrix and P is the parity submatrix.

+

+ The format of alist files is described at:

+ http://www.inference.phy.cam.ac.uk/mackay/codes/alist.html

+

+file_format: 1

+id: variable_ldpc_H_matrix_def

+label: LDPC Parity Check Matrix

+

+parameters:

+- id: value

+ label: Ignore Me

+ dtype: raw

+ default: '"ok"'

+ hide: all

+- id: filename

+ label: File

+ dtype: file_open

+- id: gap

+ label: Gap

+ dtype: int

+value: ${ value }

+

+templates:

+ imports: from gnuradio import fec

+ var_make: self.${id} = ${id} = fec.ldpc_H_matrix(${filename}, ${gap})

+

+documentation: |-

+ This block creates a FEC LDPC Parity Check Matrix variable.

+

+ This variable can be used by:

+ 1) LDPC Encoder Definition (via Parity Check) block

+ 2) LDPC Bit Flip Decoder Definition block

+

+ The format of alist files is described at:

+ http://www.inference.phy.cam.ac.uk/mackay/codes/alist.html

+

+ The specific format of this parity check matrix is described by Richardson and Urbanke in Appendix A of their book: Modern Coding Theory (ISBN 978-0-521-85229-6).

+

+ As an example, see the file {$target}/share/gnuradio/fec/ldpc/n_1800_k_0902_gap_28.alist, which is used by the FEC example flowgraph ber_curve_gen_ldpc.grc.

+

+ There is a small library of encoding-ready alist files at {$target}/share/gnuradio/fec/ldpc.

+

+ To convert a parity check matrix to the appropriate format required for this encoder, use the python functions in {$target}/lib/python2.7/dist-packages/gnuradio/fec/LDPC/Generate_LDPC_matrix.py.

+

+file_format: 1

+id: variable_ldpc_bit_flip_decoder_def

+label: LDPC Bit Flip Decoder Definition

+

+parameters:

+- id: value

+ label: Ignore Me

+ dtype: raw

+ default: '"ok"'

+ hide: all

+- id: ndim

+ label: Parallelism

+ dtype: enum

+ options: ['0', '1', '2']

+- id: dim1

+ label: Dimension 1

+ dtype: int

+ default: '1'

+ hide: ${ ('none' if (int(ndim) >= 1) else 'all') }

+- id: dim2

+ label: Dimension 2

+ dtype: int

+ default: '1'

+ hide: ${ ('none' if (int(ndim) >= 2) else 'all') }

+- id: max_iterations

+ label: Max Iterations

+ dtype: int

+ default: '100'

+- id: matrix_object

+ label: LDPC FEC Matrix ID

+ dtype: raw

+value: ${ value }

+

+templates:

+ imports: from gnuradio import fec

+ var_make: "\n% if int(ndim)==0 #:\nself.${id} = ${id} = fec.ldpc_bit_flip_decoder.make(${matrix_object}.get_base_sptr(),\

+ \ ${max_iterations})\n% elif int(ndim)==1 #:\nself.${id} = ${id} = map((lambda\

+ \ a: fec.ldpc_bit_flip_decoder.make(${matrix_object}.get_base_sptr(), ${max_iterations})),\

+ \ range(0,${dim1})) \n% else:\nself.${id} = ${id} = map((lambda b: map((lambda\

+ \ a: fec.ldpc_bit_flip_decoder.make(${matrix_object}.get_base_sptr(), ${max_iterations})),\

+ \ range(0,${dim2}))), range(0,${dim1})) \n% endif"

+

+documentation: |-

+ This block creates a LDPC Bit Flip Decoder Definition variable.

+

+ The decoder requires knowledge of the matrix used to create (encode) the codewords. In the LDPC FEC Matrix ID field, input the ID of either a:

+ 1) LDPC Generator Matrix variable, or

+ 2) LDPC Parity Check Matrix variable

+

+ Max iterations may be increased from 100 for possibly better performance, but significantly higher number of iterations may slow things down.

+

+file_format: 1

+id: variable_ldpc_encoder_G_def

+label: LDPC Encoder Definition (via Generator)

+

+parameters:

+- id: value

+ label: Ignore Me

+ dtype: raw

+ default: '"ok"'

+ hide: all

+- id: ndim

+ label: Parallelism

+ dtype: enum

+ options: ['0', '1', '2']

+- id: dim1

+ label: Dimension 1

+ dtype: int

+ default: '1'

+ hide: ${ ('none' if (int(ndim) >= 1) else 'all') }

+- id: dim2

+ label: Dimension 2

+ dtype: int

+ default: '1'

+ hide: ${ ('none' if (int(ndim) >= 2) else 'all') }

+- id: G

+ label: LDPC Generator Matrix

+ dtype: raw

+value: ${ value }

+

+templates:

+ imports: from gnuradio import fec

+ var_make: "\n% if int(ndim)==0 #:\nself.${id} = ${id} = fec.ldpc_gen_mtrx_encoder_make(${G})\n\

+ % elif int(ndim)==1 #:\nself.${id} = ${id} = map((lambda a: fec.ldpc_gen_mtrx_encoder_make(${G})),\

+ \ range(0,${dim1})) \n% else:\nself.${id} = ${id} = map((lambda b: map((lambda\

+ \ a: fec.ldpc_gen_mtrx_encoder_make(${G})), range(0,${dim2}))), range(0,${dim1}))\

+ \ \n% endif"

+

+documentation: |-

+ Given a generator matrix in systematic form, G = [I|P], where I is the identity matrix and P is the parity submatrix, the information word s is encoded into a codeword x via:

+

+ x = G'*s

+

+file_format: 1

+id: variable_ldpc_encoder_H_def

+label: LDPC Encoder Definition (via Parity Check)

+

+parameters:

+- id: value

+ label: Ignore Me

+ dtype: raw

+ default: '"ok"'

+ hide: all

+- id: ndim

+ label: Parallelism

+ dtype: enum

+ options: ['0', '1', '2']

+- id: dim1

+ label: Dimension 1

+ dtype: int

+ default: '1'

+ hide: ${ ('none' if (int(ndim) >= 1) else 'all') }

+- id: dim2

+ label: Dimension 2

+ dtype: int

+ default: '1'

+ hide: ${ ('none' if (int(ndim) >= 2) else 'all') }

+- id: H

+ label: Parity Check Matrix

+ dtype: raw

+value: ${ value }

+

+templates:

+ imports: from gnuradio import fec

+ var_make: "\n% if int(ndim)==0 #:\nself.${id} = ${id} = fec.ldpc_par_mtrx_encoder_make_H(${H})\n\

+ % elif int(ndim)==1 #:\nself.${id} = ${id} = map((lambda a: fec.ldpc_par_mtrx_encoder_make_H(${H})),\

+ \ range(0,${dim1})) \n% else:\nself.${id} = ${id} = map((lambda b: map((lambda\

+ \ a: fec.ldpc_par_mtrx_encoder_make_H(${H})), range(0,${dim2}))), range(0,${dim1}))\

+ \ \n% endif"

+

+documentation: |-

+ This block creates a LDPC Encoder Definition variable.

+

+ This encoder performs a reduced complexity algorithm described by Richardson and Urbanke in Appendix A of their book: Modern Coding Theory. Compared to the block "LDPC Encoder Definition (via Generator)," this encoder requires orders of magnitude fewer operations to create each codeword. This is accomplished by completing a significant amount of the complex matrix manipulation (including inverse, multiplication, and Gaussian elimination operations) during preprocessing. The disadvantage of this encoder is that it requires a specially formatted matrix. However, GNU Radio includes python scripts to format a standard parity check matrix appropriately for this encoder, as well as a small library of encoding-ready matrices for use.

+

+file_format: 1

+id: variable_polar_code_configurator

+label: POLAR code Configurator

+

+parameters:

+- id: channel

+ label: Channel

+ dtype: string

+ default: polar.CHANNEL_TYPE_BEC

+ options: [polar.CHANNEL_TYPE_BEC, polar.CHANNEL_TYPE_AWGN]

+ option_labels: [BEC, AWGN]

+- id: block_size

+ label: Block size (N)

+ dtype: int

+ default: '32'

+- id: num_info_bits

+ label: Info Bits (K)

+ dtype: int

+ default: '16'

+- id: design_snr

+ label: design SNR

+ dtype: float

+ default: '0.0'

+- id: mu

+ label: mu

+ dtype: int

+ default: '16'

+value: ${ polar.load_frozen_bits_info(True, channel, block_size, num_info_bits, design_snr,

+ mu) }

+

+templates:

+ imports: from gnuradio.fec import polar

+ var_make: self.${id} = ${id} = polar.load_frozen_bits_info(False, ${channel},

+ ${block_size}, ${num_info_bits}, ${design_snr}, ${mu})

+

+documentation: "This block serves as an interface to the underlying Python functions\

+ \ for channel construction.\n \n Current channel types are: BEC/AWGN\n Block\

+ \ size must be a power of 2!\n Info Bits must be 0 smaller K smaller N\n Design\

+ \ SNR does affect the target transmission SNR and thus performance.\n The parameter\

+ \ mu is only relevant for AWGN channels. It is passed on to the corresponding\

+ \ Channel construction algorithm."

+

+file_format: 1

+id: variable_polar_decoder_sc_def

+label: POLAR Decoder SC Definition

+

+parameters:

+- id: ndim

+ label: Parallelism

+ dtype: enum

+ default: '0'

+ options: ['0', '1', '2']

+- id: dim1

+ label: Dimension 1

+ dtype: int

+ default: '1'

+ hide: ${ ('none' if (int(ndim) >= 1) else 'all') }

+- id: dim2

+ label: Dimension 2

+ dtype: int

+ default: '4'

+ hide: ${ ('none' if (int(ndim) >= 2) else 'all') }

+- id: block_size

+ label: Block size (N)

+ dtype: int

+- id: num_info_bits

+ label: '#Info Bits (K)'

+ dtype: int

+- id: frozen_bit_positions

+ label: Frozen Bit Positions

+ dtype: int_vector

+- id: frozen_bit_values

+ label: Frozen Bit Values

+ dtype: int_vector

+value: ${ fec.polar_decoder_sc.make(block_size, num_info_bits, frozen_bit_positions,

+ frozen_bit_values) }

+

+templates:

+ imports: from gnuradio import fec

+ var_make: "% if int(ndim)==0 #:\nself.${id} = ${id} = fec.polar_decoder_sc.make(${block_size},\

+ \ ${num_info_bits}, ${frozen_bit_positions}, ${frozen_bit_values}) \n% elif\

+ \ int(ndim)==1 #:\nself.${id} = ${id} = map((lambda a: fec.polar_decoder_sc.make(${block_size},\

+ \ ${num_info_bits}, ${frozen_bit_positions}, ${frozen_bit_values})), range(0,\

+ \ ${dim1}) ) \n% else:\nself.${id} = ${id} = map((lambda b: map((lambda a:\

+ \ fec.polar_decoder_sc.make(${block_size}, ${num_info_bits}, ${frozen_bit_positions},\

+ \ ${frozen_bit_values})), range(0, ${dim2}))), range(0, ${dim1})) \n% endif"

+

+file_format: 1

+id: variable_polar_decoder_sc_list_def

+label: POLAR Decoder SC List Definition

+

+parameters:

+- id: ndim

+ label: Parallelism

+ dtype: enum

+ default: '0'

+ options: ['0', '1', '2']

+- id: dim1

+ label: Dimension 1

+ dtype: int

+ default: '1'

+ hide: ${ ('none' if (int(ndim) >= 1) else 'all') }

+- id: dim2

+ label: Dimension 2

+ dtype: int

+ default: '4'

+ hide: ${ ('none' if (int(ndim) >= 2) else 'all') }

+- id: max_list_size

+ label: Maximum List Size (L)

+ dtype: int

+- id: block_size

+ label: Block size (N)

+ dtype: int

+- id: num_info_bits

+ label: '#Info Bits (K)'

+ dtype: int

+- id: frozen_bit_positions

+ label: Frozen Bit Positions

+ dtype: int_vector

+- id: frozen_bit_values

+ label: Frozen Bit Values

+ dtype: int_vector

+value: ${ fec.polar_decoder_sc_list.make(max_list_size, block_size, num_info_bits,

+ frozen_bit_positions, frozen_bit_values) }

+

+templates:

+ imports: from gnuradio import fec

+ var_make: "% if int(ndim)==0 #:\nself.${id} = ${id} = fec.polar_decoder_sc_list.make(${max_list_size},\

+ \ ${block_size}, ${num_info_bits}, ${frozen_bit_positions}, ${frozen_bit_values})\

+ \ \n% elif int(ndim)==1 #:\nself.${id} = ${id} = map((lambda a: fec.polar_decoder_sc_list.make(${max_list_size},\

+ \ ${block_size}, ${num_info_bits}, ${frozen_bit_positions}, ${frozen_bit_values})),\

+ \ range(0, ${dim1})) \n% else:\nself.${id} = ${id} = map((lambda b: map((lambda\

+ \ a: fec.polar_decoder_sc_list.make(${max_list_size}, ${block_size}, ${num_info_bits},\

+ \ ${frozen_bit_positions}, ${frozen_bit_values})), range(0, ${dim2}))), range(0,\

+ \ ${dim1})) \n% endif"

+

+file_format: 1

+id: variable_polar_decoder_sc_systematic_def

+label: systematic POLAR Decoder SC Definition

+

+parameters:

+- id: ndim

+ label: Parallelism

+ dtype: enum

+ default: '0'

+ options: ['0', '1', '2']

+- id: dim1

+ label: Dimension 1

+ dtype: int

+ default: '1'

+ hide: ${ ('none' if (int(ndim) >= 1) else 'all') }

+- id: dim2

+ label: Dimension 2

+ dtype: int

+ default: '4'

+ hide: ${ ('none' if (int(ndim) >= 2) else 'all') }

+- id: block_size

+ label: Block size (N)

+ dtype: int

+- id: num_info_bits

+ label: '#Info Bits (K)'

+ dtype: int

+- id: frozen_bit_positions

+ label: Frozen Bit Positions

+ dtype: int_vector

+value: ${ fec.polar_decoder_sc_systematic.make(block_size, num_info_bits, frozen_bit_positions)

+ }

+

+templates:

+ imports: from gnuradio import fec

+ var_make: "% if int(ndim)==0 #:\nself.${id} = ${id} = fec.polar_decoder_sc_systematic.make(${block_size},\

+ \ ${num_info_bits}, ${frozen_bit_positions}) \n% elif int(ndim)==1 #:\nself.${id}\

+ \ = ${id} = map((lambda a: fec.polar_decoder_sc_systematic.make(${block_size},\

+ \ ${num_info_bits}, ${frozen_bit_positions})), range(0, ${dim1}) ) \n% else:\n\

+ self.${id} = ${id} = map((lambda b: map((lambda a: fec.polar_decoder_sc_systematic.make(${block_size},\

+ \ ${num_info_bits}, ${frozen_bit_positions})), range(0, ${dim2}))), range(0,\

+ \ ${dim1})) \n% endif"

+

+file_format: 1

+id: variable_polar_encoder_def

+label: POLAR Encoder Definition

+

+parameters:

+- id: is_packed

+ label: Packed Bits

+ dtype: enum

+ default: 'False'

+ options: ['False', 'True']

+ option_labels: ['No', 'Yes']

+- id: ndim

+ label: Parallelism

+ dtype: enum

+ default: '0'

+ options: ['0', '1', '2']

+- id: dim1

+ label: Dimension 1

+ dtype: int

+ default: '1'

+ hide: ${ ('none' if (int(ndim) >= 1) else 'all') }

+- id: dim2

+ label: Dimension 2

+ dtype: int

+ default: '4'

+ hide: ${ ('none' if (int(ndim) >= 2) else 'all') }

+- id: block_size

+ label: Block size (N)

+ dtype: int

+- id: num_info_bits

+ label: '#Info Bits (K)'

+ dtype: int

+- id: frozen_bit_positions

+ label: Frozen Bit Positions

+ dtype: int_vector

+- id: frozen_bit_values

+ label: Frozen Bit Values

+ dtype: int_vector

+value: ${ fec.polar_encoder.make(block_size, num_info_bits, frozen_bit_positions,

+ frozen_bit_values, is_packed) }

+

+templates:

+ imports: from gnuradio import fec

+ var_make: "% if int(ndim)==0 #:\nself.${id} = ${id} = fec.polar_encoder.make(${block_size},\

+ \ ${num_info_bits}, ${frozen_bit_positions}, ${frozen_bit_values}, ${is_packed})\

+ \ \n% elif int(ndim)==1 #:\nself.${id} = ${id} = map((lambda a: fec.polar_encoder.make(${block_size},\

+ \ ${num_info_bits}, ${frozen_bit_positions}, ${frozen_bit_values}, ${is_packed})),\

+ \ range(0, ${dim1})) \n% else:\nself.${id} = ${id} = map((lambda b: map((lambda\

+ \ a: fec.polar_encoder.make(${block_size}, ${num_info_bits}, ${frozen_bit_positions},\

+ \ ${frozen_bit_values}, ${is_packed})), range(0, ${dim2}))), range(0, ${dim1}))\

+ \ \n% endif"

+

+file_format: 1

+id: variable_polar_encoder_systematic_def

+label: systematic POLAR Encoder Definition

+

+parameters:

+- id: ndim

+ label: Parallelism

+ dtype: enum

+ default: '0'

+ options: ['0', '1', '2']

+- id: dim1

+ label: Dimension 1

+ dtype: int

+ default: '1'

+ hide: ${ ('none' if (int(ndim) >= 1) else 'all') }

+- id: dim2

+ label: Dimension 2

+ dtype: int

+ default: '4'

+ hide: ${ ('none' if (int(ndim) >= 2) else 'all') }

+- id: block_size

+ label: Block size (N)

+ dtype: int

+- id: num_info_bits

+ label: '#Info Bits (K)'

+ dtype: int

+- id: frozen_bit_positions

+ label: Frozen Bit Positions

+ dtype: int_vector

+value: ${ fec.polar_encoder_systematic.make(block_size, num_info_bits, frozen_bit_positions)

+ }

+

+templates:

+ imports: from gnuradio import fec

+ var_make: "% if int(ndim)==0 #:\nself.${id} = ${id} = fec.polar_encoder_systematic.make(${block_size},\

+ \ ${num_info_bits}, ${frozen_bit_positions}) \n% elif int(ndim)==1 #:\nself.${id}\

+ \ = ${id} = map((lambda a: fec.polar_encoder_systematic.make(${block_size},\

+ \ ${num_info_bits}, ${frozen_bit_positions})), range(0, ${dim1})) \n% else:\n\

+ self.${id} = ${id} = map((lambda b: map((lambda a: fec.polar_encoder_systematic.make(${block_size},\

+ \ ${num_info_bits}, ${frozen_bit_positions})), range(0, ${dim2}))), range(0,\

+ \ ${dim1})) \n% endif"

+

+file_format: 1

+id: variable_repetition_decoder_def

+label: Repetition Decoder Definition

+

+parameters:

+- id: value

+ label: Ignore Me

+ dtype: raw

+ default: '"ok"'

+ hide: all

+- id: ndim

+ label: Parallelism

+ dtype: enum

+ options: ['0', '1', '2']

+- id: dim1

+ label: Dimension 1

+ dtype: int

+ default: '1'

+ hide: ${ ('none' if (int(ndim) >= 1) else 'all') }

+- id: dim2

+ label: Dimension 2

+ dtype: int

+ default: '1'

+ hide: ${ ('none' if (int(ndim) >= 2) else 'all') }

+- id: framebits

+ label: Frame Bits

+ dtype: int

+ default: '2048'

+- id: rep

+ label: Repetitions

+ dtype: int

+ default: '3'

+- id: prob

+ label: a prior prob

+ dtype: float

+ default: '0.5'

+value: ${ fec.repetition_decoder.make(framebits, rep, prob) }

+

+templates:

+ imports: from gnuradio import fec

+ var_make: "\n% if int(ndim)==0 #:\nself.${id} = ${id} = fec.repetition_decoder.make(${framebits},\

+ \ ${rep}, ${prob})\n% elif int(ndim)==1 #:\nself.${id} = ${id} = map( (lambda\

+ \ a: fec.repetition_decoder.make(${framebits}, ${rep}, ${prob})), range(0,${dim1})\

+ \ ) \n% else:\nself.${id} = ${id} = map( (lambda b: map( ( lambda a: fec.repetition_decoder.make(${framebits},\

+ \ ${rep}, ${prob})), range(0,${dim2}) ) ), range(0,${dim1})) \n% endif\n \

+ \ "

+

+documentation: ""

+

+file_format: 1

+id: variable_repetition_encoder_def

+label: Repetition Encoder Definition

+

+parameters:

+- id: ndim

+ label: Parallelism

+ dtype: enum

+ options: ['0', '1', '2']

+- id: dim1

+ label: Dimension 1

+ dtype: int

+ default: '1'

+ hide: ${ ('none' if (int(ndim) >= 1) else 'all') }

+- id: dim2

+ label: Dimension 2

+ dtype: int

+ default: '1'

+ hide: ${ ('none' if (int(ndim) >= 2) else 'all') }

+- id: framebits

+ label: Frame Bits

+ dtype: int

+ default: '2048'

+- id: rep

+ label: Repetitions

+ dtype: int

+ default: '3'

+value: ${ fec.repetition_encoder_make(framebits, rep) }

+

+templates:

+ imports: from gnuradio import fec

+ var_make: "\n% if int(ndim)==0 #:\nself.${id} = ${id} = fec.repetition_encoder_make(${framebits},\

+ \ ${rep})\n% elif int(ndim)==1 #:\nself.${id} = ${id} = map((lambda a: fec.repetition_encoder_make(${framebits},\

+ \ ${rep})), range(0,${dim1})) \n% else:\nself.${id} = ${id} = map((lambda\

+ \ b: map((lambda a: fec.repetition_encoder_make(${framebits}, ${rep})), range(0,${dim2}))),\

+ \ range(0,${dim1})) \n% endif\n "

+

+documentation: ""

+

+file_format: 1