1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
//
// Copyright 2010 Ettus Research LLC
//
// This program 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.
//
// This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
//
#include "usrp2_impl.hpp"
#include "usrp2_regs.hpp"
#include <uhd/transport/convert_types.hpp>
#include <boost/format.hpp>
#include <boost/asio.hpp> //htonl and ntohl
#include <iostream>
using namespace uhd;
using namespace uhd::usrp;
using namespace uhd::transport;
namespace asio = boost::asio;
/***********************************************************************
* Helper Functions
**********************************************************************/
void usrp2_impl::io_init(void){
//setup rx otw type
_rx_otw_type.width = 16;
_rx_otw_type.shift = 0;
_rx_otw_type.byteorder = otw_type_t::BO_BIG_ENDIAN;
//setup tx otw type
_tx_otw_type.width = 16;
_tx_otw_type.shift = 0;
_tx_otw_type.byteorder = otw_type_t::BO_BIG_ENDIAN;
//send a small data packet so the usrp2 knows the udp source port
managed_send_buffer::sptr send_buff = _data_transport->get_send_buff();
boost::uint32_t data = htonl(USRP2_INVALID_VRT_HEADER);
memcpy(send_buff->cast<void*>(), &data, sizeof(data));
send_buff->done(sizeof(data));
//setup RX DSP regs
std::cout << "RX samples per packet: " << max_rx_samps_per_packet() << std::endl;
_iface->poke32(FR_RX_CTRL_NSAMPS_PER_PKT, max_rx_samps_per_packet());
_iface->poke32(FR_RX_CTRL_NCHANNELS, 1);
_iface->poke32(FR_RX_CTRL_CLEAR_OVERRUN, 1); //reset
_iface->poke32(FR_RX_CTRL_VRT_HEADER, 0
| (0x1 << 28) //if data with stream id
| (0x1 << 26) //has trailer
| (0x3 << 22) //integer time other
| (0x1 << 20) //fractional time sample count
);
_iface->poke32(FR_RX_CTRL_VRT_STREAM_ID, 0);
_iface->poke32(FR_RX_CTRL_VRT_TRAILER, 0);
}
/***********************************************************************
* Send Data
**********************************************************************/
size_t usrp2_impl::send(
const asio::const_buffer &buff,
const tx_metadata_t &metadata_,
const io_type_t &io_type
){
tx_metadata_t metadata = metadata_; //rw copy to change later
transport::managed_send_buffer::sptr send_buff = _data_transport->get_send_buff();
boost::uint32_t *tx_mem = send_buff->cast<boost::uint32_t *>();
size_t num_samps = std::min(std::min(
asio::buffer_size(buff)/io_type.size,
size_t(max_tx_samps_per_packet())),
send_buff->size()/io_type.size
);
//kill the end of burst flag if this is a fragment
if (asio::buffer_size(buff)/io_type.size < num_samps)
metadata.end_of_burst = false;
size_t num_header_words32, num_packet_words32;
size_t packet_count = _tx_stream_id_to_packet_seq[metadata.stream_id]++;
//pack metadata into a vrt header
vrt::pack(
metadata, //input
tx_mem, //output
num_header_words32, //output
num_samps, //input
num_packet_words32, //output
packet_count, //input
get_master_clock_freq()
);
boost::uint32_t *items = tx_mem + num_header_words32; //offset for data
//copy-convert the samples into the send buffer
convert_io_type_to_otw_type(
asio::buffer_cast<const void*>(buff), io_type,
(void*)items, _tx_otw_type,
num_samps
);
//send and return number of samples
send_buff->done(num_packet_words32*sizeof(boost::uint32_t));
return num_samps;
}
/***********************************************************************
* Receive Data
**********************************************************************/
size_t usrp2_impl::recv(
const asio::mutable_buffer &buff,
rx_metadata_t &metadata,
const io_type_t &io_type
){
return vrt_packet_handler::recv(
_packet_handler_recv_state, //last state of the recv handler
buff, metadata, //buffer to fill and samples metadata
io_type, _rx_otw_type, //input and output types to convert
get_master_clock_freq(), //master clock tick rate
_data_transport //zero copy interface
);
}
|
