void generate_sine_tables(void)
{
struct tuning_state *ts;
int i;
for (i=0; i < tune_count; i++) {
ts = &tunes[i];
sine_table(ts->bin_e);
ts->sine = &s_tables[ts->bin_e];
ts->fft_buf = malloc(ts->buf_len * sizeof(int16_t));
}
}
void writeStream(PaStream *handle, float frequency, float duration, float amplitude) {
int i,j,dur, count = 0;
dur = duration*44100/256;
float index, index2, control, cr, *buf, *wave;
cr = 44100/256;
index = 0.f;
buf = (float*) malloc(256*sizeof(float));
wave = sine_table(2048, 0);
for(j = 0;j < dur;j++){
oscillator(buf, frequency+oscillator(&control,5.f,5.f, wave, &index2,2048, 1,cr),envelope(duration,cr,&count)*amplitude,wave,&index,2048,256,44100);
Pa_WriteStream(handle, buf, 256);
}
free(buf);
free(wave);
}
int main ( void )
/******************************************************************************/
/*
Purpose:
MAIN is the main program for MULTITASK_OPENMP.
Discussion:
This program demonstrates how OpenMP can be used for multitasking, that
is, a simple kind of parallel processing in which a certain number of
perhaps quite unrelated tasks must be done.
The OpenMP SECTIONS directive identifies the portion of the program where
the code for these tasks is given.
The OpenMP SECTION directive is used repeatedly to divide this area of
the program into independent tasks.
The code will get the benefit of parallel processing up to the point where
there are as many threads as there are tasks.
The code will get a substantial speedup if the tasks take roughly the
same amount of time. However, if one task takes substantially more time
than the others, this results in a limit to the parallel speedup that is
possible.
Licensing:
This code is distributed under the GNU LGPL license.
Modified:
19 October 2011
Author:
John Burkardt
*/
{
int prime_num;
int *primes;
int sine_num;
double *sines;
double wtime;
double wtime1;
double wtime2;
timestamp ( );
printf ( "\n" );
printf ( "MULTITASK_OPENMP:\n" );
printf ( " C/OpenMP version\n" );
printf ( " Demonstrate how OpenMP can \"multitask\" by using the\n" );
printf ( " SECTIONS directive to carry out several tasks in parallel.\n" );
prime_num = 20000;
sine_num = 20000;
wtime = omp_get_wtime ( );
# pragma omp parallel shared ( prime_num, primes, sine_num, sines )
{
# pragma omp sections
{
# pragma omp section
{
wtime1 = omp_get_wtime ( );
primes = prime_table ( prime_num );
wtime1 = omp_get_wtime ( ) - wtime1;
}
# pragma omp section
{
wtime2 = omp_get_wtime ( );
sines = sine_table ( sine_num );
wtime2 = omp_get_wtime ( ) - wtime2;
}
}
}
wtime = omp_get_wtime ( ) - wtime;
printf ( "\n" );
printf ( " Number of primes computed was %d\n", prime_num );
printf ( " Last prime was %d\n", primes[prime_num-1] );
printf ( " Number of sines computed was %d\n", sine_num );
printf ( " Last sine computed was %g\n", sines[sine_num-1] );
printf ( "\n" );
printf ( " Elapsed time = %g\n", wtime );
printf ( " Task 1 time = %g\n", wtime1 );
printf ( " Task 2 time = %g\n", wtime2 );
free ( primes );
free ( sines );
/*
Terminate.
*/
printf ( "\n" );
printf ( "MULTITASK_OPENMP:\n" );
printf ( " Normal end of execution.\n" );
printf ( "\n" );
timestamp ( );
return 0;
}
int main(int argc, char **argv)
{
#ifndef _WIN32
struct sigaction sigact;
#endif
char *filename = NULL;
int i, length, n_read, r, opt, wb_mode = 0;
int f_set = 0;
int gain = AUTO_GAIN; // tenths of a dB
uint8_t *buffer;
uint32_t dev_index = 0;
int device_count;
int ppm_error = 0;
int interval = 10;
int fft_threads = 1;
int smoothing = 0;
int single = 0;
double crop = 0.0;
char vendor[256], product[256], serial[256];
char *freq_optarg;
time_t next_tick;
time_t time_now;
time_t exit_time = 0;
char t_str[50];
struct tm *cal_time;
double (*window_fn)(int, int) = rectangle;
freq_optarg = "";
while ((opt = getopt(argc, argv, "f:i:s:t:d:g:p:e:w:c:1Fh")) != -1) {
switch (opt) {
case 'f': // lower:upper:bin_size
freq_optarg = strdup(optarg);
f_set = 1;
break;
case 'd':
dev_index = atoi(optarg);
break;
case 'g':
gain = (int)(atof(optarg) * 10);
break;
case 'c':
crop = atofp(optarg);
break;
case 'i':
interval = (int)round(atoft(optarg));
break;
case 'e':
exit_time = (time_t)((int)round(atoft(optarg)));
break;
case 's':
if (strcmp("avg", optarg) == 0) {
smoothing = 0;}
if (strcmp("iir", optarg) == 0) {
smoothing = 1;}
break;
case 'w':
if (strcmp("rectangle", optarg) == 0) {
window_fn = rectangle;}
if (strcmp("hamming", optarg) == 0) {
window_fn = hamming;}
if (strcmp("blackman", optarg) == 0) {
window_fn = blackman;}
if (strcmp("blackman-harris", optarg) == 0) {
window_fn = blackman_harris;}
if (strcmp("hann-poisson", optarg) == 0) {
window_fn = hann_poisson;}
if (strcmp("youssef", optarg) == 0) {
window_fn = youssef;}
if (strcmp("kaiser", optarg) == 0) {
window_fn = kaiser;}
if (strcmp("bartlett", optarg) == 0) {
window_fn = bartlett;}
break;
case 't':
fft_threads = atoi(optarg);
break;
case 'p':
ppm_error = atoi(optarg);
break;
case '1':
single = 1;
break;
case 'F':
boxcar = 0;
break;
case 'h':
default:
usage();
break;
}
}
if (!f_set) {
fprintf(stderr, "No frequency range provided.\n");
exit(1);
}
if ((crop < 0.0) || (crop > 1.0)) {
fprintf(stderr, "Crop value outside of 0 to 1.\n");
exit(1);
}
frequency_range(freq_optarg, crop);
if (tune_count == 0) {
usage();}
if (argc <= optind) {
filename = "-";
} else {
filename = argv[optind];
}
if (interval < 1) {
interval = 1;}
fprintf(stderr, "Reporting every %i seconds\n", interval);
device_count = rtlsdr_get_device_count();
if (!device_count) {
fprintf(stderr, "No supported devices found.\n");
exit(1);
}
fprintf(stderr, "Found %d device(s):\n", device_count);
for (i = 0; i < device_count; i++) {
rtlsdr_get_device_usb_strings(i, vendor, product, serial);
fprintf(stderr, " %d: %s, %s, SN: %s\n", i, vendor, product, serial);
}
fprintf(stderr, "\n");
fprintf(stderr, "Using device %d: %s\n",
dev_index, rtlsdr_get_device_name(dev_index));
r = rtlsdr_open(&dev, dev_index);
if (r < 0) {
fprintf(stderr, "Failed to open rtlsdr device #%d.\n", dev_index);
exit(1);
}
#ifndef _WIN32
sigact.sa_handler = sighandler;
sigemptyset(&sigact.sa_mask);
sigact.sa_flags = 0;
sigaction(SIGINT, &sigact, NULL);
sigaction(SIGTERM, &sigact, NULL);
sigaction(SIGQUIT, &sigact, NULL);
sigaction(SIGPIPE, &sigact, NULL);
#else
SetConsoleCtrlHandler( (PHANDLER_ROUTINE) sighandler, TRUE );
#endif
/* Set the tuner gain */
if (gain == AUTO_GAIN) {
r = rtlsdr_set_tuner_gain_mode(dev, 0);
} else {
r = rtlsdr_set_tuner_gain_mode(dev, 1);
gain = nearest_gain(gain);
r = rtlsdr_set_tuner_gain(dev, gain);
}
if (r != 0) {
fprintf(stderr, "WARNING: Failed to set tuner gain.\n");
} else if (gain == AUTO_GAIN) {
fprintf(stderr, "Tuner gain set to automatic.\n");
} else {
fprintf(stderr, "Tuner gain set to %0.2f dB.\n", gain/10.0);
}
r = rtlsdr_set_freq_correction(dev, ppm_error);
if (strcmp(filename, "-") == 0) { /* Write log to stdout */
file = stdout;
#ifdef _WIN32
// Is this necessary? Output is ascii.
_setmode(_fileno(file), _O_BINARY);
#endif
} else {
file = fopen(filename, "wb");
if (!file) {
fprintf(stderr, "Failed to open %s\n", filename);
exit(1);
}
}
/* Reset endpoint before we start reading from it (mandatory) */
r = rtlsdr_reset_buffer(dev);
if (r < 0) {
fprintf(stderr, "WARNING: Failed to reset buffers.\n");}
/* actually do stuff */
rtlsdr_set_sample_rate(dev, (uint32_t)tunes[0].rate);
sine_table(tunes[0].bin_e);
next_tick = time(NULL) + interval;
if (exit_time) {
exit_time = time(NULL) + exit_time;}
fft_buf = malloc(tunes[0].buf_len * sizeof(int16_t));
length = 1 << tunes[0].bin_e;
window_coefs = malloc(length * sizeof(int));
for (i=0; i<length; i++) {
window_coefs[i] = (int)(256*window_fn(i, length));
}
while (!do_exit) {
scanner();
time_now = time(NULL);
if (time_now < next_tick) {
continue;}
// time, Hz low, Hz high, Hz step, samples, dbm, dbm, ...
cal_time = localtime(&time_now);
strftime(t_str, 50, "%Y-%m-%d, %H:%M:%S", cal_time);
for (i=0; i<tune_count; i++) {
fprintf(file, "%s, ", t_str);
csv_dbm(&tunes[i]);
}
fflush(file);
while (time(NULL) >= next_tick) {
next_tick += interval;}
if (single) {
do_exit = 1;}
if (exit_time && time(NULL) >= exit_time) {
do_exit = 1;}
}
/* clean up */
if (do_exit) {
fprintf(stderr, "\nUser cancel, exiting...\n");}
else {
fprintf(stderr, "\nLibrary error %d, exiting...\n", r);}
if (file != stdout) {
fclose(file);}
rtlsdr_close(dev);
free(fft_buf);
free(window_coefs);
//for (i=0; i<tune_count; i++) {
// free(tunes[i].avg);
// free(tunes[i].buf8);
//}
return r >= 0 ? r : -r;
}
