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 Rate Matching of convolutionally encoded information
* Applied for PDCCH
*
* Main DSP function
*
*
* \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.
*
* \param E Number of output bits of rate matching in transmitter mode
* \param S Number of output bits of rate matching in receiver mode
*
* @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 S, E;
int rcv_samples, snd_samples;
char *input_b;
char *output_b;
float *input_f;
float *output_f;
rcv_samples = get_input_samples(0);
if (!rcv_samples || !out[0] || rcv_samples > 3*6114) {
return 0;
}
input_f = inp[0];
input_b = inp[0];
output_f = out[0];
output_b = out[0];
if (!direction) {
/* @Transmitter */
if (param_get_int(E_id, &E) != 1) {
moderror("Error getting parameter 'E', indiciating the "
"number of rate matching output samples in Tx mode.\n");
return -1;
}
if (E > OUTPUT_MAX_SAMPLES) {
moderror("Too may output samples (E).\n");
return -1;
}
rate_matching(input_b, output_b, rcv_samples, E);
snd_samples = E;
} else {
/* @Receiver */
if (param_get_int(S_id, &S) != 1) {
moderror("Error getting parameter 'S', indiciating the "
"number of rate matching output samples in Rx mode\n");
return -1;
}
if (S > OUTPUT_MAX_SAMPLES) {
moderror("Too may output samples (S).\n");
return -1;
}
if (S%3 > 0) {
moderror("Number of output samples S not integer divisible by 3.\n");
return -1;
}
snd_samples = rate_unmatching(input_f, output_f, rcv_samples, S);
}
return snd_samples;
}
/**
* @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;
}
/**@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 gen_crc
* Adds a CRC to every received packet from each interface
*/
int work(void **inp, void **out) {
int i;
unsigned int n;
input_t *input;
if (poly_id) param_get_int(poly_id,&poly);
if (long_crc_id) param_get_int(long_crc_id, &long_crc);
for (i=0;i<NOF_INPUT_ITF;i++) {
if (get_input_samples(i)) {
moddebug("rcv_len=%d\n",get_input_samples(i));
memcpy(out[i],inp[i],sizeof(input_t)*get_input_samples(i));
input = out[i];
n = icrc(0, input, get_input_samples(i), long_crc, poly, mode == MODE_ADD);
if (mode==MODE_CHECK) {
if (n) {
total_errors++;
}
total_pkts++;
set_output_samples(i,get_input_samples(i)-long_crc);
if (!print_nof_pkts) {
tscnt++;
if (tscnt==interval_ts) {
tscnt=0;
#ifdef PRINT_BLER
printf("Total blocks: %d\tTotal errors: %d\tBLER=%g\n",
total_pkts,total_errors,(float)total_errors/total_pkts);
#endif
}
} else {
print_nof_pkts_cnt++;
if (print_nof_pkts_cnt == print_nof_pkts) {
print_nof_pkts_cnt=0;
printf("Total blocks: %d\tTotal errors: %d\tBLER=%g\n",
total_pkts,total_errors,(float)total_errors/total_pkts);
total_pkts=0;
total_errors=0;
}
}
} else {
set_output_samples(i,get_input_samples(i)+long_crc);
}
}
}
return 0;
}
/** Stores in the address of the second parameter the scalar integer value of the
* parameter name.
* Tries to parse the parameter as an integer. Read param_addr() for supported formats.
* \returns 0 on success or -1 on error.
*/
int param_get_int_name(char *name, int *value) {
pmid_t id = param_id(name);
if (id == NULL) {
return -1;
}
return (param_get_int(id,value)==-1)?-1:0;
}
/**
* @ingroup udp_sink
*
* Writes the received samples to the dac output buffer
*
*/
int work(void **inp, void **out) {
int rcv_samples;
int n;
char tmp[16];
int nof_pkts,pkt_len,i;
input_t *input = inp[0];
rcv_samples = get_input_samples(0);
if (!rcv_samples) {
return 0;
}
nof_pkts=1;
param_get_int(blen_id,&nof_pkts);
if (rcv_samples % nof_pkts) {
modinfo_msg("Warning received packet len %d not multiple of %d packets\n",
rcv_samples,nof_pkts);
}
pkt_len = rcv_samples/nof_pkts;
modinfo_msg("Sending %d packets of %d bytes\n",nof_pkts,pkt_len);
for (i=0;i<nof_pkts;i++) {
n = sendto(fd,&input[i*pkt_len],pkt_len,0,(struct sockaddr *) &servaddr, sizeof (servaddr));
if (n == -1) {
perror("sendto");
return -1;
}
}
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;
}
/**
* 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;
}
/**
* 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;
}
/**
* @ingroup lte_resource_mapper
*
* Main DSP function
*
* This function allocates the data symbols of one slot (0.5 ms) in the corresponding place
* of the LTE frame grid. During initialization phase CRS, PSS and SSS signals has been
* incorporated and will no be modified during run phase.
* PBCH (Physical Broadcast Channel), PCFICH (Physical Control Format Indicator Channel) &
* PDCCH (Physical Downlink Control Channel) will be incorporated.
*
*/
int work(void **inp, void **out) {
if (subframe_idx_id) {
param_get_int(subframe_idx_id, &subframe_idx);
}
#ifdef CHECK_RCV_SAMPLES
int n;
n=check_received_samples_mapper();
if (n < 1) {
return n;
}
#endif
#ifdef _COMPILE_ALOE
moddebug("subframe_idx=%d tstamp=%d rcv=%d\n",subframe_idx,oesr_tstamp(ctx),get_input_samples(0));
#endif
if (allocate_all_channels(inp,out[0])) {
moderror("Error allocating channels\n");
return 0;
}
subframe_idx++;
if (subframe_idx==NOF_SUBFRAMES_X_FRAME) {
subframe_idx=0;
}
return 0;
}
/*=============================================================================
FUNCTION sh_boot_get_bootmode_to_user
DESCRIPTION
DEPENDENCIES
None
RETURN VALUE
SIDE EFFECTS
None
NOTE
None
=============================================================================*/
static int sh_boot_get_bootmode_to_user(char *buffer, const struct kernel_param *kp)
{
int ret = 0;
boot_mode = sh_boot_get_bootmode();
ret = param_get_int(buffer, kp);
return ret;
}
/*=============================================================================
FUNCTION sh_boot_get_handset_to_user
DESCRIPTION
DEPENDENCIES
None
RETURN VALUE
SIDE EFFECTS
None
NOTE
None
=============================================================================*/
static int sh_boot_get_handset_to_user(char *buffer, const struct kernel_param *kp)
{
int ret = 0;
handset = sh_boot_get_handset();
ret = param_get_int(buffer, kp);
return ret;
}
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 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_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,n;
#if NOF_INPUTS>1
for (i=0;i<NOF_INPUT_ITF;i++) {
binsource.input[i] = inp[i];
binsource.in_len[i] = get_input_samples(i)
}
#elif NOF_INPUTS == 1
binsource.input = inp[0];
binsource.in_len = get_input_samples(0);
#endif
#if NOF_OUTPUTS>1
for (i=0;i<NOF_OUTPUT_ITF;i++) {
binsource.output[i] = out[i];
binsource.out_len = &out_len[i];
}
#elif NOF_OUTPUTS == 1
binsourceoutput = out[0];
binsource.out_len = &out_len[0];
#endif
/* Get input parameters */
if (param_get_int(nbits_id, &binsource.ctrl_in.nbits) != 1) {
moderror("Error getting parameter nbits\n");
return -1;
}
/* call work */
n = binsource_work(&binsource);
/* Set output nof_samples */
for (i=0;i<NOF_OUTPUT_ITF;i++) {
set_output_samples(i,out_len[i]);
binsource.out_len = &out_len[i];
}
/* Set output parameters */
return n;
}
int work(void **inp, void **out) {
int i, out_len;
input_t *input;
output_t *output;
param_get_int(modulation_id,&modulation);
for (i=0;i<NOF_INPUT_ITF;i++) {
input = inp[i];
output = out[i];
if (get_input_samples(i)) {
out_len = modulate(input,output,get_input_samples(i));
if (out_len == -1) {
return -1;
}
set_output_samples(i,out_len);
}
}
return 0;
}
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;
}
/**
* @ingroup lte_resource_mapper
*
* Main DSP function
*
* This function allocates the data symbols of one slot (0.5 ms) in the corresponding place
* of the LTE frame grid. During initialization phase CRS, PSS and SSS signals has been
* incorporated and will no be modified during run phase.
* PBCH (Physical Broadcast Channel), PCFICH (Physical Control Format Indicator Channel) &
* PDCCH (Physical Downlink Control Channel) will be incorporated.
*
*/
int work(void **inp, void **out) {
int n;
subframe_idx=-1;
if (subframe_idx_id) {
param_get_int(subframe_idx_id, &subframe_idx);
}
#ifdef _COMPILE_ALOE
moddebug("subframe_idx=%d tstamp=%d rcv_len=%d cfi=%d\n",subframe_idx,oesr_tstamp(ctx),
get_input_samples(0),grid.cfi);
#endif
if (subframe_idx==-1) {
return 0;
}
n=check_received_samples_demapper();
if (n < 1) {
return n;
}
if (channels_init_grid(channel_ids, nof_channels)) {
moderror("Initiating resource grid\n");
return 0;
}
if (deallocate_all_channels(channel_ids, nof_channels, inp[0],out)) {
return -1;
}
if (extract_refsig(inp[0],out)) {
return -1;
}
if (copy_signal(inp[0],out)) {
return -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 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;
}
int process_params() {
float _rate,_gain,_freq;
if (param_get_float(rate_id,&_rate) != 1) {
modinfo("Getting parameter rate\n");
return -1;
}
if (_rate != rate) {
rate = _rate;
_rate = rtdal_dac_set_rx_srate(dac,rate);
modinfo_msg("Set TX sampling rate %g MHz\n", _rate/1000000);
}
if (param_get_float(freq_id,&_freq) != 1) {
modinfo("Getting parameter freq\n");
return -1;
}
if (_freq != freq) {
freq = _freq;
_freq = rtdal_dac_set_rx_freq(dac,freq);
modinfo_msg("Set TX freq %g MHz\n",_freq/1000000);
}
if (gain_id) {
if (param_get_float(gain_id,&_gain) != 1) {
modinfo("Getting parameter gain\n");
return -1;
}
} else {
_gain = 0.0;
}
if (_gain != gain) {
gain = _gain;
_gain = rtdal_dac_set_rx_gain(dac,gain);
modinfo_msg("Set TX gain %g dB (%g)\n",_gain,gain);
}
param_get_int(nsamples_id, &nsamples);
return 0;
}
static int emscripten_setup(struct sim_state *s, const struct run_ops *ops,
void **run_data, void *ops_data)
{
struct emscripten_wrap data = {
.s = s,
.ops = ops,
.run_data = run_data,
.ops_data = ops_data,
.insns_per_frame = 1,
};
param_get_int(s->conf.params, "emscripten.insns_per_anim_frame", &data.insns_per_frame);
emscripten_cancel_main_loop(); // In case we get called more than once
emscripten_set_main_loop_arg(emscripten_wrap_step, &data, 0, 1);
return data.rc;
}
int recipe_emscript(struct sim_state *s)
{
s->run_sim = emscripten_setup;
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 int hp_state_get(char *buffer, const struct kernel_param *kp)
{
return param_get_int(buffer, kp);
}
static int min_online_cpus_fn_get(char *buffer, const struct kernel_param *kp)
{
return param_get_int(buffer, kp);
}
static int wakeup_delay_time_get(char *buffer, const struct kernel_param *kp)
{
int ret = param_get_int(buffer, kp);
return param_get_int(buffer, kp);
}
int work(void **inp, void **out) {
int i, j, k;
int rcv_samples, nof_ffts;
int df, fs;
int e;
int dft_size;
input_t *input;
output_t *output;
dft_plan_t *plan;
if (param_get_int(dft_size_id,&dft_size) != 1) {
dft_size = get_input_samples(0);
moddebug("Parameter dft_size not defined. Assuming %d"
" (number of input samples on interface 0).\n", dft_size);
/*moderror("Getting parameter dft_size\n");
return -1;*/
}
if (dft_size == 0) {
modinfo("dft_size = 0. Returning.\n");
return 0;
} else {
moddebug("dft_size = %d.\n", dft_size);
}
/* if (param_get_int(param_id("dft_size"),&dft_size) != 1) {
moddebug("Parameter dft_size not defined. Assuming %d"
" (number of input samples on interface 0).\n", dft_size);
}
*/
plan = find_plan(dft_size);
if (!plan) {
if ((plan = generate_new_plan(dft_size)) == NULL) {
moderror("Generating plan.\n");
return -1;
}
}
if (param_get_int(df_id, &df) != 1) {
df = 0;
}
if (df != 0) {
if (param_get_int(fs_id, &fs) != 1) {
moderror("Parameter fs not defined.\n");
return -1;
}
if (fs <= 0) {
moderror("Sampling rate fs must be larger than 0.\n");
return -1;
}
if ((df != previous_df) || (fs != previous_fs) || (dft_size != previous_dft_size)) {
e = process_shift_params(df, fs, dft_size);
if (e < 0) {
return -1;
}
previous_df = df;
previous_fs = fs;
previous_dft_size = dft_size;
}
}
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 interface %d.\n",rcv_samples, i);
if (rcv_samples == 0) {
moddebug("%d samples to process. Returning.\n", rcv_samples);
continue;
}
moddebug("Processing %d samples...\n",rcv_samples);
if (rcv_samples % dft_size) {
moderror_msg("Number of input samples (%d) not integer multiple"
" of dft_size (%d) on interface %d\n",rcv_samples,dft_size,i);
return -1;
}
if (get_input_samples(0)>0) {
modinfo_msg("received %d samples\n",get_input_samples(0));
}
nof_ffts = rcv_samples/dft_size;
for (j=0;j<nof_ffts;j++) {
if ((df != 0) && (direction == FORWARD)) { /* Rx: shift before FFT */
for (k=0;k<dft_size;k++) {
input[j*dft_size+k] *= shift[k*shift_increment];
}
}
dft_run_c2c(plan, &input[j*dft_size], &output[j*dft_size]);
if ((df !=0) && (direction == BACKWARD)) { /* Tx: shift after IFFT */
for (k=0;k<dft_size;k++) {
output[j*dft_size+k] *= shift[k*shift_increment];
}
}
}
set_output_samples(i,dft_size*nof_ffts);
moddebug("%d samples sent to output interface %d.\n",dft_size*nof_ffts,i);
}
return 0;
}
/**@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 dc_offset Set a null to the 0 subcarrier
* \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.
* \param df Frequency shift (choose a positive value for upconversion and a negative value for
* downconversion) (default is 0--no frequency shift)
* \param fs Sampling rate. This parameter is mandatory if df!=0.
*/
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 == 1) {
options |= DFT_MIRROR_PRE;
} else if (tmp == 2) {
options |= DFT_MIRROR_POS;
}
}
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("dc_offset"),&tmp) != 1) {
modinfo("Parameter dc_offset not defined. Disabling. \n");
} else {
if (tmp) options |= DFT_DC_OFFSET;
}
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;*/
modinfo("Parameter dft_size not defined. Assuming "
"dft_size = number of input samples on interface 0.\n");
}
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;
}
df_id = param_id("df");
fs_id = param_id("fs");
precalculate_shift_vectors(precomputed_shift_1536, precomputed_shift_reg);
/* assume 1.4 MHz LTE UL Tx (fs = 1.92 MHz, 128 IFFT, df = 7.5 kHz) */
shift = precomputed_shift_reg;
previous_df = df_lte;
previous_fs = 1920000;
previous_dft_size = 128;
shift_increment = 16;
return 0;
}
static int mp_policy_get(char *buffer, const struct kernel_param *kp)
{
return param_get_int(buffer, kp);
}
