main.cpp

00001 
00002 #include "mbed.h"
00003 #include "sdram.h"
00004 
00005 #define MEM_LIBC_MALLOC 1
00006 #include "EthernetInterface.h"
00007 // #include "NTPClient.h"
00008 #include "lwip/opt.h"
00009 #include "lwip/sockets.h"
00010 #include "lwip/sys.h"
00011 
00012 // mbed stuff
00013 DigitalOut led1(LED1);
00014 Serial pc(USBTX, USBRX);
00015 Timer t;
00016 Ticker blinker;
00017 
00018 
00019 #define DEFAULTPORT 0x494F /* "IO" */
00020 
00021 #define INTERVAL 6
00022 
00023 int nSizes[] = {1024, 2048, 4096, 8192, 16384, 32768};
00024 size_t nnSizes = sizeof(nSizes) / sizeof(int);
00025 #define NMAXSIZE 65536
00026 
00027 int tSizes[] = {1024, 2048, 4096, 8192, 16384, 32767};
00028 size_t ntSizes = sizeof(tSizes) / sizeof(int);
00029 #define TMAXSIZE 65536
00030 
00031 
00032 #define KB(nSize)   ((nSize) + 512) / 1024
00033 
00034 typedef struct {
00035   uint32_t cmd;
00036   uint32_t data;
00037 } CONTROL;
00038 
00039 #define CMD_NONE  0
00040 #define CMD_C2S   1
00041 #define CMD_S2C   2
00042 #define CMD_RES   3
00043 
00044 #define CTLSIZE sizeof(CONTROL)
00045 
00046 int nPort = DEFAULTPORT;
00047 
00048 
00049 static void blink(void) {
00050     led1 = !led1;
00051 }
00052 
00053 
00054 static void StartTimer(void) {
00055     t.reset();
00056     t.start();
00057 }
00058 
00059 
00060 static float ReadTimer(void) {
00061     return t.read();
00062 }
00063 
00064 
00065 static float StopTimer(void) {
00066     t.stop();
00067     return ReadTimer();
00068 }
00069 
00070 
00071 static void GenerateRandomData(char *cBuffer, size_t nSize) {
00072     if (cBuffer != NULL) {
00073         size_t i;
00074         
00075         cBuffer[0] = 0;
00076         srand(time(NULL));
00077         
00078         for (i = 1; i < nSize; i++)
00079             cBuffer[i] = (char) rand();
00080     }
00081 }
00082 
00083 
00084 static char *InitBuffer(size_t nSize) {
00085     char *cBuffer = (char *)malloc(nSize);
00086     
00087     GenerateRandomData(cBuffer, nSize); 
00088     return cBuffer;
00089 }
00090 
00091 
00092 static int send_data(int socket, void *buffer, size_t size, int flags) {
00093     int rc = lwip_send(socket, buffer, size, flags);
00094     
00095     if (rc < 0) {
00096         printf("send error\n");
00097         return -1;
00098     }
00099     
00100     if (rc != size)
00101         return 1;
00102     
00103     return 0;
00104 }
00105 
00106 
00107 static int recv_data(int socket, void *buffer, size_t size, int flags) {
00108     int rc = lwip_recv(socket, buffer, size, flags);
00109     
00110     if (rc < 0) {
00111         printf("recv error\n");
00112         return -1;
00113     }
00114     
00115     if (rc != size)
00116         return 1;
00117     
00118     return 0;
00119 }
00120 
00121 
00122 static void netio_server (const void *arg) {
00123     char *cBuffer;
00124     CONTROL ctl;
00125     float nTime;
00126     long long nData;
00127     struct sockaddr_in sa_server, sa_client;
00128     int server, client;
00129     socklen_t length;
00130     struct timeval tv;
00131     fd_set fds;
00132     int rc;
00133     int nByte;
00134 
00135     if ((cBuffer = InitBuffer(TMAXSIZE)) == NULL) {
00136         printf("malloc error\n");
00137         return;
00138     }
00139 
00140     server = lwip_socket(AF_INET, SOCK_STREAM, 0);
00141     if (server < 0) {
00142         printf("socket error\n");
00143         free(cBuffer);
00144         return;
00145     }
00146     
00147     sa_server.sin_family = AF_INET;
00148     sa_server.sin_port = htons(nPort);
00149     sa_server.sin_addr.s_addr = INADDR_ANY;
00150     if (lwip_bind(server, (struct sockaddr *)&sa_server, sizeof(sa_server)) < 0) {
00151         printf("bind error\n");
00152         lwip_close(server);
00153         free(cBuffer);
00154         return;
00155     }
00156     
00157     if (lwip_listen(server, 1) != 0) {
00158         printf("listen error\n");
00159         lwip_close(server);
00160         free(cBuffer);
00161         return;
00162     }
00163     
00164     for (;;) {
00165         printf("TCP server listening.\n");
00166     
00167         FD_ZERO(&fds);
00168         FD_SET(server, &fds);
00169         tv.tv_sec  = 3600;
00170         tv.tv_usec = 0;
00171     
00172         if ((rc = lwip_select(FD_SETSIZE, &fds, 0, 0, &tv)) < 0) {
00173             printf("select error\n");
00174             break;
00175         }
00176     
00177         if (rc == 0 || FD_ISSET(server, &fds) == 0)
00178             continue;
00179     
00180         length = sizeof(sa_client);
00181         if ((client = lwip_accept(server, (struct sockaddr *) &sa_client, &length)) == -1)
00182             continue;
00183         
00184         printf("TCP connection established.\n");
00185         
00186         for (;;) {
00187             if (recv_data(client, (void *) &ctl, CTLSIZE, 0))
00188                 break;
00189             
00190             ctl.cmd = ntohl(ctl.cmd);
00191             ctl.data = ntohl(ctl.data);
00192             
00193             if (ctl.cmd == CMD_C2S) {
00194                 printf("Packet size %2uk bytes: ", KB(ctl.data));
00195                 fflush(stdout);
00196                 nData = 0;
00197                 StartTimer();
00198                 
00199                 do {
00200                     for (nByte = 0; nByte < ctl.data; ) {
00201                         rc = lwip_recv(client, cBuffer + nByte, ctl.data - nByte, 0);
00202                         
00203                         if (rc < 0) {
00204                             printf("recv error\n");
00205                             break;
00206                         }
00207                         
00208                         if (rc > 0)
00209                             nByte += rc;
00210                     }
00211                     
00212                     nData += ctl.data;
00213                 } while (cBuffer[0] == 0 && rc > 0);
00214                 
00215                 if ((nTime = StopTimer()) != -1) {
00216                     printf(" %0.2f KByte/s Rx", nData / 1024 / nTime);
00217                     fflush(stdout);
00218                 }
00219             } else if (ctl.cmd == CMD_S2C) {
00220                 cBuffer[0] = 0;
00221                 nData = 0;
00222 
00223                 StartTimer();
00224                 
00225                 while (ReadTimer() < INTERVAL) {
00226                     //GenerateRandomData(cBuffer, ctl.data);
00227                     
00228                     for (nByte = 0; nByte < ctl.data; ) {
00229                         rc = lwip_send(client, cBuffer + nByte, ctl.data - nByte, 0);
00230                         
00231                         if (rc < 0) {
00232                             printf("send error\n");
00233                             break;
00234                         }
00235                         
00236                         if (rc > 0)
00237                             nByte += rc;
00238                     }
00239                         
00240                     nData += ctl.data;
00241                 }
00242                     
00243                 cBuffer[0] = 1;
00244                 
00245                 if (send_data(client, cBuffer, ctl.data, 0))
00246                     break;
00247                 
00248                 if ((nTime = StopTimer()) != -1) {
00249                     printf(", %0.2f KByte/s Tx\n", nData / 1024 / nTime);
00250                 }
00251             } else {
00252                 // quit
00253                 break;
00254             }
00255         }
00256         printf("Done.\n");
00257 
00258         lwip_close(client);
00259         
00260         if (rc < 0)
00261             break;
00262     }
00263     lwip_close(server);
00264     
00265     free(cBuffer);
00266 }
00267 
00268 
00269 int main() {
00270     pc.baud(115200);
00271     
00272     if (sdram_init() == 0) {
00273         printf("SDRAM initialized\n");
00274     } else {
00275         printf("Failed to initialized SDRAM\n");
00276     }
00277 
00278     blinker.attach(&blink, 0.5);
00279     
00280     EthernetInterface eth;
00281     eth.init(); // Use DHCP
00282     eth.connect();
00283     printf("IP Address is %s\n", eth.getIPAddress());
00284 
00285 /*    
00286     NTPClient ntp;
00287     if (ntp.setTime("0.pool.ntp.org") == 0) {
00288       printf("Set time successfully\n");
00289       time_t rawtime = time(NULL) + (2 * 60 * 60);
00290       struct tm *timeinfo = localtime(&rawtime);
00291       strftime(buffer, sizeof(buffer), "Time: %d.%m.%Y %H:%M:%S", timeinfo);
00292       printf("%s\n", buffer);
00293     } else {
00294       printf("NTP Error\n");
00295     }
00296 */
00297 
00298     Thread thread(netio_server);
00299 
00300     while(1) {
00301         Thread::wait(60000);
00302     }
00303     
00304     // eth.disconnect();
00305 }