rtlsdr.rtlsdrtcp

This module allows client/server communication.

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.

Examples

server = RtlSdrTcpServer(hostname='192.168.1.100', port=12345)
server.run_forever()
# Will listen for clients until Ctrl-C is pressed

# 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 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

rtlsdr.rtlsdrtcp.server

class rtlsdr.rtlsdrtcp.server.RequestHandler(request, client_address, server)

Bases: BaseRequestHandler

close()

finish()

handle(rx_message=None)

handle_method_call(rx_message)

handle_prop_get(rx_message)

handle_prop_set(rx_message)

setup()

class rtlsdr.rtlsdrtcp.server.RtlSdrTcpServer(device_index=0, test_mode_enabled=False, serial_number=None, hostname='127.0.0.1', port=None, dithering_enabled=True)

Bases: RtlSdrAio, RtlSdrTcpBase

Server that connects to a physical dongle to allow client connections.

close()

Stops the server (if it’s running) and closes the connection to the dongle.

open(device_index=0, test_mode_enabled=False, serial_number=None, dithering_enabled=True)

Connect to the device through the underlying wrapper library

Initializes communication with the device and retrieves information from it with a call to init_device_values().

Parameters:

• device_index (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 (bool, optional) – If True, enables a special test mode, which will return the value of an internal RTL2832 8-bit counter with calls to read_bytes().

• serial_number (str, optional) – If not None, the device will be searched for by the given serial_number by get_device_index_by_serial() and the device_index returned will be used automatically.

• dithering_enabled (bool, optional) – If False, disables PLL dithering to prevent it destroying phase coherence in CLK-synchronized dongles.

Notes

The arguments used here are passed directly from object initialization.

Raises:

IOError – If communication with the device could not be established.

read_bytes(num_bytes=1024)

Return a packed string of bytes read along with the struct_fmt.

read_samples(num_samples=1024)

This overrides the base implementation so that the raw data is sent. It will be unpacked to I/Q samples on the client side.

run()

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.

run_forever()

Runs the server and begins a mainloop. The loop will exit with Ctrl-C.

class rtlsdr.rtlsdrtcp.server.Server(rtl_sdr)

Bases: TCPServer

server_close()

Called to clean-up the server.

May be overridden.

REQUEST_RECV_SIZE = 1024

class rtlsdr.rtlsdrtcp.server.ServerThread(rtl_sdr)

Bases: Thread

run()

Method representing the thread’s activity.

You may override this method in a subclass. The standard run() method invokes the callable object passed to the object’s constructor as the target argument, if any, with sequential and keyword arguments taken from the args and kwargs arguments, respectively.

stop()

rtlsdr.rtlsdrtcp.server.run_server()

Convenience function to run the server from the command line with options for hostname, port and device index.

rtlsdr.rtlsdrtcp.client

class rtlsdr.rtlsdrtcp.client.RtlSdrTcpClient(device_index=0, test_mode_enabled=False, hostname='127.0.0.1', port=None)

Bases: 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.

close()

get_bandwidth()

get_center_freq()

get_freq_correction()

get_gain()

get_gains()

get_sample_rate()

get_tuner_type()

open(*args)

read_bytes(num_bytes=1024)

read_bytes_async(*args)

read_samples(num_samples=1024)

read_samples_async(*args)

set_bandwidth(value)

set_bias_tee(value)

set_center_freq(value)

set_direct_sampling(value)

set_freq_correction(value)

set_gain(value)

set_sample_rate(value)

property bandwidth

property center_freq

property fc

property freq_correction

property gain

property rs

property sample_rate

rtlsdr.rtlsdrtcp.base

exception rtlsdr.rtlsdrtcp.base.CommunicationError(msg, source_exc=None)

Bases: Exception

class rtlsdr.rtlsdrtcp.base.AckMessage(**kwargs)

Bases: MessageBase

Simple message type meant for ACKnolegemnt of message receipt

get_header(**kwargs)

Builds the header data for the message

The timestamp is added to the header if not already present.

Return type:

dict

class rtlsdr.rtlsdrtcp.base.ClientMessage(**kwargs)

Bases: MessageBase

get_header(**kwargs)

Builds the header data for the message

The timestamp is added to the header if not already present.

Return type:

dict

get_response_class()

send_message(sock)

Serializes and sends the message

Parameters:

sock – The socket object to write to

class rtlsdr.rtlsdrtcp.base.MessageBase(**kwargs)

Bases: object

Base class for messages sent between clients and servers.

Handles serialization/deserialization and communication with socket type objects.

timestamp

Timestamp given from time.time()

Type:

float

header

A dict containing message type and payload information

Type:

dict

data

The payload containing either the request or response data

classmethod from_remote(sock)

Reads data from the socket and parses an instance of MessageBase

Parameters:

sock – The socket object to read from

get_ack_response(sock)

get_data(**kwargs)

get_header(**kwargs)

Builds the header data for the message

The timestamp is added to the header if not already present.

Return type:

dict

get_response(sock)

Waits for a specific response message

The message class returned from get_response_class() is used to parse the message (called from from_remote())

Parameters:

sock – The socket object to read from

send_message(sock)

Serializes and sends the message

Parameters:

sock – The socket object to write to

class rtlsdr.rtlsdrtcp.base.RtlSdrTcpBase(device_index=0, test_mode_enabled=False, hostname='127.0.0.1', port=None)

Bases: object

Base class for all rtlsdrtcp functionality

Parameters:

• device_index (int, optional)

• test_mode_enabled (bool, optional)

• hostname (str, optional)

• port (int, optional)

packed_bytes_to_iq(bytes)

A direct copy of rtlsdr.BaseRtlSdr.packed_bytes_to_iq()

DEFAULT_PORT = 1235

class rtlsdr.rtlsdrtcp.base.ServerMessage(**kwargs)

Bases: MessageBase

classmethod from_remote(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)

get_data(**kwargs)

get_header(**kwargs)

Builds the header data for the message

The timestamp is added to the header if not already present.

Return type:

dict

get_response_class()

send_message(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.