File content as of revision 20:f533b3c9296f:

// Server code

#include "mbed.h"
#include "EthernetInterface.h"

#include "NetworkAPI/buffer.hpp"
#include "NetworkAPI/select.hpp"
#include "NetworkAPI/ip/address.hpp"
#include "NetworkAPI/tcp/socket.hpp"

#define STATIC 1
#ifdef STATIC
#define IP "127.0.0.5" // "192.168.1.5"
#define MASK "255.255.255.0"
#define GATEWAY "127.0.0.1"//"192.168.1.1"
#define MAC "00:02:f7:f0:00:00"
#endif

#define PORT 23

Serial pc(USBTX, USBRX);
DigitalOut led_red(LED_RED);
DigitalOut led_green(LED_GREEN);
DigitalOut led_blue(LED_BLUE);

uint32_t sample_array[30000];

using namespace network;
 
#define MAX_CLIENTS 5
 
int main() {
    for(int i = 0; i < 30000; i++) sample_array[i] = 0x3132;
    led_red = 1;
    led_green = 1;
    led_blue = 1;
    pc.baud(230400);
    pc.printf("Starting Server\r\n");
    
    EthernetInterface interface;
    #ifdef STATIC
    interface.init(IP, MASK, GATEWAY);
    #else
    interface.init();
    #endif
    interface.connect();
    pc.printf("IP Address is: %s\n\r", interface.getIPAddress());
    pc.printf("Network Mask is: %s\n\r", interface.getNetworkMask());
    pc.printf("MAC address is: %s\n\r", interface.getMACAddress());
    pc.printf("Gateway is: %s\n\r", interface.getGateway());
    
    
    
    Select select;
    tcp::Socket server;
    tcp::Socket client[MAX_CLIENTS];
    tcp::Socket *socket = NULL;
     
    int result = 0;
    int index = 0;
     
    network::Buffer buffer(256);
    std::string message("Hello world!");
     
    // Configure the server socket (assume everty thing works)
    server.open();
    server.bind(PORT);
    server.listen(MAX_CLIENTS);
   
    // Add sockets to the select api
    select.set(&server, Select::Read);
    for (index = 0; index < MAX_CLIENTS; index++) {
        select.set(&client[index], Select::Read);
    }
     
    do {
        // Wait for activity
        result = select.wait();
        if (result < -1) {
            pc.printf("Failed to select\n\r");
            break;
        }
         
        // Get the first socket
        socket = (tcp::Socket *)select.getReadable();
         
        for (; socket != NULL; socket = (tcp::Socket *)select.getReadable()) {
            // Check if there was a connection request.
            if (socket->getHandle() == server.getHandle()) {                
                // Find an unused client
                for (index = 0; index < MAX_CLIENTS; index++) {
                    if (client[index].getStatus() == network::Socket::Closed) {
                        break;
                    }
                }
                 
                // Maximum connections reached
                if (index == MAX_CLIENTS) {
                    pc.printf("Maximum connections reached\n\r");
                    continue;
                }
                
                // Accept the client
                socket->accept(client[index]);
                pc.printf("Client connected %s:%d\n\r",
                    client[index].getRemoteEndpoint().getAddress().toString().c_str(),
                    client[index].getRemoteEndpoint().getPort());
                     
                // Send a nice message to the client
                client[index].write((void *)message.data(), message.size());
                
                // read some registers for some info.
                //uint32_t* rcr = (uint32_t*) 0x400C0084;
                //uint32_t* ecr = (uint32_t*) 0x400C0024;
                //pc.printf("RCR register: %x\r\n", *rcr);
                //pc.printf("ECR register: %x\r\n", *ecr);
                
                continue;
            }
            
            // It was not the server socket, so it must be a client talking to us.
            switch (socket->read(buffer)) {
                case 0:
                    // Remote end disconnected
                    pc.printf("Client disconnected %s:%d\n\r",
                        socket->getRemoteEndpoint().getAddress().toString().c_str(),
                        socket->getRemoteEndpoint().getPort());
                     
                    // Close socket
                    socket->close();
                    break;
                
                case -1:
                    pc.printf("Error while reading data from socket\n\r");
                    socket->close();
                    break;
//************* this is where data is printed to the screen
                default:
                    pc.printf("Message from %s:%d\n\r",
                        socket->getRemoteEndpoint().getAddress().toString().c_str(),
                        socket->getRemoteEndpoint().getPort());
                         
                    //pc.printf("%s\n\r", (char *)buffer.data());
                    
//***************** print a message back to the client
                    Timer timeStamp;
                    timeStamp.stop();
                    timeStamp.reset();
                    timeStamp.start();
                    client[index].write((void *)&sample_array,30000);
                    int timeStampVar = timeStamp.read_us();
                    timeStamp.stop();
                    wait(1);
                    pc.printf("*******\r\nTime taken to send data: %i\r\n", timeStampVar);
                    
                    char premessage[40];
                    sprintf(premessage, "Time taken to send data: %i\r\n", timeStampVar);
                    std::string response1 = premessage;
                    client[index].write((void *)response1.data(), response1.size());
                    
                    break;
            }
        }
             
    } while (server.getStatus() == network::Socket::Listening);
}