osmocom-sdr

osmocom-sdr@lists.osmocom.org

3 participants
909 discussions

Using rtl-sdr libraries from scratch
by madoak92＠gmail.com 25 Feb '22

25 Feb '22

Hi everyone! I'm so interested about using the rtl-sdr libraries for creating some own applications, but am a bit lost concerning the code structure and the interaction between cmake and the libraries. I have some background in C programming, but I haven't write any code as complicated, and nor of course have I had to use tools like cmake to distribute code, only I've used some Makefiles in order to compile locally a basic code. With this background, I'm trying to manage antenna switches within an array, but I need some new functionalities in the rtl_biast.c code. For this purpose, I have to use the following functions: rtlsdr_set_bias_tee rtlsdr_set_i2c_repeater rtlsdr_i2c_write_reg rtlsdr_close_bt I have modified the code but when I execute cmake and make again, I obtain errors regarding the file dependencies, saying that these functions are undeclared. How should I change the file dependencies/include and recompile it in order to make it works? Could you help me to understand the compilation process in order to arrange my own applications using rtl-sdr libraries locally? I assume I have to study thoroughly the cmake and make advanced topics, but it's a bit overwhelming and I would like to learn about it constructing the code from the basic pieces. Thank you very much in advance.

1 0

FOSDEM 2022 - Free Software Radio Devroom
by Andrej Rode 05 Feb '22

05 Feb '22

Hi all, I’d like to invite you all to join the Free Software Radio Devroom at the FOSDEM 2022 online event tomorrow February 6th 2022 at 1300 (CET). We have a range of very interesting presentations ranging from project updates, implementation of hardware accelerators for Software Radio up to receiving communication from the most distant artificial object from Earth. You can find the full schedule here: https://fosdem.org/2022/schedule/track/free_software_radio/ You can either join just the livestream of the event, but I really encourage you to join the Matrix chat to ask questions you might have and continue discussion about the presentation after it is finished, you can even join the video call for a more direct way of communication. You can find information about the chat system here: https://fosdem.org/2022/practical/online/. If you are already a member of the GNU Radio Matrix server, you don’t have to create a new account or anything. You can simply visit: https://matrix.to/#/#space-radio-devroom:fosdem.org to join the dedicated "Free Software Radio Devroom space". This space contains the main chatroom during the devroom but also you will find all dedicated presentation chatrooms in there after the presentation has finished to continue in-depth discussion. During the presentation you can ask questions in the chat and upvote questions of others, at the end of the presentation there will be a short live Q&A where a presentation host will address said questions directly to the presenter. If your question is not answered during this time you are welcome to join the presentation chatroom to ask yourself. I hope to “see” many of you tomorrow. And a big thanks for everyone presenting or helping to make this Devroom possible this year! Cheers Andrej

1 0

Help on patch submission process for a fix in rtlsdr
by Gonzalo José Carracedo Carballal 04 Feb '22

04 Feb '22

Hi, Long story short: I have a fix for a crash in Windows in librtlsdr when closing the device, and I'd love to submit a patch. I went through this page: https://osmocom.org/projects/cellular-infrastructure/wiki/Coding_standards and saw that I have to follow certain steps (design, review, etc) but I am not quite sure who to contact. For some projects, this is somehow automatized by means of Gerrit, but it looks that this is not the case for librtlsdr (yet) I'd like to do it the right way, how should I proceed? Should I post the patch here directly? Do I have to document the design of my fix and have it reviewed first somewhere else? Bit of backstory: some days ago I came across a crash in librtlsdr for Windows when closing the device (initially reported as a potential libusb bug, see https://github.com/libusb/libusb/issues/1043). Although workarounds existed (https://github.com/TALUAtGitHub/librtlsdr/commit/27d79d258c0fffb73afd3fffd3…) they relied on a somewhat arbitrary (1 ms) delay to give some time for libusb event callbacks to be triggered before resource cleanup. This was not working anymore, so I decided to look into it and ended up working on a solution. This solution involved refactoring the transfer / buffer array into an array of transfer objects that enabled synchronous cancellation of pending transfers (see https://github.com/BatchDrake/rtl-sdr-blog/blob/feature/xfer-completion/src…). Since it seems to work rather well, I though it could be interesting to submit a patch to have this fixed upstream. Thanks in advance, -- >> Gonzalo José Carracedo Carballal

2 1

[PATCH] call libsub_intertrupt_event_handler in rtlsdr_cancel_async
by Jasper 26 Jan '22

26 Jan '22

Please find below a patch as per suggestion of Martin Ling: call libusb_interrupt_event_handler in rtlsdr_cancel_async to trigger the event loop handler to look at the async_cancel variable. (https://lists.osmocom.org/hyperkitty/list/osmocom-sdr@lists.osmocom.org/thr…) I have tested timings on a windows 11 machine with and without the patch when running a async transfer at two different sampling rates: sample rate with without theory 1536K 0 - 2 ms 0 - 84 ms 85 ms 288K 0 - 4 ms 0 - 457 ms 455 ms The table shows the range of timings to cancel the async transfer as measured over a couple of runs. The "theory" column shows the theoretical time to complete one transfer at the particular sampling rate (i.e. driven by the size of a transfer buffer). And indeed, on some machines it appears that cancelling the async transfer, if unlucky, can take as much time as waiting for a full transfer to complete. The call to libsub_intertrupt_event_handler fixes that. For large transfer buffers and/or low sample rates this can make a difference. Thanks to Martin for sharing the insight. Jasper Author: jvde.github <jvde.github(a)gmail.com> Date: Wed Jan 26 19:00:55 2022 +0100 call interrupt_event_handler in cancel_async diff --git a/src/librtlsdr.c b/src/librtlsdr.c index 67e30c4..b949692 100644 --- a/src/librtlsdr.c +++ b/src/librtlsdr.c @@ -1948,6 +1948,9 @@ int rtlsdr_cancel_async(rtlsdr_dev_t *dev) if (RTLSDR_RUNNING == dev->async_status) { dev->async_status = RTLSDR_CANCELING; dev->async_cancel = 1; + + libusb_interrupt_event_handler(dev->ctx); + return 0; }

1 0

[PATCH] count number of open transfers and ensure zero open transfers before freeing memory
by Jasper 24 Jan '22

24 Jan '22

Hi all, As per discussion with Martin Ling on this mailing list, please find below a proposed patch that simplifies the async_read, keeps track of open tranfers and checks for zero open transfers before closing to avoid unidentified behaviour at close. Thanks, Jasper commit 4b06ae321e91296f13355a0715e9a961b4f57e45 Author: jvde.github <jvde.github(a)gmail.com> Date: Mon Jan 24 20:15:34 2022 +0100 count live transfers before close diff --git a/src/librtlsdr.c b/src/librtlsdr.c index 096abae..67e30c4 100644 --- a/src/librtlsdr.c +++ b/src/librtlsdr.c @@ -119,6 +119,7 @@ struct rtlsdr_dev { int dev_lost; int driver_active; unsigned int xfer_errors; + int live_transfers; }; void rtlsdr_set_gpio_bit(rtlsdr_dev_t *dev, uint8_t gpio, int val); @@ -1695,11 +1696,15 @@ static void LIBUSB_CALL _libusb_callback(struct libusb_transfer *xfer) { rtlsdr_dev_t *dev = (rtlsdr_dev_t *)xfer->user_data; + dev->live_transfers --; + if (LIBUSB_TRANSFER_COMPLETED == xfer->status) { if (dev->cb) dev->cb(xfer->buffer, xfer->actual_length, dev->cb_ctx); - libusb_submit_transfer(xfer); /* resubmit transfer */ + if(!dev->async_cancel) + if( libusb_submit_transfer(xfer) == 0) /* resubmit transfer */ + dev->live_transfers++; dev->xfer_errors = 0; } else if (LIBUSB_TRANSFER_CANCELLED != xfer->status) { #ifndef _WIN32 @@ -1847,9 +1852,9 @@ int rtlsdr_read_async(rtlsdr_dev_t *dev, rtlsdr_read_async_cb_t cb, void *ctx, { unsigned int i; int r = 0; + int ret = 0; struct timeval tv = { 1, 0 }; - struct timeval zerotv = { 0, 0 }; - enum rtlsdr_async_status next_status = RTLSDR_INACTIVE; + struct timeval canceltv = { 0, 50 }; if (!dev) return -1; @@ -1863,6 +1868,7 @@ int rtlsdr_read_async(rtlsdr_dev_t *dev, rtlsdr_read_async_cb_t cb, void *ctx, dev->cb = cb; dev->cb_ctx = ctx; + if (buf_num > 0) dev->xfer_buf_num = buf_num; else @@ -1875,6 +1881,8 @@ int rtlsdr_read_async(rtlsdr_dev_t *dev, rtlsdr_read_async_cb_t cb, void *ctx, _rtlsdr_alloc_async_buffers(dev); + dev->live_transfers = 0; + for(i = 0; i < dev->xfer_buf_num; ++i) { libusb_fill_bulk_transfer(dev->xfer[i], dev->devh, @@ -1894,64 +1902,41 @@ int rtlsdr_read_async(rtlsdr_dev_t *dev, rtlsdr_read_async_cb_t cb, void *ctx, "echo 0 > /sys/module/usbcore" "/parameters/usbfs_memory_mb\n", i); dev->async_status = RTLSDR_CANCELING; + ret = -3; break; } + else + dev->live_transfers++; } - while (RTLSDR_INACTIVE != dev->async_status) { + while (RTLSDR_RUNNING == dev->async_status) { r = libusb_handle_events_timeout_completed(dev->ctx, &tv, - &dev->async_cancel); + &dev->async_cancel); if (r < 0) { /*fprintf(stderr, "handle_events returned: %d\n", r);*/ if (r == LIBUSB_ERROR_INTERRUPTED) /* stray signal */ continue; - break; + rtlsdr_cancel_async(dev); + ret = -4; } + } - if (RTLSDR_CANCELING == dev->async_status) { - next_status = RTLSDR_INACTIVE; + if (!dev->xfer) return -5; - if (!dev->xfer) - break; + for(i = 0; i < dev->xfer_buf_num; ++i) + if (dev->xfer[i]) + libusb_cancel_transfer(dev->xfer[i]); - for(i = 0; i < dev->xfer_buf_num; ++i) { - if (!dev->xfer[i]) - continue; + for (i = 0; i < dev->xfer_buf_num && dev->live_transfers > 0; ++i) + libusb_handle_events_timeout_completed(dev->ctx, &canceltv, NULL); - if (LIBUSB_TRANSFER_CANCELLED != - dev->xfer[i]->status) { - r = libusb_cancel_transfer(dev->xfer[i]); - /* handle events after canceling - * to allow transfer status to - * propagate */ -#ifdef _WIN32 - Sleep(1); -#endif - libusb_handle_events_timeout_completed(dev->ctx, - &zerotv, NULL); - if (r < 0) - continue; - - next_status = RTLSDR_CANCELING; - } - } - - if (dev->dev_lost || RTLSDR_INACTIVE == next_status) { - /* handle any events that still need to - * be handled before exiting after we - * just cancelled all transfers */ - libusb_handle_events_timeout_completed(dev->ctx, - &zerotv, NULL); - break; - } - } - } + if(dev->live_transfers > 0) return -6; _rtlsdr_free_async_buffers(dev); - dev->async_status = next_status; + dev->async_status = RTLSDR_INACTIVE; - return r; + return ret; } int rtlsdr_cancel_async(rtlsdr_dev_t *dev)

1 0

[PATCH] librtlsdr: force wait state after lib_cancel_transfer to avoid crash on close in windows
by Jasper van den Eshof 24 Jan '22

24 Jan '22

Good day! I was struggling with an occasional crash of the rtl-sdr tools on windows when closing the device after pressing CTRL-C. Both with the versions as provided with VCPKG and when directly compiling the latest version in MSVC (with latest of libusb). It is a bit difficult to spot a crash at close as usually it is silent but you can see it running it from MSVC or in a debugger. It does not happen always but frequent enough. Also, consider this example for the binary versions from Jan 2 (https://ftp.osmocom.org/binaries/windows/rtl-sdr/): C:\>rtl_adsb.exe Found 1 device(s): 0: Realtek, RTL2838UHIDIR, SN: 00000001 Using device 0: Generic RTL2832U OEM Found Rafael Micro R820T tuner .... Signal caught, exiting! User cancel, exiting... C:\>echo %ERRORLEVEL% -1073741819 After investigation of the libusb logs and experimentation I think this crash can be avoided by 1) defining zerotv in rtlsdr_read_async as 1 ms instead of zero (see libusb/libusb#1043) or 2) include a short call to Sleep to allow async operations to finish. Please find below a patch for the latter fix for your consideration. More information, here: https://github.com/osmocom/rtl-sdr/pull/18 and here: https://github.com/libusb/libusb/issues/1043 Thanks for your great work on the rtlsdr library and kind regards. Author: jvde.github <jvde.github(a)gmail.com> Date: Sat Jan 8 13:30:34 2022 +0100 force wait state after cancel of usb transfer and before handling usb events diff --git a/src/librtlsdr.c b/src/librtlsdr.c index 0146298..2682d77 100644 --- a/src/librtlsdr.c +++ b/src/librtlsdr.c @@ -1930,6 +1930,9 @@ int rtlsdr_read_async(rtlsdr_dev_t *dev, rtlsdr_read_async_cb_t cb, void *ctx, /* handle events after canceling * to allow transfer status to * propagate */ +#ifdef _WIN32 + Sleep(1); +#endif libusb_handle_events_timeout_completed(dev->ctx, &zerotv, NULL); if (r < 0)

4 6

[PATCH] fix build issue on macOS by adding libusb shared lib directory to search path
by Jasper 24 Jan '22

24 Jan '22

Hi all, on some systems building librtlsdr can fail when libusb-1.0 is not installed in the standard library locations (e.g. macOS with libusb installed via homebrew can have the shared library in /usr/local/Cellar/libusb/1.0.24/lib). The below patch includes LIBUSB_LIBRARY_DIRS in the search path for the linker to correct this issue. For your kind consideration. Thanks, Jasper Author: jvde.github <jvde.github(a)gmail.com> Date: Mon Jan 24 19:21:44 2022 +0100 fix build for macOS diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 7b47309..3b8060b 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -21,6 +21,7 @@ add_library(rtlsdr SHARED librtlsdr.c tuner_e4k.c tuner_fc0012.c tuner_fc0013.c tuner_fc2580.c tuner_r82xx.c) target_link_libraries(rtlsdr ${LIBUSB_LIBRARIES} ${THREADS_PTHREADS_LIBRARY}) +target_link_directories(rtlsdr PUBLIC ${LIBUSB_LIBRARY_DIRS}) target_include_directories(rtlsdr PUBLIC $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/include> $<INSTALL_INTERFACE:include> # <prefix>/include

1 0

[PATCH] rfspace: Add PPM correction
by argilo＠gmail.com 23 Jan '22

23 Jan '22

From: Clayton Smith <argilo(a)gmail.com> This patch was originally written by Alexandru Csete and posted at https://github.com/csete/gr-osmosdr-gqrx/commit/d66df300. The only change I made was to rename the _freq_corr_ppm variable to _freq_corr, since many other devices use that name. This patch used to be included in Gqrx releases, so it should work correctly. --- lib/rfspace/rfspace_source_c.cc | 17 +++++++++++++---- lib/rfspace/rfspace_source_c.h | 2 ++ 2 files changed, 15 insertions(+), 4 deletions(-) diff --git a/lib/rfspace/rfspace_source_c.cc b/lib/rfspace/rfspace_source_c.cc index 314dfc732d..113588a5d4 100644 --- a/lib/rfspace/rfspace_source_c.cc +++ b/lib/rfspace/rfspace_source_c.cc @@ -103,6 +103,7 @@ rfspace_source_c::rfspace_source_c (const std::string &args) _nchan(1), _sample_rate(NAN), _bandwidth(0.0f), + _freq_corr(0.0), _fifo(NULL) { std::string host = ""; @@ -446,6 +447,8 @@ rfspace_source_c::rfspace_source_c (const std::string &args) _thread = gr::thread::thread( boost::bind(&rfspace_source_c::tcp_keepalive_task, this) ); } + _center_freq = get_center_freq(); + #if 0 std::cerr << "sample_rates: " << get_sample_rates().to_pp_string() << std::endl; std::cerr << "sample rate: " << (uint32_t)get_sample_rate() << std::endl; @@ -600,7 +603,7 @@ static size_t read_bytes( int fd, char *data, size_t size, bool &run ) int nread = read( fd, &data[nbytes], 1 ); if ( nread == 0 ) - continue; + continue; if ( nread < 0 ) break; @@ -1378,7 +1381,10 @@ osmosdr::freq_range_t rfspace_source_c::get_freq_range( size_t chan ) double rfspace_source_c::set_center_freq( double freq, size_t chan ) { - uint32_t u32_freq = freq; + uint32_t u32_freq; + + u32_freq = freq * (1.0 + _freq_corr * 0.000001); + _center_freq = freq; /* SDR-IQ 5.2.2 Receiver Frequency */ /* SDR-IP 4.2.2 Receiver Frequency */ @@ -1395,7 +1401,7 @@ double rfspace_source_c::set_center_freq( double freq, size_t chan ) transaction( tune, sizeof(tune) ); - return get_center_freq( chan ); + return _center_freq; } double rfspace_source_c::get_center_freq( size_t chan ) @@ -1423,12 +1429,15 @@ double rfspace_source_c::get_center_freq( size_t chan ) double rfspace_source_c::set_freq_corr( double ppm, size_t chan ) { + _freq_corr = ppm; + set_center_freq( _center_freq, chan ); + return get_freq_corr( chan ); } double rfspace_source_c::get_freq_corr( size_t chan ) { - return 0; + return _freq_corr; } std::vector<std::string> rfspace_source_c::get_gain_names( size_t chan ) diff --git a/lib/rfspace/rfspace_source_c.h b/lib/rfspace/rfspace_source_c.h index 996f47b392..42bb6de6ac 100644 --- a/lib/rfspace/rfspace_source_c.h +++ b/lib/rfspace/rfspace_source_c.h @@ -145,6 +145,8 @@ private: /* members */ size_t _nchan; double _sample_rate; double _bandwidth; + double _center_freq; + double _freq_corr; gr::thread::thread _thread; bool _run_usb_read_task; -- 2.25.1

1 0

[PATCH] Stop applying workaround for libusb < 1.0.9
by argilo＠gmail.com 19 Jan '22

19 Jan '22

From: Clayton Smith <argilo(a)gmail.com> Librtlsdr has a workaround for libusb versions that lack libusb_handle_events_timeout_completed, which was added in version 1.0.9 (released 2012-04-02). The workaround is always applied unless the HAVE_LIBUSB_HANDLE_EVENTS_TIMEOUT_COMPLETED macro is set, but the cmake code that sets this macro was removed in 849f8efca42b659bf7e8fe17156ee0aa67b47233. As a result, the workaround is now always applied. This results in an extra 1-second delay whenever a GNU Radio flowgraph containing an RTL-SDR block is stopped, which makes operations like switching between demodulators in Gqrx annoyingly slow. To solve this problem, I've simply removed the workaround, as it should no longer be needed. I wonder if perhaps the workaround recently applied in 2659e2df31e592d74d6dd264a4f5ce242c6369c8 might stem from the same bug. --- src/librtlsdr.c | 6 ------ 1 file changed, 6 deletions(-) diff --git a/src/librtlsdr.c b/src/librtlsdr.c index 2682d77ec2..096abaeffc 100644 --- a/src/librtlsdr.c +++ b/src/librtlsdr.c @@ -39,12 +39,6 @@ #define LIBUSB_CALL #endif -/* libusb < 1.0.9 doesn't have libusb_handle_events_timeout_completed */ -#ifndef HAVE_LIBUSB_HANDLE_EVENTS_TIMEOUT_COMPLETED -#define libusb_handle_events_timeout_completed(ctx, tv, c) \ - libusb_handle_events_timeout(ctx, tv) -#endif - /* two raised to the power of n */ #define TWO_POW(n) ((double)(1ULL<<(n))) -- 2.25.1

2 1

[PATCH] Show readable error when hackrf start/stop fails
by Martin Ling 04 Jan '22

04 Jan '22

Error codes from libhackrf are not very legible, and in the case of HACKRF_ERROR_LIBUSB, don't uniquely describe the cause of the error. Calling hackrf_error_name() provides a human-readable message, and in the case of libusb errors, identifies the actual cause rather than just indicating that the error came from libusb. This came up whilst trying to diagnose a libhackrf bug which showed up when using libhackrf, via gr-osmosdr, via gqrx: https://github.com/greatscottgadgets/hackrf/issues/883 --- lib/hackrf/hackrf_source_c.cc | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/lib/hackrf/hackrf_source_c.cc b/lib/hackrf/hackrf_source_c.cc index 03ea3bd..2826924 100644 --- a/lib/hackrf/hackrf_source_c.cc +++ b/lib/hackrf/hackrf_source_c.cc @@ -170,7 +170,8 @@ bool hackrf_source_c::start() hackrf_common::start(); int ret = hackrf_start_rx( _dev.get(), _hackrf_rx_callback, (void *)this ); if ( ret != HACKRF_SUCCESS ) { - std::cerr << "Failed to start RX streaming (" << ret << ")" << std::endl; + const char *msg = hackrf_error_name( (enum hackrf_error) ret ); + std::cerr << "Failed to start RX streaming (" << ret << ": " << msg << ")" << std::endl; return false; } return true; @@ -184,7 +185,8 @@ bool hackrf_source_c::stop() hackrf_common::stop(); int ret = hackrf_stop_rx( _dev.get() ); if ( ret != HACKRF_SUCCESS ) { - std::cerr << "Failed to stop RX streaming (" << ret << ")" << std::endl; + const char *msg = hackrf_error_name( (enum hackrf_error) ret ); + std::cerr << "Failed to stop RX streaming (" << ret << ": " << msg << ")" << std::endl; return false; } return true; -- 2.30.2

1 0

← Newer
1
2
3
4
5
6
7
8
9
...
91
Older →

Jump to page:

2026

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

osmocom-sdr