/ - Diff - Colony - Robotics Club

     /* Public functions */
     int wirelessMessageHandler(ColonetPacket* pkt)
+    {
       printf("Received wireless message!!!\n");
       if (!pkt) {
         printf("The packet pointer was null.\n");
         return -1;
+      }
     int wirelessMessageHandler(unsigned char type, short source, int dest,
                                unsigned char* data, int len) {
       printf("Server received wireless message!!!\n");
       if ((int)pkt->msg_type == COLONET_RESPONSE) {
       if (type == COLONET_RESPONSE) {
         printf("response\n");
         int dest = (int)(pkt->msg_dest);
         char buffer[WRITE_BUFFER_SIZE];
         int value = (int)(pkt->data[0]);
         int value = (int)(data[0]);
         snprintf(buffer, WRITE_BUFFER_SIZE, "%d\n", value);
         int len = strlen(buffer);
         if (connection_pool->write_to_client(dest, buffer, len) == ERROR_INVALID_CLIENT_ID) {
           printf("The robot wanted to pass the data to a client not in the pool.\n");
         int buflen = strlen(buffer);
         if (connection_pool->write_to_client(dest, buffer, buflen)
             == ERROR_INVALID_CLIENT_ID) {
           printf("The robot wanted to pass the data to a client not in the "
                  "pool.\n");
           return -1;
+        }
-...
         printf("not a response\n");
+      }
       pkt = 0;
       return 0;
+    }

       int add_client(int client_file_descriptor);
       int remove_client(int pool_index);
       int check_clients(ColonetWireless * wireless);
       int check_clients();
       int write_to_client(int pool_index, char * message, int length);
       void set_listen_socket_in_ready_set(int listen_socket);
       int perform_select(int listen_socket);
-...
       char * write_buffer[MAX_CONNECTIONS];
       int write_buffer_size[MAX_CONNECTIONS];
       int parse_command(char* command, int pool_index, ColonetWireless * wireless);
       int parse_command(char* command, int pool_index);
       int tokenize_command(char* command, char tokens[MAX_TOKENS][MAX_TOKEN_SIZE]);
       int check_tokens(unsigned char* tokens, int number_tokens);
     };

     #ifndef COLONETSERVER_H
     #define COLONETSERVER_H
     #include <colonet_wireless.h>
     #include "ConnectionPool.h"
     #include "Log.h"
-...
     private:
       ConnectionPool connection_pool;
       Log logger;
       ColonetWireless* wireless;
       int listen_socket;
       int initialize_wireless();

     #include <colonet_wireless.h>
     int wirelessMessageHandler(ColonetPacket* pkt);
     int wirelessMessageHandler(unsigned char* pkt, int len);
     int initWireless(void);
     void send_wireless_message(unsigned char msg_dest, unsigned char msg_type,
                                unsigned char msg_code, unsigned char* data);
     int wirelessMessageHandler(unsigned char type, short source, int dest,
                                unsigned char* data, int len);
     #endif

     #include "includes/ConnectionPool.h"
     #include "includes/client.h"
     #include "../lib/colonet_defs.h"
     #include <colonet_wireless.h>
     /**
      * @brief The default constructor for ConnectionPool
-...
      * Sees is any clients are ready to read from their file descriptor or are
      *  ready to write to their file descriptor.
+     *
      * @param wireless A pointer to the wireless object
+     *
      * @return 0 on success, negative error code on error
      */
     //TODO: test that it drops commands properly if it gets sent too much data
     //      do we want it to drop the data or drop the connection?
     int ConnectionPool::check_clients(ColonetWireless * wireless) {
     int ConnectionPool::check_clients() {
       char temporary_buffer[READ_BUFFER_SIZE];
       char temporary_command_buffer[READ_BUFFER_SIZE+1];
       int i;
-...
                 break;
+              }
               if (parse_command(temporary_command_buffer, i, wireless) < 0) {
               if (parse_command(temporary_command_buffer, i) < 0) {
                 printf("There was an error parsing command\n");
                 break;
+              }
-...
+    }
     //TODO: write a function to write data into the write buffers (jason: what was this referring to?)
     int ConnectionPool::parse_command(char* command, int pool_index, ColonetWireless * wireless) {
     int ConnectionPool::parse_command(char* command, int pool_index) {
       char tokens[MAX_TOKENS][MAX_TOKEN_SIZE];
       unsigned char int_tokens[MAX_TOKENS];
       int number_tokens = 0;
-...
         */
         // Fill arguments buffer with arguments
         for (i = ROBOT_COMMAND_LEN; i < number_int_tokens-ROBOT_COMMAND_OFFSET; i++) {
         for (i = ROBOT_COMMAND_LEN; i < number_int_tokens-ROBOT_COMMAND_OFFSET;
              i++) {
           arguments[i-ROBOT_COMMAND_LEN] = int_tokens[i];
+        }
-...
+        }
         // Send packet to robot
         fprintf(stderr, "Calling wireless->send(%d, %d, %d, arguments)\n",
         fprintf(stderr, "Calling colonet_wl_send(%d, %d, %d, arguments)\n",
                 int_tokens[0], int_tokens[1], int_tokens[2]);
         wireless->send(int_tokens[0], int_tokens[1], int_tokens[2], arguments);
         colonet_wl_send(pool_index, int_tokens[0],
                         (ColonetMessageType)int_tokens[1], int_tokens[2],
                         arguments);
       } else if (command_id == REQUEST_FROM_SERVER) {
         if (number_tokens < 2)
           return -1;

      * @date 10/31/06
      */
     #include <colonet_wireless.h>
     #include <arpa/inet.h>
     #include <fcntl.h>
     #include <errno.h>
     #include <netinet/in.h>
     #include <string.h>
     #include <sys/select.h>
     #include <sys/socket.h>
     #include <netinet/in.h>
     #include <errno.h>
     #include <arpa/inet.h>
     #include <fcntl.h>
     #include <colonet_wireless.h>
     #include "includes/ColonetServer.h"
-...
             logger.logMessage(LOG_TYPE_CONNECT, log_buffer);
+          }
           if (connection_pool.check_clients(wireless) < 0) {
           if (connection_pool.check_clients() < 0) {
             printf("\tThere was an error trying to update the clients.");
             continue;
+          }
-...
         log_filename = optionsG.log_filename;
+      }
       wireless = new ColonetWireless(optionsG.wireless_port,
                                      wirelessMessageHandler, log_filename,
                                      /*!optionsG.listener_mode*/false, true);
       //Note: last arg set to true ignores token ring;  in general, this should
       //probably be false (changed for demo purposes)
       colonet_wl_init(optionsG.wireless_port, wirelessMessageHandler,
                       log_filename);
       if (!wireless->run_listener_thread()) {
       if (!colonet_wl_run_listener_thread()) {
         fprintf(stderr, "%s: colonet_wl_run_listener_thread failed.\n",
                 __FUNCTION__);
         return -1;
+      }

     VPATH = ../lib:../lib/colonet_wireless
     INCLUDE_DIRS = ../lib/colonet_wireless ../lib
     LIBRARY_DIRS = ../lib
     LIBRARY_DIRS = ../lib ../../libwireless/lib
     #this takes the include directory and puts a -I in front of each directory name before being used in a gcc statement
-...
     	$(CC) $(CFLAGS) -c $(COLONETFILES) $(INCLUDE_DIRS_FOR_GCC)
     	$(CC) $(CFLAGS) -c $(COLONETCPPFILES) $(INCLUDE_DIRS_FOR_GCC)
     	$(CC) $(CFLAGS) -c $(LOGGINGFILES) $(INCLUDE_DIRS_FOR_GCC)
     	$(CC) $(CFLAGS) $(COLONETOBJECTS) $(COLONETCPPOBJECTS) $(LOGGINGOBJECTS) $(LIBRARY_DIRS_FOR_GCC) -lpthread -lcolonet_wireless $(INCLUDE_DIRS_FOR_GCC) -o $@
     	$(CC) $(CFLAGS) $(COLONETOBJECTS) $(COLONETCPPOBJECTS) $(LOGGINGOBJECTS) $(LIBRARY_DIRS_FOR_GCC) -lpthread -lcolonet_wireless $(INCLUDE_DIRS_FOR_GCC) -lwireless -o $@
     clean:
     	rm -rf *.o ColonetServer

Project

General

Profile

Colony

Revision 118