/** 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;
}
