USRP Hardware Driver and USRP Manual: uhd::rfnoc::replay_block_control Class Reference

| USRP Hardware Driver and USRP Manual Version: 4.9.0.makepkg-0-g9ec1f582 UHD and USRP Manual |

Loading...
Searching...
No Matches
uhd::rfnoc::replay_block_control Class Referenceabstract
RFNoC » RFNoC Blocks

`#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, const uhd::time_spec_t time_spec, const bool repeat)=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 size_t iterations=1)=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
virtual void | post_input_action (const std::shared_ptr< uhd::rfnoc::action_info > &action, const size_t port)=0
virtual void | post_output_action (const std::shared_ptr< uhd::rfnoc::action_info > &action, const size_t port)=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.
size_t | get_num_input_ports () const override
size_t | get_num_output_ports () const override
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.
uhd::property_tree::sptr & | get_tree ()
| Return a reference to this block's subtree (non-const version).
std::shared_ptr< mb_controller > | get_mb_controller ()
Public Member Functions inherited from uhd::rfnoc::node_t
| node_t ()
virtual | ~node_t ()
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 constexpr auto | PLAY_CONTINUOUS {std::numeric_limits<size_t>::max()}
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.
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 | graph_mutex_callback_t = std::function<std::recursive_mutex&(void)>
using | action_handler_t
using | forwarding_map_t
Protected Types inherited from uhd::rfnoc::node_t
using | prop_ptrs_t = std::vector<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)
void | set_num_output_ports (const size_t num_ports)
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)
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.

## 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().
payload_size | Size of outgoing packet payload (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() [1/2]

virtual void uhd::rfnoc::replay_block_control::play | ( | const uint64_t | offset,
|  | const uint64_t | size,
|  | const size_t | port,
|  | const uhd::time_spec_t | time_spec,
|  | const bool | repeat )
| 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.

Deprecated

      \param 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.
      \param 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.
      \param port Which output port of the replay block to use
      \param 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.
      \param 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.
      \throws uhd::value_error if offset+size exceeds the available memory.
      \throws uhd::op_failed Too many play commands are queued.

## ◆ play() [2/2]

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 size_t | iterations = 1 )
| 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.
  iterations | Determines whether the data should be played continous (PLAY_CONTINUOUS) or num_repeat times. If set to PLAY_CONTINUOUS 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.

## ◆ post_input_action()

virtual void uhd::rfnoc::replay_block_control::post_input_action | ( | const std::shared_ptr< uhd::rfnoc::action_info > & | action,
|  | const size_t | port )
| pure virtual

Issue an action from the replay block

Post an action to the input of replay block.

Parameters

  action | The action pointer to post
  port | Which input port of the replay block to use

## ◆ post_output_action()

virtual void uhd::rfnoc::replay_block_control::post_output_action | ( | const std::shared_ptr< uhd::rfnoc::action_info > & | action,
|  | const size_t | port )
| pure virtual

Issue an action from the replay block

Post an action to the output of replay block.

Parameters

  action | The action pointer to post
  port | Which output port of the replay block to use

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

## ◆ PLAY_CONTINUOUS

auto uhd::rfnoc::replay_block_control::PLAY_CONTINUOUS {std::numeric_limits<size_t>::max()}
| staticconstexpr

This constant can be used in the play command to trigger continous play of the signal.

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