/**@ingroup gen_mux * */ int work(void **inp, void **out) { int i; int out_len; int nof_active_inputs; nof_active_inputs = 0; for (i=0;i<nof_inputs;i++) { input_lengths[i] = get_input_samples(i); nof_active_inputs++; } if (exclusive && nof_active_inputs>1) { moderror_msg("Exclusive mux but %d inputs have data\n",nof_active_inputs); return -1; } if(check_all && (nof_active_inputs<nof_inputs)) { moderror_msg("Only %d/%d inputs have data\n",nof_active_inputs,nof_inputs); return -1; } if (!out[0]) { moderror("Output not ready\n"); return -1; } out_len = sum_i(input_lengths,nof_inputs); if (out_len) { mux(inp,out[0],input_lengths,input_padding_pre,nof_inputs,input_sample_sz); } return out_len; }
/** @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; }
int initialize() { sample_t d_type; if (param_get_int_name("data_type",&data_type)) { moderror("Error getting parameter data_type\n"); return -1; } if (type_param_2_type(data_type,&d_type)) { moderror_msg("Invalid data_type parameter %d\n",data_type); return -1; } input_sample_sz = type_size(d_type); output_sample_sz = input_sample_sz; if (param_get_int_name("nof_inputs",&nof_inputs)) { moderror("Error getting parameter nof_inputs\n"); return -1; } nof_input_itf = nof_inputs; if (nof_inputs > NOF_INPUT_ITF) { moderror_msg("Only %d interfaces are supported. nof_inputs=%d\n",NOF_INPUT_ITF,nof_inputs); return -1; } memset(input_padding_pre,0,sizeof(int)*nof_inputs); return 0; }
/** * @ingroup dac_sink * * Writes the received samples to the dac output buffer * */ int work(void **inp, void **out) { int rcv_samples; int n; rcv_samples = get_input_samples(0); if (!rcv_samples) { return 0; } if (check_blen && check_blen != rcv_samples) { moderror_msg("Expected %d samples but got %d\n", check_blen, rcv_samples); return -1; } if (process_params()) { return -1; } vec_mult_c_r((complex_t*) inp[0],out_buffer,amplitude,rcv_samples); if (enable_dac) { n = rtdal_dac_send(dac,out_buffer,rcv_samples,blocking); } else { n = rcv_samples; } modinfo_msg("send %d samples amplitude %g\n",n,amplitude); if (n != rcv_samples) { moderror_msg("Sent %d/%d samples\n",n,rcv_samples); return -1; } return 0; }
int process_ctrl_packets(void *ctx) { int n, nof_packets; int i; do { moddebug("receiving control\n",0); n = oesr_itf_read(ctrl_in, ctrl_in_buffer, sizeof(struct ctrl_in_pkt)*MAX_INPUT_PACKETS,oesr_tstamp(ctx)); if (n == -1) { oesr_perror("oesr_itf_read"); return -1; } else if (n>0) { if (n % sizeof(struct ctrl_in_pkt)) { moderror_msg("Received %d bytes but packet size is %d\n", n, sizeof(struct ctrl_in_pkt)); } nof_packets = n / sizeof(struct ctrl_in_pkt); for (i=0;i<nof_packets;i++) { if (process_ctrl_packet(ctx, &ctrl_in_buffer[i])) { moderror_msg("Error processing control packet %d/%d\n",i,nof_packets); return -1; } } } } while(n>0); return 0; }
int work(void **inp, void **out) { int block_length, type; int i,j; int snd_samples; period_cnt++; if (period_cnt>=period) { period_cnt=0; } if (period_cnt) { return 0; } block_length = 0; if (param_get_int(blen_id,&block_length) != 1) { moderror("Getting integer parameter block_length\n"); return -1; } type = 0; if (param_get_int(gen_id,&type) != 1) { moderror("Getting integer parameter type\n"); return -1; } for(i=0;i<NOF_GENERATORS;i++) { if (generators[i].key == type) { break; } } if (i == NOF_GENERATORS) { moderror_msg("Generator type %d not implemented\n", type); return -1; } if (type != last_type) { moddebug("Select generator: %s\n",generators[i].desc); last_type = type; } if (block_length > OUTPUT_MAX_SAMPLES/generators[i].samp_sz) { moderror_msg("block_length %d too large. Maximum is %d for this generator\n",block_length, OUTPUT_MAX_SAMPLES/generators[i].samp_sz); return -1; } #ifdef _COMPILE_ALOE if (block_length != last_block_length) { moddebug("Select block_length: block_length=%d at tslot=%d\n",block_length,oesr_tstamp(ctx)); last_block_length = block_length; } #endif snd_samples = generators[i].work(out[0],block_length); #ifdef _COMPILE_ALOE moddebug("Sent %d samples at ts=%d\n",snd_samples,oesr_tstamp(ctx)); #endif return snd_samples; }
/** * @ingroup lte_cfi_coding * Main DSP function * Encodes the control format indicator (CFI) * * @return On success, returns a non-negative number indicating the output * samples that should be transmitted through all output interface. To specify a different length * for certain interface, use the function set_output_samples(int idx, int len) * On error returns -1. * */ int work(void **inp, void **out) { int i; int rcv_samples, snd_samples; input_t *input; output_t *output; input = inp[0]; output = out[0]; rcv_samples = get_input_samples(0); snd_samples = NOF_BITS; if ((input[0] > 0) && (input[0] < 5)) { memcpy(output, &table[input[0]-1], NOF_BITS); } else { moderror_msg("Wrong cfi %d. Specify 1, 2, 3, or 4 (4 reserved)." "\n", input[0]); return -1; } /* printf("\n\n"); for (i=0; i<snd_samples; i++) { printf("%d",output[i]); } printf("\n\n %d %d %d", table, &table[input[0]-1], &table[input[0]-1][0]); */ return snd_samples; }
/** * @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 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; }
int scan_remote_itf(void *ctx, int nof_variables) { int i,j,k; for (i=0;i<MAX_OUTPUTS;i++) { outputs[i].module_idx = -1; } for (i=0;i<nof_variables;i++) { k=-1; for (j=0;j<MAX_OUTPUTS;j++) { if (outputs[j].module_idx == remote_variables[i].module_idx) { break; } else if (outputs[j].module_idx == -1 && k==-1) { k = j; } } if (j==MAX_OUTPUTS) { if (k==-1) { moderror_msg("Not enough output interfaces. Increase MAX_OUTPUTS (%d) " "in oesr/src/ctrl_skeleton.c\n",j); return -1; } else { j=k; } } remote_variables[i].addr = &outputs[j]; outputs[j].module_idx = remote_variables[i].module_idx; } k=0; for (j=0;j<MAX_OUTPUTS;j++) { if (outputs[j].module_idx!=-1) { k++; } } return k; }
/**@ingroup gen_demux * */ int work(void **inp, void **out) { int i; int rcv_len, out_len; rcv_len=get_input_samples(0); moddebug("%d samples recevied.\n",rcv_len); if (!rcv_len) return 0; modinfo_msg("received %d bytes\n",rcv_len); if ((rcv_len - sum_special_output_lengths) % (nof_outputs-nof_special_outputs)) { /* moderror_msg("Received length %d is not multiple of the number of output interfaces %d\n", rcv_len,nof_outputs); */ return 0; } out_len = (rcv_len - sum_special_output_lengths) / (nof_outputs-nof_special_outputs); for (i=0;i<nof_outputs;i++) { if (special_output_length[i]) { output_lengths[i] = special_output_length[i]; } else { output_lengths[i] = out_len; } set_output_samples(i,output_lengths[i]); if (!out[i]) { moderror_msg("output itf %d not ready\n",out[i]); return -1; } } demux(inp[0],out,output_lengths,output_padding_pre, output_padding_post,nof_outputs,input_sample_sz); return 0; }
/** * @ingroup dac_source * * Writes the received samples to the dac output buffer * */ int work(void **inp, void **out) { int n; if (!stream_started) { rtdal_dac_start_rx_stream(dac); stream_started=1; } if (process_params()) { return -1; } if (!nsamples) { return 0; } if (!out[0]) { moderror("Output interface not ready\n"); return -1; } if (cnt<wait_packets) { cnt++; modinfo_msg("not receiving ts=%d\n",oesr_tstamp(ctx)); return 0; } n = rtdal_dac_recv(dac,out[0],nsamples,blocking); modinfo_msg("ts=%d, recv %d samples\n",oesr_tstamp(ctx),n); if (n != nsamples) { moderror_msg("Recv %d/%d samples\n",n,nsamples); return -1; } return nsamples; }
int init_remote_itf(void *ctx, int nof_itf) { int i,j; int port,delay; char tmp[64]; for (i=0;i<nof_itf;i++) { port = outputs[i].module_idx-oesr_module_id(ctx)+nof_output_data_itf; if (port < 0) { moderror_msg("Can't sent to a module back in the chain (module_idx=%d)\n",outputs[i].module_idx); return -1; } /* check if a parameter sets a different delay */ for (j=0;j<nof_remote_variables;j++) { if (remote_variables[j].module_idx == outputs[i].module_idx) { break; } } if (j < nof_remote_variables) { snprintf(tmp,64,"delay_%s",remote_params_db[j].module_name); if (!param_get_int_name(tmp,&delay)) { moddebug("Setting a delay of %d slots to port %d, module %s\n",delay,port, remote_params_db[j].module_name); if (oesr_itf_delay_set(ctx,port,ITF_WRITE,delay)) { moderror_msg("Setting delay to port %d\n",port); return -1; } } } /* now create the variable */ outputs[i].itf = oesr_itf_create(ctx, port, ITF_WRITE, sizeof(struct ctrl_in_pkt)); if (outputs[i].itf == NULL) { if (oesr_error_code(ctx) == OESR_ERROR_NOTFOUND) { modinfo_msg("Caution output port %d not connected,\n",i); } else { moderror_msg("Error creating output port %d\n",i); oesr_perror("oesr_itf_create\n"); return -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; }
/**@ingroup Process shift parameters * Processes the configuration parameters that define the shift pointer and index * increment (shift_increment). * \param df Frequency shift in Hz (positive for upconversion, negative for downconversion) * \param fs Sampling rate in Hz * \param dft_size Number of DFT/IDFT points */ int process_shift_params(int df, int fs, int dft_size) { if (df == df_lte) { if ((fs == 1920000) && (dft_size == 128)) { /* 1.4 MHz LTE mode */ shift = precomputed_shift_reg; shift_increment = 16; } else if ((fs == 3840000) && (dft_size == 256)) {/* 3 MHz LTE mode */ shift = precomputed_shift_reg; shift_increment = 8; } else if ((fs == 7680000) && (dft_size == 512)) {/* 5 MHz LTE mode */ shift = precomputed_shift_reg; shift_increment = 4; } else if ((fs == 15360000) && (dft_size == 1024)) {/* 10 MHz LTE mode */ shift = precomputed_shift_reg; shift_increment = 2; } else if ((fs == 23040000) && (dft_size == 1536)) {/* 15 MHz LTE mode */ shift = precomputed_shift_1536; shift_increment = 1; } else if ((fs == 30720000) && (dft_size == 2048)) {/* 20 MHz LTE mode */ shift = precomputed_shift_reg; shift_increment = 1; } else { if (dft_size > MAX_DFT_SIZE) { moderror_msg("Too large DFT size %d. Maximum " "supported size is %d\n", dft_size, MAX_DFT_SIZE); return -1; } calculate_shift_vector(computed_shift, df, fs, dft_size); shift = computed_shift; shift_increment = 1; } } else { if (dft_size > MAX_DFT_SIZE) { moderror_msg("Too large DFT size %d. Maximum supported size " "is %d\n", dft_size, MAX_DFT_SIZE); return -1; } calculate_shift_vector(computed_shift, df, fs, dft_size); shift = computed_shift; shift_increment = 1; } return 0; }
int process_ctrl_packet(void *ctx, struct ctrl_in_pkt *packet) { if (oesr_var_param_set_value_idx(ctx,packet->pm_idx,packet->value, packet->size) == -1) { moderror_msg("pm_idx=%d, value=0x%x, size=%d\n",packet->pm_idx,packet->value,packet->size); oesr_perror("Error setting control parameter\n"); return -1; } return 0; }
int initialize() { int i; sample_t d_type; char pname[64]; if (param_get_int_name("data_type",&data_type)) { moderror("Error getting parameter data_type\n"); return -1; } if (type_param_2_type(data_type,&d_type)) { moderror_msg("Invalid data_type parameter %d\n",data_type); return -1; } input_sample_sz = type_size(d_type); output_sample_sz = input_sample_sz; if (param_get_int_name("nof_outputs",&nof_outputs)) { moderror("Error getting parameter nof_outputs\n"); return -1; } if (nof_outputs > NOF_OUTPUT_ITF) { moderror_msg("Only %d interfaces are supported. nof_input_itf=%d\n",NOF_OUTPUT_ITF,nof_outputs); return -1; } memset(special_output_length,0,sizeof(int)*nof_outputs); nof_special_outputs = 0; for (i=0;i<nof_outputs;i++) { snprintf(pname,64,"out_len_%d",i); if (!param_get_int_name(pname,&special_output_length[i])) { nof_special_outputs++; } } sum_special_output_lengths = sum_i(special_output_length,nof_outputs); nof_output_itf = nof_outputs; memset(output_padding_pre,0,sizeof(int)*nof_outputs); memset(output_padding_post,0,sizeof(int)*nof_outputs); return 0; }
int init_interfaces(void *ctx) { int i; int has_ctrl=0; if (oesr_itf_nofinputs(ctx) > nof_input_itf) { /* try to create control interface */ ctrl_in = oesr_itf_create(ctx, 0, ITF_READ, CTRL_IN_BUFFER); if (ctrl_in == NULL) { if (oesr_error_code(ctx) == OESR_ERROR_NOTREADY) { return 0; } } else { modinfo("Created control port\n"); has_ctrl=1; } } moddebug("configuring %d inputs and %d outputs %d %d %d\n",nof_input_itf,nof_output_itf,inputs[0],input_max_samples,input_sample_sz); for (i=0;i<nof_input_itf;i++) { if (inputs[i] == NULL) { inputs[i] = oesr_itf_create(ctx, has_ctrl+i, ITF_READ, input_max_samples*input_sample_sz); if (inputs[i] == NULL) { if (oesr_error_code(ctx) == OESR_ERROR_NOTREADY) { return 0; } else { oesr_perror("creating input interface\n"); return -1; } } else { moddebug("input_%d=0x%x\n",i,inputs[i]); } } } for (i=0;i<nof_output_itf;i++) { if (outputs[i] == NULL) { outputs[i] = oesr_itf_create(ctx, i, ITF_WRITE, output_max_samples*output_sample_sz); if (outputs[i] == NULL) { if (oesr_error_code(ctx) == OESR_ERROR_NOTFOUND) { modinfo_msg("Caution output port %d not connected,\n",i); } else { moderror_msg("Error creating output port %d\n",i); oesr_perror("oesr_itf_create\n"); return -1; } } else { moddebug("output_%d=0x%x\n",i,outputs[i]); } } } return 1; }
int check_configuration(void *ctx) { moddebug("nof_input=%d, nof_output=%d\n",nof_input_itf,nof_output_itf); if (nof_input_itf > MAX_INPUTS) { moderror_msg("Maximum number of input interfaces is %d. The module uses %d. " "Increase MAX_INPUTS in oesr_static/skeleton/skeleton.c and recompile ALOE\n", MAX_INPUTS,nof_input_itf); return -1; } if (nof_output_itf > MAX_OUTPUTS) { moderror_msg("Maximum number of output interfaces is %d. The module uses %d. " "Increase MAX_OUTPUTS in oesr_static/skeleton/skeleton.c and recompile ALOE\n", MAX_OUTPUTS,nof_output_itf); return -1; } user_vars = NULL; nof_vars = 0; return 0; }
/** * @ingroup lte_ratematching * * Main DSP function * */ int work(void **inp, void **out) { int i, in_pkt_len, out_pkt_len, j; int rcv_samples; char *input, *output; param_get_int(pre_padding_id, &pre_padding); param_get_int(post_padding_id, &post_padding); param_get_int(nof_packets_id, &nof_packets); for (i=0;i<NOF_INPUT_ITF;i++) { input = inp[i]; output = out[i]; rcv_samples = get_input_samples(i); moddebug("%d samples received on input interface %d.\n",rcv_samples,i); if (rcv_samples == 0) { moddebug("%d samples to process. Returning.\n", rcv_samples); continue; } if ((rcv_samples) % nof_packets) { moderror_msg("Received samples (%d) should multiple of " "nof_packets (%d)\n", rcv_samples, nof_packets); return -1; } in_pkt_len = rcv_samples / nof_packets; if (direction) { out_pkt_len = in_pkt_len - pre_padding - post_padding; } else { out_pkt_len = in_pkt_len + pre_padding + post_padding; } if (in_pkt_len) { if (direction) { for (j=0;j<nof_packets;j++) { memcpy(outaddr(0),inaddr(pre_padding),input_sample_sz*out_pkt_len); } } else { for (j=0;j<nof_packets;j++) { memset(outaddr(0),0,input_sample_sz*pre_padding); memcpy(outaddr(pre_padding),inaddr(0),input_sample_sz*in_pkt_len); memset(outaddr(pre_padding+in_pkt_len),0,input_sample_sz*post_padding); } } moddebug("%d samples sent to output interface %d.\n",out_pkt_len*nof_packets, i); set_output_samples(i,out_pkt_len*nof_packets); } } return 0; }
int init_remote_variables(void *ctx) { int i; for (i=0;i<nof_remote_variables;i++) { remote_variables[i].module_idx = oesr_get_module_idx(ctx, (char*) remote_params_db[i].module_name); if (remote_variables[i].module_idx == -1) { moderror_msg("Module %s not found\n",remote_params_db[i].module_name); return -1; } remote_variables[i].variable_idx = oesr_get_variable_idx(ctx, (char*) remote_params_db[i].module_name, (char*) remote_params_db[i].variable_name); if (remote_variables[i].variable_idx == -1) { moddebug("Variable %s not found in module %s. " "Creating...\n",remote_params_db[i].variable_name, remote_params_db[i].module_name); /* create a new variable if not defined in .app */ var_t new_var = oesr_var_param_create_remote(ctx,remote_variables[i].module_idx, (char*) remote_params_db[i].variable_name,remote_params_db[i].size); if (!new_var) { moderror_msg("Error creating remote variable %s in module %s.\n", remote_params_db[i].variable_name, remote_params_db[i].module_name); return -1; } remote_variables[i].variable_idx = new_var->id-1; } moddebug("Init remote parameter %s:%s (%d,%d)\n",remote_params_db[i].module_name, remote_params_db[i].variable_name,remote_variables[i].module_idx, remote_variables[i].variable_idx); } if (i==MAX_VARIABLES) { modinfo_msg("Caution: Only %d variables where parsed. " "Increase MAX_VARIABLES in oesr/include/ctrl_skeleton.h",i); } return i; }
/** * @ingroup file_source * * \param data_type If specified, reads formated data in text mode: * 0 for float, 1 for _Complex float and 2 for _Complex short * \param block_length Number of samples to read per timeslot, or bytes * \param file_name Name of the *.mat file to save the signal */ int initialize() { char name[64]; var_t pm; int i; if (param_get_int_name("data_type", &data_type)) { data_type=-1; } switch(data_type) { case 0: output_sample_sz = sizeof(float); break; case 1: output_sample_sz = sizeof(_Complex float); break; case 2: output_sample_sz = sizeof(_Complex short); break; case -1: output_sample_sz=sizeof(char); } if (param_get_int_name("block_length", &block_length)) { moderror("Parameter block_length not specified\n"); return -1; } #ifdef _COMPILE_ALOE pm = oesr_var_param_get(ctx, "file_name"); if (!pm) { moderror("Parameter file_name undefined\n"); return -1; } if (oesr_var_param_get_value(ctx, pm, name, 64) == -1) { moderror("Error getting file_name value\n"); return -1; } #endif modinfo_msg("Opening file %s for reading\n",name); fd = rtdal_datafile_open(name,"r"); if (!fd) { moderror_msg("Error opening file %s\n",name); return -1; } return 0; }
/** * @ingroup file_sink * * \param data_type If specified, formats data in text mode: * 0 for float, 1 for _Complex float and 2 for _Complex short * \param file_name Name of the *.mat file to save the signal */ int initialize() { char name[64]; 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; case -1: input_sample_sz=sizeof(char); } #ifdef _COMPILE_ALOE var_t pm; pm = oesr_var_param_get(ctx, "file_name"); if (!pm) { moderror("Parameter file_name undefined\n"); return -1; } if (oesr_var_param_get_value(ctx, pm, name, 64) == -1) { moderror("Error getting file_name value\n"); return -1; } #endif modinfo_msg("Opening file %s for writing\n",name); fd = rtdal_datafile_open(name,"w"); if (!fd) { moderror_msg("Error opening file %s\n",name); return -1; } last_rcv_samples = 0; return 0; }
int init_local_variables(void *ctx) { int i; i=0; while(local_params_db[i].name && i<MAX_VARIABLES) { local_variables[i] = oesr_var_param_get(ctx,(char*) local_params_db[i].name); if (!local_variables[i]) { moderror_msg("Parameter %s not found\n",local_params_db[i].name); return -1; } i++; } if (i==MAX_VARIABLES) { modinfo_msg("Caution: Only %d variables where parsed. " "Increase MAX_VARIABLES in oesr/include/ctrl_skeleton.h",i); } return i; }
/** * @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; }
/** * @ingroup gen_hard_demod * * Main DSP function * * Calls the appropriate function for demodulating all recevied symbols. * * \param inp Input interface buffers. The value inp[i] points to the buffer received * from the i-th interface. The function get_input_samples(i) returns the number of received * samples (the sample size is by default sizeof(input_t)) * * \param out Output interface buffers. The value out[i] points to the buffer where the samples * to be sent through the i-th interfaces must be stored. * * @return On success, returns a non-negative number indicating the output * samples that should be transmitted through all output interface. To specify a different length * for certain interface, use the function set_output_samples(int idx, int len) * On error returns -1. * * */ int work(void **inp, void **out) { int rcv_samples, snd_samples; int modulation; int bits_per_symbol; input_t *input; output_t *output; float *inreal; if (!get_input_samples(0)) { return 0; } /* Dynamically obtain modulation type */ if (param_get_int(modulation_id, &modulation) != 1) { moderror("Error getting 'modulation' parameter. Assuming BPSK.\n"); modulation = BPSK; } /* Verify parameters */ if ((modulation != BPSK) && (modulation != QPSK) && (modulation != QAM16) && (modulation != QAM64)) { moderror_msg("Invalid modulation %d. Specify 1 for BPSK, 2 for QPSK," "4 for 16QAM, or 6 for 64QAM\n", modulation); return -1; } input = inp[0]; output = out[0]; rcv_samples = get_input_samples(0); /* number of input samples */ bits_per_symbol = get_bits_per_symbol(modulation); if (in_real) { inreal = inp[0]; hard_demod_real(inreal, output, rcv_samples, modulation); } else { hard_demod(input, output, rcv_samples, modulation); } snd_samples = rcv_samples*bits_per_symbol; return snd_samples; }
int work(void **inp, void **out) { int i, j, nof_fft; int dft_size; input_t *input; output_t *output; dft_plan_t *plan; if (param_get_int(dft_size_id,&dft_size) != 1) { moderror("Getting parameter dft_size\n"); return -1; } plan = find_plan(dft_size); if (!plan) { if ((plan = generate_new_plan(dft_size)) == NULL) { moderror("Generating plan.\n"); return -1; } } for (i=0;i<NOF_INPUT_ITF;i++) { input = inp[i]; output = out[i]; if (get_input_samples(i) % dft_size) { moderror_msg("Number of input samples (%d) must be multiple of dft_size (%d), in " "interface %d\n",get_input_samples(i),dft_size,i); return -1; } nof_fft = get_input_samples(i)/dft_size; for (j=0;j<nof_fft;j++) { dft_run_c2c(plan, &input[j*dft_size], &output[j*dft_size]); } set_output_samples(i,dft_size*nof_fft); } return 0; }
int modulate(input_t *input, output_t *output, int nof_bits) { int bits_per_symbol, nof_symbols; int i,j; j = 0; bits_per_symbol = get_bits_per_symbol(modulation); nof_symbols = nof_bits/bits_per_symbol; switch(modulation) { case BPSK: for (i=0; i<nof_bits; i+=bits_per_symbol) { modulate_BPSK(&input[i], &output[j]); j++; // one symbol every bits_per_symbol bits } break; case QPSK: for (i=0; i<nof_bits; i+=bits_per_symbol) { modulate_QPSK(&input[i], &output[j]); j++; // one symbol every bitspersymbol bits } break; case QAM16: for (i=0; i<nof_bits; i+=bits_per_symbol) { modulate_16QAM(&input[i], &output[j]); j++; // one symbol every bitspersymbol bits } break; case QAM64: for (i=0; i<nof_bits; i+=bits_per_symbol) { modulate_64QAM(&input[i], &output[j]); j++; // one symbol every bitspersymbol bits } break; default: moderror_msg("Unknown modulation %d\n",modulation); return -1; } return nof_symbols; }
/** * @ingroup gen_hard_demod * * Main DSP function * * Calls the appropriate function for demodulating all recevied symbols. * * \param inp Input interface buffers. The value inp[i] points to the buffer received * from the i-th interface. The function get_input_samples(i) returns the number of received * samples (the sample size is by default sizeof(input_t)) * * \param out Output interface buffers. The value out[i] points to the buffer where the samples * to be sent through the i-th interfaces must be stored. * * @return On success, returns a non-negative number indicating the output * samples that should be transmitted through all output interface. To specify a different length * for certain interface, use the function set_output_samples(int idx, int len) * On error returns -1. * * */ int work(void **inp, void **out) { int i; int rcv_samples, snd_samples; int modulation; float sigma2; int bits_per_symbol; input_t *input; output_t *output; /* Dynamically obtain modulation type */ if (param_get_int(modulation_id, &modulation) != 1) { moderror("Error getting 'modulation' parameter. Assuming QPSK.\n"); modulation = QPSK; } /* Verify parameters */ if (modulation > 3 || modulation < 0) { moderror_msg("Invalid modulation %d. Specify 0 for BPSK, 1 for QPSK," "2 for 16QAM, or 3 for 64QAM\n", modulation); return -1; } else { modinfo_msg("Modulation type is %d (0:BPSK; 1:QPSK; 2:16QAM;" "3:64QAM)\n",modulation); } input = inp[0]; output = out[0]; rcv_samples = get_input_samples(0); /* number of input samples */ bits_per_symbol = get_bits_per_symbol(modulation); hard_demod(input, output, rcv_samples, modulation); snd_samples = rcv_samples*bits_per_symbol; /* printf("\n\n"); for (i=0; i<snd_samples; i++) { printf("%d",output[i]); } */ return snd_samples; }