Colony

/** @file colonet_wireless.h

 *

 * @brief Wireless library for communicating with colony robots

 *

 * @author Eugene Marinelli

 * @date 10/26/06

 *

 * @bug gtkterm must be running for the library to work...

 */

/*

   NOTES

   Things colonet server must be able to do with wireless:

   - Send a commmand/request packet to a specific robot

   - Accept packets from robots - need a "SIGNAL"-like function and a

   message queue

   - Only send stuff when we have the token

   - Pass token along to the next robot

   - Join ad-hoc network automatically

*/

#ifndef COLONET_WIRELESS_H_

#define COLONET_WIRELESS_H_

#include <queue>

#include <colonet_defs.h>

using namespace std;

typedef int(*MsgHandlerFunction)(ColonetPacket*);

/* takes src, msg_type, req_code, data */

class ColonetWireless {

 public:

  /** @brief Constructor - creates a new instance of ColonetWireless

   * and initializes values

   *

   * @param wl_port Either SERIAL_PORT or USB_PORT (as defined in COLONET_DEFS)

   * @param log_filename Path to log file - outputs all raw data on the network

   * If set to NULL, logging is disabled.

   * @param msg_handler Function to be called when a packet is received.

   * Must take a ColonetPacket as an argument (see defn of MsgHandlerFunction)

   * @param join_token_ring true if server should join the token ring,

   * false if it should just observe the network

   *

   * @return new ColonetWireless object

   */

  ColonetWireless(char* wl_port, MsgHandlerFunction message_handler_,

                  char* log_filename_, bool join_token_ring_,

                                                                        bool ignore_token_);

  /**

   * @brief Deconstructor - frees queue and other stuff

   */

  ~ColonetWireless(void);

  /** @brief Spawns a thread which reads data from the hardware interface

   * with the colony (either a dongle or a robot programmed to relay data)

   * and runs msg_handler when a full packet is received

   *

   * @return pointer to the thread

   */

  pthread_t* run_listener_thread(void);

  /** @brief Adds a message to the message sending queue.  One message in the

   * queue is sent each time the server receives the token.  Therefore

   * there might be a delay on the order of seconds before the packet is

   * actually sent.

   *

   * @param msg_dest ID of the robot message is being sent to.  To send to

   * all robots, use GLOBAL_DEST

   * @param msg_type Type of message being sent.  Should be either

   * COLONET_COMMAND or COLONET_REQUEST

   * @param msg_code The message code/id telling the robot what to do or

   * return.  For example this might be ORB_SET

   * @param data Pointer to a buffer of data to be sent.  Assumed to

   * point to valid data.  An invalid pointer will cause a segfault.

   *

   * @return -1 on failure, 0 on success

   */

  int send(unsigned char msg_dest, unsigned char msg_type,

           unsigned char msg_code, unsigned char* data);

  /** @brief Clears the message queue

   * @return void

   */

  void clear_message_queue(void);

  /** @brief Handles a complete packet.

   *

   * @param pkt A complete packet to which we should react

   *

   * @return 0 on success, -1 on failure

   */

  int handle_packet(ColonetPacket* pkt);

  //the rest of these would ideally be private, but must be accessed by

  //the listen function

  ColonetPacket* create_packet(unsigned char token_src_,

                               unsigned char token_dest_,

                               unsigned char msg_dest,

                               unsigned char msg_type,

                               unsigned char msg_code,

                               unsigned char* data, unsigned char num_robots_);

  ColonetPacket* build_packet(unsigned char* buf, int len);

  int send_packet(ColonetPacket* pkt);

  char wireless_port[80];

  unsigned char token_src; //id of server in token ring

  unsigned char token_dest; //id of "dest" robot in token ring

  unsigned char num_robots;

 private:

  queue<ColonetPacket*> outbox;

  bool join_token_ring;

  MsgHandlerFunction message_handler;

  bool have_token;

  bool connected; //whether we are connected to the robot

  bool first_packet_sent;

  bool logging_enabled;

        bool ignore_token;

  char log_filename[80];

  int transmit_queued_message(void);

  int join_network(ColonetPacket* pkt);

  void update_network_props(ColonetPacket* pkt);

  unsigned char compute_checksum(ColonetPacket* pkt);

  void print_packet(ColonetPacket* pkt);

  int handle_error(ColonetPacket* pkt);

  int log_packet(ColonetPacket* pkt);

};

#endif