#include <stdio.h>
#include <string.h>
#if defined(HAVE_NETDB_H)
+#include <netdb.h>
+#include <sys/socket.h> //usually included by <netdb.h>?
typedef void* optval_t;
#elif defined(HAVE_WINDOWS_H)
// if not posix, assume winsock
}
gr_udp_sink::gr_udp_sink (size_t itemsize,
- const char *src, unsigned short port_src,
- const char *dst, unsigned short port_dst,
- int payload_size)
+ const char *host, unsigned short port,
+ int payload_size, bool eof)
: gr_sync_block ("udp_sink",
gr_make_io_signature (1, 1, itemsize),
gr_make_io_signature (0, 0, 0)),
- d_itemsize (itemsize), d_payload_size(payload_size)
+ d_itemsize (itemsize), d_payload_size(payload_size), d_eof(eof),
+ d_connected(false)
{
- int ret = 0;
- struct addrinfo *ip_src; // store the source ip info
- struct addrinfo *ip_dst; // store the destination ip info
-
#if defined(USING_WINSOCK) // for Windows (with MinGW)
// initialize winsock DLL
WSADATA wsaData;
report_error( "gr_udp_source WSAStartup", "can't open socket" );
}
#endif
-
- // Set up the address stucture for the source address and port numbers
- // Get the source IP address from the host name
- struct addrinfo hints;
- memset( (void*)&hints, 0, sizeof(hints) );
- hints.ai_family = AF_INET;
- hints.ai_socktype = SOCK_DGRAM;
- hints.ai_protocol = IPPROTO_UDP;
- char port_str[7];
- sprintf( port_str, "%d", port_src );
- ret = getaddrinfo( src, port_str, &hints, &ip_src );
- if( ret != 0 )
- report_error("gr_udp_source/getaddrinfo",
- "can't initialize source socket" );
-
- // Get the destination IP address from the host name
- sprintf( port_str, "%d", port_dst );
- ret = getaddrinfo( dst, port_str, &hints, &ip_dst );
- if( ret != 0 )
- report_error("gr_udp_source/getaddrinfo",
- "can't initialize destination socket" );
// create socket
- d_socket = socket(ip_src->ai_family, ip_src->ai_socktype,
- ip_src->ai_protocol);
+ d_socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if(d_socket == -1) {
report_error("socket open","can't open socket");
}
- // Turn on reuse address
- int opt_val = true;
- if(setsockopt(d_socket, SOL_SOCKET, SO_REUSEADDR, (optval_t)&opt_val, sizeof(int)) == -1) {
- report_error("SO_REUSEADDR","can't set socket option SO_REUSEADDR");
- }
-
// Don't wait when shutting down
linger lngr;
lngr.l_onoff = 1;
}
}
- // bind socket to an address and port number to listen on
- if(bind (d_socket, ip_src->ai_addr, ip_src->ai_addrlen) == -1) {
- report_error("socket bind","can't bind socket");
- }
-
- // Not sure if we should throw here or allow retries
- if(connect(d_socket, ip_dst->ai_addr, ip_dst->ai_addrlen) == -1) {
- report_error("socket connect","can't connect to socket");
- }
-
- freeaddrinfo(ip_src);
- freeaddrinfo(ip_dst);
+ // Get the destination address
+ connect(host, port);
}
// public constructor that returns a shared_ptr
gr_udp_sink_sptr
gr_make_udp_sink (size_t itemsize,
- const char *src, unsigned short port_src,
- const char *dst, unsigned short port_dst,
- int payload_size)
+ const char *host, unsigned short port,
+ int payload_size, bool eof)
{
return gr_udp_sink_sptr (new gr_udp_sink (itemsize,
- src, port_src,
- dst, port_dst,
- payload_size));
+ host, port,
+ payload_size, eof));
}
gr_udp_sink::~gr_udp_sink ()
{
+ if (d_connected)
+ disconnect();
+
if (d_socket){
shutdown(d_socket, SHUT_RDWR);
#if defined(USING_WINSOCK)
printf("Entered udp_sink\n");
#endif
+ gruel::scoped_lock guard(d_mutex); // protect d_socket
+
while(bytes_sent < total_size) {
bytes_to_send = std::min((ssize_t)d_payload_size, (total_size-bytes_sent));
- r = send(d_socket, (in+bytes_sent), bytes_to_send, 0);
- if(r == -1) { // error on send command
- if( is_error(ECONNREFUSED) )
- r = bytes_to_send; // discard data until receiver is started
- else {
- report_error("udp_sink",NULL); // there should be no error case where
- return -1; // this function should not exit immediately
+ if(d_connected) {
+ r = send(d_socket, (in+bytes_sent), bytes_to_send, 0);
+ if(r == -1) { // error on send command
+ if( is_error(ECONNREFUSED) )
+ r = bytes_to_send; // discard data until receiver is started
+ else {
+ report_error("udp_sink",NULL); // there should be no error case where
+ return -1; // this function should not exit immediately
+ }
}
}
+ else
+ r = bytes_to_send; // discarded for lack of connection
bytes_sent += r;
#if SNK_VERBOSE
- printf("\tbyte sent: %d bytes\n", bytes);
+ printf("\tbyte sent: %d bytes\n", r);
#endif
}
return noutput_items;
}
+
+void gr_udp_sink::connect( const char *host, unsigned short port )
+{
+ if(d_connected)
+ disconnect();
+
+ if(host != NULL ) {
+ // Get the destination address
+ struct addrinfo *ip_dst;
+ struct addrinfo hints;
+ memset( (void*)&hints, 0, sizeof(hints) );
+ hints.ai_family = AF_INET;
+ hints.ai_socktype = SOCK_DGRAM;
+ hints.ai_protocol = IPPROTO_UDP;
+ char port_str[12];
+ sprintf( port_str, "%d", port );
+ int ret = getaddrinfo( host, port_str, &hints, &ip_dst );
+ if( ret != 0 )
+ report_error("gr_udp_source/getaddrinfo",
+ "can't initialize destination socket" );
+
+ // don't need d_mutex lock when !d_connected
+ if(::connect(d_socket, ip_dst->ai_addr, ip_dst->ai_addrlen) == -1) {
+ report_error("socket connect","can't connect to socket");
+ }
+ d_connected = true;
+
+ freeaddrinfo(ip_dst);
+ }
+
+ return;
+}
+
+void gr_udp_sink::disconnect()
+{
+ if(!d_connected)
+ return;
+
+ #if SNK_VERBOSE
+ printf("gr_udp_sink disconnecting\n");
+ #endif
+
+ gruel::scoped_lock guard(d_mutex); // protect d_socket from work()
+
+ // Send a few zero-length packets to signal receiver we are done
+ if(d_eof) {
+ int i;
+ for( i = 0; i < 3; i++ )
+ (void) send( d_socket, NULL, 0, 0 ); // ignore errors
+ }
+
+ // Since I can't find any way to disconnect a datagram socket in Cygwin,
+ // we just leave it connected but disable sending.
+#if 0
+ // zeroed address structure should reset connection
+ struct sockaddr addr;
+ memset( (void*)&addr, 0, sizeof(addr) );
+ // addr.sa_family = AF_UNSPEC; // doesn't work on Cygwin
+ // addr.sa_family = AF_INET; // doesn't work on Cygwin
+
+ if(::connect(d_socket, &addr, sizeof(addr)) == -1)
+ report_error("socket connect","can't connect to socket");
+#endif
+
+ d_connected = false;
+
+ return;
+}
#define INCLUDED_GR_UDP_SINK_H
#include <gr_sync_block.h>
-#if defined(HAVE_NETDB_H)
-#include <netdb.h>
-#include <sys/socket.h> // usually #included by <netdb.h>?
-#elif defined(HAVE_WINDOWS_H)
-#include <winsock2.h>
-#include <ws2tcpip.h>
-#endif
-
#include <gruel/thread.h>
class gr_udp_sink;
gr_udp_sink_sptr
gr_make_udp_sink (size_t itemsize,
- const char *src, unsigned short port_src,
- const char *dst, unsigned short port_dst,
- int payload_size=1472);
+ const char *host, unsigned short port,
+ int payload_size=1472, bool eof=true);
/*!
* \brief Write stream to an UDP socket.
* \ingroup sink_blk
*
* \param itemsize The size (in bytes) of the item datatype
- * \param src The source address as either the host name or the 'numbers-and-dots'
- * IP address
- * \param port_src Destination port to bind to (0 allows socket to choose an appropriate port)
- * \param dst The destination address as either the host name or the 'numbers-and-dots'
- * IP address
- * \param port_dst Destination port to connect to
- * \param payload_size UDP payload size by default set to
- * 1472 = (1500 MTU - (8 byte UDP header) - (20 byte IP header))
+ * \param host The name or IP address of the receiving host; use
+ * NULL or None for no connection
+ * \param port Destination port to connect to on receiving host
+ * \param payload_size UDP payload size by default set to 1472 =
+ * (1500 MTU - (8 byte UDP header) - (20 byte IP header))
+ * \param eof Send zero-length packet on disconnect
*/
class gr_udp_sink : public gr_sync_block
{
friend gr_udp_sink_sptr gr_make_udp_sink (size_t itemsize,
- const char *src, unsigned short port_src,
- const char *dst, unsigned short port_dst,
- int payload_size);
+ const char *host,
+ unsigned short port,
+ int payload_size, bool eof);
private:
size_t d_itemsize;
- int d_payload_size; // maximum transmission unit (packet length)
- int d_socket; // handle to socket
+ int d_payload_size; // maximum transmission unit (packet length)
+ bool d_eof; // send zero-length packet on disconnect
+ int d_socket; // handle to socket
+ bool d_connected; // are we connected?
+ gruel::mutex d_mutex; // protects d_socket and d_connected
protected:
/*!
* \brief UDP Sink Constructor
*
* \param itemsize The size (in bytes) of the item datatype
- * \param src The source address as either the host name or the 'numbers-and-dots'
- * IP address
- * \param port_src Destination port to bind to (0 allows socket to choose an appropriate port)
- * \param dst The destination address as either the host name or the 'numbers-and-dots'
- * IP address
- * \param port_dst Destination port to connect to
+ * \param host The name or IP address of the receiving host; use
+ * NULL or None for no connection
+ * \param port Destination port to connect to on receiving host
* \param payload_size UDP payload size by default set to
* 1472 = (1500 MTU - (8 byte UDP header) - (20 byte IP header))
+ * \param eof Send zero-length packet on disconnect
*/
gr_udp_sink (size_t itemsize,
- const char *src, unsigned short port_src,
- const char *dst, unsigned short port_dst,
- int payload_size);
+ const char *host, unsigned short port,
+ int payload_size, bool eof);
public:
~gr_udp_sink ();
/*! \brief return the PAYLOAD_SIZE of the socket */
int payload_size() { return d_payload_size; }
+ /*! \brief Change the connection to a new destination
+ *
+ * \param host The name or IP address of the receiving host; use
+ * NULL or None to break the connection without closing
+ * \param port Destination port to connect to on receiving host
+ *
+ * Calls disconnect() to terminate any current connection first.
+ */
+ void connect( const char *host, unsigned short port );
+
+ /*! \brief Send zero-length packet (if eof is requested) then stop sending
+ *
+ * Zero-byte packets can be interpreted as EOF by gr_udp_source. Note that
+ * disconnect occurs automatically when the sink is destroyed, but not when
+ * its top_block stops.*/
+ void disconnect();
+
// should we export anything else?
int work (int noutput_items,
/* -*- c++ -*- */
/*
- * Copyright 2007 Free Software Foundation, Inc.
+ * Copyright 2007,2010 Free Software Foundation, Inc.
*
* This file is part of GNU Radio
*
gr_udp_sink_sptr
gr_make_udp_sink (size_t itemsize,
- const char *src, unsigned short port_src,
- const char *dst, unsigned short port_dst,
- int payload_size=1472);
+ const char *host, unsigned short port,
+ int payload_size=1472, bool eof=true);
class gr_udp_sink : public gr_sync_block
{
protected:
gr_udp_sink (size_t itemsize,
- const char *src, unsigned short port_src,
- const char *dst, unsigned short port_dst,
- int payload_size);
-
- bool open();
- void close();
- int payload_size() { return d_payload_size; }
+ const char *host, unsigned short port,
+ int payload_size, bool eof);
public:
~gr_udp_sink ();
+
+ int payload_size() { return d_payload_size; }
+ void connect( const char *host, unsigned short port );
+ void disconnect();
+
};
#include <errno.h>
#include <stdio.h>
#include <string.h>
+
#if defined(HAVE_NETDB_H)
#include <netdb.h>
typedef void* optval_t;
+
+// ntohs() on FreeBSD may require both netinet/in.h and arpa/inet.h, in order
+#if defined(HAVE_NETINET_IN_H)
+#include <netinet/in.h>
+#endif
+#if defined(HAVE_ARPA_INET_H)
+#include <arpa/inet.h>
+#endif
+
#elif defined(HAVE_WINDOWS_H)
// if not posix, assume winsock
#define USING_WINSOCK
#endif
}
-static void report_error( char *msg1, char *msg2 )
+static void report_error( const char *msg1, const char *msg2 )
{
// Deal with errors, both posix and winsock
#if defined(USING_WINSOCK)
return;
}
-gr_udp_source::gr_udp_source(size_t itemsize, const char *src,
- unsigned short port_src, int payload_size,
- bool wait)
+gr_udp_source::gr_udp_source(size_t itemsize, const char *host,
+ unsigned short port, int payload_size,
+ bool eof, bool wait)
: gr_sync_block ("udp_source",
gr_make_io_signature(0, 0, 0),
gr_make_io_signature(1, 1, itemsize)),
- d_itemsize(itemsize), d_payload_size(payload_size), d_wait(wait), d_residual(0), d_temp_offset(0)
+ d_itemsize(itemsize), d_payload_size(payload_size),
+ d_eof(eof), d_wait(wait), d_residual(0), d_temp_offset(0)
{
int ret = 0;
- struct addrinfo *ip_src; // store the source IP address to use
#if defined(USING_WINSOCK) // for Windows (with MinGW)
// initialize winsock DLL
// Set up the address stucture for the source address and port numbers
// Get the source IP address from the host name
+ struct addrinfo *ip_src; // store the source IP address to use
struct addrinfo hints;
memset( (void*)&hints, 0, sizeof(hints) );
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
- char port_str[7];
- sprintf( port_str, "%d", port_src );
- ret = getaddrinfo( src, port_str, &hints, &ip_src );
+ hints.ai_flags = AI_PASSIVE;
+ char port_str[12];
+ sprintf( port_str, "%d", port );
+ ret = getaddrinfo( host, port_str, &hints, &ip_src );
if( ret != 0 )
report_error("gr_udp_source/getaddrinfo",
"can't initialize source socket" );
gr_udp_source_sptr
gr_make_udp_source (size_t itemsize, const char *ipaddr,
- unsigned short port, int payload_size, bool wait)
+ unsigned short port, int payload_size, bool eof, bool wait)
{
return gr_udp_source_sptr (new gr_udp_source (itemsize, ipaddr,
- port, payload_size, wait));
+ port, payload_size, eof, wait));
}
gr_udp_source::~gr_udp_source ()
return -1;
}
}
+ else if(r==0) {
+ if(d_eof) {
+ // zero-length packet interpreted as EOF
+
+ #if SNK_VERBOSE
+ printf("\tzero-length packet received; returning EOF\n");
+ #endif
+
+ return -1;
+ }
+ else{
+ // do we need to allow boost thread interrupt?
+ boost::this_thread::interruption_point();
+ continue;
+ }
+ }
else {
// Calculate the number of bytes we can take from the buffer in this call
nbytes = std::min(r, total_bytes-bytes_received);
return bytes_received/d_itemsize;
}
+// Return port number of d_socket
+int gr_udp_source::get_port(void)
+{
+ sockaddr_in name;
+ socklen_t len = sizeof(name);
+ int ret = getsockname( d_socket, (sockaddr*)&name, &len );
+ if( ret ) {
+ report_error("gr_udp_source/getsockname",NULL);
+ return -1;
+ }
+ return ntohs(name.sin_port);
+}
#define INCLUDED_GR_UDP_SOURCE_H
#include <gr_sync_block.h>
-#if defined(HAVE_NETDB_H)
-#include <netdb.h>
-#include <sys/socket.h> // usually #included by <netdb.h>?
-#elif defined(HAVE_WINDOWS_H)
-#include <winsock2.h>
-#include <ws2tcpip.h>
-#endif
-
#include <gruel/thread.h>
class gr_udp_source;
typedef boost::shared_ptr<gr_udp_source> gr_udp_source_sptr;
-gr_udp_source_sptr gr_make_udp_source(size_t itemsize, const char *src,
- unsigned short port_src,
- int payload_size=1472, bool wait=true);
+gr_udp_source_sptr gr_make_udp_source(size_t itemsize, const char *host,
+ unsigned short port,
+ int payload_size=1472,
+ bool eof=true, bool wait=true);
/*!
* \brief Read stream from an UDP socket.
* \ingroup source_blk
*
* \param itemsize The size (in bytes) of the item datatype
- * \param src The source address as either the host name or the 'numbers-and-dots'
- * IP address
- * \param port_src The port number on which the socket listens for data
- * \param payload_size UDP payload size by default set to
- * 1472 = (1500 MTU - (8 byte UDP header) - (20 byte IP header))
- * \param wait Wait for data if not immediately available (default: true)
+ * \param host The name or IP address of the receiving host; can be
+ * NULL, None, or "0.0.0.0" to allow reading from any
+ * interface on the host
+ * \param port The port number on which to receive data; use 0 to
+ * have the system assign an unused port number
+ * \param payload_size UDP payload size by default set to 1472 =
+ * (1500 MTU - (8 byte UDP header) - (20 byte IP header))
+ * \param eof Interpret zero-length packet as EOF (default: true)
+ * \param wait Wait for data if not immediately available
+ * (default: true)
*
*/
class gr_udp_source : public gr_sync_block
{
- friend gr_udp_source_sptr gr_make_udp_source(size_t itemsize, const char *src,
- unsigned short port_src,
- int payload_size, bool wait);
+ friend gr_udp_source_sptr gr_make_udp_source(size_t itemsize,
+ const char *host,
+ unsigned short port,
+ int payload_size,
+ bool eof, bool wait);
private:
size_t d_itemsize;
-
- int d_payload_size; // maximum transmission unit (packet length)
- bool d_wait; // wait if data if not immediately available
- int d_socket; // handle to socket
+ int d_payload_size; // maximum transmission unit (packet length)
+ bool d_eof; // zero-length packet is EOF
+ bool d_wait; // wait if data if not immediately available
+ int d_socket; // handle to socket
char *d_temp_buff; // hold buffer between calls
ssize_t d_residual; // hold information about number of bytes stored in the temp buffer
size_t d_temp_offset; // point to temp buffer location offset
* \brief UDP Source Constructor
*
* \param itemsize The size (in bytes) of the item datatype
- * \param src The source address as either the host name or the 'numbers-and-dots'
- * IP address
- * \param port_src The port number on which the socket listens for data
- * \param payload_size UDP payload size by default set to
- * 1472 = (1500 MTU - (8 byte UDP header) - (20 byte IP header))
- * \param wait Wait for data if not immediately available (default: true)
+ * \param host The name or IP address of the receiving host; can be
+ * NULL, None, or "0.0.0.0" to allow reading from any
+ * interface on the host
+ * \param port The port number on which to receive data; use 0 to
+ * have the system assign an unused port number
+ * \param payload_size UDP payload size by default set to 1472 =
+ * (1500 MTU - (8 byte UDP header) - (20 byte IP header))
+ * \param eof Interpret zero-length packet as EOF (default: true)
+ * \param wait Wait for data if not immediately available
+ * (default: true)
*/
- gr_udp_source(size_t itemsize, const char *src, unsigned short port_src,
- int payload_size, bool wait);
+ gr_udp_source(size_t itemsize, const char *host, unsigned short port,
+ int payload_size, bool eof, bool wait);
public:
~gr_udp_source();
/*! \brief return the PAYLOAD_SIZE of the socket */
int payload_size() { return d_payload_size; }
+ /*! \breif return the port number of the socket */
+ int get_port();
+
// should we export anything else?
int work(int noutput_items,
/* -*- c++ -*- */
/*
- * Copyright 2007 Free Software Foundation, Inc.
+ * Copyright 2007,2010 Free Software Foundation, Inc.
*
* This file is part of GNU Radio
*
GR_SWIG_BLOCK_MAGIC(gr,udp_source)
gr_udp_source_sptr
-gr_make_udp_source (size_t itemsize, const char *src,
- unsigned short port_src, int payload_size=1472,
- bool wait=true);
+gr_make_udp_source (size_t itemsize, const char *host,
+ unsigned short port, int payload_size=1472,
+ bool eof=true, bool wait=true);
class gr_udp_source : public gr_sync_block
{
protected:
- gr_udp_source (size_t itemsize, const char *src,
- unsigned short port_src, int payload_size, bool wait);
+ gr_udp_source (size_t itemsize, const char *host,
+ unsigned short port, int payload_size, bool eof, bool wait);
public:
~gr_udp_source ();
int payload_size() { return d_payload_size; }
-
+ int get_port();
};
qa_unpack_k_bits.py \
qa_repeat.py \
qa_scrambler.py \
+ qa_udp_sink_source.py \
qa_vector_sink_source.py
--- /dev/null
+#!/usr/bin/env python
+#
+# Copyright 2008 Free Software Foundation, Inc.
+#
+# This file is part of GNU Radio
+#
+# GNU Radio 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, or (at your option)
+# any later version.
+#
+# GNU Radio 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 GNU Radio; see the file COPYING. If not, write to
+# the Free Software Foundation, Inc., 51 Franklin Street,
+# Boston, MA 02110-1301, USA.
+#
+
+from gnuradio import gr, gr_unittest
+from threading import Timer
+
+class test_sink_source(gr_unittest.TestCase):
+
+ def setUp(self):
+ self.tb_snd = gr.top_block()
+ self.tb_rcv = gr.top_block()
+
+ def tearDown(self):
+ self.tb_rcv = None
+ self.tb_snd = None
+
+ def test_001(self):
+ port = 65500
+
+ n_data = 16
+ src_data = [float(x) for x in range(n_data)]
+ expected_result = tuple(src_data)
+ src = gr.vector_source_f(src_data)
+ udp_snd = gr.udp_sink( gr.sizeof_float, 'localhost', port )
+ self.tb_snd.connect( src, udp_snd )
+
+ udp_rcv = gr.udp_source( gr.sizeof_float, 'localhost', port )
+ dst = gr.vector_sink_f()
+ self.tb_rcv.connect( udp_rcv, dst )
+
+ self.tb_rcv.start()
+ self.tb_snd.run()
+ udp_snd.disconnect()
+ self.timeout = False
+ q = Timer(3.0,self.stop_rcv)
+ q.start()
+ self.tb_rcv.wait()
+ q.cancel()
+
+ result_data = dst.data()
+ self.assertEqual(expected_result, result_data)
+ self.assert_(not self.timeout)
+
+ def test_002(self):
+ udp_rcv = gr.udp_source( gr.sizeof_float, '0.0.0.0', 0, eof=False )
+ rcv_port = udp_rcv.get_port()
+
+ udp_snd = gr.udp_sink( gr.sizeof_float, '127.0.0.1', 65500 )
+ udp_snd.connect( 'localhost', rcv_port )
+
+ n_data = 16
+ src_data = [float(x) for x in range(n_data)]
+ expected_result = tuple(src_data)
+ src = gr.vector_source_f(src_data)
+ dst = gr.vector_sink_f()
+
+ self.tb_snd.connect( src, udp_snd )
+ self.tb_rcv.connect( udp_rcv, dst )
+
+ self.tb_rcv.start()
+ self.tb_snd.run()
+ udp_snd.disconnect()
+ self.timeout = False
+ q = Timer(3.0,self.stop_rcv)
+ q.start()
+ self.tb_rcv.wait()
+ q.cancel()
+
+ result_data = dst.data()
+ self.assertEqual(expected_result, result_data)
+ self.assert_(self.timeout) # source ignores EOF?
+
+ def stop_rcv(self):
+ self.timeout = True
+ self.tb_rcv.stop()
+ #print "tb_rcv stopped by Timer"
+
+if __name__ == '__main__':
+ gr_unittest.main ()
+
#!/usr/bin/env python
#
-# Copyright 2006,2007 Free Software Foundation, Inc.
+# Copyright 2006,2007,2010 Free Software Foundation, Inc.
#
# This file is part of GNU Radio
#
from optparse import OptionParser
class audio_sink(gr.top_block):
- def __init__(self, src, port, pkt_size, sample_rate):
+ def __init__(self, host, port, pkt_size, sample_rate, eof, wait):
gr.top_block.__init__(self, "audio_sink")
- src = gr.udp_source(gr.sizeof_float, src, port, pkt_size)
+ src = gr.udp_source(gr.sizeof_float, host, port, pkt_size,
+ eof=eof, wait=wait)
dst = audio.sink(sample_rate)
self.connect(src, dst)
if __name__ == '__main__':
parser = OptionParser(option_class=eng_option)
- parser.add_option("", "--src-name", type="string", default="localhost",
+ parser.add_option("", "--host", type="string", default="0.0.0.0",
help="local host name (domain name or IP address)")
- parser.add_option("", "--src-port", type="int", default=65500,
+ parser.add_option("", "--port", type="int", default=65500,
help="port value to listen to for connection")
parser.add_option("", "--packet-size", type="int", default=1472,
help="packet size.")
parser.add_option("-r", "--sample-rate", type="int", default=32000,
help="audio signal sample rate [default=%default]")
+ parser.add_option("", "--no-eof", action="store_true", default=False,
+ help="don't send EOF on disconnect")
+ parser.add_option("", "--no-wait", action="store_true", default=False,
+ help="don't wait for source")
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
raise SystemExit, 1
# Create an instance of a hierarchical block
- top_block = audio_sink(options.src_name, options.src_port,
- options.packet_size, options.sample_rate)
+ top_block = audio_sink(options.host, options.port,
+ options.packet_size, options.sample_rate,
+ not options.no_eof, not options.no_wait)
try:
# Run forever
#!/usr/bin/env python
#
-# Copyright 2006,2007 Free Software Foundation, Inc.
+# Copyright 2006,2007,2010 Free Software Foundation, Inc.
#
# This file is part of GNU Radio
#
from optparse import OptionParser
class audio_source(gr.top_block):
- def __init__(self, src, dst, port, pkt_size, sample_rate):
+ def __init__(self, host, port, pkt_size, sample_rate, eof):
gr.top_block.__init__(self, "audio_source")
self.audio = audio.source(sample_rate)
- self.sink = gr.udp_sink(gr.sizeof_float, src, 0, dst, port, pkt_size)
+ self.sink = gr.udp_sink(gr.sizeof_float, host, port, pkt_size, eof=eof)
self.connect(self.audio, self.sink)
if __name__ == '__main__':
parser = OptionParser(option_class=eng_option)
- parser.add_option("", "--src-name", type="string", default="localhost",
- help="local host name (domain name or IP address)")
- parser.add_option("", "--dst-name", type="string", default="localhost",
+ parser.add_option("", "--host", type="string", default="localhost",
help="Remote host name (domain name or IP address")
- parser.add_option("", "--dst-port", type="int", default=65500,
- help="port value to connect to")
+ parser.add_option("", "--port", type="int", default=65500,
+ help="port number to connect to")
parser.add_option("", "--packet-size", type="int", default=1472,
help="packet size.")
parser.add_option("-r", "--sample-rate", type="int", default=32000 ,
help="audio signal sample rate [default=%default]")
+ parser.add_option("", "--no-eof", action="store_true", default=False,
+ help="don't send EOF on disconnect")
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
raise SystemExit, 1
# Create an instance of a hierarchical block
- top_block = audio_source(options.src_name, options.dst_name, options.dst_port,
- options.packet_size, options.sample_rate)
+ top_block = audio_source(options.host, options.port,
+ options.packet_size, options.sample_rate,
+ not options.no_eof)
try:
# Run forever
#!/usr/bin/env python
#
-# Copyright 2006,2007 Free Software Foundation, Inc.
+# Copyright 2006,2007,2010 Free Software Foundation, Inc.
#
# This file is part of GNU Radio
#
from optparse import OptionParser
class dial_tone_sink(gr.top_block):
- def __init__(self, src, port, pkt_size, sample_rate, wait):
+ def __init__(self, host, port, pkt_size, sample_rate, eof, wait):
gr.top_block.__init__(self, "dial_tone_sink")
- udp = gr.udp_source(gr.sizeof_float, src, port, pkt_size, wait=wait)
+ udp = gr.udp_source(gr.sizeof_float, host, port, pkt_size,
+ eof=eof, wait=wait)
sink = audio.sink(sample_rate)
self.connect(udp, sink)
if __name__ == '__main__':
parser = OptionParser(option_class=eng_option)
- parser.add_option("", "--src-name", type="string", default="localhost",
+ parser.add_option("", "--host", type="string", default="0.0.0.0",
help="local host name (domain name or IP address)")
- parser.add_option("", "--src-port", type="int", default=65500,
+ parser.add_option("", "--port", type="int", default=65500,
help="port value to listen to for connection")
parser.add_option("", "--packet-size", type="int", default=1472,
help="packet size.")
parser.add_option("-r", "--sample-rate", type="int", default=8000,
help="audio signal sample rate [default=%default]")
- parser.add_option("-n", "--no-wait", action="store_true", default=False,
+ parser.add_option("", "--no-eof", action="store_true", default=False,
+ help="don't send EOF on disconnect")
+ parser.add_option("", "--no-wait", action="store_true", default=False,
help="don't wait for source")
(options, args) = parser.parse_args()
if len(args) != 0:
raise SystemExit, 1
# Create an instance of a hierarchical block
- top_block = dial_tone_sink(options.src_name, options.src_port,
+ top_block = dial_tone_sink(options.host, options.port,
options.packet_size, options.sample_rate,
- not options.no_wait)
+ not options.no_eof, not options.no_wait)
try:
# Run forever
#!/usr/bin/env python
#
-# Copyright 2006,2007 Free Software Foundation, Inc.
+# Copyright 2006,2007,2010 Free Software Foundation, Inc.
#
# This file is part of GNU Radio
#
from optparse import OptionParser
class dial_tone_source(gr.top_block):
- def __init__(self, src, dst, port, pkt_size, sample_rate):
+ def __init__(self, host, port, pkt_size, sample_rate, eof):
gr.top_block.__init__(self, "dial_tone_source")
amplitude = 0.3
# Throttle needed here to account for the other side's audio card sampling rate
thr = gr.throttle(gr.sizeof_float, sample_rate)
- sink = gr.udp_sink(gr.sizeof_float, src, 0, dst, port, pkt_size)
+ sink = gr.udp_sink(gr.sizeof_float, host, port, pkt_size, eof=eof)
self.connect(src0, (add, 0))
self.connect(src1, (add, 1))
self.connect(add, thr, sink)
if __name__ == '__main__':
parser = OptionParser(option_class=eng_option)
- parser.add_option("", "--src-name", type="string", default="localhost",
- help="local host name (domain name or IP address)")
- parser.add_option("", "--dst-name", type="string", default="localhost",
+ parser.add_option("", "--host", type="string", default="localhost",
help="Remote host name (domain name or IP address")
- parser.add_option("", "--dst-port", type="int", default=65500,
- help="port value to connect to")
+ parser.add_option("", "--port", type="int", default=65500,
+ help="port number to connect to")
parser.add_option("", "--packet-size", type="int", default=1472,
help="packet size.")
parser.add_option("-r", "--sample-rate", type="int", default=8000,
help="audio signal sample rate [default=%default]")
+ parser.add_option("", "--no-eof", action="store_true", default=False,
+ help="don't send EOF on disconnect")
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
raise SystemExit, 1
# Create an instance of a hierarchical block
- top_block = dial_tone_source(options.src_name, options.dst_name, options.dst_port,
- options.packet_size, options.sample_rate)
+ top_block = dial_tone_source(options.host, options.port,
+ options.packet_size, options.sample_rate,
+ not options.no_eof)
try:
# Run forever
except KeyboardInterrupt:
# Ctrl-C exits
pass
-
#!/usr/bin/env python
#
-# Copyright 2006 Free Software Foundation, Inc.
+# Copyright 2006,2010 Free Software Foundation, Inc.
#
# This file is part of GNU Radio
#
from optparse import OptionParser
class vector_sink(gr.top_block):
- def __init__(self, src, port, pkt_size):
+ def __init__(self, host, port, pkt_size, eof, wait):
gr.top_block.__init__(self, "vector_sink")
- udp = gr.udp_source(gr.sizeof_float, src, port, pkt_size)
+ udp = gr.udp_source(gr.sizeof_float, host, port, pkt_size,
+ eof=eof, wait=wait)
sink = gr.file_sink(gr.sizeof_float, "received.dat")
self.connect(udp, sink)
if __name__ == "__main__":
parser = OptionParser(option_class=eng_option)
- parser.add_option("", "--src-name", type="string", default="localhost",
+ parser.add_option("", "--host", type="string", default="0.0.0.0",
help="local host name (domain name or IP address)")
- parser.add_option("", "--src-port", type="int", default=65500,
+ parser.add_option("", "--port", type="int", default=65500,
help="port value to listen to for connection")
parser.add_option("", "--packet-size", type="int", default=1471,
help="packet size.")
+ parser.add_option("", "--no-eof", action="store_true", default=False,
+ help="don't send EOF on disconnect")
+ parser.add_option("", "--no-wait", action="store_true", default=False,
+ help="don't wait for source")
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
raise SystemExit, 1
# Create an instance of a hierarchical block
- top_block = vector_sink(options.src_name, options.src_port, options.packet_size)
+ top_block = vector_sink(options.host, options.port,
+ options.packet_size,
+ not options.no_eof, not options.no_wait)
try:
# Run forever
#!/usr/bin/env python
#
-# Copyright 2006 Free Software Foundation, Inc.
+# Copyright 2006,2010 Free Software Foundation, Inc.
#
# This file is part of GNU Radio
#
from optparse import OptionParser
class vector_source(gr.top_block):
- def __init__(self, src, dst, port, pkt_size):
+ def __init__(self, host, port, pkt_size, eof):
gr.top_block.__init__(self, "vector_source")
data = [i*0.01 for i in range(1000)]
vec = gr.vector_source_f(data, True)
- udp = gr.udp_sink(gr.sizeof_float, src, 0, dst, port, pkt_size)
+ udp = gr.udp_sink(gr.sizeof_float, host, port, pkt_size, eof=eof)
self.connect(vec, udp)
if __name__ == '__main__':
parser = OptionParser(option_class=eng_option)
- parser.add_option("", "--src-name", type="string", default="localhost",
- help="local host name (domain name or IP address)")
- parser.add_option("", "--dst-name", type="string", default="localhost",
+ parser.add_option("", "--host", type="string", default="localhost",
help="Remote host name (domain name or IP address")
- parser.add_option("", "--dst-port", type="int", default=65500,
- help="port value to connect to")
+ parser.add_option("", "--port", type="int", default=65500,
+ help="port number to connect to")
parser.add_option("", "--packet-size", type="int", default=1471,
help="packet size.")
+ parser.add_option("", "--no-eof", action="store_true", default=False,
+ help="don't send EOF on disconnect")
(options, args) = parser.parse_args()
if len(args) != 0:
parser.print_help()
raise SystemExit, 1
# Create an instance of a hierarchical block
- top_block = vector_source(options.src_name, options.dst_name,
- options.dst_port, options.packet_size)
+ top_block = vector_source(options.host, options.port, options.packet_size,
+ not options.no_eof)
try:
# Run forever
projects / debian / gnuradio / commitdiff