Sojus07/hackrf
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add support for transmitting/receiving from stdin/stdout

Browse Source 
When '-' is used for filename, write samples to stdout when receiving or
read samples from stdin when transmitting. This allows using
hackrf_transfer in shell pipes with tools like csdr.
User info messages are written to stderr.
This commit is contained in:
Radoslav Gerganov
2016-05-29 13:39:51 +03:00
parent 04687dce50
commit 51419b7efc
1 changed files with 69 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

130
host/hackrf-tools/src/hackrf_transfer.c
View File

@ -426,8 +426,8 @@ int tx_callback(hackrf_transfer* transfer) {
static void usage() { static void usage() {
printf("Usage:\n"); printf("Usage:\n");
printf("\t[-d serial_number] # Serial number of desired HackRF.\n"); printf("\t[-d serial_number] # Serial number of desired HackRF.\n");
printf("\t-r <filename> # Receive data into file.\n"); printf("\t-r <filename> # Receive data into file (use '-' for stdout).\n");
printf("\t-t <filename> # Transmit data from file.\n"); printf("\t-t <filename> # Transmit data from file (use '-' for stdin).\n");
printf("\t-w # Receive data into file with WAV header and automatic name.\n"); printf("\t-w # Receive data into file with WAV header and automatic name.\n");
printf("\t # This is for SDR# compatibility and may not work with other software.\n"); printf("\t # This is for SDR# compatibility and may not work with other software.\n");
printf("\t[-f freq_hz] # Frequency in Hz [%sMHz to %sMHz].\n", printf("\t[-f freq_hz] # Frequency in Hz [%sMHz to %sMHz].\n",
@ -611,26 +611,26 @@ int main(int argc, char** argv) {
break; break;
default: default:
printf("unknown argument '-%c %s'\n", opt, optarg); fprintf(stderr, "unknown argument '-%c %s'\n", opt, optarg);
usage(); usage();
return EXIT_FAILURE; return EXIT_FAILURE;
} }
if( result != HACKRF_SUCCESS ) { if( result != HACKRF_SUCCESS ) {
printf("argument error: '-%c %s' %s (%d)\n", opt, optarg, hackrf_error_name(result), result); fprintf(stderr, "argument error: '-%c %s' %s (%d)\n", opt, optarg, hackrf_error_name(result), result);
usage(); usage();
return EXIT_FAILURE; return EXIT_FAILURE;
} }
} }
if (lna_gain % 8) if (lna_gain % 8)
printf("warning: lna_gain (-l) must be a multiple of 8\n"); fprintf(stderr, "warning: lna_gain (-l) must be a multiple of 8\n");
if (vga_gain % 2) if (vga_gain % 2)
printf("warning: vga_gain (-g) must be a multiple of 2\n"); fprintf(stderr, "warning: vga_gain (-g) must be a multiple of 2\n");
if (samples_to_xfer >= SAMPLES_TO_XFER_MAX) { if (samples_to_xfer >= SAMPLES_TO_XFER_MAX) {
printf("argument error: num_samples must be less than %s/%sMio\n", fprintf(stderr, "argument error: num_samples must be less than %s/%sMio\n",
u64toa(SAMPLES_TO_XFER_MAX,&ascii_u64_data1), u64toa(SAMPLES_TO_XFER_MAX,&ascii_u64_data1),
u64toa((SAMPLES_TO_XFER_MAX/FREQ_ONE_MHZ),&ascii_u64_data2)); u64toa((SAMPLES_TO_XFER_MAX/FREQ_ONE_MHZ),&ascii_u64_data2));
usage(); usage();
@ -640,41 +640,41 @@ int main(int argc, char** argv) {
if (if_freq || lo_freq || image_reject) { if (if_freq || lo_freq || image_reject) {
/* explicit tuning selected */ /* explicit tuning selected */
if (!if_freq) { if (!if_freq) {
printf("argument error: if_freq_hz must be specified for explicit tuning.\n"); fprintf(stderr, "argument error: if_freq_hz must be specified for explicit tuning.\n");
usage(); usage();
return EXIT_FAILURE; return EXIT_FAILURE;
} }
if (!image_reject) { if (!image_reject) {
printf("argument error: image_reject must be specified for explicit tuning.\n"); fprintf(stderr, "argument error: image_reject must be specified for explicit tuning.\n");
usage(); usage();
return EXIT_FAILURE; return EXIT_FAILURE;
} }
if (!lo_freq && (image_reject_selection != RF_PATH_FILTER_BYPASS)) { if (!lo_freq && (image_reject_selection != RF_PATH_FILTER_BYPASS)) {
printf("argument error: lo_freq_hz must be specified for explicit tuning unless image_reject is set to bypass.\n"); fprintf(stderr, "argument error: lo_freq_hz must be specified for explicit tuning unless image_reject is set to bypass.\n");
usage(); usage();
return EXIT_FAILURE; return EXIT_FAILURE;
} }
if ((if_freq_hz > IF_MAX_HZ) || (if_freq_hz < IF_MIN_HZ)) { if ((if_freq_hz > IF_MAX_HZ) || (if_freq_hz < IF_MIN_HZ)) {
printf("argument error: if_freq_hz shall be between %s and %s.\n", fprintf(stderr, "argument error: if_freq_hz shall be between %s and %s.\n",
u64toa(IF_MIN_HZ,&ascii_u64_data1), u64toa(IF_MIN_HZ,&ascii_u64_data1),
u64toa(IF_MAX_HZ,&ascii_u64_data2)); u64toa(IF_MAX_HZ,&ascii_u64_data2));
usage(); usage();
return EXIT_FAILURE; return EXIT_FAILURE;
} }
if ((lo_freq_hz > LO_MAX_HZ) || (lo_freq_hz < LO_MIN_HZ)) { if ((lo_freq_hz > LO_MAX_HZ) || (lo_freq_hz < LO_MIN_HZ)) {
printf("argument error: lo_freq_hz shall be between %s and %s.\n", fprintf(stderr, "argument error: lo_freq_hz shall be between %s and %s.\n",
u64toa(LO_MIN_HZ,&ascii_u64_data1), u64toa(LO_MIN_HZ,&ascii_u64_data1),
u64toa(LO_MAX_HZ,&ascii_u64_data2)); u64toa(LO_MAX_HZ,&ascii_u64_data2));
usage(); usage();
return EXIT_FAILURE; return EXIT_FAILURE;
} }
if (image_reject_selection > 2) { if (image_reject_selection > 2) {
printf("argument error: image_reject must be 0, 1, or 2 .\n"); fprintf(stderr, "argument error: image_reject must be 0, 1, or 2 .\n");
usage(); usage();
return EXIT_FAILURE; return EXIT_FAILURE;
} }
if (automatic_tuning) { if (automatic_tuning) {
printf("warning: freq_hz ignored by explicit tuning selection.\n"); fprintf(stderr, "warning: freq_hz ignored by explicit tuning selection.\n");
automatic_tuning = false; automatic_tuning = false;
} }
switch (image_reject_selection) { switch (image_reject_selection) {
@ -691,13 +691,13 @@ int main(int argc, char** argv) {
freq_hz = DEFAULT_FREQ_HZ; freq_hz = DEFAULT_FREQ_HZ;
break; break;
} }
printf("explicit tuning specified for %s Hz.\n", fprintf(stderr, "explicit tuning specified for %s Hz.\n",
u64toa(freq_hz,&ascii_u64_data1)); u64toa(freq_hz,&ascii_u64_data1));
} else if (automatic_tuning) { } else if (automatic_tuning) {
if( (freq_hz > FREQ_MAX_HZ) || (freq_hz < FREQ_MIN_HZ) ) if( (freq_hz > FREQ_MAX_HZ) || (freq_hz < FREQ_MIN_HZ) )
{ {
printf("argument error: freq_hz shall be between %s and %s.\n", fprintf(stderr, "argument error: freq_hz shall be between %s and %s.\n",
u64toa(FREQ_MIN_HZ,&ascii_u64_data1), u64toa(FREQ_MIN_HZ,&ascii_u64_data1),
u64toa(FREQ_MAX_HZ,&ascii_u64_data2)); u64toa(FREQ_MAX_HZ,&ascii_u64_data2));
usage(); usage();
@ -712,7 +712,7 @@ int main(int argc, char** argv) {
if( amp ) { if( amp ) {
if( amp_enable > 1 ) if( amp_enable > 1 )
{ {
printf("argument error: amp_enable shall be 0 or 1.\n"); fprintf(stderr, "argument error: amp_enable shall be 0 or 1.\n");
usage(); usage();
return EXIT_FAILURE; return EXIT_FAILURE;
} }
@ -720,7 +720,7 @@ int main(int argc, char** argv) {
if (antenna) { if (antenna) {
if (antenna_enable > 1) { if (antenna_enable > 1) {
printf("argument error: antenna_enable shall be 0 or 1.\n"); fprintf(stderr, "argument error: antenna_enable shall be 0 or 1.\n");
usage(); usage();
return EXIT_FAILURE; return EXIT_FAILURE;
} }
@ -742,14 +742,14 @@ int main(int argc, char** argv) {
} }
if (baseband_filter_bw_hz > BASEBAND_FILTER_BW_MAX) { if (baseband_filter_bw_hz > BASEBAND_FILTER_BW_MAX) {
printf("argument error: baseband_filter_bw_hz must be less or equal to %u Hz/%.03f MHz\n", fprintf(stderr, "argument error: baseband_filter_bw_hz must be less or equal to %u Hz/%.03f MHz\n",
BASEBAND_FILTER_BW_MAX, (float)(BASEBAND_FILTER_BW_MAX/FREQ_ONE_MHZ)); BASEBAND_FILTER_BW_MAX, (float)(BASEBAND_FILTER_BW_MAX/FREQ_ONE_MHZ));
usage(); usage();
return EXIT_FAILURE; return EXIT_FAILURE;
} }
if (baseband_filter_bw_hz < BASEBAND_FILTER_BW_MIN) { if (baseband_filter_bw_hz < BASEBAND_FILTER_BW_MIN) {
printf("argument error: baseband_filter_bw_hz must be greater or equal to %u Hz/%.03f MHz\n", fprintf(stderr, "argument error: baseband_filter_bw_hz must be greater or equal to %u Hz/%.03f MHz\n",
BASEBAND_FILTER_BW_MIN, (float)(BASEBAND_FILTER_BW_MIN/FREQ_ONE_MHZ)); BASEBAND_FILTER_BW_MIN, (float)(BASEBAND_FILTER_BW_MIN/FREQ_ONE_MHZ));
usage(); usage();
return EXIT_FAILURE; return EXIT_FAILURE;
@ -757,7 +757,7 @@ int main(int argc, char** argv) {
if( (transmit == false) && (receive == receive_wav) ) if( (transmit == false) && (receive == receive_wav) )
{ {
printf("receive -r and receive_wav -w options are mutually exclusive\n"); fprintf(stderr, "receive -r and receive_wav -w options are mutually exclusive\n");
usage(); usage();
return EXIT_FAILURE; return EXIT_FAILURE;
} }
@ -768,10 +768,10 @@ int main(int argc, char** argv) {
{ {
if( transmit == true ) if( transmit == true )
{ {
printf("receive -r and transmit -t options are mutually exclusive\n"); fprintf(stderr, "receive -r and transmit -t options are mutually exclusive\n");
} else } else
{ {
printf("specify either transmit -t or receive -r or receive_wav -w option\n"); fprintf(stderr, "specify either transmit -t or receive -r or receive_wav -w option\n");
} }
usage(); usage();
return EXIT_FAILURE; return EXIT_FAILURE;
@ -789,7 +789,7 @@ int main(int argc, char** argv) {
if (signalsource) { if (signalsource) {
transceiver_mode = TRANSCEIVER_MODE_SS; transceiver_mode = TRANSCEIVER_MODE_SS;
if (amplitude >127) { if (amplitude >127) {
printf("argument error: amplitude shall be in between 0 and 128.\n"); fprintf(stderr, "argument error: amplitude shall be in between 0 and 128.\n");
usage(); usage();
return EXIT_FAILURE; return EXIT_FAILURE;
} }
@ -804,13 +804,13 @@ int main(int argc, char** argv) {
strftime(date_time, DATE_TIME_MAX_LEN, "%Y%m%d_%H%M%S", timeinfo); strftime(date_time, DATE_TIME_MAX_LEN, "%Y%m%d_%H%M%S", timeinfo);
snprintf(path_file, PATH_FILE_MAX_LEN, "HackRF_%sZ_%ukHz_IQ.wav", date_time, (uint32_t)(freq_hz/(1000ull)) ); snprintf(path_file, PATH_FILE_MAX_LEN, "HackRF_%sZ_%ukHz_IQ.wav", date_time, (uint32_t)(freq_hz/(1000ull)) );
path = path_file; path = path_file;
printf("Receive wav file: %s\n", path); fprintf(stderr, "Receive wav file: %s\n", path);
} }
// In signal source mode, the PATH argument is neglected. // In signal source mode, the PATH argument is neglected.
if (transceiver_mode != TRANSCEIVER_MODE_SS) { if (transceiver_mode != TRANSCEIVER_MODE_SS) {
if( path == NULL ) { if( path == NULL ) {
printf("specify a path to a file to transmit/receive\n"); fprintf(stderr, "specify a path to a file to transmit/receive\n");
usage(); usage();
return EXIT_FAILURE; return EXIT_FAILURE;
} }
@ -818,14 +818,14 @@ int main(int argc, char** argv) {
result = hackrf_init(); result = hackrf_init();
if( result != HACKRF_SUCCESS ) { if( result != HACKRF_SUCCESS ) {
printf("hackrf_init() failed: %s (%d)\n", hackrf_error_name(result), result); fprintf(stderr, "hackrf_init() failed: %s (%d)\n", hackrf_error_name(result), result);
usage(); usage();
return EXIT_FAILURE; return EXIT_FAILURE;
} }
result = hackrf_open_by_serial(serial_number, &device); result = hackrf_open_by_serial(serial_number, &device);
if( result != HACKRF_SUCCESS ) { if( result != HACKRF_SUCCESS ) {
printf("hackrf_open() failed: %s (%d)\n", hackrf_error_name(result), result); fprintf(stderr, "hackrf_open() failed: %s (%d)\n", hackrf_error_name(result), result);
usage(); usage();
return EXIT_FAILURE; return EXIT_FAILURE;
} }
@ -833,19 +833,27 @@ int main(int argc, char** argv) {
if (transceiver_mode != TRANSCEIVER_MODE_SS) { if (transceiver_mode != TRANSCEIVER_MODE_SS) {
if( transceiver_mode == TRANSCEIVER_MODE_RX ) if( transceiver_mode == TRANSCEIVER_MODE_RX )
{ {
fd = fopen(path, "wb"); if (strcmp(path, "-") == 0) {
fd = stdout;
} else {
fd = fopen(path, "wb");
}
} else { } else {
fd = fopen(path, "rb"); if (strcmp(path, "-") == 0) {
fd = stdin;
} else {
fd = fopen(path, "rb");
}
} }
if( fd == NULL ) { if( fd == NULL ) {
printf("Failed to open file: %s\n", path); fprintf(stderr, "Failed to open file: %s\n", path);
return EXIT_FAILURE; return EXIT_FAILURE;
} }
/* Change fd buffer to have bigger one to store or read data on/to HDD */ /* Change fd buffer to have bigger one to store or read data on/to HDD */
result = setvbuf(fd , NULL , _IOFBF , FD_BUFFER_SIZE); result = setvbuf(fd , NULL , _IOFBF , FD_BUFFER_SIZE);
if( result != 0 ) { if( result != 0 ) {
printf("setvbuf() failed: %d\n", result); fprintf(stderr, "setvbuf() failed: %d\n", result);
usage(); usage();
return EXIT_FAILURE; return EXIT_FAILURE;
} }
@ -867,19 +875,19 @@ int main(int argc, char** argv) {
signal(SIGTERM, &sigint_callback_handler); signal(SIGTERM, &sigint_callback_handler);
signal(SIGABRT, &sigint_callback_handler); signal(SIGABRT, &sigint_callback_handler);
#endif #endif
printf("call hackrf_sample_rate_set(%u Hz/%.03f MHz)\n", sample_rate_hz,((float)sample_rate_hz/(float)FREQ_ONE_MHZ)); fprintf(stderr, "call hackrf_sample_rate_set(%u Hz/%.03f MHz)\n", sample_rate_hz,((float)sample_rate_hz/(float)FREQ_ONE_MHZ));
result = hackrf_set_sample_rate_manual(device, sample_rate_hz, 1); result = hackrf_set_sample_rate_manual(device, sample_rate_hz, 1);
if( result != HACKRF_SUCCESS ) { if( result != HACKRF_SUCCESS ) {
printf("hackrf_sample_rate_set() failed: %s (%d)\n", hackrf_error_name(result), result); fprintf(stderr, "hackrf_sample_rate_set() failed: %s (%d)\n", hackrf_error_name(result), result);
usage(); usage();
return EXIT_FAILURE; return EXIT_FAILURE;
} }
printf("call hackrf_baseband_filter_bandwidth_set(%d Hz/%.03f MHz)\n", fprintf(stderr, "call hackrf_baseband_filter_bandwidth_set(%d Hz/%.03f MHz)\n",
baseband_filter_bw_hz, ((float)baseband_filter_bw_hz/(float)FREQ_ONE_MHZ)); baseband_filter_bw_hz, ((float)baseband_filter_bw_hz/(float)FREQ_ONE_MHZ));
result = hackrf_set_baseband_filter_bandwidth(device, baseband_filter_bw_hz); result = hackrf_set_baseband_filter_bandwidth(device, baseband_filter_bw_hz);
if( result != HACKRF_SUCCESS ) { if( result != HACKRF_SUCCESS ) {
printf("hackrf_baseband_filter_bandwidth_set() failed: %s (%d)\n", hackrf_error_name(result), result); fprintf(stderr, "hackrf_baseband_filter_bandwidth_set() failed: %s (%d)\n", hackrf_error_name(result), result);
usage(); usage();
return EXIT_FAILURE; return EXIT_FAILURE;
} }
@ -893,29 +901,29 @@ int main(int argc, char** argv) {
result |= hackrf_start_tx(device, tx_callback, NULL); result |= hackrf_start_tx(device, tx_callback, NULL);
} }
if( result != HACKRF_SUCCESS ) { if( result != HACKRF_SUCCESS ) {
printf("hackrf_start_?x() failed: %s (%d)\n", hackrf_error_name(result), result); fprintf(stderr, "hackrf_start_?x() failed: %s (%d)\n", hackrf_error_name(result), result);
usage(); usage();
return EXIT_FAILURE; return EXIT_FAILURE;
} }
if (automatic_tuning) { if (automatic_tuning) {
printf("call hackrf_set_freq(%s Hz/%.03f MHz)\n", fprintf(stderr, "call hackrf_set_freq(%s Hz/%.03f MHz)\n",
u64toa(freq_hz, &ascii_u64_data1),((double)freq_hz/(double)FREQ_ONE_MHZ) ); u64toa(freq_hz, &ascii_u64_data1),((double)freq_hz/(double)FREQ_ONE_MHZ) );
result = hackrf_set_freq(device, freq_hz); result = hackrf_set_freq(device, freq_hz);
if( result != HACKRF_SUCCESS ) { if( result != HACKRF_SUCCESS ) {
printf("hackrf_set_freq() failed: %s (%d)\n", hackrf_error_name(result), result); fprintf(stderr, "hackrf_set_freq() failed: %s (%d)\n", hackrf_error_name(result), result);
usage(); usage();
return EXIT_FAILURE; return EXIT_FAILURE;
} }
} else { } else {
printf("call hackrf_set_freq_explicit() with %s Hz IF, %s Hz LO, %s\n", fprintf(stderr, "call hackrf_set_freq_explicit() with %s Hz IF, %s Hz LO, %s\n",
u64toa(if_freq_hz,&ascii_u64_data1), u64toa(if_freq_hz,&ascii_u64_data1),
u64toa(lo_freq_hz,&ascii_u64_data2), u64toa(lo_freq_hz,&ascii_u64_data2),
hackrf_filter_path_name(image_reject_selection)); hackrf_filter_path_name(image_reject_selection));
result = hackrf_set_freq_explicit(device, if_freq_hz, lo_freq_hz, result = hackrf_set_freq_explicit(device, if_freq_hz, lo_freq_hz,
image_reject_selection); image_reject_selection);
if (result != HACKRF_SUCCESS) { if (result != HACKRF_SUCCESS) {
printf("hackrf_set_freq_explicit() failed: %s (%d)\n", fprintf(stderr, "hackrf_set_freq_explicit() failed: %s (%d)\n",
hackrf_error_name(result), result); hackrf_error_name(result), result);
usage(); usage();
return EXIT_FAILURE; return EXIT_FAILURE;
@ -923,27 +931,27 @@ int main(int argc, char** argv) {
} }
if( amp ) { if( amp ) {
printf("call hackrf_set_amp_enable(%u)\n", amp_enable); fprintf(stderr, "call hackrf_set_amp_enable(%u)\n", amp_enable);
result = hackrf_set_amp_enable(device, (uint8_t)amp_enable); result = hackrf_set_amp_enable(device, (uint8_t)amp_enable);
if( result != HACKRF_SUCCESS ) { if( result != HACKRF_SUCCESS ) {
printf("hackrf_set_amp_enable() failed: %s (%d)\n", hackrf_error_name(result), result); fprintf(stderr, "hackrf_set_amp_enable() failed: %s (%d)\n", hackrf_error_name(result), result);
usage(); usage();
return EXIT_FAILURE; return EXIT_FAILURE;
} }
} }
if (antenna) { if (antenna) {
printf("call hackrf_set_antenna_enable(%u)\n", antenna_enable); fprintf(stderr, "call hackrf_set_antenna_enable(%u)\n", antenna_enable);
result = hackrf_set_antenna_enable(device, (uint8_t)antenna_enable); result = hackrf_set_antenna_enable(device, (uint8_t)antenna_enable);
if (result != HACKRF_SUCCESS) { if (result != HACKRF_SUCCESS) {
printf("hackrf_set_antenna_enable() failed: %s (%d)\n", hackrf_error_name(result), result); fprintf(stderr, "hackrf_set_antenna_enable() failed: %s (%d)\n", hackrf_error_name(result), result);
usage(); usage();
return EXIT_FAILURE; return EXIT_FAILURE;
} }
} }
if( limit_num_samples ) { if( limit_num_samples ) {
printf("samples_to_xfer %s/%sMio\n", fprintf(stderr, "samples_to_xfer %s/%sMio\n",
u64toa(samples_to_xfer,&ascii_u64_data1), u64toa(samples_to_xfer,&ascii_u64_data1),
u64toa((samples_to_xfer/FREQ_ONE_MHZ),&ascii_u64_data2) ); u64toa((samples_to_xfer/FREQ_ONE_MHZ),&ascii_u64_data2) );
} }
@ -951,7 +959,7 @@ int main(int argc, char** argv) {
gettimeofday(&t_start, NULL); gettimeofday(&t_start, NULL);
gettimeofday(&time_start, NULL); gettimeofday(&time_start, NULL);
printf("Stop with Ctrl-C\n"); fprintf(stderr, "Stop with Ctrl-C\n");
while( (hackrf_is_streaming(device) == HACKRF_TRUE) && while( (hackrf_is_streaming(device) == HACKRF_TRUE) &&
(do_exit == false) ) (do_exit == false) )
{ {
@ -967,14 +975,14 @@ int main(int argc, char** argv) {
time_difference = TimevalDiff(&time_now, &time_start); time_difference = TimevalDiff(&time_now, &time_start);
rate = (float)byte_count_now / time_difference; rate = (float)byte_count_now / time_difference;
printf("%4.1f MiB / %5.3f sec = %4.1f MiB/second\n", fprintf(stderr, "%4.1f MiB / %5.3f sec = %4.1f MiB/second\n",
(byte_count_now / 1e6f), time_difference, (rate / 1e6f) ); (byte_count_now / 1e6f), time_difference, (rate / 1e6f) );
time_start = time_now; time_start = time_now;
if (byte_count_now == 0) { if (byte_count_now == 0) {
exit_code = EXIT_FAILURE; exit_code = EXIT_FAILURE;
printf("\nCouldn't transfer any bytes for one second.\n"); fprintf(stderr, "\nCouldn't transfer any bytes for one second.\n");
break; break;
} }
} }
@ -982,14 +990,14 @@ int main(int argc, char** argv) {
result = hackrf_is_streaming(device); result = hackrf_is_streaming(device);
if (do_exit) if (do_exit)
{ {
printf("\nUser cancel, exiting...\n"); fprintf(stderr, "\nUser cancel, exiting...\n");
} else { } else {
printf("\nExiting... hackrf_is_streaming() result: %s (%d)\n", hackrf_error_name(result), result); fprintf(stderr, "\nExiting... hackrf_is_streaming() result: %s (%d)\n", hackrf_error_name(result), result);
} }
gettimeofday(&t_end, NULL); gettimeofday(&t_end, NULL);
time_diff = TimevalDiff(&t_end, &t_start); time_diff = TimevalDiff(&t_end, &t_start);
printf("Total time: %5.5f s\n", time_diff); fprintf(stderr, "Total time: %5.5f s\n", time_diff);
if(device != NULL) if(device != NULL)
{ {
@ -997,9 +1005,9 @@ int main(int argc, char** argv) {
{ {
result = hackrf_stop_rx(device); result = hackrf_stop_rx(device);
if( result != HACKRF_SUCCESS ) { if( result != HACKRF_SUCCESS ) {
printf("hackrf_stop_rx() failed: %s (%d)\n", hackrf_error_name(result), result); fprintf(stderr, "hackrf_stop_rx() failed: %s (%d)\n", hackrf_error_name(result), result);
}else { }else {
printf("hackrf_stop_rx() done\n"); fprintf(stderr, "hackrf_stop_rx() done\n");
} }
} }
@ -1007,22 +1015,22 @@ int main(int argc, char** argv) {
{ {
result = hackrf_stop_tx(device); result = hackrf_stop_tx(device);
if( result != HACKRF_SUCCESS ) { if( result != HACKRF_SUCCESS ) {
printf("hackrf_stop_tx() failed: %s (%d)\n", hackrf_error_name(result), result); fprintf(stderr, "hackrf_stop_tx() failed: %s (%d)\n", hackrf_error_name(result), result);
}else { }else {
printf("hackrf_stop_tx() done\n"); fprintf(stderr, "hackrf_stop_tx() done\n");
} }
} }
result = hackrf_close(device); result = hackrf_close(device);
if( result != HACKRF_SUCCESS ) if( result != HACKRF_SUCCESS )
{ {
printf("hackrf_close() failed: %s (%d)\n", hackrf_error_name(result), result); fprintf(stderr, "hackrf_close() failed: %s (%d)\n", hackrf_error_name(result), result);
}else { }else {
printf("hackrf_close() done\n"); fprintf(stderr, "hackrf_close() done\n");
} }
hackrf_exit(); hackrf_exit();
printf("hackrf_exit() done\n"); fprintf(stderr, "hackrf_exit() done\n");
} }
if(fd != NULL) if(fd != NULL)
@ -1042,8 +1050,8 @@ int main(int argc, char** argv) {
} }
fclose(fd); fclose(fd);
fd = NULL; fd = NULL;
printf("fclose(fd) done\n"); fprintf(stderr, "fclose(fd) done\n");
} }
printf("exit\n"); fprintf(stderr, "exit\n");
return exit_code; return exit_code;
} }