+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

+#include <vector>

+

+ GR_ADD_TEST(${py_qa_test_name} ${QA_PYTHON_EXECUTABLE} -B ${py_qa_test_file})

+from __future__ import print_function

+from __future__ import absolute_import

+from __future__ import division

+from __future__ import unicode_literals

+

+from .Generate_LDPC_matrix_functions import *

+# Print(out some of the resulting properties.)

+print("Parity check matrix properties:")

+print("\tSize :", bestH.shape)

+print("\tRank :", linalg.matrix_rank(bestH))

+print("\tRate : %.3f" % ((k*1.0) / n))

+print("\tn :", n, " (codeword length)")

+print("\tk :", k, " (info word length)")

+print("\tgap : %i" % g)

+print('\nMatrix saved to alist file:', alist_filename, "\n")

+from __future__ import print_function

+from __future__ import division

+from __future__ import unicode_literals

+

+ # The subsequent lines in the file list the indices for where

+ # the 1s are in the rows, but this is redundant

+ # information.

+ tempstring = repr(numCols) + ' ' + repr(numRows) + '\n'

+ tempstring1 = tempstring1 + repr(rowWeight) + ' '

+ tempstring2 = tempstring2 + repr(index+1) + ' '

+ tempstring2 = tempstring2 + '\n'

+ tempstring1 = tempstring1 + '\n'

+ tempstring3 = tempstring3 + repr(colWeight) + ' '

+ tempstring4 = tempstring4 + repr(index+1) + ' '

+ tempstring4 = tempstring4 + '\n'

+ tempstring3 = tempstring3 + '\n'

+ tempstring = repr(maxColWeight) + ' ' + repr(maxRowWeight) + '\n'

+class LDPC_matrix(object):

+ n_p_q = None,

+ H_matrix = None):

+ print('Error: provide either an alist filename, ', end='')

+ print('parameters for constructing regular LDPC parity, ', end='')

+ print('check matrix, or a numpy array.')

+ ratioTest = (n*1.0) / q

+ print('\nError in regular_LDPC_code_contructor: The ', end='')

+ print('ratio of inputs n/q must be a whole number.\n')

+ m = (n*p) / q # number of rows in H matrix

+ submatrix1 = zeros((m / p,n))

+ for row in arange(m / p):

+ H = submatrix1

+ submatrix = zeros((m / p,n))

+ submatrix1[:,newColumnOrder[columnNum]]

+ print('Row', rowNum, 'has incorrect weight!')

+ print('Row', columnNum, 'has incorrect weight!')

+ print('Rank of H:', linalg.matrix_rank(tempArray))

+ print('H has', H_t.shape[0], 'rows')

+ print('Error: H must be full rank.')

+ return

+ .nonzero()[1]

+ .nonzero()[0]

+ H_t = Htemp.copy()

+ Htemp = H_t.copy()

+ print('Error: gap is 0.')

+ print('Initial phi is singular')

+ print('Initial phi is nonsingular')

+ print('Initial phi is all zeros:\n', phi)

+ print('C and D are all zeros. There is no hope in',)

+ print('finding a nonsingular phi matrix. ')

+ print('iterationCount:', iterationCount)

+ tempH = H_t.copy()

+ H_t[:,oldColumnNumber]

+ print('Phi is still singular')

+ print('Found a nonsingular phi on',)

+ print('iterationCount = ', iterationCount)

+ print('phi is all zeros')

+ print('--- Error: nonsingular phi matrix not found.')

+ print('In inv_mod2. Rounding error on this',)

+ print('value? Mod 2 has already been done.',)

+ print('value:', value)

+ print('Error in inv_mod2: did not find inverse.')

+ # TODO is this the most appropriate error to raise?

+ print('Returning H; it is already full rank.')

+ print('In get_full_rank_H_matrix; i:', i)

+ # Flag indicating that the row contains a non-zero entry

+ print('original H.shape:', H.shape)

+ print('newH.shape:', newH.shape)

+ print('--- In get_best_matrix, iteration:', index)

+ index += 1

+ except ValueError as e:

+ print('greedy_upper_triangulation error: ', e)

+ print('Error: Could not find appropriate H form',)

+ print('for encoding.')

+ This function does not convert parity check (H) matrices to the

+ # the rows below i are the dependent rows, which we discard

+ print('received H with size: ', H.shape)

+ print('returning G with size: ', G.shape)

+ return G

+from __future__ import absolute_import

+from __future__ import unicode_literals

+from .Generate_LDPC_matrix_functions import *

+from __future__ import absolute_import

+from __future__ import unicode_literals

+

+ from .fec_swig import *

+ from .fec_swig import *

+from .bitflip import *

+from .extended_encoder import extended_encoder

+from .extended_decoder import extended_decoder

+from .threaded_encoder import threaded_encoder

+from .threaded_decoder import threaded_decoder

+from .capillary_threaded_decoder import capillary_threaded_decoder

+from .capillary_threaded_encoder import capillary_threaded_encoder

+from .extended_async_encoder import extended_async_encoder

+from .extended_tagged_encoder import extended_tagged_encoder

+from .extended_tagged_decoder import extended_tagged_decoder

+from .fec_test import fec_test

+from .bercurve_generator import bercurve_generator

+from __future__ import print_function

+from __future__ import absolute_import

+from __future__ import unicode_literals

+

+

+import numpy

+

+from gnuradio import gr, blocks

+# Must use absolute import here because this file is not installed as part

+# of the module

+from gnuradio.fec import extended_encoder

+from gnuradio.fec import extended_decoder

+ output_items[0][:] = [self.bitmap[x] for x in input_items[0]]

+ print("Decoded properly")

+ print("Problem Decoding")

+from __future__ import absolute_import

+from __future__ import unicode_literals

+from .fec_test import fec_test

+ self.random_gen_b_0 = blocks.vector_source_b(list(map(int, numpy.random.randint(0, 256, 100000))), True)

+from __future__ import division

+from __future__ import unicode_literals

+

+

+

+ for j in range(0, len(bitlist) / 64):

+ for i in range(1, len(symlist[0]) / 2):

+ invlist[i] = symlist[0][i + len(symlist[0]) / 2];

+ invlist[i + len(symlist[0]) / 2] = symlist[0][i];

+from __future__ import division

+from __future__ import unicode_literals

+

+from gnuradio import gr, blocks

+from . import fec_swig as fec

+

+

+ for i in range(len(decoder_list_0) // 2):

+ for i in range(len(decoder_list_0) // 2):

+from __future__ import division

+from __future__ import unicode_literals

+

+from gnuradio import gr, blocks

+from . import fec_swig as fec

+

+

+ self.generic_encoders_0 = [];

+ for i in range(len(encoder_list_0) // 2):

+ for i in range(len(encoder_list_0) // 2):

+ if((len(self.encoder_list_0)) > 1):

+from __future__ import print_function

+from __future__ import absolute_import

+from __future__ import unicode_literals

+

+from gnuradio import gr

+

+from . import fec_swig as fec

+from .bitflip import read_bitlist

+

+

+from __future__ import print_function

+from __future__ import absolute_import

+from __future__ import division

+from __future__ import unicode_literals

+from gnuradio import gr, blocks, digital

+

+from . import fec_swig as fec

+

+from .bitflip import *

+from .threaded_decoder import threaded_decoder

+from .capillary_threaded_decoder import capillary_threaded_decoder

+ #print(str(log((1-(2 * .035)), (1-(2 * i)))) + ':' + str(i);)

+ idx_list = list(self.garbletable.keys())

+ if 1.0 / self.ann.count('1') >= i:

+ print('using syndrom garble threshold ' + str(synd_garble) + 'for conv_bit_corr_bb')

+ print('ceiling: .0335 data garble rate')

+from __future__ import absolute_import

+from __future__ import unicode_literals

+

+from . import fec_swig as fec

+from .threaded_encoder import threaded_encoder

+from .capillary_threaded_encoder import capillary_threaded_encoder

+from .bitflip import read_bitlist

+

+from __future__ import print_function

+from __future__ import absolute_import

+from __future__ import division

+from __future__ import unicode_literals

+

+from gnuradio import gr, blocks, digital

+

+from . import fec_swig as fec

+

+from .bitflip import *

+ #print(str(log((1-(2 * .035)), (1-(2 * i)))) + ':' + str(i);)

+ idx_list = list(self.garbletable.keys())

+ if 1.0 / self.ann.count('1') >= i:

+ print('using syndrom garble threshold ' + str(synd_garble) + 'for conv_bit_corr_bb')

+ print('ceiling: .0335 data garble rate')

+from __future__ import absolute_import

+from __future__ import unicode_literals

+

+

+from . import fec_swig as fec

+

+from .bitflip import read_bitlist

+

+from __future__ import absolute_import

+from __future__ import division

+from __future__ import unicode_literals

+if "gnuradio.digital" in sys.modules:

+from .extended_encoder import extended_encoder

+from .extended_decoder import extended_decoder

+ noise = math.sqrt((10.0**(old_div(-esno / 10.0)),2.0))

+ encoder.py

+ decoder.py

+ common.py

+from __future__ import print_function

+from __future__ import absolute_import

+from __future__ import unicode_literals

+from . import channel_construction as cc

+from .channel_construction_bec import bhattacharyya_bounds

+from .helper_functions import is_power_of_two

+from __future__ import print_function

+from __future__ import absolute_import

+from .channel_construction_bec import calculate_bec_channel_capacities

+from .channel_construction_bec import design_snr_to_bec_eta

+from .channel_construction_bec import bhattacharyya_bounds

+from .channel_construction_awgn import tal_vardy_tpm_algorithm

+from .helper_functions import *

+ print('channel construction Bhattacharyya bounds by Arikan')