osmocom-sdr

osmocom-sdr@lists.osmocom.org

1 participants
908 discussions

Fwd: Raspberry Pi 5 + RTL-SDR Blog V4 – rtl_* CLI tools produce zero output
by Bodó Richárd 03 Jan '26

03 Jan '26

Subject: Raspberry Pi 5 + RTL-SDR Blog V4 – rtl_* CLI tools produce zero output Dear Developers, I would like to report a reproducible issue observed with a Raspberry Pi 5 and an RTL-SDR Blog V4 device. *Hardware setup:* Raspberry Pi 5 (8 GB) RTL-SDR Blog V4 Direct USB connection (no external hub) Adequate power supply (official Raspberry Pi 5 power supply) *Software environment:* Raspberry Pi OS 64-bit (Bookworm) rtl-sdr package (rtl_sdr, rtl_fm, rtl_power) librtlsdr installed via distribution packages Fully updated kernel and system *Issue description:* rtl_test -p runs successfully USB streaming is active and samples are reported PLL lock messages are shown and the device appears stable *However, the following CLI tools produce no output data:* rtl_sdr rtl_fm rtl_power Output files remain at 0 bytes Processes run without errors, but no IQ samples or audio data are produced *Important observation:* The same RTL-SDR Blog V4 device works correctly on Raspberry Pi 3 and Raspberry Pi 4 systems using the same software stack. *Conclusion:* Based on testing, this appears to be an interaction issue between the Raspberry Pi 5 USB subsystem and/or kernel, librtlsdr, and the RTL-SDR Blog V4. Since rtl_test confirms that USB streaming is functional, the problem seems to occur at the level of sample delivery or processing in the CLI tools. I am happy to provide logs, detailed version information, or perform additional tests if required. Thank you for your time and for maintaining these tools. Kind regards, An RTL-SDR user P.S. My original goal was to develop an Airband (voice) scanner application with the help of ChatGPT, capable of scanning and monitoring airband frequencies. Neither the RTL-SDR Blog V3 nor the V4 worked as expected on the Raspberry Pi 5 during this effort. Based on recommendations, I specifically purchased an RTL-SDR Blog V4 because it was expected to be better aligned with the Raspberry Pi 5 USB implementation. This report is the result of several days of systematic testing and comparison across different Raspberry Pi models. The device enumerates correctly on USB and remains stable during operation. rtl_test confirms continuous sample streaming, indicating that bulk USB transfers are functional. No kernel errors, USB resets, or xHCI faults are observed in dmesg during runtime. The issue appears after device initialization, at the stage where librtlsdr-based tools should consume and process the incoming samples. USB-related kernel and firmware boot parameters were reviewed and adjusted via /boot/firmware/cmdline.txt, including settings related to USB behavior and buffering; these changes did not alter the observed issue. This suggests a possible interaction issue between the Raspberry Pi 5 USB/xHCI implementation, kernel behavior, and librtlsdr buffer handling rather than a physical USB or power problem uname -a lsusb lsusb -t dmesg | grep -i usb rtl_test -p rtl_sdr test.iq rtl_fm -f 118M -M am -s 240k - rtl_power -f 118M:137M:25k test.csv I did not purchase the Raspberry Pi 5 and the RTL-SDR Blog V4 as experimental or disposable hardware. This report is submitted in good faith, with the expectation that this platform can be made fully functional through proper investigation and resolution

1 0

rtl_fm Change cb transfer status: X, canceling...
by Ramon Smits 26 Dec '25

26 Dec '25

I occasionally get the error "cb transfer status: 1, canceling...". This usually is because something bumped my pi causing the RTLSDR dongle to move. rtl_fm nicely emits to ERROUT but remains running. I think this is likely an error. I would expect the process to die in this state. Is this reasoning correct? I made a change with claude.ai , it removed invoking `rtlsdr_cancel_async(dev);` === Why this fixes the halt: The callback was calling rtlsdr_cancel_async() while already executing inside the libusb_handle_events_timeout_completed() loop (line 1924), which would modify the dev->async_cancel flag that the event handler was actively monitoring. This created a deadlock/race condition. Now the callback simply sets the dev->dev_lost flag, and the main event loop at line 1961 properly detects this condition and breaks out cleanly, allowing normal termination to occur. The process should now terminate correctly when USB transfer errors occur. === The change is available at https://github.com/osmocom/rtl-sdr/compare/master...ramonsmits:rtl-sdr:rtls… Does this change make any sense? I have not fully tested this as I'm new to this project and somehow need to build this and deploy on my pi4 which I need to figure out. Any help appreciated! -- Ramon

1 1

deadline extension: FOSDEM 2026 (Feb. 1 2026): call for contributions on SDR/DSP (deadlineDec. 1 2025)
by jmfriedt 17 Nov '25

17 Nov '25

The Software Defined Radio/Digital Signal Processing (SDR/DSP) devroom is being organized for the 2026 FOSDEM held in Brussels (Belgium) Sunday Feb. 1, 2026. Any topic or achievement from the last year that you would be proud to share with the community? A few slots for the SDR/DSP devroom are still available, so the submission deadline is extended by a couple of weeks. We are seeking contributions discussing FOSS software for (radiofrequency) discrete time digital signal processing/software defined radio (SDR) including digital communication and data integrity (CRC calculation, Forward Error Correction -- FEC), communication channel characterization, navigation and positioning, target ranging and velocity measurement, and signal characteristics extraction from raw IQ collected from single or multiple antennas, as well as software frameworks easing such applications including GNU Radio, FutureSDR, Pothosware or custom frameworks. Novel openhardware description, possibly including the latest acceleration peripherals including FPGA and GPUs (or others), is encouraged, especially if using FOSS frameworks, but maybe also demonstrating how a radiofrequency grade oscilloscope can make an excellent (discontinuous stream) SDR receiver. Proposals should be submitted through https://pretalx.fosdem.org/fosdem-2026/ December 1st at latest, or 2 weeks from now. See you in Brussels, Jean-Michel

1 0

FOSDEM 2026 (Feb. 1 2026): call for contributions on SDR/DSP (deadline Nov. 15 2025)
by friedtj＠free.fr 01 Nov '25

01 Nov '25

The Software Defined Radio/Digital Signal Processing (SDR/DSP) devroom is being organized for the 2026 FOSDEM held in Brussels (Belgium) Sunday Feb. 1, 2026. We are seeking contributions discussing FOSS software for (radiofrequency) discrete time digital signal processing/software defined radio (SDR) including digital communication and data integrity (CRC calculation, Forward Error Correction -- FEC), communication channel characterization, navigation and positioning, target ranging and velocity measurement, and signal characteristics extraction from raw IQ collected from single or multiple antennas, as well as software frameworks easing such applications including GNU Radio, FutureSDR, Pothosware or custom frameworks. Novel openhardware description, possibly including the latest acceleration peripherals including FPGA and GPUs (or others), is encouraged, especially if using FOSS frameworks, but maybe also demonstrating how a radiofrequency grade oscilloscope can make an excellent (discontinuous stream) SDR receiver. Proposals should be submitted through https://pretalx.fosdem.org by November 15 at latest, or 2 weeks from now. See you in Brussels, Jean-Michel

1 0

[Patch][Add] Support for the new HydraSDR
by sebastien.dudek＠penthertz.com 22 Jun '25

22 Jun '25

Hello, I hope it will go in the right place, here you can find a patch adding HydraSDR device support that upgrades the AirSpy R2. I had to create wrappers around GPIOs definition as putting the headers in namespace was a failure at run time. Indeed, the GPIOs have same references for now and this is the only clean way I've found to support both AirSpy and HydraSDR without disabling one of each. Please find the patch here that is also directly available and working on rfswift.io through this repo https://github.com/PentHertz/gr-osmosdr: ############################################################################ diff --git a/AUTHORS b/AUTHORS index 2fd882c..590b6db 100644 --- a/AUTHORS +++ b/AUTHORS @@ -7,3 +7,4 @@ SDRplay Ltd. Pavel Demin Marcus Müller Lukas Lao Beyer +Penthertz folks diff --git a/CMakeLists.txt b/CMakeLists.txt index 3a6b0da..6d86c8e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -171,6 +171,7 @@ endif(ENABLE_NONFREE) find_package(LibHackRF) find_package(LibAIRSPY) find_package(LibAIRSPYHF) +find_package(LibHYDRASDR) find_package(LibbladeRF) find_package(GnuradioFuncube) find_package(SoapySDR NO_MODULE) diff --git a/cmake/Modules/FindLibHYDRASDR.cmake b/cmake/Modules/FindLibHYDRASDR.cmake new file mode 100644 index 0000000..1b11d72 --- /dev/null +++ b/cmake/Modules/FindLibHYDRASDR.cmake @@ -0,0 +1,42 @@ +if(NOT PKG_CONFIG_FOUND) + INCLUDE(FindPkgConfig) +endif() +PKG_CHECK_MODULES(PC_LIBHYDRASDR libhydrasdr) + +message("Debug: Running PKG_CHECK_MODULES for libhydrasdr") +PKG_CHECK_MODULES(PC_LIBHYDRASDR libhydrasdr) +message("Debug: PC_LIBHYDRASDR_FOUND=${PC_LIBHYDRASDR_FOUND}") +message("Debug: PC_LIBHYDRASDR_INCLUDEDIR=${PC_LIBHYDRASDR_INCLUDEDIR}") +message("Debug: PC_LIBHYDRASDR_LIBDIR=${PC_LIBHYDRASDR_LIBDIR}") + +message("Debug: Looking for libhydrasdr/hydrasdr.h") + +FIND_PATH( +LIBHYDRASDR_INCLUDE_DIRS + NAMES libhydrasdr/hydrasdr.h + HINTS $ENV{LIBHYDRASDR_DIR}/include + ${PC_LIBHYDRASDR_INCLUDEDIR} + PATHS /usr/local/include + /usr/include +) + +message("Debug: LIBHYDRASDR_INCLUDE_DIRS=${LIBHYDRASDR_INCLUDE_DIRS}") +message("Debug: Looking for hydrasdr library") + +FIND_LIBRARY( + LIBHYDRASDR_LIBRARIES + NAMES hydrasdr + HINTS $ENV{LIBHYDRASDR_DIR}/lib + ${PC_LIBHYDRASDR_LIBDIR} + PATHS /usr/local/lib + /usr/lib +) + +message("Debug: LIBHYDRASDR_LIBRARIES=${LIBHYDRASDR_LIBRARIES}") + +INCLUDE(FindPackageHandleStandardArgs) +FIND_PACKAGE_HANDLE_STANDARD_ARGS(LibHYDRASDR DEFAULT_MSG LIBHYDRASDR_LIBRARIES LIBHYDRASDR_INCLUDE_DIRS) +MARK_AS_ADVANCED(LIBHYDRASDR_LIBRARIES LIBHYDRASDR_INCLUDE_DIRS) + +message("Debug: LibHYDRASDR_FOUND=${LibHYDRASDR_FOUND}") +message("Debug: LIBHYDRASDR_FOUND=${LIBHYDRASDR_FOUND}") diff --git a/grc/gen_osmosdr_blocks.py b/grc/gen_osmosdr_blocks.py index 3bba1b2..5300189 100644 --- a/grc/gen_osmosdr_blocks.py +++ b/grc/gen_osmosdr_blocks.py @@ -164,6 +164,7 @@ documentation: |- * gnuradio .cfile input through libgnuradio-blocks * RFSPACE SDR-IQ, SDR-IP, NetSDR (incl. X2 option) * AirSpy Wideband Receiver through libairspy + * HydraSDR Wideband Receiver through libhydrasdr % endif % if sourk == 'sink': * gnuradio .cfile output through libgnuradio-blocks @@ -204,6 +205,7 @@ documentation: |- cloudiq=127.0.0.1[:50000] sdr-iq=/dev/ttyUSB0 airspy=0[,bias=0|1][,linearity][,sensitivity] + hydrasdr=0[,bias=0|1][,linearity][,sensitivity] % endif % if sourk == 'sink': file='/path/to/your file',rate=1e6[,freq=100e6][,append=true][,throttle=true] ... diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt index 8673038..e28aef5 100644 --- a/lib/CMakeLists.txt +++ b/lib/CMakeLists.txt @@ -239,6 +239,14 @@ if(ENABLE_AIRSPYHF) add_subdirectory(airspyhf) endif(ENABLE_AIRSPYHF) +######################################################################## +# Setup HYDRASDR component +######################################################################## +GR_REGISTER_COMPONENT("HYDRASDR Receiver" ENABLE_HYDRASDR LIBHYDRASDR_FOUND) +if(ENABLE_HYDRASDR) + add_subdirectory(hydrasdr) +endif(ENABLE_HYDRASDR) + ######################################################################## # Setup SoapySDR component ######################################################################## diff --git a/lib/airspy/airspy_source_c.h b/lib/airspy/airspy_source_c.h index 81add15..75b2b95 100644 --- a/lib/airspy/airspy_source_c.h +++ b/lib/airspy/airspy_source_c.h @@ -29,7 +29,7 @@ #include <gnuradio/sync_block.h> -#include <libairspy/airspy.h> +#include "airspy_wrapper.h" #include "source_iface.h" diff --git a/lib/airspy/airspy_wrapper.h b/lib/airspy/airspy_wrapper.h new file mode 100644 index 0000000..7c26b5f --- /dev/null +++ b/lib/airspy/airspy_wrapper.h @@ -0,0 +1,102 @@ +#ifndef AIRSPY_WRAPPER_H +#define AIRSPY_WRAPPER_H + +// Remap ALL conflicting symbols for AIRSPY +#define RECEIVER_MODE_OFF AIRSPY_RECEIVER_MODE_OFF +#define RECEIVER_MODE_RX AIRSPY_RECEIVER_MODE_RX +#define receiver_mode_t airspy_receiver_mode_t + +#define GPIO_PORT0 AIRSPY_GPIO_PORT0 +#define GPIO_PORT1 AIRSPY_GPIO_PORT1 +#define GPIO_PORT2 AIRSPY_GPIO_PORT2 +#define GPIO_PORT3 AIRSPY_GPIO_PORT3 +#define GPIO_PORT4 AIRSPY_GPIO_PORT4 +#define GPIO_PORT5 AIRSPY_GPIO_PORT5 +#define GPIO_PORT6 AIRSPY_GPIO_PORT6 +#define GPIO_PORT7 AIRSPY_GPIO_PORT7 + +#define GPIO_PIN0 AIRSPY_GPIO_PIN0 +#define GPIO_PIN1 AIRSPY_GPIO_PIN1 +#define GPIO_PIN2 AIRSPY_GPIO_PIN2 +#define GPIO_PIN3 AIRSPY_GPIO_PIN3 +#define GPIO_PIN4 AIRSPY_GPIO_PIN4 +#define GPIO_PIN5 AIRSPY_GPIO_PIN5 +#define GPIO_PIN6 AIRSPY_GPIO_PIN6 +#define GPIO_PIN7 AIRSPY_GPIO_PIN7 +#define GPIO_PIN8 AIRSPY_GPIO_PIN8 +#define GPIO_PIN9 AIRSPY_GPIO_PIN9 +#define GPIO_PIN10 AIRSPY_GPIO_PIN10 +#define GPIO_PIN11 AIRSPY_GPIO_PIN11 +#define GPIO_PIN12 AIRSPY_GPIO_PIN12 +#define GPIO_PIN13 AIRSPY_GPIO_PIN13 +#define GPIO_PIN14 AIRSPY_GPIO_PIN14 +#define GPIO_PIN15 AIRSPY_GPIO_PIN15 +#define GPIO_PIN16 AIRSPY_GPIO_PIN16 +#define GPIO_PIN17 AIRSPY_GPIO_PIN17 +#define GPIO_PIN18 AIRSPY_GPIO_PIN18 +#define GPIO_PIN19 AIRSPY_GPIO_PIN19 +#define GPIO_PIN20 AIRSPY_GPIO_PIN20 +#define GPIO_PIN21 AIRSPY_GPIO_PIN21 +#define GPIO_PIN22 AIRSPY_GPIO_PIN22 +#define GPIO_PIN23 AIRSPY_GPIO_PIN23 +#define GPIO_PIN24 AIRSPY_GPIO_PIN24 +#define GPIO_PIN25 AIRSPY_GPIO_PIN25 +#define GPIO_PIN26 AIRSPY_GPIO_PIN26 +#define GPIO_PIN27 AIRSPY_GPIO_PIN27 +#define GPIO_PIN28 AIRSPY_GPIO_PIN28 +#define GPIO_PIN29 AIRSPY_GPIO_PIN29 +#define GPIO_PIN30 AIRSPY_GPIO_PIN30 +#define GPIO_PIN31 AIRSPY_GPIO_PIN31 + +extern "C" { +#include <libairspy/airspy.h> +} + +// Undefine ALL remapped symbols +#undef RECEIVER_MODE_OFF +#undef RECEIVER_MODE_RX +#undef receiver_mode_t + +#undef GPIO_PORT0 +#undef GPIO_PORT1 +#undef GPIO_PORT2 +#undef GPIO_PORT3 +#undef GPIO_PORT4 +#undef GPIO_PORT5 +#undef GPIO_PORT6 +#undef GPIO_PORT7 + +#undef GPIO_PIN0 +#undef GPIO_PIN1 +#undef GPIO_PIN2 +#undef GPIO_PIN3 +#undef GPIO_PIN4 +#undef GPIO_PIN5 +#undef GPIO_PIN6 +#undef GPIO_PIN7 +#undef GPIO_PIN8 +#undef GPIO_PIN9 +#undef GPIO_PIN10 +#undef GPIO_PIN11 +#undef GPIO_PIN12 +#undef GPIO_PIN13 +#undef GPIO_PIN14 +#undef GPIO_PIN15 +#undef GPIO_PIN16 +#undef GPIO_PIN17 +#undef GPIO_PIN18 +#undef GPIO_PIN19 +#undef GPIO_PIN20 +#undef GPIO_PIN21 +#undef GPIO_PIN22 +#undef GPIO_PIN23 +#undef GPIO_PIN24 +#undef GPIO_PIN25 +#undef GPIO_PIN26 +#undef GPIO_PIN27 +#undef GPIO_PIN28 +#undef GPIO_PIN29 +#undef GPIO_PIN30 +#undef GPIO_PIN31 + +#endif // AIRSPY_WRAPPER_H diff --git a/lib/config.h.in b/lib/config.h.in index 4e63444..6562506 100644 --- a/lib/config.h.in +++ b/lib/config.h.in @@ -20,6 +20,7 @@ #cmakedefine ENABLE_REDPITAYA #cmakedefine ENABLE_FREESRP #cmakedefine ENABLE_XTRX +#cmakedefine ENABLE_HYDRASDR //provide NAN define for MSVC older than VC12 #if defined(_MSC_VER) && (_MSC_VER < 1800) diff --git a/lib/device.cc b/lib/device.cc index 1dee01f..6bc577d 100644 --- a/lib/device.cc +++ b/lib/device.cc @@ -77,6 +77,10 @@ #include <airspyhf_source_c.h> #endif +#ifdef ENABLE_HYDRASDR +#include <hydrasdr_source_c.h> +#endif + #ifdef ENABLE_SOAPY #include <soapy_source_c.h> #endif diff --git a/lib/hydrasdr/CMakeLists.txt b/lib/hydrasdr/CMakeLists.txt new file mode 100644 index 0000000..42b6b75 --- /dev/null +++ b/lib/hydrasdr/CMakeLists.txt @@ -0,0 +1,38 @@ +# Copyright 2012 Free Software Foundation, Inc. +# +# This file is part of gr-osmosdr +# +# gr-osmosdr 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 3, or (at your option) +# any later version. +# +# gr-osmosdr 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 gr-osmosdr; see the file COPYING. If not, write to +# the Free Software Foundation, Inc., 51 Franklin Street, +# Boston, MA 02110-1301, USA. + +######################################################################## +# This file included, use CMake directory variables +######################################################################## + +target_include_directories(gnuradio-osmosdr PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR} + ${LIBHYDRASDR_INCLUDE_DIRS} +) + +APPEND_LIB_LIST( + gnuradio::gnuradio-filter + ${Gnuradio-blocks_LIBRARIES} + ${LIBHYDRASDR_LIBRARIES} +) + +list(APPEND gr_osmosdr_srcs + ${CMAKE_CURRENT_SOURCE_DIR}/hydrasdr_source_c.cc +) +set(gr_osmosdr_srcs ${gr_osmosdr_srcs} PARENT_SCOPE) diff --git a/lib/hydrasdr/hydrasdr_fir_kernels.h b/lib/hydrasdr/hydrasdr_fir_kernels.h new file mode 100644 index 0000000..e15f4e1 --- /dev/null +++ b/lib/hydrasdr/hydrasdr_fir_kernels.h @@ -0,0 +1,101 @@ +#pragma once + +#define KERNEL_16_110_LEN 7 +const float KERNEL_16_110[] = +{ + -0.031835079193115234f, + 0.000000000000000000f, + 0.281831502914428710f, + 0.500007271766662600f, + 0.281831502914428710f, + 0.000000000000000000f, + -0.031835079193115234f +}; + +#define KERNEL_8_100_LEN 11 +const float KERNEL_8_100[] = +{ + 0.006633400917053223f, + 0.000000000000000000f, + -0.051035523414611816f, + 0.000000000000000000f, + 0.294403314590454100f, + 0.499997496604919430f, + 0.294403314590454100f, + 0.000000000000000000f, + -0.051035523414611816f, + 0.000000000000000000f, + 0.006633400917053223f +}; + +#define KERNEL_4_90_LEN 15 +const float KERNEL_4_90[] = +{ + -0.002474188804626465f, + 0.000000000000000000f, + 0.016965746879577637f, + 0.000000000000000000f, + -0.067680597305297852f, + 0.000000000000000000f, + 0.303180575370788570f, + 0.500017046928405760f, + 0.303180575370788570f, + 0.000000000000000000f, + -0.067680597305297852f, + 0.000000000000000000f, + 0.016965746879577637f, + 0.000000000000000000f, + -0.002474188804626465f +}; + +#define KERNEL_2_80_LEN 47 +const float KERNEL_2_80[KERNEL_2_80_LEN] = +{ + -0.000198006629943848f, + 0.000000000000000000f, + 0.000576853752136230f, + 0.000000000000000000f, + -0.001352190971374512f, + 0.000000000000000000f, + 0.002729177474975586f, + 0.000000000000000000f, + -0.004988193511962891f, + 0.000000000000000000f, + 0.008499503135681152f, + 0.000000000000000000f, + -0.013788580894470215f, + 0.000000000000000000f, + 0.021713137626647949f, + 0.000000000000000000f, + -0.033980011940002441f, + 0.000000000000000000f, + 0.054944872856140137f, + 0.000000000000000000f, + -0.100657463073730470f, + 0.000000000000000000f, + 0.316457390785217290f, + 0.500000000000000000f, + 0.316457390785217290f, + 0.000000000000000000f, + -0.100657463073730470f, + 0.000000000000000000f, + 0.054944872856140137f, + 0.000000000000000000f, + -0.033980011940002441f, + 0.000000000000000000f, + 0.021713137626647949f, + 0.000000000000000000f, + -0.013788580894470215f, + 0.000000000000000000f, + 0.008499503135681152f, + 0.000000000000000000f, + -0.004988193511962891f, + 0.000000000000000000f, + 0.002729177474975586f, + 0.000000000000000000f, + -0.001352190971374512f, + 0.000000000000000000f, + 0.000576853752136230f, + 0.000000000000000000f, + -0.000198006629943848f +}; diff --git a/lib/hydrasdr/hydrasdr_source_c.cc b/lib/hydrasdr/hydrasdr_source_c.cc new file mode 100644 index 0000000..79f2c35 --- /dev/null +++ b/lib/hydrasdr/hydrasdr_source_c.cc @@ -0,0 +1,714 @@ +/* -*- c++ -*- */ +/* + * Copyright 2013 Dimitri Stolnikov <horiz0n(a)gmx.net> + * Copyright 2025 Sébastien Dudek @ Penthertz.com + * + * GNU Radio 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 3, or (at your option) + * any later version. + * + * GNU Radio 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 GNU Radio; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, + * Boston, MA 02110-1301, USA. + */ + +/* + * config.h is generated by configure. It contains the results + * of probing for features, options etc. It should be the first + * file included in your .cc file. + */ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <stdexcept> +#include <iostream> +#include <algorithm> + +#include <boost/assign.hpp> +#include <boost/format.hpp> +#include <boost/algorithm/string.hpp> +#include <boost/thread/thread.hpp> + +#include <gnuradio/io_signature.h> + +#include "hydrasdr_source_c.h" +#include "hydrasdr_fir_kernels.h" + +#include "arg_helpers.h" + +using namespace boost::assign; + +#define HYDRASDR_FORMAT_ERROR(ret, msg) \ + boost::str( boost::format(msg " (%1%) %2%") \ + % ret % hydrasdr_error_name((enum hydrasdr_error)ret) ) + +#define HYDRASDR_THROW_ON_ERROR(ret, msg) \ + if ( ret != HYDRASDR_SUCCESS ) \ + { \ + throw std::runtime_error( HYDRASDR_FORMAT_ERROR(ret, msg) ); \ + } + +#define HYDRASDR_FUNC_STR(func, arg) \ + boost::str(boost::format(func "(%1%)") % arg) + " has failed" + +hydrasdr_source_c_sptr make_hydrasdr_source_c (const std::string & args) +{ + return gnuradio::get_initial_sptr(new hydrasdr_source_c (args)); +} + +/* + * Specify constraints on number of input and output streams. + * This info is used to construct the input and output signatures + * (2nd & 3rd args to gr::block's constructor). The input and + * output signatures are used by the runtime system to + * check that a valid number and type of inputs and outputs + * are connected to this block. In this case, we accept + * only 0 input and 1 output. + */ +static const int MIN_IN = 0; // mininum number of input streams +static const int MAX_IN = 0; // maximum number of input streams +static const int MIN_OUT = 1; // minimum number of output streams +static const int MAX_OUT = 1; // maximum number of output streams + +/* + * The private constructor + */ +hydrasdr_source_c::hydrasdr_source_c (const std::string &args) + : gr::sync_block ("hydrasdr_source_c", + gr::io_signature::make(MIN_IN, MAX_IN, sizeof (gr_complex)), + gr::io_signature::make(MIN_OUT, MAX_OUT, sizeof (gr_complex))), + _dev(NULL), + _sample_rate(0), + _center_freq(0), + _freq_corr(0), + _auto_gain(false), + _gain_policy(linearity), + _lna_gain(0), + _mix_gain(0), + _vga_gain(0), + _bandwidth(0) +{ + int ret; + + dict_t dict = params_to_dict(args); + + _dev = NULL; + ret = hydrasdr_open( &_dev ); + HYDRASDR_THROW_ON_ERROR(ret, "Failed to open HydraSDR device") + + uint8_t board_id; + ret = hydrasdr_board_id_read( _dev, &board_id ); + HYDRASDR_THROW_ON_ERROR(ret, "Failed to get HydraSDR board id") + + char version[128]; + memset(version, 0, sizeof(version)); + ret = hydrasdr_version_string_read( _dev, version, sizeof(version)); + HYDRASDR_THROW_ON_ERROR(ret, "Failed to read version string") +#if 0 + hydrasdr_read_partid_serialno_t part_serial; + ret = hydrasdr_board_partid_serialno_read( _dev, &part_serial ); + HYDRASDR_THROW_ON_ERROR(ret, "Failed to read serial number") +#endif + uint32_t num_rates; + hydrasdr_get_samplerates(_dev, &num_rates, 0); + uint32_t *samplerates = (uint32_t *) malloc(num_rates * sizeof(uint32_t)); + hydrasdr_get_samplerates(_dev, samplerates, num_rates); + for (size_t i = 0; i < num_rates; i++) + _sample_rates.push_back( std::pair<double, uint32_t>( samplerates[i], i ) ); + free(samplerates); + + /* since they may (and will) give us an unsorted array we have to sort it here + * to play nice with the monotonic requirement of meta-range later on */ + std::sort(_sample_rates.begin(), _sample_rates.end()); + + std::cerr << "Using " << version << ", samplerates: "; + + for (size_t i = 0; i < _sample_rates.size(); i++) + std::cerr << boost::format("%gM ") % (_sample_rates[i].first / 1e6); + + std::cerr << std::endl; + + set_center_freq( (get_freq_range().start() + get_freq_range().stop()) / 2.0 ); + set_sample_rate( get_sample_rates().start() ); + set_bandwidth( 0 ); + + if ( dict.count( "linearity" ) ) + _gain_policy = linearity; + + if ( dict.count( "sensitivity" ) ) + _gain_policy = sensitivity; + + set_lna_gain( 8 ); /* preset to a reasonable default (non-GRC use case) */ + + set_mix_gain( 5 ); /* preset to a reasonable default (non-GRC use case) */ + + set_if_gain( 5 ); /* preset to a reasonable default (non-GRC use case) */ + + if ( dict.count( "bias" ) ) + { + bool bias = boost::lexical_cast<bool>( dict["bias"] ); + int ret = hydrasdr_set_rf_bias(_dev, (uint8_t)bias); + HYDRASDR_THROW_ON_ERROR(ret, "Failed to enable DC bias") + } + +/* pack 4 sets of 12 bits into 3 sets 16 bits for the data transfer across the + * USB bus. The default is is unpacked, to transfer 12 bits across the USB bus + * in 16 bit words. libhydrasdr transparently unpacks if packing is enabled */ + if ( dict.count( "pack" ) ) + { + bool pack = boost::lexical_cast<bool>( dict["pack"] ); + int ret = hydrasdr_set_packing(_dev, (uint8_t)pack); + HYDRASDR_THROW_ON_ERROR(ret, "Failed to set USB bit packing") + } + + _fifo = new boost::circular_buffer<gr_complex>(5000000); + if (!_fifo) { + throw std::runtime_error( std::string(__FUNCTION__) + " " + + "Failed to allocate a sample FIFO!" ); + } +} + +/* + * Our virtual destructor. + */ +hydrasdr_source_c::~hydrasdr_source_c () +{ + int ret; + + if (_dev) { + if ( hydrasdr_is_streaming( _dev ) == HYDRASDR_TRUE ) + { + ret = hydrasdr_stop_rx( _dev ); + if ( ret != HYDRASDR_SUCCESS ) + { + std::cerr << HYDRASDR_FORMAT_ERROR(ret, "Failed to stop RX streaming") << std::endl; + } + } + + ret = hydrasdr_close( _dev ); + if ( ret != HYDRASDR_SUCCESS ) + { + std::cerr << HYDRASDR_FORMAT_ERROR(ret, "Failed to close HydraSDR") << std::endl; + } + _dev = NULL; + } + + if (_fifo) + { + delete _fifo; + _fifo = NULL; + } +} + +int hydrasdr_source_c::_hydrasdr_rx_callback(hydrasdr_transfer *transfer) +{ + hydrasdr_source_c *obj = (hydrasdr_source_c *)transfer->ctx; + + return obj->hydrasdr_rx_callback((float *)transfer->samples, transfer->sample_count); +} + +int hydrasdr_source_c::hydrasdr_rx_callback(void *samples, int sample_count) +{ + size_t i, n_avail, to_copy, num_samples = sample_count; + float *sample = (float *)samples; + + _fifo_lock.lock(); + + n_avail = _fifo->capacity() - _fifo->size(); + to_copy = (n_avail < num_samples ? n_avail : num_samples); + + for (i = 0; i < to_copy; i++ ) + { + /* Push sample to the fifo */ + _fifo->push_back( gr_complex( *sample, *(sample+1) ) ); + + /* offset to the next I+Q sample */ + sample += 2; + } + + _fifo_lock.unlock(); + + /* We have made some new samples available to the consumer in work() */ + if (to_copy) { + //std::cerr << "+" << std::flush; + _samp_avail.notify_one(); + } + + /* Indicate overrun, if neccesary */ + if (to_copy < num_samples) + std::cerr << "O" << std::flush; + + return 0; // TODO: return -1 on error/stop +} + +bool hydrasdr_source_c::start() +{ + if ( ! _dev ) + return false; + + int ret = hydrasdr_start_rx( _dev, _hydrasdr_rx_callback, (void *)this ); + if ( ret != HYDRASDR_SUCCESS ) { + std::cerr << "Failed to start RX streaming (" << ret << ")" << std::endl; + return false; + } + + return true; +} + +bool hydrasdr_source_c::stop() +{ + if ( ! _dev ) + return false; + + int ret = hydrasdr_stop_rx( _dev ); + if ( ret != HYDRASDR_SUCCESS ) { + std::cerr << "Failed to stop RX streaming (" << ret << ")" << std::endl; + return false; + } + + return true; +} + +int hydrasdr_source_c::work( int noutput_items, + gr_vector_const_void_star &input_items, + gr_vector_void_star &output_items ) +{ + gr_complex *out = (gr_complex *)output_items[0]; + + bool running = false; + + if ( _dev ) + running = (hydrasdr_is_streaming( _dev ) == HYDRASDR_TRUE); + + if ( ! running ) + return WORK_DONE; + + std::unique_lock<std::mutex> lock(_fifo_lock); + + /* Wait until we have the requested number of samples */ + int n_samples_avail = _fifo->size(); + + while (n_samples_avail < noutput_items) { + _samp_avail.wait(lock); + n_samples_avail = _fifo->size(); + } + + for(int i = 0; i < noutput_items; ++i) { + out[i] = _fifo->at(0); + _fifo->pop_front(); + } + + //std::cerr << "-" << std::flush; + + return noutput_items; +} + +std::vector<std::string> hydrasdr_source_c::get_devices() +{ + std::vector<std::string> devices; + std::string label; + + int ret; + hydrasdr_device *dev = NULL; + ret = hydrasdr_open(&dev); + if ( HYDRASDR_SUCCESS == ret ) + { + std::string args = "hydrasdr=0"; + + label = "HydraSDR RFOne"; + + uint8_t board_id; + ret = hydrasdr_board_id_read( dev, &board_id ); + if ( HYDRASDR_SUCCESS == ret ) + { + label += std::string(" ") + hydrasdr_board_id_name(hydrasdr_board_id(board_id)); + } + + args += ",label='" + label + "'"; + devices.push_back( args ); + + ret = hydrasdr_close(dev); + } + + return devices; +} + +size_t hydrasdr_source_c::get_num_channels() +{ + return 1; +} + +osmosdr::meta_range_t hydrasdr_source_c::get_sample_rates() +{ + osmosdr::meta_range_t range; + + for (size_t i = 0; i < _sample_rates.size(); i++) + range += osmosdr::range_t( _sample_rates[i].first ); + + return range; +} + +double hydrasdr_source_c::set_sample_rate( double rate ) +{ + int ret = HYDRASDR_SUCCESS; + + if (_dev) { + bool found_supported_rate = false; + uint32_t samp_rate_index = 0; + + for( unsigned int i = 0; i < _sample_rates.size(); i++ ) + { + if( _sample_rates[i].first == rate ) + { + samp_rate_index = _sample_rates[i].second; + + found_supported_rate = true; + } + } + + if ( ! found_supported_rate ) + { + throw std::runtime_error( + boost::str( boost::format("Unsupported samplerate: %gM") % (rate/1e6) ) ); + } + + ret = hydrasdr_set_samplerate( _dev, samp_rate_index ); + if ( HYDRASDR_SUCCESS == ret ) { + _sample_rate = rate; + } else { + HYDRASDR_THROW_ON_ERROR( ret, HYDRASDR_FUNC_STR( "hydrasdr_set_samplerate", rate ) ) + } + } + + return get_sample_rate(); +} + +double hydrasdr_source_c::get_sample_rate() +{ + return _sample_rate; +} + +osmosdr::freq_range_t hydrasdr_source_c::get_freq_range( size_t chan ) +{ + osmosdr::freq_range_t range; + + range += osmosdr::range_t( 24e6, 1766e6 ); + + return range; +} + +double hydrasdr_source_c::set_center_freq( double freq, size_t chan ) +{ + int ret; + + #define APPLY_PPM_CORR(val, ppm) ((val) * (1.0 + (ppm) * 0.000001)) + + if (_dev) { + double corr_freq = APPLY_PPM_CORR( freq, _freq_corr ); + ret = hydrasdr_set_freq( _dev, uint64_t(corr_freq) ); + if ( HYDRASDR_SUCCESS == ret ) { + _center_freq = freq; + } else { + HYDRASDR_THROW_ON_ERROR( ret, HYDRASDR_FUNC_STR( "hydrasdr_set_freq", corr_freq ) ) + } + } + + return get_center_freq( chan ); +} + +double hydrasdr_source_c::get_center_freq( size_t chan ) +{ + return _center_freq; +} + +double hydrasdr_source_c::set_freq_corr( double ppm, size_t chan ) +{ + _freq_corr = ppm; + + set_center_freq( _center_freq ); + + return get_freq_corr( chan ); +} + +double hydrasdr_source_c::get_freq_corr( size_t chan ) +{ + return _freq_corr; +} + +std::vector<std::string> hydrasdr_source_c::get_gain_names( size_t chan ) +{ + std::vector< std::string > names; + + names += "LNA"; + names += "MIX"; + names += "IF"; + + return names; +} + +osmosdr::gain_range_t hydrasdr_source_c::get_gain_range( size_t chan ) +{ + return osmosdr::gain_range_t( 0, 21, 1 ); +} + +osmosdr::gain_range_t hydrasdr_source_c::get_gain_range( const std::string & name, size_t chan ) +{ + /* They don't spec any gain values in dB so we simply use gain stage indices for now. */ + + if ( "LNA" == name ) { + return osmosdr::gain_range_t( 0, 15, 1 ); + } + + if ( "MIX" == name ) { + return osmosdr::gain_range_t( 0, 15, 1 ); + } + + if ( "IF" == name ) { + return osmosdr::gain_range_t( 0, 15, 1 ); + } + + return osmosdr::gain_range_t(); +} + +bool hydrasdr_source_c::set_gain_mode( bool automatic, size_t chan ) +{ + if ( automatic ) { + hydrasdr_set_lna_agc( _dev, 1 ); + hydrasdr_set_mixer_agc( _dev, 1 ); + } else { + hydrasdr_set_lna_agc( _dev, 0 ); + hydrasdr_set_mixer_agc( _dev, 0 ); + + set_lna_gain( _lna_gain ); + set_mix_gain( _mix_gain ); + } + + _auto_gain = automatic; + + return get_gain_mode(chan); +} + +bool hydrasdr_source_c::get_gain_mode( size_t chan ) +{ + return _auto_gain; +} + +double hydrasdr_source_c::set_gain( double gain, size_t chan ) +{ + int ret = HYDRASDR_SUCCESS; + osmosdr::gain_range_t gains = get_gain_range( chan ); + + if (_dev) { + double clip_gain = gains.clip( gain, true ); + uint8_t value = clip_gain; + + if ( _gain_policy == linearity ) { + ret = hydrasdr_set_linearity_gain( _dev, value ); + if ( HYDRASDR_SUCCESS == ret ) { + _gain = clip_gain; + } else { + HYDRASDR_THROW_ON_ERROR( ret, HYDRASDR_FUNC_STR( "hydrasdr_set_linearity_gain", value ) ) + } + } else if ( _gain_policy == sensitivity ) { + ret = hydrasdr_set_sensitivity_gain( _dev, value ); + if ( HYDRASDR_SUCCESS == ret ) { + _gain = clip_gain; + } else { + HYDRASDR_THROW_ON_ERROR( ret, HYDRASDR_FUNC_STR( "hydrasdr_set_sensitivity_gain", value ) ) + } + } + } + + return _gain; +} + +double hydrasdr_source_c::set_gain( double gain, const std::string & name, size_t chan) +{ + if ( "LNA" == name ) { + return set_lna_gain( gain, chan ); + } + + if ( "MIX" == name ) { + return set_mix_gain( gain, chan ); + } + + if ( "IF" == name ) { + return set_if_gain( gain, chan ); + } + + return set_gain( gain, chan ); +} + +double hydrasdr_source_c::get_gain( size_t chan ) +{ + return _gain; +} + +double hydrasdr_source_c::get_gain( const std::string & name, size_t chan ) +{ + if ( "LNA" == name ) { + return _lna_gain; + } + + if ( "MIX" == name ) { + return _mix_gain; + } + + if ( "IF" == name ) { + return _vga_gain; + } + + return get_gain( chan ); +} + +double hydrasdr_source_c::set_lna_gain( double gain, size_t chan ) +{ + int ret = HYDRASDR_SUCCESS; + osmosdr::gain_range_t gains = get_gain_range( "LNA", chan ); + + if (_dev) { + double clip_gain = gains.clip( gain, true ); + uint8_t value = clip_gain; + + ret = hydrasdr_set_lna_gain( _dev, value ); + if ( HYDRASDR_SUCCESS == ret ) { + _lna_gain = clip_gain; + } else { + HYDRASDR_THROW_ON_ERROR( ret, HYDRASDR_FUNC_STR( "hydrasdr_set_lna_gain", value ) ) + } + } + + return _lna_gain; +} + +double hydrasdr_source_c::set_mix_gain(double gain, size_t chan) +{ + int ret; + osmosdr::gain_range_t gains = get_gain_range( "MIX", chan ); + + if (_dev) { + double clip_gain = gains.clip( gain, true ); + uint8_t value = clip_gain; + + ret = hydrasdr_set_mixer_gain( _dev, value ); + if ( HYDRASDR_SUCCESS == ret ) { + _mix_gain = clip_gain; + } else { + HYDRASDR_THROW_ON_ERROR( ret, HYDRASDR_FUNC_STR( "hydrasdr_set_mixer_gain", value ) ) + } + } + + return _mix_gain; +} + +double hydrasdr_source_c::set_if_gain(double gain, size_t chan) +{ + int ret; + osmosdr::gain_range_t gains = get_gain_range( "MIX", chan ); + + if (_dev) { + double clip_gain = gains.clip( gain, true ); + uint8_t value = clip_gain; + + ret = hydrasdr_set_vga_gain( _dev, value ); + if ( HYDRASDR_SUCCESS == ret ) { + _vga_gain = clip_gain; + } else { + HYDRASDR_THROW_ON_ERROR( ret, HYDRASDR_FUNC_STR( "hydrasdr_set_vga_gain", value ) ) + } + } + + return _vga_gain; +} + +std::vector< std::string > hydrasdr_source_c::get_antennas( size_t chan ) +{ + std::vector< std::string > antennas; + + antennas += get_antenna( chan ); + + return antennas; +} + +std::string hydrasdr_source_c::set_antenna( const std::string & antenna, size_t chan ) +{ + return get_antenna( chan ); +} + +std::string hydrasdr_source_c::get_antenna( size_t chan ) +{ + return "RX"; +} + +double hydrasdr_source_c::set_bandwidth( double bandwidth, size_t chan ) +{ + if (bandwidth == 0.f) + return get_bandwidth( chan ); + + { + int ret; + int decim; + int size; + const float *kernel; + + decim = (int)(_sample_rate / bandwidth); +// if (decim < 2) +// { +// kernel = 0; +// size = 0; +// } +// else + if (decim < 4) + { + kernel = KERNEL_2_80; + size = KERNEL_2_80_LEN; + } + else if (decim < 8) + { + kernel = KERNEL_4_90; + size = KERNEL_4_90_LEN; + } + else if (decim < 16) + { + kernel = KERNEL_8_100; + size = KERNEL_8_100_LEN; + } + else + { + kernel = KERNEL_16_110; + size = KERNEL_16_110_LEN; + } + + if (size) + { + std::cerr << " HydraSDR decim:" << decim + << " kernel size:" << size << std::endl; + ret = hydrasdr_set_conversion_filter_float32(_dev, kernel, size); + HYDRASDR_THROW_ON_ERROR(ret, "Failed to set IQ conversion filter") + } + } + + return get_bandwidth( chan ); +} + +double hydrasdr_source_c::get_bandwidth( size_t chan ) +{ + return _sample_rate; +} + +osmosdr::freq_range_t hydrasdr_source_c::get_bandwidth_range( size_t chan ) +{ + osmosdr::freq_range_t bandwidths; + + bandwidths += osmosdr::range_t( get_bandwidth( chan ) ); + + return bandwidths; +} diff --git a/lib/hydrasdr/hydrasdr_source_c.h b/lib/hydrasdr/hydrasdr_source_c.h new file mode 100644 index 0000000..7541dfb --- /dev/null +++ b/lib/hydrasdr/hydrasdr_source_c.h @@ -0,0 +1,154 @@ +/* -*- c++ -*- */ +/* + * Copyright 2013 Dimitri Stolnikov <horiz0n(a)gmx.net> + * Copyright 2025 Adapted to HydraSDR by Sébastien Dudek @ Penthertz.com + * + * This file is part of GNU Radio + * + * GNU Radio 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 3, or (at your option) + * any later version. + * + * GNU Radio 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 GNU Radio; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, + * Boston, MA 02110-1301, USA. + */ +#ifndef INCLUDED_HYDRASDR_SOURCE_C_H +#define INCLUDED_HYDRASDR_SOURCE_C_H + +#include <boost/circular_buffer.hpp> + +#include <mutex> +#include <condition_variable> + +#include <gnuradio/sync_block.h> + +#include "hydrasdr_wrapper.h" + +#include "source_iface.h" + +class hydrasdr_source_c; + +/* + * We use std::shared_ptr's instead of raw pointers for all access + * to gr::blocks (and many other data structures). The shared_ptr gets + * us transparent reference counting, which greatly simplifies storage + * management issues. This is especially helpful in our hybrid + * C++ / Python system. + * + * See http://www.boost.org/libs/smart_ptr/smart_ptr.htm + * + * As a convention, the _sptr suffix indicates a std::shared_ptr + */ +typedef std::shared_ptr<hydrasdr_source_c> hydrasdr_source_c_sptr; + +/*! + * \brief Return a shared_ptr to a new instance of hydrasdr_source_c. + * + * To avoid accidental use of raw pointers, hydrasdr_source_c's + * constructor is private. make_hydrasdr_source_c is the public + * interface for creating new instances. + */ +hydrasdr_source_c_sptr make_hydrasdr_source_c (const std::string & args = ""); + +/*! + * \brief Provides a stream of complex samples. + * \ingroup block + */ +class hydrasdr_source_c : + public gr::sync_block, + public source_iface +{ +private: + // The friend declaration allows make_hydrasdr_source_c to + // access the private constructor. + + friend hydrasdr_source_c_sptr make_hydrasdr_source_c (const std::string & args); + + /*! + * \brief Provides a stream of complex samples. + */ + hydrasdr_source_c (const std::string & args); // private constructor + +public: + ~hydrasdr_source_c (); // public destructor + + bool start(); + bool stop(); + + int work( int noutput_items, + gr_vector_const_void_star &input_items, + gr_vector_void_star &output_items ); + + static std::vector< std::string > get_devices(); + + size_t get_num_channels( void ); + + osmosdr::meta_range_t get_sample_rates( void ); + double set_sample_rate( double rate ); + double get_sample_rate( void ); + + osmosdr::freq_range_t get_freq_range( size_t chan = 0 ); + double set_center_freq( double freq, size_t chan = 0 ); + double get_center_freq( size_t chan = 0 ); + double set_freq_corr( double ppm, size_t chan = 0 ); + double get_freq_corr( size_t chan = 0 ); + + std::vector<std::string> get_gain_names( size_t chan = 0 ); + osmosdr::gain_range_t get_gain_range( size_t chan = 0 ); + osmosdr::gain_range_t get_gain_range( const std::string & name, size_t chan = 0 ); + bool set_gain_mode( bool automatic, size_t chan = 0 ); + bool get_gain_mode( size_t chan = 0 ); + double set_gain( double gain, size_t chan = 0 ); + double set_gain( double gain, const std::string & name, size_t chan = 0 ); + double get_gain( size_t chan = 0 ); + double get_gain( const std::string & name, size_t chan = 0 ); + + double set_lna_gain( double gain, size_t chan = 0 ); + double set_mix_gain(double gain, size_t chan = 0 ); + double set_if_gain( double gain, size_t chan = 0 ); + + std::vector< std::string > get_antennas( size_t chan = 0 ); + std::string set_antenna( const std::string & antenna, size_t chan = 0 ); + std::string get_antenna( size_t chan = 0 ); + + double set_bandwidth( double bandwidth, size_t chan = 0 ); + double get_bandwidth( size_t chan = 0 ); + osmosdr::freq_range_t get_bandwidth_range( size_t chan = 0 ); + +private: + static int _hydrasdr_rx_callback(hydrasdr_transfer* transfer); + int hydrasdr_rx_callback(void *samples, int sample_count); + + hydrasdr_device *_dev; + + boost::circular_buffer<gr_complex> *_fifo; + std::mutex _fifo_lock; + std::condition_variable _samp_avail; + + std::vector< std::pair<double, uint32_t> > _sample_rates; + double _sample_rate; + double _center_freq; + double _freq_corr; + bool _auto_gain; + double _gain; + enum gain_policy + { + linearity, + sensitivity + }; + enum gain_policy _gain_policy; + double _lna_gain; + double _mix_gain; + double _vga_gain; + double _bandwidth; +}; + +#endif /* INCLUDED_HYDRASDR_SOURCE_C_H */ diff --git a/lib/hydrasdr/hydrasdr_wrapper.h b/lib/hydrasdr/hydrasdr_wrapper.h new file mode 100644 index 0000000..bc44d48 --- /dev/null +++ b/lib/hydrasdr/hydrasdr_wrapper.h @@ -0,0 +1,102 @@ +#ifndef HYDRASDR_WRAPPER_H +#define HYDRASDR_WRAPPER_H + +// Remap ALL conflicting symbols for HYDRASDR +#define RECEIVER_MODE_OFF HYDRA_RECEIVER_MODE_OFF +#define RECEIVER_MODE_RX HYDRA_RECEIVER_MODE_RX +#define receiver_mode_t hydra_receiver_mode_t + +#define GPIO_PORT0 HYDRA_GPIO_PORT0 +#define GPIO_PORT1 HYDRA_GPIO_PORT1 +#define GPIO_PORT2 HYDRA_GPIO_PORT2 +#define GPIO_PORT3 HYDRA_GPIO_PORT3 +#define GPIO_PORT4 HYDRA_GPIO_PORT4 +#define GPIO_PORT5 HYDRA_GPIO_PORT5 +#define GPIO_PORT6 HYDRA_GPIO_PORT6 +#define GPIO_PORT7 HYDRA_GPIO_PORT7 + +#define GPIO_PIN0 HYDRA_GPIO_PIN0 +#define GPIO_PIN1 HYDRA_GPIO_PIN1 +#define GPIO_PIN2 HYDRA_GPIO_PIN2 +#define GPIO_PIN3 HYDRA_GPIO_PIN3 +#define GPIO_PIN4 HYDRA_GPIO_PIN4 +#define GPIO_PIN5 HYDRA_GPIO_PIN5 +#define GPIO_PIN6 HYDRA_GPIO_PIN6 +#define GPIO_PIN7 HYDRA_GPIO_PIN7 +#define GPIO_PIN8 HYDRA_GPIO_PIN8 +#define GPIO_PIN9 HYDRA_GPIO_PIN9 +#define GPIO_PIN10 HYDRA_GPIO_PIN10 +#define GPIO_PIN11 HYDRA_GPIO_PIN11 +#define GPIO_PIN12 HYDRA_GPIO_PIN12 +#define GPIO_PIN13 HYDRA_GPIO_PIN13 +#define GPIO_PIN14 HYDRA_GPIO_PIN14 +#define GPIO_PIN15 HYDRA_GPIO_PIN15 +#define GPIO_PIN16 HYDRA_GPIO_PIN16 +#define GPIO_PIN17 HYDRA_GPIO_PIN17 +#define GPIO_PIN18 HYDRA_GPIO_PIN18 +#define GPIO_PIN19 HYDRA_GPIO_PIN19 +#define GPIO_PIN20 HYDRA_GPIO_PIN20 +#define GPIO_PIN21 HYDRA_GPIO_PIN21 +#define GPIO_PIN22 HYDRA_GPIO_PIN22 +#define GPIO_PIN23 HYDRA_GPIO_PIN23 +#define GPIO_PIN24 HYDRA_GPIO_PIN24 +#define GPIO_PIN25 HYDRA_GPIO_PIN25 +#define GPIO_PIN26 HYDRA_GPIO_PIN26 +#define GPIO_PIN27 HYDRA_GPIO_PIN27 +#define GPIO_PIN28 HYDRA_GPIO_PIN28 +#define GPIO_PIN29 HYDRA_GPIO_PIN29 +#define GPIO_PIN30 HYDRA_GPIO_PIN30 +#define GPIO_PIN31 HYDRA_GPIO_PIN31 + +extern "C" { +#include <libhydrasdr/hydrasdr.h> +} + +// Undefine ALL remapped symbols +#undef RECEIVER_MODE_OFF +#undef RECEIVER_MODE_RX +#undef receiver_mode_t + +#undef GPIO_PORT0 +#undef GPIO_PORT1 +#undef GPIO_PORT2 +#undef GPIO_PORT3 +#undef GPIO_PORT4 +#undef GPIO_PORT5 +#undef GPIO_PORT6 +#undef GPIO_PORT7 + +#undef GPIO_PIN0 +#undef GPIO_PIN1 +#undef GPIO_PIN2 +#undef GPIO_PIN3 +#undef GPIO_PIN4 +#undef GPIO_PIN5 +#undef GPIO_PIN6 +#undef GPIO_PIN7 +#undef GPIO_PIN8 +#undef GPIO_PIN9 +#undef GPIO_PIN10 +#undef GPIO_PIN11 +#undef GPIO_PIN12 +#undef GPIO_PIN13 +#undef GPIO_PIN14 +#undef GPIO_PIN15 +#undef GPIO_PIN16 +#undef GPIO_PIN17 +#undef GPIO_PIN18 +#undef GPIO_PIN19 +#undef GPIO_PIN20 +#undef GPIO_PIN21 +#undef GPIO_PIN22 +#undef GPIO_PIN23 +#undef GPIO_PIN24 +#undef GPIO_PIN25 +#undef GPIO_PIN26 +#undef GPIO_PIN27 +#undef GPIO_PIN28 +#undef GPIO_PIN29 +#undef GPIO_PIN30 +#undef GPIO_PIN31 + +#endif // HYDRASDR_WRAPPER_H diff --git a/test_find.cmake b/test_find.cmake new file mode 100644 index 0000000..74a7a40 --- /dev/null +++ b/test_find.cmake @@ -0,0 +1,15 @@ +FIND_PATH( + LIBHYDRASDR_INCLUDE_DIRS + NAMES libhydrasdr/hydrasdr.h + PATHS /usr/include +) + +FIND_LIBRARY( + LIBHYDRASDR_LIBRARIES + NAMES hydrasdr + PATHS /usr/lib + /lib +) + +message("LIBHYDRASDR_INCLUDE_DIRS: ${LIBHYDRASDR_INCLUDE_DIRS}") +message("LIBHYDRASDR_LIBRARIES: ${LIBHYDRASDR_LIBRARIES}") diff --git a/thirdparty/libhydrasdr/hydrasdr.h b/thirdparty/libhydrasdr/hydrasdr.h new file mode 100644 index 0000000..78d7268 --- /dev/null +++ b/thirdparty/libhydrasdr/hydrasdr.h @@ -0,0 +1,224 @@ +/* +Copyright (c) 2012, Jared Boone <jared(a)sharebrained.com> +Copyright (c) 2013, Michael Ossmann <mike(a)ossmann.com> +Copyright (C) 2013-2016, Youssef Touil <youssef(a)airspy.com> +Copyright (c) 2013-2025, Benjamin Vernoux <bvernoux(a)hydrasdr.com> + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. +Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the +documentation and/or other materials provided with the distribution. +Neither the name of HydraSDR nor the names of its contributors may be used to endorse or promote products derived from this software +without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#ifndef __HYDRASDR_H__ +#define __HYDRASDR_H__ + +#include <stdint.h> +#include "hydrasdr_commands.h" + +#define HYDRASDR_VERSION "1.0.0" +#define HYDRASDR_VER_MAJOR 1 +#define HYDRASDR_VER_MINOR 0 +#define HYDRASDR_VER_REVISION 0 + +#ifdef _WIN32 + #define ADD_EXPORTS + + /* You should define ADD_EXPORTS *only* when building the DLL. */ + #ifdef ADD_EXPORTS + #define ADDAPI __declspec(dllexport) + #else + #define ADDAPI __declspec(dllimport) + #endif + + /* Define calling convention in one place, for convenience. */ + #define ADDCALL __cdecl + +#else /* _WIN32 not defined. */ + + /* Define with no value on non-Windows OSes. */ + #define ADDAPI + #define ADDCALL + +#endif + +#ifdef __cplusplus +extern "C" +{ +#endif + +enum hydrasdr_error +{ + HYDRASDR_SUCCESS = 0, + HYDRASDR_TRUE = 1, + HYDRASDR_ERROR_INVALID_PARAM = -2, + HYDRASDR_ERROR_NOT_FOUND = -5, + HYDRASDR_ERROR_BUSY = -6, + HYDRASDR_ERROR_NO_MEM = -11, + HYDRASDR_ERROR_UNSUPPORTED = -12, + HYDRASDR_ERROR_LIBUSB = -1000, + HYDRASDR_ERROR_THREAD = -1001, + HYDRASDR_ERROR_STREAMING_THREAD_ERR = -1002, + HYDRASDR_ERROR_STREAMING_STOPPED = -1003, + HYDRASDR_ERROR_OTHER = -9999, +}; + +enum hydrasdr_board_id +{ + HYDRASDR_BOARD_ID_PROTO_HYDRASDR = 0, + HYDRASDR_BOARD_ID_INVALID = 0xFF, +}; + +enum hydrasdr_sample_type +{ + HYDRASDR_SAMPLE_FLOAT32_IQ = 0, /* 2 * 32bit float per sample */ + HYDRASDR_SAMPLE_FLOAT32_REAL = 1, /* 1 * 32bit float per sample */ + HYDRASDR_SAMPLE_INT16_IQ = 2, /* 2 * 16bit int per sample */ + HYDRASDR_SAMPLE_INT16_REAL = 3, /* 1 * 16bit int per sample */ + HYDRASDR_SAMPLE_UINT16_REAL = 4, /* 1 * 16bit unsigned int per sample */ + HYDRASDR_SAMPLE_RAW = 5, /* Raw packed samples from the device */ + HYDRASDR_SAMPLE_END = 6 /* Number of supported sample types */ +}; + +#define MAX_CONFIG_PAGE_SIZE (0x10000) + +struct hydrasdr_device; + +typedef struct { + struct hydrasdr_device* device; + void* ctx; + void* samples; + int sample_count; + uint64_t dropped_samples; + enum hydrasdr_sample_type sample_type; +} hydrasdr_transfer_t, hydrasdr_transfer; + +typedef struct { + uint32_t part_id[2]; + uint32_t serial_no[4]; +} hydrasdr_read_partid_serialno_t; + +typedef struct { + uint32_t major_version; + uint32_t minor_version; + uint32_t revision; +} hydrasdr_lib_version_t; + +typedef int (*hydrasdr_sample_block_cb_fn)(hydrasdr_transfer* transfer); + +extern ADDAPI void ADDCALL hydrasdr_lib_version(hydrasdr_lib_version_t* lib_version); + +extern ADDAPI int ADDCALL hydrasdr_list_devices(uint64_t *serials, int count); + +extern ADDAPI int ADDCALL hydrasdr_open_sn(struct hydrasdr_device** device, uint64_t serial_number); +extern ADDAPI int ADDCALL hydrasdr_open_fd(struct hydrasdr_device** device, int fd); +extern ADDAPI int ADDCALL hydrasdr_open(struct hydrasdr_device** device); +extern ADDAPI int ADDCALL hydrasdr_close(struct hydrasdr_device* device); + +/* Use hydrasdr_get_samplerates(device, buffer, 0) to get the number of available sample rates. It will be returned in the first element of buffer */ +extern ADDAPI int ADDCALL hydrasdr_get_samplerates(struct hydrasdr_device* device, uint32_t* buffer, const uint32_t len); + +/* Parameter samplerate can be either the index of a samplerate or directly its value in Hz within the list returned by hydrasdr_get_samplerates() */ +extern ADDAPI int ADDCALL hydrasdr_set_samplerate(struct hydrasdr_device* device, uint32_t samplerate); + +extern ADDAPI int ADDCALL hydrasdr_set_conversion_filter_float32(struct hydrasdr_device* device, const float *kernel, const uint32_t len); +extern ADDAPI int ADDCALL hydrasdr_set_conversion_filter_int16(struct hydrasdr_device* device, const int16_t *kernel, const uint32_t len); + +extern ADDAPI int ADDCALL hydrasdr_start_rx(struct hydrasdr_device* device, hydrasdr_sample_block_cb_fn callback, void* rx_ctx); +extern ADDAPI int ADDCALL hydrasdr_stop_rx(struct hydrasdr_device* device); + +/* return HYDRASDR_TRUE if success */ +extern ADDAPI int ADDCALL hydrasdr_is_streaming(struct hydrasdr_device* device); + +extern ADDAPI int ADDCALL hydrasdr_si5351c_write(struct hydrasdr_device* device, uint8_t register_number, uint8_t value); +extern ADDAPI int ADDCALL hydrasdr_si5351c_read(struct hydrasdr_device* device, uint8_t register_number, uint8_t* value); + +extern ADDAPI int ADDCALL hydrasdr_config_write(struct hydrasdr_device* device, const uint8_t page_index, const uint16_t length, unsigned char *data); +extern ADDAPI int ADDCALL hydrasdr_config_read(struct hydrasdr_device* device, const uint8_t page_index, const uint16_t length, unsigned char *data); + +extern ADDAPI int ADDCALL hydrasdr_r82x_write(struct hydrasdr_device* device, uint8_t register_number, uint8_t value); +extern ADDAPI int ADDCALL hydrasdr_r82x_read(struct hydrasdr_device* device, uint8_t register_number, uint8_t* value); + +/* Parameter value shall be 0=clear GPIO or 1=set GPIO */ +extern ADDAPI int ADDCALL hydrasdr_gpio_write(struct hydrasdr_device* device, hydrasdr_gpio_port_t port, hydrasdr_gpio_pin_t pin, uint8_t value); +/* Parameter value corresponds to GPIO state 0 or 1 */ +extern ADDAPI int ADDCALL hydrasdr_gpio_read(struct hydrasdr_device* device, hydrasdr_gpio_port_t port, hydrasdr_gpio_pin_t pin, uint8_t* value); + +/* Parameter value shall be 0=GPIO Input direction or 1=GPIO Output direction */ +extern ADDAPI int ADDCALL hydrasdr_gpiodir_write(struct hydrasdr_device* device, hydrasdr_gpio_port_t port, hydrasdr_gpio_pin_t pin, uint8_t value); +extern ADDAPI int ADDCALL hydrasdr_gpiodir_read(struct hydrasdr_device* device, hydrasdr_gpio_port_t port, hydrasdr_gpio_pin_t pin, uint8_t* value); + +extern ADDAPI int ADDCALL hydrasdr_spiflash_erase(struct hydrasdr_device* device); +extern ADDAPI int ADDCALL hydrasdr_spiflash_write(struct hydrasdr_device* device, const uint32_t address, const uint16_t length, unsigned char* const data); +extern ADDAPI int ADDCALL hydrasdr_spiflash_read(struct hydrasdr_device* device, const uint32_t address, const uint16_t length, unsigned char* data); + +extern ADDAPI int ADDCALL hydrasdr_board_id_read(struct hydrasdr_device* device, uint8_t* value); +/* Parameter length shall be at least 128bytes to avoid possible string clipping */ +extern ADDAPI int ADDCALL hydrasdr_version_string_read(struct hydrasdr_device* device, char* version, uint8_t length); + +extern ADDAPI int ADDCALL hydrasdr_board_partid_serialno_read(struct hydrasdr_device* device, hydrasdr_read_partid_serialno_t* read_partid_serialno); + +extern ADDAPI int ADDCALL hydrasdr_set_sample_type(struct hydrasdr_device* device, enum hydrasdr_sample_type sample_type); + +/* Parameter freq_hz shall be between 24000000(24MHz) and 1800000000(1.8GHz) and more with extensions */ +extern ADDAPI int ADDCALL hydrasdr_set_freq(struct hydrasdr_device* device, const uint64_t freq_hz); + +/* Parameter value shall be between 0 and 15 */ +extern ADDAPI int ADDCALL hydrasdr_set_lna_gain(struct hydrasdr_device* device, uint8_t value); + +/* Parameter value shall be between 0 and 15 */ +extern ADDAPI int ADDCALL hydrasdr_set_mixer_gain(struct hydrasdr_device* device, uint8_t value); + +/* Parameter value shall be between 0 and 15 */ +extern ADDAPI int ADDCALL hydrasdr_set_vga_gain(struct hydrasdr_device* device, uint8_t value); + +/* Parameter value: + 0=Disable LNA Automatic Gain Control + 1=Enable LNA Automatic Gain Control +*/ +extern ADDAPI int ADDCALL hydrasdr_set_lna_agc(struct hydrasdr_device* device, uint8_t value); +/* Parameter value: + 0=Disable MIXER Automatic Gain Control + 1=Enable MIXER Automatic Gain Control +*/ +extern ADDAPI int ADDCALL hydrasdr_set_mixer_agc(struct hydrasdr_device* device, uint8_t value); + +/* Parameter value: 0..21 */ +extern ADDAPI int ADDCALL hydrasdr_set_linearity_gain(struct hydrasdr_device* device, uint8_t value); + +/* Parameter value: 0..21 */ +extern ADDAPI int ADDCALL hydrasdr_set_sensitivity_gain(struct hydrasdr_device* device, uint8_t value); + +/* Parameter value shall be 0=Disable BiasT or 1=Enable BiasT */ +extern ADDAPI int ADDCALL hydrasdr_set_rf_bias(struct hydrasdr_device* dev, uint8_t value); + +/* Parameter value shall be 0=Disable Packing or 1=Enable Packing */ +extern ADDAPI int ADDCALL hydrasdr_set_packing(struct hydrasdr_device* device, uint8_t value); + +extern ADDAPI const char* ADDCALL hydrasdr_error_name(enum hydrasdr_error errcode); +extern ADDAPI const char* ADDCALL hydrasdr_board_id_name(enum hydrasdr_board_id board_id); + +/* Parameter sector_num shall be between 2 & 13 (sector 0 & 1 are reserved for the firmware) */ +extern ADDAPI int ADDCALL hydrasdr_spiflash_erase_sector(struct hydrasdr_device* device, const uint16_t sector_num); + +extern ADDAPI int ADDCALL hydrasdr_reset(struct hydrasdr_device* device); + +extern ADDAPI int ADDCALL hydrasdr_set_rf_port(struct hydrasdr_device* device, hydrasdr_rf_port_t rf_port); + +#ifdef __cplusplus +} // __cplusplus defined. +#endif + +#endif//__HYDRASDR_H__ diff --git a/thirdparty/libhydrasdr/hydrasdr_commands.h b/thirdparty/libhydrasdr/hydrasdr_commands.h new file mode 100644 index 0000000..8ccf6cb --- /dev/null +++ b/thirdparty/libhydrasdr/hydrasdr_commands.h @@ -0,0 +1,132 @@ +/* +Copyright (c) 2013-2025 Benjamin Vernoux <bvernoux(a)hydrasdr.com> + +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. +Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the +documentation and/or other materials provided with the distribution. +Neither the name of HydraSDR nor the names of its contributors may be used to endorse or promote products derived from this software +without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#ifndef __HYDRASDR_COMMANDS_H__ +#define __HYDRASDR_COMMANDS_H__ + +#include <stdint.h> + +#ifdef __cplusplus +extern "C" +{ +#endif + +typedef enum +{ + RECEIVER_MODE_OFF = 0, + RECEIVER_MODE_RX = 1 +} receiver_mode_t; + +// Commands (usb vendor request) shared between Firmware and Host. +#define HYDRASDR_CMD_MAX (28) +typedef enum +{ + HYDRASDR_RESET = 0, + HYDRASDR_RECEIVER_MODE = 1, + HYDRASDR_SI5351C_WRITE = 2, + HYDRASDR_SI5351C_READ = 3, + HYDRASDR_R82X_WRITE = 4, + HYDRASDR_R82X_READ = 5, + HYDRASDR_SPIFLASH_ERASE = 6, + HYDRASDR_SPIFLASH_WRITE = 7, + HYDRASDR_SPIFLASH_READ = 8, + HYDRASDR_BOARD_ID_READ = 9, + HYDRASDR_VERSION_STRING_READ = 10, + HYDRASDR_BOARD_PARTID_SERIALNO_READ = 11, + HYDRASDR_SET_SAMPLERATE = 12, + HYDRASDR_SET_FREQ = 13, + HYDRASDR_SET_LNA_GAIN = 14, + HYDRASDR_SET_MIXER_GAIN = 15, + HYDRASDR_SET_VGA_GAIN = 16, + HYDRASDR_SET_LNA_AGC = 17, + HYDRASDR_SET_MIXER_AGC = 18, + HYDRASDR_MS_VENDOR_CMD = 19, + HYDRASDR_SET_RF_BIAS_CMD = 20, + HYDRASDR_GPIO_WRITE = 21, + HYDRASDR_GPIO_READ = 22, + HYDRASDR_GPIODIR_WRITE = 23, + HYDRASDR_GPIODIR_READ = 24, + HYDRASDR_GET_SAMPLERATES = 25, + HYDRASDR_SET_PACKING = 26, + HYDRASDR_SPIFLASH_ERASE_SECTOR = 27, + HYDRASDR_SET_RF_PORT = HYDRASDR_CMD_MAX +} hydrasdr_vendor_request; + +typedef enum +{ + GPIO_PORT0 = 0, + GPIO_PORT1 = 1, + GPIO_PORT2 = 2, + GPIO_PORT3 = 3, + GPIO_PORT4 = 4, + GPIO_PORT5 = 5, + GPIO_PORT6 = 6, + GPIO_PORT7 = 7 +} hydrasdr_gpio_port_t; + +typedef enum +{ + GPIO_PIN0 = 0, + GPIO_PIN1 = 1, + GPIO_PIN2 = 2, + GPIO_PIN3 = 3, + GPIO_PIN4 = 4, + GPIO_PIN5 = 5, + GPIO_PIN6 = 6, + GPIO_PIN7 = 7, + GPIO_PIN8 = 8, + GPIO_PIN9 = 9, + GPIO_PIN10 = 10, + GPIO_PIN11 = 11, + GPIO_PIN12 = 12, + GPIO_PIN13 = 13, + GPIO_PIN14 = 14, + GPIO_PIN15 = 15, + GPIO_PIN16 = 16, + GPIO_PIN17 = 17, + GPIO_PIN18 = 18, + GPIO_PIN19 = 19, + GPIO_PIN20 = 20, + GPIO_PIN21 = 21, + GPIO_PIN22 = 22, + GPIO_PIN23 = 23, + GPIO_PIN24 = 24, + GPIO_PIN25 = 25, + GPIO_PIN26 = 26, + GPIO_PIN27 = 27, + GPIO_PIN28 = 28, + GPIO_PIN29 = 29, + GPIO_PIN30 = 30, + GPIO_PIN31 = 31 +} hydrasdr_gpio_pin_t; + +typedef enum +{ + RF_PORT_RX0 = 0, /* RX Channel 0 (default/standard AIR_IN called ANT) */ + RF_PORT_RX1 = 1, /* RX Channel 1 (called also CABLE1) */ + RF_PORT_RX2 = 2 /* RX Channel 2 (called also CABLE2) */ +} hydrasdr_rf_port_t; + +#ifdef __cplusplus +} // __cplusplus defined. +#endif + +#endif//__HYDRASDR_COMMANDS_H__ ############################################ Thank you in advance and feel free if you have a cleaner way that work than the wrappers I made. Best regards, Seb

1 0

[PATCH 1/1] switch to cmake 3.13
by Cherniaev Andrei 14 Mar '25

14 Mar '25

stop to use make because since CMake 3.15 (Ubuntu 20.04), Generator can be set in env CMAKE_GENERATOR and sometimes it is not the Unix Makefiles; Tested in Ubuntu 24 Signed-off-by: Cherniaev Andrei <dungeonlords789(a)naver.com> --- CMakeLists.txt | 2 +- README.md | 8 +++----- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 3a6b0da..ad8c42f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -20,7 +20,7 @@ ######################################################################## # Project setup ######################################################################## -cmake_minimum_required(VERSION 3.8) +cmake_minimum_required(VERSION 3.13) project(gr-osmosdr CXX C) include(GNUInstallDirs) enable_testing() diff --git a/README.md b/README.md index 338b5b8..380b284 100644 --- a/README.md +++ b/README.md @@ -48,11 +48,9 @@ Building with cmake: ``` git clone https://gitea.osmocom.org/sdr/gr-osmosdr cd gr-osmosdr/ -mkdir build -cd build/ -cmake ../ -make -sudo make install +cmake -S . -B build +cmake --build build --parallel +sudo cmake --install build sudo ldconfig ``` -- 2.43.0

1 0

osmocom sink issue in GNU Radio 3.10.7
by edwar ewer 14 Feb '25

14 Feb '25

Dear gr-osmocom developers, I have a project that uses Jetson Xavier NX and BladeRF 2.0 to transmit and receive radar signals. I decided to use GNU Radio and gr-osmocom to do that task. Unfortunately, I encountered an error that, I think, GNU Radio failed to read all the parameters. This is the first time that I face this kind of error. I have been using GNU Radio for a while in a PC or Raspberry Pi but never see an error like this. Do you have any idea where is this error coming from and how to deal with it? Your suggestions are highly appreciated. Thank you. Best regards, Edwar [image: Screenshot from 2025-02-14 10-52-25.png] in osmocom sink and source.

1 0

[PATCH] Make osmocom_fft timezone-aware
by Stefan Zehl 26 Aug '24

26 Aug '24

Hi, I just stumbled across the problem that osmocom_fft's default recording filename does not contain the timezone. I think it would be a good idea to change that, and I hope you agree :) The change I propose is relatively simple: diff --git a/apps/osmocom_fft b/apps/osmocom_fft index c48ac7ee15..05a6de842c 100755 --- a/apps/osmocom_fft +++ b/apps/osmocom_fft @@ -326,7 +326,7 @@ class app_top_block(gr.top_block, Qt.QMainWindow): s = self._fre.text() s = s.replace('%S', '%e' % self.src.get_sample_rate()) s = s.replace('%F', '%e' % self.src.get_center_freq()) - s = s.replace('%T', datetime.datetime.now().strftime('%Y%m%d%H%M%S')) + s = s.replace('%T', datetime.datetime.now().astimezone().strftime('%Y%m%d%H%M%S%z')) return s def _set_status_msg(self, msg, timeout=0): CU, Sec -- "This 'telephone' has too many shortcomings to be seriously considered as a means of communication. The device is inherently of no value to us." -Western Union internal memo, 1876

1 0

Fix build errors for osmo-fl2k in mingw
by Philip Heron 17 May '24

17 May '24

Hi all, I've attached a patch that fixes a build error for osmo-fl2k under mingw. It seems that __argc and __argv are #defined by mingw as function calls. The patch simply removes the underscores in the argument names. Some of the errors: osmo-fl2k/src/fl2k_fm.c: In function 'main': osmo-fl2k/src/fl2k_fm.c:455:35: error: passing argument 1 of 'getopt_long' makes pointer from integer without a cast [-Wint- conversion] 455 | opt = getopt_long(argc, argv, "d:c:f:i:s:", long_options, &option_index); | ^~~~ | | | int In file included from /usr/x86_64-w64-mingw32/sys- root/mingw/include/_mingw.h:10, from /usr/x86_64-w64-mingw32/sys- root/mingw/include/corecrt.h:10, from /usr/x86_64-w64-mingw32/sys- root/mingw/include/corecrt_stdio_config.h:10, from /usr/x86_64-w64-mingw32/sys- root/mingw/include/stdio.h:9, from osmo-fl2k/src/fl2k_fm.c:26: osmo-fl2k/src/getopt/getopt.h:151:29: note: expected 'int *' but argument is of type 'int' 151 | extern int getopt_long (int __argc, char *const *__argv, const char *__shortopts, | ^ osmo-fl2k/src/fl2k_fm.c:455:41: error: passing argument 2 of 'getopt_long' from incompatible pointer type [-Wincompatible-pointer- types] 455 | opt = getopt_long(argc, argv, "d:c:f:i:s:", long_options, &option_index); | ^~~~ | | | char ** In file included from osmo-fl2k/src/fl2k_fm.c:27: osmo-fl2k/src/getopt/getopt.h:151:50: note: expected 'char * const** (*)()' but argument is of type 'char **' 151 | extern int getopt_long (int __argc, char *const *__argv, const char *__shortopts, | ^ Thanks, -Phil

1 0

[PATCH] Getting device fd from command line with termux-usb
by rio＠r26.me 22 Apr '24

22 Apr '24

Hello, I am working on getting rtl-sdr working on Android inside a Termux environment. Termux-usb (https://wiki.termux.com/wiki/Termux-usb) negotiates with Android to get an fd, and the fd gets passed as command line argument to the program needing the USB device. This patch adds support for it. With it, I can run termux-usb -e "./rtl-sdr/build/src/rtl_fm -f 440M -M fm -N" /dev/bus/usb/001/002 | ./direwolf/build/src/direwolf -t 0 stdin in Termux, and connecto to it from APRSDroid. --- include/rtl-sdr.h | 2 ++ src/librtlsdr.c | 92 +++++++++++++++++++++++++++++++++++++++++++++-- src/rtl_adsb.c | 21 ++++++++--- src/rtl_biast.c | 19 +++++++--- src/rtl_fm.c | 19 +++++++--- src/rtl_power.c | 19 +++++++--- src/rtl_sdr.c | 17 +++++++-- src/rtl_tcp.c | 19 +++++++--- src/rtl_test.c | 19 +++++++--- 9 files changed, 196 insertions(+), 31 deletions(-) diff --git a/include/rtl-sdr.h b/include/rtl-sdr.h index d64701e..bd88f74 100644 --- a/include/rtl-sdr.h +++ b/include/rtl-sdr.h @@ -62,6 +62,8 @@ RTLSDR_API int rtlsdr_get_index_by_serial(const char *serial); RTLSDR_API int rtlsdr_open(rtlsdr_dev_t **dev, uint32_t index); +RTLSDR_API int rtlsdr_open_fd(rtlsdr_dev_t **dev, intptr_t fd); + RTLSDR_API int rtlsdr_close(rtlsdr_dev_t *dev); /* configuration functions */ diff --git a/src/librtlsdr.c b/src/librtlsdr.c index ee13556..1c4985b 100644 --- a/src/librtlsdr.c +++ b/src/librtlsdr.c @@ -125,6 +125,7 @@ struct rtlsdr_dev { void rtlsdr_set_gpio_bit(rtlsdr_dev_t *dev, uint8_t gpio, int val); static int rtlsdr_set_if_freq(rtlsdr_dev_t *dev, uint32_t freq); +static int rtlsdr_init(rtlsdr_dev_t *dev); /* generic tuner interface functions, shall be moved to the tuner implementations */ int e4000_init(void *dev) { @@ -1451,7 +1452,6 @@ int rtlsdr_open(rtlsdr_dev_t **out_dev, uint32_t index) libusb_device *device = NULL; uint32_t device_count = 0; struct libusb_device_descriptor dd; - uint8_t reg; ssize_t cnt; dev = malloc(sizeof(rtlsdr_dev_t)); @@ -1503,6 +1503,94 @@ int rtlsdr_open(rtlsdr_dev_t **out_dev, uint32_t index) libusb_free_device_list(list, 1); + r = rtlsdr_init(dev); + if (r < 0) { + goto err; + } + + *out_dev = dev; + + return r; +err: + if (dev) { + if (dev->devh) + libusb_close(dev->devh); + + if (dev->ctx) + libusb_exit(dev->ctx); + + free(dev); + } + + return r; +} + +int rtlsdr_open_fd(rtlsdr_dev_t **out_dev, intptr_t fd) +{ + int r; + rtlsdr_dev_t *dev = NULL; + libusb_device *device = NULL; + struct libusb_device_descriptor dd; + + dev = malloc(sizeof(rtlsdr_dev_t)); + if (NULL == dev) + return -ENOMEM; + + memset(dev, 0, sizeof(rtlsdr_dev_t)); + memcpy(dev->fir, fir_default, sizeof(fir_default)); + + libusb_set_option(NULL, LIBUSB_OPTION_NO_DEVICE_DISCOVERY); + r = libusb_init(&dev->ctx); + if(r < 0){ + free(dev); + return -1; + } + + dev->dev_lost = 1; + + r = libusb_wrap_sys_device(dev->ctx, fd, &dev->devh); + if (r < 0) { + fprintf(stderr, "usb_open error %d\n", r); + if(r == LIBUSB_ERROR_ACCESS) + fprintf(stderr, "Please fix the device permissions, e.g. " + "by installing the udev rules file rtl-sdr.rules\n"); + goto err; + } + + device = libusb_get_device(dev->devh); + libusb_get_device_descriptor(device, &dd); + if (!find_known_device(dd.idVendor, dd.idProduct)) { + fprintf(stderr, "Unrecognized device\n"); + r = -1; + goto err; + } + + r = rtlsdr_init(dev); + if (r < 0) { + goto err; + } + + *out_dev = dev; + + return r; +err: + if (dev) { + if (dev->devh) + libusb_close(dev->devh); + + if (dev->ctx) + libusb_exit(dev->ctx); + + free(dev); + } + + return r; +} + +static int rtlsdr_init(rtlsdr_dev_t *dev) { + int r; + uint8_t reg; + if (libusb_kernel_driver_active(dev->devh, 0) == 1) { dev->driver_active = 1; @@ -1639,8 +1727,6 @@ found: rtlsdr_set_i2c_repeater(dev, 0); - *out_dev = dev; - return 0; err: if (dev) { diff --git a/src/rtl_adsb.c b/src/rtl_adsb.c index 8119ac8..ae5eccd 100644 --- a/src/rtl_adsb.c +++ b/src/rtl_adsb.c @@ -89,7 +89,8 @@ void usage(void) fprintf(stderr, "rtl_adsb, a simple ADS-B decoder\n\n" "Use:\trtl_adsb [-R] [-g gain] [-p ppm] [output file]\n" - "\t[-d device_index (default: 0)]\n" + "\t[-d device_index (default: 1)]\n" + "\t[-N file_desc use file descriptor instead of libusb index\n" "\t[-V verbove output (default: off)]\n" "\t[-S show short frames (default: off)]\n" "\t[-Q quality (0: no sanity checks, 0.5: half bit, 1: one bit (default), 2: two bits)]\n" @@ -372,19 +373,24 @@ int main(int argc, char **argv) int gain = AUTO_GAIN; /* tenths of a dB */ int dev_index = 0; int dev_given = 0; + int fd_given = 0; int ppm_error = 0; int enable_biastee = 0; pthread_cond_init(&ready, NULL); pthread_mutex_init(&ready_m, NULL); squares_precompute(); - while ((opt = getopt(argc, argv, "d:g:p:e:Q:VST")) != -1) + while ((opt = getopt(argc, argv, "d:N:g:p:e:Q:VST")) != -1) { switch (opt) { case 'd': dev_index = verbose_device_search(optarg); dev_given = 1; break; + case 'N': + dev_index = atoi(optarg); + fd_given = 1; + break; case 'g': gain = (int)(atof(optarg) * 10); break; @@ -420,7 +426,7 @@ int main(int argc, char **argv) buffer = malloc(DEFAULT_BUF_LENGTH * sizeof(uint8_t)); - if (!dev_given) { + if (!dev_given && !fd_given) { dev_index = verbose_device_search("0"); } @@ -428,7 +434,12 @@ int main(int argc, char **argv) exit(1); } - r = rtlsdr_open(&dev, (uint32_t)dev_index); + if (fd_given) { + r = rtlsdr_open_fd(&dev, dev_index); + } else { + r = rtlsdr_open(&dev, (uint32_t)dev_index); + } + if (r < 0) { fprintf(stderr, "Failed to open rtlsdr device #%d.\n", dev_index); exit(1); @@ -493,7 +504,7 @@ int main(int argc, char **argv) else { fprintf(stderr, "\nLibrary error %d, exiting...\n", r);} rtlsdr_cancel_async(dev); - pthread_cancel(demod_thread); + pthread_kill(demod_thread, 0); pthread_join(demod_thread, NULL); pthread_cond_destroy(&ready); pthread_mutex_destroy(&ready_m); diff --git a/src/rtl_biast.c b/src/rtl_biast.c index 185e838..e9c914e 100644 --- a/src/rtl_biast.c +++ b/src/rtl_biast.c @@ -41,7 +41,8 @@ void usage(void) "bias tee: rtl_biast -d 0 -b 1\n" "Any GPIO: rtl_biast -d 0 -g 1 -b 1\n\n" "Usage:\n" - "\t[-d device_index (default: 0)]\n" + "\t[-d device_index (default: 1)]\n" + "\t[-N file_desc use file descriptor instead of libusb index\n" "\t[-b bias_on (default: 0)]\n" "\t[-g GPIO select (default: 0)]\n"); exit(1); @@ -52,16 +53,21 @@ int main(int argc, char **argv) int i, r, opt; int dev_index = 0; int dev_given = 0; + int fd_given = 0; uint32_t bias_on = 0; uint32_t gpio_pin = 0; int device_count; - while ((opt = getopt(argc, argv, "d:b:g:h?")) != -1) { + while ((opt = getopt(argc, argv, "d:N:b:g:h?")) != -1) { switch (opt) { case 'd': dev_index = verbose_device_search(optarg); dev_given = 1; break; + case 'N': + dev_index = atoi(optarg); + fd_given = 1; + break; case 'b': bias_on = atoi(optarg); break; @@ -74,7 +80,7 @@ int main(int argc, char **argv) } } - if (!dev_given) { + if (!dev_given && !fd_given) { dev_index = verbose_device_search("0"); } @@ -82,7 +88,12 @@ int main(int argc, char **argv) exit(1); } - r = rtlsdr_open(&dev, dev_index); + if (fd_given) { + r = rtlsdr_open_fd(&dev, dev_index); + } else { + r = rtlsdr_open(&dev, (uint32_t)dev_index); + } + rtlsdr_set_bias_tee_gpio(dev, gpio_pin, bias_on); exit: diff --git a/src/rtl_fm.c b/src/rtl_fm.c index 037793c..c1b562c 100644 --- a/src/rtl_fm.c +++ b/src/rtl_fm.c @@ -192,7 +192,8 @@ void usage(void) "\t wbfm == -M fm -s 170k -o 4 -A fast -r 32k -l 0 -E deemp\n" "\t raw mode outputs 2x16 bit IQ pairs\n" "\t[-s sample_rate (default: 24k)]\n" - "\t[-d device_index (default: 0)]\n" + "\t[-d device_index (default: 1)]\n" + "\t[-N file_desc use file descriptor instead of libusb index\n" "\t[-T enable bias-T on GPIO PIN 0 (works for rtl-sdr.com v3 dongles)]\n" "\t[-g tuner_gain (default: automatic)]\n" "\t[-l squelch_level (default: 0/off)]\n" @@ -1057,6 +1058,7 @@ int main(int argc, char **argv) #endif int r, opt; int dev_given = 0; + int fd_given = 0; int custom_ppm = 0; int enable_biastee = 0; dongle_init(&dongle); @@ -1064,12 +1066,16 @@ int main(int argc, char **argv) output_init(&output); controller_init(&controller); - while ((opt = getopt(argc, argv, "d:f:g:s:b:l:o:t:r:p:E:F:A:M:hT")) != -1) { + while ((opt = getopt(argc, argv, "d:N:f:g:s:b:l:o:t:r:p:E:F:A:M:hT")) != -1) { switch (opt) { case 'd': dongle.dev_index = verbose_device_search(optarg); dev_given = 1; break; + case 'N': + dongle.dev_index = atoi(optarg); + fd_given = 1; + break; case 'f': if (controller.freq_len >= FREQUENCIES_LIMIT) { break;} @@ -1190,7 +1196,7 @@ int main(int argc, char **argv) ACTUAL_BUF_LENGTH = lcm_post[demod.post_downsample] * DEFAULT_BUF_LENGTH; - if (!dev_given) { + if (!dev_given && !fd_given) { dongle.dev_index = verbose_device_search("0"); } @@ -1198,7 +1204,12 @@ int main(int argc, char **argv) exit(1); } - r = rtlsdr_open(&dongle.dev, (uint32_t)dongle.dev_index); + if (fd_given) { + r = rtlsdr_open_fd(&dongle.dev, dongle.dev_index); + } else { + r = rtlsdr_open(&dongle.dev, (uint32_t)dongle.dev_index); + } + if (r < 0) { fprintf(stderr, "Failed to open rtlsdr device #%d.\n", dongle.dev_index); exit(1); diff --git a/src/rtl_power.c b/src/rtl_power.c index df3ceb7..3c750ce 100644 --- a/src/rtl_power.c +++ b/src/rtl_power.c @@ -130,7 +130,8 @@ void usage(void) "\t[-e exit_timer (default: off/0)]\n" //"\t[-s avg/iir smoothing (default: avg)]\n" //"\t[-t threads (default: 1)]\n" - "\t[-d device_index (default: 0)]\n" + "\t[-d device_index (default: 1)]\n" + "\t[-N file_desc use file descriptor instead of libusb index\n" "\t[-g tuner_gain (default: automatic)]\n" "\t[-p ppm_error (default: 0)]\n" "\t[-T enable bias-T on GPIO PIN 0 (works for rtl-sdr.com v3 dongles)]\n" @@ -774,6 +775,7 @@ int main(int argc, char **argv) int gain = AUTO_GAIN; // tenths of a dB int dev_index = 0; int dev_given = 0; + int fd_given = 0; int ppm_error = 0; int interval = 10; int fft_threads = 1; @@ -792,7 +794,7 @@ int main(int argc, char **argv) double (*window_fn)(int, int) = rectangle; freq_optarg = ""; - while ((opt = getopt(argc, argv, "f:i:s:t:d:g:p:e:w:c:F:1PDOhT")) != -1) { + while ((opt = getopt(argc, argv, "f:i:s:t:d:N:g:p:e:w:c:F:1PDOhT")) != -1) { switch (opt) { case 'f': // lower:upper:bin_size freq_optarg = strdup(optarg); @@ -802,6 +804,10 @@ int main(int argc, char **argv) dev_index = verbose_device_search(optarg); dev_given = 1; break; + case 'N': + dev_index = atoi(optarg); + fd_given = 1; + break; case 'g': gain = (int)(atof(optarg) * 10); break; @@ -896,7 +902,7 @@ int main(int argc, char **argv) fprintf(stderr, "Reporting every %i seconds\n", interval); - if (!dev_given) { + if (!dev_given && !fd_given) { dev_index = verbose_device_search("0"); } @@ -904,7 +910,12 @@ int main(int argc, char **argv) exit(1); } - r = rtlsdr_open(&dev, (uint32_t)dev_index); + if (fd_given) { + r = rtlsdr_open_fd(&dev, dev_index); + } else { + r = rtlsdr_open(&dev, (uint32_t)dev_index); + } + if (r < 0) { fprintf(stderr, "Failed to open rtlsdr device #%d.\n", dev_index); exit(1); diff --git a/src/rtl_sdr.c b/src/rtl_sdr.c index ccd6d76..60acd78 100644 --- a/src/rtl_sdr.c +++ b/src/rtl_sdr.c @@ -49,7 +49,8 @@ void usage(void) "rtl_sdr, an I/Q recorder for RTL2832 based DVB-T receivers\n\n" "Usage:\t -f frequency_to_tune_to [Hz]\n" "\t[-s samplerate (default: 2048000 Hz)]\n" - "\t[-d device_index (default: 0)]\n" + "\t[-d device_index (default: 1)]\n" + "\t[-N file_desc use file descriptor instead of libusb index\n" "\t[-g gain (default: 0 for auto)]\n" "\t[-p ppm_error (default: 0)]\n" "\t[-b output_block_size (default: 16 * 16384)]\n" @@ -120,6 +121,7 @@ int main(int argc, char **argv) uint8_t *buffer; int dev_index = 0; int dev_given = 0; + int fd_given = 0; uint32_t frequency = 100000000; uint32_t samp_rate = DEFAULT_SAMPLE_RATE; uint32_t out_block_size = DEFAULT_BUF_LENGTH; @@ -130,6 +132,10 @@ int main(int argc, char **argv) dev_index = verbose_device_search(optarg); dev_given = 1; break; + case 'N': + dev_index = atoi(optarg); + fd_given = 1; + break; case 'f': frequency = (uint32_t)atofs(optarg); break; @@ -179,7 +185,7 @@ int main(int argc, char **argv) buffer = malloc(out_block_size * sizeof(uint8_t)); - if (!dev_given) { + if (!dev_given && !fd_given) { dev_index = verbose_device_search("0"); } @@ -187,7 +193,12 @@ int main(int argc, char **argv) exit(1); } - r = rtlsdr_open(&dev, (uint32_t)dev_index); + if (fd_given) { + r = rtlsdr_open_fd(&dev, dev_index); + } else { + r = rtlsdr_open(&dev, (uint32_t)dev_index); + } + if (r < 0) { fprintf(stderr, "Failed to open rtlsdr device #%d.\n", dev_index); exit(1); diff --git a/src/rtl_tcp.c b/src/rtl_tcp.c index 78d625a..c3d5e11 100644 --- a/src/rtl_tcp.c +++ b/src/rtl_tcp.c @@ -102,7 +102,8 @@ void usage(void) printf("\t[-s samplerate in Hz (default: %d Hz)]\n", DEFAULT_SAMPLE_RATE_HZ); printf("\t[-b number of buffers (default: 15, set by library)]\n"); printf("\t[-n max number of linked list buffers to keep (default: %d)]\n", DEFAULT_MAX_NUM_BUFFERS); - printf("\t[-d device index (default: 0)]\n"); + printf("\t[-d device_index (default: 1)]\n"); + printf("\t[-N file_desc use file descriptor instead of libusb index\n"); printf("\t[-P ppm_error (default: 0)]\n"); printf("\t[-T enable bias-T on GPIO PIN 0 (works for rtl-sdr.com v3 dongles)]\n"); printf("\t[-D enable direct sampling (default: off)]\n"); @@ -395,6 +396,7 @@ int main(int argc, char **argv) uint32_t buf_num = 0; int dev_index = 0; int dev_given = 0; + int fd_given = 0; int gain = 0; int ppm_error = 0; int direct_sampling = 0; @@ -415,12 +417,16 @@ int main(int argc, char **argv) struct sigaction sigact, sigign; #endif - while ((opt = getopt(argc, argv, "a:p:f:g:s:b:n:d:P:TD")) != -1) { + while ((opt = getopt(argc, argv, "a:p:f:g:s:b:n:d:N:P:TD")) != -1) { switch (opt) { case 'd': dev_index = verbose_device_search(optarg); dev_given = 1; break; + case 'N': + dev_index = atoi(optarg); + fd_given = 1; + break; case 'f': frequency = (uint32_t)atofs(optarg); break; @@ -460,7 +466,7 @@ int main(int argc, char **argv) if (argc < optind) usage(); - if (!dev_given) { + if (!dev_given && !fd_given) { dev_index = verbose_device_search("0"); } @@ -468,7 +474,12 @@ int main(int argc, char **argv) exit(1); } - rtlsdr_open(&dev, (uint32_t)dev_index); + if (fd_given) { + r = rtlsdr_open_fd(&dev, dev_index); + } else { + r = rtlsdr_open(&dev, (uint32_t)dev_index); + } + if (NULL == dev) { fprintf(stderr, "Failed to open rtlsdr device #%d.\n", dev_index); exit(1); diff --git a/src/rtl_test.c b/src/rtl_test.c index b7f46ea..033aeb1 100644 --- a/src/rtl_test.c +++ b/src/rtl_test.c @@ -90,7 +90,8 @@ void usage(void) "rtl_test, a benchmark tool for RTL2832 based DVB-T receivers\n\n" "Usage:\n" "\t[-s samplerate (default: 2048000 Hz)]\n" - "\t[-d device_index (default: 0)]\n" + "\t[-d device_index (default: 1)]\n" + "\t[-N file_desc use file descriptor instead of libusb index\n" "\t[-t enable Elonics E4000 tuner benchmark]\n" #ifndef _WIN32 "\t[-p[seconds] enable PPM error measurement (default: 10 seconds)]\n" @@ -312,16 +313,21 @@ int main(int argc, char **argv) uint8_t *buffer; int dev_index = 0; int dev_given = 0; + int fd_given = 0; uint32_t out_block_size = DEFAULT_BUF_LENGTH; int count; int gains[100]; - while ((opt = getopt(argc, argv, "d:s:b:tp::Sh")) != -1) { + while ((opt = getopt(argc, argv, "d:N:D:s:b:tp::Sh")) != -1) { switch (opt) { case 'd': dev_index = verbose_device_search(optarg); dev_given = 1; break; + case 'N': + dev_index = atoi(optarg); + fd_given = 1; + break; case 's': samp_rate = (uint32_t)atof(optarg); break; @@ -359,7 +365,7 @@ int main(int argc, char **argv) buffer = malloc(out_block_size * sizeof(uint8_t)); - if (!dev_given) { + if (!dev_given && !fd_given) { dev_index = verbose_device_search("0"); } @@ -367,7 +373,12 @@ int main(int argc, char **argv) exit(1); } - r = rtlsdr_open(&dev, (uint32_t)dev_index); + if (fd_given) { + r = rtlsdr_open_fd(&dev, dev_index); + } else { + r = rtlsdr_open(&dev, (uint32_t)dev_index); + } + if (r < 0) { fprintf(stderr, "Failed to open rtlsdr device #%d.\n", dev_index); exit(1); -- 2.44.0

1 0

Jump to page:

2026

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

osmocom-sdr