/** 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; }
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_tx_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_tx_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_tx_gain(dac,gain); modinfo_msg("Set TX gain %g dB (%g)\n",_gain,gain); } if (amp_id) { if (param_get_float(amp_id,&litude) != 1) { modinfo("Getting parameter amplitude\n"); return -1; } } else { amplitude = 1.0; } return 0; }
/** * @ingroup template * * Main DSP function * * Document here your module, which parameters it requires and how it behaves as a function of them. * * \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 j; input_t *input; output_t *output; float gain; if (param_get_float(gain_id, &gain) != 1) { moderror("Error getting parameter gain\n"); return -1; } /* inp[n] and out[m] are pointer to the n-th and m-th input and output interfaces */ /* let us assume we only have one input and output interface */ input = inp[0]; output = out[0]; rcv_samples = get_input_samples(0); /* this function returns the samples received from an input */ for (j = 0; j < rcv_samples; j++) { /* do here your DSP work */ output[j] = gain*input[j]; } snd_samples = rcv_samples; return snd_samples; }
/** * @ingroup dac_sink * * Writes the received samples to the dac output buffer * */ int work(void **inp, void **out) { int rcv_samples; float *input_rf; _Complex float *input_f; _Complex short *input_s; int i,j; float freq; float gain; float x=0; float *buffer_rf = buffer; _Complex float *buffer_f = buffer; _Complex short *buffer_s = buffer; if (param_get_float(freq_id,&freq) != 1) { moderror("Getting parameter freq_samp\n"); return -1; } if (gain_id) { if (param_get_float(gain_id,&gain) != 1) { moderror("Getting parameter gain\n"); return -1; } } else { gain = 1.0; } #ifdef _COMPILE_ALOE if (freq != last_freq) { modinfo_msg("Set sampling frequency to %.2f MHz at tslot %d\n", freq/1000000,oesr_tstamp(ctx)); last_freq = freq; } #endif rtdal_uhd_set_freq(freq); for (i=0;i<NOF_INPUT_ITF;i++) { input_s = inp[i]; input_f = inp[i]; input_rf = inp[i]; rcv_samples = get_input_samples(i); #ifdef _COMPILE_ALOE if (rcv_samples != last_rcv_samples) { last_rcv_samples = rcv_samples; modinfo_msg("Receiving %d samples at tslot %d\n",rcv_samples,oesr_tstamp(ctx)); } #endif rtdal_uhd_set_block_len(rcv_samples); x=0; for (j=0;j<rcv_samples;j++) { switch(data_type) { case 0: buffer_rf[j] = gain*input_rf[j]; break; case 1: buffer_f[j] = gain*input_f[j]; break; case 2: buffer_s[j] = gain*input_s[j]; break; } } } return 0; }
int work(void **inp, void **out) { int rcv_samples; int n; input_t *input; output_t *output; float gain_re,gain_im,variance,scale; _Complex float gain_c; if (!get_input_samples(0)) { return 0; } if (param_get_float(gain_re_id, &gain_re) != 1) { moderror("Error getting parameter gain_re\n"); return -1; } if (param_get_float(gain_im_id, &gain_im) != 1) { moderror("Error getting parameter gain_im\n"); return -1; } if (param_get_float(scale_id, &scale) != 1) { moderror("Error getting parameter scale\n"); return -1; } if (!auto_mode) { if (param_get_float(variance_id, &variance) != 1) { moderror("Error getting parameter variance\n"); return -1; } } else if (auto_mode == 1) { variance = get_variance(snr_current,scale); cnt_realizations++; if (cnt_realizations >= num_realizations) { snr_current += snr_step; cnt_realizations=0; } if (snr_current >= snr_max) { auto_mode=2; variance=0; } } __real__ gain_c = gain_re; __imag__ gain_c = gain_im; for (n=0;n<NOF_INPUT_ITF;n++) { input = inp[n]; output = out[n]; rcv_samples = get_input_samples(0); if (variance != 0) { gen_noise_c(noise_vec,variance,rcv_samples); vec_sum_c(output,input,noise_vec,rcv_samples); } else { memcpy(output,input,rcv_samples*sizeof(input_t)); } if (gain_re != 1.0 && gain_im != 0.0) { vec_mult_c(output,output,gain_c,rcv_samples); } } return rcv_samples; }