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
131
132
133
134
135
136
137
138
|
//
// Copyright 2010-2011,2014 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 "udp_common.hpp"
#include <uhd/transport/udp_simple.hpp>
#include <uhd/utils/log.hpp>
#include <boost/format.hpp>
using namespace uhd::transport;
namespace asio = boost::asio;
/***********************************************************************
* UDP simple implementation: connected and broadcast
**********************************************************************/
class udp_simple_impl : public udp_simple{
public:
udp_simple_impl(
const std::string &addr, const std::string &port, bool bcast, bool connect
):_connected(connect){
UHD_LOG << boost::format("Creating udp transport for %s %s") % addr % port << std::endl;
//resolve the address
asio::ip::udp::resolver resolver(_io_service);
asio::ip::udp::resolver::query query(asio::ip::udp::v4(), addr, port);
_send_endpoint = *resolver.resolve(query);
//create and open the socket
_socket = socket_sptr(new asio::ip::udp::socket(_io_service));
_socket->open(asio::ip::udp::v4());
//allow broadcasting
_socket->set_option(asio::socket_base::broadcast(bcast));
//connect the socket
if (connect) _socket->connect(_send_endpoint);
}
size_t send(const asio::const_buffer &buff){
if (_connected) return _socket->send(asio::buffer(buff));
return _socket->send_to(asio::buffer(buff), _send_endpoint);
}
size_t recv(const asio::mutable_buffer &buff, double timeout){
if (not wait_for_recv_ready(_socket->native(), timeout)) return 0;
return _socket->receive_from(asio::buffer(buff), _recv_endpoint);
}
std::string get_recv_addr(void){
return _recv_endpoint.address().to_string();
}
private:
bool _connected;
asio::io_service _io_service;
socket_sptr _socket;
asio::ip::udp::endpoint _send_endpoint;
asio::ip::udp::endpoint _recv_endpoint;
};
udp_simple::~udp_simple(void){
/* NOP */
}
/***********************************************************************
* UDP public make functions
**********************************************************************/
udp_simple::sptr udp_simple::make_connected(
const std::string &addr, const std::string &port
){
return sptr(new udp_simple_impl(addr, port, false, true /* no bcast, connect */));
}
udp_simple::sptr udp_simple::make_broadcast(
const std::string &addr, const std::string &port
){
return sptr(new udp_simple_impl(addr, port, true, false /* bcast, no connect */));
}
/***********************************************************************
* Simple UART over UDP
**********************************************************************/
#include <boost/thread/thread.hpp>
class udp_simple_uart_impl : public uhd::uart_iface{
public:
udp_simple_uart_impl(udp_simple::sptr udp){
_udp = udp;
_len = 0;
_off = 0;
this->write_uart(""); //send an empty packet to init
}
void write_uart(const std::string &buf){
_udp->send(asio::buffer(buf));
}
std::string read_uart(double timeout){
std::string line;
const boost::system_time exit_time = boost::get_system_time() + boost::posix_time::milliseconds(long(timeout*1000));
do{
//drain anything in current buffer
while (_off < _len){
const char ch = _buf[_off]; _off++;
line += std::string(1, ch);
if (ch == '\n' or ch == '\r') return line;
}
//recv a new packet into the buffer
_len = _udp->recv(asio::buffer(_buf), std::max((exit_time - boost::get_system_time()).total_milliseconds()/1000., 0.0));
_off = 0;
} while (_len != 0);
return line;
}
private:
udp_simple::sptr _udp;
size_t _len, _off;
boost::uint8_t _buf[udp_simple::mtu];
};
uhd::uart_iface::sptr udp_simple::make_uart(sptr udp){
return uart_iface::sptr(new udp_simple_uart_impl(udp));
}
|
