越疆M1-B1 ROS下使用TCP加导航加红外校准加视觉以及机械臂动作

 越疆M1-B1 ROS下使用TCP加导航加红外校准加视觉以及机械臂动作

#include <ros/ros.h>
#include "ros/console.h"
#include <tf/transform_listener.h>
#include <nav_msgs/Odometry.h>
#include <string.h>
#include <move_base_msgs/MoveBaseAction.h>
#include <actionlib/client/simple_action_client.h>
#include <cmath>
#include <unistd.h>
#include <iostream>
#include <sys/types.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <std_msgs/Bool.h>
#include "iostream"
#include "ar_track_alvar_msgs/AlvarMarkers.h"
#include "stdio.h"
#include "cv.h"
#include "opencv2/opencv.hpp"
#include "cv_bridge/cv_bridge.h"

#include "std_msgs/String.h"
#include "std_msgs/Int16.h"
#include "dobot/SetCmdTimeout.h"
#include "dobot/SetQueuedCmdClear.h"
#include "dobot/SetQueuedCmdStartExec.h"
#include "dobot/SetQueuedCmdForceStopExec.h"
#include "dobot/GetDeviceVersion.h"

#include "dobot/SetEndEffectorParams.h"
#include "dobot/SetPTPJointParams.h"
#include "dobot/SetPTPCoordinateParams.h"
#include "dobot/SetPTPJumpParams.h"
#include "dobot/SetPTPCommonParams.h"
#include "dobot/SetPTPCmd.h"
#include "dobot/SetEndEffectorGripper.h"
#include "dobot/SetHOMECmd.h"
#include "dobot/SetHOMEParams.h"
#include "dobot/SetIODO.h"
#include "dobot/GetAlarmsState.h"
#include "dobot/ClearAllAlarmsState.h"
#include "dobot/SetArmOrientation.h"

using namespace std;
using namespace cv;


相机区域
//机械臂拍照点位
float picture_x = 237.633
    , picture_y = 60.6892
    , picture_z = 230.7879
;

//标定像素坐标 3个点
float cam_x1 = 159.387
    , cam_y1 = -21.6633

    , cam_x2 = 34.927
    , cam_y2 = 40.634

    , cam_x3 = 165.001
    , cam_y3 = 81.35
;

//标定机械包坐标 3个点
float rob_x1 = 327.7778
    , rob_y1 = -78.2467

    , rob_x2 = 357.0341
    , rob_y2 = 43.5529
    
    , rob_x3 = 250.8334
    , rob_y3 = -21.1507
;

//标定像素坐标 3个点
Mat A = (Mat_<float>(3,3) <<
	cam_x1, cam_y1, 1,
	cam_x2, cam_y2, 1,
	cam_x3, cam_y3, 1
	); //3×3
	
//标定机械包坐标 3个点
Mat B = (Mat_<float>(3,3) <<
	rob_x1, rob_y1, 1,
	rob_x2, rob_y2, 1,
	rob_x3, rob_y3, 1
	); //3×3

//矩阵参数
Mat X;


//相机得到图像的坐标和ID
int   ar_ID;
float cam_getX;
float cam_getY;
	
//机械臂最后执行的点位
float X_pose;
float Y_pose;
float Z_pose = 150.9403;
相机区域

//导航结束后成功和失败的flag
int navigation_flag = 0;
//TCP接收到的消息
string TCP_Receive;
//红外校准发布器
ros::Publisher recharge_pub;
//红外校准数据变量
int recharge_status = 0;

//服务注册
ros::ServiceClient client;
ros::ServiceClient clientPTP;
ros::ServiceClient clientIO;
ros::ServiceClient clientClearState;

//函数声明
//导航部分
void navigation(actionlib::SimpleActionClient<move_base_msgs::MoveBaseAction> &ac, geometry_msgs::Point &point, geometry_msgs::Quaternion &quaternion);
//TCP服务器函数
void socket_server(char* message);
//回充校准函数
void jiaozhun_recharge(ros::NodeHandle &n,ros::Publisher recharge_pub);
//回调函数获取红外校准数据
void sub_recharge_status_callback(const std_msgs::Int16::ConstPtr& status_msg);
//视觉回调函数获取二维码的位置
void sub_ar_callback(const ar_track_alvar_msgs::AlvarMarkers::ConstPtr& msg);
//视觉计算处理部分
void vision_processor(ros::NodeHandle &n);
//执行 PTP 指令
void setPTP(uint8_t ptpMode ,float x, float y, float z, float r,ros::NodeHandle &n);
//设置 I/O 输出电平
void setIO(uint8_t address, uint8_t level, bool isQueued, ros::NodeHandle &n);
//获取系统报警状态
int getState(ros::NodeHandle &n);
//清除系统所有报警
int ClearState(ros::NodeHandle &n);
//矩阵变换函数(只是开始调用一次，求出矩阵参数X)
Mat solve_equation(Mat A, Mat B);
//M1抓取功能
void M1_pick(ros::NodeHandle &n);

/函数实现部分

//导航部分
void navigation(actionlib::SimpleActionClient<move_base_msgs::MoveBaseAction> &ac, geometry_msgs::Point &point, geometry_msgs::Quaternion &quaternion)
{
	//设置我们要机器人走的几个点。
	geometry_msgs::Pose pose_list;

	pose_list.position = point;
	pose_list.orientation = quaternion;
	

 	 ROS_INFO("Waiting for move_base action server...");
  	//等待60秒以使操作服务器可用
  	if(!ac.waitForServer(ros::Duration(60)))
  	{
   	 	ROS_INFO("Can't connected to move base server");
		exit(-1);
 	 }
 	 ROS_INFO("Connected to move base server");
 	 ROS_INFO("Starting navigation test");

         //初始化航点目标
         move_base_msgs::MoveBaseGoal goal1;

         //使用地图框定义目标姿势
         goal1.target_pose.header.frame_id = "map";

         //将时间戳设置为“now”
         goal1.target_pose.header.stamp = ros::Time::now();

        //将目标姿势设置为第i个航点
        goal1.target_pose.pose = pose_list;

        //让机器人向目标移动
        //将目标姿势发送到MoveBaseAction服务器
        ac.sendGoal(goal1);

        //等3分钟到达那里
        bool finished_within_time1 = ac.waitForResult(ros::Duration(180));

        //如果我们没有及时赶到那里，就会中止目标
        if(!finished_within_time1)
        {
            ac.cancelGoal();
            ROS_INFO("Timed out achieving goal");
	    navigation_flag = 0;
        }
	else
        {
            //We made it!
            if(ac.getState() == actionlib::SimpleClientGoalState::SUCCEEDED)
            {
                ROS_INFO("Goal succeeded!");
		navigation_flag =1;
            }
            else
            {
                ROS_INFO("The base failed for some reason");
		navigation_flag = 0;
            }
        }
}

//TCP服务器函数
void socket_server(char* message)
{
/*服务端：
1、socket（）获得一个sockfd。注意第二个参数必须SOCK_STREAM.
2、准备通信地址（必须服务器的）
3、bind（）绑定。（开放了端口，允许客户端连接）
4、监听客户端 listen()函数
5、等待客户端的连接 accept(),返回用于交互的socket描述符
6、使用第5步返回sockt描述符，进行读写通信。
7、关闭sockfd。
*/

	//1.socket（）获得一个sockfd。注意第二个参数必须SOCK_STREAM.
    	//第一个参数是地址描述符，常用AF_INET（表示IPV4）
   	//第三个参数是套接口所用的协议，不想调用就用0
	int socket_fd = socket(AF_INET,SOCK_STREAM,0);
	if(socket_fd == -1)
	{
		cout<<"socket faild!"<<endl;
		exit(-1);
	}

	//2.准备通讯地址（必须是服务器的）
    	//sin_family：协议簇一般用AF_INET（表示IPV4）
   	//sin_port: 端口，一般用htons(填端口：数字随便要和服务器的一样)将十进制转为网络进制
    	//sin_addr.s_addr:一般用inet_addr(" "填IP地址)或者htonl(INADDR_ANY)直接设置为本地ip
	struct sockaddr_in addr;
	addr.sin_family = AF_INET;
	addr.sin_port = htons(10004);
	addr.sin_addr.s_addr = htonl(INADDR_ANY);
	
	//3.bind() 绑定。（开发了端口，允许客服端链接）
    	//参数一：0的返回值（socket_fd）
   	//参数二：(struct sockaddr*)&addr 前面结构体，即地址
   	//参数三: addr结构体的长度
	int res = bind(socket_fd, (struct sockaddr*)&addr, sizeof(addr));
	if(res == -1)
	{
		cout<<"binf fiald!"<<endl;
		exit(-1);
	}

	cout<<"bind ok"<<endl;

    	//4.监听客户端 listen()函数
    	//参数二：进程上限，一般小于30
	listen(socket_fd,30);
	
	//5.等待客户端的连接 accept(),返回用于交互的socket描述符
	struct sockaddr_in client;
	socklen_t len = sizeof(client);
	int fd = accept(socket_fd,(struct sockaddr*)&client, &len);
	if(fd == -1)
	{
		cout<<"aceept fiald!"<<endl;
		exit(-1);
	}
	
	//6.使用第5步返回sockt描述符，进行读写通信。
	char *ip = inet_ntoa(client.sin_addr);
	cout<<"client ["<<ip<<"] connect !"<<endl;

	char buffer[255] = {};
	//第一个参数：accept 返回的文件描述符
    	//第二个参数：存放读取的内容
    	//第三个参数：内容的大小 
	int size = read(fd,buffer,sizeof(buffer));
   
	cout<<"accept bet:"<<size<<endl;
	cout<<"cantent:"<<buffer<<endl;
	//接受到信息并赋值给全局变量
	TCP_Receive = buffer;
	//反馈给客户端信息
	write(fd,message,7);	

	//7.关闭sockfd。
	close(fd);
	close(socket_fd);	
}

//回充校准函数
void jiaozhun_recharge(ros::NodeHandle &n,ros::Publisher recharge_pub)
{
	std_msgs::Int16 msg1;
	msg1.data = 1;
	std_msgs::Int16 msg0;
	msg0.data = 0;	
	//启动校准发布3次
	for(int i =0;i<3;i++)
	{
		recharge_pub.publish(msg1);  //启动红外校准
	}
	//订阅校准状态,完成后就停止回充
	while(recharge_status != 2 && recharge_status != 3 && recharge_status != 4 && ros::ok())
	{
		cout<<"开始订阅对准状态:"<<recharge_status<<endl;
		//订阅红外校准状态，成功后返回值为int 3
	    	ros::Subscriber sub1 = n.subscribe("/recharge_status", 1, sub_recharge_status_callback);
		ros::Rate loop_rate(0.5);
		int i = 1;
		while(i >= 0 && ros::ok())
		{
			ros::spinOnce();
			i = i-1;
			//cout<<"call :"<<i<<endl;
			loop_rate.sleep();
		}		
	}
	recharge_pub.publish(msg0);  //关闭红外校准
	cout<<"校准结束！"<<endl;
}

//回充回调函数获取红外校准数据
void sub_recharge_status_callback(const std_msgs::Int16::ConstPtr& status_msg)
{
	cout<<"回调函数处理数据:"<<status_msg->data<<endl;
	recharge_status = status_msg->data;
}

//矩阵变换函数(只是开始调用一次，求出矩阵参数X)
Mat solve_equation(Mat A, Mat B)
{
	//矩阵转换公式
	solve(A, B, X, CV_SVD);
	cout<<"矩阵转换完成,参数X："<<endl<<X<<endl;
	return X;
}

//视觉计算处理部分
void vision_processor(ros::NodeHandle &n)
{
	//订阅相机获取二维码的位置
	ros::Subscriber sub2 = n.subscribe("/ar_pose_marker", 1, sub_ar_callback);
	ros::Rate loop_rate(0.5);
	int i = 1;
	while(i >= 0 && ros::ok())
	{
		ros::spinOnce();
		i = i-1;
		//cout<<"call :"<<i<<endl;
		loop_rate.sleep();
	}


}

//视觉回调函数获取二维码的位置
void sub_ar_callback(const ar_track_alvar_msgs::AlvarMarkers::ConstPtr& msg)
{
 	cout<<"回调函数获取二维码的位置"	<<endl;
	//if((msg->markers.size() > 0) && (msg->markers[0].id < 30) )
	if(msg->markers.size() > 0 && (msg->markers[0].id < 30) )
	{
	ar_ID = msg->markers[0].id;
	cam_getX = msg->markers[0].pose.pose.position.x*1000;
	cam_getY = msg->markers[0].pose.pose.position.y*1000;

	cout<<"获取二维码的位置"<<endl<<"二维码ID:"<<ar_ID<<endl;
	cout<<"Point position:"<<endl;
	cout<<"cam_getX: "<<cam_getX<<endl;
	cout<<"cam_getY: "<<cam_getY<<endl;
	cout<<"-----------"<<endl;
	} 

	//获取机器人抓取位置
	//相机得到图像的坐标来计算机械臂点位
	Mat cam_pose = (Mat_<float>(1,3) << cam_getX, cam_getY, 1);
	//通过矩阵变换得到机器人抓取的物理坐标
	Mat rot_pose = cam_pose*X; 
	
	//机械臂抓取点位输出
	X_pose = rot_pose.at<float>(0);
	Y_pose = rot_pose.at<float>(1);
	cout<<"抓取点位："<<endl;
	cout<<"X_pose:"<<X_pose<<endl;
	cout<<"Y_pose:"<<Y_pose<<endl;	

}


/机械臂区域
//清除系统所有报警
int ClearState(ros::NodeHandle &n) 
{
	clientClearState = n.serviceClient<dobot::ClearAllAlarmsState>("/DobotServer/ClearAllAlarmsState");
	dobot::ClearAllAlarmsState srv;
	clientClearState.call(srv);
}

//获取系统报警状态
int getState(ros::NodeHandle &n)
{
	dobot::GetAlarmsState srv;
	client.call(srv);
	cout<<"State result: "<<srv.response.result<<endl;
	cout<<"size_alarmsState:"<<srv.response.alarmsState.size()<<endl;
	for(int i = 0; i<srv.response.alarmsState.size(); i++)
	{
		cout<<srv.response.alarmsState[i];
	}
	cout<<"end  "<<endl;
	//cout<<"State alarmsState: "<<srv.response.alarmsState[0]<<endl;
}

//执行 PTP 指令
void setPTP(uint8_t ptpMode ,float x, float y, float z, float r, ros::NodeHandle &n)
{
	clientPTP = n.serviceClient<dobot::SetPTPCmd>("/DobotServer/SetPTPCmd");
	dobot::SetPTPCmd srv;
	srv.request.ptpMode = ptpMode;
        srv.request.x = x;
        srv.request.y = y;
        srv.request.z = z;
        srv.request.r = r;
        clientPTP.call(srv);   
}

//设置 I/O 输出电平
void setIO(uint8_t address, uint8_t level, bool isQueued, ros::NodeHandle &n)
{
	clientIO = n.serviceClient<dobot::SetIODO>("/DobotServer/SetIODO");
	dobot::SetIODO IO;
	IO.request.address = address;
	IO.request.level = level;
	IO.request.isQueued = isQueued;
	clientIO.call(IO);
	ROS_INFO("SetIODO%d ok, %d", IO.request.address , IO.response.queuedCmdIndex);
}

//M1抓取功能
void M1_pick(ros::NodeHandle &n)
{
	//运行到抓取点位PTP
	setPTP(0 ,X_pose ,Y_pose ,Z_pose ,0 , n);

	//开启气泵setIO	
	setIO(18,0,1,n);
	setIO(17,1,1,n);

	//运行到拍照点位PTP
	setPTP(0 ,picture_x ,picture_y ,picture_z ,0 , n);

	//关闭气泵setIO	
	//setIO(18,1,1,n);
	//setIO(17,1,1,n);
	
	//睡眠8秒等待抓取完成
	sleep(8);	
}
/机械臂区域

int main(int argc, char** argv)
{
	ros::init(argc, argv, "send_goal");
	ros::NodeHandle n;
	
	//红外校准发布器
	recharge_pub = n.advertise<std_msgs::Int16>("/recharge_handle",10);
	//订阅move_base操作服务器
	actionlib::SimpleActionClient<move_base_msgs::MoveBaseAction> ac("move_base",true);

	//机械臂初始化
	// SetCmdTimeout
    client = n.serviceClient<dobot::SetCmdTimeout>("/DobotServer/SetCmdTimeout");
    dobot::SetCmdTimeout srv1;
    srv1.request.timeout = 3000;
    if (client.call(srv1) == false) {
        ROS_ERROR("Failed to call SetCmdTimeout. Maybe DobotServer isn't started yet!");
        return -1;
    }

    // Clear the command queue
    client = n.serviceClient<dobot::SetQueuedCmdClear>("/DobotServer/SetQueuedCmdClear");
    dobot::SetQueuedCmdClear srv2;
    client.call(srv2);

    // Start running the command queue
    client = n.serviceClient<dobot::SetQueuedCmdStartExec>("/DobotServer/SetQueuedCmdStartExec");
    dobot::SetQueuedCmdStartExec srv3;
    client.call(srv3);

    // Get device version information
    client = n.serviceClient<dobot::GetDeviceVersion>("/DobotServer/GetDeviceVersion");
    dobot::GetDeviceVersion srv4;
    client.call(srv4);
    if (srv4.response.result == 0) {
        ROS_INFO("Device version:%d.%d.%d", srv4.response.majorVersion, srv4.response.minorVersion, srv4.response.revision);
    } else {
        ROS_ERROR("Failed to get device version information!");
    }

    // Set PTP joint parameters
    do {
        client = n.serviceClient<dobot::SetPTPJointParams>("/DobotServer/SetPTPJointParams");
        dobot::SetPTPJointParams srv;

        for (int i = 0; i < 4; i++) {
            srv.request.velocity.push_back(100);
        }
        for (int i = 0; i < 4; i++) {
            srv.request.acceleration.push_back(100);
        }
        client.call(srv);
    } while (0);

    // Set PTP coordinate parameters
    do {
        client = n.serviceClient<dobot::SetPTPCoordinateParams>("/DobotServer/SetPTPCoordinateParams");
        dobot::SetPTPCoordinateParams srv;

        srv.request.xyzVelocity = 100;
        srv.request.xyzAcceleration = 100;
        srv.request.rVelocity = 100;
        srv.request.rAcceleration = 100;
        client.call(srv);
    } while (0);

    // Set PTP jump parameters
    do {
        client = n.serviceClient<dobot::SetPTPJumpParams>("/DobotServer/SetPTPJumpParams");
        dobot::SetPTPJumpParams srv;

        srv.request.jumpHeight = 20;
        srv.request.zLimit = 200;
        client.call(srv);
    } while (0);

    // Set PTP common parameters
    do {
        client = n.serviceClient<dobot::SetPTPCommonParams>("/DobotServer/SetPTPCommonParams");
        dobot::SetPTPCommonParams srv;

        srv.request.velocityRatio = 50;
        srv.request.accelerationRatio = 50;
        client.call(srv);
    } while (0);

	//设置机械臂方向
	client = n.serviceClient<dobot::SetArmOrientation>("/DobotServer/SetArmOrientation");
	dobot::SetArmOrientation srv_arm;
	srv_arm.request.tagArmOrientation = 0;
	srv_arm.request.isQueued =1;
	client.call(srv_arm);
	//运行到拍照点位PTP
	setPTP(0 ,picture_x ,picture_y ,picture_z ,0 ,n);
	//矩阵变换函数
	solve_equation(A, B);



	//服务器部分
	char* A = "这里是服务器！";
	socket_server(A);
	cout<<"TCP_Receive:"<<TCP_Receive<<endl;
	cout<<"len:"<<TCP_Receive.size()<<endl;

	//设置我们要机器人走的几个点。
	geometry_msgs::Point point;
	geometry_msgs::Quaternion quaternion;
	
	//导航部分
	point.x = 6.06296396255;
	point.y = 4.37734413147;
	point.z = 0;
	quaternion.x = 0.000;
	quaternion.y = 0.000;
	quaternion.z = 0.408275405284;
	quaternion.w = 0.912858802576;
	
	navigation(ac, point, quaternion);

	cout<<"--------------"<<endl;
	//启动回充
	jiaozhun_recharge(n, recharge_pub);

	//视觉识别部分
	vision_processor(n);
	//M1抓取部分
	M1_pick(n);


	point.x = 4.98605394363;
	point.y = 7.20435905457;
	point.z = 0;
	quaternion.x = 0.000;
	quaternion.y = 0.000;
	quaternion.z = 0.997947341797;
	quaternion.w = 0.0640398547754;

	navigation(ac, point, quaternion);	

	return 0;
	
			
}