From 4f9665fb3b43462e39a1592fc34f3dfb50de4a07 Mon Sep 17 00:00:00 2001 From: Vinayak Kariappa Chettimada Date: Sun, 3 Apr 2016 07:36:48 +0200 Subject: [PATCH 01/48] Fixed missing reset of do_exit, which prevented calls to callback when thread is created once again. --- host/libhackrf/src/hackrf.c | 1 + 1 file changed, 1 insertion(+) diff --git a/host/libhackrf/src/hackrf.c b/host/libhackrf/src/hackrf.c index 2f309c38..b9707319 100644 --- a/host/libhackrf/src/hackrf.c +++ b/host/libhackrf/src/hackrf.c @@ -1415,6 +1415,7 @@ static int create_transfer_thread(hackrf_device* device, if( device->transfer_thread_started == false ) { device->streaming = false; + do_exit = false; result = prepare_transfers( device, endpoint_address, From 303334870f91af7eff46e551dbbaf6db7f9e1984 Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Fri, 1 Jul 2016 20:07:29 +0100 Subject: [PATCH 02/48] Don't bother setting path 1 when tuning RFFC5072 Mixer path 1 only exists in the RFFC5071 --- firmware/common/rffc5071.c | 7 ------- 1 file changed, 7 deletions(-) diff --git a/firmware/common/rffc5071.c b/firmware/common/rffc5071.c index 71ba9f5c..653a28a8 100644 --- a/firmware/common/rffc5071.c +++ b/firmware/common/rffc5071.c @@ -254,13 +254,6 @@ uint64_t rffc5071_config_synth_int(rffc5071_driver_t* const drv, uint16_t lo) { tune_freq_hz = (REF_FREQ * (tmp_n >> 5ULL) * fbkdiv * FREQ_ONE_MHZ) / (lodiv * (1 << 24ULL)); - /* Path 1 */ - set_RFFC5071_P1LODIV(drv, n_lo); - set_RFFC5071_P1N(drv, n); - set_RFFC5071_P1PRESC(drv, fbkdiv >> 1); - set_RFFC5071_P1NMSB(drv, p1nmsb); - set_RFFC5071_P1NLSB(drv, p1nlsb); - /* Path 2 */ set_RFFC5071_P2LODIV(drv, n_lo); set_RFFC5071_P2N(drv, n); From f7bdbb07d89b817b27d7a6a595952e1b85a2c3da Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Sat, 9 Jul 2016 00:02:45 +0100 Subject: [PATCH 03/48] Speed up RFFC5072 comms by 50%! --- firmware/common/rffc5071_spi.c | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/firmware/common/rffc5071_spi.c b/firmware/common/rffc5071_spi.c index 7c3d9da2..5699f93c 100644 --- a/firmware/common/rffc5071_spi.c +++ b/firmware/common/rffc5071_spi.c @@ -94,10 +94,7 @@ void rffc5071_spi_stop(spi_bus_t* const bus) { static void rffc5071_spi_serial_delay(spi_bus_t* const bus) { (void)bus; - volatile uint32_t i; - - for (i = 0; i < 2; i++) - __asm__("nop"); + __asm__("nop"); } static void rffc5071_spi_sck(spi_bus_t* const bus) { From 31a37bd841b99154fce7217d2b3d78a24f8aacd9 Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Sat, 9 Jul 2016 00:03:35 +0100 Subject: [PATCH 04/48] Output RFFC5072 LOCK status --- firmware/common/rffc5071.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/firmware/common/rffc5071.c b/firmware/common/rffc5071.c index 653a28a8..10542b6c 100644 --- a/firmware/common/rffc5071.c +++ b/firmware/common/rffc5071.c @@ -117,6 +117,10 @@ void rffc5071_setup(rffc5071_driver_t* const drv) /* GPOs are active at all times */ set_RFFC5071_GATE(drv, 1); + /* Output LOCK status on GPO4 and enable lock detect */ + set_RFFC5071_LOCK(drv, 1); + set_RFFC5071_LDEN(drv, 1); + rffc5071_regs_commit(drv); } From 9f2d6cdbeada0bc4d543aadf8b6ba6d6b2ba4b2b Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Fri, 1 Jul 2016 20:09:15 +0100 Subject: [PATCH 05/48] WIP scanning --- firmware/hackrf_usb/hackrf_usb.c | 50 +++++++++++++++++++++++--------- 1 file changed, 36 insertions(+), 14 deletions(-) diff --git a/firmware/hackrf_usb/hackrf_usb.c b/firmware/hackrf_usb/hackrf_usb.c index 2c5ec3d0..394875c4 100644 --- a/firmware/hackrf_usb/hackrf_usb.c +++ b/firmware/hackrf_usb/hackrf_usb.c @@ -28,6 +28,8 @@ #include +#include "tuning.h" + #include "usb.h" #include "usb_standard_request.h" @@ -239,6 +241,13 @@ int main(void) { rf_path_init(&rf_path); unsigned int phase = 0; + + unsigned int blocks_queued = 0; + const uint64_t scan_freq_min = 100000000; + const uint64_t scan_freq_max = 6000000000; + const uint64_t scan_freq_step = 20000000; + uint64_t scan_freq = scan_freq_min; + set_freq(scan_freq); while(true) { // Check whether we need to initiate a CPLD update if (start_cpld_update) @@ -248,28 +257,41 @@ int main(void) { if ( usb_bulk_buffer_offset >= 16384 && phase == 1 && transceiver_mode() != TRANSCEIVER_MODE_OFF) { - usb_transfer_schedule_block( - (transceiver_mode() == TRANSCEIVER_MODE_RX) - ? &usb_endpoint_bulk_in : &usb_endpoint_bulk_out, - &usb_bulk_buffer[0x0000], - 0x4000, - NULL, NULL - ); + if (blocks_queued == 2) + usb_transfer_schedule_block( + (transceiver_mode() == TRANSCEIVER_MODE_RX) + ? &usb_endpoint_bulk_in : &usb_endpoint_bulk_out, + &usb_bulk_buffer[0x0000], + 0x4000, + NULL, NULL + ); phase = 0; + blocks_queued++; } // Set up IN transfer of buffer 1. if ( usb_bulk_buffer_offset < 16384 && phase == 0 && transceiver_mode() != TRANSCEIVER_MODE_OFF) { - usb_transfer_schedule_block( - (transceiver_mode() == TRANSCEIVER_MODE_RX) - ? &usb_endpoint_bulk_in : &usb_endpoint_bulk_out, - &usb_bulk_buffer[0x4000], - 0x4000, - NULL, NULL - ); + if (blocks_queued == 2) + usb_transfer_schedule_block( + (transceiver_mode() == TRANSCEIVER_MODE_RX) + ? &usb_endpoint_bulk_in : &usb_endpoint_bulk_out, + &usb_bulk_buffer[0x4000], + 0x4000, + NULL, NULL + ); phase = 1; + blocks_queued++; + } + + if (blocks_queued > 2) { + scan_freq += scan_freq_step; + if (scan_freq > scan_freq_max) { + scan_freq = scan_freq_min; + } + set_freq(scan_freq); + blocks_queued = 0; } } From 2e17b7e88494f0e5bdd2244115b37a36938b2bc5 Mon Sep 17 00:00:00 2001 From: Dominic Spill Date: Thu, 21 Jul 2016 18:53:49 +0100 Subject: [PATCH 06/48] Use vendor request to start scan mode --- firmware/hackrf_usb/CMakeLists.txt | 1 + firmware/hackrf_usb/hackrf_usb.c | 15 +++------ firmware/hackrf_usb/usb_api_scan.c | 53 ++++++++++++++++++++++++++++++ firmware/hackrf_usb/usb_api_scan.h | 36 ++++++++++++++++++++ 4 files changed, 94 insertions(+), 11 deletions(-) create mode 100644 firmware/hackrf_usb/usb_api_scan.c create mode 100644 firmware/hackrf_usb/usb_api_scan.h diff --git a/firmware/hackrf_usb/CMakeLists.txt b/firmware/hackrf_usb/CMakeLists.txt index 10ee4ffb..8db83f7f 100644 --- a/firmware/hackrf_usb/CMakeLists.txt +++ b/firmware/hackrf_usb/CMakeLists.txt @@ -42,6 +42,7 @@ set(SRC_M4 usb_api_register.c usb_api_spiflash.c usb_api_transceiver.c + usb_api_scan.c "${PATH_HACKRF_FIRMWARE_COMMON}/usb_queue.c" "${PATH_HACKRF_FIRMWARE_COMMON}/fault_handler.c" "${PATH_HACKRF_FIRMWARE_COMMON}/cpld_jtag.c" diff --git a/firmware/hackrf_usb/hackrf_usb.c b/firmware/hackrf_usb/hackrf_usb.c index 394875c4..c5dea94c 100644 --- a/firmware/hackrf_usb/hackrf_usb.c +++ b/firmware/hackrf_usb/hackrf_usb.c @@ -42,6 +42,7 @@ #include "usb_api_cpld.h" #include "usb_api_register.h" #include "usb_api_spiflash.h" +#include "usb_api_scan.h" #include "usb_api_transceiver.h" #include "sgpio_isr.h" @@ -142,6 +143,7 @@ static const usb_request_handler_fn vendor_request_handler[] = { #endif usb_vendor_request_set_freq_explicit, usb_vendor_request_read_wcid, // USB_WCID_VENDOR_REQ + usb_vendor_request_init_scan, }; static const uint32_t vendor_request_handler_count = @@ -241,13 +243,8 @@ int main(void) { rf_path_init(&rf_path); unsigned int phase = 0; - unsigned int blocks_queued = 0; - const uint64_t scan_freq_min = 100000000; - const uint64_t scan_freq_max = 6000000000; - const uint64_t scan_freq_step = 20000000; - uint64_t scan_freq = scan_freq_min; - set_freq(scan_freq); + while(true) { // Check whether we need to initiate a CPLD update if (start_cpld_update) @@ -286,11 +283,7 @@ int main(void) { } if (blocks_queued > 2) { - scan_freq += scan_freq_step; - if (scan_freq > scan_freq_max) { - scan_freq = scan_freq_min; - } - set_freq(scan_freq); + scan_callback(); blocks_queued = 0; } } diff --git a/firmware/hackrf_usb/usb_api_scan.c b/firmware/hackrf_usb/usb_api_scan.c new file mode 100644 index 00000000..376a17f7 --- /dev/null +++ b/firmware/hackrf_usb/usb_api_scan.c @@ -0,0 +1,53 @@ +/* + * Copyright 2016 Mike Walters, Dominic Spill + * + * This file is part of HackRF. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, + * Boston, MA 02110-1301, USA. + */ + +#include "usb_api_scan.h" +#include "usb_queue.h" +#include +//#include +#include "tuning.h" + +volatile bool scan_mode = false; +static uint64_t scan_freq; +static uint64_t scan_freq_min; +static uint64_t scan_freq_max; +static uint64_t scan_freq_step; + +usb_request_status_t usb_vendor_request_init_scan( + usb_endpoint_t* const endpoint, const usb_transfer_stage_t stage) +{ + if (stage == USB_TRANSFER_STAGE_SETUP) { + // DGS set scan frequencies here + scan_freq = scan_freq_min; + set_freq(scan_freq); + scan_mode = true; + usb_transfer_schedule_ack(endpoint->in); + } + return USB_REQUEST_STATUS_OK; +} + +void scan_callback(void) { + scan_freq += scan_freq_step; + if (scan_freq > scan_freq_max) { + scan_freq = scan_freq_min; + } + set_freq(scan_freq); +} diff --git a/firmware/hackrf_usb/usb_api_scan.h b/firmware/hackrf_usb/usb_api_scan.h new file mode 100644 index 00000000..3aca5372 --- /dev/null +++ b/firmware/hackrf_usb/usb_api_scan.h @@ -0,0 +1,36 @@ +/* + * Copyright 2016 Mike Walters, Dominic Spill + * + * This file is part of HackRF. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, + * Boston, MA 02110-1301, USA. + */ + +#ifndef __USB_API_SCAN_H__ +#define __USB_API_SCAN_H__ + +#include +#include +#include + +extern volatile bool scan_mode; + +usb_request_status_t usb_vendor_request_init_scan( + usb_endpoint_t* const endpoint, const usb_transfer_stage_t stage); + +void scan_callback(void); + +#endif /* __USB_API_SPCAN_H__ */ From 1b8e1d18c55214acfcb8af18508b5e5795f1709b Mon Sep 17 00:00:00 2001 From: Dominic Spill Date: Sun, 24 Jul 2016 14:32:55 +0100 Subject: [PATCH 07/48] Add scan mode function separate to main loop --- firmware/hackrf_usb/hackrf_usb.c | 113 ++++------------------ firmware/hackrf_usb/usb_api_scan.c | 81 ++++++++++++++-- firmware/hackrf_usb/usb_api_scan.h | 4 +- firmware/hackrf_usb/usb_api_transceiver.c | 72 ++++++++++++++ firmware/hackrf_usb/usb_api_transceiver.h | 5 + 5 files changed, 171 insertions(+), 104 deletions(-) diff --git a/firmware/hackrf_usb/hackrf_usb.c b/firmware/hackrf_usb/hackrf_usb.c index c5dea94c..25dff4ee 100644 --- a/firmware/hackrf_usb/hackrf_usb.c +++ b/firmware/hackrf_usb/hackrf_usb.c @@ -22,8 +22,6 @@ #include -#include - #include #include @@ -45,73 +43,8 @@ #include "usb_api_scan.h" #include "usb_api_transceiver.h" -#include "sgpio_isr.h" #include "usb_bulk_buffer.h" -static volatile transceiver_mode_t _transceiver_mode = TRANSCEIVER_MODE_OFF; - -void set_transceiver_mode(const transceiver_mode_t new_transceiver_mode) { - baseband_streaming_disable(&sgpio_config); - - usb_endpoint_disable(&usb_endpoint_bulk_in); - usb_endpoint_disable(&usb_endpoint_bulk_out); - - _transceiver_mode = new_transceiver_mode; - - if( _transceiver_mode == TRANSCEIVER_MODE_RX ) { - led_off(LED3); - led_on(LED2); - usb_endpoint_init(&usb_endpoint_bulk_in); - rf_path_set_direction(&rf_path, RF_PATH_DIRECTION_RX); - vector_table.irq[NVIC_SGPIO_IRQ] = sgpio_isr_rx; - } else if (_transceiver_mode == TRANSCEIVER_MODE_TX) { - led_off(LED2); - led_on(LED3); - usb_endpoint_init(&usb_endpoint_bulk_out); - rf_path_set_direction(&rf_path, RF_PATH_DIRECTION_TX); - vector_table.irq[NVIC_SGPIO_IRQ] = sgpio_isr_tx; - } else { - led_off(LED2); - led_off(LED3); - rf_path_set_direction(&rf_path, RF_PATH_DIRECTION_OFF); - vector_table.irq[NVIC_SGPIO_IRQ] = sgpio_isr_rx; - } - - if( _transceiver_mode != TRANSCEIVER_MODE_OFF ) { - si5351c_activate_best_clock_source(&clock_gen); - baseband_streaming_enable(&sgpio_config); - } -} - -transceiver_mode_t transceiver_mode(void) { - return _transceiver_mode; -} - -usb_request_status_t usb_vendor_request_set_transceiver_mode( - usb_endpoint_t* const endpoint, - const usb_transfer_stage_t stage -) { - if( stage == USB_TRANSFER_STAGE_SETUP ) { - switch( endpoint->setup.value ) { - case TRANSCEIVER_MODE_OFF: - case TRANSCEIVER_MODE_RX: - case TRANSCEIVER_MODE_TX: - set_transceiver_mode(endpoint->setup.value); - usb_transfer_schedule_ack(endpoint->in); - return USB_REQUEST_STATUS_OK; - case TRANSCEIVER_MODE_CPLD_UPDATE: - usb_endpoint_init(&usb_endpoint_bulk_out); - start_cpld_update = true; - usb_transfer_schedule_ack(endpoint->in); - return USB_REQUEST_STATUS_OK; - default: - return USB_REQUEST_STATUS_STALL; - } - } else { - return USB_REQUEST_STATUS_OK; - } -} - static const usb_request_handler_fn vendor_request_handler[] = { NULL, usb_vendor_request_set_transceiver_mode, @@ -243,50 +176,44 @@ int main(void) { rf_path_init(&rf_path); unsigned int phase = 0; - unsigned int blocks_queued = 0; while(true) { // Check whether we need to initiate a CPLD update if (start_cpld_update) cpld_update(); + // Check whether we need to initiate scan mode + if (start_scan_mode) + scan_mode(); + // Set up IN transfer of buffer 0. if ( usb_bulk_buffer_offset >= 16384 && phase == 1 && transceiver_mode() != TRANSCEIVER_MODE_OFF) { - if (blocks_queued == 2) - usb_transfer_schedule_block( - (transceiver_mode() == TRANSCEIVER_MODE_RX) - ? &usb_endpoint_bulk_in : &usb_endpoint_bulk_out, - &usb_bulk_buffer[0x0000], - 0x4000, - NULL, NULL - ); + usb_transfer_schedule_block( + (transceiver_mode() == TRANSCEIVER_MODE_RX) + ? &usb_endpoint_bulk_in : &usb_endpoint_bulk_out, + &usb_bulk_buffer[0x0000], + 0x4000, + NULL, NULL + ); phase = 0; - blocks_queued++; } - + // Set up IN transfer of buffer 1. if ( usb_bulk_buffer_offset < 16384 && phase == 0 && transceiver_mode() != TRANSCEIVER_MODE_OFF) { - if (blocks_queued == 2) - usb_transfer_schedule_block( - (transceiver_mode() == TRANSCEIVER_MODE_RX) - ? &usb_endpoint_bulk_in : &usb_endpoint_bulk_out, - &usb_bulk_buffer[0x4000], - 0x4000, - NULL, NULL - ); + usb_transfer_schedule_block( + (transceiver_mode() == TRANSCEIVER_MODE_RX) + ? &usb_endpoint_bulk_in : &usb_endpoint_bulk_out, + &usb_bulk_buffer[0x4000], + 0x4000, + NULL, NULL + ); phase = 1; - blocks_queued++; - } - - if (blocks_queued > 2) { - scan_callback(); - blocks_queued = 0; } } - + return 0; } diff --git a/firmware/hackrf_usb/usb_api_scan.c b/firmware/hackrf_usb/usb_api_scan.c index 376a17f7..14298996 100644 --- a/firmware/hackrf_usb/usb_api_scan.c +++ b/firmware/hackrf_usb/usb_api_scan.c @@ -22,32 +22,95 @@ #include "usb_api_scan.h" #include "usb_queue.h" #include -//#include +#include +#include "usb_api_transceiver.h" +#include "usb_bulk_buffer.h" #include "tuning.h" +#include "usb_endpoint.h" -volatile bool scan_mode = false; +#define MIN(x,y) ((x)<(y)?(x):(y)) +#define MAX(x,y) ((x)>(y)?(x):(y)) +#define MIN_FREQ 1000000 +#define MAX_FREQ 6000000000 + +volatile bool start_scan_mode = false; static uint64_t scan_freq; static uint64_t scan_freq_min; static uint64_t scan_freq_max; static uint64_t scan_freq_step; +static inline uint64_t bytes_to_uint64(uint8_t* buf) { + uint64_t tmp = buf[0] << 24 | buf[1] << 16 | buf[2] << 8 | buf[3]; + tmp <<= 32; + tmp |= buf[4] << 24 | buf[5] << 16 | buf[6] << 8 | buf[7]; + return tmp; +} + usb_request_status_t usb_vendor_request_init_scan( usb_endpoint_t* const endpoint, const usb_transfer_stage_t stage) { - if (stage == USB_TRANSFER_STAGE_SETUP) { + uint64_t freqs[3]; + if ((stage == USB_TRANSFER_STAGE_SETUP) && + (endpoint->setup.length == 24)) { // DGS set scan frequencies here + //freq_min = bytes_to_uint64(); + usb_transfer_schedule_block(endpoint->out, &freqs, 3*sizeof(uint64_t), + NULL, NULL); + + scan_freq_min = MAX(MIN_FREQ, freqs[0]); + scan_freq_max = MIN(MAX_FREQ, freqs[1]); + scan_freq_step = freqs[2]; + scan_freq = scan_freq_min; set_freq(scan_freq); - scan_mode = true; + start_scan_mode = true; usb_transfer_schedule_ack(endpoint->in); } return USB_REQUEST_STATUS_OK; } -void scan_callback(void) { - scan_freq += scan_freq_step; - if (scan_freq > scan_freq_max) { - scan_freq = scan_freq_min; +void scan_mode(void) { + unsigned int blocks_queued = 0; + unsigned int phase = 0; + + while(transceiver_mode() != TRANSCEIVER_MODE_OFF) { + // Set up IN transfer of buffer 0. + if ( usb_bulk_buffer_offset >= 16384 + && phase == 1 + && transceiver_mode() != TRANSCEIVER_MODE_OFF) { + usb_transfer_schedule_block( + (transceiver_mode() == TRANSCEIVER_MODE_RX) + ? &usb_endpoint_bulk_in : &usb_endpoint_bulk_out, + &usb_bulk_buffer[0x0000], + 0x4000, + NULL, NULL + ); + phase = 0; + blocks_queued++; } - set_freq(scan_freq); + + // Set up IN transfer of buffer 1. + if ( usb_bulk_buffer_offset < 16384 + && phase == 0 + && transceiver_mode() != TRANSCEIVER_MODE_OFF) { + usb_transfer_schedule_block( + (transceiver_mode() == TRANSCEIVER_MODE_RX) + ? &usb_endpoint_bulk_in : &usb_endpoint_bulk_out, + &usb_bulk_buffer[0x4000], + 0x4000, + NULL, NULL + ); + phase = 1; + blocks_queued++; + } + + if (blocks_queued > 2) { + scan_freq += scan_freq_step; + if (scan_freq > scan_freq_max) { + scan_freq = scan_freq_min; + } + set_freq(scan_freq); + blocks_queued = 0; + } + } } diff --git a/firmware/hackrf_usb/usb_api_scan.h b/firmware/hackrf_usb/usb_api_scan.h index 3aca5372..be066612 100644 --- a/firmware/hackrf_usb/usb_api_scan.h +++ b/firmware/hackrf_usb/usb_api_scan.h @@ -26,11 +26,11 @@ #include #include -extern volatile bool scan_mode; +extern volatile bool start_scan_mode; usb_request_status_t usb_vendor_request_init_scan( usb_endpoint_t* const endpoint, const usb_transfer_stage_t stage); -void scan_callback(void); +void scan_mode(void); #endif /* __USB_API_SPCAN_H__ */ diff --git a/firmware/hackrf_usb/usb_api_transceiver.c b/firmware/hackrf_usb/usb_api_transceiver.c index e8bac410..d86de7db 100644 --- a/firmware/hackrf_usb/usb_api_transceiver.c +++ b/firmware/hackrf_usb/usb_api_transceiver.c @@ -22,9 +22,16 @@ #include "usb_api_transceiver.h" +#include +#include +#include "sgpio_isr.h" + +#include "usb_api_cpld.h" // Remove when CPLD update is handled elsewhere + #include #include #include +#include #include #include @@ -221,3 +228,68 @@ usb_request_status_t usb_vendor_request_set_freq_explicit( return USB_REQUEST_STATUS_OK; } } + +static volatile transceiver_mode_t _transceiver_mode = TRANSCEIVER_MODE_OFF; + + +transceiver_mode_t transceiver_mode(void) { + return _transceiver_mode; +} + +void set_transceiver_mode(const transceiver_mode_t new_transceiver_mode) { + baseband_streaming_disable(&sgpio_config); + + usb_endpoint_disable(&usb_endpoint_bulk_in); + usb_endpoint_disable(&usb_endpoint_bulk_out); + + _transceiver_mode = new_transceiver_mode; + + if( _transceiver_mode == TRANSCEIVER_MODE_RX ) { + led_off(LED3); + led_on(LED2); + usb_endpoint_init(&usb_endpoint_bulk_in); + rf_path_set_direction(&rf_path, RF_PATH_DIRECTION_RX); + vector_table.irq[NVIC_SGPIO_IRQ] = sgpio_isr_rx; + } else if (_transceiver_mode == TRANSCEIVER_MODE_TX) { + led_off(LED2); + led_on(LED3); + usb_endpoint_init(&usb_endpoint_bulk_out); + rf_path_set_direction(&rf_path, RF_PATH_DIRECTION_TX); + vector_table.irq[NVIC_SGPIO_IRQ] = sgpio_isr_tx; + } else { + led_off(LED2); + led_off(LED3); + rf_path_set_direction(&rf_path, RF_PATH_DIRECTION_OFF); + vector_table.irq[NVIC_SGPIO_IRQ] = sgpio_isr_rx; + } + + if( _transceiver_mode != TRANSCEIVER_MODE_OFF ) { + si5351c_activate_best_clock_source(&clock_gen); + baseband_streaming_enable(&sgpio_config); + } +} + +usb_request_status_t usb_vendor_request_set_transceiver_mode( + usb_endpoint_t* const endpoint, + const usb_transfer_stage_t stage +) { + if( stage == USB_TRANSFER_STAGE_SETUP ) { + switch( endpoint->setup.value ) { + case TRANSCEIVER_MODE_OFF: + case TRANSCEIVER_MODE_RX: + case TRANSCEIVER_MODE_TX: + set_transceiver_mode(endpoint->setup.value); + usb_transfer_schedule_ack(endpoint->in); + return USB_REQUEST_STATUS_OK; + case TRANSCEIVER_MODE_CPLD_UPDATE: + usb_endpoint_init(&usb_endpoint_bulk_out); + start_cpld_update = true; + usb_transfer_schedule_ack(endpoint->in); + return USB_REQUEST_STATUS_OK; + default: + return USB_REQUEST_STATUS_STALL; + } + } else { + return USB_REQUEST_STATUS_OK; + } +} \ No newline at end of file diff --git a/firmware/hackrf_usb/usb_api_transceiver.h b/firmware/hackrf_usb/usb_api_transceiver.h index 24244025..59f85778 100644 --- a/firmware/hackrf_usb/usb_api_transceiver.h +++ b/firmware/hackrf_usb/usb_api_transceiver.h @@ -53,4 +53,9 @@ usb_request_status_t usb_vendor_request_set_antenna_enable( usb_request_status_t usb_vendor_request_set_freq_explicit( usb_endpoint_t* const endpoint, const usb_transfer_stage_t stage); +transceiver_mode_t transceiver_mode(void); +void set_transceiver_mode(const transceiver_mode_t new_transceiver_mode); +usb_request_status_t usb_vendor_request_set_transceiver_mode( + usb_endpoint_t* const endpoint, const usb_transfer_stage_t stage); + #endif/*__USB_API_TRANSCEIVER_H__*/ From 97c317e9a47865f9c276be8135f9cffba80f5d5a Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Sun, 24 Jul 2016 17:48:06 +0100 Subject: [PATCH 08/48] Add init_scan call to libhackrf --- firmware/hackrf_usb/usb_api_scan.c | 21 ++++++++-------- host/libhackrf/src/hackrf.c | 40 ++++++++++++++++++++++++++++++ host/libhackrf/src/hackrf.h | 4 +++ 3 files changed, 54 insertions(+), 11 deletions(-) diff --git a/firmware/hackrf_usb/usb_api_scan.c b/firmware/hackrf_usb/usb_api_scan.c index 14298996..9b160dec 100644 --- a/firmware/hackrf_usb/usb_api_scan.c +++ b/firmware/hackrf_usb/usb_api_scan.c @@ -39,27 +39,26 @@ static uint64_t scan_freq_min; static uint64_t scan_freq_max; static uint64_t scan_freq_step; -static inline uint64_t bytes_to_uint64(uint8_t* buf) { - uint64_t tmp = buf[0] << 24 | buf[1] << 16 | buf[2] << 8 | buf[3]; - tmp <<= 32; - tmp |= buf[4] << 24 | buf[5] << 16 | buf[6] << 8 | buf[7]; - return tmp; -} +struct init_scan_params { + uint64_t min_freq_hz; + uint64_t max_freq_hz; + uint64_t step_freq_hz; +}; +struct init_scan_params scan_params; usb_request_status_t usb_vendor_request_init_scan( usb_endpoint_t* const endpoint, const usb_transfer_stage_t stage) { - uint64_t freqs[3]; if ((stage == USB_TRANSFER_STAGE_SETUP) && (endpoint->setup.length == 24)) { // DGS set scan frequencies here //freq_min = bytes_to_uint64(); - usb_transfer_schedule_block(endpoint->out, &freqs, 3*sizeof(uint64_t), + usb_transfer_schedule_block(endpoint->out, &scan_params, sizeof(struct init_scan_params), NULL, NULL); - scan_freq_min = MAX(MIN_FREQ, freqs[0]); - scan_freq_max = MIN(MAX_FREQ, freqs[1]); - scan_freq_step = freqs[2]; + scan_freq_min = MAX(MIN_FREQ, scan_params.min_freq_hz); + scan_freq_max = MIN(MAX_FREQ, scan_params.max_freq_hz); + scan_freq_step = scan_params.step_freq_hz; scan_freq = scan_freq_min; set_freq(scan_freq); diff --git a/host/libhackrf/src/hackrf.c b/host/libhackrf/src/hackrf.c index a759fb3a..81f91ec7 100644 --- a/host/libhackrf/src/hackrf.c +++ b/host/libhackrf/src/hackrf.c @@ -67,6 +67,8 @@ typedef enum { HACKRF_VENDOR_REQUEST_SET_TXVGA_GAIN = 21, HACKRF_VENDOR_REQUEST_ANTENNA_ENABLE = 23, HACKRF_VENDOR_REQUEST_SET_FREQ_EXPLICIT = 24, + // USB_WCID_VENDOR_REQ = 25 + HACKRF_VENDOR_REQUEST_INIT_SCAN = 26, } hackrf_vendor_request; typedef enum { @@ -1695,6 +1697,44 @@ uint32_t ADDCALL hackrf_compute_baseband_filter_bw(const uint32_t bandwidth_hz) return p->bandwidth_hz; } +struct init_scan_params { + uint64_t min_freq_hz; + uint64_t max_freq_hz; + uint64_t step_freq_hz; +}; + +int ADDCALL hackrf_init_scan(hackrf_device* device, + const uint64_t min_freq_hz, const uint64_t max_freq_hz, + const uint64_t step_freq_hz) +{ + struct init_scan_params params; + uint8_t length; + int result; + + params.min_freq_hz = TO_LE(min_freq_hz); + params.max_freq_hz = TO_LE(max_freq_hz); + params.step_freq_hz = TO_LE(step_freq_hz); + length = sizeof(struct init_scan_params); + + result = libusb_control_transfer( + device->usb_device, + LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, + HACKRF_VENDOR_REQUEST_INIT_SCAN, + 0, + 0, + (unsigned char*)¶ms, + length, + 0 + ); + + if (result < length) + { + return HACKRF_ERROR_LIBUSB; + } else { + return HACKRF_SUCCESS; + } +} + #ifdef __cplusplus } // __cplusplus defined. #endif diff --git a/host/libhackrf/src/hackrf.h b/host/libhackrf/src/hackrf.h index 7ac0530f..48c192c7 100644 --- a/host/libhackrf/src/hackrf.h +++ b/host/libhackrf/src/hackrf.h @@ -196,6 +196,10 @@ extern ADDAPI const char* ADDCALL hackrf_filter_path_name(const enum rf_path_fil extern ADDAPI uint32_t ADDCALL hackrf_compute_baseband_filter_bw_round_down_lt(const uint32_t bandwidth_hz); /* Compute best default value depending on sample rate (auto filter) */ extern ADDAPI uint32_t ADDCALL hackrf_compute_baseband_filter_bw(const uint32_t bandwidth_hz); +/* Start scan mode */ +extern ADDAPI int ADDCALL hackrf_init_scan(hackrf_device* device, + const uint64_t min_freq_hz, const uint64_t max_freq_hz, + const uint64_t step_freq_hz); #ifdef __cplusplus } // __cplusplus defined. From d19b4efa2e96ee793da7109a804e619254ea4649 Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Mon, 25 Jul 2016 22:57:13 +0100 Subject: [PATCH 09/48] Only transfer one block per re-tune --- firmware/hackrf_usb/usb_api_scan.c | 30 ++++++++++++++++-------------- 1 file changed, 16 insertions(+), 14 deletions(-) diff --git a/firmware/hackrf_usb/usb_api_scan.c b/firmware/hackrf_usb/usb_api_scan.c index 9b160dec..60e4b7c6 100644 --- a/firmware/hackrf_usb/usb_api_scan.c +++ b/firmware/hackrf_usb/usb_api_scan.c @@ -77,13 +77,14 @@ void scan_mode(void) { if ( usb_bulk_buffer_offset >= 16384 && phase == 1 && transceiver_mode() != TRANSCEIVER_MODE_OFF) { - usb_transfer_schedule_block( - (transceiver_mode() == TRANSCEIVER_MODE_RX) - ? &usb_endpoint_bulk_in : &usb_endpoint_bulk_out, - &usb_bulk_buffer[0x0000], - 0x4000, - NULL, NULL - ); + if (blocks_queued == 2) + usb_transfer_schedule_block( + (transceiver_mode() == TRANSCEIVER_MODE_RX) + ? &usb_endpoint_bulk_in : &usb_endpoint_bulk_out, + &usb_bulk_buffer[0x0000], + 0x4000, + NULL, NULL + ); phase = 0; blocks_queued++; } @@ -92,13 +93,14 @@ void scan_mode(void) { if ( usb_bulk_buffer_offset < 16384 && phase == 0 && transceiver_mode() != TRANSCEIVER_MODE_OFF) { - usb_transfer_schedule_block( - (transceiver_mode() == TRANSCEIVER_MODE_RX) - ? &usb_endpoint_bulk_in : &usb_endpoint_bulk_out, - &usb_bulk_buffer[0x4000], - 0x4000, - NULL, NULL - ); + if (blocks_queued == 2) + usb_transfer_schedule_block( + (transceiver_mode() == TRANSCEIVER_MODE_RX) + ? &usb_endpoint_bulk_in : &usb_endpoint_bulk_out, + &usb_bulk_buffer[0x4000], + 0x4000, + NULL, NULL + ); phase = 1; blocks_queued++; } From 8c96d9cf326c9477795150053742faa3298f5ee5 Mon Sep 17 00:00:00 2001 From: Dominic Spill Date: Tue, 26 Jul 2016 15:29:13 +0100 Subject: [PATCH 10/48] Change granularity of scan mode to MHz --- firmware/hackrf_usb/usb_api_scan.c | 42 ++++++++++++++---------------- host/libhackrf/src/hackrf.c | 16 ++++++------ host/libhackrf/src/hackrf.h | 4 +-- 3 files changed, 30 insertions(+), 32 deletions(-) diff --git a/firmware/hackrf_usb/usb_api_scan.c b/firmware/hackrf_usb/usb_api_scan.c index 60e4b7c6..d5377198 100644 --- a/firmware/hackrf_usb/usb_api_scan.c +++ b/firmware/hackrf_usb/usb_api_scan.c @@ -30,19 +30,17 @@ #define MIN(x,y) ((x)<(y)?(x):(y)) #define MAX(x,y) ((x)>(y)?(x):(y)) -#define MIN_FREQ 1000000 -#define MAX_FREQ 6000000000 +#define FREQ_GRANULARITY 1000000 +#define MIN_FREQ 1 +#define MAX_FREQ 6000 volatile bool start_scan_mode = false; static uint64_t scan_freq; -static uint64_t scan_freq_min; -static uint64_t scan_freq_max; -static uint64_t scan_freq_step; struct init_scan_params { - uint64_t min_freq_hz; - uint64_t max_freq_hz; - uint64_t step_freq_hz; + uint16_t min_freq_mhz; + uint16_t max_freq_mhz; + uint16_t step_freq_mhz; }; struct init_scan_params scan_params; @@ -51,17 +49,17 @@ usb_request_status_t usb_vendor_request_init_scan( { if ((stage == USB_TRANSFER_STAGE_SETUP) && (endpoint->setup.length == 24)) { - // DGS set scan frequencies here - //freq_min = bytes_to_uint64(); - usb_transfer_schedule_block(endpoint->out, &scan_params, sizeof(struct init_scan_params), + + usb_transfer_schedule_block(endpoint->out, &scan_params, + sizeof(struct init_scan_params), NULL, NULL); - - scan_freq_min = MAX(MIN_FREQ, scan_params.min_freq_hz); - scan_freq_max = MIN(MAX_FREQ, scan_params.max_freq_hz); - scan_freq_step = scan_params.step_freq_hz; - - scan_freq = scan_freq_min; - set_freq(scan_freq); + + /* Limit to min/max frequency without warning (possible FIXME) */ + scan_params.min_freq_mhz = MAX(MIN_FREQ, scan_params.min_freq_mhz); + scan_params.max_freq_mhz = MIN(MAX_FREQ, scan_params.max_freq_mhz); + + scan_freq = scan_params.min_freq_mhz; + set_freq(scan_freq*FREQ_GRANULARITY); start_scan_mode = true; usb_transfer_schedule_ack(endpoint->in); } @@ -106,11 +104,11 @@ void scan_mode(void) { } if (blocks_queued > 2) { - scan_freq += scan_freq_step; - if (scan_freq > scan_freq_max) { - scan_freq = scan_freq_min; + scan_freq += scan_params.step_freq_mhz; + if (scan_freq > scan_params.max_freq_mhz) { + scan_freq = scan_params.min_freq_mhz; } - set_freq(scan_freq); + set_freq(scan_freq*FREQ_GRANULARITY); blocks_queued = 0; } } diff --git a/host/libhackrf/src/hackrf.c b/host/libhackrf/src/hackrf.c index 81f91ec7..b16763bc 100644 --- a/host/libhackrf/src/hackrf.c +++ b/host/libhackrf/src/hackrf.c @@ -1698,22 +1698,22 @@ uint32_t ADDCALL hackrf_compute_baseband_filter_bw(const uint32_t bandwidth_hz) } struct init_scan_params { - uint64_t min_freq_hz; - uint64_t max_freq_hz; - uint64_t step_freq_hz; + uint16_t min_freq_mhz; + uint16_t max_freq_mhz; + uint16_t step_freq_mhz; }; int ADDCALL hackrf_init_scan(hackrf_device* device, - const uint64_t min_freq_hz, const uint64_t max_freq_hz, - const uint64_t step_freq_hz) + const uint16_t min_freq_mhz, const uint16_t max_freq_mhz, + const uint16_t step_freq_mhz) { struct init_scan_params params; uint8_t length; int result; - params.min_freq_hz = TO_LE(min_freq_hz); - params.max_freq_hz = TO_LE(max_freq_hz); - params.step_freq_hz = TO_LE(step_freq_hz); + params.min_freq_mhz = TO_LE(min_freq_mhz); + params.max_freq_mhz = TO_LE(max_freq_mhz); + params.step_freq_mhz = TO_LE(step_freq_mhz); length = sizeof(struct init_scan_params); result = libusb_control_transfer( diff --git a/host/libhackrf/src/hackrf.h b/host/libhackrf/src/hackrf.h index 48c192c7..fb0a4853 100644 --- a/host/libhackrf/src/hackrf.h +++ b/host/libhackrf/src/hackrf.h @@ -198,8 +198,8 @@ extern ADDAPI uint32_t ADDCALL hackrf_compute_baseband_filter_bw_round_down_lt(c extern ADDAPI uint32_t ADDCALL hackrf_compute_baseband_filter_bw(const uint32_t bandwidth_hz); /* Start scan mode */ extern ADDAPI int ADDCALL hackrf_init_scan(hackrf_device* device, - const uint64_t min_freq_hz, const uint64_t max_freq_hz, - const uint64_t step_freq_hz); + const uint16_t min_freq_mhz, const uint16_t max_freq_mhz, + const uint16_t step_freq_mhz); #ifdef __cplusplus } // __cplusplus defined. From 0245204ad9130d50924b5aa175337dd0b6fa2074 Mon Sep 17 00:00:00 2001 From: Dominic Spill Date: Tue, 26 Jul 2016 19:13:36 +0100 Subject: [PATCH 11/48] Add initial hackrf_scan skeleton --- host/hackrf-tools/src/CMakeLists.txt | 4 + host/hackrf-tools/src/hackrf_scan.c | 528 +++++++++++++++++++++++++++ 2 files changed, 532 insertions(+) create mode 100644 host/hackrf-tools/src/hackrf_scan.c diff --git a/host/hackrf-tools/src/CMakeLists.txt b/host/hackrf-tools/src/CMakeLists.txt index 373e36b4..a3a56e4c 100644 --- a/host/hackrf-tools/src/CMakeLists.txt +++ b/host/hackrf-tools/src/CMakeLists.txt @@ -50,6 +50,9 @@ install(TARGETS hackrf_cpldjtag RUNTIME DESTINATION ${INSTALL_DEFAULT_BINDIR}) add_executable(hackrf_info hackrf_info.c) install(TARGETS hackrf_info RUNTIME DESTINATION ${INSTALL_DEFAULT_BINDIR}) +add_executable(hackrf_scan hackrf_scan.c) +install(TARGETS hackrf_scan RUNTIME DESTINATION ${INSTALL_DEFAULT_BINDIR}) + if(NOT libhackrf_SOURCE_DIR) include_directories(${LIBHACKRF_INCLUDE_DIR}) LIST(APPEND TOOLS_LINK_LIBS ${LIBHACKRF_LIBRARIES}) @@ -69,3 +72,4 @@ target_link_libraries(hackrf_rffc5071 ${TOOLS_LINK_LIBS}) target_link_libraries(hackrf_spiflash ${TOOLS_LINK_LIBS}) target_link_libraries(hackrf_cpldjtag ${TOOLS_LINK_LIBS}) target_link_libraries(hackrf_info ${TOOLS_LINK_LIBS}) +target_link_libraries(hackrf_scan ${TOOLS_LINK_LIBS}) diff --git a/host/hackrf-tools/src/hackrf_scan.c b/host/hackrf-tools/src/hackrf_scan.c new file mode 100644 index 00000000..45c6c0ee --- /dev/null +++ b/host/hackrf-tools/src/hackrf_scan.c @@ -0,0 +1,528 @@ +/* + * Copyright 2016 Dominic Spill + * + * This file is part of HackRF. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, + * Boston, MA 02110-1301, USA. + */ + +#include + +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#ifndef bool +typedef int bool; +#define true 1 +#define false 0 +#endif + +#ifdef _WIN32 +#include + +#ifdef _MSC_VER + +#ifdef _WIN64 +typedef int64_t ssize_t; +#else +typedef int32_t ssize_t; +#endif + +#define strtoull _strtoui64 +#define snprintf _snprintf + +int gettimeofday(struct timeval *tv, void* ignored) { + FILETIME ft; + unsigned __int64 tmp = 0; + if (NULL != tv) { + GetSystemTimeAsFileTime(&ft); + tmp |= ft.dwHighDateTime; + tmp <<= 32; + tmp |= ft.dwLowDateTime; + tmp /= 10; + tmp -= 11644473600000000Ui64; + tv->tv_sec = (long)(tmp / 1000000UL); + tv->tv_usec = (long)(tmp % 1000000UL); + } + return 0; +} + +#endif +#endif + +#if defined(__GNUC__) +#include +#include +#endif + +#include + +#define FD_BUFFER_SIZE (8*1024) + +#define FREQ_ONE_MHZ (1000000ull) + +#define FREQ_MIN_HZ (0ull) /* 0 Hz */ +#define FREQ_MAX_HZ (7250000000ull) /* 7250MHz */ + +#define DEFAULT_SAMPLE_RATE_HZ (20000000) /* 20MHz default sample rate */ +#define DEFAULT_BASEBAND_FILTER_BANDWIDTH (15000000) /* 5MHz default */ + +#if defined _WIN32 + #define sleep(a) Sleep( (a*1000) ) +#endif + +#define U64TOA_MAX_DIGIT (31) +typedef struct +{ + char data[U64TOA_MAX_DIGIT+1]; +} t_u64toa; + +t_u64toa ascii_u64_data1; +t_u64toa ascii_u64_data2; + +static float +TimevalDiff(const struct timeval *a, const struct timeval *b) +{ + return (a->tv_sec - b->tv_sec) + 1e-6f * (a->tv_usec - b->tv_usec); +} + +int parse_u64(char* s, uint64_t* const value) { + uint_fast8_t base = 10; + char* s_end; + uint64_t u64_value; + + if( strlen(s) > 2 ) { + if( s[0] == '0' ) { + if( (s[1] == 'x') || (s[1] == 'X') ) { + base = 16; + s += 2; + } else if( (s[1] == 'b') || (s[1] == 'B') ) { + base = 2; + s += 2; + } + } + } + + s_end = s; + u64_value = strtoull(s, &s_end, base); + if( (s != s_end) && (*s_end == 0) ) { + *value = u64_value; + return HACKRF_SUCCESS; + } else { + return HACKRF_ERROR_INVALID_PARAM; + } +} + +int parse_u32(char* s, uint32_t* const value) { + uint_fast8_t base = 10; + char* s_end; + uint64_t ulong_value; + + if( strlen(s) > 2 ) { + if( s[0] == '0' ) { + if( (s[1] == 'x') || (s[1] == 'X') ) { + base = 16; + s += 2; + } else if( (s[1] == 'b') || (s[1] == 'B') ) { + base = 2; + s += 2; + } + } + } + + s_end = s; + ulong_value = strtoul(s, &s_end, base); + if( (s != s_end) && (*s_end == 0) ) { + *value = (uint32_t)ulong_value; + return HACKRF_SUCCESS; + } else { + return HACKRF_ERROR_INVALID_PARAM; + } +} + + +static char *stringrev(char *str) +{ + char *p1, *p2; + + if(! str || ! *str) + return str; + + for(p1 = str, p2 = str + strlen(str) - 1; p2 > p1; ++p1, --p2) + { + *p1 ^= *p2; + *p2 ^= *p1; + *p1 ^= *p2; + } + return str; +} + +char* u64toa(uint64_t val, t_u64toa* str) +{ + #define BASE (10ull) /* Base10 by default */ + uint64_t sum; + int pos; + int digit; + int max_len; + char* res; + + sum = val; + max_len = U64TOA_MAX_DIGIT; + pos = 0; + + do + { + digit = (sum % BASE); + str->data[pos] = digit + '0'; + pos++; + + sum /= BASE; + }while( (sum>0) && (pos < max_len) ); + + if( (pos == max_len) && (sum>0) ) + return NULL; + + str->data[pos] = '\0'; + res = stringrev(str->data); + + return res; +} + +volatile bool do_exit = false; + +FILE* fd = NULL; +volatile uint32_t byte_count = 0; + +struct timeval time_start; +struct timeval t_start; + +bool amp = false; +uint32_t amp_enable; + +bool antenna = false; +uint32_t antenna_enable; + +bool sample_rate = false; +uint32_t sample_rate_hz; + +int rx_callback(hackrf_transfer* transfer) { + /* This is where we need to do interesting things with the samples + * FFT + * Throw away unused bins + * write output to pipe + */ + ssize_t bytes_to_write; + ssize_t bytes_written; + + if( fd != NULL ) + { + byte_count += transfer->valid_length; + bytes_to_write = transfer->valid_length; + + bytes_written = fwrite(transfer->buffer, 1, bytes_to_write, fd); + if (bytes_written != bytes_to_write) { + return -1; + } else { + return 0; + } + } else { + return -1; + } +} + +static void usage() { + printf("Usage:\n"); + printf("\t[-d serial_number] # Serial number of desired HackRF.\n"); + printf("\t[-a amp_enable] # RX/TX RF amplifier 1=Enable, 0=Disable.\n"); + printf("\t[-p antenna_enable] # Antenna port power, 1=Enable, 0=Disable.\n"); + printf("\t[-l gain_db] # RX LNA (IF) gain, 0-40dB, 8dB steps\n"); + printf("\t[-g gain_db] # RX VGA (baseband) gain, 0-62dB, 2dB steps\n"); + printf("\t[-x gain_db] # TX VGA (IF) gain, 0-47dB, 1dB steps\n"); +} + +static hackrf_device* device = NULL; + +#ifdef _MSC_VER +BOOL WINAPI +sighandler(int signum) { + if (CTRL_C_EVENT == signum) { + fprintf(stdout, "Caught signal %d\n", signum); + do_exit = true; + return TRUE; + } + return FALSE; +} +#else +void sigint_callback_handler(int signum) { + fprintf(stdout, "Caught signal %d\n", signum); + do_exit = true; +} +#endif + +#define PATH_FILE_MAX_LEN (FILENAME_MAX) +#define DATE_TIME_MAX_LEN (32) + +int main(int argc, char** argv) { + int opt; + const char* path = "/dev/null"; + const char* serial_number = NULL; + int result; + int exit_code = EXIT_SUCCESS; + struct timeval t_end; + float time_diff; + unsigned int lna_gain=8, vga_gain=20, txvga_gain=0; + + while( (opt = getopt(argc, argv, "a:p:l:g:x:d:")) != EOF ) + { + result = HACKRF_SUCCESS; + switch( opt ) + { + case 'd': + serial_number = optarg; + break; + + case 'a': + amp = true; + result = parse_u32(optarg, &_enable); + break; + + case 'p': + antenna = true; + result = parse_u32(optarg, &antenna_enable); + break; + + case 'l': + result = parse_u32(optarg, &lna_gain); + break; + + case 'g': + result = parse_u32(optarg, &vga_gain); + break; + + case 'x': + result = parse_u32(optarg, &txvga_gain); + break; + + default: + printf("unknown argument '-%c %s'\n", opt, optarg); + usage(); + return EXIT_FAILURE; + } + + if( result != HACKRF_SUCCESS ) { + printf("argument error: '-%c %s' %s (%d)\n", opt, optarg, hackrf_error_name(result), result); + usage(); + return EXIT_FAILURE; + } + } + + if (lna_gain % 8) + printf("warning: lna_gain (-l) must be a multiple of 8\n"); + + if (vga_gain % 2) + printf("warning: vga_gain (-g) must be a multiple of 2\n"); + + if( amp ) { + if( amp_enable > 1 ) { + printf("argument error: amp_enable shall be 0 or 1.\n"); + usage(); + return EXIT_FAILURE; + } + } + + if (antenna) { + if (antenna_enable > 1) { + printf("argument error: antenna_enable shall be 0 or 1.\n"); + usage(); + return EXIT_FAILURE; + } + } + + result = hackrf_init(); + if( result != HACKRF_SUCCESS ) { + printf("hackrf_init() failed: %s (%d)\n", hackrf_error_name(result), result); + usage(); + return EXIT_FAILURE; + } + + result = hackrf_open_by_serial(serial_number, &device); + if( result != HACKRF_SUCCESS ) { + printf("hackrf_open() failed: %s (%d)\n", hackrf_error_name(result), result); + usage(); + return EXIT_FAILURE; + } + + fd = fopen(path, "wb"); + if( fd == NULL ) { + printf("Failed to open file: %s\n", path); + return EXIT_FAILURE; + } + /* Change fd buffer to have bigger one to store or read data on/to HDD */ + result = setvbuf(fd , NULL , _IOFBF , FD_BUFFER_SIZE); + if( result != 0 ) { + printf("setvbuf() failed: %d\n", result); + usage(); + return EXIT_FAILURE; + } + +#ifdef _MSC_VER + SetConsoleCtrlHandler( (PHANDLER_ROUTINE) sighandler, TRUE ); +#else + signal(SIGINT, &sigint_callback_handler); + signal(SIGILL, &sigint_callback_handler); + signal(SIGFPE, &sigint_callback_handler); + signal(SIGSEGV, &sigint_callback_handler); + signal(SIGTERM, &sigint_callback_handler); + signal(SIGABRT, &sigint_callback_handler); +#endif + printf("call hackrf_sample_rate_set(%.03f MHz)\n", + ((float)DEFAULT_SAMPLE_RATE_HZ/(float)FREQ_ONE_MHZ)); + result = hackrf_set_sample_rate_manual(device, DEFAULT_SAMPLE_RATE_HZ, 1); + if( result != HACKRF_SUCCESS ) { + printf("hackrf_sample_rate_set() failed: %s (%d)\n", + hackrf_error_name(result), result); + usage(); + return EXIT_FAILURE; + } + + printf("call hackrf_baseband_filter_bandwidth_set(%.03f MHz)\n", + ((float)DEFAULT_BASEBAND_FILTER_BANDWIDTH/(float)FREQ_ONE_MHZ)); + result = hackrf_set_baseband_filter_bandwidth(device, DEFAULT_BASEBAND_FILTER_BANDWIDTH); + if( result != HACKRF_SUCCESS ) { + printf("hackrf_baseband_filter_bandwidth_set() failed: %s (%d)\n", + hackrf_error_name(result), result); + usage(); + return EXIT_FAILURE; + } + + result = hackrf_set_vga_gain(device, vga_gain); + result |= hackrf_set_lna_gain(device, lna_gain); + result |= hackrf_start_rx(device, rx_callback, NULL); + if (result != HACKRF_SUCCESS) { + printf("hackrf_start_?x() failed: %s (%d)\n", hackrf_error_name(result), result); + usage(); + return EXIT_FAILURE; + } + + /* DGS FIXME: allow upper and lower frequencies to be set */ + result = hackrf_init_scan(device, 50, 6000, 10); + if( result != HACKRF_SUCCESS ) { + printf("hackrf_init_scan() failed: %s (%d)\n", + hackrf_error_name(result), result); + usage(); + return EXIT_FAILURE; + } + + if (amp) { + printf("call hackrf_set_amp_enable(%u)\n", amp_enable); + result = hackrf_set_amp_enable(device, (uint8_t)amp_enable); + if (result != HACKRF_SUCCESS) { + printf("hackrf_set_amp_enable() failed: %s (%d)\n", + hackrf_error_name(result), result); + usage(); + return EXIT_FAILURE; + } + } + + if (antenna) { + printf("call hackrf_set_antenna_enable(%u)\n", antenna_enable); + result = hackrf_set_antenna_enable(device, (uint8_t)antenna_enable); + if (result != HACKRF_SUCCESS) { + printf("hackrf_set_antenna_enable() failed: %s (%d)\n", + hackrf_error_name(result), result); + usage(); + return EXIT_FAILURE; + } + } + + gettimeofday(&t_start, NULL); + gettimeofday(&time_start, NULL); + + printf("Stop with Ctrl-C\n"); + while((hackrf_is_streaming(device) == HACKRF_TRUE) && (do_exit == false)) { + uint32_t byte_count_now; + struct timeval time_now; + float time_difference, rate; + sleep(1); + + gettimeofday(&time_now, NULL); + + byte_count_now = byte_count; + byte_count = 0; + + time_difference = TimevalDiff(&time_now, &time_start); + rate = (float)byte_count_now / time_difference; + printf("%4.1f MiB / %5.3f sec = %4.1f MiB/second\n", + (byte_count_now / 1e6f), time_difference, (rate / 1e6f) ); + + time_start = time_now; + + if (byte_count_now == 0) { + exit_code = EXIT_FAILURE; + printf("\nCouldn't transfer any bytes for one second.\n"); + break; + } + } + + result = hackrf_is_streaming(device); + if (do_exit) { + printf("\nUser cancel, exiting...\n"); + } else { + printf("\nExiting... hackrf_is_streaming() result: %s (%d)\n", + hackrf_error_name(result), result); + } + + gettimeofday(&t_end, NULL); + time_diff = TimevalDiff(&t_end, &t_start); + printf("Total time: %5.5f s\n", time_diff); + + if(device != NULL) { + result = hackrf_stop_rx(device); + if(result != HACKRF_SUCCESS) { + printf("hackrf_stop_rx() failed: %s (%d)\n", + hackrf_error_name(result), result); + } else { + printf("hackrf_stop_rx() done\n"); + } + + result = hackrf_close(device); + if(result != HACKRF_SUCCESS) { + printf("hackrf_close() failed: %s (%d)\n", + hackrf_error_name(result), result); + } else { + printf("hackrf_close() done\n"); + } + + hackrf_exit(); + printf("hackrf_exit() done\n"); + } + + if(fd != NULL) { + fclose(fd); + fd = NULL; + printf("fclose(fd) done\n"); + } + printf("exit\n"); + return exit_code; +} From 9b375a17eab86978bda6a3883474026452d7405f Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Tue, 26 Jul 2016 21:05:21 +0100 Subject: [PATCH 12/48] Fix init_scan request length --- firmware/hackrf_usb/usb_api_scan.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/firmware/hackrf_usb/usb_api_scan.c b/firmware/hackrf_usb/usb_api_scan.c index d5377198..1cba69d8 100644 --- a/firmware/hackrf_usb/usb_api_scan.c +++ b/firmware/hackrf_usb/usb_api_scan.c @@ -48,7 +48,7 @@ usb_request_status_t usb_vendor_request_init_scan( usb_endpoint_t* const endpoint, const usb_transfer_stage_t stage) { if ((stage == USB_TRANSFER_STAGE_SETUP) && - (endpoint->setup.length == 24)) { + (endpoint->setup.length == 6)) { usb_transfer_schedule_block(endpoint->out, &scan_params, sizeof(struct init_scan_params), From c96156476f44227e2547f3f7171db72afe01ca9b Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Tue, 26 Jul 2016 21:51:00 +0100 Subject: [PATCH 13/48] Switch all output from stdout to stderr to allow for piping samples --- host/hackrf-tools/src/hackrf_scan.c | 84 ++++++++++++++--------------- 1 file changed, 42 insertions(+), 42 deletions(-) diff --git a/host/hackrf-tools/src/hackrf_scan.c b/host/hackrf-tools/src/hackrf_scan.c index 45c6c0ee..20884665 100644 --- a/host/hackrf-tools/src/hackrf_scan.c +++ b/host/hackrf-tools/src/hackrf_scan.c @@ -252,13 +252,13 @@ int rx_callback(hackrf_transfer* transfer) { } static void usage() { - printf("Usage:\n"); - printf("\t[-d serial_number] # Serial number of desired HackRF.\n"); - printf("\t[-a amp_enable] # RX/TX RF amplifier 1=Enable, 0=Disable.\n"); - printf("\t[-p antenna_enable] # Antenna port power, 1=Enable, 0=Disable.\n"); - printf("\t[-l gain_db] # RX LNA (IF) gain, 0-40dB, 8dB steps\n"); - printf("\t[-g gain_db] # RX VGA (baseband) gain, 0-62dB, 2dB steps\n"); - printf("\t[-x gain_db] # TX VGA (IF) gain, 0-47dB, 1dB steps\n"); + fprintf(stderr, "Usage:\n"); + fprintf(stderr, "\t[-d serial_number] # Serial number of desired HackRF.\n"); + fprintf(stderr, "\t[-a amp_enable] # RX/TX RF amplifier 1=Enable, 0=Disable.\n"); + fprintf(stderr, "\t[-p antenna_enable] # Antenna port power, 1=Enable, 0=Disable.\n"); + fprintf(stderr, "\t[-l gain_db] # RX LNA (IF) gain, 0-40dB, 8dB steps\n"); + fprintf(stderr, "\t[-g gain_db] # RX VGA (baseband) gain, 0-62dB, 2dB steps\n"); + fprintf(stderr, "\t[-x gain_db] # TX VGA (IF) gain, 0-47dB, 1dB steps\n"); } static hackrf_device* device = NULL; @@ -267,7 +267,7 @@ static hackrf_device* device = NULL; BOOL WINAPI sighandler(int signum) { if (CTRL_C_EVENT == signum) { - fprintf(stdout, "Caught signal %d\n", signum); + fprintf(stderr, "Caught signal %d\n", signum); do_exit = true; return TRUE; } @@ -275,7 +275,7 @@ sighandler(int signum) { } #else void sigint_callback_handler(int signum) { - fprintf(stdout, "Caught signal %d\n", signum); + fprintf(stderr, "Caught signal %d\n", signum); do_exit = true; } #endif @@ -325,27 +325,27 @@ int main(int argc, char** argv) { break; default: - printf("unknown argument '-%c %s'\n", opt, optarg); + fprintf(stderr, "unknown argument '-%c %s'\n", opt, optarg); usage(); return EXIT_FAILURE; } 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(); return EXIT_FAILURE; } } 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) - 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( amp ) { 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(); return EXIT_FAILURE; } @@ -353,7 +353,7 @@ int main(int argc, char** argv) { if (antenna) { 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(); return EXIT_FAILURE; } @@ -361,27 +361,27 @@ int main(int argc, char** argv) { result = hackrf_init(); 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(); return EXIT_FAILURE; } result = hackrf_open_by_serial(serial_number, &device); 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(); return EXIT_FAILURE; } fd = fopen(path, "wb"); if( fd == NULL ) { - printf("Failed to open file: %s\n", path); + fprintf(stderr, "Failed to open file: %s\n", path); return EXIT_FAILURE; } /* Change fd buffer to have bigger one to store or read data on/to HDD */ result = setvbuf(fd , NULL , _IOFBF , FD_BUFFER_SIZE); if( result != 0 ) { - printf("setvbuf() failed: %d\n", result); + fprintf(stderr, "setvbuf() failed: %d\n", result); usage(); return EXIT_FAILURE; } @@ -396,21 +396,21 @@ int main(int argc, char** argv) { signal(SIGTERM, &sigint_callback_handler); signal(SIGABRT, &sigint_callback_handler); #endif - printf("call hackrf_sample_rate_set(%.03f MHz)\n", + fprintf(stderr, "call hackrf_sample_rate_set(%.03f MHz)\n", ((float)DEFAULT_SAMPLE_RATE_HZ/(float)FREQ_ONE_MHZ)); result = hackrf_set_sample_rate_manual(device, DEFAULT_SAMPLE_RATE_HZ, 1); if( result != HACKRF_SUCCESS ) { - printf("hackrf_sample_rate_set() failed: %s (%d)\n", + fprintf(stderr, "hackrf_sample_rate_set() failed: %s (%d)\n", hackrf_error_name(result), result); usage(); return EXIT_FAILURE; } - printf("call hackrf_baseband_filter_bandwidth_set(%.03f MHz)\n", + fprintf(stderr, "call hackrf_baseband_filter_bandwidth_set(%.03f MHz)\n", ((float)DEFAULT_BASEBAND_FILTER_BANDWIDTH/(float)FREQ_ONE_MHZ)); result = hackrf_set_baseband_filter_bandwidth(device, DEFAULT_BASEBAND_FILTER_BANDWIDTH); if( result != HACKRF_SUCCESS ) { - printf("hackrf_baseband_filter_bandwidth_set() failed: %s (%d)\n", + fprintf(stderr, "hackrf_baseband_filter_bandwidth_set() failed: %s (%d)\n", hackrf_error_name(result), result); usage(); return EXIT_FAILURE; @@ -420,7 +420,7 @@ int main(int argc, char** argv) { result |= hackrf_set_lna_gain(device, lna_gain); result |= hackrf_start_rx(device, rx_callback, NULL); 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(); return EXIT_FAILURE; } @@ -428,17 +428,17 @@ int main(int argc, char** argv) { /* DGS FIXME: allow upper and lower frequencies to be set */ result = hackrf_init_scan(device, 50, 6000, 10); if( result != HACKRF_SUCCESS ) { - printf("hackrf_init_scan() failed: %s (%d)\n", + fprintf(stderr, "hackrf_init_scan() failed: %s (%d)\n", hackrf_error_name(result), result); usage(); return EXIT_FAILURE; } 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); if (result != HACKRF_SUCCESS) { - printf("hackrf_set_amp_enable() failed: %s (%d)\n", + fprintf(stderr, "hackrf_set_amp_enable() failed: %s (%d)\n", hackrf_error_name(result), result); usage(); return EXIT_FAILURE; @@ -446,10 +446,10 @@ int main(int argc, char** argv) { } 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); if (result != HACKRF_SUCCESS) { - printf("hackrf_set_antenna_enable() failed: %s (%d)\n", + fprintf(stderr, "hackrf_set_antenna_enable() failed: %s (%d)\n", hackrf_error_name(result), result); usage(); return EXIT_FAILURE; @@ -459,7 +459,7 @@ int main(int argc, char** argv) { gettimeofday(&t_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) && (do_exit == false)) { uint32_t byte_count_now; struct timeval time_now; @@ -473,56 +473,56 @@ int main(int argc, char** argv) { time_difference = TimevalDiff(&time_now, &time_start); 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) ); time_start = time_now; if (byte_count_now == 0) { 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; } } result = hackrf_is_streaming(device); if (do_exit) { - printf("\nUser cancel, exiting...\n"); + fprintf(stderr, "\nUser cancel, exiting...\n"); } else { - printf("\nExiting... hackrf_is_streaming() result: %s (%d)\n", + fprintf(stderr, "\nExiting... hackrf_is_streaming() result: %s (%d)\n", hackrf_error_name(result), result); } gettimeofday(&t_end, NULL); 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) { result = hackrf_stop_rx(device); if(result != HACKRF_SUCCESS) { - printf("hackrf_stop_rx() failed: %s (%d)\n", + fprintf(stderr, "hackrf_stop_rx() failed: %s (%d)\n", hackrf_error_name(result), result); } else { - printf("hackrf_stop_rx() done\n"); + fprintf(stderr, "hackrf_stop_rx() done\n"); } result = hackrf_close(device); if(result != HACKRF_SUCCESS) { - printf("hackrf_close() failed: %s (%d)\n", + fprintf(stderr, "hackrf_close() failed: %s (%d)\n", hackrf_error_name(result), result); } else { - printf("hackrf_close() done\n"); + fprintf(stderr, "hackrf_close() done\n"); } hackrf_exit(); - printf("hackrf_exit() done\n"); + fprintf(stderr, "hackrf_exit() done\n"); } if(fd != NULL) { fclose(fd); fd = NULL; - printf("fclose(fd) done\n"); + fprintf(stderr, "fclose(fd) done\n"); } - printf("exit\n"); + fprintf(stderr, "exit\n"); return exit_code; } From 805e8c02e9dee13df6a9162235591223564a29b8 Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Wed, 27 Jul 2016 00:34:53 +0100 Subject: [PATCH 14/48] Revert "Only transfer one block per re-tune" This reverts commit 3614cd3050d4cbbde651dae57fc35d689b18934f. --- firmware/hackrf_usb/usb_api_scan.c | 30 ++++++++++++++---------------- 1 file changed, 14 insertions(+), 16 deletions(-) diff --git a/firmware/hackrf_usb/usb_api_scan.c b/firmware/hackrf_usb/usb_api_scan.c index 1cba69d8..f4abc02f 100644 --- a/firmware/hackrf_usb/usb_api_scan.c +++ b/firmware/hackrf_usb/usb_api_scan.c @@ -75,14 +75,13 @@ void scan_mode(void) { if ( usb_bulk_buffer_offset >= 16384 && phase == 1 && transceiver_mode() != TRANSCEIVER_MODE_OFF) { - if (blocks_queued == 2) - usb_transfer_schedule_block( - (transceiver_mode() == TRANSCEIVER_MODE_RX) - ? &usb_endpoint_bulk_in : &usb_endpoint_bulk_out, - &usb_bulk_buffer[0x0000], - 0x4000, - NULL, NULL - ); + usb_transfer_schedule_block( + (transceiver_mode() == TRANSCEIVER_MODE_RX) + ? &usb_endpoint_bulk_in : &usb_endpoint_bulk_out, + &usb_bulk_buffer[0x0000], + 0x4000, + NULL, NULL + ); phase = 0; blocks_queued++; } @@ -91,14 +90,13 @@ void scan_mode(void) { if ( usb_bulk_buffer_offset < 16384 && phase == 0 && transceiver_mode() != TRANSCEIVER_MODE_OFF) { - if (blocks_queued == 2) - usb_transfer_schedule_block( - (transceiver_mode() == TRANSCEIVER_MODE_RX) - ? &usb_endpoint_bulk_in : &usb_endpoint_bulk_out, - &usb_bulk_buffer[0x4000], - 0x4000, - NULL, NULL - ); + usb_transfer_schedule_block( + (transceiver_mode() == TRANSCEIVER_MODE_RX) + ? &usb_endpoint_bulk_in : &usb_endpoint_bulk_out, + &usb_bulk_buffer[0x4000], + 0x4000, + NULL, NULL + ); phase = 1; blocks_queued++; } From ccc424e21fa801f85bcc6ac97eb4a3f4be3f5e63 Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Wed, 27 Jul 2016 00:42:29 +0100 Subject: [PATCH 15/48] Cleanup scan_mode usb transfer logic --- firmware/hackrf_usb/usb_api_scan.c | 39 +++++++++++++++--------------- 1 file changed, 19 insertions(+), 20 deletions(-) diff --git a/firmware/hackrf_usb/usb_api_scan.c b/firmware/hackrf_usb/usb_api_scan.c index f4abc02f..7d079391 100644 --- a/firmware/hackrf_usb/usb_api_scan.c +++ b/firmware/hackrf_usb/usb_api_scan.c @@ -70,43 +70,42 @@ void scan_mode(void) { unsigned int blocks_queued = 0; unsigned int phase = 0; + uint8_t *buffer; + bool transfer = false; + while(transceiver_mode() != TRANSCEIVER_MODE_OFF) { // Set up IN transfer of buffer 0. - if ( usb_bulk_buffer_offset >= 16384 - && phase == 1 - && transceiver_mode() != TRANSCEIVER_MODE_OFF) { - usb_transfer_schedule_block( - (transceiver_mode() == TRANSCEIVER_MODE_RX) - ? &usb_endpoint_bulk_in : &usb_endpoint_bulk_out, - &usb_bulk_buffer[0x0000], - 0x4000, - NULL, NULL - ); + if ( usb_bulk_buffer_offset >= 16384 && phase == 1) { + transfer = true; + buffer = &usb_bulk_buffer[0x0000]; phase = 0; blocks_queued++; } // Set up IN transfer of buffer 1. - if ( usb_bulk_buffer_offset < 16384 - && phase == 0 - && transceiver_mode() != TRANSCEIVER_MODE_OFF) { + if ( usb_bulk_buffer_offset < 16384 && phase == 0) { + transfer = true; + buffer = &usb_bulk_buffer[0x4000]; + phase = 1; + blocks_queued++; + } + + if (transfer) { usb_transfer_schedule_block( - (transceiver_mode() == TRANSCEIVER_MODE_RX) - ? &usb_endpoint_bulk_in : &usb_endpoint_bulk_out, - &usb_bulk_buffer[0x4000], + &usb_endpoint_bulk_in, + buffer, 0x4000, NULL, NULL ); - phase = 1; - blocks_queued++; + transfer = false; } if (blocks_queued > 2) { scan_freq += scan_params.step_freq_mhz; if (scan_freq > scan_params.max_freq_mhz) { scan_freq = scan_params.min_freq_mhz; - } - set_freq(scan_freq*FREQ_GRANULARITY); + } + set_freq(scan_freq*FREQ_GRANULARITY); blocks_queued = 0; } } From a303097c3167127ec7412df865229223d71f7bc4 Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Wed, 27 Jul 2016 01:46:11 +0100 Subject: [PATCH 16/48] Add magic & scan_freq to the start of each transfer --- firmware/hackrf_usb/usb_api_scan.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/firmware/hackrf_usb/usb_api_scan.c b/firmware/hackrf_usb/usb_api_scan.c index 7d079391..789bbd53 100644 --- a/firmware/hackrf_usb/usb_api_scan.c +++ b/firmware/hackrf_usb/usb_api_scan.c @@ -91,6 +91,8 @@ void scan_mode(void) { } if (transfer) { + *(uint16_t*)buffer = 0x7F7F; + *(uint16_t*)(buffer+2) = scan_freq; usb_transfer_schedule_block( &usb_endpoint_bulk_in, buffer, From 8c08d99879e7410d661548b3792abbcdc81341c0 Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Wed, 27 Jul 2016 01:52:50 +0100 Subject: [PATCH 17/48] Wait for scan_params to actually arrive before starting scan mode --- firmware/hackrf_usb/usb_api_scan.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/firmware/hackrf_usb/usb_api_scan.c b/firmware/hackrf_usb/usb_api_scan.c index 789bbd53..1ad25526 100644 --- a/firmware/hackrf_usb/usb_api_scan.c +++ b/firmware/hackrf_usb/usb_api_scan.c @@ -53,7 +53,7 @@ usb_request_status_t usb_vendor_request_init_scan( usb_transfer_schedule_block(endpoint->out, &scan_params, sizeof(struct init_scan_params), NULL, NULL); - + } else if (stage == USB_TRANSFER_STAGE_DATA) { /* Limit to min/max frequency without warning (possible FIXME) */ scan_params.min_freq_mhz = MAX(MIN_FREQ, scan_params.min_freq_mhz); scan_params.max_freq_mhz = MIN(MAX_FREQ, scan_params.max_freq_mhz); From 57e0924e0dc71674fef487a426a4742ba2fc5de1 Mon Sep 17 00:00:00 2001 From: Dominic Spill Date: Wed, 27 Jul 2016 07:24:59 +0100 Subject: [PATCH 18/48] Rename scan to sweep --- firmware/hackrf_usb/CMakeLists.txt | 2 +- firmware/hackrf_usb/hackrf_usb.c | 10 ++--- .../{usb_api_scan.c => usb_api_sweep.c} | 38 +++++++++---------- .../{usb_api_scan.h => usb_api_sweep.h} | 6 +-- host/hackrf-tools/src/CMakeLists.txt | 6 +-- .../src/{hackrf_scan.c => hackrf_sweep.c} | 0 6 files changed, 31 insertions(+), 31 deletions(-) rename firmware/hackrf_usb/{usb_api_scan.c => usb_api_sweep.c} (74%) rename firmware/hackrf_usb/{usb_api_scan.h => usb_api_sweep.h} (90%) rename host/hackrf-tools/src/{hackrf_scan.c => hackrf_sweep.c} (100%) diff --git a/firmware/hackrf_usb/CMakeLists.txt b/firmware/hackrf_usb/CMakeLists.txt index 8db83f7f..c9c9a9d4 100644 --- a/firmware/hackrf_usb/CMakeLists.txt +++ b/firmware/hackrf_usb/CMakeLists.txt @@ -42,7 +42,7 @@ set(SRC_M4 usb_api_register.c usb_api_spiflash.c usb_api_transceiver.c - usb_api_scan.c + usb_api_sweep.c "${PATH_HACKRF_FIRMWARE_COMMON}/usb_queue.c" "${PATH_HACKRF_FIRMWARE_COMMON}/fault_handler.c" "${PATH_HACKRF_FIRMWARE_COMMON}/cpld_jtag.c" diff --git a/firmware/hackrf_usb/hackrf_usb.c b/firmware/hackrf_usb/hackrf_usb.c index 25dff4ee..05d3975f 100644 --- a/firmware/hackrf_usb/hackrf_usb.c +++ b/firmware/hackrf_usb/hackrf_usb.c @@ -40,7 +40,7 @@ #include "usb_api_cpld.h" #include "usb_api_register.h" #include "usb_api_spiflash.h" -#include "usb_api_scan.h" +#include "usb_api_sweep.h" #include "usb_api_transceiver.h" #include "usb_bulk_buffer.h" @@ -76,7 +76,7 @@ static const usb_request_handler_fn vendor_request_handler[] = { #endif usb_vendor_request_set_freq_explicit, usb_vendor_request_read_wcid, // USB_WCID_VENDOR_REQ - usb_vendor_request_init_scan, + usb_vendor_request_init_sweep, }; static const uint32_t vendor_request_handler_count = @@ -182,9 +182,9 @@ int main(void) { if (start_cpld_update) cpld_update(); - // Check whether we need to initiate scan mode - if (start_scan_mode) - scan_mode(); + // Check whether we need to initiate sweep mode + if (start_sweep_mode) + sweep_mode(); // Set up IN transfer of buffer 0. if ( usb_bulk_buffer_offset >= 16384 diff --git a/firmware/hackrf_usb/usb_api_scan.c b/firmware/hackrf_usb/usb_api_sweep.c similarity index 74% rename from firmware/hackrf_usb/usb_api_scan.c rename to firmware/hackrf_usb/usb_api_sweep.c index 1ad25526..1a7ad97c 100644 --- a/firmware/hackrf_usb/usb_api_scan.c +++ b/firmware/hackrf_usb/usb_api_sweep.c @@ -19,7 +19,7 @@ * Boston, MA 02110-1301, USA. */ -#include "usb_api_scan.h" +#include "usb_api_sweep.h" #include "usb_queue.h" #include #include @@ -34,39 +34,39 @@ #define MIN_FREQ 1 #define MAX_FREQ 6000 -volatile bool start_scan_mode = false; -static uint64_t scan_freq; +volatile bool start_sweep_mode = false; +static uint64_t sweep_freq; -struct init_scan_params { +struct init_sweep_params { uint16_t min_freq_mhz; uint16_t max_freq_mhz; uint16_t step_freq_mhz; }; -struct init_scan_params scan_params; +struct init_sweep_params sweep_params; -usb_request_status_t usb_vendor_request_init_scan( +usb_request_status_t usb_vendor_request_init_sweep( usb_endpoint_t* const endpoint, const usb_transfer_stage_t stage) { if ((stage == USB_TRANSFER_STAGE_SETUP) && (endpoint->setup.length == 6)) { - usb_transfer_schedule_block(endpoint->out, &scan_params, - sizeof(struct init_scan_params), + usb_transfer_schedule_block(endpoint->out, &sweep_params, + sizeof(struct init_sweep_params), NULL, NULL); } else if (stage == USB_TRANSFER_STAGE_DATA) { /* Limit to min/max frequency without warning (possible FIXME) */ - scan_params.min_freq_mhz = MAX(MIN_FREQ, scan_params.min_freq_mhz); - scan_params.max_freq_mhz = MIN(MAX_FREQ, scan_params.max_freq_mhz); + sweep_params.min_freq_mhz = MAX(MIN_FREQ, sweep_params.min_freq_mhz); + sweep_params.max_freq_mhz = MIN(MAX_FREQ, sweep_params.max_freq_mhz); - scan_freq = scan_params.min_freq_mhz; - set_freq(scan_freq*FREQ_GRANULARITY); - start_scan_mode = true; + sweep_freq = sweep_params.min_freq_mhz; + set_freq(sweep_freq*FREQ_GRANULARITY); + start_sweep_mode = true; usb_transfer_schedule_ack(endpoint->in); } return USB_REQUEST_STATUS_OK; } -void scan_mode(void) { +void sweep_mode(void) { unsigned int blocks_queued = 0; unsigned int phase = 0; @@ -92,7 +92,7 @@ void scan_mode(void) { if (transfer) { *(uint16_t*)buffer = 0x7F7F; - *(uint16_t*)(buffer+2) = scan_freq; + *(uint16_t*)(buffer+2) = sweep_freq; usb_transfer_schedule_block( &usb_endpoint_bulk_in, buffer, @@ -103,11 +103,11 @@ void scan_mode(void) { } if (blocks_queued > 2) { - scan_freq += scan_params.step_freq_mhz; - if (scan_freq > scan_params.max_freq_mhz) { - scan_freq = scan_params.min_freq_mhz; + sweep_freq += sweep_params.step_freq_mhz; + if (sweep_freq > sweep_params.max_freq_mhz) { + sweep_freq = sweep_params.min_freq_mhz; } - set_freq(scan_freq*FREQ_GRANULARITY); + set_freq(sweep_freq*FREQ_GRANULARITY); blocks_queued = 0; } } diff --git a/firmware/hackrf_usb/usb_api_scan.h b/firmware/hackrf_usb/usb_api_sweep.h similarity index 90% rename from firmware/hackrf_usb/usb_api_scan.h rename to firmware/hackrf_usb/usb_api_sweep.h index be066612..828647cd 100644 --- a/firmware/hackrf_usb/usb_api_scan.h +++ b/firmware/hackrf_usb/usb_api_sweep.h @@ -26,11 +26,11 @@ #include #include -extern volatile bool start_scan_mode; +extern volatile bool start_sweep_mode; -usb_request_status_t usb_vendor_request_init_scan( +usb_request_status_t usb_vendor_request_init_sweep( usb_endpoint_t* const endpoint, const usb_transfer_stage_t stage); -void scan_mode(void); +void sweep_mode(void); #endif /* __USB_API_SPCAN_H__ */ diff --git a/host/hackrf-tools/src/CMakeLists.txt b/host/hackrf-tools/src/CMakeLists.txt index a3a56e4c..6f925cde 100644 --- a/host/hackrf-tools/src/CMakeLists.txt +++ b/host/hackrf-tools/src/CMakeLists.txt @@ -50,8 +50,8 @@ install(TARGETS hackrf_cpldjtag RUNTIME DESTINATION ${INSTALL_DEFAULT_BINDIR}) add_executable(hackrf_info hackrf_info.c) install(TARGETS hackrf_info RUNTIME DESTINATION ${INSTALL_DEFAULT_BINDIR}) -add_executable(hackrf_scan hackrf_scan.c) -install(TARGETS hackrf_scan RUNTIME DESTINATION ${INSTALL_DEFAULT_BINDIR}) +add_executable(hackrf_sweep hackrf_sweep.c) +install(TARGETS hackrf_sweep RUNTIME DESTINATION ${INSTALL_DEFAULT_BINDIR}) if(NOT libhackrf_SOURCE_DIR) include_directories(${LIBHACKRF_INCLUDE_DIR}) @@ -72,4 +72,4 @@ target_link_libraries(hackrf_rffc5071 ${TOOLS_LINK_LIBS}) target_link_libraries(hackrf_spiflash ${TOOLS_LINK_LIBS}) target_link_libraries(hackrf_cpldjtag ${TOOLS_LINK_LIBS}) target_link_libraries(hackrf_info ${TOOLS_LINK_LIBS}) -target_link_libraries(hackrf_scan ${TOOLS_LINK_LIBS}) +target_link_libraries(hackrf_sweep ${TOOLS_LINK_LIBS}) diff --git a/host/hackrf-tools/src/hackrf_scan.c b/host/hackrf-tools/src/hackrf_sweep.c similarity index 100% rename from host/hackrf-tools/src/hackrf_scan.c rename to host/hackrf-tools/src/hackrf_sweep.c From 86bde9f4c224f35bb1f858bff88cb476789a5fea Mon Sep 17 00:00:00 2001 From: Dominic Spill Date: Wed, 27 Jul 2016 07:42:07 +0100 Subject: [PATCH 19/48] Remove unused helper functions from hackrf_sweep --- host/hackrf-tools/src/hackrf_sweep.c | 91 +--------------------------- 1 file changed, 1 insertion(+), 90 deletions(-) diff --git a/host/hackrf-tools/src/hackrf_sweep.c b/host/hackrf-tools/src/hackrf_sweep.c index 20884665..90f87f51 100644 --- a/host/hackrf-tools/src/hackrf_sweep.c +++ b/host/hackrf-tools/src/hackrf_sweep.c @@ -92,48 +92,10 @@ int gettimeofday(struct timeval *tv, void* ignored) { #define sleep(a) Sleep( (a*1000) ) #endif -#define U64TOA_MAX_DIGIT (31) -typedef struct -{ - char data[U64TOA_MAX_DIGIT+1]; -} t_u64toa; - -t_u64toa ascii_u64_data1; -t_u64toa ascii_u64_data2; - -static float -TimevalDiff(const struct timeval *a, const struct timeval *b) -{ +static float TimevalDiff(const struct timeval *a, const struct timeval *b) { return (a->tv_sec - b->tv_sec) + 1e-6f * (a->tv_usec - b->tv_usec); } -int parse_u64(char* s, uint64_t* const value) { - uint_fast8_t base = 10; - char* s_end; - uint64_t u64_value; - - if( strlen(s) > 2 ) { - if( s[0] == '0' ) { - if( (s[1] == 'x') || (s[1] == 'X') ) { - base = 16; - s += 2; - } else if( (s[1] == 'b') || (s[1] == 'B') ) { - base = 2; - s += 2; - } - } - } - - s_end = s; - u64_value = strtoull(s, &s_end, base); - if( (s != s_end) && (*s_end == 0) ) { - *value = u64_value; - return HACKRF_SUCCESS; - } else { - return HACKRF_ERROR_INVALID_PARAM; - } -} - int parse_u32(char* s, uint32_t* const value) { uint_fast8_t base = 10; char* s_end; @@ -161,54 +123,6 @@ int parse_u32(char* s, uint32_t* const value) { } } - -static char *stringrev(char *str) -{ - char *p1, *p2; - - if(! str || ! *str) - return str; - - for(p1 = str, p2 = str + strlen(str) - 1; p2 > p1; ++p1, --p2) - { - *p1 ^= *p2; - *p2 ^= *p1; - *p1 ^= *p2; - } - return str; -} - -char* u64toa(uint64_t val, t_u64toa* str) -{ - #define BASE (10ull) /* Base10 by default */ - uint64_t sum; - int pos; - int digit; - int max_len; - char* res; - - sum = val; - max_len = U64TOA_MAX_DIGIT; - pos = 0; - - do - { - digit = (sum % BASE); - str->data[pos] = digit + '0'; - pos++; - - sum /= BASE; - }while( (sum>0) && (pos < max_len) ); - - if( (pos == max_len) && (sum>0) ) - return NULL; - - str->data[pos] = '\0'; - res = stringrev(str->data); - - return res; -} - volatile bool do_exit = false; FILE* fd = NULL; @@ -280,9 +194,6 @@ void sigint_callback_handler(int signum) { } #endif -#define PATH_FILE_MAX_LEN (FILENAME_MAX) -#define DATE_TIME_MAX_LEN (32) - int main(int argc, char** argv) { int opt; const char* path = "/dev/null"; From dc0b5a5798145bf9ef0d1343c0eaba802b287caa Mon Sep 17 00:00:00 2001 From: Dominic Spill Date: Wed, 27 Jul 2016 07:59:10 +0100 Subject: [PATCH 20/48] Fix missed scan -> sweep changes --- host/hackrf-tools/src/hackrf_sweep.c | 2 +- host/libhackrf/src/hackrf.c | 12 ++++++------ host/libhackrf/src/hackrf.h | 2 +- 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/host/hackrf-tools/src/hackrf_sweep.c b/host/hackrf-tools/src/hackrf_sweep.c index 90f87f51..e2cab8d6 100644 --- a/host/hackrf-tools/src/hackrf_sweep.c +++ b/host/hackrf-tools/src/hackrf_sweep.c @@ -337,7 +337,7 @@ int main(int argc, char** argv) { } /* DGS FIXME: allow upper and lower frequencies to be set */ - result = hackrf_init_scan(device, 50, 6000, 10); + result = hackrf_init_sweep(device, 50, 6000, 10); if( result != HACKRF_SUCCESS ) { fprintf(stderr, "hackrf_init_scan() failed: %s (%d)\n", hackrf_error_name(result), result); diff --git a/host/libhackrf/src/hackrf.c b/host/libhackrf/src/hackrf.c index b16763bc..41f36fee 100644 --- a/host/libhackrf/src/hackrf.c +++ b/host/libhackrf/src/hackrf.c @@ -68,7 +68,7 @@ typedef enum { HACKRF_VENDOR_REQUEST_ANTENNA_ENABLE = 23, HACKRF_VENDOR_REQUEST_SET_FREQ_EXPLICIT = 24, // USB_WCID_VENDOR_REQ = 25 - HACKRF_VENDOR_REQUEST_INIT_SCAN = 26, + HACKRF_VENDOR_REQUEST_INIT_SWEEP = 26, } hackrf_vendor_request; typedef enum { @@ -1697,29 +1697,29 @@ uint32_t ADDCALL hackrf_compute_baseband_filter_bw(const uint32_t bandwidth_hz) return p->bandwidth_hz; } -struct init_scan_params { +struct init_sweep_params { uint16_t min_freq_mhz; uint16_t max_freq_mhz; uint16_t step_freq_mhz; }; -int ADDCALL hackrf_init_scan(hackrf_device* device, +int ADDCALL hackrf_init_sweep(hackrf_device* device, const uint16_t min_freq_mhz, const uint16_t max_freq_mhz, const uint16_t step_freq_mhz) { - struct init_scan_params params; + struct init_sweep_params params; uint8_t length; int result; params.min_freq_mhz = TO_LE(min_freq_mhz); params.max_freq_mhz = TO_LE(max_freq_mhz); params.step_freq_mhz = TO_LE(step_freq_mhz); - length = sizeof(struct init_scan_params); + length = sizeof(struct init_sweep_params); result = libusb_control_transfer( device->usb_device, LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, - HACKRF_VENDOR_REQUEST_INIT_SCAN, + HACKRF_VENDOR_REQUEST_INIT_SWEEP, 0, 0, (unsigned char*)¶ms, diff --git a/host/libhackrf/src/hackrf.h b/host/libhackrf/src/hackrf.h index fb0a4853..9fe11abb 100644 --- a/host/libhackrf/src/hackrf.h +++ b/host/libhackrf/src/hackrf.h @@ -197,7 +197,7 @@ extern ADDAPI uint32_t ADDCALL hackrf_compute_baseband_filter_bw_round_down_lt(c /* Compute best default value depending on sample rate (auto filter) */ extern ADDAPI uint32_t ADDCALL hackrf_compute_baseband_filter_bw(const uint32_t bandwidth_hz); /* Start scan mode */ -extern ADDAPI int ADDCALL hackrf_init_scan(hackrf_device* device, +extern ADDAPI int ADDCALL hackrf_init_sweep(hackrf_device* device, const uint16_t min_freq_mhz, const uint16_t max_freq_mhz, const uint16_t step_freq_mhz); From 6db1849b7465b1c250c8b9c9ed4d401657e3322d Mon Sep 17 00:00:00 2001 From: Dominic Spill Date: Thu, 28 Jul 2016 17:08:26 +0100 Subject: [PATCH 21/48] Add some fftw magic to proceedings --- host/cmake/modules/FindFFTW.cmake | 22 +++++++++++++++++ host/hackrf-tools/src/CMakeLists.txt | 1 + host/hackrf-tools/src/hackrf_sweep.c | 37 ++++++++++++++++++++++++++-- 3 files changed, 58 insertions(+), 2 deletions(-) create mode 100644 host/cmake/modules/FindFFTW.cmake diff --git a/host/cmake/modules/FindFFTW.cmake b/host/cmake/modules/FindFFTW.cmake new file mode 100644 index 00000000..00c3401c --- /dev/null +++ b/host/cmake/modules/FindFFTW.cmake @@ -0,0 +1,22 @@ +# - Find FFTW +# Find the native FFTW includes and library +# +# FFTW_INCLUDES - where to find fftw3.h +# FFTW_LIBRARIES - List of libraries when using FFTW. +# FFTW_FOUND - True if FFTW found. + +if (FFTW_INCLUDES) + # Already in cache, be silent + set (FFTW_FIND_QUIETLY TRUE) +endif (FFTW_INCLUDES) + +find_path (FFTW_INCLUDES fftw3.h) + +find_library (FFTW_LIBRARIES NAMES fftw3) + +# handle the QUIETLY and REQUIRED arguments and set FFTW_FOUND to TRUE if +# all listed variables are TRUE +include (FindPackageHandleStandardArgs) +find_package_handle_standard_args (FFTW DEFAULT_MSG FFTW_LIBRARIES FFTW_INCLUDES) + +mark_as_advanced (FFTW_LIBRARIES FFTW_INCLUDES) diff --git a/host/hackrf-tools/src/CMakeLists.txt b/host/hackrf-tools/src/CMakeLists.txt index 6f925cde..1873165c 100644 --- a/host/hackrf-tools/src/CMakeLists.txt +++ b/host/hackrf-tools/src/CMakeLists.txt @@ -64,6 +64,7 @@ if(MSVC) LIST(APPEND TOOLS_LINK_LIBS libgetopt_static) endif() +LIST(APPEND TOOLS_LINK_LIBS m fftw3f) target_link_libraries(hackrf_max2837 ${TOOLS_LINK_LIBS}) target_link_libraries(hackrf_si5351c ${TOOLS_LINK_LIBS}) diff --git a/host/hackrf-tools/src/hackrf_sweep.c b/host/hackrf-tools/src/hackrf_sweep.c index e2cab8d6..a71c2a9c 100644 --- a/host/hackrf-tools/src/hackrf_sweep.c +++ b/host/hackrf-tools/src/hackrf_sweep.c @@ -31,6 +31,8 @@ #include #include #include +#include +#include #ifndef bool typedef int bool; @@ -137,8 +139,11 @@ uint32_t amp_enable; bool antenna = false; uint32_t antenna_enable; -bool sample_rate = false; -uint32_t sample_rate_hz; +int fftSize; +fftwf_complex *fftwIn = NULL; +fftwf_complex *fftwOut = NULL; +fftwf_plan fftwPlan = NULL; +double* pwr; int rx_callback(hackrf_transfer* transfer) { /* This is where we need to do interesting things with the samples @@ -148,11 +153,33 @@ int rx_callback(hackrf_transfer* transfer) { */ ssize_t bytes_to_write; ssize_t bytes_written; + uint16_t* buf_short, frequency; + int i, j; if( fd != NULL ) { byte_count += transfer->valid_length; bytes_to_write = transfer->valid_length; + buf_short = (uint16_t*) transfer->buffer; + for(j=0; j<16; j++) { + if(buf_short[0] == 0x7F7F) { + frequency = buf_short[1]; + fprintf(stderr, "Received sweep buffer(%dMHz)\n", frequency); + } + /* copy to fftwIn as floats */ + buf_short = buf_short + 2; + for(i=0; i<2046; i+=2) { + fftwIn[i][0] = (float) buf_short[i]; + fftwIn[i][1] = (float) buf_short[i+1]; + } + buf_short = buf_short + 8190; + fftwf_execute(fftwPlan); + for (i=0; i < fftSize; i++) { + pwr[i] += pow(fftwOut[i][0], 2) + pow(fftwOut[i][1], 2); + fprintf(stderr, "%f\n", pwr[i]); + } + fprintf(stderr, "\n"); + } bytes_written = fwrite(transfer->buffer, 1, bytes_to_write, fd); if (bytes_written != bytes_to_write) { @@ -269,6 +296,12 @@ int main(int argc, char** argv) { return EXIT_FAILURE; } } + + fftSize = 2048; + fftwIn = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex) * fftSize); + fftwOut = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex) * fftSize); + fftwPlan = fftwf_plan_dft_1d(fftSize, fftwIn, fftwOut, FFTW_FORWARD, FFTW_MEASURE); + pwr = (double*)fftwf_malloc(sizeof(double) * fftSize); result = hackrf_init(); if( result != HACKRF_SUCCESS ) { From c73a1d56a7a3b6341206adda9c037146941009b8 Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Fri, 29 Jul 2016 02:31:08 +0100 Subject: [PATCH 22/48] Calculate log power --- host/hackrf-tools/src/hackrf_sweep.c | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/host/hackrf-tools/src/hackrf_sweep.c b/host/hackrf-tools/src/hackrf_sweep.c index a71c2a9c..7cae4c84 100644 --- a/host/hackrf-tools/src/hackrf_sweep.c +++ b/host/hackrf-tools/src/hackrf_sweep.c @@ -1,5 +1,6 @@ /* * Copyright 2016 Dominic Spill + * Copyright 2016 Mike Walters * * This file is part of HackRF. * @@ -143,7 +144,15 @@ int fftSize; fftwf_complex *fftwIn = NULL; fftwf_complex *fftwOut = NULL; fftwf_plan fftwPlan = NULL; -double* pwr; +float* pwr; + +float logPower(fftwf_complex in, float scale) +{ + float re = in[0] * scale; + float im = in[1] * scale; + float magsq = re * re + im * im; + return log2f(magsq) * 10.0f / log2(10.0f); +} int rx_callback(hackrf_transfer* transfer) { /* This is where we need to do interesting things with the samples @@ -175,7 +184,7 @@ int rx_callback(hackrf_transfer* transfer) { buf_short = buf_short + 8190; fftwf_execute(fftwPlan); for (i=0; i < fftSize; i++) { - pwr[i] += pow(fftwOut[i][0], 2) + pow(fftwOut[i][1], 2); + pwr[i] += logPower(fftwOut[i], 1.0f / fftSize); fprintf(stderr, "%f\n", pwr[i]); } fprintf(stderr, "\n"); @@ -301,7 +310,7 @@ int main(int argc, char** argv) { fftwIn = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex) * fftSize); fftwOut = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex) * fftSize); fftwPlan = fftwf_plan_dft_1d(fftSize, fftwIn, fftwOut, FFTW_FORWARD, FFTW_MEASURE); - pwr = (double*)fftwf_malloc(sizeof(double) * fftSize); + pwr = (float*)fftwf_malloc(sizeof(float) * fftSize); result = hackrf_init(); if( result != HACKRF_SUCCESS ) { From cb53e60a0dba33927cbe17e1350d82b50e143e9c Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Fri, 29 Jul 2016 02:31:16 +0100 Subject: [PATCH 23/48] Don't increment power --- host/hackrf-tools/src/hackrf_sweep.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/host/hackrf-tools/src/hackrf_sweep.c b/host/hackrf-tools/src/hackrf_sweep.c index 7cae4c84..a0c3a9ee 100644 --- a/host/hackrf-tools/src/hackrf_sweep.c +++ b/host/hackrf-tools/src/hackrf_sweep.c @@ -184,7 +184,7 @@ int rx_callback(hackrf_transfer* transfer) { buf_short = buf_short + 8190; fftwf_execute(fftwPlan); for (i=0; i < fftSize; i++) { - pwr[i] += logPower(fftwOut[i], 1.0f / fftSize); + pwr[i] = logPower(fftwOut[i], 1.0f / fftSize); fprintf(stderr, "%f\n", pwr[i]); } fprintf(stderr, "\n"); From a15bff3acf13e673fc49253081266dfe61906eb4 Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Fri, 29 Jul 2016 02:40:27 +0100 Subject: [PATCH 24/48] Scale input samples --- host/hackrf-tools/src/hackrf_sweep.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/host/hackrf-tools/src/hackrf_sweep.c b/host/hackrf-tools/src/hackrf_sweep.c index a0c3a9ee..21f94199 100644 --- a/host/hackrf-tools/src/hackrf_sweep.c +++ b/host/hackrf-tools/src/hackrf_sweep.c @@ -177,9 +177,9 @@ int rx_callback(hackrf_transfer* transfer) { } /* copy to fftwIn as floats */ buf_short = buf_short + 2; - for(i=0; i<2046; i+=2) { - fftwIn[i][0] = (float) buf_short[i]; - fftwIn[i][1] = (float) buf_short[i+1]; + for(i=0; i < fftSize; i+=2) { + fftwIn[i][0] = buf_short[i] / 128.0f; + fftwIn[i][1] = buf_short[i+1] / 128.0f; } buf_short = buf_short + 8190; fftwf_execute(fftwPlan); From 27b8f674dad7ab3dbdfc36e68bf82139df1ac556 Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Fri, 29 Jul 2016 02:40:41 +0100 Subject: [PATCH 25/48] Fix input copy loop --- host/hackrf-tools/src/hackrf_sweep.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/host/hackrf-tools/src/hackrf_sweep.c b/host/hackrf-tools/src/hackrf_sweep.c index 21f94199..0a6331c5 100644 --- a/host/hackrf-tools/src/hackrf_sweep.c +++ b/host/hackrf-tools/src/hackrf_sweep.c @@ -177,7 +177,7 @@ int rx_callback(hackrf_transfer* transfer) { } /* copy to fftwIn as floats */ buf_short = buf_short + 2; - for(i=0; i < fftSize; i+=2) { + for(i=0; i < fftSize; i++) { fftwIn[i][0] = buf_short[i] / 128.0f; fftwIn[i][1] = buf_short[i+1] / 128.0f; } From 1bd4c9a846be02ccabe4eb1f0cd9554d970ebd2c Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Fri, 29 Jul 2016 03:21:56 +0100 Subject: [PATCH 26/48] Rearrange fftw output --- host/hackrf-tools/src/hackrf_sweep.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/host/hackrf-tools/src/hackrf_sweep.c b/host/hackrf-tools/src/hackrf_sweep.c index 0a6331c5..59368521 100644 --- a/host/hackrf-tools/src/hackrf_sweep.c +++ b/host/hackrf-tools/src/hackrf_sweep.c @@ -184,8 +184,11 @@ int rx_callback(hackrf_transfer* transfer) { buf_short = buf_short + 8190; fftwf_execute(fftwPlan); for (i=0; i < fftSize; i++) { - pwr[i] = logPower(fftwOut[i], 1.0f / fftSize); - fprintf(stderr, "%f\n", pwr[i]); + // Start from the middle of the FFTW array and wrap + // to rearrange the data + int k = i ^ (fftSize >> 1); + pwr[i] = logPower(fftwOut[k], 1.0f / fftSize); + fprintf(stderr, "%f\n", pwr[i]); } fprintf(stderr, "\n"); } From cf64ccc058caee10f2f789e4137ac7a842a5e220 Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Fri, 29 Jul 2016 03:49:22 +0100 Subject: [PATCH 27/48] Fix up datatypes --- host/hackrf-tools/src/hackrf_sweep.c | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/host/hackrf-tools/src/hackrf_sweep.c b/host/hackrf-tools/src/hackrf_sweep.c index 59368521..2e76696b 100644 --- a/host/hackrf-tools/src/hackrf_sweep.c +++ b/host/hackrf-tools/src/hackrf_sweep.c @@ -162,26 +162,27 @@ int rx_callback(hackrf_transfer* transfer) { */ ssize_t bytes_to_write; ssize_t bytes_written; - uint16_t* buf_short, frequency; + int8_t* buf; + uint16_t frequency; int i, j; if( fd != NULL ) { byte_count += transfer->valid_length; bytes_to_write = transfer->valid_length; - buf_short = (uint16_t*) transfer->buffer; + buf = (int8_t*) transfer->buffer; for(j=0; j<16; j++) { - if(buf_short[0] == 0x7F7F) { - frequency = buf_short[1]; - fprintf(stderr, "Received sweep buffer(%dMHz)\n", frequency); + if(buf[0] == 0x7F && buf[1] == 0x7F) { + frequency = *(uint16_t*)&buf[2]; + fprintf(stderr, "Received sweep buffer(%uMHz)\n", frequency); } /* copy to fftwIn as floats */ - buf_short = buf_short + 2; + buf += 4; for(i=0; i < fftSize; i++) { - fftwIn[i][0] = buf_short[i] / 128.0f; - fftwIn[i][1] = buf_short[i+1] / 128.0f; + fftwIn[i][0] = buf[i*2] / 128.0f; + fftwIn[i][1] = buf[i*2+1] / 128.0f; } - buf_short = buf_short + 8190; + buf = buf + 8190; fftwf_execute(fftwPlan); for (i=0; i < fftSize; i++) { // Start from the middle of the FFTW array and wrap From d9b26c5ffa8d75e32e32fd89598b11387b43a769 Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Sat, 30 Jul 2016 06:24:57 +0100 Subject: [PATCH 28/48] Smaller FFT size --- host/hackrf-tools/src/hackrf_sweep.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/host/hackrf-tools/src/hackrf_sweep.c b/host/hackrf-tools/src/hackrf_sweep.c index 2e76696b..623c1366 100644 --- a/host/hackrf-tools/src/hackrf_sweep.c +++ b/host/hackrf-tools/src/hackrf_sweep.c @@ -310,7 +310,7 @@ int main(int argc, char** argv) { } } - fftSize = 2048; + fftSize = 32; fftwIn = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex) * fftSize); fftwOut = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex) * fftSize); fftwPlan = fftwf_plan_dft_1d(fftSize, fftwIn, fftwOut, FFTW_FORWARD, FFTW_MEASURE); From 316d7be6c298b68e915ed49f3e4498525ccac669 Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Sat, 30 Jul 2016 06:25:13 +0100 Subject: [PATCH 29/48] Write power values to stdout --- host/hackrf-tools/src/hackrf_sweep.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/host/hackrf-tools/src/hackrf_sweep.c b/host/hackrf-tools/src/hackrf_sweep.c index 623c1366..53eeba79 100644 --- a/host/hackrf-tools/src/hackrf_sweep.c +++ b/host/hackrf-tools/src/hackrf_sweep.c @@ -163,7 +163,7 @@ int rx_callback(hackrf_transfer* transfer) { ssize_t bytes_to_write; ssize_t bytes_written; int8_t* buf; - uint16_t frequency; + float frequency; int i, j; if( fd != NULL ) @@ -174,7 +174,6 @@ int rx_callback(hackrf_transfer* transfer) { for(j=0; j<16; j++) { if(buf[0] == 0x7F && buf[1] == 0x7F) { frequency = *(uint16_t*)&buf[2]; - fprintf(stderr, "Received sweep buffer(%uMHz)\n", frequency); } /* copy to fftwIn as floats */ buf += 4; @@ -189,9 +188,9 @@ int rx_callback(hackrf_transfer* transfer) { // to rearrange the data int k = i ^ (fftSize >> 1); pwr[i] = logPower(fftwOut[k], 1.0f / fftSize); - fprintf(stderr, "%f\n", pwr[i]); } - fprintf(stderr, "\n"); + fwrite(&frequency, sizeof(float), 1, stdout); + fwrite(pwr, sizeof(float), fftSize, stdout); } bytes_written = fwrite(transfer->buffer, 1, bytes_to_write, fd); From 3dc6742be2c8d40c8f2739d71fa3b438da6af72f Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Sat, 30 Jul 2016 08:02:48 +0100 Subject: [PATCH 30/48] Fix messed up buffer skip --- host/hackrf-tools/src/hackrf_sweep.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/host/hackrf-tools/src/hackrf_sweep.c b/host/hackrf-tools/src/hackrf_sweep.c index 53eeba79..0ef96929 100644 --- a/host/hackrf-tools/src/hackrf_sweep.c +++ b/host/hackrf-tools/src/hackrf_sweep.c @@ -181,7 +181,7 @@ int rx_callback(hackrf_transfer* transfer) { fftwIn[i][0] = buf[i*2] / 128.0f; fftwIn[i][1] = buf[i*2+1] / 128.0f; } - buf = buf + 8190; + buf = buf + 16380; fftwf_execute(fftwPlan); for (i=0; i < fftSize; i++) { // Start from the middle of the FFTW array and wrap From 62d06659f89f0f043d5f41fbdabab7f5e9cb4717 Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Sat, 30 Jul 2016 10:57:09 +0100 Subject: [PATCH 31/48] FFT size tweak again --- host/hackrf-tools/src/hackrf_sweep.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/host/hackrf-tools/src/hackrf_sweep.c b/host/hackrf-tools/src/hackrf_sweep.c index 0ef96929..295256f3 100644 --- a/host/hackrf-tools/src/hackrf_sweep.c +++ b/host/hackrf-tools/src/hackrf_sweep.c @@ -309,7 +309,7 @@ int main(int argc, char** argv) { } } - fftSize = 32; + fftSize = 64; fftwIn = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex) * fftSize); fftwOut = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex) * fftSize); fftwPlan = fftwf_plan_dft_1d(fftSize, fftwIn, fftwOut, FFTW_FORWARD, FFTW_MEASURE); From 8e21d5cba0efcf06ccf5e4d387a0bea0e06e6689 Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Sat, 30 Jul 2016 10:57:32 +0100 Subject: [PATCH 32/48] Skip first block after retune --- firmware/hackrf_usb/usb_api_sweep.c | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/firmware/hackrf_usb/usb_api_sweep.c b/firmware/hackrf_usb/usb_api_sweep.c index 1a7ad97c..6ae5a2e9 100644 --- a/firmware/hackrf_usb/usb_api_sweep.c +++ b/firmware/hackrf_usb/usb_api_sweep.c @@ -93,12 +93,13 @@ void sweep_mode(void) { if (transfer) { *(uint16_t*)buffer = 0x7F7F; *(uint16_t*)(buffer+2) = sweep_freq; - usb_transfer_schedule_block( - &usb_endpoint_bulk_in, - buffer, - 0x4000, - NULL, NULL - ); + if (blocks_queued > 1) + usb_transfer_schedule_block( + &usb_endpoint_bulk_in, + buffer, + 0x4000, + NULL, NULL + ); transfer = false; } From df6a7986cf28aabcecf52b6e921f4d5a1218328f Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Sat, 30 Jul 2016 10:58:25 +0100 Subject: [PATCH 33/48] DC offset hacks --- host/hackrf-tools/src/hackrf_sweep.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/host/hackrf-tools/src/hackrf_sweep.c b/host/hackrf-tools/src/hackrf_sweep.c index 295256f3..14d2b2dc 100644 --- a/host/hackrf-tools/src/hackrf_sweep.c +++ b/host/hackrf-tools/src/hackrf_sweep.c @@ -178,8 +178,8 @@ int rx_callback(hackrf_transfer* transfer) { /* copy to fftwIn as floats */ buf += 4; for(i=0; i < fftSize; i++) { - fftwIn[i][0] = buf[i*2] / 128.0f; - fftwIn[i][1] = buf[i*2+1] / 128.0f; + fftwIn[i][0] = buf[i*2] / 128.0f + 0.001f; + fftwIn[i][1] = buf[i*2+1] / 128.0f - 0.0067f; } buf = buf + 16380; fftwf_execute(fftwPlan); From 7935fc973f42a0275f202a4ad6f2c26047a2e39f Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Sat, 30 Jul 2016 14:50:49 +0100 Subject: [PATCH 34/48] Add -f argument for sweep freq range --- host/hackrf-tools/src/hackrf_sweep.c | 40 ++++++++++++++++++++++++++-- 1 file changed, 38 insertions(+), 2 deletions(-) diff --git a/host/hackrf-tools/src/hackrf_sweep.c b/host/hackrf-tools/src/hackrf_sweep.c index 14d2b2dc..1058b67f 100644 --- a/host/hackrf-tools/src/hackrf_sweep.c +++ b/host/hackrf-tools/src/hackrf_sweep.c @@ -126,6 +126,25 @@ int parse_u32(char* s, uint32_t* const value) { } } +int parse_u32_range(char* s, uint32_t* const value_min, uint32_t* const value_max) { + int result; + + char *sep = strchr(s, ':'); + if (!sep) + return HACKRF_ERROR_INVALID_PARAM; + + *sep = 0; + + result = parse_u32(s, value_min); + if (result != HACKRF_SUCCESS) + return result; + result = parse_u32(sep + 1, value_max); + if (result != HACKRF_SUCCESS); + return result; + + return HACKRF_SUCCESS; +} + volatile bool do_exit = false; FILE* fd = NULL; @@ -140,6 +159,10 @@ uint32_t amp_enable; bool antenna = false; uint32_t antenna_enable; +bool freq_range = false; +uint32_t freq_min; +uint32_t freq_max; + int fftSize; fftwf_complex *fftwIn = NULL; fftwf_complex *fftwOut = NULL; @@ -208,6 +231,7 @@ static void usage() { fprintf(stderr, "Usage:\n"); fprintf(stderr, "\t[-d serial_number] # Serial number of desired HackRF.\n"); fprintf(stderr, "\t[-a amp_enable] # RX/TX RF amplifier 1=Enable, 0=Disable.\n"); + fprintf(stderr, "\t[-f freq_min:freq_max # Specify minimum & maximum sweep frequencies (MHz).\n"); fprintf(stderr, "\t[-p antenna_enable] # Antenna port power, 1=Enable, 0=Disable.\n"); fprintf(stderr, "\t[-l gain_db] # RX LNA (IF) gain, 0-40dB, 8dB steps\n"); fprintf(stderr, "\t[-g gain_db] # RX VGA (baseband) gain, 0-62dB, 2dB steps\n"); @@ -243,7 +267,7 @@ int main(int argc, char** argv) { float time_diff; unsigned int lna_gain=8, vga_gain=20, txvga_gain=0; - while( (opt = getopt(argc, argv, "a:p:l:g:x:d:")) != EOF ) + while( (opt = getopt(argc, argv, "a:f:p:l:g:x:d:")) != EOF ) { result = HACKRF_SUCCESS; switch( opt ) @@ -257,6 +281,12 @@ int main(int argc, char** argv) { result = parse_u32(optarg, &_enable); break; + case 'f': + freq_range = true; + result = parse_u32_range(optarg, &freq_min, &freq_max); + fprintf(stderr, "Scanning %uMHz to %uMHz\n", freq_min, freq_max); + break; + case 'p': antenna = true; result = parse_u32(optarg, &antenna_enable); @@ -308,6 +338,12 @@ int main(int argc, char** argv) { return EXIT_FAILURE; } } + + if (!freq_range) { + fprintf(stderr, "argument error: must specify sweep frequency range (-f).\n"); + usage(); + return EXIT_FAILURE; + } fftSize = 64; fftwIn = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex) * fftSize); @@ -382,7 +418,7 @@ int main(int argc, char** argv) { } /* DGS FIXME: allow upper and lower frequencies to be set */ - result = hackrf_init_sweep(device, 50, 6000, 10); + result = hackrf_init_sweep(device, freq_min, freq_max, 20); if( result != HACKRF_SUCCESS ) { fprintf(stderr, "hackrf_init_scan() failed: %s (%d)\n", hackrf_error_name(result), result); From b6a7972916d1e5ccc932d854fa3588572c359337 Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Sat, 30 Jul 2016 14:56:15 +0100 Subject: [PATCH 35/48] Add extra fs/4 hops to overlap band-edges and DC spikes --- firmware/hackrf_usb/usb_api_sweep.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/firmware/hackrf_usb/usb_api_sweep.c b/firmware/hackrf_usb/usb_api_sweep.c index 6ae5a2e9..62f16af0 100644 --- a/firmware/hackrf_usb/usb_api_sweep.c +++ b/firmware/hackrf_usb/usb_api_sweep.c @@ -36,6 +36,7 @@ volatile bool start_sweep_mode = false; static uint64_t sweep_freq; +bool odd = true; struct init_sweep_params { uint16_t min_freq_mhz; @@ -104,8 +105,14 @@ void sweep_mode(void) { } if (blocks_queued > 2) { - sweep_freq += sweep_params.step_freq_mhz; + if (odd) + sweep_freq += sweep_params.step_freq_mhz / 4; + else + sweep_freq += 3 * (sweep_params.step_freq_mhz / 4); + odd = !odd; + if (sweep_freq > sweep_params.max_freq_mhz) { + odd = true; sweep_freq = sweep_params.min_freq_mhz; } set_freq(sweep_freq*FREQ_GRANULARITY); From d09e83e42316d5be595113c8bd3392ca88688a15 Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Sat, 30 Jul 2016 17:56:25 +0100 Subject: [PATCH 36/48] Revert "DC offset hacks" This reverts commit 96f680016f81b480bb2a66ec937be29185b26224. --- host/hackrf-tools/src/hackrf_sweep.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/host/hackrf-tools/src/hackrf_sweep.c b/host/hackrf-tools/src/hackrf_sweep.c index 1058b67f..1b597a2e 100644 --- a/host/hackrf-tools/src/hackrf_sweep.c +++ b/host/hackrf-tools/src/hackrf_sweep.c @@ -201,8 +201,8 @@ int rx_callback(hackrf_transfer* transfer) { /* copy to fftwIn as floats */ buf += 4; for(i=0; i < fftSize; i++) { - fftwIn[i][0] = buf[i*2] / 128.0f + 0.001f; - fftwIn[i][1] = buf[i*2+1] / 128.0f - 0.0067f; + fftwIn[i][0] = buf[i*2] / 128.0f; + fftwIn[i][1] = buf[i*2+1] / 128.0f; } buf = buf + 16380; fftwf_execute(fftwPlan); From a5a1c8ce70e73fcf344d9930839ab577ef481003 Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Sat, 30 Jul 2016 18:43:08 +0100 Subject: [PATCH 37/48] Apply window --- host/hackrf-tools/src/hackrf_sweep.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/host/hackrf-tools/src/hackrf_sweep.c b/host/hackrf-tools/src/hackrf_sweep.c index 1b597a2e..2ab1670f 100644 --- a/host/hackrf-tools/src/hackrf_sweep.c +++ b/host/hackrf-tools/src/hackrf_sweep.c @@ -168,6 +168,7 @@ fftwf_complex *fftwIn = NULL; fftwf_complex *fftwOut = NULL; fftwf_plan fftwPlan = NULL; float* pwr; +float* window; float logPower(fftwf_complex in, float scale) { @@ -201,8 +202,8 @@ int rx_callback(hackrf_transfer* transfer) { /* copy to fftwIn as floats */ buf += 4; for(i=0; i < fftSize; i++) { - fftwIn[i][0] = buf[i*2] / 128.0f; - fftwIn[i][1] = buf[i*2+1] / 128.0f; + fftwIn[i][0] = buf[i*2] * window[i] * 1.0f / 128.0f; + fftwIn[i][1] = buf[i*2+1] * window[i] * 1.0f / 128.0f; } buf = buf + 16380; fftwf_execute(fftwPlan); @@ -350,6 +351,11 @@ int main(int argc, char** argv) { fftwOut = (fftwf_complex*)fftwf_malloc(sizeof(fftwf_complex) * fftSize); fftwPlan = fftwf_plan_dft_1d(fftSize, fftwIn, fftwOut, FFTW_FORWARD, FFTW_MEASURE); pwr = (float*)fftwf_malloc(sizeof(float) * fftSize); + window = (float*)fftwf_malloc(sizeof(float) * fftSize); + int i; + for (i = 0; i < fftSize; i++) { + window[i] = 0.5f * (1.0f - cos(2 * M_PI * i / (fftSize - 1))); + } result = hackrf_init(); if( result != HACKRF_SUCCESS ) { From 39c15c93a97ad6bb7beec5246eefcc9b4f7985e8 Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Sat, 30 Jul 2016 18:43:33 +0100 Subject: [PATCH 38/48] Increase default gains --- host/hackrf-tools/src/hackrf_sweep.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/host/hackrf-tools/src/hackrf_sweep.c b/host/hackrf-tools/src/hackrf_sweep.c index 2ab1670f..d504f530 100644 --- a/host/hackrf-tools/src/hackrf_sweep.c +++ b/host/hackrf-tools/src/hackrf_sweep.c @@ -266,7 +266,7 @@ int main(int argc, char** argv) { int exit_code = EXIT_SUCCESS; struct timeval t_end; float time_diff; - unsigned int lna_gain=8, vga_gain=20, txvga_gain=0; + unsigned int lna_gain=20, vga_gain=20, txvga_gain=0; while( (opt = getopt(argc, argv, "a:f:p:l:g:x:d:")) != EOF ) { From 02eda1fd92ee0cdc428ed9baad00d6a0aae3efa5 Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Sat, 30 Jul 2016 18:43:43 +0100 Subject: [PATCH 39/48] Take samples from the end of the buffer --- host/hackrf-tools/src/hackrf_sweep.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/host/hackrf-tools/src/hackrf_sweep.c b/host/hackrf-tools/src/hackrf_sweep.c index d504f530..e5f95a53 100644 --- a/host/hackrf-tools/src/hackrf_sweep.c +++ b/host/hackrf-tools/src/hackrf_sweep.c @@ -200,12 +200,12 @@ int rx_callback(hackrf_transfer* transfer) { frequency = *(uint16_t*)&buf[2]; } /* copy to fftwIn as floats */ - buf += 4; + buf += 16384 - (fftSize * 2); for(i=0; i < fftSize; i++) { fftwIn[i][0] = buf[i*2] * window[i] * 1.0f / 128.0f; fftwIn[i][1] = buf[i*2+1] * window[i] * 1.0f / 128.0f; } - buf = buf + 16380; + buf += fftSize * 2; fftwf_execute(fftwPlan); for (i=0; i < fftSize; i++) { // Start from the middle of the FFTW array and wrap From 2d88fe4de33232760ab37ebd3fd3dc76d5f61b5d Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Sun, 31 Jul 2016 12:27:16 +0100 Subject: [PATCH 40/48] Reset enter_scan_mode to avoid going straight back into scan_mode --- firmware/hackrf_usb/hackrf_usb.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/firmware/hackrf_usb/hackrf_usb.c b/firmware/hackrf_usb/hackrf_usb.c index 05d3975f..ba31908a 100644 --- a/firmware/hackrf_usb/hackrf_usb.c +++ b/firmware/hackrf_usb/hackrf_usb.c @@ -183,8 +183,10 @@ int main(void) { cpld_update(); // Check whether we need to initiate sweep mode - if (start_sweep_mode) + if (start_sweep_mode) { + start_sweep_mode = false; sweep_mode(); + } // Set up IN transfer of buffer 0. if ( usb_bulk_buffer_offset >= 16384 From c127cdc0a477f3be0d4657801d6b946cdf87c5da Mon Sep 17 00:00:00 2001 From: Dominic Spill Date: Thu, 8 Sep 2016 17:10:39 +0100 Subject: [PATCH 41/48] Frequency list PoC --- firmware/hackrf_usb/usb_api_sweep.c | 40 +++++++++------------------- host/hackrf-tools/src/hackrf_sweep.c | 36 ++++++++++++++++--------- host/libhackrf/src/hackrf.c | 25 +++++------------ host/libhackrf/src/hackrf.h | 4 +-- 4 files changed, 44 insertions(+), 61 deletions(-) diff --git a/firmware/hackrf_usb/usb_api_sweep.c b/firmware/hackrf_usb/usb_api_sweep.c index 62f16af0..d2ee8ec5 100644 --- a/firmware/hackrf_usb/usb_api_sweep.c +++ b/firmware/hackrf_usb/usb_api_sweep.c @@ -33,33 +33,23 @@ #define FREQ_GRANULARITY 1000000 #define MIN_FREQ 1 #define MAX_FREQ 6000 +#define MAX_FREQ_COUNT 500 volatile bool start_sweep_mode = false; static uint64_t sweep_freq; bool odd = true; - -struct init_sweep_params { - uint16_t min_freq_mhz; - uint16_t max_freq_mhz; - uint16_t step_freq_mhz; -}; -struct init_sweep_params sweep_params; +static uint16_t frequencies[MAX_FREQ_COUNT]; +static uint16_t frequency_count = 0; usb_request_status_t usb_vendor_request_init_sweep( usb_endpoint_t* const endpoint, const usb_transfer_stage_t stage) { - if ((stage == USB_TRANSFER_STAGE_SETUP) && - (endpoint->setup.length == 6)) { - - usb_transfer_schedule_block(endpoint->out, &sweep_params, - sizeof(struct init_sweep_params), - NULL, NULL); + if (stage == USB_TRANSFER_STAGE_SETUP) { + frequency_count = endpoint->setup.length; + usb_transfer_schedule_block(endpoint->out, &frequencies, + endpoint->setup.length, NULL, NULL); } else if (stage == USB_TRANSFER_STAGE_DATA) { - /* Limit to min/max frequency without warning (possible FIXME) */ - sweep_params.min_freq_mhz = MAX(MIN_FREQ, sweep_params.min_freq_mhz); - sweep_params.max_freq_mhz = MIN(MAX_FREQ, sweep_params.max_freq_mhz); - - sweep_freq = sweep_params.min_freq_mhz; + sweep_freq = frequencies[0]; set_freq(sweep_freq*FREQ_GRANULARITY); start_sweep_mode = true; usb_transfer_schedule_ack(endpoint->in); @@ -70,6 +60,7 @@ usb_request_status_t usb_vendor_request_init_sweep( void sweep_mode(void) { unsigned int blocks_queued = 0; unsigned int phase = 0; + unsigned int ifreq = 0; uint8_t *buffer; bool transfer = false; @@ -105,16 +96,9 @@ void sweep_mode(void) { } if (blocks_queued > 2) { - if (odd) - sweep_freq += sweep_params.step_freq_mhz / 4; - else - sweep_freq += 3 * (sweep_params.step_freq_mhz / 4); - odd = !odd; - - if (sweep_freq > sweep_params.max_freq_mhz) { - odd = true; - sweep_freq = sweep_params.min_freq_mhz; - } + if(++ifreq >= frequency_count) + ifreq = 0; + sweep_freq = frequencies[ifreq]; set_freq(sweep_freq*FREQ_GRANULARITY); blocks_queued = 0; } diff --git a/host/hackrf-tools/src/hackrf_sweep.c b/host/hackrf-tools/src/hackrf_sweep.c index e5f95a53..014c2d18 100644 --- a/host/hackrf-tools/src/hackrf_sweep.c +++ b/host/hackrf-tools/src/hackrf_sweep.c @@ -91,6 +91,9 @@ int gettimeofday(struct timeval *tv, void* ignored) { #define DEFAULT_SAMPLE_RATE_HZ (20000000) /* 20MHz default sample rate */ #define DEFAULT_BASEBAND_FILTER_BANDWIDTH (15000000) /* 5MHz default */ +#define FREQ_STEP (DEFAULT_SAMPLE_RATE_HZ / FREQ_ONE_MHZ) +#define MAX_FREQ_COUNT 500 + #if defined _WIN32 #define sleep(a) Sleep( (a*1000) ) #endif @@ -139,7 +142,7 @@ int parse_u32_range(char* s, uint32_t* const value_min, uint32_t* const value_ma if (result != HACKRF_SUCCESS) return result; result = parse_u32(sep + 1, value_max); - if (result != HACKRF_SUCCESS); + if (result != HACKRF_SUCCESS) return result; return HACKRF_SUCCESS; @@ -159,7 +162,6 @@ uint32_t amp_enable; bool antenna = false; uint32_t antenna_enable; -bool freq_range = false; uint32_t freq_min; uint32_t freq_max; @@ -259,17 +261,17 @@ void sigint_callback_handler(int signum) { #endif int main(int argc, char** argv) { - int opt; + int opt, i, result, ifreq = 0; + bool odd; const char* path = "/dev/null"; const char* serial_number = NULL; - int result; int exit_code = EXIT_SUCCESS; struct timeval t_end; float time_diff; - unsigned int lna_gain=20, vga_gain=20, txvga_gain=0; - - while( (opt = getopt(argc, argv, "a:f:p:l:g:x:d:")) != EOF ) - { + unsigned int lna_gain=16, vga_gain=20, txvga_gain=0; + uint16_t frequencies[MAX_FREQ_COUNT]; + + while( (opt = getopt(argc, argv, "a:f:p:l:g:x:d:")) != EOF ) { result = HACKRF_SUCCESS; switch( opt ) { @@ -283,9 +285,18 @@ int main(int argc, char** argv) { break; case 'f': - freq_range = true; result = parse_u32_range(optarg, &freq_min, &freq_max); fprintf(stderr, "Scanning %uMHz to %uMHz\n", freq_min, freq_max); + frequencies[ifreq++] = freq_min; + odd = true; + while(frequencies[ifreq-1] <= freq_max) { + if (odd) + frequencies[ifreq] = frequencies[ifreq-1] + FREQ_STEP / 4; + else + frequencies[ifreq] = frequencies[ifreq-1] + 3*(FREQ_STEP/4); + ifreq++; + odd = !odd; + } break; case 'p': @@ -340,7 +351,7 @@ int main(int argc, char** argv) { } } - if (!freq_range) { + if (ifreq == 0) { fprintf(stderr, "argument error: must specify sweep frequency range (-f).\n"); usage(); return EXIT_FAILURE; @@ -352,7 +363,6 @@ int main(int argc, char** argv) { fftwPlan = fftwf_plan_dft_1d(fftSize, fftwIn, fftwOut, FFTW_FORWARD, FFTW_MEASURE); pwr = (float*)fftwf_malloc(sizeof(float) * fftSize); window = (float*)fftwf_malloc(sizeof(float) * fftSize); - int i; for (i = 0; i < fftSize; i++) { window[i] = 0.5f * (1.0f - cos(2 * M_PI * i / (fftSize - 1))); } @@ -424,9 +434,9 @@ int main(int argc, char** argv) { } /* DGS FIXME: allow upper and lower frequencies to be set */ - result = hackrf_init_sweep(device, freq_min, freq_max, 20); + result = hackrf_init_sweep(device, frequencies, ifreq); if( result != HACKRF_SUCCESS ) { - fprintf(stderr, "hackrf_init_scan() failed: %s (%d)\n", + fprintf(stderr, "hackrf_init_sweep() failed: %s (%d)\n", hackrf_error_name(result), result); usage(); return EXIT_FAILURE; diff --git a/host/libhackrf/src/hackrf.c b/host/libhackrf/src/hackrf.c index 41f36fee..59f0f2c6 100644 --- a/host/libhackrf/src/hackrf.c +++ b/host/libhackrf/src/hackrf.c @@ -1697,24 +1697,14 @@ uint32_t ADDCALL hackrf_compute_baseband_filter_bw(const uint32_t bandwidth_hz) return p->bandwidth_hz; } -struct init_sweep_params { - uint16_t min_freq_mhz; - uint16_t max_freq_mhz; - uint16_t step_freq_mhz; -}; - int ADDCALL hackrf_init_sweep(hackrf_device* device, - const uint16_t min_freq_mhz, const uint16_t max_freq_mhz, - const uint16_t step_freq_mhz) + uint16_t* frequency_list, + int length) { - struct init_sweep_params params; - uint8_t length; - int result; + int result, i; - params.min_freq_mhz = TO_LE(min_freq_mhz); - params.max_freq_mhz = TO_LE(max_freq_mhz); - params.step_freq_mhz = TO_LE(step_freq_mhz); - length = sizeof(struct init_sweep_params); + for(i=0; iusb_device, @@ -1722,13 +1712,12 @@ int ADDCALL hackrf_init_sweep(hackrf_device* device, HACKRF_VENDOR_REQUEST_INIT_SWEEP, 0, 0, - (unsigned char*)¶ms, + (unsigned char*)frequency_list, length, 0 ); - if (result < length) - { + if (result < length) { return HACKRF_ERROR_LIBUSB; } else { return HACKRF_SUCCESS; diff --git a/host/libhackrf/src/hackrf.h b/host/libhackrf/src/hackrf.h index 9fe11abb..54ad7092 100644 --- a/host/libhackrf/src/hackrf.h +++ b/host/libhackrf/src/hackrf.h @@ -198,8 +198,8 @@ extern ADDAPI uint32_t ADDCALL hackrf_compute_baseband_filter_bw_round_down_lt(c extern ADDAPI uint32_t ADDCALL hackrf_compute_baseband_filter_bw(const uint32_t bandwidth_hz); /* Start scan mode */ extern ADDAPI int ADDCALL hackrf_init_sweep(hackrf_device* device, - const uint16_t min_freq_mhz, const uint16_t max_freq_mhz, - const uint16_t step_freq_mhz); + uint16_t* frequency_list, + int length); #ifdef __cplusplus } // __cplusplus defined. From f7cd712ff9324a19ae9040fd527ffb5b93b606eb Mon Sep 17 00:00:00 2001 From: Mike Walters Date: Sun, 11 Sep 2016 15:52:29 +0100 Subject: [PATCH 42/48] Fix up frequency list size --- firmware/hackrf_usb/usb_api_sweep.c | 2 +- host/libhackrf/src/hackrf.c | 5 +++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/firmware/hackrf_usb/usb_api_sweep.c b/firmware/hackrf_usb/usb_api_sweep.c index d2ee8ec5..1b4e40dc 100644 --- a/firmware/hackrf_usb/usb_api_sweep.c +++ b/firmware/hackrf_usb/usb_api_sweep.c @@ -45,7 +45,7 @@ usb_request_status_t usb_vendor_request_init_sweep( usb_endpoint_t* const endpoint, const usb_transfer_stage_t stage) { if (stage == USB_TRANSFER_STAGE_SETUP) { - frequency_count = endpoint->setup.length; + frequency_count = endpoint->setup.length / sizeof(uint16_t); usb_transfer_schedule_block(endpoint->out, &frequencies, endpoint->setup.length, NULL, NULL); } else if (stage == USB_TRANSFER_STAGE_DATA) { diff --git a/host/libhackrf/src/hackrf.c b/host/libhackrf/src/hackrf.c index 59f0f2c6..539fd0a7 100644 --- a/host/libhackrf/src/hackrf.c +++ b/host/libhackrf/src/hackrf.c @@ -1702,6 +1702,7 @@ int ADDCALL hackrf_init_sweep(hackrf_device* device, int length) { int result, i; + int size = length * sizeof(frequency_list[0]); for(i=0; i Date: Thu, 15 Sep 2016 08:34:07 -0600 Subject: [PATCH 43/48] Extend frequency array to allow 6GHz sweeping --- firmware/hackrf_usb/usb_api_sweep.c | 2 +- host/hackrf-tools/src/hackrf_sweep.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/firmware/hackrf_usb/usb_api_sweep.c b/firmware/hackrf_usb/usb_api_sweep.c index 1b4e40dc..88a065d1 100644 --- a/firmware/hackrf_usb/usb_api_sweep.c +++ b/firmware/hackrf_usb/usb_api_sweep.c @@ -33,7 +33,7 @@ #define FREQ_GRANULARITY 1000000 #define MIN_FREQ 1 #define MAX_FREQ 6000 -#define MAX_FREQ_COUNT 500 +#define MAX_FREQ_COUNT 1000 volatile bool start_sweep_mode = false; static uint64_t sweep_freq; diff --git a/host/hackrf-tools/src/hackrf_sweep.c b/host/hackrf-tools/src/hackrf_sweep.c index 014c2d18..dda62c1d 100644 --- a/host/hackrf-tools/src/hackrf_sweep.c +++ b/host/hackrf-tools/src/hackrf_sweep.c @@ -92,7 +92,7 @@ int gettimeofday(struct timeval *tv, void* ignored) { #define DEFAULT_BASEBAND_FILTER_BANDWIDTH (15000000) /* 5MHz default */ #define FREQ_STEP (DEFAULT_SAMPLE_RATE_HZ / FREQ_ONE_MHZ) -#define MAX_FREQ_COUNT 500 +#define MAX_FREQ_COUNT 1000 #if defined _WIN32 #define sleep(a) Sleep( (a*1000) ) From a95d1ac027621048cad8104ac6fa618086c6d077 Mon Sep 17 00:00:00 2001 From: Dominic Spill Date: Sun, 18 Sep 2016 22:36:31 -0600 Subject: [PATCH 44/48] Add dwell time argument to hackrf sweep - untested because I'm not able to fire up my HackRF right now --- firmware/hackrf_usb/usb_api_sweep.c | 6 +++++- host/hackrf-tools/CMakeLists.txt | 2 +- host/hackrf-tools/src/hackrf_sweep.c | 18 +++++++++++++++--- host/libhackrf/src/hackrf.c | 6 +++--- host/libhackrf/src/hackrf.h | 2 +- 5 files changed, 25 insertions(+), 9 deletions(-) diff --git a/firmware/hackrf_usb/usb_api_sweep.c b/firmware/hackrf_usb/usb_api_sweep.c index 88a065d1..434b7fdc 100644 --- a/firmware/hackrf_usb/usb_api_sweep.c +++ b/firmware/hackrf_usb/usb_api_sweep.c @@ -40,11 +40,15 @@ static uint64_t sweep_freq; bool odd = true; static uint16_t frequencies[MAX_FREQ_COUNT]; static uint16_t frequency_count = 0; +static uint32_t dwell_blocks = 0; usb_request_status_t usb_vendor_request_init_sweep( usb_endpoint_t* const endpoint, const usb_transfer_stage_t stage) { + uint32_t dwell_time; if (stage == USB_TRANSFER_STAGE_SETUP) { + dwell_time = (endpoint->setup.index << 16) | endpoint->setup.value; + dwell_blocks = dwell_time / 0x4000; frequency_count = endpoint->setup.length / sizeof(uint16_t); usb_transfer_schedule_block(endpoint->out, &frequencies, endpoint->setup.length, NULL, NULL); @@ -95,7 +99,7 @@ void sweep_mode(void) { transfer = false; } - if (blocks_queued > 2) { + if (blocks_queued >= dwell_blocks) { if(++ifreq >= frequency_count) ifreq = 0; sweep_freq = frequencies[ifreq]; diff --git a/host/hackrf-tools/CMakeLists.txt b/host/hackrf-tools/CMakeLists.txt index cc7ff9be..82ea47d8 100644 --- a/host/hackrf-tools/CMakeLists.txt +++ b/host/hackrf-tools/CMakeLists.txt @@ -24,7 +24,7 @@ cmake_minimum_required(VERSION 2.8) project(hackrf-tools C) set(MAJOR_VERSION 0) -set(MINOR_VERSION 4) +set(MINOR_VERSION 5) set(PACKAGE hackrf-tools) set(VERSION_STRING ${MAJOR_VERSION}.${MINOR_VERSION}) set(VERSION ${VERSION_STRING}) diff --git a/host/hackrf-tools/src/hackrf_sweep.c b/host/hackrf-tools/src/hackrf_sweep.c index dda62c1d..59127e7d 100644 --- a/host/hackrf-tools/src/hackrf_sweep.c +++ b/host/hackrf-tools/src/hackrf_sweep.c @@ -94,6 +94,8 @@ int gettimeofday(struct timeval *tv, void* ignored) { #define FREQ_STEP (DEFAULT_SAMPLE_RATE_HZ / FREQ_ONE_MHZ) #define MAX_FREQ_COUNT 1000 +#define DEFAULT_DWELL_TIME 0x4000 + #if defined _WIN32 #define sleep(a) Sleep( (a*1000) ) #endif @@ -239,6 +241,7 @@ static void usage() { fprintf(stderr, "\t[-l gain_db] # RX LNA (IF) gain, 0-40dB, 8dB steps\n"); fprintf(stderr, "\t[-g gain_db] # RX VGA (baseband) gain, 0-62dB, 2dB steps\n"); fprintf(stderr, "\t[-x gain_db] # TX VGA (IF) gain, 0-47dB, 1dB steps\n"); + fprintf(stderr, "\t[-s dwell_time] # Dwell time in samples, 0-%lu\n", (uint64_t)1<<32); } static hackrf_device* device = NULL; @@ -270,8 +273,9 @@ int main(int argc, char** argv) { float time_diff; unsigned int lna_gain=16, vga_gain=20, txvga_gain=0; uint16_t frequencies[MAX_FREQ_COUNT]; + uint32_t dwell_time = DEFAULT_DWELL_TIME; - while( (opt = getopt(argc, argv, "a:f:p:l:g:x:d:")) != EOF ) { + while( (opt = getopt(argc, argv, "a:f:p:l:g:x:d:s:")) != EOF ) { result = HACKRF_SUCCESS; switch( opt ) { @@ -316,6 +320,10 @@ int main(int argc, char** argv) { result = parse_u32(optarg, &txvga_gain); break; + case 's': + result = parse_u32(optarg, &dwell_time); + break; + default: fprintf(stderr, "unknown argument '-%c %s'\n", opt, optarg); usage(); @@ -335,6 +343,11 @@ int main(int argc, char** argv) { if (vga_gain % 2) fprintf(stderr, "warning: vga_gain (-g) must be a multiple of 2\n"); + if (dwell_time % 0x4000) { + fprintf(stderr, "warning: dwell_time (-s) must be a multiple of 16384\n"); + return EXIT_FAILURE; + } + if( amp ) { if( amp_enable > 1 ) { fprintf(stderr, "argument error: amp_enable shall be 0 or 1.\n"); @@ -433,8 +446,7 @@ int main(int argc, char** argv) { return EXIT_FAILURE; } - /* DGS FIXME: allow upper and lower frequencies to be set */ - result = hackrf_init_sweep(device, frequencies, ifreq); + result = hackrf_init_sweep(device, frequencies, ifreq, dwell_time); if( result != HACKRF_SUCCESS ) { fprintf(stderr, "hackrf_init_sweep() failed: %s (%d)\n", hackrf_error_name(result), result); diff --git a/host/libhackrf/src/hackrf.c b/host/libhackrf/src/hackrf.c index 539fd0a7..fffb04e5 100644 --- a/host/libhackrf/src/hackrf.c +++ b/host/libhackrf/src/hackrf.c @@ -1699,7 +1699,7 @@ uint32_t ADDCALL hackrf_compute_baseband_filter_bw(const uint32_t bandwidth_hz) int ADDCALL hackrf_init_sweep(hackrf_device* device, uint16_t* frequency_list, - int length) + int length, uint32_t dwell_time) { int result, i; int size = length * sizeof(frequency_list[0]); @@ -1711,8 +1711,8 @@ int ADDCALL hackrf_init_sweep(hackrf_device* device, device->usb_device, LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, HACKRF_VENDOR_REQUEST_INIT_SWEEP, - 0, - 0, + dwell_time & 0xff, + (dwell_time >> 16) & 0xff, (unsigned char*)frequency_list, size, 0 diff --git a/host/libhackrf/src/hackrf.h b/host/libhackrf/src/hackrf.h index 54ad7092..a318f6ed 100644 --- a/host/libhackrf/src/hackrf.h +++ b/host/libhackrf/src/hackrf.h @@ -199,7 +199,7 @@ extern ADDAPI uint32_t ADDCALL hackrf_compute_baseband_filter_bw(const uint32_t /* Start scan mode */ extern ADDAPI int ADDCALL hackrf_init_sweep(hackrf_device* device, uint16_t* frequency_list, - int length); + int length, uint32_t dwell_time); #ifdef __cplusplus } // __cplusplus defined. From 146445483511ec6662e358c862afe3d0ba36d4b3 Mon Sep 17 00:00:00 2001 From: Dominic Spill Date: Sun, 2 Oct 2016 19:17:03 +0100 Subject: [PATCH 45/48] Change dwell_time to num_samples --- host/hackrf-tools/src/hackrf_sweep.c | 16 ++++++++-------- host/libhackrf/src/hackrf.c | 8 +++----- 2 files changed, 11 insertions(+), 13 deletions(-) diff --git a/host/hackrf-tools/src/hackrf_sweep.c b/host/hackrf-tools/src/hackrf_sweep.c index 59127e7d..13fe9f78 100644 --- a/host/hackrf-tools/src/hackrf_sweep.c +++ b/host/hackrf-tools/src/hackrf_sweep.c @@ -94,7 +94,7 @@ int gettimeofday(struct timeval *tv, void* ignored) { #define FREQ_STEP (DEFAULT_SAMPLE_RATE_HZ / FREQ_ONE_MHZ) #define MAX_FREQ_COUNT 1000 -#define DEFAULT_DWELL_TIME 0x4000 +#define DEFAULT_SAMPLE_COUNT 0x4000 #if defined _WIN32 #define sleep(a) Sleep( (a*1000) ) @@ -241,7 +241,7 @@ static void usage() { fprintf(stderr, "\t[-l gain_db] # RX LNA (IF) gain, 0-40dB, 8dB steps\n"); fprintf(stderr, "\t[-g gain_db] # RX VGA (baseband) gain, 0-62dB, 2dB steps\n"); fprintf(stderr, "\t[-x gain_db] # TX VGA (IF) gain, 0-47dB, 1dB steps\n"); - fprintf(stderr, "\t[-s dwell_time] # Dwell time in samples, 0-%lu\n", (uint64_t)1<<32); + fprintf(stderr, "\t[-n num_samples] # Number of samples per frequency, 0-%lu\n", (uint64_t)1<<32); } static hackrf_device* device = NULL; @@ -273,7 +273,7 @@ int main(int argc, char** argv) { float time_diff; unsigned int lna_gain=16, vga_gain=20, txvga_gain=0; uint16_t frequencies[MAX_FREQ_COUNT]; - uint32_t dwell_time = DEFAULT_DWELL_TIME; + uint32_t num_samples = DEFAULT_SAMPLE_COUNT; while( (opt = getopt(argc, argv, "a:f:p:l:g:x:d:s:")) != EOF ) { result = HACKRF_SUCCESS; @@ -320,8 +320,8 @@ int main(int argc, char** argv) { result = parse_u32(optarg, &txvga_gain); break; - case 's': - result = parse_u32(optarg, &dwell_time); + case 'n': + result = parse_u32(optarg, &num_samples); break; default: @@ -343,8 +343,8 @@ int main(int argc, char** argv) { if (vga_gain % 2) fprintf(stderr, "warning: vga_gain (-g) must be a multiple of 2\n"); - if (dwell_time % 0x4000) { - fprintf(stderr, "warning: dwell_time (-s) must be a multiple of 16384\n"); + if (num_samples % 0x4000) { + fprintf(stderr, "warning: num_samples (-s) must be a multiple of 16384\n"); return EXIT_FAILURE; } @@ -446,7 +446,7 @@ int main(int argc, char** argv) { return EXIT_FAILURE; } - result = hackrf_init_sweep(device, frequencies, ifreq, dwell_time); + result = hackrf_init_sweep(device, frequencies, ifreq, num_samples); if( result != HACKRF_SUCCESS ) { fprintf(stderr, "hackrf_init_sweep() failed: %s (%d)\n", hackrf_error_name(result), result); diff --git a/host/libhackrf/src/hackrf.c b/host/libhackrf/src/hackrf.c index fffb04e5..65bec61c 100644 --- a/host/libhackrf/src/hackrf.c +++ b/host/libhackrf/src/hackrf.c @@ -1697,9 +1697,7 @@ uint32_t ADDCALL hackrf_compute_baseband_filter_bw(const uint32_t bandwidth_hz) return p->bandwidth_hz; } -int ADDCALL hackrf_init_sweep(hackrf_device* device, - uint16_t* frequency_list, - int length, uint32_t dwell_time) +int ADDCALL hackrf_init_sweep(hackrf_device* device, uint16_t* frequency_list, int length, uint32_t dwell_time) { int result, i; int size = length * sizeof(frequency_list[0]); @@ -1711,8 +1709,8 @@ int ADDCALL hackrf_init_sweep(hackrf_device* device, device->usb_device, LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, HACKRF_VENDOR_REQUEST_INIT_SWEEP, - dwell_time & 0xff, - (dwell_time >> 16) & 0xff, + dwell_time & 0xffff, + (dwell_time >> 16) & 0xffff, (unsigned char*)frequency_list, size, 0 From 6639ab3e0966cd6a09c6e50016a16e8c43fee213 Mon Sep 17 00:00:00 2001 From: Dominic Spill Date: Mon, 3 Oct 2016 12:34:38 +0100 Subject: [PATCH 46/48] Fix argument parsing for num_samples --- host/hackrf-tools/src/hackrf_sweep.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/host/hackrf-tools/src/hackrf_sweep.c b/host/hackrf-tools/src/hackrf_sweep.c index 13fe9f78..220c1d2c 100644 --- a/host/hackrf-tools/src/hackrf_sweep.c +++ b/host/hackrf-tools/src/hackrf_sweep.c @@ -194,8 +194,7 @@ int rx_callback(hackrf_transfer* transfer) { float frequency; int i, j; - if( fd != NULL ) - { + if( fd != NULL ) { byte_count += transfer->valid_length; bytes_to_write = transfer->valid_length; buf = (int8_t*) transfer->buffer; @@ -275,7 +274,7 @@ int main(int argc, char** argv) { uint16_t frequencies[MAX_FREQ_COUNT]; uint32_t num_samples = DEFAULT_SAMPLE_COUNT; - while( (opt = getopt(argc, argv, "a:f:p:l:g:x:d:s:")) != EOF ) { + while( (opt = getopt(argc, argv, "a:f:p:l:g:x:d:n:")) != EOF ) { result = HACKRF_SUCCESS; switch( opt ) { From 6b831d31cc15c323ba035183ff425b3980a9378c Mon Sep 17 00:00:00 2001 From: Dominic Spill Date: Mon, 3 Oct 2016 12:39:30 +0100 Subject: [PATCH 47/48] Stop dropping buffers in firmware and allow the host to make the decision. --- firmware/hackrf_usb/usb_api_sweep.c | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/firmware/hackrf_usb/usb_api_sweep.c b/firmware/hackrf_usb/usb_api_sweep.c index 434b7fdc..581faacc 100644 --- a/firmware/hackrf_usb/usb_api_sweep.c +++ b/firmware/hackrf_usb/usb_api_sweep.c @@ -89,13 +89,12 @@ void sweep_mode(void) { if (transfer) { *(uint16_t*)buffer = 0x7F7F; *(uint16_t*)(buffer+2) = sweep_freq; - if (blocks_queued > 1) - usb_transfer_schedule_block( - &usb_endpoint_bulk_in, - buffer, - 0x4000, - NULL, NULL - ); + usb_transfer_schedule_block( + &usb_endpoint_bulk_in, + buffer, + 0x4000, + NULL, NULL + ); transfer = false; } From 7e7ce3dff1a97190ca54f1f6387faa5fe327cd7a Mon Sep 17 00:00:00 2001 From: Michael Ossmann Date: Mon, 23 Jan 2017 16:31:32 -0700 Subject: [PATCH 48/48] removed pre-libhackrf python host code --- host/python/max2837_dump.py | 53 ---------------------------- host/python/set_transceiver_mode.py | 54 ----------------------------- 2 files changed, 107 deletions(-) delete mode 100755 host/python/max2837_dump.py delete mode 100755 host/python/set_transceiver_mode.py diff --git a/host/python/max2837_dump.py b/host/python/max2837_dump.py deleted file mode 100755 index 6624737b..00000000 --- a/host/python/max2837_dump.py +++ /dev/null @@ -1,53 +0,0 @@ -#!/usr/bin/env python -# -# Copyright 2012 Jared Boone -# -# This file is part of HackRF. -# -# This program is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 2, or (at your option) -# any later version. -# -# This program is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with this program; see the file COPYING. If not, write to -# the Free Software Foundation, Inc., 51 Franklin Street, -# Boston, MA 02110-1301, USA. -# - -import usb -import struct -import sys - -device = usb.core.find(idVendor=0x1d50, idProduct=0x604b) -if device: - print 'Find: HackRF Jawbreaker' -else: - device = usb.core.find(idVendor=0x1d50, idProduct=0x6089) - if device: - print 'Find: HackRF One' - else: - device = usb.core.find(idVendor=0x1d50, idProduct=0xcc15) - if device: - print 'Find: rad1o' - else: - print 'Not find any HackRF device.' - sys.exit() -device.set_configuration() - -def read_max2837_register(register_number): - return struct.unpack('