#include <uhd/rfnoc/replay_block_control.hpp>

Inheritance diagram for uhd::rfnoc::replay_block_control:

Public Member Functions
virtual void	record (const uint64_t offset, const uint64_t size, const size_t port=0)=0

virtual void	record_restart (const size_t port=0)=0

virtual void	play (const uint64_t offset, const uint64_t size, const size_t port=0, const uhd::time_spec_t time_spec=uhd::time_spec_t(0.0), const bool repeat=false)=0

virtual void	stop (const size_t port=0)=0

virtual uint64_t	get_mem_size () const =0

virtual uint64_t	get_word_size () const =0

virtual uint64_t	get_record_offset (const size_t port=0) const =0

virtual uint64_t	get_record_size (const size_t port=0) const =0

virtual uint64_t	get_record_fullness (const size_t port=0)=0

virtual uint64_t	get_record_position (const size_t port=0)=0

virtual io_type_t	get_record_type (const size_t port=0) const =0

virtual size_t	get_record_item_size (const size_t port=0) const =0

virtual bool	get_record_async_metadata (uhd::rx_metadata_t &metadata, const double timeout=0.1)=0

virtual uint64_t	get_play_offset (const size_t port=0) const =0

virtual uint64_t	get_play_size (const size_t port=0) const =0

virtual uint64_t	get_play_position (const size_t port=0)=0

virtual uint32_t	get_max_items_per_packet (const size_t port=0) const =0

virtual uint32_t	get_max_packet_size (const size_t port=0) const =0

virtual io_type_t	get_play_type (const size_t port=0) const =0

virtual size_t	get_play_item_size (const size_t port=0) const =0

virtual bool	get_play_async_metadata (uhd::async_metadata_t &metadata, const double timeout=0.1)=0

virtual void	set_record_type (const io_type_t type, const size_t port=0)=0

virtual void	config_play (const uint64_t offset, const uint64_t size, const size_t port=0)=0

virtual void	set_play_type (const io_type_t type, const size_t port=0)=0

virtual void	set_max_items_per_packet (const uint32_t ipp, const size_t port=0)=0

virtual void	set_max_packet_size (const uint32_t size, const size_t port=0)=0

virtual void	issue_stream_cmd (const uhd::stream_cmd_t &stream_cmd, const size_t port=0)=0

Public Member Functions inherited from uhd::rfnoc::noc_block_base
	~noc_block_base () override

std::string	get_unique_id () const override
	Unique ID for an RFNoC block is its block ID. More...

size_t	get_num_input_ports () const override
	Number of input ports. Note: This gets passed into this block from the. More...

size_t	get_num_output_ports () const override
	Number of output ports. Note: This gets passed outto this block from the. More...

noc_id_t	get_noc_id () const

const block_id_t &	get_block_id () const

double	get_tick_rate () const

size_t	get_mtu (const res_source_info &edge)

size_t	get_chdr_hdr_len (const bool account_for_ts=true) const

size_t	get_max_payload_size (const res_source_info &edge, const bool account_for_ts=true)

uhd::device_addr_t	get_block_args () const

uhd::property_tree::sptr &	get_tree () const
	Return a reference to this block's subtree. More...

uhd::property_tree::sptr &	get_tree ()
	Return a reference to this block's subtree (non-const version) More...

std::shared_ptr< mb_controller >	get_mb_controller ()

Public Member Functions inherited from uhd::rfnoc::node_t
	node_t ()

virtual	~node_t ()

virtual std::string	get_unique_id () const
	Return a unique identifier string for this node. In every RFNoC graph,. More...

virtual size_t	get_num_input_ports () const =0

virtual size_t	get_num_output_ports () const =0

std::vector< std::string >	get_property_ids () const

template<typename prop_data_t >
void	set_property (const std::string &id, const prop_data_t &val, const size_t instance=0)

void	set_properties (const uhd::device_addr_t &props, const size_t instance=0)

template<typename prop_data_t >
const prop_data_t &	get_property (const std::string &id, const size_t instance=0)

virtual void	set_command_time (uhd::time_spec_t time, const size_t instance)

virtual uhd::time_spec_t	get_command_time (const size_t instance) const

virtual void	clear_command_time (const size_t instance)

Public Member Functions inherited from uhd::rfnoc::register_iface_holder
	register_iface_holder (register_iface::sptr reg)

virtual	~register_iface_holder ()=default

register_iface &	regs ()

Static Public Attributes
static const uint16_t	MINOR_COMPAT

static const uint16_t	MAJOR_COMPAT

static const uint32_t	REPLAY_ADDR_W

static const uint32_t	REPLAY_BLOCK_OFFSET

static const uint32_t	REG_COMPAT_ADDR

static const uint32_t	REG_MEM_SIZE_ADDR

static const uint32_t	REG_REC_RESTART_ADDR

static const uint32_t	REG_REC_BASE_ADDR_LO_ADDR

static const uint32_t	REG_REC_BASE_ADDR_HI_ADDR

static const uint32_t	REG_REC_BUFFER_SIZE_LO_ADDR

static const uint32_t	REG_REC_BUFFER_SIZE_HI_ADDR

static const uint32_t	REG_REC_FULLNESS_LO_ADDR

static const uint32_t	REG_REC_FULLNESS_HI_ADDR

static const uint32_t	REG_PLAY_BASE_ADDR_LO_ADDR

static const uint32_t	REG_PLAY_BASE_ADDR_HI_ADDR

static const uint32_t	REG_PLAY_BUFFER_SIZE_LO_ADDR

static const uint32_t	REG_PLAY_BUFFER_SIZE_HI_ADDR

static const uint32_t	REG_PLAY_CMD_NUM_WORDS_LO_ADDR

static const uint32_t	REG_PLAY_CMD_NUM_WORDS_HI_ADDR

static const uint32_t	REG_PLAY_CMD_TIME_LO_ADDR

static const uint32_t	REG_PLAY_CMD_TIME_HI_ADDR

static const uint32_t	REG_PLAY_CMD_ADDR

static const uint32_t	REG_PLAY_WORDS_PER_PKT_ADDR

static const uint32_t	REG_PLAY_ITEM_SIZE_ADDR

static const uint32_t	REG_REC_POS_LO_ADDR

static const uint32_t	REG_REC_POS_HI_ADDR

static const uint32_t	REG_PLAY_POS_LO_ADDR

static const uint32_t	REG_PLAY_POS_HI_ADDR

static const uint32_t	REG_PLAY_CMD_FIFO_SPACE_ADDR

static const uint32_t	PLAY_CMD_STOP

static const uint32_t	PLAY_CMD_FINITE

static const uint32_t	PLAY_CMD_CONTINUOUS

Static Public Attributes inherited from uhd::rfnoc::node_t
static const size_t	ANY_PORT = size_t(~0)

Additional Inherited Members
Public Types inherited from uhd::rfnoc::noc_block_base
using	sptr = std::shared_ptr< noc_block_base >

using	make_args_ptr = std::unique_ptr< make_args_t >
	Opaque pointer to the constructor arguments. More...

Public Types inherited from uhd::rfnoc::node_t
enum class	forwarding_policy_t { ONE_TO_ONE , ONE_TO_FAN , ONE_TO_ALL_IN , ONE_TO_ALL_OUT , ONE_TO_ALL , DROP , USE_MAP }
	Types of property/action forwarding for those not defined by the block itself. More...

using	resolver_fn_t = std::function< void(void)>

using	resolve_callback_t = std::function< void(void)>

using	action_handler_t = std::function< void(const res_source_info &, action_info::sptr)>

using	forwarding_map_t = std::unordered_map< res_source_info, std::vector< res_source_info > >

Protected Types inherited from uhd::rfnoc::node_t
using	prop_ptrs_t = std::unordered_set< property_base_t * >

Protected Member Functions inherited from uhd::rfnoc::noc_block_base
	noc_block_base (make_args_ptr make_args)

void	set_num_input_ports (const size_t num_ports)
	Update number of input ports. More...

void	set_num_output_ports (const size_t num_ports)
	Update number of output ports. More...

void	set_tick_rate (const double tick_rate)

void	set_mtu_forwarding_policy (const forwarding_policy_t policy)

void	set_mtu (const res_source_info &edge, const size_t new_mtu)

property_base_t *	get_mtu_prop_ref (const res_source_info &edge)

virtual void	deinit ()

Protected Member Functions inherited from uhd::rfnoc::node_t
void	register_property (property_base_t *prop, resolve_callback_t &&clean_callback=nullptr)

void	add_property_resolver (prop_ptrs_t &&inputs, prop_ptrs_t &&outputs, resolver_fn_t &&resolver_fn)

void	set_prop_forwarding_policy (forwarding_policy_t policy, const std::string &prop_id="")

void	set_prop_forwarding_map (const forwarding_map_t &map)

template<typename prop_data_t >
void	set_property (const std::string &id, const prop_data_t &val, const res_source_info &src_info)

template<typename prop_data_t >
const prop_data_t &	get_property (const std::string &id, const res_source_info &src_info)

void	register_action_handler (const std::string &id, action_handler_t &&handler)

void	set_action_forwarding_policy (forwarding_policy_t policy, const std::string &action_key="")

void	set_action_forwarding_map (const forwarding_map_t &map)

void	post_action (const res_source_info &edge_info, action_info::sptr action)

virtual bool	check_topology (const std::vector< size_t > &connected_inputs, const std::vector< size_t > &connected_outputs)

virtual void	shutdown ()

Protected Member Functions inherited from uhd::rfnoc::register_iface_holder
void	update_reg_iface (register_iface::sptr new_iface=nullptr)

Static Protected Attributes inherited from uhd::rfnoc::node_t
static dirtifier_t	ALWAYS_DIRTY
	A dirtifyer object, useful for properties that always need updating. More...

Detailed Description

Replay Block Control CLass

The Replay block records data to memory and plays back data from memory.

It is the responsibility of the user to manage the memory. Care must be taken to avoid unintentional overlaps in the memory across blocks and ports. Each port of the Replay block has access to the full memory space. This allows recording data on any input port of any Replay block and playback on any output port of any Replay block. The section of memory used by a record or play operation is controlled by setting the offset and size.

For both record and playback, the offset and the size must be aligned to the memory's word size. For playback, the size must also be aligned to the size of an item. An item is a single unit of data as defined by the data type of a port. For record, the data type is automatically determined by the connection to the upstream block by using the "type" edge property for the corresponding input port. For playback, this is automatically determined by the connection to the downstream block by using the "type" edge property for the corresponding output port. These can be explicitly set by the user, if necessary. It is the user's responsibility to manage the types of the individual record and the playback ports. Methods to get the word size and item sizes are provided to help calculate proper alignment.

One key configuration of playback is the packet size. Larger packet sizes provide for better throughput while smaller packet sizes provide for lower latency. By default, the "mtu" edge property of the output port is used to define the maximum packet size to achieve the best throughput to the downstream block without exceeding the supported packet size. The maximum packet size can be explicitly set in terms of bytes or number of items to allow users to tune the performance to suit their application.

Block Properties

User Properties:

Key	Description
record_offset	The base address for recordings (data will be written here). Will be set by record().
record_size	Size of the record buffer. Will be set by record().
play_offset	Base address for playback (streaming will start from here). Set by play() or config_play().
play_size	Size of the playback buffer. Set by play() or config_play().
packet_size	Size of outgoing packets (in bytes). Gets set by set_max_items_per_packet().

Edge properties:

Key	Description
type	Data type. On the input, it set by the upstream block (see get_record_type()). For output, it should be provided by set_play_type().

Recording Data

Before streaming data to the replay block, it must be configured to record by calling record(), which will also configure the size of the record buffer for the indicated input port. After calling this method, the block will accept incoming data until its record buffer is full (use the get_record_fullness() method to query the fullness). Unlike the radio, the replay block does not care about end-of-burst flags, and will not report underruns if subsequent packets are not streamed to this block back-to-back.

Once the record buffer is full, the block will no longer accept incoming data and will back-pressure. If, for example, the radio block is connected to the replay block, the radio could overrun in this scenario. By calling record() again, the write-pointer of the block is reset, and it will accept new data. To reset the write-pointer and buffer size to the same values as before, it is sufficient to call record_restart().

Playing back Data

To playback data from a given port, there are two options with basically the same functionality: Either call config_play() to configure the playback region on memory, and then call issue_stream_cmd() to start streaming.

A shorthand version of this is to call play(), which is equivalent to calling config_play() and issue_stream_cmd() together.

In either case, the replay block will start streaming the requested number of samples, or until it is stopped. If a specific number of samples is requested, then it will tag the last outgoing packet with an end-of-burst flag. If more samples were requested than stored in the playback buffer, it will wrap around.

To stop a continuous playback, either call stop(), or issue a stream command with uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS.

Action Handling

If this block receives TX or RX actions (uhd::rfnoc::tx_event_action_info o uhd::rfnoc::rx_event_action_info), it will store them in a circular buffer. The API calls get_record_async_metadata() and get_play_async_metadata() can be used to read them back out asynchronously. To avoid the block controller continously expanding in memory, the total number of messages that will be stored is limited. If this block receives more event info objects than it can store before get_record_async_metadata() or get_play_async_metadata() is called, the oldest message will be dropped.

Member Function Documentation

◆ config_play()

virtual void uhd::rfnoc::replay_block_control::config_play	(	const uint64_t	offset,
		const uint64_t	size,
		const size_t	port = `0`
	)

pure virtual

Configure the offsets and size of the playback buffer region

Specifies a buffer area in the memory for playback. In order to begin playback on this region, a stream command must be issued.

Parameters

offset	Memory offset of the data to be played. This value must be aligned to the size of the word in memory. Use get_word_size() to get the memory word size.
size	Size of data to play back. This value must be aligned to the size of the memory word and item size. Use get_word_size() to get the memory word size and get_output_item_size() to get the item size.
port	Which output port of the replay block to use

Exceptions

uhd::value_error if offset+size exceeds the available memory.

◆ get_max_items_per_packet()

virtual uint32_t uhd::rfnoc::replay_block_control::get_max_items_per_packet ( const size_t port = 0 ) const

pure virtual

Get the maximum number of items in a packet

Parameters

port	Which output port of the replay block to use

Returns: the maximum number of items in a packet

◆ get_max_packet_size()

virtual uint32_t uhd::rfnoc::replay_block_control::get_max_packet_size ( const size_t port = 0 ) const

pure virtual

Get the maximum size of a packet

Returns the maximum size of a packet, inclusive of headers and payload.

Parameters

port	Which output port of the replay block to use

Returns: the maximum size of a packet

◆ get_mem_size()

virtual uint64_t uhd::rfnoc::replay_block_control::get_mem_size ( ) const

pure virtual

Get the size of the memory

Returns the size of the shared memory space. Any record or playback buffers must be configured in this memory space.

Returns: the size of the shared Replay memory

◆ get_play_async_metadata()

virtual bool uhd::rfnoc::replay_block_control::get_play_async_metadata	(	uhd::async_metadata_t &	metadata,
		const double	timeout = `0.1`
	)

pure virtual

Return TX- (output-/playback-) related metadata.

The typical use case for this is when connecting Replay -> Radio for playback, the radio may produce information like 'underrun occurred'. When transmitting from a host using a uhd::tx_streamer, this information is returned as part of the uhd::tx_streamer::recv_async_msg() call, but when the data is streamed into the replay block, these metadata are stored inside the replay block until queried by this method.

Parameters

metadata	A metadata object to store the information in.
timeout	A timeout (in seconds) to wait before returning.

Returns: true if a message was available, and was popped into metadata.

◆ get_play_item_size()

virtual size_t uhd::rfnoc::replay_block_control::get_play_item_size ( const size_t port = 0 ) const

pure virtual

Get the current play item size

Parameters

port	Which output port of the replay block to use

Returns: the size of an item in the current play buffer

◆ get_play_offset()

virtual uint64_t uhd::rfnoc::replay_block_control::get_play_offset ( const size_t port = 0 ) const

pure virtual

Get the offset of the current playback buffer

Parameters

port	Which output port of the replay block to use

Returns: the offset of the current playback buffer

◆ get_play_position()

virtual uint64_t uhd::rfnoc::replay_block_control::get_play_position ( const size_t port = 0 )

pure virtual

Get the current playback position

Parameters

port	Which output port of the replay block to use

Returns: the byte address of the current playback position

◆ get_play_size()

virtual uint64_t uhd::rfnoc::replay_block_control::get_play_size ( const size_t port = 0 ) const

pure virtual

Get the current size of the playback space

Parameters

port	Which output port of the replay block to use

Returns: size of the playback buffer

◆ get_play_type()

virtual io_type_t uhd::rfnoc::replay_block_control::get_play_type ( const size_t port = 0 ) const

pure virtual

Get the current play data type

Parameters

port	Which output port of the replay block to use

Returns: the current play data type

◆ get_record_async_metadata()

virtual bool uhd::rfnoc::replay_block_control::get_record_async_metadata	(	uhd::rx_metadata_t &	metadata,
		const double	timeout = `0.1`
	)

pure virtual

Return RX- (input-/record-) related metadata.

The typical use case for this is when connecting Radio -> Replay for recording, the radio may produce information like 'overrun occurred'. When receiving to a host using a uhd::rx_streamer, this information is returned as part of the uhd::rx_streamer::recv() call, but when the data is streamed into the replay block, these metadata are stored inside the replay block until queried by this method.

Parameters

metadata	A metadata object to store the information in.
timeout	A timeout (in seconds) to wait before returning.

Returns: true if a message was available, and was popped into metadata.

◆ get_record_fullness()

virtual uint64_t uhd::rfnoc::replay_block_control::get_record_fullness ( const size_t port = 0 )

pure virtual

Get the fullness of the current record buffer

Returns the number of bytes that have been recorded in the record buffer. A record restart will reset this number back to 0.

Parameters

port	Which input port of the replay block to use

Returns: fullness of the record buffer

◆ get_record_item_size()

virtual size_t uhd::rfnoc::replay_block_control::get_record_item_size ( const size_t port = 0 ) const

pure virtual

Get the current record item size

Parameters

port	Which input port of the replay block to use

Returns: the size of an item in the current record buffer

◆ get_record_offset()

virtual uint64_t uhd::rfnoc::replay_block_control::get_record_offset ( const size_t port = 0 ) const

pure virtual

Get the starting offset of the current record buffer

Parameters

port	Which input port of the replay block to use

Returns: starting offset of the record buffer

◆ get_record_position()

virtual uint64_t uhd::rfnoc::replay_block_control::get_record_position ( const size_t port = 0 )

pure virtual

Get the current record position

Parameters

port	Which output port of the replay block to use

Returns: the byte address of the current record position

◆ get_record_size()

virtual uint64_t uhd::rfnoc::replay_block_control::get_record_size ( const size_t port = 0 ) const

pure virtual

Get the current size of the record space

Parameters

port	Which input port of the replay block to use

Returns: size of the record buffer

◆ get_record_type()

virtual io_type_t uhd::rfnoc::replay_block_control::get_record_type ( const size_t port = 0 ) const

pure virtual

Get the current record data type

Parameters

port	Which input port of the replay block to use

Returns: the current record data type

◆ get_word_size()

virtual uint64_t uhd::rfnoc::replay_block_control::get_word_size ( ) const

pure virtual

Get the size of a memory word

Returns: the size of a memory word

◆ issue_stream_cmd()

virtual void uhd::rfnoc::replay_block_control::issue_stream_cmd	(	const uhd::stream_cmd_t &	stream_cmd,
		const size_t	port = `0`
	)

pure virtual

Issue a stream command to the replay block

Issue stream commands to start or stop playback from the configured playback buffer. Supports STREAM_MODE_START_CONTINUOUS to start continuous repeating playback, STREAM_MODE_NUM_SAMPS_AND_DONE to play the given number of samples once, and STREAM_MODE_STOP_CONTINUOUS to stop all playback immediately. If a time_spec is supplied, it is placed in the header of the first packet produced for that command. Commands are queued and executed in order. A STREAM_MODE_STOP_CONTINUOUS command will halt all playback and purge all commands in the queue for a given output port.

Parameters

stream_cmd	The command to execute
port	Which output port of the replay block to use

Exceptions

uhd::op_failed Too many commands are queued.

◆ play()

virtual void uhd::rfnoc::replay_block_control::play	(	const uint64_t	offset,
		const uint64_t	size,
		const size_t	port = `0`,
		const uhd::time_spec_t	time_spec = `uhd::time_spec_t(0.0)`,
		const bool	repeat = `false`
	)

pure virtual

Play back data.

The offset and size define what data is played back on an output port. It will stream out size bytes of data, starting at memory offset offset.

The data can be played once or repeated continuously until a stop command is issued. If a time_spec is supplied, it will be placed in the header of the first packet. Typically, this is used to tell a downstream Radio block when to start transmitting the data.

If the data type on the output port is not defined, this function will throw an error.

This is equivalent to calling config_play() with the same arguments for offset, size, and port, and then calling issue_stream_cmd() with the same time spec, and either continuous streaming (if repeat is true) or STREAM_MODE_START_NUM_SAMPS_AND_DONE if it is not.

Parameters

offset	Memory offset of the data to be played. This value must be aligned to the size of the word in memory. Use get_word_size() to get the memory word size.
size	Size of data to play back. This value must be aligned to the size of the memory word and item size. Use get_word_size() to get the memory word size and get_output_item_size() to get the item size. This value will be used for the num_samps component of the underlying stream command.
port	Which output port of the replay block to use
time_spec	Set the time for the first item. Any non-zero value is used to set the time in the header of the first packet. Most commonly, this is used to set the start time of a transmission. Note that this block will not wait for a time to occur, rather, it will tag the first outgoing packet with this time stamp.
repeat	Determines whether the data should be played repeatedly or just once. If set to true, stop() must be called to stop the play back.

Exceptions

uhd::value_error	if offset+size exceeds the available memory.
uhd::op_failed	Too many play commands are queued.

◆ record()

virtual void uhd::rfnoc::replay_block_control::record	(	const uint64_t	offset,
		const uint64_t	size,
		const size_t	port = `0`
	)

pure virtual

Record

Begin recording. The offset sets the starting location in memory and the size limits the length of the recording. The flow of data is controlled by upstream RFNoC blocks.

Parameters

offset	Memory offset where to start recording the data. This value must be aligned to the memory word size. Use get_word_size() to get the size of the memory word.
size	Size limit, in bytes. This value must be aligned to the memory word size and the item size. Use get_word_size() to get the size of the memory word and get_item_size() to get the item size. A value of 0 means to use all available space.
port	Which input port of the replay block to use

Exceptions

uhd::value_error if offset+size exceeds the available memory.

◆ record_restart()

virtual void uhd::rfnoc::replay_block_control::record_restart ( const size_t port = 0 )

pure virtual

Restarts recording from the record offset

This is a shortcut for calling record() again with the same arguments.

Parameters

port	Which input port of the replay block to use

◆ set_max_items_per_packet()

virtual void uhd::rfnoc::replay_block_control::set_max_items_per_packet	(	const uint32_t	ipp,
		const size_t	port = `0`
	)

pure virtual

Set the maximum number of items in a packet

Sets the maximum number of items that can be in a packet's payload. An actual packet may be smaller in order to coerce to mtu values, or to align with memory word size.

Parameters

ipp	Number of items per packet
port	Which output port of the replay block to use

◆ set_max_packet_size()

virtual void uhd::rfnoc::replay_block_control::set_max_packet_size	(	const uint32_t	size,
		const size_t	port = `0`
	)

pure virtual

Set the maximum size of a packet

Sets the maximum packet size, inclusive of headers and payload. Cannot exceed the MTU for this block.

Parameters

size	The size of the packet
port	Which output port of the replay block to use

◆ set_play_type()

virtual void uhd::rfnoc::replay_block_control::set_play_type	(	const io_type_t	type,
		const size_t	port = `0`
	)

pure virtual

Explicitly set the current play data type

Sets the data type for items in the current play buffer for the given output port.

Parameters

type	The data type
port	Which output port of the replay block to use

◆ set_record_type()

virtual void uhd::rfnoc::replay_block_control::set_record_type	(	const io_type_t	type,
		const size_t	port = `0`
	)

pure virtual

Explicitly set the current record data type

Sets the data type for items in the current record buffer for the given input port.

Parameters

type	The data type
port	Which input port of the replay block to use

◆ stop()

virtual void uhd::rfnoc::replay_block_control::stop ( const size_t port = 0 )

pure virtual

Stops playback

Halts any currently executing play commands and cancels any other play commands that are waiting to be executed for that output port.

Parameters

port	Which output port of the replay block to use

Member Data Documentation

◆ MAJOR_COMPAT

const uint16_t uhd::rfnoc::replay_block_control::MAJOR_COMPAT

static

◆ MINOR_COMPAT

const uint16_t uhd::rfnoc::replay_block_control::MINOR_COMPAT

static

◆ PLAY_CMD_CONTINUOUS

const uint32_t uhd::rfnoc::replay_block_control::PLAY_CMD_CONTINUOUS

static

◆ PLAY_CMD_FINITE

const uint32_t uhd::rfnoc::replay_block_control::PLAY_CMD_FINITE

static

◆ PLAY_CMD_STOP

const uint32_t uhd::rfnoc::replay_block_control::PLAY_CMD_STOP

static

◆ REG_COMPAT_ADDR

const uint32_t uhd::rfnoc::replay_block_control::REG_COMPAT_ADDR

static

◆ REG_MEM_SIZE_ADDR

const uint32_t uhd::rfnoc::replay_block_control::REG_MEM_SIZE_ADDR

static

◆ REG_PLAY_BASE_ADDR_HI_ADDR

const uint32_t uhd::rfnoc::replay_block_control::REG_PLAY_BASE_ADDR_HI_ADDR

static

◆ REG_PLAY_BASE_ADDR_LO_ADDR

const uint32_t uhd::rfnoc::replay_block_control::REG_PLAY_BASE_ADDR_LO_ADDR

static

◆ REG_PLAY_BUFFER_SIZE_HI_ADDR

const uint32_t uhd::rfnoc::replay_block_control::REG_PLAY_BUFFER_SIZE_HI_ADDR

static

◆ REG_PLAY_BUFFER_SIZE_LO_ADDR

const uint32_t uhd::rfnoc::replay_block_control::REG_PLAY_BUFFER_SIZE_LO_ADDR

static

◆ REG_PLAY_CMD_ADDR

const uint32_t uhd::rfnoc::replay_block_control::REG_PLAY_CMD_ADDR

static

◆ REG_PLAY_CMD_FIFO_SPACE_ADDR

const uint32_t uhd::rfnoc::replay_block_control::REG_PLAY_CMD_FIFO_SPACE_ADDR

static

◆ REG_PLAY_CMD_NUM_WORDS_HI_ADDR

const uint32_t uhd::rfnoc::replay_block_control::REG_PLAY_CMD_NUM_WORDS_HI_ADDR

static

◆ REG_PLAY_CMD_NUM_WORDS_LO_ADDR

const uint32_t uhd::rfnoc::replay_block_control::REG_PLAY_CMD_NUM_WORDS_LO_ADDR

static

◆ REG_PLAY_CMD_TIME_HI_ADDR

const uint32_t uhd::rfnoc::replay_block_control::REG_PLAY_CMD_TIME_HI_ADDR

static

◆ REG_PLAY_CMD_TIME_LO_ADDR

const uint32_t uhd::rfnoc::replay_block_control::REG_PLAY_CMD_TIME_LO_ADDR

static

◆ REG_PLAY_ITEM_SIZE_ADDR

const uint32_t uhd::rfnoc::replay_block_control::REG_PLAY_ITEM_SIZE_ADDR

static

◆ REG_PLAY_POS_HI_ADDR

const uint32_t uhd::rfnoc::replay_block_control::REG_PLAY_POS_HI_ADDR

static

◆ REG_PLAY_POS_LO_ADDR

const uint32_t uhd::rfnoc::replay_block_control::REG_PLAY_POS_LO_ADDR

static

◆ REG_PLAY_WORDS_PER_PKT_ADDR

const uint32_t uhd::rfnoc::replay_block_control::REG_PLAY_WORDS_PER_PKT_ADDR

static

◆ REG_REC_BASE_ADDR_HI_ADDR

const uint32_t uhd::rfnoc::replay_block_control::REG_REC_BASE_ADDR_HI_ADDR

static

◆ REG_REC_BASE_ADDR_LO_ADDR

const uint32_t uhd::rfnoc::replay_block_control::REG_REC_BASE_ADDR_LO_ADDR

static

◆ REG_REC_BUFFER_SIZE_HI_ADDR

const uint32_t uhd::rfnoc::replay_block_control::REG_REC_BUFFER_SIZE_HI_ADDR

static

◆ REG_REC_BUFFER_SIZE_LO_ADDR

const uint32_t uhd::rfnoc::replay_block_control::REG_REC_BUFFER_SIZE_LO_ADDR

static

◆ REG_REC_FULLNESS_HI_ADDR

const uint32_t uhd::rfnoc::replay_block_control::REG_REC_FULLNESS_HI_ADDR

static

◆ REG_REC_FULLNESS_LO_ADDR

const uint32_t uhd::rfnoc::replay_block_control::REG_REC_FULLNESS_LO_ADDR

static

◆ REG_REC_POS_HI_ADDR

const uint32_t uhd::rfnoc::replay_block_control::REG_REC_POS_HI_ADDR

static

◆ REG_REC_POS_LO_ADDR

const uint32_t uhd::rfnoc::replay_block_control::REG_REC_POS_LO_ADDR

static

◆ REG_REC_RESTART_ADDR

const uint32_t uhd::rfnoc::replay_block_control::REG_REC_RESTART_ADDR

static

◆ REPLAY_ADDR_W

const uint32_t uhd::rfnoc::replay_block_control::REPLAY_ADDR_W

static

◆ REPLAY_BLOCK_OFFSET

const uint32_t uhd::rfnoc::replay_block_control::REPLAY_BLOCK_OFFSET

static

The documentation for this class was generated from the following file:

replay_block_control.hpp

Public Member Functions

Static Public Attributes

Additional Inherited Members

Detailed Description

Block Properties

Recording Data

Playing back Data

Action Handling

Member Function Documentation

◆ config_play()

◆ get_max_items_per_packet()

◆ get_max_packet_size()

◆ get_mem_size()

◆ get_play_async_metadata()

◆ get_play_item_size()

◆ get_play_offset()

◆ get_play_position()

◆ get_play_size()

◆ get_play_type()

◆ get_record_async_metadata()

◆ get_record_fullness()

◆ get_record_item_size()

◆ get_record_offset()

◆ get_record_position()

◆ get_record_size()

◆ get_record_type()

◆ get_word_size()

◆ issue_stream_cmd()

◆ play()

◆ record()

◆ record_restart()

◆ set_max_items_per_packet()

◆ set_max_packet_size()

◆ set_play_type()

◆ set_record_type()

◆ stop()

Member Data Documentation

◆ MAJOR_COMPAT

◆ MINOR_COMPAT

◆ PLAY_CMD_CONTINUOUS

◆ PLAY_CMD_FINITE

◆ PLAY_CMD_STOP

◆ REG_COMPAT_ADDR

◆ REG_MEM_SIZE_ADDR

◆ REG_PLAY_BASE_ADDR_HI_ADDR

◆ REG_PLAY_BASE_ADDR_LO_ADDR

◆ REG_PLAY_BUFFER_SIZE_HI_ADDR

◆ REG_PLAY_BUFFER_SIZE_LO_ADDR

◆ REG_PLAY_CMD_ADDR

◆ REG_PLAY_CMD_FIFO_SPACE_ADDR

◆ REG_PLAY_CMD_NUM_WORDS_HI_ADDR

◆ REG_PLAY_CMD_NUM_WORDS_LO_ADDR

◆ REG_PLAY_CMD_TIME_HI_ADDR

◆ REG_PLAY_CMD_TIME_LO_ADDR

◆ REG_PLAY_ITEM_SIZE_ADDR

◆ REG_PLAY_POS_HI_ADDR

◆ REG_PLAY_POS_LO_ADDR

◆ REG_PLAY_WORDS_PER_PKT_ADDR

◆ REG_REC_BASE_ADDR_HI_ADDR

◆ REG_REC_BASE_ADDR_LO_ADDR

◆ REG_REC_BUFFER_SIZE_HI_ADDR

◆ REG_REC_BUFFER_SIZE_LO_ADDR

◆ REG_REC_FULLNESS_HI_ADDR

◆ REG_REC_FULLNESS_LO_ADDR

◆ REG_REC_POS_HI_ADDR

◆ REG_REC_POS_LO_ADDR

◆ REG_REC_RESTART_ADDR

◆ REPLAY_ADDR_W

◆ REPLAY_BLOCK_OFFSET