ax2550.h

Go to the documentation of this file.

#ifndef AX2550_AX2550_H
#define AX2550_AX2550_H

#include <string>
#include <sstream>
#include <serial/serial.h>
// #define SERIAL_LISTENER_DEBUG 1
#include <serial/utils/serial_listener.h>

// Handy macro for throwing exceptions
#define AX2550_THROW(exceptionClass,message) throw \
  exceptionClass(__FILE__,__LINE__,(message))

namespace ax2550 {

  typedef boost::function<void(const std::string&)> LoggingCallback;

  typedef boost::function<void()> WatchDogCallback;

  class AX2550 {
  public:
    AX2550 (std::string port = "");
    ~AX2550 ();

    void connect (std::string port = "");

    void disconnect ();

    bool isConnected ();

    bool issueCommand (const std::string &command, std::string &fail_why);

    void move (double speed, double direction);

    void queryEncoders (long &encoder1, long &encoder2, bool relative = false);

    WatchDogCallback watch_dog_callback;
    LoggingCallback debug;
    LoggingCallback info;
    LoggingCallback warn;
  private:
    // Serial stuff
    std::string port_;
    serial::Serial * serial_port_;
    serial::utils::SerialListener serial_listener_;
    // Filter stuff
    void setupFilters_ ();
    serial::utils::BufferedFilterPtr encoders_filt_;
    void watchDogCallback_ (const std::string&);
    serial::utils::FilterPtr watch_dog_filt_;
    serial::utils::BufferedFilterPtr ack_nak_filt_;
    // serial::utils::BufferedFilterPtr rc_msg_filt_;
    // State stuff
    void sync_ ();
    bool connected_;
    bool synced_;
    boost::mutex mc_mutex;
  };

  class ConnectionException : public std::exception {
    std::string file_;
    int line_;
    const char* e_what_;
  public:
    ConnectionException (std::string file, int line, const char * description)
    : file_(file), line_(line), e_what_ (description) {}
    virtual ~ConnectionException() throw() {}

    virtual const char* what () const throw () {
      std::stringstream ss;
      ss << "Connection Exception: " << e_what_;
      ss << ", file " << file_ << ", line " << line_ << ".";
      return ss.str ().c_str ();
    }
  };

  class SynchronizationException : public std::exception {
    std::string file_;
    int line_;
    const char* e_what_;
  public:
    SynchronizationException (std::string file, int line,
                              const char * description)
    : file_(file), line_(line), e_what_ (description) {}
    virtual ~SynchronizationException() throw() {}

    virtual const char* what () const throw () {
      std::stringstream ss;
      ss << "Synchronization Exception: " << e_what_;
      ss << ", file " << file_ << ", line " << line_ << ".";
      return ss.str ().c_str ();
    }
  };

  class CommandFailedException : public std::exception {
    std::string file_;
    int line_;
    const char* e_what_;
  public:
    CommandFailedException (std::string file, int line,
                              const char * description)
    : file_(file), line_(line), e_what_ (description) {}
    virtual ~CommandFailedException() throw() {}

    virtual const char* what () const throw () {
      std::stringstream ss;
      ss << "Command Failed Exception: " << e_what_;
      ss << ", file " << file_ << ", line " << line_ << ".";
      return ss.str ().c_str ();
    }
  };

} // namespace ax2550

#endif