void dac_reload_callback(void)
{
int i;
if (current_stereo_out_buf == stereo_out_buf1)
current_stereo_out_buf = stereo_out_buf2;
else
current_stereo_out_buf = stereo_out_buf1;
generate_signal(signal1_buf, &signal1_generator);
generate_signal(signal2_buf, &signal2_generator);
/* In order for the FIR filter to work correctly we need to keep
* the last part of the previous buffer */
for (i = 0; i < FIR_NUM_COEF; i++) {
signal_pre_filter_buf[i] =
signal_pre_filter_buf[BUFFER_LENGTH + i];
}
/* New data is put in the signal_in_buf which points behind the data
* kept from the previous buffer */
dsp16_vect_add_and_sat(signal_in_buf, signal1_buf, signal2_buf,
BUFFER_LENGTH);
/* Run the FIR filter; the input buffer will be ... longer then the
* output buffer, which has normal length */
if (active_filter > 0) {
dsp16_filt_fir(signal_out_buf, signal_pre_filter_buf,
BUFFER_LENGTH + FIR_NUM_COEF - 1,
filter_coef[active_filter - 1], FIR_NUM_COEF);
} else {
for (i = 0; i < BUFFER_LENGTH; i++)
signal_out_buf[i] = signal_in_buf[i];
}
for (i = 0; i < BUFFER_LENGTH; i++) {
current_stereo_out_buf[i*2] = signal_out_buf[i];
current_stereo_out_buf[i*2+1] = signal_out_buf[i];
}
signals_are_updated = 1;
/* Update PDCA buffer */
tpa6130_dac_output(current_stereo_out_buf, BUFFER_LENGTH);
}
int main(int argc, char *argv[])
{
(void) argc;
(void) argv;
struct xdf *xdf = NULL;
int step, retval = EXIT_FAILURE;
unsigned int ns, i;
size_t strides[NARRAYS] = {
NEEG*sizeof(eeg[0]),
NSENS*sizeof(sens[0]),
sizeof(trigger[0])
};
/*************************************************
* File preparation *
*************************************************/
step = 0;
xdf = xdf_open(filename, XDF_WRITE, XDF_BDF);
if (xdf == NULL)
goto exit;
xdf_set_conf(xdf, XDF_F_SAMPLING_FREQ, FS, XDF_NOF);
step++;
if (configure_channels(xdf, NEEG, NSENS))
goto exit;
step++;
if (xdf_define_arrays(xdf, NARRAYS, strides)
|| xdf_prepare_transfer(xdf) )
goto exit;
/************************************************
* Writing loop *
*************************************************/
step++;
for (i=0; i<TOTAL_NS; i+=NS) {
ns = ((TOTAL_NS - i) >= NS) ? NS : (TOTAL_NS - i);
generate_signal(NEEG, eeg, NSENS, sens, trigger, FS, ns);
if (xdf_write(xdf, ns, eeg, sens, trigger) < 0)
goto exit;
}
retval = EXIT_SUCCESS;
exit:
if (retval != EXIT_SUCCESS) {
fprintf(stderr, "Error while %s : (%i) %s\n",
stepmsg[step], errno, strerror(errno));
}
xdf_close(xdf);
return retval;
}
int main() {
fftw_complex signal[NUM_POINTS];
fftw_complex result[NUM_POINTS];
fftw_plan plan = fftw_plan_dft_1d(NUM_POINTS,
signal,
result,
FFTW_FORWARD,
FFTW_ESTIMATE);
generate_signal(signal);
fftw_execute(plan);
compute_magnitude(result);
fftw_destroy_plan(plan);
return 0;
}
END_TEST
START_TEST(test_l2c_cm_correlator)
{
struct signal signal;
s8* code;
double init_code_phase = 0;
double init_carr_phase = 0;
double I_E;
double Q_E;
double I_P;
double Q_P;
double I_L;
double Q_L;
u32 num_samples;
code = get_prn_code(gps_l2cm_code, sizeof(gps_l2cm_code),
L2C_CM_CHIPS_PER_PRN_CODE);
fail_if(NULL == code, "Could not allocate L2C CM PRN code data");
signal = generate_signal( L2C_SIGNAL, /* signal type */
IF_FREQUENCY_HZ, /* intermediate frequency */
L2C_CM_CHIPPING_RATE_HZ, /* code frequency */
CARRIER_DOPPLER_FREQ_HZ,/* carr_doppler frequency */
1. / 1200, /* carrier to code scaling factor */
SAMPLING_FREQ_HZ, /* sampling frequency */
code, /* PRN code data */
20); /* milliseconds to generate */
fail_if(NULL == signal.samples, "Could not generate signal data");
debug_start_timing();
l2c_cm_track_correlate(signal.samples, signal.size,
code,
2 * L2C_CM_CHIPS_PER_PRN_CODE,
&init_code_phase,
L2C_CM_CHIPPING_RATE_HZ / SAMPLING_FREQ_HZ,
&init_carr_phase,
(IF_FREQUENCY_HZ + CARRIER_DOPPLER_FREQ_HZ) * 2.0 * M_PI / SAMPLING_FREQ_HZ,
&I_E, &Q_E,
&I_P, &Q_P,
&I_L, &Q_L,
&num_samples);
debug_stop_timing();
debug_dump_results(num_samples, I_E, Q_E, I_P, Q_P, I_L, Q_L);
u32 expected_samples = 20 * SAMPLING_FREQ_HZ / 1000; /* samples per PRN code */
fail_if(num_samples != expected_samples);
fail_if((I_P != 0) && (fabs(I_E / I_P) > 0.6));
fail_if((I_P != 0) && (fabs(I_L / I_P) > 0.6));
fail_if((I_E != 0) && (fabs(Q_E / I_E) > 0.006));
fail_if((I_P != 0) && (fabs(Q_P / I_P) > 0.005));
fail_if((I_L != 0) && (fabs(Q_L / I_L) > 0.006));
free(code);
free(signal.samples);
}
