/**
* @ingroup dac_sink
*
* \param freq_samp Sets DA converter sampling frequency
*/
int initialize() {
buffer = rtdal_uhd_buffer(1);
freq_id = param_id("freq_samp");
if (!freq_id) {
moderror("Parameter freq_samp not found\n");
return -1;
}
gain_id = param_id("gain");
if (param_get_int_name("data_type", &data_type)) {
data_type = 1;
}
switch(data_type) {
case 0:
input_sample_sz = sizeof(float);
break;
case 1:
input_sample_sz = sizeof(_Complex float);
break;
case 2:
input_sample_sz = sizeof(_Complex short);
break;
}
return 0;
}
/**@ingroup gen_remcyclic
*
* \param dft_size Size of the OFDM symbol (in samples). This parameter is mandatory.
* \param cyclic_prefix_sz Size of the cyclic prefix to add to each received symbol (in samples)
* This parameter is mandatory.
* \param first_cyclic_prefix_sz Size of the cyclic prefix to add to the first received symbol
* (in samples). Optional parameter, default is cyclic_prefix_sz
*/
int initialize() {
dft_size_id = param_id("dft_size");
if (!dft_size_id) {
/*moderror("Parameter dft_size undefined\n");
return -1;*/
modinfo("Parameter dft_size not defined. Assuming "
"dft_size = number of input samples on interface 0 - cyclic_prefix_sz.\n");
}
cyclic_prefix_sz_id = param_id("cyclic_prefix_sz");
if (!cyclic_prefix_sz_id) {
moderror("Parameter cyclic_prefix_sz undefined\n");
return -1;
}
first_cyclic_prefix_sz_id = param_id("first_cyclic_prefix_sz");
if (NOF_INPUT_ITF != NOF_OUTPUT_ITF) {
moderror_msg("Fatal error, the number of input interfaces (%d) must be equal to the "
"number of output interfaces (%d)\n",NOF_INPUT_ITF,NOF_OUTPUT_ITF);
return -1;
}
return 0;
}
/**
* @ingroup Lte Rate Matching of convolutionally encoded information
* Applied for PDCCH
* Initialization function
*
* \param direction Transmitter mode if 0 and receiver mode otherwise
* \param E Number of output bits of rate matching in transmitter mode
* \param S Number of output bits of rate matching in receiver mode
*
* \returns This function returns 0 on success or -1 on error
*/
int initialize() {
if (param_get_int_name("direction", &direction)) {
moderror_msg("Parameter 'direction' not specified. Assuming "
"transmission mode (%d).\n", 0);
direction = 0;
}
if (direction) {
/* Reception mode */
S_id = param_id("S");
if (!S_id) {
moderror("Parameter S not found\n");
return -1;
}
input_sample_sz=sizeof(float);
output_sample_sz=sizeof(float);
} else {
/* Transmission mode */
E_id = param_id("E");
if (!E_id) {
moderror("Parameter E not found\n");
return -1;
}
input_sample_sz=sizeof(char);
output_sample_sz=sizeof(char);
}
return 0;
}
/**@ingroup source
*
* The available generators are defined in generators.h
* \param block_length Number of items (bits or samples) to generate
* \param generator Integer indicating the generator (see generators.h)
*
*/
int initialize() {
int size;
int block_length;
blen_id = param_id("block_length");
if (!blen_id) {
moderror("Parameter block_length not found\n");
return -1;
}
if (param_get_int(blen_id,&block_length) != 1) {
moderror("Getting integer parameter block_length\n");
return -1;
}
period=1;
param_get_int_name("period",&period);
period_cnt=period;
generator_init_random();
moddebug("Parameter block_length is %d\n",block_length);
gen_id = param_id("generator");
if (!gen_id) {
moderror("Parameter type not found\n");
return -1;
}
last_type = -1;
return 0;
}
/**
* @ingroup dac_source
*
* \param rate Sets DA converter sampling rateuency
*/
int initialize() {
var_t pm;
pm = oesr_var_param_get(ctx, "board");
if (!pm) {
moderror("Parameter board undefined\n");
return -1;
}
if (oesr_var_param_get_value(ctx, pm, board, 128) == -1) {
moderror("Error getting board value\n");
return -1;
}
pm = oesr_var_param_get(ctx, "args");
if (pm) {
if (oesr_var_param_get_value(ctx, pm, args, 128) == -1) {
moderror("Error getting board value\n");
return -1;
}
} else {
bzero(args,128);
}
blocking=0;
param_get_int_name("blocking",&blocking);
wait_packets=0;
param_get_int_name("wait_packets",&wait_packets);
nsamples_id = param_id("nsamples");
if (!nsamples_id) {
moderror("Parameter nsamples not found\n");
return -1;
}
rate_id = param_id("rate");
if (!rate_id) {
moderror("Parameter rate not found\n");
return -1;
}
freq_id = param_id("freq");
if (!freq_id) {
moderror("Parameter freq not found\n");
return -1;
}
gain_id = param_id("gain");
dac = rtdal_dac_open(board,args);
if (!dac) {
moderror_msg("Initiating DAC %s (args=%s)\n",board,args);
return -1;
}
if (process_params()) {
moderror("Setting parameters\n");
return -1;
}
return 0;
}
optional<name> get_undef_param(level const & l, level_param_names const & ps) {
optional<name> r;
for_each(l, [&](level const & l) {
if (!has_param(l) || r)
return false;
if (is_param(l) && std::find(ps.begin(), ps.end(), param_id(l)) == ps.end())
r = param_id(l);
return true;
});
return r;
}
/**
* @ingroup dac_sink
*
* \param rate Sets DA converter sampling rateuency
*/
int initialize() {
var_t pm;
pm = oesr_var_param_get(ctx, "board");
if (!pm) {
moderror("Parameter board undefined\n");
return -1;
}
if (oesr_var_param_get_value(ctx, pm, board, 128) == -1) {
moderror("Error getting board value\n");
return -1;
}
pm = oesr_var_param_get(ctx, "args");
if (pm) {
if (oesr_var_param_get_value(ctx, pm, args, 128) == -1) {
moderror("Error getting board value\n");
return -1;
}
} else {
bzero(args,128);
}
check_blen=0;
param_get_int_name("check_blen",&check_blen);
enable_dac=1;
param_get_int_name("enable_dac",&enable_dac);
rate_id = param_id("rate");
if (!rate_id) {
moderror("Parameter rate not found\n");
return -1;
}
freq_id = param_id("freq");
if (!freq_id) {
moderror("Parameter freq not found\n");
return -1;
}
gain_id = param_id("gain");
amp_id = param_id("amplitude");
blocking=0;
param_get_int_name("blocking",&blocking);
if (!enable_dac) {
modinfo("Warning: DAC is disabled\n");
}
dac = rtdal_dac_open(board,args);
return process_params();
}
/** @ingroup gen_convcoderr
* \param padding (Optional) Default 0. Number of zero bits to add to the output after encoding the data.
* \param constraint_length
* \param tail_bit 1 for tail-bitting, 0 for none
* \param rate
* \param generator_i polynomy of the i-th generator
*/
int initialize() {
int i;
char tmp[64];
padding_id = param_id("padding");
if (!padding_id) {
padding = 0;
moddebug("Parameter padding not configured. Setting to %d\n",padding);
}
if (param_get_int_name("constraint_length",&constraint_length)) {
moderror("Parameter constraint_length not specified\n");
return -1;
}
if (param_get_int_name("tail_bit",&tail_bit)) {
moderror("Parameter tail_bit not specified\n");
return -1;
}
if (param_get_int_name("rate",&rate)) {
moderror("Parameter rate not specified\n");
return -1;
}
if (rate<0 || rate > MAX_RATE) {
moderror_msg("Invalid rate %d\n",rate);
return -1;
}
for (i=0;i<rate;i++) {
snprintf(tmp,64,"generator_%d",i);
if (param_get_int_name(tmp,&g[i])) {
moderror_msg("Parameter %s not specified\n",tmp);
return -1;
}
}
return 0;
}
/** Stores in the address of the second parameter the scalar float value of the
* parameter name.
* Tries to parse the parameter as an float. Read param_addr() for supported formats.
* \returns 0 on success or -1 on error.
*/
int param_get_float_name(char *name, float *value) {
pmid_t id = param_id(name);
if (id == NULL) {
return -1;
}
return (param_get_float(id,value)==-1)?-1:0;
}
/**
* @ingroup udp_sink
*
* \param address IP address to connect
* \param port Port to connect
*/
int initialize() {
char address[64];
var_t pm;
int i;
int port;
blen_id = param_id("nof_pkts");
if (param_get_int_name("port",&port)) {
moderror("Port undefined\n");
return -1;
}
#ifdef _COMPILE_ALOE
pm = oesr_var_param_get(ctx, "address");
if (!pm) {
moderror("Parameter file_name undefined\n");
return -1;
}
if (oesr_var_param_get_value(ctx, pm, address, 64) == -1) {
moderror("Error getting file_name value\n");
return -1;
}
#endif
fd = create_client_upd(address,port,&servaddr);
if (fd == -1) {
moderror("Creating socket\n");
return -1;
}
modinfo_msg("sock=%d\n",fd);
return 0;
}
/**
* Generates input signal. VERY IMPORTANT to fill length vector with the number of
* samples that have been generated.
* @param inp Input interface buffers. Data from other interfaces is stacked in the buffer.
* Use in(ptr,idx) to access the address.
*
* @param lengths Save on n-th position the number of samples generated for the n-th interface
*/
int generate_input_signal(void *in, int *lengths)
{
int i;
input_t *input = in;
int block_length;
pmid_t blen_id;
blen_id = param_id("block_length");
if (!blen_id) {
moderror("Parameter block_length not found\n");
return -1;
}
if (!param_get_int(blen_id,&block_length)) {
moderror("Getting integer parameter block_length\n");
return -1;
}
modinfo_msg("Parameter block_length is %d\n",block_length);
/** HERE INDICATE THE LENGTH OF THE SIGNAL */
lengths[0] = block_length;
for (i=0;i<block_length;i++) {
input[i] = 0.7 + 0.7*_Complex_I;
}
return 0;
}
/**
* @ingroup gen_hard_demod
* Initializes parameters.
*
* Modulation types: BPSK, QPSK, QAM16, QAM64.
*
* \param modulation Modulation index (0: BPSK, 1: QPSK, 2: QAM16, 3: QAM64).
* Default: 1 (QPSK).
*
* \returns This function returns 0 on success or -1 on error
*/
int initialize() {
/* obtains a handler for fast access to the parameter */
modulation_id = param_id("modulation");
return 0;
}
unsigned level_cases_on(vm_obj const & o, buffer<vm_obj> & data) {
level const & l = to_level(o);
switch (l.kind()) {
case level_kind::Zero:
break;
case level_kind::Succ:
data.push_back(to_obj(succ_of(l)));
break;
case level_kind::Max:
data.push_back(to_obj(max_lhs(l)));
data.push_back(to_obj(max_rhs(l)));
break;
case level_kind::IMax:
data.push_back(to_obj(imax_lhs(l)));
data.push_back(to_obj(imax_rhs(l)));
break;
case level_kind::Param:
data.push_back(to_obj(param_id(l)));
break;
case level_kind::Global:
data.push_back(to_obj(global_id(l)));
break;
case level_kind::Meta:
data.push_back(to_obj(meta_id(l)));
break;
}
return static_cast<unsigned>(l.kind());
}
/**
* Generates input signal. VERY IMPORTANT to fill length vector with the number of
* samples that have been generated.
* @param inp Input interface buffers. Data from other interfaces is stacked in the buffer.
* Use in(ptr,idx) to access the address.
*
* @param lengths Save on n-th position the number of samples generated for the n-th interface
*/
int generate_input_signal(void *in, int *lengths)
{
int i;
input_t *input = in;
int block_length;
pmid_t blen_id;
blen_id = param_id("block_length");
if (!blen_id) {
moderror("Parameter block_length not found\n");
return -1;
}
if (!param_get_int(blen_id,&block_length)) {
moderror("Getting integer parameter block_length\n");
return -1;
}
modinfo_msg("Parameter block_length is %d\n",block_length);
/** HERE INDICATE THE LENGTH OF THE SIGNAL */
lengths[0] = block_length;
for (i=0;i<block_length;i++) {
#ifdef GENESRSLTE_TCOD_RATE_COMPLEX
__real__ input[i] = (float) ((i+offset)%(block_length));
__imag__ input[i] = (float) ((block_length-i-1+offset)%(block_length));
#else
input[i] = (i+offset)%(block_length);
#endif
}
offset++;
return 0;
}
level collect(level const & l) {
return replace(l, [&](level const & l) {
if (is_meta(l)) {
name const & id = meta_id(l);
if (auto r = m_univ_meta_to_param.find(id)) {
return some_level(*r);
} else {
name n = m_prefix.append_after(m_next_idx);
m_next_idx++;
level new_r = mk_param_univ(n);
m_univ_meta_to_param.insert(id, new_r);
m_univ_meta_to_param_inv.insert(n, l);
m_level_params.push_back(n);
return some_level(new_r);
}
} else if (is_param(l)) {
name const & id = param_id(l);
if (!m_found_univ_params.contains(id)) {
m_found_univ_params.insert(id);
m_level_params.push_back(id);
}
}
return none_level();
});
}
void collect_univ_params_core(level const & l, name_set & r) {
for_each(l, [&](level const & l) {
if (!has_param(l))
return false;
if (is_param(l))
r.insert(param_id(l));
return true;
});
}
int initialize() {
int tslen;
if (param_get_int_name("direction",&mode)) {
mode = MODE_ADD;
}
if (param_get_int_name("print_nof_pkts",&print_nof_pkts)) {
print_nof_pkts = 0;
} else {
print_nof_pkts_cnt = 0;
}
long_crc_id = param_id("long_crc");
if (param_get_int(long_crc_id,&long_crc) != 1) {
modinfo_msg("Parameter long_crc not configured. Set to %d\n",
DEFAULT_LONG_CRC);
long_crc = DEFAULT_LONG_CRC;
long_crc_id = NULL;
}
poly_id = param_id("poly");
if (param_get_int(poly_id,&poly) != 1) {
poly = DEFAULT_POLY;
poly_id = NULL;
}
#ifdef _COMPILE_ALOE
tslen = oesr_tslot_length(ctx);
if (tslen > EXEC_MIN_INTERVAL_MS*1000) {
interval_ts = 1;
} else {
interval_ts = (EXEC_MIN_INTERVAL_MS*1000)/tslen;
modinfo_msg("Timeslot is %d usec, refresh interval set to %d tslots\n",tslen,interval_ts);
}
#endif
total_errors=0;
total_pkts=0;
tscnt=0;
return 0;
}
/**
* @ingroup channel
*
* \param variance Gaussian noise variance
* \param gain Channel gain
*
* \returns This function returns 0 on success or -1 on error
*/
int initialize() {
gain_re_id = param_id("gain_re");
gain_im_id = param_id("gain_im");
variance_id = param_id("variance");
scale_id = param_id("noise_scale");
if (!param_get_float_name("snr_min",&snr_min)
&& !param_get_float_name("snr_max",&snr_max)
&& !param_get_float_name("snr_step",&snr_step)
&& !param_get_int_name("num_realizations",&num_realizations)) {
auto_mode=1;
snr_current=snr_min;
cnt_realizations=0;
} else {
auto_mode=0;
}
return 0;
}
/**
* @ingroup gen_hard_demod
* Initializes parameters.
*
* Modulation types: BPSK, QPSK, QAM16, QAM64.
*
* \param modulation Modulation index (1: BPSK, 2: QPSK, 4: QAM16, 6: QAM64).
* Default: 1 (BPSK).
*
* \returns This function returns 0 on success or -1 on error
*/
int initialize() {
/* obtains a handler for fast access to the parameter */
modulation_id = param_id("modulation");
param_get_int_name("in_real",&in_real);
if (in_real == 1) {
input_sample_sz=sizeof(float);
}
return 0;
}
/**
* @ingroup Zero padding/unpadding
* This module has two operational modes.
* Zero-padding mode (direction = 0): Pads pre_padding and post_padding zeros
* to each of the nof_packets data packets
* Sample-unpadding mode (direction != 0): Eliminates pre_padding and
* post_padding samples from each of the nof_packets data packets
*
* \param data_type Specify data type: 0 for _Complex float, 1 for real, 2 for
* char (default: 0)
* \param direction Padding if 0 and unpadding otherwise (default: 0)
* \param pre_padding Number of samples to be added to/ eliminated from the
* beginning of the packet
* \param post_padding Number of samples to be added to/ eliminated from the
* end of the packet
* \param nof_packets Number of data packets that the input stream contains
*
* \returns This function returns 0 on success or -1 on error
*/
int initialize() {
int data_type;
if (param_get_int(param_id("data_type"),&data_type) != 1) {
modinfo("Parameter data_type undefined. Using complex data type\n");
data_type = DATA_TYPE_COMPLEX;
}
input_sample_sz = get_input_sample_sz(data_type);
output_sample_sz = input_sample_sz;
moddebug("Chosen data type %d sample_sz=%d\n",data_type, input_sample_sz);
if (param_get_int(param_id("direction"),&direction) != 1) {
modinfo("Parameter direction undefined. Assuming padding mode.\n");
direction = 0;
}
pre_padding_id = param_id("pre_padding");
if (!pre_padding_id) {
modinfo("Parameter pre_padding undefined. Adding 0 bits.\n");
pre_padding = 0;
}
post_padding_id = param_id("post_padding");
if (!post_padding_id) {
modinfo("Parameter post_padding undefined. Adding 0 bits.\n");
post_padding = 0;
}
nof_packets_id = param_id("nof_packets");
if (!nof_packets_id) {
modinfo("Parameter nof_packets undefined. Assuming 1 packet.\n");
nof_packets = 1;
}
return 0;
}
/**@ingroup gen_modulator
*
* \param modulation Choose between 0: BPŜK, 1: QPSK, 2: QAM16 or 3: QAM64. Default is BPSK.
*/
int initialize() {
modulation_id = param_id("modulation");
if (!modulation_id) {
modinfo("Parameter modulation not configured. Setting to BPSK\n");
modulation = BPSK;
}
set_BPSKtable();
set_QPSKtable();
set_16QAMtable();
set_64QAMtable();
return 0;
}
int initialize() {
/* Initialization Parameters */
if (param_get_int_name("cache_seq_nbits", &binsource.init.cache_seq_nbits)) {
binsource.init.cache_seq_nbits = 2;
}
if (param_get_int_name("seed", &binsource.init.seed)) {
binsource.init.seed = 0;
}
/* Input Control Parameters */
nbits_id = param_id("nbits");
/* Initialization function */
return binsource_initialize(&binsource);
}
/**@ingroup gen_dft
* \param direction Direction of the dft: 0 computes a dft and 1 computes an idft (default is 0)
* \param mirror 0 computes a normal dft, 1 swaps the two halfes of the input signal before computing
* the dft (used in LTE) (default is 0)
* \param psd Set to 1 to compute the power spectral density (untested) (default is 0)
* \param out_db Set to 1 to produce the output results in dB (untested) (default is 0)
* \param dft_size Number of DFT points. This parameter is mandatory.
*/
int initialize() {
int tmp;
int i;
memset(plans,0,sizeof(dft_plan_t)*NOF_PRECOMPUTED_DFT);
memset(extra_plans,0,sizeof(dft_plan_t)*MAX_EXTRA_PLANS);
if (param_get_int(param_id("direction"),&direction) != 1) {
modinfo("Parameter direction not defined. Setting to FORWARD\n");
direction = 0;
}
options = 0;
if (param_get_int(param_id("mirror"),&tmp) != 1) {
modinfo("Parameter mirror not defined. Disabling. \n");
} else {
if (tmp) options |= DFT_MIRROR;
}
if (param_get_int(param_id("psd"),&tmp) != 1) {
modinfo("Parameter psd not defined. Disabling. \n");
} else {
if (tmp) options |= DFT_PSD;
}
if (param_get_int(param_id("out_db"),&tmp) != 1) {
modinfo("Parameter out_db not defined. Disabling. \n");
} else {
if (tmp) options |= DFT_OUT_DB;
}
if (param_get_int(param_id("normalize"),&tmp) != 1) {
modinfo("Parameter normalize not defined. Disabling. \n");
} else {
if (tmp) options |= DFT_NORMALIZE;
}
dft_size_id = param_id("dft_size");
if (!dft_size_id) {
moderror("Parameter dft_size not defined\n");
return -1;
}
if (dft_plan_multi_c2c(precomputed_dft_len, (!direction)?FORWARD:BACKWARD, NOF_PRECOMPUTED_DFT,
plans)) {
moderror("Precomputing plans\n");
return -1;
}
for (i=0;i<NOF_PRECOMPUTED_DFT;i++) {
plans[i].options = options;
}
return 0;
}
/**
* @ingroup lte_ratematching
* Rate adapter for LTE DL/UL. Code rate is out_len/in_len
*
* There are two ways to configure this module:
* - Automatic: Choose tslot_idx, modulation and fft_size to let the module
* automatically determine the required output length at each slot, according to the
* LTE slotting
* - Manual: Set out_len variable to the desired output length.
*
* Automatic mode is selected when parameter out_len is not defined.
*
* \param tslot_idx In automatic mode, indicates the tslot index
* \param mcs In automatic mode, indicates the Modulation and Coding Scheme (MCS)
* \param nrb In automatic mode, indicates the Number of allocated Resource Blocs
* \param fft_size In automatic mode, indicates the length of the fft
* \param cp_is_long In automatic mode, non-null selects long cyclic prefix
* \param lteslots_x_timeslot In automatic mode, number of lte slots per execution time slot
* \param out_len Output length
* \param rv_idx Document this parameter
* \param direction 0 for the transmitter, 1 for the receiver
*
* \returns This function returns 0 on success or -1 on error
*/
int initialize() {
int size;
out_len_id = param_id("out_len");
if (!out_len_id) {
tslot_idx_id = param_id("tslot_idx");
tslot_idx = 0;
if (!(fft_size_id = param_id("fft_size"))) {
moderror("In automatic mode, parameter fft_size must be specified\n");
}
if (!(mcs_id = param_id("mcs"))) {
moderror("In automatic mode, parameter mcs must be specified\n");
}
if (!(nrb_id = param_id("nrb"))) {
moderror("In automatic mode, parameter nrb must be specified\n");
}
if (!(cp_long_id = param_id("cp_is_long"))) {
moderror("In automatic mode, parameter cp_is_long must be specified\n");
}
if (param_get_int_name("lteslots_x_timeslot",<eslots_x_timeslot)) {
moderror("In automatic mode, parameter lteslots_x_timeslot must be specified\n");
}
}
rvidx_id = param_id("rvidx");
if (param_get_int_name("direction",&direction)) {
moderror("Error getting parameter direction\n");
return -1;
}
if (direction) {
input_sample_sz=sizeof(float);
output_sample_sz=sizeof(float);
} else {
input_sample_sz=sizeof(char);
output_sample_sz=sizeof(char);
}
tslot_idx=0;
return 0;
}
/**
* @ingroup template
* Document here the module's initialization parameters
*
* The documentation should explain which are the possible parameters, what they do and if they are
* mandatory or optional (indicating the default value in such case).
*
* \param gain Document paramater gain
* \param block_length Document parameter block_length
*
* \returns This function returns 0 on success or -1 on error
*/
int initialize() {
/* obtains a handler for fast access to the parameter */
gain_id = param_id("gain");
/* In this case, we are obtaining the parameter value directly */
if (param_get_int_name("block_length", &block_length)) {
block_length = 0;
}
/* use this function to print formatted messages */modinfo_msg("Parameter block_length is %d\n",block_length);
/* Verify control parameters */
if (block_length > input_max_samples || block_length < 0) {
moderror_msg("Invalid block length %d\n", block_length);
return -1;
}
/* here you may do some other initialization stuff */
return 0;
}
/**
* @ingroup lte_resource_mapper
*
* See lte_ctrl_tx for grid params.
*
* \param nof_channels Number of channels to extract
* \param channel_id_n Id of the n-th channel to extract (configured in channel_setup.h)
* \param (optional) subframe_idx, if not provided, subframe_idx is counted automatically starting at zero
*
* \returns This function returns 0 on success or -1 on error
*/
int initialize() {
int i;
char tmp[64];
int max_out_port;
max_out_port = read_channels();
grid.fft_size = 128;
grid.nof_prb = 6;
grid.nof_osymb_x_subf = 14;
grid.nof_ports = 1;
grid.cell_id = 0;
grid.cfi = -1;
grid.nof_pdsch = 0;
grid.nof_pdcch = 0;
subframe_idx_id = param_id("subframe_idx");
if (!subframe_idx_id) {
subframe_idx = 0;
}
if (param_get_int_name("nof_channels",&nof_channels)) {
nof_channels = 1;
}
if (nof_channels > MAX_CHANNELS) {
moderror_msg("Maximum allowed channels is %d (%d)\n",nof_channels,MAX_CHANNELS);
return -1;
}
for (i=0;i<nof_channels;i++) {
snprintf(tmp,64,"channel_id_%d",i);
if (param_get_int_name(tmp,&channel_ids[i])) {
channel_ids[i] = i;
}
}
nof_output_itf = max_out_port+1;
nof_input_itf = 1;
return 0;
}
level instantiate(level const & l, level_param_names const & ps, levels const & ls) {
lean_assert(length(ps) == length(ls));
return replace(l, [=](level const & l) {
if (!has_param(l)) {
return some_level(l);
} else if (is_param(l)) {
name const & id = param_id(l);
list<name> const *it1 = &ps;
list<level> const * it2 = &ls;
while (!is_nil(*it1)) {
if (head(*it1) == id)
return some_level(head(*it2));
it1 = &tail(*it1);
it2 = &tail(*it2);
}
return some_level(l);
} else {
return none_level();
}
});
}
/**
* @ingroup lte_resource_mapper
*
* See lte_ctrl_tx for grid params.
*
* \param (optional) subframe_idx, if not provided, subframe_idx is counted automatically starting at zero
*
* \returns This function returns 0 on success or -1 on error
*/
int initialize() {
int max_in_port;
max_in_port = read_channels();
grid.fft_size = 128;
grid.nof_prb = 6;
grid.nof_osymb_x_subf = 14;
grid.nof_ports = 1;
grid.cell_id = 0;
grid.cfi = 1;
grid.nof_pdcch = 1;
grid.pdcch[0].nof_cce = 2;
grid.nof_pdsch = 1;
grid.pdsch[0].rbg_mask=0xFFFF;
grid.verbose = 0;
if (lte_grid_init(&grid)) {
moderror("Initiating channels grid\n");
return -1;
}
nof_output_itf = 1;
nof_input_itf = max_in_port+1;
if (init_refsinc_signals()) {
return -1;
}
subframe_idx_id = param_id("subframe_idx");
if (!subframe_idx_id) {
subframe_idx = 0;
}
return 0;
}
/**
* Generates input signal. VERY IMPORTANT to fill length vector with the number of
* samples that have been generated.
* @param inp Input interface buffers. Data from other interfaces is stacked in the buffer.
* Use in(ptr,idx) to access the address.
*
* @param lengths Save on n-th position the number of samples generated for the n-th interface
*/
int generate_input_signal(void *in, int *lengths)
{
int i;
input_t *input = in;
int block_length;
pmid_t blen_id;
int size;
blen_id = param_id("block_length");
if (!blen_id) {
moderror("Parameter block_length not found\n");
return -1;
}
if (!param_get_int(blen_id,&block_length)) {
moderror("Getting integer parameter block_length\n");
return -1;
}
modinfo_msg("Parameter block_length is %d\n",block_length);
/** HERE INDICATE THE LENGTH OF THE SIGNAL */
lengths[0] = block_length;
for (i=0;i<block_length;i++) {
input[i] = 0x1;
}
/* UL: test*/
input[10] = 'x';
input[11] = 'x';
input[12] = 'x';
input[13] = 'x';
input[14] = 'y';
return 0;
}
static environment mk_below(environment const & env, name const & n, bool ibelow) {
if (!is_recursive_datatype(env, n))
return env;
if (is_inductive_predicate(env, n))
return env;
inductive::inductive_decls decls = *inductive::is_inductive_decl(env, n);
type_checker tc(env);
name_generator ngen;
unsigned nparams = std::get<1>(decls);
declaration ind_decl = env.get(n);
declaration rec_decl = env.get(inductive::get_elim_name(n));
unsigned nindices = *inductive::get_num_indices(env, n);
unsigned nminors = *inductive::get_num_minor_premises(env, n);
unsigned ntypeformers = length(std::get<2>(decls));
level_param_names lps = rec_decl.get_univ_params();
bool is_reflexive = is_reflexive_datatype(tc, n);
level lvl = mk_param_univ(head(lps));
levels lvls = param_names_to_levels(tail(lps));
level_param_names blvls; // universe level parameters of ibelow/below
level rlvl; // universe level of the resultant type
// The arguments of below (ibelow) are the ones in the recursor - minor premises.
// The universe we map to is also different (l+1 for below of reflexive types) and (0 fo ibelow).
expr ref_type;
expr Type_result;
if (ibelow) {
// we are eliminating to Prop
blvls = tail(lps);
rlvl = mk_level_zero();
ref_type = instantiate_univ_param(rec_decl.get_type(), param_id(lvl), mk_level_zero());
} else if (is_reflexive) {
blvls = lps;
rlvl = get_datatype_level(ind_decl.get_type());
// if rlvl is of the form (max 1 l), then rlvl <- l
if (is_max(rlvl) && is_one(max_lhs(rlvl)))
rlvl = max_rhs(rlvl);
rlvl = mk_max(mk_succ(lvl), rlvl);
ref_type = instantiate_univ_param(rec_decl.get_type(), param_id(lvl), mk_succ(lvl));
} else {
// we can simplify the universe levels for non-reflexive datatypes
blvls = lps;
rlvl = mk_max(mk_level_one(), lvl);
ref_type = rec_decl.get_type();
}
Type_result = mk_sort(rlvl);
buffer<expr> ref_args;
to_telescope(ngen, ref_type, ref_args);
if (ref_args.size() != nparams + ntypeformers + nminors + nindices + 1)
throw_corrupted(n);
// args contains the below/ibelow arguments
buffer<expr> args;
buffer<name> typeformer_names;
// add parameters and typeformers
for (unsigned i = 0; i < nparams; i++)
args.push_back(ref_args[i]);
for (unsigned i = nparams; i < nparams + ntypeformers; i++) {
args.push_back(ref_args[i]);
typeformer_names.push_back(mlocal_name(ref_args[i]));
}
// we ignore minor premises in below/ibelow
for (unsigned i = nparams + ntypeformers + nminors; i < ref_args.size(); i++)
args.push_back(ref_args[i]);
// We define below/ibelow using the recursor for this type
levels rec_lvls = cons(mk_succ(rlvl), lvls);
expr rec = mk_constant(rec_decl.get_name(), rec_lvls);
for (unsigned i = 0; i < nparams; i++)
rec = mk_app(rec, args[i]);
// add type formers
for (unsigned i = nparams; i < nparams + ntypeformers; i++) {
buffer<expr> targs;
to_telescope(ngen, mlocal_type(args[i]), targs);
rec = mk_app(rec, Fun(targs, Type_result));
}
// add minor premises
for (unsigned i = nparams + ntypeformers; i < nparams + ntypeformers + nminors; i++) {
expr minor = ref_args[i];
expr minor_type = mlocal_type(minor);
buffer<expr> minor_args;
minor_type = to_telescope(ngen, minor_type, minor_args);
buffer<expr> prod_pairs;
for (expr & minor_arg : minor_args) {
buffer<expr> minor_arg_args;
expr minor_arg_type = to_telescope(tc, mlocal_type(minor_arg), minor_arg_args);
if (is_typeformer_app(typeformer_names, minor_arg_type)) {
expr fst = mlocal_type(minor_arg);
minor_arg = update_mlocal(minor_arg, Pi(minor_arg_args, Type_result));
expr snd = Pi(minor_arg_args, mk_app(minor_arg, minor_arg_args));
prod_pairs.push_back(mk_prod(tc, fst, snd, ibelow));
}
}
expr new_arg = foldr([&](expr const & a, expr const & b) { return mk_prod(tc, a, b, ibelow); },
[&]() { return mk_unit(rlvl, ibelow); },
prod_pairs.size(), prod_pairs.data());
rec = mk_app(rec, Fun(minor_args, new_arg));
}
// add indices and major premise
for (unsigned i = nparams + ntypeformers; i < args.size(); i++) {
rec = mk_app(rec, args[i]);
}
name below_name = ibelow ? name{n, "ibelow"} : name{n, "below"};
expr below_type = Pi(args, Type_result);
expr below_value = Fun(args, rec);
bool use_conv_opt = true;
declaration new_d = mk_definition(env, below_name, blvls, below_type, below_value,
use_conv_opt);
environment new_env = module::add(env, check(env, new_d));
new_env = set_reducible(new_env, below_name, reducible_status::Reducible);
if (!ibelow)
new_env = add_unfold_hint(new_env, below_name, nparams + nindices + ntypeformers);
return add_protected(new_env, below_name);
}
