USRP Hardware Driver and USRP Manual Version: 4.1.0.3
UHD and USRP Manual
mock_block.hpp
Go to the documentation of this file.
1//
2// Copyright 2019 Ettus Research, a National Instruments Brand
3//
4// SPDX-License-Identifier: GPL-3.0-or-later
5//
6
7#pragma once
8
9#include <uhd/config.hpp>
10#include <uhd/property_tree.hpp>
16#include <uhd/utils/log.hpp>
17#include <unordered_map>
18#include <boost/format.hpp>
19#include <vector>
20
21namespace uhd { namespace rfnoc {
22
28{
29public:
30 mock_reg_iface_t() = default;
31 ~mock_reg_iface_t() override = default;
32
33 /**************************************************************************
34 * API
35 *************************************************************************/
36 void poke32(uint32_t addr, uint32_t data, uhd::time_spec_t time, bool ack) override
37 {
38 write_memory[addr] = data;
39 _poke_cb(addr, data, time, ack);
40 }
41
42 void multi_poke32(const std::vector<uint32_t> addrs,
43 const std::vector<uint32_t> data,
45 bool ack) override
46 {
47 if (addrs.size() != data.size()) {
48 throw uhd::value_error("addrs and data vectors must be of the same length");
49 }
50 for (size_t i = 0; i < addrs.size(); i++) {
51 poke32(addrs[i], data[i], time, ack);
52 }
53 }
54
55 void block_poke32(uint32_t first_addr,
56 const std::vector<uint32_t> data,
57 uhd::time_spec_t timestamp,
58 bool ack) override
59 {
60 for (size_t i = 0; i < data.size(); i++) {
61 poke32(first_addr + 4 * i, data[i], timestamp, ack);
62 }
63 }
64
65 uint32_t peek32(uint32_t addr, uhd::time_spec_t time) override
66 {
67 _peek_cb(addr, time);
68 try {
69 return read_memory.at(addr);
70 } catch (const std::out_of_range&) {
72 str(boost::format("No data defined for address: 0x%04X") % addr));
73 }
74 }
75
76 std::vector<uint32_t> block_peek32(
77 uint32_t first_addr, size_t length, uhd::time_spec_t time) override
78 {
79 std::vector<uint32_t> result(length, 0);
80 for (size_t i = 0; i < length; ++i) {
81 result[i] = peek32(first_addr + i * 4, time);
82 }
83 return result;
84 }
85
86 void poll32(uint32_t addr,
87 uint32_t data,
88 uint32_t mask,
89 uhd::time_spec_t /* timeout */,
91 bool /* ack */ = false) override
92 {
93 if (force_timeout) {
94 throw uhd::op_timeout("timeout");
95 }
96
97 if ((peek32(addr, time) & mask) == data) {
98 UHD_LOG_INFO("MOCK_REG_IFACE", "poll32() successful at addr " << addr);
99 } else {
100 UHD_LOG_INFO("MOCK_REG_IFACE", "poll32() not successful at addr " << addr);
101 }
102 }
103
104 void sleep(uhd::time_spec_t /*duration*/, bool /*ack*/) override
105 {
106 // nop
107 }
108
110 {
111 // nop
112 }
113
115 {
116 // nop
117 }
118
119 void set_policy(const std::string& name, const uhd::device_addr_t& args) override
120 {
121 UHD_LOG_INFO("MOCK_REG_IFACE",
122 "Requested to set policy for " << name << " to " << args.to_string());
123 }
124
125 uint16_t get_src_epid() const override
126 {
127 return 0;
128 }
129
130 uint16_t get_port_num() const override
131 {
132 return 0;
133 }
134
135 bool force_timeout = false;
136
138 std::unordered_map<uint32_t, uint32_t> read_memory;
140 // been previously set.
141 std::unordered_map<uint32_t, uint32_t> write_memory;
142
143protected:
144 virtual void _poke_cb(
145 uint32_t /*addr*/, uint32_t /*data*/, uhd::time_spec_t /*time*/, bool /*ack*/)
146 {
147 }
148
149 virtual void _peek_cb(uint32_t /*addr*/, uhd::time_spec_t /*time*/) {}
150};
151
155{
156 friend class get_mock_block;
158 std::shared_ptr<mock_reg_iface_t> reg_iface;
159
162
164 // the register space is appropiately primed before doing so.
165 template <typename block_type = noc_block_base>
166 std::shared_ptr<block_type> get_block()
167 {
168 return std::dynamic_pointer_cast<block_type>(factory(std::move(make_args)));
169 }
170
173
174 // Note: The make args would ideally be captured by the factory function,
175 // but std::functions need to be CopyConstructible, and this struct doesn't,
176 // so it needs to live out here in the open.
178};
179
183 const size_t num_inputs = 1,
184 const size_t num_outputs = 1,
186 const size_t mtu = 8000,
187 const device_type_t device_id = ANY_DEVICE,
188 std::shared_ptr<mock_reg_iface_t> client_reg_iface = nullptr,
189 mb_controller::sptr mbc = nullptr);
190
191}}; // namespace uhd::rfnoc
Definition: device_addr.hpp:38
std::string to_string(void) const
std::shared_ptr< property_tree > sptr
Definition: property_tree.hpp:216
std::shared_ptr< mb_controller > sptr
Definition: mb_controller.hpp:29
Definition: mock_block.hpp:28
uint16_t get_src_epid() const override
Definition: mock_block.hpp:125
~mock_reg_iface_t() override=default
std::unordered_map< uint32_t, uint32_t > write_memory
All peeks read from this map. A peek will fail if the address has not.
Definition: mock_block.hpp:141
void block_poke32(uint32_t first_addr, const std::vector< uint32_t > data, uhd::time_spec_t timestamp, bool ack) override
Definition: mock_block.hpp:55
std::vector< uint32_t > block_peek32(uint32_t first_addr, size_t length, uhd::time_spec_t time) override
Definition: mock_block.hpp:76
void poll32(uint32_t addr, uint32_t data, uint32_t mask, uhd::time_spec_t, uhd::time_spec_t time=uhd::time_spec_t::ASAP, bool=false) override
Definition: mock_block.hpp:86
void multi_poke32(const std::vector< uint32_t > addrs, const std::vector< uint32_t > data, uhd::time_spec_t time, bool ack) override
Definition: mock_block.hpp:42
uint32_t peek32(uint32_t addr, uhd::time_spec_t time) override
Definition: mock_block.hpp:65
virtual void _peek_cb(uint32_t, uhd::time_spec_t)
Definition: mock_block.hpp:149
void set_policy(const std::string &name, const uhd::device_addr_t &args) override
Definition: mock_block.hpp:119
std::unordered_map< uint32_t, uint32_t > read_memory
All pokes end up writing to this map.
Definition: mock_block.hpp:138
void register_async_msg_validator(async_msg_validator_t) override
Definition: mock_block.hpp:109
void sleep(uhd::time_spec_t, bool) override
Definition: mock_block.hpp:104
virtual void _poke_cb(uint32_t, uint32_t, uhd::time_spec_t, bool)
Definition: mock_block.hpp:144
void poke32(uint32_t addr, uint32_t data, uhd::time_spec_t time, bool ack) override
Definition: mock_block.hpp:36
void register_async_msg_handler(async_msg_callback_t) override
Definition: mock_block.hpp:114
uint16_t get_port_num() const override
Definition: mock_block.hpp:130
std::unique_ptr< make_args_t > make_args_ptr
Opaque pointer to the constructor arguments.
Definition: noc_block_base.hpp:53
std::shared_ptr< noc_block_base > sptr
Definition: noc_block_base.hpp:47
Definition: register_iface.hpp:28
std::function< void(uint32_t addr, const std::vector< uint32_t > &data, boost::optional< uint64_t >)> async_msg_callback_t
Definition: register_iface.hpp:56
std::function< bool(uint32_t addr, const std::vector< uint32_t > &data)> async_msg_validator_t
Definition: register_iface.hpp:43
Definition: time_spec.hpp:31
static constexpr double ASAP
Definition: time_spec.hpp:34
#define UHD_API
Definition: config.h:70
#define UHD_LOG_INFO(component,...)
Definition: log.h:55
uint16_t device_type_t
Device Type.
Definition: defaults.hpp:58
UHD_API mock_block_container get_mock_block(const noc_id_t noc_id, const size_t num_inputs=1, const size_t num_outputs=1, const uhd::device_addr_t &args=uhd::device_addr_t(), const size_t mtu=8000, const device_type_t device_id=ANY_DEVICE, std::shared_ptr< mock_reg_iface_t > client_reg_iface=nullptr, mb_controller::sptr mbc=nullptr)
uint32_t noc_id_t
Definition: defaults.hpp:54
UHD_INLINE data_t mask(const soft_reg_field_t field)
Definition: soft_register.hpp:87
Definition: build_info.hpp:12
Definition: exception.hpp:252
Definition: mock_block.hpp:155
uhd::property_tree::sptr tree
Reference to the prop tree object the block sees.
Definition: mock_block.hpp:161
std::shared_ptr< block_type > get_block()
Use this to retrieve a reference to the block controller. Make sure that.
Definition: mock_block.hpp:166
std::function< noc_block_base::sptr(noc_block_base::make_args_ptr)> factory
Factory to get the block. Use get_block() instead.
Definition: mock_block.hpp:172
std::shared_ptr< mock_reg_iface_t > reg_iface
Reference to the register interface object.
Definition: mock_block.hpp:158
noc_block_base::make_args_ptr make_args
Definition: mock_block.hpp:177
Definition: exception.hpp:133
Definition: exception.hpp:109