Compiles

donat

@@ -28,7 +28,7 @@ system( "echo 0 | sudo tee /proc/sys/net/ipv4/conf/default/rp_filter" );
 system( "echo 1 | sudo tee /proc/sys/net/ipv4/conf/default/accept_local" );
 system( "echo 1 | sudo tee /proc/sys/net/ipv4/conf/default/log_martians" );
 
-for my $device ( qw[A] ) {
+for my $device ( qw[A B] ) {
   my ( $num ) = $device =~ tr{ABC}{123}r;
   my $dev = $devs[ $num ];
 

runon

@@ -4,9 +4,8 @@ use strict;
 
 my $ADB = '/home/keithw/android/android-sdk-linux/platform-tools/adb';
 
-my %devices = ( A => '0149A97C0F012017',
-		B => '0149A44C0C012007',
-		C => '0149A44C1000D00C' );
+my %devices = ( A => '014696C50601901F',
+		B => '0149A97C0F012017' );
 
 my ( $device, @command ) = @ARGV;
 

sender/Makefile

@@ -1,6 +1,6 @@
-source = send1way.cc socket.cc buffer-setpoint.cc hist.cc controlled-delay.cc rate-estimate.cc payload.cc history.cc delay-servo.cc
-objects = socket.o hist.o rate-estimate.o payload.o history.o delay-servo.o
-executables = send1way buffer-setpoint controlled-delay
+source = send1way.cc socket.cc buffer-setpoint.cc hist.cc controlled-delay.cc rate-estimate.cc payload.cc history.cc delay-servo.cc saturatr.cc acker.cc saturateservo.cc
+objects = socket.o hist.o rate-estimate.o payload.o history.o delay-servo.o acker.o saturateservo.o
+executables = send1way buffer-setpoint controlled-delay saturatr
 
 CXX = g++
 CXXFLAGS = -g -O3 -std=c++0x -ffast-math -pedantic -Werror -Wall -Wextra -Weffc++ -fno-default-inline -pipe -D_FILE_OFFSET_BITS=64 -D_XOPEN_SOURCE=500 -D_GNU_SOURCE
@@ -17,6 +17,9 @@ buffer-setpoint: buffer-setpoint.o $(objects)
 controlled-delay: controlled-delay.o $(objects)
 	$(CXX) $(CXXFLAGS) -o $@ $+ $(LIBS)
 
+saturatr: saturatr.o $(objects)
+	$(CXX) $(CXXFLAGS) -o $@ $+ $(LIBS)
+
 %.o: %.cc
 	$(CXX) $(CXXFLAGS) -c -o $@ $<
 

sender/payload.cc

@@ -16,3 +16,19 @@ bool Payload::operator==( const Payload & other ) const
 	  && recv_timestamp == other.recv_timestamp
 	  && sender_id == other.sender_id);
 }
+
+const std::string SatPayload::str( const size_t len ) const
+{
+  assert( len >= sizeof( SatPayload ) );
+  std::string padding( len - sizeof( SatPayload ), 0 );
+  return std::string( (char*)this, sizeof( SatPayload ) ) + padding;
+}
+
+bool SatPayload::operator==( const SatPayload & other ) const
+{
+  return (sequence_number == other.sequence_number
+	  && ack_number == other.ack_number
+	  && sent_timestamp == other.sent_timestamp
+	  && recv_timestamp == other.recv_timestamp
+	  && sender_id == other.sender_id);
+}

sender/payload.hh

@@ -14,4 +14,15 @@ public:
   bool operator==( const Payload & other ) const;
 };
 
+class SatPayload
+{
+public:
+  int32_t sequence_number, ack_number;
+  uint64_t sent_timestamp, recv_timestamp;
+  int sender_id;
+
+  const std::string str( const size_t len ) const;
+  bool operator==( const SatPayload & other ) const;
+};
+
 #endif

sender/saturatr.cc

@@ -0,0 +1,86 @@
+#include <string>
+#include <vector>
+#include <poll.h>
+#include <assert.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include "acker.hh"
+#include "saturateservo.hh"
+
+using namespace std;
+
+int main( int argc, char *argv[] )
+{
+  if ( argc != 1 && argc != 7 ) {
+    fprintf( stderr, "Usage: %s [RELIABLE_IP RELIABLE_DEV TEST_IP TEST_DEV SERVER_IP ID]\n",
+	     argv[ 0 ]);
+    exit( 1 );
+  }
+
+  Socket data_socket, feedback_socket;
+  bool server;
+
+  int sender_id = getpid();
+
+  Socket::Address remote_data_address( UNKNOWN ), remote_feedback_address( UNKNOWN );
+
+  if ( argc == 1 ) { /* server */
+    server = true;
+    data_socket.bind( Socket::Address( "0.0.0.0", 9001 ) );
+    feedback_socket.bind( Socket::Address( "0.0.0.0", 9002 ) );
+  } else { /* client */
+    server = false;
+
+    const char *reliable_ip = argv[ 1 ];
+    const char *reliable_dev = argv[ 2 ];
+
+    const char *test_ip = argv[ 3 ];
+    const char *test_dev = argv[ 4 ];
+
+    const char *server_ip = argv[ 5 ];
+
+    sender_id = atoi( argv[ 6 ] );
+
+    data_socket.bind( Socket::Address( test_ip, 9003 ) );
+    data_socket.bind_to_device( test_dev );
+    remote_data_address = Socket::Address( server_ip, 9001 );
+
+    feedback_socket.bind( Socket::Address( reliable_ip, 9004 ) );
+    feedback_socket.bind_to_device( reliable_dev );
+    remote_feedback_address = Socket::Address( server_ip, 9002 );
+  }
+
+  SaturateServo saturatr( "OUTGOING", feedback_socket, data_socket, remote_data_address, server, sender_id );
+  Acker acker( "INCOMING", data_socket, feedback_socket, remote_feedback_address, server, sender_id );
+
+  while ( 1 ) {
+    fflush( NULL );
+
+    /* possibly send packet */
+    //    saturatr.tick();
+    acker.tick();
+
+    /* wait for incoming packet OR expiry of timer */
+    struct pollfd poll_fds[ 2 ];
+    poll_fds[ 0 ].fd = data_socket.get_sock();
+    poll_fds[ 0 ].events = POLLIN;
+    poll_fds[ 1 ].fd = feedback_socket.get_sock();
+    poll_fds[ 1 ].events = POLLIN;
+
+    struct timespec timeout;
+    uint64_t next_transmission_delay = 0; //std::min( saturatr.wait_time(), acker.wait_time() );
+    timeout.tv_sec = next_transmission_delay / 1000000000;
+    timeout.tv_nsec = next_transmission_delay % 1000000000;
+    ppoll( poll_fds, 2, &timeout, NULL );
+
+    if ( poll_fds[ 0 ].revents & POLLIN ) {
+      acker.recv();
+    }
+
+    if ( poll_fds[ 1 ].revents & POLLIN ) {
+      //saturatr.recv();
+      server++;
+    }
+  }
+}

sender/socket.cc

@@ -21,6 +21,13 @@ Socket::Address::Address( string ip, uint16_t port )
   }
 }
 
+std::string Socket::Address::ip( void ) const
+{
+  char tmp[ 64 ];
+  snprintf( tmp, 64, "%s", inet_ntoa( _sockaddr.sin_addr ) );
+  return string( tmp );
+}
+
 const string Socket::Address::str( void ) const
 {
   char tmp[ 64 ];
@@ -45,6 +52,15 @@ Socket::Socket()
   }
 }
 
+void Socket::connect( const Socket::Address & addr ) const
+{
+  if ( ::connect( sock, (sockaddr *)&addr.sockaddr(), sizeof( addr.sockaddr() ) ) < 0 ) {
+    fprintf( stderr, "Error connecting to %s\n", addr.str().c_str() );
+    perror( "bind" );
+    exit( 1 );
+  }
+}
+
 void Socket::bind( const Socket::Address & addr ) const
 {
   if ( ::bind( sock, (sockaddr *)&addr.sockaddr(), sizeof( addr.sockaddr() ) ) < 0 ) {

sender/socket.hh

@@ -5,6 +5,7 @@
 #include <netinet/in.h>
 #include <string>
 #include <time.h>
+#include <string.h>
 
 class Socket {
 public:
@@ -20,6 +21,10 @@ public:
 
     const struct sockaddr_in & sockaddr( void ) const { return _sockaddr; }
     const std::string str( void ) const;
+
+    std::string ip( void ) const;
+
+    bool operator==( const Address & other ) const { return (0 == memcmp( &_sockaddr, &other._sockaddr, sizeof( _sockaddr ))); }
   };
 
   class Packet {
@@ -43,10 +48,13 @@ private:
 public:
   Socket();
   void bind( const Address & addr ) const;
+  void connect( const Address & addr ) const;
   void send( const Packet & payload ) const;
   void bind_to_device( const std::string & name ) const;
   Packet recv( void ) const;
   int get_sock( void ) const { return sock; }
 };
 
+const Socket::Address UNKNOWN( "0.0.0.0", 0 );
+
 #endif