/ - Diff - Colony - Robotics Club

Revision 618

Added by Jason knichel about 16 years ago

added some comments

     static int log_packet(unsigned char* packet, int len);
     /**************************** Public functions *******************************/
     /**
      * @brief Initializes the wireless library
+     *
      * @param wl_port_ The port to listen for wireless messages on
      * @param log_filename_ The name of the log file
+     *
      * @return 0 on success, negative error code on failure
      */
     int colonet_wl_init(char* wl_port_, char* log_filename_) {
       if (log_filename_ != NULL) {
         logging_enabled = true;
-...
       return 0;
+    }
     /**
      * @brief This function will kill the thread that is listening for wireless messages
      */
     void colonet_wl_kill_listener_thread() {
       pthread_kill(listener_thread, 9);
+    }
     /**
      * @brief This function spawns a thread to listen for wireless messages
+     *
      * @return 0 on success, negative error code on failure
      */
     int colonet_wl_run_listener_thread() {
       dbg_printf("Spawning listener thread...\n");
-...
       return 0;
+    }
     /**
      * @brief This function sends a message out on the wireless
+     *
      * @param client_source The index in the connection pool of the client that is sending the message
      * @param dest The robot that is meant to receive this message
      * @param msg_type The type of the message
      * @param msg_code The message code
      * @param args The arguments to send with the message
+     *
      * @return 0 on success, a negative error code on failure
      */
     int colonet_wl_send(short client_source, short dest, ColonetRobotMessageType msg_type, unsigned char msg_code,
       unsigned char* args) {
       //printf("colonet_wl_send: client_source:%d, dest:%d, msg_code:%d\n", client_source, dest, msg_code);
       //create a new packet to be sent
       ColonetRobotServerPacket pkt;
       //set up the packet
       pkt.client_id = client_source;
       pkt.msg_code = msg_code;
       //copy over the args into the data portion of the packet
       for (int i = 0; i < PACKET_DATA_LEN; i++) {
         //printf("data %i: %u\n", i, args[i]);
         pkt.data[i] = args[i];
-...
       return 0;
+    }
     /**
      * @brief Used to get the number of robots in the token ring
+     *
      * @return The result of wl_token_get_num_robots()
      */
     int colonet_get_num_robots(void) {
       return wl_token_get_num_robots();
+    }
     /**
      * @brief Gets a list of the xbee ids of the ones in the token ring
+     *
      * @param numrobots A pointer to the variable where you want the number of robots to be stored
+     *
      * @return A dynamically allocated piece of memory that contains the list of xbee ids.
      *   The function calling this function must free this memory when done with it.
      */
     int* colonet_get_xbee_ids(int* numrobots) {
       int num_robots = wl_token_get_num_robots();
       int* ids = (int*)malloc(num_robots * sizeof(int));
-...
       return ids;
+    }
     // Returns int**; should be freed
     /**
      * @brief Gets the sensor matrix from the wireless library
+     *
      * @param numrobots A pointer to the variable where you want the number of robots to be stored
      * @param ids_ A pointer to a pointer that you want to point to the list of xbee ids.  This memory is dynamically allocated and should be freed by the calling process when it is done with it
+     *
      * @return The 2d matrix reprsenting the sensor matrix.  This memory is dynamically allocated and should be freed by the calling process when it is done with it
      */
     int** colonet_get_sensor_matrix(int* numrobots, int** ids_) {
       int num_robots;
       int* ids = colonet_get_xbee_ids(&num_robots);
-...
         log_packet(data, len);
+      }
       //see if a robot wants the server to tell it where it is
       if (pkt->msg_code == ROBOT_REQUEST_POSITION_FROM_SERVER) {
         /* Robot has requested its position. */
         int robot_x, robot_y;
         PositionMonitor* pm = colonet_server.getPositionMonitor();
         int num_robots = pm->getNumVisibleRobots();
         //ask the position monitor for where that robot is.
         int ret = pm->getRobotPosition(source, &robot_x, &robot_y);
         if (ret != 0 && num_robots != 1) {
           fprintf(stderr, "Robot %d requested position, but its position is not known.\n", source);

       return 0;
+    }
     /**
      * @brief The function that is run in the new pthread in order to do the position monitoring
+     *
      * @param arg the argument to give to the new thread
      */
     void* run_thread(void* arg) {
       PositionMonitor* p = (PositionMonitor*) arg;
       p->run();
       return NULL;
+    }
     /**
      * @brief This function spawns a new thread to do the position monitoring based off data
      *  retrieved from the library that parses the image from the camera
      */
     int ColonetServer::run_position_monitor() {
       pthread_t posmon_thread;
       pthread_create(&posmon_thread, NULL, run_thread, &position_monitor);
-...
      * @brief Starts the server running (starts an infinite loop)
      */
     int ColonetServer::run_server() {
       //add the socket that you will listen to connections on to the connection pool
       connection_pool->add_new_socket_to_pool(listen_socket);
       int accept_socket = 0;
-...
+      }
       while(1) {
         //sleep for a little bit so this program doesn't hog cpu
         usleep(10000);
         //tell the connection pool to look at the file descriptors and see which ones are ready
         connection_pool->perform_select(listen_socket);
         //either no descriptors are ready or there was an error
-...
           continue;
+        }
         //check to see if a new client is trying to connect
         if (connection_pool->is_socket_ready_to_read(listen_socket)) {
           printf("Something is trying to connect...\n");
           //accept the connection
           if ((accept_socket = accept(listen_socket, (struct sockaddr*) &client_addr, &client_addr_size)) < 0) {
             if (errno == EMFILE) {
               printf("\tWhen attempting to accept a connection, reached the per process limit of file descriptors."
                 "  Dropping the new connection.\n");
     		 "  Dropping the new connection.\n");
               continue;
             } else {
               printf("\tThere was an error when attempting to accept a connection");
-...
           if (optionsG.logging_enabled) {
             char log_buffer[LOG_BUFFER_LENGTH];
             snprintf(log_buffer, LOG_BUFFER_LENGTH, "Client at address %s attempting to connect.",
               inet_ntoa(client_addr.sin_addr));
     		 inet_ntoa(client_addr.sin_addr));
             logger->log_string(LOG_TYPE_CONNECT, log_buffer);
+          }
           //add the new client to the connection pool
           if (connection_pool->add_client(accept_socket) < 0) {
             printf("\tThere was an error when trying to add a client to the connection pool.");
             continue;
-...
+          }
+        }
         //check all the clients in the connection pool
         if (connection_pool->check_clients() < 0) {
           printf("\tThere was an error trying to update the clients.");
           continue;
-...
+    }
     /**
     * @param source - ID of robot that message is from.
     * @param dest - ID of internet client to send message to.
     * @param data - Data to send to internet client.
     * @param len - Length of the data param.
     */
      * @brief when the server receives a new wireless message, it calls this function to process it
+     *
      * @param source - ID of robot that message is from.
      * @param dest - ID of internet client to send message to.
      * @param data - Data to send to internet client.
      * @param len - Length of the data param.
      */
     int ColonetServer::process_received_wireless_message(int dest, char* data, int len) {
       //try to pass the robot's response onto the client it wanted to respond to
       if (connection_pool->write_to_client(dest, data, len) == ERROR_INVALID_CLIENT_ID) {
         printf("The robot wanted to pass the data to a client not in the pool.\n");
         return -1;
-...
         printf("Logging disabled.\n");
+      }
       //initialize the wireless library giving it the port and the log file name
       if (colonet_wl_init(optionsG.wireless_port, log_filename) != 0) {
         fprintf(stderr, "ERROR - colonet_wl_init failed.\n");
         return -1;
+      }
       //call the function that will start the thread that will listen for wireless messages
       if (colonet_wl_run_listener_thread()) {
         fprintf(stderr, "%s: colonet_wl_run_listener_thread failed.\n", __FUNCTION__);
         return -1;
-...
       return 0;
+    }
     /**
      * @brief returns the position monitor
      */
     PositionMonitor* ColonetServer::getPositionMonitor() {
       return &position_monitor;
+    }

Also available in: Unified diff

Project

General

Profile

Colony

Revision 618