IOTBot.h

Go to the documentation of this file.

#ifndef IOTBOT_H_
#define IOTBOT_H_
 
#include <ros/ros.h>
#include <sensor_msgs/Joy.h>
#include <geometry_msgs/Twist.h>
#include <std_msgs/Float32.h>
#include <std_msgs/Float32MultiArray.h>
#include <std_srvs/SetBool.h>
#include <std_srvs/Empty.h>
#include <sensor_msgs/Imu.h>
#include <geometry_msgs/PoseStamped.h>
#include <iostream>
#include "IOTShield.h"
 
using namespace std;
 
namespace iotbot
{
 
struct MotorParams
{
  float            gearRatio;
  float            encoderRatio;
  float            rpmMax;
  int              controlFrequency;
  float            kp;
  float            ki;
  float            kd;
  float            lowPassInputFilter;
  float            lowPassEncoderTicks;
  
  MotorParams()
  {
    gearRatio           = 0.f;
    encoderRatio        = 0.f;
    rpmMax              = 0.f;
    controlFrequency    = 16000;
    kp                  = 0.f;
    ki                  = 0.f;
    kd                  = 0.f;
    lowPassInputFilter  = 1.f;
    lowPassEncoderTicks = 1.f;
  }
 
  MotorParams(const MotorParams &p)
  {
    gearRatio           = p.gearRatio;
    encoderRatio        = p.encoderRatio;
    rpmMax              = p.rpmMax;
    controlFrequency    = p.controlFrequency;
    kp                  = p.kp;
    ki                  = p.ki;
    kd                  = p.kd;
    lowPassInputFilter  = p.lowPassInputFilter;
    lowPassEncoderTicks = p.lowPassEncoderTicks;
  }
};
 
struct ChassisParams
{
  float track;
  float wheelBase;
  float wheelDiameter;
  int   chFrontLeft;
  int   chFrontRight;
  int   chRearLeft;
  int   chRearRight;
  int   direction;
  int   enableYMotion;
 
  ChassisParams()
  {
    track               = 0.f;
    wheelBase           = 0.f;
    wheelDiameter       = 0.f;
    chFrontLeft         = 0;
    chFrontRight        = 0;
    chRearLeft          = 0;
    chRearRight         = 0;
    direction           = 0;
    enableYMotion       = 0;
  }
};
 
class IOTBot
{
public:
 
  IOTBot(ChassisParams &chassisParams, MotorParams &motorParams);
 
  ~IOTBot();
 
  void run();
 
private:
 
  bool enableCallback(std_srvs::SetBool::Request& request, std_srvs::SetBool::Response& response);
 
  bool calibrateCallback(std_srvs::Empty::Request& request, std_srvs::Empty::Response& response);
 
  bool fixIMUZAxisCallback(std_srvs::SetBool::Request& request, std_srvs::SetBool::Response& response);
 
  void joyCallback(const sensor_msgs::Joy::ConstPtr& joy);
 
  void velocityCallback(const geometry_msgs::Twist::ConstPtr& cmd);
 
  void controlMotors(float vFwd, float vLeft, float omega);
 
  ros::NodeHandle        _nh;
  ros::Subscriber        _subJoy;
  ros::Subscriber        _subVel;
  ros::ServiceServer     _srvEnable;
  ros::ServiceServer     _srvCali;
  ros::ServiceServer     _srvFix;
  ros::Publisher         _pubToF;
  ros::Publisher         _pubRPM;
  ros::Publisher         _pubVoltage;
  ros::Publisher         _pubCurrent;
  ros::Publisher         _pubIMU;
  ros::Publisher         _pubPose;
  ros::Publisher         _pubTemp;
  ChassisParams          _chassisParams;
  MotorParams*           _motorParams;
  IOTShield*             _shield;
 
  // revolutions per minute for each channel
  float                  _rpm[4];
 
  // maximum velocity [m/s]
  float                  _vMax;
 
  // maximum rotating rate [rad]
  float                  _omegaMax;
 
  // conversion from [m/s] to revolutions per minute [RPM]
  float                  _ms2rpm;
 
  // conversion from revolutions per minute [RPM] to [m/s]
  float                  _rpm2ms;
 
  // conversion from [rad/s] to revolutions per minute [RPM]
  float                  _rad2rpm;
 
  // conversion from revolutions per minute [RPM] to [rad/s]
  float                  _rpm2rad;
 
  // enable motion in direction of the y-axis. This is only meaningful for mecanum steering.
  bool                   _enableYMotion;
 
  // RGB values of lighting system
  unsigned char          _rgb[3];
 
  // time elapsed since last call
  ros::Time              _lastCmd;
};
 
} // end namespace
 
#endif