Пример #1
0
int main(int argc, char ** argv)
{
  struct sigaction sa;
  bzero(&sa, sizeof(sa));
  sa.sa_handler = handle;
  if (0 != sigaction(SIGINT, &sa, 0)) {
    err(EXIT_FAILURE, "sigaction");
  }
  
  // Before we attempt to read any tasks and skills from the YAML
  // file, we need to inform the static type registry about custom
  // additions such as the HelloGoodbyeSkill.
  Factory::addSkillType<uta_opspace::HelloGoodbyeSkill>("uta_opspace::HelloGoodbyeSkill");
  
  ros::init(argc, argv, "wbc_m3_ctrl_servo", ros::init_options::NoSigintHandler);
  parse_options(argc, argv);
  ros::NodeHandle node("~");
  
  controller.reset(new ControllerNG("wbc_m3_ctrl::servo"));
  param_cbs.reset(new ParamCallbacks());
  Servo servo;
  try {
    if (verbose) {
      warnx("initializing param callbacks");
    }
    registry.reset(factory->createRegistry());
    registry->add(controller);
    param_cbs->init(node, registry, 1, 100);
    
    if (verbose) {
      warnx("starting servo with %lld Hz", servo_rate);
    }
    actual_servo_rate = servo_rate;
    servo.start(servo_rate);
  }
  catch (std::runtime_error const & ee) {
    errx(EXIT_FAILURE, "failed to start servo: %s", ee.what());
  }
  
  warnx("started servo RT thread");
  ros::Time dbg_t0(ros::Time::now());
  ros::Time dump_t0(ros::Time::now());
  ros::Duration dbg_dt(0.1);
  ros::Duration dump_dt(0.05);
  
  while (ros::ok()) {
    ros::Time t1(ros::Time::now());
    if (verbose) {
      if (t1 - dbg_t0 > dbg_dt) {
	dbg_t0 = t1;
	servo.skill->dbg(cout, "\n\n**************************************************", "");
	controller->dbg(cout, "--------------------------------------------------", "");
	cout << "--------------------------------------------------\n";
	jspace::pretty_print(model->getState().position_, cout, "jpos", "  ");
	jspace::pretty_print(model->getState().velocity_, cout, "jvel", "  ");
	jspace::pretty_print(model->getState().force_, cout, "jforce", "  ");
	jspace::pretty_print(controller->getCommand(), cout, "gamma", "  ");
	Vector gravity;
	model->getGravity(gravity);
	jspace::pretty_print(gravity, cout, "gravity", "  ");
	cout << "servo rate: " << actual_servo_rate << "\n";
      }
    }
    if (t1 - dump_t0 > dump_dt) {
      dump_t0 = t1;
      controller->qhlog(*servo.skill, rt_get_cpu_time_ns() / 1000);
    }
    ros::spinOnce();
    usleep(10000);		// 100Hz-ish
  }
  
  warnx("shutting down");
  servo.shutdown();
}
Пример #2
0
int main(int argc, char ** argv)
{
  struct sigaction sa;
  bzero(&sa, sizeof(sa));
  sa.sa_handler = handle;
  if (0 != sigaction(SIGINT, &sa, 0)) {
    err(EXIT_FAILURE, "sigaction");
  }
  
  // Before we attempt to read any tasks and skills from the YAML
  // file, we need to inform the static type registry about custom
  // additions such as the HelloGoodbyeSkill.
  Factory::addSkillType<uta_opspace::RigidTf>("uta_opspace::RigidTf");
  Factory::addSkillType<uta_opspace::SurfaceMotion>("uta_opspace::SurfaceMotion");
  Factory::addSkillType<uta_opspace::SurfaceOriMotion>("uta_opspace::SurfaceOriMotion");
  Factory::addSkillType<uta_opspace::AttachSurface>("uta_opspace::AttachSurface");
  Factory::addSkillType<uta_opspace::KnownAttachSurface>("uta_opspace::KnownAttachSurface");
  Factory::addSkillType<uta_opspace::JointMultiPos>("uta_opspace::JointMultiPos");
  
  
  ros::init(argc, argv, "wbc_fri_servo", ros::init_options::NoSigintHandler);
  parse_options(argc, argv);
  ros::NodeHandle node("~");

  jspace::Vector command(Vector::Zero(7));
  pos_prev = Vector::Zero(7);
  //Need to setup the transform here
  //Should be changed to a parameter in TAO
  jspace::Matrix R(Matrix::Identity(3,3));
  R(0,0) = 0.9221;
  R(0,1) = -0.0576;
  R(0,2) = -0.3827;
  R(1,0) = 0.3791;
  R(1,1) = -0.0643;
  R(1,2) = 0.9231;
  R(2,0) = -0.0778;
  R(2,1) = -0.9963;
  R(2,2) = -0.0374;
  jspace::Matrix d(Matrix::Zero(3,1));
  /*d(0,0) = -1.0877;
  d(1,0) = 2.8646;
  d(2,0) = 0.0528;*/
  d(0,0) = -1.0877;
  d(1,0) = 3.0146;
  d(2,0) = 0.0428;
  
  controller.reset(new ControllerNG("wbc_fri::servo"));
  param_cbs.reset(new ParamCallbacks());
  Servo servo;
  if (verbose) {
    warnx("initializing param callbacks");
  }
  registry.reset(factory->createRegistry());
  registry->add(controller);
  param_cbs->init(node, registry, 1, 100);

  //Initial message
  ros::Publisher torque_pub = node.advertise<JointEfforts>("/JointEffortCommand", 1000);
  ros::Publisher jointimp_pub = node.advertise<FriJointImpedance>("/FriJointImpedance", 1000);
  ros::Subscriber state_sub = node.subscribe("/JointState", 1000, stateCallback);
  ros::Subscriber mass_sub = node.subscribe("/MassMatrix", 1000, massCallback);
  ros::Subscriber fristate_sub = node.subscribe("/FriJointState", 1000, friCallback);
  JointEfforts torque_msg;
  FriJointImpedance jointimp_msg;

  for (size_t ii(0); ii<7; ++ii) {
	torque_msg.efforts.push_back(0.0);
	jointimp_msg.stiffness[ii] = 0.0;
	jointimp_msg.damping[ii] = 0.0;
  }
  torque_pub.publish(torque_msg);
  jointimp_pub.publish(jointimp_msg);



  //UDP camera- with option of no camera
  Position3d rawCamData[56];
  jspace::Matrix camData;

  //EDIT ME to actual camera address
  char local_cam_port [10];
  sprintf(local_cam_port, "%d", CLIENT_PORT+2);
  char cam_port [10];
  sprintf(cam_port, "%d", CS8C_PORT+2);
  UdpOSI cameraUDP("50000", "192.168.1.39", cam_port, 0);
  int bytes =0;
  if (cam) {
    bytes = cameraUDP.recvPacket((char*)rawCamData, sizeof(rawCamData));
    if (bytes<1) {
      fprintf(stderr, "Error receiving data from camera");
	 servo.cleanup();
	 return 0;
    }
    camData = Matrix::Zero(bytes/sizeof(Position3d),3);
    for (size_t ii=0; ii < bytes/sizeof(Position3d); ++ii){
      camData(ii,0) = rawCamData[ii].x*1e-3;
      camData(ii,1) = rawCamData[ii].y*1e-3;
      camData(ii,2) = rawCamData[ii].z*1e-3;
    } 
    Matrix temp(R * camData.transpose() + d*Matrix::Ones(1,bytes/sizeof(Position3d)));
    state.camData_ = temp.transpose();
    cout <<"Recieved initial camera data\n";
    }  

  /*
  //Visualization
  visinfo info;
  UdpOSI visUDP( "57860", const_cast<char*>(CS8C_IPADDR), "50000", 0);*/
  

  int status = servo.init(state);
  if (0!= status) {
    fprintf(stderr, "init callback returned %d\n", status);
    servo.cleanup();
    return 0;
  }

  ros::Time dbg_t0(ros::Time::now());
  ros::Time dump_t0(ros::Time::now());
  ros::Duration dbg_dt(0.1);
  ros::Duration dump_dt(0.05);
 //ros::Rate loop_rate(10);
  ros::Time begin(ros::Time::now());
  while (ros::ok()) {

    //UDP camera in and out
    if (cam) {
      bytes = cameraUDP.recvPacket((char*)rawCamData, sizeof(rawCamData));
      if (bytes <1) {
	fprintf(stderr,"Error: no camera data recieved");
	servo.cleanup();
	return 0;
      }    
      for (size_t ii=0; ii < bytes/sizeof(Position3d); ++ii){
	camData(ii,0) = rawCamData[ii].x*1e-3;
	camData(ii,1) = rawCamData[ii].y*1e-3;
	camData(ii,2) = rawCamData[ii].z*1e-3;
      }
      Matrix temp(R * camData.transpose() + d*Matrix::Ones(1,bytes/sizeof(Position3d)));
      state.camData_ = temp.transpose();
    }  

    /*
    //Vis out
    for (size_t ii(0); ii<6 ; ++ii) {
      info.q[ii] = state.position_[ii];
    }
    Skill::task_table_t const * tasks(servo.skill->getTaskTable());
    info.R[0] = 0.1;
    info.T[0] = 0.4;//No longer automatic-> should not be manual
    if (cam) {
      for (size_t ii(0); ii < state.camData_.rows(); ++ii) {
	for (size_t jj(0); jj < state.camData_.cols(); ++jj) {
	  info.sp[ii][jj] = state.camData_(ii,jj);
	}
      }
    }

    info.eedes[0] = 0.0;
    info.eedes[1] = 0.0;
    info.eedes[2] = 0.0;
    
    info.cp[0] = 0.0;
    info.cp[1] = 0.0;
    info.cp[2] = 0.0;


    bytes = visUDP.sendPacket((char*)&info, sizeof(info));
     */

    status = servo.update(state, command);
    if (0 != status) {
      fprintf(stderr, "update callback returned %d\n", status);
      servo.cleanup();
      return 0;
    }

    for (size_t ii(0); ii<7; ++ii) {
      if (isnan(command[ii])) {
	torque_msg.efforts[ii] = 0;
      }
      else {
          torque_msg.efforts[ii] = command[ii];
      }
    }

    torque_pub.publish(torque_msg);
    jointimp_pub.publish(jointimp_msg);
    ros::Time t1(ros::Time::now());
    if (verbose) {
      if (t1 - dbg_t0 > dbg_dt) {
	dbg_t0 = t1;
	servo.skill->dbg(cout, "\n\n**************************************************", "");
	controller->dbg(cout, "--------------------------------------------------", "");
	cout << "--------------------------------------------------\n";
	jspace::pretty_print(model->getState().position_, cout, "jpos", "  ");
	jspace::pretty_print(controller->getCommand(), cout, "gamma", "  ");
	jspace::pretty_print(model->getState().camData_, cout, "cam", "  ");
      }
    }
    if (t1 - dump_t0 > dump_dt) {
      dump_t0 = t1;
      controller->qhlog(*servo.skill, ros::Duration(t1-begin).toSec()*1000);
    }
    ros::spinOnce();
    //loop_rate.sleep();
  }
  
  warnx("shutting down");
  ros::shutdown();
  servo.cleanup();
  //cameraUDP.~UdpOSI();
}