pax_global_header00006660000000000000000000000064144625243100014513gustar00rootroot0000000000000052 comment=b5069f9a9125169ada8b11189172070497b4f72f pyrtlsdr-0.3.0/000077500000000000000000000000001446252431000133765ustar00rootroot00000000000000pyrtlsdr-0.3.0/.coveragerc000066400000000000000000000000301446252431000155100ustar00rootroot00000000000000[run] source = rtlsdr/* pyrtlsdr-0.3.0/.gitattributes000066400000000000000000000016061446252431000162740ustar00rootroot00000000000000*.doc diff=astextplain *.DOC diff=astextplain *.docx diff=astextplain *.DOCX diff=astextplain *.dot diff=astextplain *.DOT diff=astextplain *.pdf diff=astextplain *.PDF diff=astextplain *.rtf diff=astextplain *.RTF diff=astextplain *.jpg binary *.png binary *.gif binary *.cs text=auto diff=csharp *.vb text=auto *.c text=auto *.cpp text=auto *.cxx text=auto *.h text=auto *.hxx text=auto *.py text=auto *.rb text=auto *.java text=auto *.html text=auto *.htm text=auto *.css text=auto *.scss text=auto *.sass text=auto *.less text=auto *.js text=auto *.lisp text=auto *.clj text=auto *.sql text=auto *.php text=auto *.lua text=auto *.m text=auto *.asm text=auto *.erl text=auto *.fs text=auto *.fsx text=auto *.hs text=auto *.csproj text=auto merge=union *.vbproj text=auto merge=union *.fsproj text=auto merge=union *.dbproj text=auto merge=union *.sln text=auto eol=crlf merge=union pyrtlsdr-0.3.0/.github/000077500000000000000000000000001446252431000147365ustar00rootroot00000000000000pyrtlsdr-0.3.0/.github/workflows/000077500000000000000000000000001446252431000167735ustar00rootroot00000000000000pyrtlsdr-0.3.0/.github/workflows/dist-test.yml000066400000000000000000000073151446252431000214440ustar00rootroot00000000000000 name: Test Distribution on: push: branches: [ master ] pull_request: branches: [ master ] workflow_dispatch: inputs: allow_deploy: description: 'Deploy with twine' required: true type: boolean jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v2 with: python-version: 3.8 - name: Install dependencies run: | python -m pip install --upgrade pip setuptools wheel - name: Build dists run: python setup.py sdist bdist_wheel - name: Upload artifacts uses: actions/upload-artifact@v2 with: name: 'dists' path: 'dist/*' test: needs: build runs-on: ${{ matrix.os }} strategy: matrix: os: [ubuntu-latest, macos-latest, windows-latest ] python-version: ["2.7", "3.8", "3.9", "3.10", "3.11"] dist-type: [sdist, wheel] exclude: - os: windows-latest python-version: "2.7" - os: macos-latest python-version: "2.7" fail-fast: false env: LD_LIBRARY_PATH: '' steps: - uses: actions/checkout@v2 - name: Set up Python ${{ matrix.python-version }} uses: MatteoH2O1999/setup-python@v1 with: python-version: ${{ matrix.python-version }} cache-build: true - name: Build librtlsdr if: ${{ matrix.python-version == 2.7 }} run: | sudo apt-get install -y libusb-1.0-0-dev cd tools/ci ./install-librtlsdr.sh cd ../.. echo "NEW_LD_LIBPATH=$HOME/.local:$LD_LIBRARY_PATH" >> $GITHUB_ENV - name: Install dependencies run: | python -m pip install --upgrade pip setuptools wheel pip install -U pytest pytest-forked pytest-cov pip install numpy - name: Download artifacts uses: actions/download-artifact@v2 with: name: 'dists' path: dist - name: Delete source directories shell: bash run: | rm -Rf rtlsdr - name: Install wheel shell: bash if: ${{ matrix.dist-type == 'wheel' }} run: pip install dist/*.whl - name: Install sdist shell: bash if: ${{ matrix.dist-type == 'sdist' }} run: pip install dist/*.tar.gz - name: Install pyrtlsdrlib if: ${{ matrix.python-version != 2.7 }} run: pip install pyrtlsdrlib - name: Test distribution shell: bash run: | py.test --cov-config .coveragerc --cov=rtlsdr py.test --cov-append --cov-config .coveragerc --cov=rtlsdr --no-overrides --pyargs tests/no_override_client_mode.py py.test --cov-append --cov-config .coveragerc --cov=rtlsdr --no-overrides --pyargs tests/no_override_dll_loader.py env: LD_LIBRARY_PATH: ${{ env.NEW_LD_LIBPATH }} deploy: needs: test if: ${{ success() && (github.event.inputs.allow_deploy == 'true') }} runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Set up Python uses: actions/setup-python@v2 with: python-version: 3.8 - name: Install dependencies run: | python -m pip install --upgrade pip setuptools wheel twine - name: Download artifacts uses: actions/download-artifact@v2 with: name: 'dists' path: dist - name: Publish to PyPI if: ${{ success() && github.event.inputs.allow_deploy == 'true' }} env: TWINE_REPOSITORY: ${{ secrets.TWINE_REPOSITORY }} TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }} TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }} run: twine upload dist/* pyrtlsdr-0.3.0/.github/workflows/python-package.yml000066400000000000000000000054201446252431000224310ustar00rootroot00000000000000# This workflow will install Python dependencies, run tests and lint with a variety of Python versions # For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions name: Python package on: push: branches: [ master ] pull_request: branches: [ master ] workflow_dispatch: jobs: test: runs-on: ${{ matrix.os }} strategy: matrix: python-version: ["2.7", "3.8", "3.9", "3.10", "3.11"] os: [ubuntu-latest, macos-latest, windows-latest] exclude: - os: macos-latest python-version: "2.7" - os: windows-latest python-version: "2.7" fail-fast: false env: LD_LIBRARY_PATH: '' steps: - uses: actions/checkout@v2 - name: Set up Python ${{ matrix.python-version }} uses: MatteoH2O1999/setup-python@v1 with: python-version: ${{ matrix.python-version }} cache-build: true - name: Build librtlsdr if: ${{ matrix.python-version == 2.7 }} run: | sudo apt-get install -y libusb-1.0-0-dev cd tools/ci ./install-librtlsdr.sh cd ../.. echo "NEW_LD_LIBPATH=$HOME/.local:$LD_LIBRARY_PATH" >> $GITHUB_ENV - name: Install dependencies run: | python -m pip install --upgrade pip setuptools wheel pip install -U pytest pytest-cov pip install numpy - name: Install pyrtlsdr with lib if: ${{ matrix.python-version != 2.7 }} run: pip install -e '.[lib]' - name: Install pyrtlsdr run: pip install -e . if: ${{ matrix.python-version == 2.7 }} - name: Test with pytest shell: bash run: | py.test --cov-config .coveragerc --cov=rtlsdr py.test --cov-append --cov-config .coveragerc --cov=rtlsdr --no-overrides --pyargs tests/no_override_client_mode.py py.test --cov-append --cov-config .coveragerc --cov=rtlsdr --no-overrides --pyargs tests/no_override_dll_loader.py env: LD_LIBRARY_PATH: ${{ env.NEW_LD_LIBPATH }} - name: Set up Python3 for coveralls if: ${{ matrix.python-version == 2.7 }} uses: actions/setup-python@v2 with: python-version: 3.8 - name: Upload to Coveralls run: | python -m pip install coveralls python -m coveralls --service=github env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} COVERALLS_FLAG_NAME: run-${{ matrix.python-version }} COVERALLS_PARALLEL: true coveralls: name: Indicate completion to coveralls.io needs: test runs-on: ubuntu-latest container: python:3-slim steps: - name: Finished run: | pip3 install --upgrade coveralls coveralls --finish env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} pyrtlsdr-0.3.0/.gitignore000066400000000000000000000041121446252431000153640ustar00rootroot00000000000000 ################# ## Eclipse ################# *.pydevproject .project .metadata bin/** tmp/** tmp/**/* *.tmp *.bak *.swp *~.nib local.properties .classpath .settings/ .loadpath *.dll *.exe # External tool builders .externalToolBuilders/ # Locally stored "Eclipse launch configurations" *.launch # CDT-specific .cproject # PDT-specific .buildpath ################# ## Visual Studio ################# ## Ignore Visual Studio temporary files, build results, and ## files generated by popular Visual Studio add-ons. # User-specific files *.suo *.user *.sln.docstates # Build results **/[Dd]ebug/ **/[Rr]elease/ *_i.c *_p.c *.ilk *.meta *.obj *.pch *.pdb *.pgc *.pgd *.rsp *.sbr *.tlb *.tli *.tlh *.tmp *.vspscc .builds **/*.dotCover ## TODO: If you have NuGet Package Restore enabled, uncomment this #**/packages/ # Visual C++ cache files ipch/ *.aps *.ncb *.opensdf *.sdf # Visual Studio profiler *.psess *.vsp # ReSharper is a .NET coding add-in _ReSharper* # Installshield output folder [Ee]xpress # DocProject is a documentation generator add-in DocProject/buildhelp/ DocProject/Help/*.HxT DocProject/Help/*.HxC DocProject/Help/*.hhc DocProject/Help/*.hhk DocProject/Help/*.hhp DocProject/Help/Html2 DocProject/Help/html # Click-Once directory publish # Others [Bb]in [Oo]bj sql TestResults *.Cache ClientBin stylecop.* ~$* *.dbmdl Generated_Code #added for RIA/Silverlight projects # Backup & report files from converting an old project file to a newer # Visual Studio version. Backup files are not needed, because we have git ;-) _UpgradeReport_Files/ Backup*/ UpgradeLog*.XML ############ ## Windows ############ # Windows image file caches Thumbs.db # Folder config file Desktop.ini ############# ## Python ############# __pycache__/ *.py[cod] # Packages eggs/ .eggs/ *.egg *.egg-info dist build eggs parts bin var sdist develop-eggs .installed.cfg # Installer logs pip-log.txt # Unit test / coverage reports htmlcov/ .tox/ .coverage .coverage.* .cache nosetests.xml coverage.xml *,cover #Translations *.mo #Mr Developer .mr.developer.cfg # Mac crap .DS_Store venv* README.rst pyrtlsdr-0.3.0/MANIFEST.in000066400000000000000000000000721446252431000151330ustar00rootroot00000000000000include README* include demo_waterfall.py include test.py pyrtlsdr-0.3.0/README.md000066400000000000000000000171251446252431000146630ustar00rootroot00000000000000# pyrtlsdr A Python wrapper for librtlsdr (a driver for Realtek RTL2832U based SDR's) [![PyPI](https://img.shields.io/pypi/v/pyrtlsdr)](https://pypi.org/project/pyrtlsdr) ![GitHub Workflow Status](https://img.shields.io/github/workflow/status/pyrtlsdr/pyrtlsdr/Python%20package) ![PyPI - Downloads](https://img.shields.io/pypi/dm/pyrtlsdr) [![Coveralls](https://img.shields.io/coveralls/github/pyrtlsdr/pyrtlsdr)](https://coveralls.io/github/pyrtlsdr/pyrtlsdr) # Description pyrtlsdr is a simple Python interface to devices supported by the RTL-SDR project, which turns certain USB DVB-T dongles employing the Realtek RTL2832U chipset into low-cost, general purpose software-defined radio receivers. It wraps many of the functions in the [librtlsdr library](https://github.com/librtlsdr/librtlsdr) including asynchronous read support and also provides a more Pythonic API. # Links * Documentation: * https://pyrtlsdr.readthedocs.io/ * Releases: * https://pypi.org/project/pyrtlsdr/ * Source code and project home: * https://github.com/pyrtlsdr/pyrtlsdr * Releases for `librtlsdr`: * https://github.com/librtlsdr/librtlsdr/releases # Installation pyrtlsdr can be installed by downloading the source files and running `python setup.py install`, or using [pip](https://pip.pypa.io/en/stable/) and `pip install pyrtlsdr`. ## Full installation (recommended) **New in version 0.3.0** On most platforms, the `librtlsdr` binaries may be also installed with the [pyrtlsdrlib](https://github.com/pyrtlsdr/pyrtlsdrlib) package. This new feature should *drastically* simplify the installation process (especially for Windows). This can be done by installing `pyrtlsdrlib` separately (via pip) or for simplicity, both can be installed at once via: ```bash pip install pyrtlsdr[lib] ``` If errors are encountered with the `pyrtlsdrlib` integration (during installation or package import), you may want to ensure you have the latest versions of both: ```bash pip install --upgrade pyrtlsdr[lib] ``` # Usage All functions in librtlsdr are accessible via librtlsdr.py and a Pythonic interface is available in rtlsdr.py (recommended). Some documentation can be found in docstrings in the latter file. ## Examples ### Simple way to read and print some samples: ```python from rtlsdr import RtlSdr sdr = RtlSdr() # configure device sdr.sample_rate = 2.048e6 # Hz sdr.center_freq = 70e6 # Hz sdr.freq_correction = 60 # PPM sdr.gain = 'auto' print(sdr.read_samples(512)) ``` ### Plotting the PSD with matplotlib: ```python from pylab import * from rtlsdr import * sdr = RtlSdr() # configure device sdr.sample_rate = 2.4e6 sdr.center_freq = 95e6 sdr.gain = 4 samples = sdr.read_samples(256*1024) sdr.close() # use matplotlib to estimate and plot the PSD psd(samples, NFFT=1024, Fs=sdr.sample_rate/1e6, Fc=sdr.center_freq/1e6) xlabel('Frequency (MHz)') ylabel('Relative power (dB)') show() ``` ### Resulting Plot: ![](https://i.imgur.com/hFhg8.png "Resulting Plot") See the files 'demo_waterfall.py' and 'test.py' for more examples. ## Handling multiple devices: *(added in v2.5.6)* ```python from rtlsdr import RtlSdr # Get a list of detected device serial numbers (str) serial_numbers = RtlSdr.get_device_serial_addresses() # Find the device index for a given serial number device_index = RtlSdr.get_device_index_by_serial('00000001') sdr = RtlSdr(device_index) # Or pass the serial number directly: sdr = RtlSdr(serial_number='00000001') ``` ### Note Most devices by default have the same serial number: '0000001'. This can be set to a custom value by using the [rtl_eeprom][rtl_eeprom] utility packaged with `librtlsdr`. [rtl_eeprom]: https://manpages.ubuntu.com/manpages/trusty/man1/rtl_eeprom.1.html # Experimental features Two new submodules are available for testing: **rtlsdraio**, which adds native Python 3 asynchronous support (asyncio module), and **rtlsdrtcp** which adds a TCP server/client for accessing a device over the network. See the respective modules in the rtlsdr folder for more details and feel free to test and report any bugs! ## rtlsdraio Note that the rtlsdraio module is automatically imported and adds `stream()` and `stop()` methods to the normal `RtlSdr` class. It also requires the new `async`/`await` syntax introduced in Python 3.5+. The syntax is basically: ```python import asyncio from rtlsdr import RtlSdr async def streaming(): sdr = RtlSdr() async for samples in sdr.stream(): # do something with samples # ... # to stop streaming: await sdr.stop() # done sdr.close() loop = asyncio.get_event_loop() loop.run_until_complete(streaming()) ``` ## rtlsdrtcp The `RtlSdrTcpServer` class is meant to be connected physically to an SDR dongle and communicate with an instance of `RtlSdrTcpClient`. The client is intended to function as closely as possible to the base RtlSdr class (as if it had a physical dongle attached to it). Both of these classes have the same arguments as the base `RtlSdr` class with the addition of `hostname` and `port`: ```python server = RtlSdrTcpServer(hostname='192.168.1.100', port=12345) server.run_forever() # Will listen for clients until Ctrl-C is pressed ``` ```python # On another machine (typically) client = RtlSdrTcpClient(hostname='192.168.1.100', port=12345) client.center_freq = 2e6 data = client.read_samples() ``` ## TCP Client Mode On platforms where the `librtlsdr` library cannot be installed/compiled, it is possible to import the `RtlSdrTcpClient` only by setting the environment variable `"RTLSDR_CLIENT_MODE"` to `"true"`. If this is set, no other modules will be available. *Feature added in v0.2.4* # Dependencies * Windows/Linux/OSX * Python 2.7.x/3.3+ * [librtlsdr](https://github.com/librtlsdr/librtlsdr/releases) * **Optional**: NumPy (wraps samples in a more convenient form) matplotlib is also useful for plotting data. The librtlsdr binaries (rtlsdr.dll in Windows and librtlsdr.so in Linux) should be in the pyrtlsdr directory, or a system path. Note that these binaries may have additional dependencies. # Todo There are a few remaining functions in librtlsdr that haven't been wrapped yet. It's a simple process if there's an additional function you need to add support for, and please send a pull request if you'd like to share your changes. # Troubleshooting * Some operating systems (Linux, OS X) seem to result in libusb buffer issues when performing small reads. Try reading 1024 (or higher powers of two) samples at a time if you have problems. ## librtlsdr import errors First try upgrading `pyrtlsdr` and using the `pyrtlsdrlib` helper package described above. * In cases where that isn't feasible: * **Windows**: Make sure all the librtlsdr DLL files (librtlsdr.dll, libusb-1.0.dll) are in your system path, or the same folder as this README file. Also make sure you have all of *their* dependencies (e.g. libgcc_s_dw2-1.dll or possibly the Visual Studio runtime files). If rtl_sdr.exe works, then you should be okay. Also note that you can't mix the 64 bit version of Python with 32 bit builds of librtlsdr, and vice versa. * **Linux**: Make sure your LD_LIBRARY_PATH environment variable contains the directory where the librtlsdr.so.0 library is located. You can do this in a shell with (for example): `export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/lib`. See [this issue](https://github.com/roger-/pyrtlsdr/issues/7) for more details. # License All of the code contained here is licensed by the GNU General Public License v3. # Credit Credit to dbasden for his earlier wrapper [python-librtlsdr](https://github.com/dbasden/python-librtlsdr) and all the contributors on GitHub. Copyright (C) 2013 by Roger pyrtlsdr-0.3.0/demo_waterfall.py000066400000000000000000000140411446252431000167350ustar00rootroot00000000000000# This file is part of pyrlsdr. # Copyright (C) 2013 by Roger # # pyrlsdr 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 of the License, or # (at your option) any later version. # pyrlsdr 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 pyrlsdr. If not, see . from __future__ import division import matplotlib.animation as animation from matplotlib.mlab import psd import pylab as pyl import numpy as np import sys from rtlsdr import RtlSdr # A simple waterfall, spectrum plotter # # Controls: # # * Scroll mouse-wheel up or down, or press the left or right arrow keys, to # change the center frequency (hold shift for finer control). # * Press "+" and "-" to control gain, and space to enable AGC. # * Type a frequency (in MHz) and press enter to directly change the center frequency NFFT = 1024*4 NUM_SAMPLES_PER_SCAN = NFFT*16 NUM_BUFFERED_SWEEPS = 100 # change this to control the number of scans that are combined in a single sweep # (e.g. 2, 3, 4, etc.) Note that it can slow things down NUM_SCANS_PER_SWEEP = 1 # these are the increments when scrolling the mouse wheel or pressing '+' or '-' FREQ_INC_COARSE = 1e6 FREQ_INC_FINE = 0.1e6 GAIN_INC = 5 class Waterfall(object): keyboard_buffer = [] shift_key_down = False image_buffer = -100*np.ones((NUM_BUFFERED_SWEEPS,\ NUM_SCANS_PER_SWEEP*NFFT)) def __init__(self, sdr=None, fig=None): self.fig = fig if fig else pyl.figure() self.sdr = sdr if sdr else RtlSdr() self.init_plot() def init_plot(self): self.ax = self.fig.add_subplot(1,1,1) self.image = self.ax.imshow(self.image_buffer, aspect='auto',\ interpolation='nearest', vmin=-50, vmax=10) self.ax.set_xlabel('Current frequency (MHz)') self.ax.get_yaxis().set_visible(False) self.fig.canvas.mpl_connect('scroll_event', self.on_scroll) self.fig.canvas.mpl_connect('key_press_event', self.on_key_press) self.fig.canvas.mpl_connect('key_release_event', self.on_key_release) def update_plot_labels(self): fc = self.sdr.fc rs = self.sdr.rs freq_range = (fc - rs/2)/1e6, (fc + rs*(NUM_SCANS_PER_SWEEP - 0.5))/1e6 self.image.set_extent(freq_range + (0, 1)) self.fig.canvas.draw_idle() def on_scroll(self, event): if event.button == 'up': self.sdr.fc += FREQ_INC_FINE if self.shift_key_down else FREQ_INC_COARSE self.update_plot_labels() elif event.button == 'down': self.sdr.fc -= FREQ_INC_FINE if self.shift_key_down else FREQ_INC_COARSE self.update_plot_labels() def on_key_press(self, event): if event.key == '+': self.sdr.gain += GAIN_INC elif event.key == '-': self.sdr.gain -= GAIN_INC elif event.key == ' ': self.sdr.gain = 'auto' elif event.key == 'shift': self.shift_key_down = True elif event.key == 'right': self.sdr.fc += FREQ_INC_FINE if self.shift_key_down else FREQ_INC_COARSE self.update_plot_labels() elif event.key == 'left': self.sdr.fc -= FREQ_INC_FINE if self.shift_key_down else FREQ_INC_COARSE self.update_plot_labels() elif event.key == 'enter': # see if valid frequency was entered, then change center frequency try: # join individual key presses into a string input = ''.join(self.keyboard_buffer) # if we're doing multiple adjacent scans, we need to figure out # the appropriate center freq for the leftmost scan center_freq = float(input)*1e6 + (self.sdr.rs/2)*(1 - NUM_SCANS_PER_SWEEP) self.sdr.fc = center_freq self.update_plot_labels() except ValueError: pass self.keyboard_buffer = [] else: self.keyboard_buffer.append(event.key) def on_key_release(self, event): if event.key == 'shift': self.shift_key_down = False def update(self, *args): # save center freq. since we're gonna be changing it start_fc = self.sdr.fc # prepare space in buffer # TODO: use indexing to avoid recreating buffer each time self.image_buffer = np.roll(self.image_buffer, 1, axis=0) for scan_num, start_ind in enumerate(range(0, NUM_SCANS_PER_SWEEP*NFFT, NFFT)): self.sdr.fc += self.sdr.rs*scan_num # estimate PSD for one scan samples = self.sdr.read_samples(NUM_SAMPLES_PER_SCAN) psd_scan, f = psd(samples, NFFT=NFFT) self.image_buffer[0, start_ind: start_ind+NFFT] = 10*np.log10(psd_scan) # plot entire sweep self.image.set_array(self.image_buffer) # restore original center freq. self.sdr.fc = start_fc return self.image, def start(self): self.update_plot_labels() if sys.platform == 'darwin': # Disable blitting. The matplotlib.animation's restore_region() # method is only implemented for the Agg-based backends, # which the macosx backend is not. blit = False else: blit = True ani = animation.FuncAnimation(self.fig, self.update, interval=50, blit=blit) pyl.show() return def main(): sdr = RtlSdr() wf = Waterfall(sdr) # some defaults sdr.rs = 2.4e6 sdr.fc = 100e6 sdr.gain = 10 wf.start() # cleanup sdr.close() if __name__ == '__main__': main() pyrtlsdr-0.3.0/doc/000077500000000000000000000000001446252431000141435ustar00rootroot00000000000000pyrtlsdr-0.3.0/doc/Makefile000066400000000000000000000172741446252431000156160ustar00rootroot00000000000000# Makefile for Sphinx documentation # # You can set these variables from the command line. SPHINXOPTS = SPHINXBUILD = sphinx-build PAPER = BUILDDIR = build # User-friendly check for sphinx-build ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1) $(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don\'t have Sphinx installed, grab it from http://sphinx-doc.org/) endif # Internal variables. PAPEROPT_a4 = -D latex_paper_size=a4 PAPEROPT_letter = -D latex_paper_size=letter ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source # the i18n builder cannot share the environment and doctrees with the others I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source .PHONY: help help: @echo "Please use \`make ' where is one of" @echo " html to make standalone HTML files" @echo " dirhtml to make HTML files named index.html in directories" @echo " singlehtml to make a single large HTML file" @echo " pickle to make pickle files" @echo " json to make JSON files" @echo " htmlhelp to make HTML files and a HTML help project" @echo " qthelp to make HTML files and a qthelp project" @echo " applehelp to make an Apple Help Book" @echo " devhelp to make HTML files and a Devhelp project" @echo " epub to make an epub" @echo " epub3 to make an epub3" @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" @echo " latexpdf to make LaTeX files and run them through pdflatex" @echo " latexpdfja to make LaTeX files and run them through platex/dvipdfmx" @echo " text to make text files" @echo " man to make manual pages" @echo " texinfo to make Texinfo files" @echo " info to make Texinfo files and run them through makeinfo" @echo " gettext to make PO message catalogs" @echo " changes to make an overview of all changed/added/deprecated items" @echo " xml to make Docutils-native XML files" @echo " pseudoxml to make pseudoxml-XML files for display purposes" @echo " linkcheck to check all external links for integrity" @echo " doctest to run all doctests embedded in the documentation (if enabled)" @echo " coverage to run coverage check of the documentation (if enabled)" .PHONY: clean clean: rm -rf $(BUILDDIR)/* .PHONY: html html: $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." .PHONY: dirhtml dirhtml: $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml." .PHONY: singlehtml singlehtml: $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml @echo @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml." .PHONY: pickle pickle: $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle @echo @echo "Build finished; now you can process the pickle files." .PHONY: json json: $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json @echo @echo "Build finished; now you can process the JSON files." .PHONY: htmlhelp htmlhelp: $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp @echo @echo "Build finished; now you can run HTML Help Workshop with the" \ ".hhp project file in $(BUILDDIR)/htmlhelp." .PHONY: qthelp qthelp: $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp @echo @echo "Build finished; now you can run "qcollectiongenerator" with the" \ ".qhcp project file in $(BUILDDIR)/qthelp, like this:" @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/pyrtlsdr.qhcp" @echo "To view the help file:" @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/pyrtlsdr.qhc" .PHONY: applehelp applehelp: $(SPHINXBUILD) -b applehelp $(ALLSPHINXOPTS) $(BUILDDIR)/applehelp @echo @echo "Build finished. The help book is in $(BUILDDIR)/applehelp." @echo "N.B. You won't be able to view it unless you put it in" \ "~/Library/Documentation/Help or install it in your application" \ "bundle." .PHONY: devhelp devhelp: $(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp @echo @echo "Build finished." @echo "To view the help file:" @echo "# mkdir -p $$HOME/.local/share/devhelp/pyrtlsdr" @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/pyrtlsdr" @echo "# devhelp" .PHONY: epub epub: $(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub @echo @echo "Build finished. The epub file is in $(BUILDDIR)/epub." .PHONY: epub3 epub3: $(SPHINXBUILD) -b epub3 $(ALLSPHINXOPTS) $(BUILDDIR)/epub3 @echo @echo "Build finished. The epub3 file is in $(BUILDDIR)/epub3." .PHONY: latex latex: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex." @echo "Run \`make' in that directory to run these through (pdf)latex" \ "(use \`make latexpdf' here to do that automatically)." .PHONY: latexpdf latexpdf: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through pdflatex..." $(MAKE) -C $(BUILDDIR)/latex all-pdf @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." .PHONY: latexpdfja latexpdfja: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through platex and dvipdfmx..." $(MAKE) -C $(BUILDDIR)/latex all-pdf-ja @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." .PHONY: text text: $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text @echo @echo "Build finished. The text files are in $(BUILDDIR)/text." .PHONY: man man: $(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man @echo @echo "Build finished. The manual pages are in $(BUILDDIR)/man." .PHONY: texinfo texinfo: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo @echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo." @echo "Run \`make' in that directory to run these through makeinfo" \ "(use \`make info' here to do that automatically)." .PHONY: info info: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo "Running Texinfo files through makeinfo..." make -C $(BUILDDIR)/texinfo info @echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo." .PHONY: gettext gettext: $(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale @echo @echo "Build finished. The message catalogs are in $(BUILDDIR)/locale." .PHONY: changes changes: $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes @echo @echo "The overview file is in $(BUILDDIR)/changes." .PHONY: linkcheck linkcheck: $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck @echo @echo "Link check complete; look for any errors in the above output " \ "or in $(BUILDDIR)/linkcheck/output.txt." .PHONY: doctest doctest: $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest @echo "Testing of doctests in the sources finished, look at the " \ "results in $(BUILDDIR)/doctest/output.txt." .PHONY: coverage coverage: $(SPHINXBUILD) -b coverage $(ALLSPHINXOPTS) $(BUILDDIR)/coverage @echo "Testing of coverage in the sources finished, look at the " \ "results in $(BUILDDIR)/coverage/python.txt." .PHONY: xml xml: $(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml @echo @echo "Build finished. The XML files are in $(BUILDDIR)/xml." .PHONY: pseudoxml pseudoxml: $(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml @echo @echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml." pyrtlsdr-0.3.0/doc/requirements.txt000066400000000000000000000002151446252431000174250ustar00rootroot00000000000000docutils>=0.17 Sphinx>=2.3.1 git+https://github.com/readthedocs/sphinx_rtd_theme.git@1.0.0rc1#egg=sphinx_rtd_theme myst-parser linkify-it-py pyrtlsdr-0.3.0/doc/source/000077500000000000000000000000001446252431000154435ustar00rootroot00000000000000pyrtlsdr-0.3.0/doc/source/Overview.rst000066400000000000000000000001421446252431000200000ustar00rootroot00000000000000======== Overview ======== .. include:: ../../README.md :parser: mdreadme :start-line: 2 pyrtlsdr-0.3.0/doc/source/Reference.rst000066400000000000000000000001261446252431000200720ustar00rootroot00000000000000Reference ========= .. toctree:: rtlsdr rtlsdraio rtlsdrtcp helpers pyrtlsdr-0.3.0/doc/source/conf.py000066400000000000000000000235601446252431000167500ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # pyrtlsdr documentation build configuration file, created by # sphinx-quickstart on Mon Apr 11 13:18:30 2016. # # This file is execfile()d with the current directory set to its # containing dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. import sys import os sys.path.append(os.path.abspath('./ext')) # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. #sys.path.insert(0, os.path.abspath('.')) import pkg_resources __version__ = pkg_resources.require('pyrtlsdr')[0].version html_theme = "sphinx_rtd_theme" html_theme_options = { 'collapse_navigation':False, } # -- General configuration ------------------------------------------------ # If your documentation needs a minimal Sphinx version, state it here. #needs_sphinx = '1.0' # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. extensions = [ 'sphinx.ext.autodoc', 'sphinx.ext.intersphinx', 'sphinx.ext.ifconfig', 'sphinx.ext.viewcode', 'sphinx.ext.githubpages', 'sphinx.ext.napoleon', ] autodoc_member_order = 'groupwise' napoleon_google_docstring = True # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # The suffix(es) of source filenames. # You can specify multiple suffix as a list of string: # source_suffix = '.rst' # The encoding of source files. #source_encoding = 'utf-8-sig' # The master toctree document. master_doc = 'index' # General information about the project. project = u'pyrtlsdr' copyright = u'2016, Roger ' author = u'Roger ' # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # # The short X.Y version. version = __version__ # The full version, including alpha/beta/rc tags. release = __version__ # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. # # This is also used if you do content translation via gettext catalogs. # Usually you set "language" from the command line for these cases. language = 'en' # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: #today = '' # Else, today_fmt is used as the format for a strftime call. #today_fmt = '%B %d, %Y' # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This patterns also effect to html_static_path and html_extra_path exclude_patterns = [] # The reST default role (used for this markup: `text`) to use for all # documents. #default_role = None # If true, '()' will be appended to :func: etc. cross-reference text. #add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). #add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. #show_authors = False # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' # A list of ignored prefixes for module index sorting. #modindex_common_prefix = [] # If true, keep warnings as "system message" paragraphs in the built documents. #keep_warnings = False # If true, `todo` and `todoList` produce output, else they produce nothing. todo_include_todos = False # -- Options for HTML output ---------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. #html_theme = 'alabaster' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. #html_theme_options = {} # Add any paths that contain custom themes here, relative to this directory. #html_theme_path = [] # The name for this set of Sphinx documents. # " v documentation" by default. #html_title = u'pyrtlsdr v0.2.2' # A shorter title for the navigation bar. Default is the same as html_title. #html_short_title = None # The name of an image file (relative to this directory) to place at the top # of the sidebar. #html_logo = None # The name of an image file (relative to this directory) to use as a favicon of # the docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. #html_favicon = None # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". #html_static_path = ['_static'] # Add any extra paths that contain custom files (such as robots.txt or # .htaccess) here, relative to this directory. These files are copied # directly to the root of the documentation. #html_extra_path = [] # If not None, a 'Last updated on:' timestamp is inserted at every page # bottom, using the given strftime format. # The empty string is equivalent to '%b %d, %Y'. #html_last_updated_fmt = None # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. #html_use_smartypants = True # Custom sidebar templates, maps document names to template names. #html_sidebars = {} # Additional templates that should be rendered to pages, maps page names to # template names. #html_additional_pages = {} # If false, no module index is generated. #html_domain_indices = True # If false, no index is generated. #html_use_index = True # If true, the index is split into individual pages for each letter. #html_split_index = False # If true, links to the reST sources are added to the pages. #html_show_sourcelink = True # If true, "Created using Sphinx" is shown in the HTML footer. Default is True. #html_show_sphinx = True # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True. #html_show_copyright = True # If true, an OpenSearch description file will be output, and all pages will # contain a tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. #html_use_opensearch = '' # This is the file name suffix for HTML files (e.g. ".xhtml"). #html_file_suffix = None # Language to be used for generating the HTML full-text search index. # Sphinx supports the following languages: # 'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja' # 'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr', 'zh' #html_search_language = 'en' # A dictionary with options for the search language support, empty by default. # 'ja' uses this config value. # 'zh' user can custom change `jieba` dictionary path. #html_search_options = {'type': 'default'} # The name of a javascript file (relative to the configuration directory) that # implements a search results scorer. If empty, the default will be used. #html_search_scorer = 'scorer.js' # Output file base name for HTML help builder. htmlhelp_basename = 'pyrtlsdrdoc' # -- Options for LaTeX output --------------------------------------------- latex_elements = { # The paper size ('letterpaper' or 'a4paper'). #'papersize': 'letterpaper', # The font size ('10pt', '11pt' or '12pt'). #'pointsize': '10pt', # Additional stuff for the LaTeX preamble. #'preamble': '', # Latex figure (float) alignment #'figure_align': 'htbp', } # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, # author, documentclass [howto, manual, or own class]). latex_documents = [ (master_doc, 'pyrtlsdr.tex', u'pyrtlsdr Documentation', u'Roger \\textless{}https://github.com/pyrtlsdr/pyrtlsdr\\textgreater{}', 'manual'), ] # The name of an image file (relative to this directory) to place at the top of # the title page. #latex_logo = None # For "manual" documents, if this is true, then toplevel headings are parts, # not chapters. #latex_use_parts = False # If true, show page references after internal links. #latex_show_pagerefs = False # If true, show URL addresses after external links. #latex_show_urls = False # Documents to append as an appendix to all manuals. #latex_appendices = [] # If false, no module index is generated. #latex_domain_indices = True # -- Options for manual page output --------------------------------------- # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [ (master_doc, 'pyrtlsdr', u'pyrtlsdr Documentation', [author], 1) ] # If true, show URL addresses after external links. #man_show_urls = False # -- Options for Texinfo output ------------------------------------------- # Grouping the document tree into Texinfo files. List of tuples # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ (master_doc, 'pyrtlsdr', u'pyrtlsdr Documentation', author, 'pyrtlsdr', 'One line description of project.', 'Miscellaneous'), ] # Documents to append as an appendix to all manuals. #texinfo_appendices = [] # If false, no module index is generated. #texinfo_domain_indices = True # How to display URL addresses: 'footnote', 'no', or 'inline'. #texinfo_show_urls = 'footnote' # If true, do not generate a @detailmenu in the "Top" node's menu. #texinfo_no_detailmenu = False # Example configuration for intersphinx: refer to the Python standard library. intersphinx_mapping = { 'python':('https://docs.python.org/', None), 'numpy':('https://docs.scipy.org/doc/numpy/', None), } pyrtlsdr-0.3.0/doc/source/ext/000077500000000000000000000000001446252431000162435ustar00rootroot00000000000000pyrtlsdr-0.3.0/doc/source/ext/__init__.py000066400000000000000000000000001446252431000203420ustar00rootroot00000000000000pyrtlsdr-0.3.0/doc/source/ext/mdreadme.py000066400000000000000000000026731446252431000204030ustar00rootroot00000000000000"""Override of myst_parser.docutils_ module to enable ``linkify`` extension Currently only used for ``doc/source/Overview.rst`` to render ``README.md``. Very hackish, but easier than sifting through docutils to find correct config injection method. https://github.com/executablebooks/MyST-Parser/blob/v0.15.2/myst_parser/docutils_.py """ from docutils import nodes from markdown_it.token import Token from myst_parser.config.main import MdParserConfig from myst_parser.parsers.mdit import create_md_parser from myst_parser.mdit_to_docutils.sphinx_ import SphinxRenderer from myst_parser.docutils_ import Parser as _Parser class Parser(_Parser): def parse(self, inputstring: str, document: nodes.document) -> None: """Parse source text. :param inputstring: The source string to parse :param document: The root docutils node to add AST elements to """ config = MdParserConfig(enable_extensions=['linkify']) parser = create_md_parser(config, SphinxRenderer) parser.options["document"] = document env = {} tokens = parser.parse(inputstring, env) if not tokens or tokens[0].type != "front_matter": # we always add front matter, so that we can merge it with global keys, # specified in the sphinx configuration tokens = [Token("front_matter", "", 0, content="{}", map=[0, 0])] + tokens parser.renderer.render(tokens, parser.options, env) pyrtlsdr-0.3.0/doc/source/helpers.rst000066400000000000000000000002051446252431000176340ustar00rootroot00000000000000:mod:`rtlsdr.helpers` ===================== .. automodule:: rtlsdr.helpers :members: :undoc-members: :show-inheritance: pyrtlsdr-0.3.0/doc/source/index.rst000066400000000000000000000007441446252431000173110ustar00rootroot00000000000000.. pyrtlsdr documentation master file, created by sphinx-quickstart on Mon Apr 11 13:18:30 2016. You can adapt this file completely to your liking, but it should at least contain the root `toctree` directive. Welcome to pyrtlsdr's documentation! ==================================== .. toctree:: :caption: Contents :name: mastertoc :maxdepth: 2 Overview Reference Indices and tables ================== * :ref:`genindex` * :ref:`modindex` * :ref:`search` pyrtlsdr-0.3.0/doc/source/rtlsdr.rst000066400000000000000000000002041446252431000175030ustar00rootroot00000000000000:mod:`rtlsdr.rtlsdr` ==================== .. automodule:: rtlsdr.rtlsdr :members: :private-members: :show-inheritance: pyrtlsdr-0.3.0/doc/source/rtlsdraio.rst000066400000000000000000000002241446252431000201760ustar00rootroot00000000000000:mod:`rtlsdr.rtlsdraio` ======================= .. automodule:: rtlsdr.rtlsdraio :members: RtlSdrAio, AsyncCallbackIter :show-inheritance: pyrtlsdr-0.3.0/doc/source/rtlsdrtcp.rst000066400000000000000000000010571446252431000202210ustar00rootroot00000000000000:mod:`rtlsdr.rtlsdrtcp` ======================= .. automodule:: rtlsdr.rtlsdrtcp :mod:`rtlsdr.rtlsdrtcp.server` ------------------------------ .. automodule:: rtlsdr.rtlsdrtcp.server :members: :undoc-members: :show-inheritance: :mod:`rtlsdr.rtlsdrtcp.client` ------------------------------ .. automodule:: rtlsdr.rtlsdrtcp.client :members: :undoc-members: :show-inheritance: :mod:`rtlsdr.rtlsdrtcp.base` ---------------------------- .. automodule:: rtlsdr.rtlsdrtcp.base :members: :undoc-members: :show-inheritance: pyrtlsdr-0.3.0/pytest.ini000066400000000000000000000001121446252431000154210ustar00rootroot00000000000000[pytest] testpaths = tests python_files = *.py faulthandler_timeout = 300 pyrtlsdr-0.3.0/rtlsdr/000077500000000000000000000000001446252431000147105ustar00rootroot00000000000000pyrtlsdr-0.3.0/rtlsdr/__init__.py000066400000000000000000000046171446252431000170310ustar00rootroot00000000000000# This file is part of pyrlsdr. # Copyright (C) 2013 by Roger # # pyrlsdr 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 of the License, or # (at your option) any later version. # pyrlsdr 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 pyrlsdr. If not, see . import os import warnings import pkg_resources try: __version__ = pkg_resources.require('pyrtlsdr')[0].version except: # pragma: no cover __version__ = 'unknown' RTLSDR_CLIENT_MODE = False if os.environ.get('RTLSDR_CLIENT_MODE', '').lower() in ['true', '1', 'yes']: RTLSDR_CLIENT_MODE = True class ClientModeWarning(UserWarning): def __init__(self): msg = '\n'.join([ 'Running in "client-only" mode: {varname}="{val}"', 'Only Tcp communication will be available (RtlSdrTcpClient)', 'If this is was not intended, set "{varname}" to "false" or remove it', ]).format(varname='$RTLSDR_CLIENT_MODE', val=os.environ['RTLSDR_CLIENT_MODE']) super(ClientModeWarning, self).__init__(msg) def warn_client_mode(): def formatwarning(message, category, filename, lineno, line=None): return '{}: {}: \n{}\n'.format(filename, category.__name__, message) orig_fmt = warnings.formatwarning warnings.formatwarning = formatwarning warnings.warn(ClientModeWarning()) warnings.formatwarning = orig_fmt if RTLSDR_CLIENT_MODE: warn_client_mode() from .rtlsdrtcp.client import RtlSdrTcpClient librtlsdr = None RtlSdr = None RtlSdrTcpServer = None RtlSdrAio = None AIO_AVAILABLE = False else: from .librtlsdr import librtlsdr from .rtlsdr import RtlSdr from .rtlsdrtcp import RtlSdrTcpServer, RtlSdrTcpClient from .helpers import limit_calls, limit_time from .rtlsdraio import RtlSdrAio, AIO_AVAILABLE if AIO_AVAILABLE: RtlSdr = RtlSdrAio __all__ = ['librtlsdr', 'RtlSdr', 'RtlSdrTcpServer', 'RtlSdrTcpClient', 'limit_calls', 'limit_time'] pyrtlsdr-0.3.0/rtlsdr/helpers.py000066400000000000000000000054401446252431000167270ustar00rootroot00000000000000# This file is part of pyrlsdr. # Copyright (C) 2013 by Roger # # pyrlsdr 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 of the License, or # (at your option) any later version. # pyrlsdr 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 pyrlsdr. If not, see . from __future__ import division, print_function from functools import wraps import time def limit_time(max_seconds): """Decorator to cancel async reads after a specified time period. Arguments: max_seconds: Number of seconds to wait before cancelling Examples: Stop reading after 10 seconds: >>> @limit_time(10) >>> def read_callback(data, context): >>> print('signal mean:', sum(data)/len(data)) >>> sdr = RtlSdr() >>> sdr.read_samples_async(read_callback) Notes: The context in either :meth:`~rtlsdr.RtlSdr.read_bytes_async` or :meth:`~rtlsdr.RtlSdr.read_samples_async` is relied upon and must use the default value (the :class:`~rtlsdr.RtlSdr` instance) """ def decorator(f): f._start_time = None @wraps(f) def wrapper(buffer, rtlsdr_obj): if f._start_time is None: f._start_time = time.time() elapsed = time.time() - f._start_time if elapsed < max_seconds: return f(buffer, rtlsdr_obj) rtlsdr_obj.cancel_read_async() return return wrapper return decorator def limit_calls(max_calls): """Decorator to cancel async reads after the given number of calls. Arguments: max_calls (int): Number of calls to wait for before cancelling Examples: Stop reading after 10 calls: >>> @limit_calls(10) >>> def read_callback(data, context): >>> print('signal mean:', sum(data)/len(data)) >>> sdr = RtlSdr() >>> sdr.read_samples_async(read_callback) Notes: See notes in :func:`limit_time` """ def decorator(f): f._num_calls = 0 @wraps(f) def wrapper(buffer, rtlsdr_obj): f._num_calls += 1 if f._num_calls <= max_calls: return f(buffer, rtlsdr_obj) rtlsdr_obj.cancel_read_async() return return wrapper return decorator pyrtlsdr-0.3.0/rtlsdr/librtlsdr.py000066400000000000000000000174601446252431000172730ustar00rootroot00000000000000# This file is part of pyrlsdr. # Copyright (C) 2013 by Roger # # pyrlsdr 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 of the License, or # (at your option) any later version. # pyrlsdr 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 pyrlsdr. If not, see . import sys import os from ctypes import * from ctypes.util import find_library try: import pyrtlsdrlib except ImportError: pyrtlsdrlib = None def load_librtlsdr(): # If pyrtlsdrlib is intalled try its loader first if pyrtlsdrlib is not None: dll = pyrtlsdrlib.load_librtlsdr() if dll is not None: return dll if sys.platform == "linux" and 'LD_LIBRARY_PATH' in os.environ.keys(): ld_library_paths = [local_path for local_path in os.environ['LD_LIBRARY_PATH'].split(':') if local_path.strip()] driver_files = [local_path + '/librtlsdr.so' for local_path in ld_library_paths] else: driver_files = [] driver_files += ['librtlsdr.so', 'rtlsdr/librtlsdr.so'] driver_files += ['rtlsdr.dll', 'librtlsdr.so', 'librtlsdr.dylib'] driver_files += ['..//rtlsdr.dll', '..//librtlsdr.so'] driver_files += ['rtlsdr//rtlsdr.dll', 'rtlsdr//librtlsdr.so'] driver_files += [lambda : find_library('rtlsdr'), lambda : find_library('librtlsdr')] dll = None for driver in driver_files: if callable(driver): driver = driver() if driver is None: continue try: dll = CDLL(driver) break except: pass else: raise ImportError('Error loading librtlsdr. Make sure librtlsdr '\ '(and all of its dependencies) are in your path') return dll librtlsdr = load_librtlsdr() # we don't care about the rtlsdr_dev struct and it's allocated by librtlsdr, so # we won't even bother filling it in p_rtlsdr_dev = c_void_p # async callbacks must be passed through this function # typedef void(*rtlsdr_read_async_cb_t)(unsigned char *buf, uint32_t len, void *ctx); rtlsdr_read_async_cb_t = CFUNCTYPE(None, POINTER(c_ubyte), c_int, py_object) # uint32_t rtlsdr_get_device_count(void); f = librtlsdr.rtlsdr_get_device_count f.restype, f.argtypes = c_uint, [] # const char* rtlsdr_get_device_name(uint32_t index); f = librtlsdr.rtlsdr_get_device_name f.restype, f.argtypes = c_char_p, [c_uint] # int rtlsdr_get_device_usb_strings(uint32_t index, char *manufact, # char *product, char *serial) f = librtlsdr.rtlsdr_get_device_usb_strings f.restype, f.argtypes = c_int, [c_uint, POINTER(c_ubyte), POINTER(c_ubyte), POINTER(c_ubyte)] # int rtlsdr_get_index_by_serial(const char *serial); f = librtlsdr.rtlsdr_get_index_by_serial f.restype, f.argtypes = c_int, [c_char_p] # int rtlsdr_open(rtlsdr_dev_t **dev, uint32_t index); f = librtlsdr.rtlsdr_open f.restype, f.argtypes = c_int, [POINTER(p_rtlsdr_dev), c_uint] # int rtlsdr_close(rtlsdr_dev_t *dev); f = librtlsdr.rtlsdr_close f.restype, f.argtypes = c_int, [p_rtlsdr_dev] # /* configuration functions */ # int rtlsdr_set_center_freq(rtlsdr_dev_t *dev, uint32_t freq); f = librtlsdr.rtlsdr_set_center_freq f.restype, f.argtypes = c_int, [p_rtlsdr_dev, c_uint] # int rtlsdr_get_center_freq(rtlsdr_dev_t *dev); f = librtlsdr.rtlsdr_get_center_freq f.restype, f.argtypes = c_uint, [p_rtlsdr_dev] # int rtlsdr_set_freq_correction(rtlsdr_dev_t *dev, int ppm); f = librtlsdr.rtlsdr_set_freq_correction f.restype, f.argtypes = c_int, [p_rtlsdr_dev, c_int] # int rtlsdr_get_freq_correction(rtlsdr_dev_t *dev); f = librtlsdr.rtlsdr_get_freq_correction f.restype, f.argtypes = c_int, [p_rtlsdr_dev] # enum rtlsdr_tuner rtlsdr_get_tuner_type(rtlsdr_dev_t *dev); f = librtlsdr.rtlsdr_get_tuner_type f.restype, f.argtypes = c_int, [p_rtlsdr_dev] # int rtlsdr_set_tuner_gain(rtlsdr_dev_t *dev, int gain); f = librtlsdr.rtlsdr_set_tuner_gain f.restype, f.argtypes = c_int, [p_rtlsdr_dev, c_int] # int rtlsdr_get_tuner_gain(rtlsdr_dev_t *dev); f = librtlsdr.rtlsdr_get_tuner_gain f.restype, f.argtypes = c_int, [p_rtlsdr_dev] # int rtlsdr_get_tuner_gains(rtlsdr_dev_t *dev, int *gains) f = librtlsdr.rtlsdr_get_tuner_gains f.restype, f.argtypes = c_int, [p_rtlsdr_dev, POINTER(c_int)] # RTLSDR_API int rtlsdr_set_tuner_gain_mode(rtlsdr_dev_t *dev, int manual); f = librtlsdr.rtlsdr_set_tuner_gain_mode f.restype, f.argtypes = c_int, [p_rtlsdr_dev, c_int] # RTLSDR_API int rtlsdr_set_agc_mode(rtlsdr_dev_t *dev, int on); f = librtlsdr.rtlsdr_set_agc_mode f.restype, f.argtypes = c_int, [p_rtlsdr_dev, c_int] # RTLSDR_API int rtlsdr_set_direct_sampling(rtlsdr_dev_t *dev, int on) f = librtlsdr.rtlsdr_set_direct_sampling f.restype, f.argtypes = c_int, [p_rtlsdr_dev, c_int] # int rtlsdr_set_sample_rate(rtlsdr_dev_t *dev, uint32_t rate); f = librtlsdr.rtlsdr_set_sample_rate f.restype, f.argtypes = c_int, [p_rtlsdr_dev, c_uint] # int rtlsdr_get_sample_rate(rtlsdr_dev_t *dev); f = librtlsdr.rtlsdr_get_sample_rate f.restype, f.argtypes = c_uint, [p_rtlsdr_dev] # int rtlsdr_set_and_get_tuner_bandwidth(rtlsdr_dev_t *dev, uint32_t bw, uint32_t *applied_bw, int apply_bw ); try: f = librtlsdr.rtlsdr_set_and_get_tuner_bandwidth f.restype, f.argtypes = c_uint, [p_rtlsdr_dev, c_uint32, POINTER(c_uint32), c_int] tuner_bandwidth_supported = True except AttributeError: tuner_bandwidth_supported = False # int rtlsdr_set_tuner_bandwidth(rtlsdr_dev_t *dev, uint32_t bw); try: f = librtlsdr.rtlsdr_set_tuner_bandwidth f.restype, f.argtypes = c_uint, [p_rtlsdr_dev, c_uint] tuner_set_bandwidth_supported = True except AttributeError: tuner_set_bandwidth_supported = False #/* streaming functions */ # int rtlsdr_reset_buffer(rtlsdr_dev_t *dev); f = librtlsdr.rtlsdr_reset_buffer f.restype, f.argtypes = c_int, [p_rtlsdr_dev] # int rtlsdr_read_sync(rtlsdr_dev_t *dev, void *buf, int len, int *n_read); f = librtlsdr.rtlsdr_read_sync f.restype, f.argtypes = c_int, [p_rtlsdr_dev, c_void_p, c_int, POINTER(c_int)] # int rtlsdr_wait_async(rtlsdr_dev_t *dev, rtlsdr_read_async_cb_t cb, void *ctx); f = librtlsdr.rtlsdr_wait_async f.restype, f.argtypes = c_int, [p_rtlsdr_dev, POINTER(rtlsdr_read_async_cb_t), py_object] #int rtlsdr_read_async(rtlsdr_dev_t *dev, # rtlsdr_read_async_cb_t cb, # void *ctx, # uint32_t buf_num, # uint32_t buf_len); f = librtlsdr.rtlsdr_read_async f.restype, f.argtypes = c_int, [p_rtlsdr_dev, rtlsdr_read_async_cb_t, py_object, c_uint, c_uint] # int rtlsdr_cancel_async(rtlsdr_dev_t *dev); f = librtlsdr.rtlsdr_cancel_async f.restype, f.argtypes = c_int, [p_rtlsdr_dev] # RTLSDR_API int rtlsdr_set_bias_tee(rtlsdr_dev_t *dev, int on); f = librtlsdr.rtlsdr_set_bias_tee f.restype, f.argtypes = c_int, [p_rtlsdr_dev, c_int] # RTLSDR_API int rtlsdr_set_xtal_freq(rtlsdr_dev_t *dev, uint32_t rtl_freq, # uint32_t tuner_freq); f = librtlsdr.rtlsdr_set_xtal_freq f.restype, f.argtypes = c_int, [p_rtlsdr_dev, c_uint, c_uint] # RTLSDR_API int rtlsdr_get_xtal_freq(rtlsdr_dev_t *dev, uint32_t *rtl_freq, # uint32_t *tuner_freq); f = librtlsdr.rtlsdr_get_xtal_freq f.restype, f.argtypes = c_int, [p_rtlsdr_dev, POINTER(c_uint), POINTER(c_uint)] # RTLSDR_API int rtlsdr_set_testmode(rtlsdr_dev_t *dev, int on); f = librtlsdr.rtlsdr_set_testmode f.restype, f.argtypes = c_int, [p_rtlsdr_dev, c_int] __all__ = ['librtlsdr', 'p_rtlsdr_dev', 'rtlsdr_read_async_cb_t'] pyrtlsdr-0.3.0/rtlsdr/rtlsdr.py000066400000000000000000000626101446252431000166010ustar00rootroot00000000000000# This file is part of pyrlsdr. # Copyright (C) 2013 by Roger # # pyrlsdr 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 of the License, or # (at your option) any later version. # pyrlsdr 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 pyrlsdr. If not, see . from __future__ import division, print_function from ctypes import * from .librtlsdr import ( librtlsdr, p_rtlsdr_dev, rtlsdr_read_async_cb_t, tuner_bandwidth_supported, tuner_set_bandwidth_supported, ) try: from itertools import izip except ImportError: izip = zip import sys PY3 = sys.version_info.major >= 3 if PY3: basestring = str # see if NumPy is available has_numpy = True try: import numpy as np except ImportError: has_numpy = False class BaseRtlSdr(object): """Core interface for most API functionality Arguments: device_index (:obj:`int`, optional): The device index to use if there are multiple dongles attached. If only one is being used, the default value (0) will be used. test_mode_enabled (:obj:`bool`, optional): If True, enables a special test mode, which will return the value of an internal RTL2832 8-bit counter with calls to :meth:`read_bytes`. serial_number (:obj:`str`, optional): If not None, the device will be searched for by the given serial_number by :meth:`get_device_index_by_serial` and the ``device_index`` returned will be used automatically. Attributes: DEFAULT_GAIN: Default :attr:`gain` value used on initialization: ``'auto'`` DEFAULT_FC (float): Default :attr:`center_freq` value used on initialization: ``80e6`` (80 Mhz) DEFAULT_RS (float): Default :attr:`sample_rate` value used on initialization: ``1.024e6`` (1024 Msps) DEFAULT_READ_SIZE (int): Default number of samples or bytes to read if no arguments are supplied for :meth:`read_bytes` or :meth:`read_samples`. Default value is ``1024`` gain_values (list(int)): The valid gain parameters supported by the device (in tenths of dB). These are stored as returned by ``librtlsdr``. valid_gains_db (list(float)): The valid gains in dB """ # some default values for various parameters DEFAULT_GAIN = 'auto' DEFAULT_FC = 80e6 DEFAULT_RS = 1.024e6 DEFAULT_READ_SIZE = 1024 CRYSTAL_FREQ = 28800000 gain_values = [] valid_gains_db = [] buffer = [] num_bytes_read = c_int32(0) device_opened = False @staticmethod def get_device_index_by_serial(serial): """Retrieves the device index for a device matching the given serial number Arguments: serial (str): The serial number to search for Returns: int: The device_index as reported by ``librtlsdr`` Notes: Most devices by default have the same serial number: `'0000001'`. This can be set to a custom value by using the `rtl\_eeprom`_ utility packaged with ``librtlsdr``. .. _rtl\_eeprom: http://manpages.ubuntu.com/manpages/trusty/man1/rtl_eeprom.1.html """ if PY3 and isinstance(serial, str): serial = bytes(serial, 'UTF-8') result = librtlsdr.rtlsdr_get_index_by_serial(serial) if result < 0: raise LibUSBError(result) return result @staticmethod def get_device_serial_addresses(): """Get serial numbers for all attached devices Returns: list(str): A ``list`` of all detected serial numbers (``str``) """ def get_serial(device_index): bfr = (c_ubyte * 256)() r = librtlsdr.rtlsdr_get_device_usb_strings(device_index, None, None, bfr) if r != 0: raise LibUSBError( r, 'while reading USB strings (device %d)' % (device_index) ) return ''.join((chr(b) for b in bfr if b > 0)) num_devices = librtlsdr.rtlsdr_get_device_count() return [get_serial(i) for i in range(num_devices)] def __init__(self, device_index=0, test_mode_enabled=False, serial_number=None): self.open(device_index, test_mode_enabled, serial_number) def open(self, device_index=0, test_mode_enabled=False, serial_number=None): """Connect to the device through the underlying wrapper library Initializes communication with the device and retrieves information from it with a call to :meth:`init_device_values`. Arguments: device_index (:obj:`int`, optional): The device index to use if there are multiple dongles attached. If only one is being used, the default value (0) will be used. test_mode_enabled (:obj:`bool`, optional): If True, enables a special test mode, which will return the value of an internal RTL2832 8-bit counter with calls to :meth:`read_bytes`. serial_number (:obj:`str`, optional): If not None, the device will be searched for by the given serial_number by :meth:`get_device_index_by_serial` and the ``device_index`` returned will be used automatically. Notes: The arguments used here are passed directly from object initialization. Raises: IOError: If communication with the device could not be established. """ if serial_number is not None: device_index = self.get_device_index_by_serial(serial_number) # this is the pointer to the device structure used by all librtlsdr # functions self.dev_p = p_rtlsdr_dev(None) # initialize device result = librtlsdr.rtlsdr_open(self.dev_p, device_index) if result < 0: raise LibUSBError(result, 'Could not open SDR (device index = %d)' % (device_index)) # enable test mode if necessary result = librtlsdr.rtlsdr_set_testmode(self.dev_p, int(test_mode_enabled)) if result < 0: raise LibUSBError(result, 'Could not set test mode') # reset buffers result = librtlsdr.rtlsdr_reset_buffer(self.dev_p) if result < 0: raise LibUSBError(result, 'Could not reset buffer') self.device_opened = True self.init_device_values() def init_device_values(self): """Retrieves information from the device This method acquires the values for :attr:`gain_values`. Also sets the device to the default :attr:`center frequency `, the :attr:`sample rate ` and :attr:`gain ` """ self.gain_values = self.get_gains() self.valid_gains_db = [val/10 for val in self.gain_values] # set default state self.set_sample_rate(self.DEFAULT_RS) self.set_center_freq(self.DEFAULT_FC) self.set_gain(self.DEFAULT_GAIN) def close(self): if not self.device_opened: return librtlsdr.rtlsdr_close(self.dev_p) self.device_opened = False def __del__(self): self.close() def set_center_freq(self, freq): freq = int(freq) result = librtlsdr.rtlsdr_set_center_freq(self.dev_p, freq) if result < 0: self.close() raise LibUSBError(result, 'Could not set center_freq to %d Hz' % (freq)) return def get_center_freq(self): result = librtlsdr.rtlsdr_get_center_freq(self.dev_p) if result < 0: self.close() raise LibUSBError(result, 'Could not get center_freq') # FIXME: the E4000 rounds to kHz, this may not be true for other tuners reported_center_freq = result center_freq = round(reported_center_freq, -3) return center_freq def set_freq_correction(self, err_ppm): freq = int(err_ppm) result = librtlsdr.rtlsdr_set_freq_correction(self.dev_p, err_ppm) if result < 0: self.close() raise LibUSBError(result, 'Could not set freq. offset to %d ppm' % (err_ppm)) return def get_freq_correction(self): result = librtlsdr.rtlsdr_get_freq_correction(self.dev_p) if result < 0: self.close() raise LibUSBError(result, 'Could not get freq. offset') return result def set_sample_rate(self, rate): rate = int(rate) result = librtlsdr.rtlsdr_set_sample_rate(self.dev_p, rate) if result < 0: self.close() raise LibUSBError(result, 'Could not set sample rate to %d Hz' % (rate)) return def get_sample_rate(self): result = librtlsdr.rtlsdr_get_sample_rate(self.dev_p) if result < 0: self.close() raise LibUSBError(result, 'Could not get sample rate') # figure out actual sample rate, taken directly from librtlsdr reported_sample_rate = result rsamp_ratio = (self.CRYSTAL_FREQ * pow(2, 22)) // reported_sample_rate rsamp_ratio &= ~3 real_rate = (self.CRYSTAL_FREQ * pow(2, 22)) / rsamp_ratio; return real_rate def set_bandwidth(self, bw): requested_bw = int(bw) bw = int(bw) if tuner_bandwidth_supported: apply_bw = c_int(1) applied_bw = c_uint32(bw) bw = c_uint32(bw) result = librtlsdr.rtlsdr_set_and_get_tuner_bandwidth( self.dev_p, bw, byref(applied_bw), apply_bw) self._bandwidth = applied_bw.value elif tuner_set_bandwidth_supported: bw = int(bw) result = librtlsdr.rtlsdr_set_tuner_bandwidth(self.dev_p, bw) self._bandwidth = bw else: raise IOError('set_tuner_bandwidth not supported in this version of librtlsdr') if result != 0: self.close() raise LibUSBError(result, 'Could not set tuner bandwidth to %d Hz' % (requested_bw)) return def get_bandwidth(self): return getattr(self, '_bandwidth', 0) def set_gain(self, gain): if isinstance(gain, basestring) and gain == 'auto': # disable manual gain -> enable AGC self.set_manual_gain_enabled(False) return # find supported gain nearest to one requested errors = [abs(10*gain - g) for g in self.gain_values] nearest_gain_ind = errors.index(min(errors)) # disable AGC self.set_manual_gain_enabled(True) result = librtlsdr.rtlsdr_set_tuner_gain(self.dev_p, self.gain_values[nearest_gain_ind]) if result < 0: self.close() raise LibUSBError(result, 'Could not set gain to %d' % (gain)) return def get_gain(self): result = librtlsdr.rtlsdr_get_tuner_gain(self.dev_p) if 0 and result == 0: self.close() raise IOError('Error when getting gain') return result/10 def get_gains(self): """Get all supported gain values from driver Returns: list(int): Gains in tenths of a dB """ buffer = (c_int *50)() result = librtlsdr.rtlsdr_get_tuner_gains(self.dev_p, buffer) if result == 0: self.close() raise IOError('Error when getting gains') gains = [] for i in range(result): gains.append(buffer[i]) return gains def set_manual_gain_enabled(self, enabled): """Enable or disable manual gain control of tuner. Arguments: enabled (bool): Notes: If ``enabled`` is False, then AGC should also be used by calling :meth:`set_agc_mode`. It is recommended to use :meth:`set_gain` instead of calling this method directly. """ result = librtlsdr.rtlsdr_set_tuner_gain_mode(self.dev_p, int(enabled)) if result < 0: raise LibUSBError(result, 'Could not get gain mode') return def set_agc_mode(self, enabled): """Enable RTL2832 AGC Arguments: enabled (bool): """ result = librtlsdr.rtlsdr_set_agc_mode(self.dev_p, int(enabled)) if result < 0: raise LibUSBError(result, 'Could not set AGC mode') return result def set_bias_tee(self, enabled): """Enable RTL2832 Bias Tee Enables or disables the Bias Tee option (RTL-SDRv3 only) Arguments: enabled (bool): .. warning:: Using this could potentially damage your device! Please make sure you understand what Bias Tee does before using this method. See the Bias T section of the `RTL-SDRv3 Manual`_ for information. .. versionadded:: 0.2.93 .. _RTL-SDRv3 Manual: https://www.rtl-sdr.com/rtl-sdr-blog-v-3-dongles-user-guide/ """ result = librtlsdr.rtlsdr_set_bias_tee(self.dev_p, int(enabled)) if result < 0: raise LibUSBError(result, 'Could not set Bias Tee mode') return result def set_direct_sampling(self, direct): """Enable direct sampling. Arguments: direct: If False or 0, disable direct sampling. If 'i' or 1, use ADC I input. If 'q' or 2, use ADC Q input. """ # convert parameter if isinstance(direct, basestring): if direct.lower() == 'i': direct = 1 elif direct.lower() == 'q': direct = 2 else: raise SyntaxError('invalid value "%s"' % direct) # make sure False works as an option if not direct: direct = 0 result = librtlsdr.rtlsdr_set_direct_sampling(self.dev_p, direct) if result < 0: raise LibUSBError(result, 'Could not set direct sampling') return result def get_tuner_type(self): """Get the tuner type. Returns: int: The tuner type as reported by the driver. See the `tuner enum definition`_ for more information. .. _tuner enum definition: https://github.com/librtlsdr/librtlsdr/blob/c7d970ac5b70e897501909a48b2b32d4bfb16979/include/rtl-sdr.h#L185-L201 """ result = librtlsdr.rtlsdr_get_tuner_type(self.dev_p) if result < 0: raise LibUSBError(result, 'Could not get tuner type') return result def read_bytes(self, num_bytes=DEFAULT_READ_SIZE): """Read specified number of bytes from tuner. Does not attempt to unpack complex samples (see :meth:`read_samples`), and data may be unsafe as buffer is reused. Arguments: num_bytes (:obj:`int`, optional): The number of bytes to read. Defaults to :attr:`DEFAULT_READ_SIZE`. Returns: ctypes.Array[c_ubyte]: A buffer of len(num_bytes) containing the raw samples read. """ # FIXME: libsdrrtl may not be able to read an arbitrary number of bytes num_bytes = int(num_bytes) # create buffer, as necessary if len(self.buffer) != num_bytes: array_type = (c_ubyte*num_bytes) self.buffer = array_type() result = librtlsdr.rtlsdr_read_sync(self.dev_p, self.buffer, num_bytes,\ byref(self.num_bytes_read)) if result < 0: self.close() raise LibUSBError(result, 'Could not read %d bytes' % (num_bytes)) if self.num_bytes_read.value != num_bytes: self.close() raise IOError('Short read, requested %d bytes, received %d'\ % (num_bytes, self.num_bytes_read.value)) return self.buffer def read_samples(self, num_samples=DEFAULT_READ_SIZE): """Read specified number of complex samples from tuner. Real and imaginary parts are normalized to be in the range [-1, 1]. Data is safe after this call (will not get overwritten by another one). Arguments: num_samples (:obj:`int`, optional): Number of samples to read. Defaults to :attr:`DEFAULT_READ_SIZE`. Returns: The samples read as either a :class:`list` or :class:`numpy.ndarray` (if available). """ num_bytes = 2*num_samples raw_data = self.read_bytes(num_bytes) iq = self.packed_bytes_to_iq(raw_data) return iq def packed_bytes_to_iq(self, bytes): """Unpack a sequence of bytes to a sequence of normalized complex numbers This is called automatically by :meth:`read_samples`. Returns: The unpacked iq values as either a :class:`list` or :class:`numpy.ndarray` (if available). """ if has_numpy: # use NumPy array data = np.ctypeslib.as_array(bytes) iq = data.astype(np.float64).view(np.complex128) iq /= 127.5 iq -= (1 + 1j) else: # use normal list iq = [complex(i/(255/2) - 1, q/(255/2) - 1) for i, q in izip(bytes[::2], bytes[1::2])] return iq center_freq = fc = property(get_center_freq, set_center_freq, doc="""int: Get/Set the center frequency of the device (in Hz)""") sample_rate = rs = property(get_sample_rate, set_sample_rate, doc="""int: Get/Set the sample rate of the tuner (in Hz)""") gain = property(get_gain, set_gain, doc="""float or str: Get/Set gain of the tuner (in dB) Notes: If set to 'auto', AGC mode is enabled; otherwise gain is in dB. The actual gain used is rounded to the nearest value supported by the device (see the values in :attr:`valid_gains_db`). """) freq_correction = property(get_freq_correction, set_freq_correction, doc="""int: Get/Set frequency offset of the tuner (in PPM)""") bandwidth = property(get_bandwidth, set_bandwidth, doc="""int: Get/Set bandwidth value (in Hz) Set value to 0 (default) for automatic bandwidth selection. Notes: This value is stored locally and may not reflect the real tuner bandwidth """) # This adds async read support to base class BaseRtlSdr (don't use that one) class RtlSdr(BaseRtlSdr): """This adds async read support to :class:`BaseRtlSdr` """ DEFAULT_ASYNC_BUF_NUMBER = 0 # librtlsdr will use the default (15) DEFAULT_READ_SIZE = 1024 read_async_canceling = False def read_bytes_async(self, callback, num_bytes=DEFAULT_READ_SIZE, context=None): """Continuously read bytes from tuner Arguments: callback: A function or method that will be called with the result. See :meth:`_bytes_converter_callback` for the signature. num_bytes (int): Number of bytes to read for each callback. Defaults to :attr:`DEFAULT_READ_SIZE`. context (Optional): Object to be passed as an argument to the callback. If not supplied or None, the :class:`RtlSdr` instance will be used. Notes: As with :meth:`~BaseRtlSdr.read_bytes`, the data passed to the callback may by overwritten. """ num_bytes = int(num_bytes) # we don't call the provided callback directly, but add a layer inbetween # to convert the raw buffer to a safer type # save requested callback self._callback_bytes = callback # convert Python callback function to a librtlsdr callback rtlsdr_callback = rtlsdr_read_async_cb_t(self._bytes_converter_callback) # use this object as context if none provided if not context: context = self self.read_async_canceling = False result = librtlsdr.rtlsdr_read_async(self.dev_p, rtlsdr_callback,\ context, self.DEFAULT_ASYNC_BUF_NUMBER, num_bytes) if result < 0: self.close() raise LibUSBError(result, 'Could not read %d bytes' % (num_bytes)) self.read_async_canceling = False return def _bytes_converter_callback(self, raw_buffer, num_bytes, context): """Converts the raw buffer used in ``rtlsdr_read_async`` to a usable type This method is used internally by :meth:`read_bytes_async` to convert the raw data from ``rtlsdr_read_async`` into a memory-safe array. The callback given in :meth:`read_bytes_async` will then be called with the signature:: callback(values, context) Arguments: raw_buffer: Buffer of type ``unsigned char`` num_bytes (int): Length of ``raw_buffer`` context: User-defined value passed to ``rtlsdr_read_async``. In most cases, will be a reference to the :class:`RtlSdr` instance Notes: This method is not meant to be called directly or overridden by subclasses. """ array_type = (c_ubyte*num_bytes) values = cast(raw_buffer, POINTER(array_type)).contents # skip callback if cancel_read_async() called if self.read_async_canceling: return self._callback_bytes(values, context) def read_samples_async(self, callback, num_samples=DEFAULT_READ_SIZE, context=None): """Continuously read 'samples' from the tuner This is a combination of :meth:`read_samples` and :meth:`read_bytes_async` Arguments: callback: A function or method that will be called with the result. See :meth:`_samples_converter_callback` for the signature. num_samples (int): The number of samples read into each callback. Defaults to :attr:`DEFAULT_READ_SIZE`. context (Optional): Object to be passed as an argument to the callback. If not supplied or None, the :class:`RtlSdr` instance will be used. """ num_bytes = 2*num_samples self._callback_samples = callback self.read_bytes_async(self._samples_converter_callback, num_bytes, context) return def _samples_converter_callback(self, buffer, context): """Converts the raw buffer used in ``rtlsdr_read_async`` to a usable type This method is used internally by :meth:`read_samples_async` to convert the data into a sequence of complex numbers. The callback given in :meth:`read_samples_async` will then be called with the signature:: callback(samples, context) Arguments: buffer: Buffer of type ``unsigned char`` context: User-defined value passed to ``rtlsdr_read_async``. In most cases, will be a reference to the :class:`RtlSdr` instance Notes: This method is not meant to be called directly or overridden by subclasses. """ iq = self.packed_bytes_to_iq(buffer) self._callback_samples(iq, context) def cancel_read_async(self): """Cancel async read. This should be called eventually when using async reads (:meth:`read_bytes_async` or :meth:`read_samples_async`), or callbacks will never stop. See Also: :func:`~rtlsdr.helpers.limit_time` and :func:`~rtlsdr.helpers.limit_calls` """ result = librtlsdr.rtlsdr_cancel_async(self.dev_p) # sometimes we get additional callbacks after canceling an async read, # in this case we don't raise exceptions if result < 0 and not self.read_async_canceling: self.close() raise LibUSBError(result, 'Could not cancel async read') self.read_async_canceling = True class LibUSBError(IOError): _errno_map = { -1: ('LIBUSB_ERROR_IO', 'Input/output error'), -2: ('LIBUSB_ERROR_INVALID_PARAM', 'Invalid parameter'), -3: ('LIBUSB_ERROR_ACCESS', 'Access denied (insufficient permissions)'), -4: ('LIBUSB_ERROR_NO_DEVICE', 'No such device (it may have been disconnected)'), -5: ('LIBUSB_ERROR_NOT_FOUND', 'Entity not found'), -6: ('LIBUSB_ERROR_BUSY', 'Resource busy'), -7: ('LIBUSB_ERROR_TIMEOUT', 'Operation timed out'), -8: ('LIBUSB_ERROR_OVERFLOW', 'Overflow'), -9: ('LIBUSB_ERROR_PIPE', 'Pipe error'), -10: ('LIBUSB_ERROR_INTERRUPTED', 'System call interrupted (perhaps due to signal)'), -11: ('LIBUSB_ERROR_NO_MEM', 'Insufficient memory'), -12: ('LIBUSB_ERROR_NOT_SUPPORTED', 'Operation not supported or unimplemented on this platform'), -99: ('LIBUSB_ERROR_OTHER', 'Other error'), } def __init__(self, errno, msg=''): self.errno = errno self.msg = msg def __str__(self): t = self._errno_map.get(self.errno) if t is not None: err_id, err_msg = t msg = '<{err_id} ({self.errno}): {err_msg}> "{self.msg}"'.format( self=self, err_id=err_id, err_msg=err_msg, ) else: msg = 'Error code {self.errno}: {self.msg}'.format(self=self) return msg pyrtlsdr-0.3.0/rtlsdr/rtlsdraio.py000066400000000000000000000143611446252431000172720ustar00rootroot00000000000000""" This module adds :mod:`asyncio` support for reading samples from the device. The main functionality can be found in the :meth:`~rtlsdr.rtlsdraio.RtlSdrAio.stream` method of :class:`rtlsdr.rtlsdraio.RtlSdrAio`. Example: .. code-block:: python import asyncio from rtlsdr import RtlSdr async def streaming(): sdr = RtlSdr() async for samples in sdr.stream(): # do something with samples # ... # to stop streaming: await sdr.stop() # done sdr.close() loop = asyncio.get_event_loop() loop.run_until_complete(streaming()) """ import logging try: import asyncio AIO_AVAILABLE = True except ImportError: AIO_AVAILABLE = False from .rtlsdr import RtlSdr log = logging.getLogger(__name__) _CLASS_TEMPLATE = """ class AsyncCallbackIter: '''Convert a callback-based legacy async function into one supporting asyncio and Python 3.5+ The queued data can be iterated using ``async for`` Arguments: func_start: A callable which should take a single callback that will be passed data. Will be run in a separate thread in case it blocks. func_stop (optional): A callable to stop ``func_start`` from calling the callback. Will be run in a separate thread in case it blocks. queue_size (:obj:`int`, optional): The maximum amount of data that will be buffered. loop (optional): The ``asyncio.event_loop`` to use. If not supplied, :func:`asyncio.get_event_loop` will be used. ''' def __init__(self, func_start, func_stop=None, queue_size=20, *, loop=None): self.queue = asyncio.Queue(queue_size) self.loop = loop if loop else asyncio.get_event_loop() self.func_stop = func_stop self.func_start = func_start self.running = False async def add_to_queue(self, *args): '''Add items to the queue Arguments: *args: Arguments to be added This method is a :obj:`~asyncio.coroutine` ''' try: self.queue.put_nowait(args) except asyncio.QueueFull: log.info('extra callback data lost') def _callback(self, *args): if not self.running: return asyncio.run_coroutine_threadsafe(self.add_to_queue(*args), self.loop) async def start(self): '''Start the execution The callback given by ``func_start`` will be called by :meth:`asyncio.AbstractEventLoop.run_in_executor` and will continue until :meth:`stop` is called. This method is a :obj:`~asyncio.coroutine` ''' assert(not self.running) # start legacy async function future = self.loop.run_in_executor(None, self.func_start, self._callback) asyncio.ensure_future(future, loop=self.loop) self.executor_task = future self.running = True async def stop(self): '''Stop the running executor task If ``func_stop`` was supplied, it will be called after the queue has been exhausted. This method is a :obj:`~asyncio.coroutine` ''' assert(self.running) self.running = False # send a signal to stop iter_stopped = False while not iter_stopped: try: self.queue.put_nowait((StopAsyncIteration(),)) iter_stopped = True except asyncio.QueueFull: try: self.queue.task_done() except ValueError: pass if self.func_stop: # stop legacy async function await self.loop.run_in_executor(None, self.func_stop) await self.executor_task def __aiter__(self): return self async def __anext__(self): val = await self.queue.get() self.queue.task_done() if isinstance(val[0], StopAsyncIteration): raise StopAsyncIteration #return val if len(val) > 1 else val[0] # slight hack for rtlsdr to ignore context object return val[0] """ if AIO_AVAILABLE: try: exec('async def test_for_async(): pass') exec('def test_unpack_operators(a, *, b): pass') except SyntaxError: AIO_AVAILABLE = False if AIO_AVAILABLE: exec(_CLASS_TEMPLATE, globals(), locals()) class RtlSdrAio(RtlSdr): DEFAULT_READ_SIZE = 128*1024 def stream(self, num_samples_or_bytes=DEFAULT_READ_SIZE, format='samples', loop=None): """Start async streaming from SDR and return an async iterator (Python 3.5+). The :meth:`read_samples_async` method is called in an :class:`~concurrent.futures.Excecutor` instance using :meth:`asyncio.AbstractEventLoop.run_in_executor`. The returned asynchronous iterable can then used to retrieve sample data using ``async for`` syntax. Calling the :meth:`~rtlsdr.rtlsdraio.RtlSdrAio.stop` method will stop the ``read_samples_async`` session and close the ``Excecutor`` task. Arguments: num_samples_or_bytes (int): The number of bytes/samples that will be returned each iteration format (:obj:`str`, optional): Specifies whether raw data ("bytes") or IQ samples ("samples") will be returned loop (optional): An asyncio event loop Returns: An ``asynchronous iterator`` to yield sample data """ if format == 'samples': func_start = self.read_samples_async elif format == 'bytes': func_start = self.read_bytes_async else: raise ValueError('format "%s" not supported' % format) self.async_iter = AsyncCallbackIter(func_start=lambda cb: func_start(cb, num_samples_or_bytes), func_stop=self.cancel_read_async, loop=loop) asyncio.ensure_future(self.async_iter.start(), loop=loop) return self.async_iter def stop(self): """Stop async stream Stops the ``read_samples_async`` and ``Excecutor`` task created by :meth:`stream`. """ return asyncio.ensure_future(self.async_iter.stop(), loop=self.async_iter.loop) pyrtlsdr-0.3.0/rtlsdr/rtlsdrtcp/000077500000000000000000000000001446252431000167315ustar00rootroot00000000000000pyrtlsdr-0.3.0/rtlsdr/rtlsdrtcp/__init__.py000066400000000000000000000030521446252431000210420ustar00rootroot00000000000000""" This module allows client/server communication. The :class:`~rtlsdr.rtlsdrtcp.server.RtlSdrTcpServer` class is meant to be connected physically to an SDR dongle and communicate with an instance of :class:`~rtlsdr.rtlsdrtcp.client.RtlSdrTcpClient`. The client is intended to function as closely as possible to the base :class:`~rtlsdr.rtlsdr.RtlSdr` class (as if it had a physical dongle attached to it). Both of these classes have the same arguments as the base :class:`~rtlsdr.rtlsdr.RtlSdr` class with the addition of ``hostname`` and ``port``. Examples: .. code-block:: python server = RtlSdrTcpServer(hostname='192.168.1.100', port=12345) server.run_forever() # Will listen for clients until Ctrl-C is pressed .. code-block:: python # On another machine (typically) client = RtlSdrTcpClient(hostname='192.168.1.100', port=12345) client.center_freq = 2e6 data = client.read_samples() Note: On platforms where the ``librtlsdr`` library cannot be installed/compiled, it is possible to import :class:`~rtlsdr.rtlsdrtcp.RtlSdrTcpClient` only by setting the environment variable ``"RTLSDR_CLIENT_MODE"`` to ``"true"``. If this is set, no other modules will be available. *Feature added in v0.2.4* """ import os RTLSDR_CLIENT_MODE = False if os.environ.get('RTLSDR_CLIENT_MODE', '').lower() in ['true', '1', 'yes']: RTLSDR_CLIENT_MODE = True from .client import RtlSdrTcpClient try: from .server import RtlSdrTcpServer except ImportError: if not RTLSDR_CLIENT_MODE: raise pyrtlsdr-0.3.0/rtlsdr/rtlsdrtcp/base.py000077500000000000000000000217761446252431000202350ustar00rootroot00000000000000from __future__ import division import sys import time import select import socket import struct import errno import traceback import json try: from itertools import izip except ImportError: izip = zip has_numpy = True try: import numpy as np except ImportError: has_numpy = False PY2 = sys.version_info[0] == 2 DEFAULT_READ_SIZE = 1024 MAX_BUFFER_SIZE = 4096 RECEIVE_TIMEOUT = 20 class CommunicationError(Exception): def __init__(self, msg, source_exc=None): self.msg = msg self.source_exc = source_exc def __str__(self): s = self.msg if self.source_exc is not None: s = 'SOURCE EXCEPTION:\n%s\n\n%s' % (traceback.format_exc(), s) return s class RtlSdrTcpBase(object): """Base class for all ``rtlsdrtcp`` functionality Arguments: device_index (:obj:`int`, optional): test_mode_enabled (:obj:`bool`, optional): hostname (:obj:`str`, optional): port (:obj:`int`, optional): """ # Use port 1235 as default since rtl_tcp uses 1234 DEFAULT_PORT = 1235 def __init__(self, device_index=0, test_mode_enabled=False, hostname='127.0.0.1', port=None): self.device_index = device_index self.test_mode_enabled = test_mode_enabled self.hostname = hostname self.port = port if self.port is None: self.port = self.DEFAULT_PORT self.device_ready = False self.server_thread = None def packed_bytes_to_iq(self, bytes): """A direct copy of :meth:`rtlsdr.BaseRtlSdr.packed_bytes_to_iq` """ if has_numpy: # use NumPy array data = np.ctypeslib.as_array(bytes) iq = data.astype(np.float64).view(np.complex128) iq /= 127.5 iq -= (1 + 1j) else: # use normal list iq = [complex(i/(255/2) - 1, q/(255/2) - 1) for i, q in izip(bytes[::2], bytes[1::2])] return iq API_METHODS = ( 'get_center_freq', 'set_center_freq', 'get_sample_rate', 'set_sample_rate', 'get_bandwidth', 'set_bandwidth', 'get_gain', 'set_gain', 'get_freq_correction', 'set_freq_correction', 'get_gains', 'get_tuner_type', 'set_direct_sampling', 'read_bytes', 'read_samples', ) API_DESCRIPTORS = { 'center_freq', 'fc', 'sample_rate', 'rs', 'bandwidth', 'gain', 'freq_correction', } class MessageBase(object): """Base class for messages sent between clients and servers. Handles serialization/deserialization and communication with socket type objects. Attributes: timestamp (float): Timestamp given from :func:`time.time` header (dict): A ``dict`` containing message type and payload information data: The payload containing either the request or response data """ def __init__(self, **kwargs): self.timestamp = kwargs.get('timestamp') self.header = self.get_header(**kwargs) self.data = self.get_data(**kwargs) @staticmethod def _send(sock, data): if not PY2 and isinstance(data, str): data = data.encode() r, w, e = select.select([], [sock], [], .5) if sock not in w: raise CommunicationError('socket %r not ready for write' % (sock)) return sock.send(data) @staticmethod def _recv(sock): start_ts = time.time() r, w, e = select.select([sock], [], [], RECEIVE_TIMEOUT) if not len(r): now = time.time() raise CommunicationError('No response from peer after %s seconds' % (now - start_ts)) if sock not in r: raise CommunicationError('socket %r not ready for read' % (sock)) return sock.recv(MAX_BUFFER_SIZE) @classmethod def from_remote(cls, sock): """Reads data from the socket and parses an instance of :class:`MessageBase` Arguments: sock: The :class:`~socket.socket` object to read from """ header = cls._recv(sock) if not PY2: header = header.decode() kwargs = json.loads(header) if kwargs.get('ACK'): cls = AckMessage return cls(**kwargs) def get_header(self, **kwargs): """Builds the header data for the message The :attr:`timestamp` is added to the header if not already present. Returns: dict: """ d = {} ts = kwargs.get('timestamp') if ts is None: ts = time.time() d['timestamp'] = ts return d def get_data(self, **kwargs): return kwargs.get('data', kwargs.get('header', {}).get('data')) def send_message(self, sock): """Serializes and sends the message Arguments: sock: The :class:`~socket.socket` object to write to """ header, data = self._serialize() self._send(sock, header) def get_response(self, sock): """Waits for a specific response message The message class returned from :meth:`get_response_class` is used to parse the message (called from :meth:`from_remote`) Arguments: sock: The :class:`~socket.socket` object to read from """ cls = self.get_response_class() return cls.from_remote(sock) def get_ack_response(self, sock): return AckMessage.from_remote(sock) def _serialize(self): """Serializes the message header and data """ struct_fmt = self.header.get('struct_fmt') if struct_fmt is not None: return json.dumps(self.header), self.data data = self.header.copy() data.setdefault('data', self.data) return json.dumps(data), None class AckMessage(MessageBase): """Simple message type meant for ACKnolegemnt of message receipt """ def get_header(self, **kwargs): d = super(AckMessage, self).get_header(**kwargs) d['ACK'] = True d['ok'] = kwargs.get('ok', True) return d class ServerMessage(MessageBase): @classmethod def from_remote(cls, sock): """Reads data for the socket buffer and reconstructs the appropriate message that was sent by the other end. This method is used by clients to reconstruct ServerMessage objects and if necessary, use multiple read calls to get the entire message (if the message size is greater than the buffer length) """ header = cls._recv(sock) if not PY2: header = header.decode() kwargs = json.loads(header) struct_fmt = kwargs.get('struct_fmt') if struct_fmt is not None: struct_fmt = str(struct_fmt) data_len = struct.calcsize(struct_fmt) else: return cls(**kwargs) ack_msg = AckMessage() ack_msg.send_message(sock) recv = None while data_len > 0: _recv = cls._recv(sock) if recv is None: recv = _recv else: recv += _recv data_len -= len(_recv) kwargs['data'] = struct.unpack(struct_fmt, recv) return cls(**kwargs) def send_message(self, sock): """Sends the message data to clients. If necessary, uses multiple calls to send to ensure all data has actually been sent through the socket objects's buffer. """ header, data = self._serialize() self._send(sock, header) if isinstance(self.data, dict): struct_fmt = self.data.get('struct_fmt') else: struct_fmt = None if struct_fmt is not None: struct_fmt = str(struct_fmt) data = self.data['data'] data_len = struct.calcsize(struct_fmt) ack = self.get_ack_response(sock) if not ack.header.get('ok'): raise CommunicationError('No ACK received') while data_len > 0: sent = self._send(sock, data) data_len -= sent data = data[sent:] def get_header(self, **kwargs): d = super(ServerMessage, self).get_header(**kwargs) d['success'] = kwargs.get('success', True) client_message = kwargs.get('client_message') if client_message is not None: d['request'] = client_message.header else: d['request'] = kwargs.get('request') return d def get_data(self, **kwargs): d = super(ServerMessage, self).get_data(**kwargs) if isinstance(d, dict) and 'struct_fmt' in d: self.header['struct_fmt'] = d['struct_fmt'] return d def get_response_class(self): return AckMessage class ClientMessage(MessageBase): def send_message(self, sock): super(ClientMessage, self).send_message(sock) return self.get_response(sock) def get_header(self, **kwargs): d = super(ClientMessage, self).get_header(**kwargs) keys = ['type', 'name'] d.update({k: kwargs.get(k) for k in keys}) return d def get_response_class(self): return ServerMessage pyrtlsdr-0.3.0/rtlsdr/rtlsdrtcp/client.py000066400000000000000000000107611446252431000205660ustar00rootroot00000000000000 import socket from .base import ( CommunicationError, RtlSdrTcpBase, ClientMessage, ServerMessage, AckMessage, DEFAULT_READ_SIZE, ) class RtlSdrTcpClient(RtlSdrTcpBase): """Client object that connects to a remote server. Exposes most of the methods and descriptors that are available in the RtlSdr class in a transparent manner allowing an interface that is nearly identical to the core API. """ def __init__(self, device_index=0, test_mode_enabled=False, hostname='127.0.0.1', port=None): super(RtlSdrTcpClient, self).__init__(device_index, test_mode_enabled, hostname, port) self.open() def open(self, *args): self._socket = None self._keep_alive = False self.device_opened = True def close(self): self.device_opened = False def _build_socket(self): s = getattr(self, '_socket', None) if s is None: s = self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((self.hostname, self.port)) return s def _close_socket(self): if self._keep_alive: return s = getattr(self, '_socket', None) if s is None: return print('client closing socket') s.close() self._socket = None def _communicate(self, tx_message): s = self._build_socket() resp = tx_message.send_message(s) if isinstance(resp, ServerMessage): if not resp.header.get('success'): msg = 'server was unsuccessful. msg=%s' % (tx_message.header) raise CommunicationError(msg) resp_data = resp.data elif isinstance(resp, AckMessage): if not resp.header.get('ok'): raise CommunicationError('ACK message received as "NAK"') resp_data = None self._close_socket() return resp_data def _communicate_method(self, method_name, arg=None): msg = ClientMessage(type='method', name=method_name, data=arg) return self._communicate(msg) def _communicate_descriptor_get(self, prop_name): msg = ClientMessage(type='prop_get', name=prop_name) return self._communicate(msg) def _communicate_descriptor_set(self, prop_name, value): msg = ClientMessage(type='prop_set', name=prop_name, data=value) return self._communicate(msg) def get_center_freq(self): return self._communicate_descriptor_get('fc') def set_center_freq(self, value): self._communicate_descriptor_set('fc', value) def get_sample_rate(self): return self._communicate_descriptor_get('rs') def set_sample_rate(self, value): self._communicate_descriptor_set('rs', value) def get_bandwidth(self): return self._communicate_descriptor_get('bandwidth') def set_bandwidth(self, value): self._communicate_descriptor_set('bandwidth', value) def get_gain(self): return self._communicate_descriptor_get('gain') def set_gain(self, value): self._communicate_descriptor_set('gain', value) def get_freq_correction(self): return self._communicate_descriptor_get('freq_correction') def set_freq_correction(self, value): self._communicate_descriptor_set('freq_correction', value) def get_gains(self): return self._communicate_method('get_gains') def get_tuner_type(self): return self._communicate_method('get_tuner_type') def set_direct_sampling(self, value): self._communicate_method('set_direct_sampling', value) def read_bytes(self, num_bytes=DEFAULT_READ_SIZE): return self._communicate_method('read_bytes', num_bytes) def read_samples(self, num_samples=DEFAULT_READ_SIZE): raw_data = self._communicate_method('read_samples', num_samples) iq = self.packed_bytes_to_iq(raw_data) return iq def read_samples_async(self, *args): raise NotImplementedError('Async read not available in TCP mode') def read_bytes_async(self, *args): raise NotImplementedError('Async read not available in TCP mode') center_freq = fc = property(get_center_freq, set_center_freq) sample_rate = rs = property(get_sample_rate, set_sample_rate) bandwidth = property(get_bandwidth, set_bandwidth) gain = property(get_gain, set_gain) freq_correction = property(get_freq_correction, set_freq_correction) pyrtlsdr-0.3.0/rtlsdr/rtlsdrtcp/server.py000066400000000000000000000173451446252431000206230ustar00rootroot00000000000000#! /usr/bin/env python import sys import threading import struct import traceback import argparse PY2 = sys.version_info[0] == 2 if PY2: from SocketServer import TCPServer, BaseRequestHandler else: from socketserver import TCPServer, BaseRequestHandler from rtlsdr import RtlSdr from .base import ( CommunicationError, RtlSdrTcpBase, ClientMessage, ServerMessage, AckMessage, DEFAULT_READ_SIZE, API_METHODS, API_DESCRIPTORS, ) class RtlSdrTcpServer(RtlSdr, RtlSdrTcpBase): """Server that connects to a physical dongle to allow client connections. """ def __init__(self, device_index=0, test_mode_enabled=False, serial_number=None, hostname='127.0.0.1', port=None): RtlSdrTcpBase.__init__(self, device_index, test_mode_enabled, hostname, port) RtlSdr.__init__(self, device_index, test_mode_enabled, serial_number) def open(self, device_index=0, test_mode_enabled=False, serial_number=None): if not self.device_ready: return super(RtlSdrTcpServer, self).open(device_index, test_mode_enabled, serial_number) def run(self): """Runs the server thread and returns. Use this only if you are running mainline code afterwards. The server must explicitly be stopped by the stop method before exit. """ if self.server_thread is None: self.server_thread = ServerThread(self) if self.server_thread.running.is_set(): return self.server_thread.start() self.server_thread.running.wait() e = self.server_thread.exception if e is not None: print(self.server_thread.exception_tb) raise e if self.server_thread.stopped.is_set(): self.server_thread = None self.close() def run_forever(self): """Runs the server and begins a mainloop. The loop will exit with Ctrl-C. """ self.run() while True: try: self.server_thread.stopped.wait(1.) except KeyboardInterrupt: self.close() break def close(self): """Stops the server (if it's running) and closes the connection to the dongle. """ if self.server_thread is not None: if self.server_thread.running.is_set(): self.server_thread.stop() self.server_thread = None super(RtlSdrTcpServer, self).close() def read_bytes(self, num_bytes=DEFAULT_READ_SIZE): """Return a packed string of bytes read along with the struct_fmt. """ fmt_str = '%dB' % (num_bytes) buffer = super(RtlSdrTcpServer, self).read_bytes(num_bytes) s = struct.pack(fmt_str, *buffer) return {'struct_fmt':fmt_str, 'data':s} def read_samples(self, num_samples=DEFAULT_READ_SIZE): """This overrides the base implementation so that the raw data is sent. It will be unpacked to I/Q samples on the client side. """ num_samples = 2*num_samples return self.read_bytes(num_samples) class ServerThread(threading.Thread): def __init__(self, rtl_sdr): super(ServerThread, self).__init__() self.rtl_sdr = rtl_sdr self.running = threading.Event() self.stopped = threading.Event() self.exception = None def run(self): try: self.server = Server(self.rtl_sdr) except Exception as e: self.exception = e self.exception_tb = traceback.format_exc() self.running.set() self.stopped.set() return rtl_sdr = self.rtl_sdr rtl_sdr.device_ready = True rtl_sdr.open(rtl_sdr.device_index, rtl_sdr.test_mode_enabled) self.running.set() self.server.serve_forever() self.running.clear() rtl_sdr.device_ready = False self.stopped.set() def stop(self): running = getattr(self, 'running', None) if running is None or not running.is_set(): return if not hasattr(self, 'server'): return self.server.shutdown() self.server.server_close() self.stopped.wait() class Server(TCPServer): REQUEST_RECV_SIZE = 1024 def __init__(self, rtl_sdr): self.rtl_sdr = rtl_sdr server_addr = (rtl_sdr.hostname, rtl_sdr.port) TCPServer.__init__(self, server_addr, RequestHandler) self.handlers = set() def server_close(self): if not hasattr(self, 'handlers'): return for h in self.handlers: h.close() class RequestHandler(BaseRequestHandler): def setup(self): self.finished = False self.server.handlers.add(self) def handle(self, rx_message=None): if rx_message is None: rx_message = ClientMessage.from_remote(self.request) msg_type = rx_message.header.get('type') if msg_type == 'method': r = self.handle_method_call(rx_message) elif msg_type == 'prop_set': r = self.handle_prop_set(rx_message) elif msg_type == 'prop_get': r = self.handle_prop_get(rx_message) else: r = False if r is False: nak = AckMessage(ok=False) nak.send_message(self.request) def finish(self): self.server.handlers.discard(self) def close(self): self.finished = True def handle_method_call(self, rx_message): rtl_sdr = self.server.rtl_sdr method_name = rx_message.header.get('name') arg = rx_message.data if method_name not in API_METHODS: raise CommunicationError('method %s not allowed' % (method_name)) try: m = getattr(rtl_sdr, method_name) except AttributeError: msg = 'sdr has no attribute "%s"' % (method_name) raise CommunicationError(msg) if arg is not None: resp = m(arg) else: resp = m() tx_message = ServerMessage(client_message=rx_message, data=resp) tx_message.send_message(self.request) def handle_prop_set(self, rx_message): rtl_sdr = self.server.rtl_sdr prop_name = rx_message.header.get('name') value = rx_message.data if prop_name not in API_DESCRIPTORS: raise CommunicationError('property %s not allowed' % (prop_name)) setattr(rtl_sdr, prop_name, value) tx_message = ServerMessage(client_message=rx_message) tx_message.send_message(self.request) def handle_prop_get(self, rx_message): prop_name = rx_message.header.get('name') if prop_name not in API_DESCRIPTORS: raise CommunicationError('property %s not allowed' % (prop_name)) rtl_sdr = self.server.rtl_sdr value = getattr(rtl_sdr, prop_name) tx_message = ServerMessage(client_message=rx_message, data=value) tx_message.send_message(self.request) def run_server(): """Convenience function to run the server from the command line with options for hostname, port and device index. """ p = argparse.ArgumentParser() p.add_argument( '-a', '--address', dest='hostname', metavar='address', default='127.0.0.1', help='Listen address (default is "127.0.0.1")') p.add_argument( '-p', '--port', dest='port', type=int, default=1235, help='Port to listen on (default is 1235)') p.add_argument( '-d', '--device-index', dest='device_index', type=int, default=0) args, remaining = p.parse_known_args() o = vars(args) server = RtlSdrTcpServer(**o) server.run_forever() if __name__ == '__main__': run_server() pyrtlsdr-0.3.0/setup.cfg000066400000000000000000000004321446252431000152160ustar00rootroot00000000000000[bdist_wheel] universal=1 [metadata] project_urls = Documentation = https://pyrtlsdr.readthedocs.io/ Source = https://github.com/pyrtlsdr/pyrtlsdr long_description = file: README.md, long_description_content_type = text/markdown [options.extras_require] lib = pyrtlsdrlib pyrtlsdr-0.3.0/setup.py000066400000000000000000000054711446252431000151170ustar00rootroot00000000000000# This file is part of pyrlsdr. # Copyright (C) 2013 by Roger # # pyrlsdr 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 of the License, or # (at your option) any later version. # pyrlsdr 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 pyrlsdr. If not, see . import os import sys import re import shutil from setuptools import setup, find_packages PACKAGE_NAME = 'pyrtlsdr' VERSION = '0.3.0' BASE_DIR = os.path.dirname(os.path.abspath(__file__)) IS_RTDBUILD = os.environ.get('READTHEDOCS', '').lower() == 'true' if IS_RTDBUILD: # copy a mocked wrapper since we can't build librtlsdr on rtfd def copy_mock_librtlsdr(): mock_src = os.path.join(BASE_DIR, 'tests', 'testlibrtlsdr.py') lib_dst = os.path.join(BASE_DIR, 'rtlsdr', 'librtlsdr.py') orig_lib_dst = os.path.join(BASE_DIR, 'rtlsdr', 'librtlsdr.py.orig') if not os.path.exists(orig_lib_dst): print(' -> '.join([lib_dst, orig_lib_dst])) os.rename(lib_dst, orig_lib_dst) print(' -> '.join([mock_src, lib_dst])) shutil.copy(mock_src, lib_dst) if 'install' in sys.argv: copy_mock_librtlsdr() #HERE = os.path.abspath(os.path.dirname(__file__)) #README = open(os.path.join(HERE, 'README.md')).read() setup( name=PACKAGE_NAME, version=VERSION, author='roger', url='https://github.com/pyrtlsdr/pyrtlsdr', description='A Python wrapper for librtlsdr (a driver for Realtek RTL2832U based SDR\'s)', classifiers=['Development Status :: 4 - Beta', 'Environment :: Console', 'Intended Audience :: Developers', 'License :: OSI Approved :: GNU General Public License (GPL)', 'Natural Language :: English', 'Operating System :: OS Independent', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.8', 'Programming Language :: Python :: 3.9', 'Programming Language :: Python :: 3.10', 'Programming Language :: Python :: 3.11', 'Topic :: Utilities'], license='GPLv3', keywords='radio librtlsdr rtlsdr sdr', platforms=['any'], packages=find_packages(exclude=['tests*'])) pyrtlsdr-0.3.0/test.py000066400000000000000000000107101446252431000147260ustar00rootroot00000000000000# This file is part of pyrlsdr. # Copyright (C) 2013 by Roger # # pyrlsdr 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 of the License, or # (at your option) any later version. # pyrlsdr 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 pyrlsdr. If not, see . from __future__ import division from __future__ import print_function import sys import argparse try: import numpy as np HAVE_NP = True except ImportError: np = None HAVE_NP = False from rtlsdr import * def get_mean(samples): if HAVE_NP: r = samples.mean() else: r = sum(samples)/len(samples) return r def main(**opts): rs = opts.get('rs', 2.4e6) fc = opts.get('fc', 100e6) gain = opts.get('gain', 10) num_reads = opts.get('num_reads', 2) num_samples = opts.get('num_samples', 256*1024) nfft = opts.get('nfft', 1024) plot_enabled = opts.get('plot_enabled', False) @limit_calls(num_reads) def test_callback(samples, rtlsdr_obj): print(' in callback, index:', rtlsdr_obj._read_index) print(' signal mean:', get_mean(samples)) all_samples = rtlsdr_obj._all_samples if HAVE_NP: all_samples[rtlsdr_obj._read_index,:] = samples else: all_samples.extend(samples) rtlsdr_obj._read_index += 1 sdr = RtlSdr() print('Configuring SDR...') sdr.rs = rs sdr.fc = fc sdr.gain = gain print(' sample rate: %0.6f MHz' % (sdr.rs/1e6)) print(' center frequency: %0.6f MHz' % (sdr.fc/1e6)) print(' gain: %d dB' % sdr.gain) print('Reading samples...') samples = sdr.read_samples(num_samples) print(' signal mean:', get_mean(samples)) print('Testing callback...') if HAVE_NP: all_samples = np.zeros((num_reads, num_samples), dtype=np.complex128) else: all_samples = [] sdr._all_samples = all_samples sdr._read_index = 0 sdr._num_reads = num_reads sdr.read_samples_async(test_callback, num_samples) if HAVE_NP: all_samples = all_samples.flatten() print('Total sample count={}, mean={}'.format(len(all_samples), get_mean(all_samples))) if plot_enabled: try: import pylab as mpl print('Testing spectrum plotting...') mpl.figure() mpl.psd(all_samples, NFFT=nfft, Fc=sdr.fc/1e6, Fs=sdr.rs/1e6) mpl.show() except: # matplotlib not installed/working pass print('Done\n') sdr.close() class ArgParseFormatter(argparse.ArgumentDefaultsHelpFormatter): def _get_default_metavar_for_optional(self, action): return action.type.__name__ def _get_default_metavar_for_positional(self, action): return action.type.__name__ def parse_args(argv=None): if argv is None: argv = sys.argv[1:] p = argparse.ArgumentParser(formatter_class=ArgParseFormatter) p.add_argument( '--rs', dest='rs', type=float, default=2.4e6, help='Device sample rate', ) p.add_argument( '--fc', dest='fc', type=float, default=100e6, help='Device center frequency', ) p.add_argument( '--gain', dest='gain', type=float, default=10., help='Device gain (dB)', ) p.add_argument( '--num-samples', dest='num_samples', type=int, default=256*1024, help='Number of samples to read from device per iteration', ) p.add_argument( '--num-reads', dest='num_reads', type=int, default=2, help='Number of times to read samples (total samples: num_reads * num_samples)', ) p.add_argument( '--nfft', dest='nfft', type=int, default=1024, help='Number of FFT bins to use for plotting (if matplotlib is available)', ) p.add_argument( '--plot', dest='plot_enabled', action='store_true', help='Plot the PSD results (if matplotlib is installed)', ) args = p.parse_args(argv) opts = vars(args) return opts if __name__ == '__main__': opts = parse_args() main(**opts) pyrtlsdr-0.3.0/tests/000077500000000000000000000000001446252431000145405ustar00rootroot00000000000000pyrtlsdr-0.3.0/tests/conftest.py000066400000000000000000000052741446252431000167470ustar00rootroot00000000000000import sys import os import pytest def pytest_addoption(parser): parser.addoption('--no-overrides', action='store_true', help='Run tests that do not override (monkeypatch) librtlsdr') def pytest_configure(config): config.addinivalue_line( 'markers', 'no_overrides: mark test to not monkeypatch librtlsdr', ) def pytest_collection_modifyitems(config, items): if config.getoption('--no-overrides'): # '--no-overrides' given, don't skip return skip_no_overrides = pytest.mark.skip(reason='need --no-overrides to run') for item in items: if 'no_overrides' in item.keywords: item.add_marker(skip_no_overrides) collect_ignore = ['setup.py', 'demo_waterfall.py'] ASYNC_AVAILABLE = sys.version_info.major >= 3 if sys.version_info.major == 3: ASYNC_AVAILABLE = sys.version_info.minor >= 5 if not ASYNC_AVAILABLE: collect_ignore.append('test_aio.py') def is_travisci(): return any([os.environ.get(key) == 'true' for key in ['CI', 'TRAVIS']]) @pytest.fixture(params=[True, False]) def tuner_bandwidth_supported(request, monkeypatch): return request.param @pytest.fixture(params=[True, False]) def tuner_set_bandwidth_supported(request): return request.param @pytest.fixture(autouse=True) def librtlsdr_override(request, monkeypatch, tuner_bandwidth_supported, tuner_set_bandwidth_supported): if isinstance(request.node, pytest.Function): # no_override tests will not monkeypatch the wrapper library module = request.node.parent if 'no_override_' in module.name: print('skipping module {}'.format(module)) return monkeypatch.setattr('rtlsdr.rtlsdr.tuner_bandwidth_supported', tuner_bandwidth_supported) monkeypatch.setattr('rtlsdr.rtlsdr.tuner_set_bandwidth_supported', 'tuner_set_bandwidth_supported') if not is_travisci(): return import testlibrtlsdr for attr in ['p_rtlsdr_dev', 'librtlsdr', 'rtlsdr_read_async_cb_t']: lib_attr = '.'.join(['rtlsdr', 'rtlsdr', attr]) override = getattr(testlibrtlsdr, attr) monkeypatch.setattr(lib_attr, override) @pytest.fixture(params=[True, False]) def use_numpy(request, monkeypatch): if not request.param: monkeypatch.setattr('rtlsdr.rtlsdr.has_numpy', False) monkeypatch.setattr('rtlsdr.rtlsdrtcp.base.has_numpy', False) return request.param @pytest.fixture def sdr_cls(): from rtlsdr.rtlsdr import RtlSdr return RtlSdr @pytest.fixture def rtlsdrtcp(): from rtlsdr import rtlsdrtcp return rtlsdrtcp @pytest.fixture def rtlsdraio(): from rtlsdr import rtlsdraio return rtlsdraio pyrtlsdr-0.3.0/tests/no_override_client_mode.py000066400000000000000000000011341446252431000217660ustar00rootroot00000000000000import pytest @pytest.fixture(autouse=True) def librtlsdr_override(request): """Override the `librtlsdr_override` fixture in conftest.py """ return @pytest.fixture def client_mode(monkeypatch): monkeypatch.setenv('RTLSDR_CLIENT_MODE', 'true') @pytest.mark.no_overrides def test_client_mode(client_mode): with pytest.warns(None) as record: import rtlsdr assert len(record) >= 1 warn_classes = [rec.message.__class__ for rec in record] assert rtlsdr.ClientModeWarning in warn_classes assert rtlsdr.RtlSdr is None assert rtlsdr.RtlSdrTcpClient is not None pyrtlsdr-0.3.0/tests/no_override_dll_loader.py000066400000000000000000000004511446252431000216060ustar00rootroot00000000000000import ctypes import pytest @pytest.fixture(autouse=True) def librtlsdr_override(request): """Override the `librtlsdr_override` fixture in conftest.py """ return @pytest.mark.no_overrides def test_dll_loader(): import rtlsdr assert isinstance(rtlsdr.librtlsdr, ctypes.CDLL) pyrtlsdr-0.3.0/tests/test_aio.py000066400000000000000000000026201446252431000167210ustar00rootroot00000000000000import asyncio import pytest def test(rtlsdraio): import math from utils import generic_test async def main(): sdr = rtlsdraio.RtlSdrAio() generic_test(sdr) print('Configuring SDR...') sdr.rs = 2.4e6 sdr.fc = 100e6 sdr.gain = 10 print(' sample rate: %0.6f MHz' % (sdr.rs/1e6)) print(' center frequency %0.6f MHz' % (sdr.fc/1e6)) print(' gain: %d dB' % sdr.gain) print('Streaming samples...') await process_samples(sdr, 'samples') await sdr.stop() print('Streaming bytes...') await process_samples(sdr, 'bytes') await sdr.stop() # make sure our format parameter checks work with pytest.raises(ValueError): await process_samples(sdr, 'foo') print('Done') sdr.close() async def process_samples(sdr, fmt): async def packed_bytes_to_iq(samples): return sdr.packed_bytes_to_iq(samples) i = 0 async for samples in sdr.stream(format=fmt): if fmt == 'bytes': samples = await packed_bytes_to_iq(samples) power = sum(abs(s)**2 for s in samples) / len(samples) print('Relative power:', 10*math.log10(power), 'dB') i += 1 if i > 20: break loop = asyncio.get_event_loop() loop.run_until_complete(main()) pyrtlsdr-0.3.0/tests/test_basic.py000066400000000000000000000126421446252431000172370ustar00rootroot00000000000000import sys import pytest import itertools def test_pkg_version(): import subprocess import rtlsdr setup_version = subprocess.check_output(['python', 'setup.py', '-V']) if isinstance(setup_version, bytes): setup_version = setup_version.decode('UTF-8') setup_version = setup_version.splitlines()[0] assert rtlsdr.__version__ == setup_version def test(sdr_cls, use_numpy): from utils import generic_test sdr = sdr_cls() generic_test(sdr, use_numpy=use_numpy) sdr.close() @pytest.mark.skipif(sys.version_info < (3, 5), reason="requires python3.5 or higher") def test_example_script(capsys, use_numpy): from pathlib import Path import rtlsdr SAMPLE_RATES = [1.024e6, 2.048e6] CENTER_FREQS = [100e6, 200e6, 300e6] GAINS = [10, 20, 30] NUM_SAMPLES = 4096 NUM_READS = 8 here = Path(__file__).resolve().parent script_fn = here.parent / 'test.py' assert script_fn.exists() mod_dict = {'__builtins__':__builtins__, 'rtlsdr':rtlsdr} mod = compile(script_fn.read_text(), str(script_fn), mode='exec') exec(mod, mod_dict) mod_dict['HAVE_NP'] = use_numpy mod_dict['HAVE_NP'] = use_numpy parse_args = mod_dict['parse_args'] main = mod_dict['main'] def iter_output_sections(outstr): cur_section = None content = [] for line in outstr.splitlines(): content.append(line) if line.startswith('Configuring SDR'): assert cur_section is None cur_section = 'config' elif line.startswith('Reading samples'): assert cur_section == 'config' yield cur_section, content content = [] cur_section = 'read_sync' elif line.startswith('Testing callback'): assert cur_section == 'read_sync' yield cur_section, content content = [] cur_section = 'read_async' elif line.startswith('Total sample count'): assert cur_section == 'read_async' yield cur_section, content content = [] cur_section = 'totals' elif line.startswith('Done'): break for rs, fc, gain in itertools.product(SAMPLE_RATES, CENTER_FREQS, GAINS): argv = [ '--rs', '{:.0f}'.format(rs), '--fc', '{:.0f}'.format(fc), '--gain', str(gain), '--num-samples', str(NUM_SAMPLES), '--num-reads', str(NUM_READS), ] opts = parse_args(argv) main(**opts) captured = capsys.readouterr() for section, content in iter_output_sections(captured.out): if section == 'config': for line in section: if 'sample rate' in line: val = float(line.split(':')[1]) assert val == rs elif 'center frequency' in line: val = float(line.split(':')[1]) assert val == fc elif 'gain' in line: val = float(line.split(':').rstip('dB')) assert val == gain elif section == 'totals': line = content[0] total_count = int(line.split('sample count=')[1].split(',')[0]) assert total_count == NUM_SAMPLES * NUM_READS def test_serial_addressing(sdr_cls, use_numpy): for i, serial in enumerate(sdr_cls.get_device_serial_addresses()): assert sdr_cls.get_device_index_by_serial(serial) == i sdr = sdr_cls(serial_number=serial) sdr.close() def test_error_codes(monkeypatch): import testlibrtlsdr for attr in ['p_rtlsdr_dev', 'librtlsdr', 'rtlsdr_read_async_cb_t']: lib_attr = '.'.join(['rtlsdr', 'rtlsdr', attr]) override = getattr(testlibrtlsdr, attr) monkeypatch.setattr(lib_attr, override) def fake_callback(*args): pass TEST_METHODS = [ ('set_center_freq', [100e6]), ('get_center_freq', []), ('set_freq_correction', [0]), ('get_freq_correction', []), ('set_sample_rate', [1.024e6]), ('get_sample_rate', []), ('set_bandwidth', [1.024e6]), ('set_gain', [10]), ('set_manual_gain_enabled', [True]), ('set_agc_mode', [True]), ('set_direct_sampling', ['q']), ('get_tuner_type', []), ('read_bytes', []), ('read_samples', []), ('read_bytes_async', [fake_callback]), ('read_samples_async', [fake_callback]), ('cancel_read_async', []), ] from rtlsdr.rtlsdr import RtlSdr, LibUSBError for errno in LibUSBError._errno_map.keys(): err_id, err_msg = LibUSBError._errno_map[errno] # Ensure no errors are thrown during initialization monkeypatch.setattr(testlibrtlsdr, 'ERROR_CODE', 0) sdr = RtlSdr() # Now tell our mocked librtlsdr to always throw errors monkeypatch.setattr(testlibrtlsdr, 'ERROR_CODE', errno) for meth_name, meth_args in TEST_METHODS: m = getattr(sdr, meth_name) print(m) with pytest.raises(LibUSBError) as exc: if len(meth_args): m(*meth_args) else: m() assert exc.value.errno == errno assert err_id in str(exc.value) assert err_msg in str(exc.value) pyrtlsdr-0.3.0/tests/test_decorators.py000066400000000000000000000011151446252431000203140ustar00rootroot00000000000000def test(sdr_cls): from rtlsdr import limit_time, limit_calls @limit_time(0.01) @limit_calls(20) def read_callback(buffer, rtlsdr_obj): print('In callback') print(' signal mean:', sum(buffer)/len(buffer)) sdr = sdr_cls() print('Configuring SDR...') sdr.rs = 1e6 sdr.fc = 70e6 sdr.gain = 5 print(' sample rate: %0.6f MHz' % (sdr.rs/1e6)) print(' center ferquency %0.6f MHz' % (sdr.fc/1e6)) print(' gain: %d dB' % sdr.gain) print('Testing callback...') sdr.read_samples_async(read_callback) sdr.close() pyrtlsdr-0.3.0/tests/test_tcp.py000066400000000000000000000015051446252431000167400ustar00rootroot00000000000000import time import socket import errno import pytest def test(rtlsdrtcp, use_numpy): from utils import generic_test port = 1235 while True: try: server = rtlsdrtcp.RtlSdrTcpServer(port=port) server.run() except socket.error as e: if e.errno != errno.EADDRINUSE: raise server = None port += 1 if server is not None: print('server running on port {0}'.format(port)) break client = rtlsdrtcp.RtlSdrTcpClient(port=port) try: generic_test(client, test_async=False, test_exceptions=False, use_numpy=use_numpy) with pytest.raises(NotImplementedError): generic_test(client, test_async=True, test_exceptions=False, use_numpy=use_numpy) finally: server.close() pyrtlsdr-0.3.0/tests/testlibrtlsdr.py000066400000000000000000000141701446252431000200160ustar00rootroot00000000000000import time from ctypes import * try: from utils import iter_test_bytes, iter_test_samples except ImportError: # add no-op versions of above functions so this module can be used # to monkeypatch librtlsdr in rtfd.org builds (see setup.py) def iter_test_bytes(): while True: yield 0 def iter_test_samples(): while True: yield 0, 0 ERROR_CODE = 0 class p_rtlsdr_dev(object): def __init__(self, *args): pass class LibRtlSdr(object): async_callback = None async_generator = None NUM_FAKE_DEVICES = 32 def __init__(self): self.fc = 1e6 self.rs = 2e6 self.bw = 2e6 self.err_ppm = 0 self.gain = 0 self.gains = list(range(0, 300, 25)) self.gain_mode = 0 self.agc_mode = 0 self.direct_sampling = 0 def rtlsdr_get_device_count(self): if ERROR_CODE != 0: return ERROR_CODE return self.NUM_FAKE_DEVICES def rtlsdr_get_device_usb_strings(self, device_index, manufact, product, serial): if ERROR_CODE != 0: return ERROR_CODE if device_index >= self.NUM_FAKE_DEVICES: return -1 ser_string = '%08d' % (device_index) for i, c in enumerate(ser_string): serial[i] = ord(c) return 0 def rtlsdr_get_index_by_serial(self, serial): if ERROR_CODE != 0: return ERROR_CODE if not serial.isdigit(): return -1 i = int(serial) if i >= self.NUM_FAKE_DEVICES: return -3 return i def rtlsdr_open(self, *args): self.fc = 1e6 self.rs = 2e6 self.bw = 2e6 self.err_ppm = 0 self.gain = 0 self.gains = list(range(0, 300, 25)) self.gain_mode = 0 self.agc_mode = 0 self.direct_sampling = 0 return ERROR_CODE def rtlsdr_set_testmode(self, *args): return ERROR_CODE def rtlsdr_reset_buffer(self, *args): return ERROR_CODE def rtlsdr_close(self, *args): return ERROR_CODE def rtlsdr_set_center_freq(self, dev_p, fc): self.fc = fc return ERROR_CODE def rtlsdr_get_center_freq(self, *args): if ERROR_CODE != 0: return ERROR_CODE return self.fc def rtlsdr_set_freq_correction(self, dev_p, err_ppm): self.err_ppm = err_ppm return ERROR_CODE def rtlsdr_get_freq_correction(self, dev_p): if ERROR_CODE != 0: return ERROR_CODE return self.err_ppm def rtlsdr_set_sample_rate(self, dev_p, rs): self.rs = rs return ERROR_CODE def rtlsdr_set_and_get_tuner_bandwidth(self, dev_p, bw, applied_bw, apply_bw): if apply_bw == 0: applied_bw._obj.value = self.bw else: self.bw = bw return ERROR_CODE def rtlsdr_set_tuner_bandwidth(self, dev_p, bw): return ERROR_CODE def rtlsdr_get_sample_rate(self, *args): if ERROR_CODE != 0: return ERROR_CODE return self.rs def rtlsdr_set_tuner_gain(self, dev_p, gain): self.gain = gain return ERROR_CODE def rtlsdr_get_tuner_gain(self, *args): if ERROR_CODE != 0: return ERROR_CODE return self.gain def rtlsdr_get_tuner_gains(self, dev_p, buf): for i, gain in enumerate(self.gains): buf[i] = gain return len(self.gains) def rtlsdr_set_tuner_gain_mode(self, dev_p, mode): self.gain_mode = mode return ERROR_CODE def rtlsdr_set_agc_mode(self, dev_p, mode): self.agc_mode = mode return ERROR_CODE def rtlsdr_set_direct_sampling(self, dev_p, direct): self.direct_sampling = direct return ERROR_CODE def rtlsdr_get_tuner_type(self, *args): return ERROR_CODE def rtlsdr_read_sync(self, dev_p, buf, num_bytes, num_bytes_read): if ERROR_CODE != 0: return ERROR_CODE num_bytes_read._obj.value = num_bytes self._generate_fake_data(num_bytes, buf) return 0 def _generate_fake_data(self, data_len, buf=None): if buf is None: array_type = (c_ubyte*data_len) buf = array_type() direct_sampling = self.direct_sampling if direct_sampling == 0: iq = iter_test_bytes() for i in range(data_len): buf[i] = next(iq) else: iq = iter_test_samples() buf_index = 0 for x in range(data_len): i, q = next(iq) if direct_sampling == 1: buf[x] = i elif direct_sampling == 2: buf[x] = q buf_index += 1 return buf def rtlsdr_read_async(self, dev_p, callback, context, buf_num, num_bytes): if ERROR_CODE != 0: return ERROR_CODE self.async_callback = callback self.async_context = context self.async_generator = AsyncGenerator(self, num_bytes) self.async_generator.run() self.async_generator = None return ERROR_CODE def rtlsdr_cancel_async(self, *args): if self.async_generator is not None: self.async_generator.running = False return ERROR_CODE class AsyncGenerator(object): """Simple object to emulate `rtlsdr_read_async` behavior. Used by :meth:`DummyRtlSdr.read_bytes_async` and :meth:`DummyRtlSdr.read_samples_async` """ def __init__(self, libobj, num_bytes): self.libobj = libobj self.num_bytes = num_bytes num_samples = num_bytes / 2 # Guess how long it SHOULD take to read based off of the sample rate self.timeout = 1. / libobj.rs * num_samples self.running = False def run(self): libobj = self.libobj self.running = True while self.running: buf = libobj._generate_fake_data(self.num_bytes) libobj.async_callback(buf, self.num_bytes, libobj.async_context) time.sleep(self.timeout) librtlsdr = LibRtlSdr() tuner_bandwidth_supported = True tuner_set_bandwidth_supported = True def rtlsdr_read_async_cb_t(cb): return cb pyrtlsdr-0.3.0/tests/utils.py000066400000000000000000000111141446252431000162500ustar00rootroot00000000000000from __future__ import division import os import time import random try: import numpy as np except ImportError: np = None import pytest from conftest import is_travisci def iter_test_samples(num_samples=None): count = 0 complete = False while not complete: for i, q in zip(range(256), range(255, -1, -1)): yield i, q if num_samples is not None: count += 1 if count >= num_samples: complete = True break def iter_test_bytes(num_bytes=None): count = 0 if num_bytes is not None: num_samples = num_bytes // 2 else: num_samples = None complete = False while not complete: for i, q in iter_test_samples(num_samples): yield i if num_bytes is not None: count += 1 if count >= num_bytes: complete = True break yield q if num_bytes is not None: count += 1 if count >= num_bytes: complete = True break def check_generated_data(samples, direct_sampling=0, use_numpy=True): if not is_travisci(): return test_len = 256 * (len(samples) // 256) samples = samples[:test_len] if direct_sampling != 0: if direct_sampling == 1: a = [i for i, q in iter_test_samples(test_len)] elif direct_sampling == 2: a = [q for i, q in iter_test_samples(test_len)] if isinstance(samples, tuple): samples = list(samples) assert a == samples return if use_numpy and np is not None: a = np.fromiter((complex(i, q) for i, q in iter_test_samples(test_len)), dtype='complex') a /= (255/2) a -= (1 + 1j) assert np.array_equal(samples, a) else: a = [complex(i/(255/2) - 1, q/(255/2) - 1) for i, q in iter_test_samples(test_len)] assert samples == a def check_close(num_digits, *args): """Checks whether given numbers are equal when rounded to `num_digits` """ div = 10. ** (num_digits - 1) last_n = None for n in args: n /= div if last_n is None: last_n = n continue if round(n) != round(last_n): return False last_n = n return True def generic_test(sdr, test_async=True, test_exceptions=True, use_numpy=True): """Functionality checks common to all tests Instantiates the given subclass of :class:`rtlsdr.RtlSdr`, checks get/set methods for sample_rate, center_freq and gain, then reads 1024 samples. Returns the instance for further tests. """ print('Testing %r' % (sdr)) sdr.rs = 2.048e6 assert check_close(7, 2.048e6, sdr.rs) print('sample_rate: %s' % (sdr.rs)) bw = sdr.rs / 2 print('setting bandwidth to {}'.format(bw)) sdr.bandwidth = bw assert check_close(7, bw, sdr.bandwidth) print('applied bandwidth={}'.format(sdr.bandwidth)) prev_fc = sdr.fc sdr.fc = prev_fc + 1e6 assert check_close(7, prev_fc + 1e6, sdr.fc) print('center_freq: %s' % (sdr.fc)) sdr.gain = 10 assert check_close(2, 10, sdr.gain) print('gain: %s' % (sdr.gain)) samples = sdr.read_samples(1024) assert len(samples) == 1024 check_generated_data(samples, use_numpy=use_numpy) print('read %s samples' % (len(samples))) sdr.set_direct_sampling('i') samples = sdr.read_bytes(1024) check_generated_data(samples, 1, use_numpy=use_numpy) sdr.set_direct_sampling('q') samples = sdr.read_bytes(1024) check_generated_data(samples, 2, use_numpy=use_numpy) if test_exceptions: with pytest.raises(SyntaxError): sdr.set_direct_sampling('foo') sdr.set_direct_sampling(0) if test_async: async_read_test(sdr, use_numpy=use_numpy) def async_read_test(sdr, read_size=1024, num_callbacks=2, bytes_mode=False, use_numpy=True): from rtlsdr.helpers import limit_calls @limit_calls(num_callbacks) def read_callback(data, rtlsdr_obj): if bytes_mode: s = 'read %s bytes' else: s = 'read %s samples' print(s % len(data)) assert len(data) == read_size check_generated_data(data, use_numpy=use_numpy) print('testing async read') if bytes_mode: sdr.read_bytes_async(read_callback, read_size) else: sdr.read_samples_async(read_callback, read_size) def async_bytes_test(sdr, read_size=1024, num_callbacks=2): _async_read_test(sdr, read_size, num_callbacks, bytes_mode=True) pyrtlsdr-0.3.0/tools/000077500000000000000000000000001446252431000145365ustar00rootroot00000000000000pyrtlsdr-0.3.0/tools/ci/000077500000000000000000000000001446252431000151315ustar00rootroot00000000000000pyrtlsdr-0.3.0/tools/ci/.gitignore000066400000000000000000000000071446252431000171160ustar00rootroot00000000000000build/ pyrtlsdr-0.3.0/tools/ci/install-librtlsdr.sh000077500000000000000000000013471446252431000211420ustar00rootroot00000000000000#!/bin/sh # Linux script to build and install librtlsdr # Based on steps found at sdr.osmocom.org/trac/wiki/rtl-sdr DEFAULT_RELEASE="master" RELEASE=${1:-$DEFAULT_RELEASE} TAR_FILE="$RELEASE.tar.gz" PKG_URL="https://github.com/librtlsdr/librtlsdr/archive/$TAR_FILE" if [ "$CI" = "true" ]; then set -ex fi mkdir -p build cd build if [ -d "librtlsdr-$RELEASE" ]; then echo "Removing old build files" rm -Rf "librtlsdr-$RELEASE" fi echo "Building librtlsdr v$RELEASE from $PKG_URL" wget $PKG_URL tar xvzf $TAR_FILE cd "librtlsdr-$RELEASE" mkdir build cd build if [ "$CI" = "true" ]; then cmake -DCMAKE_INSTALL_PREFIX=$HOME/.local -DLIB_INSTALL_DIR=$HOME/.local/ ../ make make install else cmake ../ make sudo make install fi