使用roboware-studio从零开始--实现RTK串口数据获取和解析

最新推荐文章于 2024-05-13 09:55:25 发布
最新推荐文章于 2024-05-13 09:55:25 发布
阅读量426 收藏 2
点赞数
分类专栏： ROS机器人编程实践 文章标签： c++ ubuntu vscode 自动驾驶
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35297051/article/details/130495281
版权

1、安装测试(去官网下载即可)

$ cd code/code20230501
$ ls 
roboware-studio_1.1.0-1514335284_amd64.deb
$ sudo apt-get update
$ sudo apt install -f
# $ sudo apt-get install ros-melodic-combined-robot-hw
$ sudo dpkg roboware-studio_1.1.0-1514335284_amd64.deb

安装完成后，在终端直接在终端输入打开软件：

$ roboware-studio

2、RoboWare使用

1、基本工作区创建

文件选项栏下选择新建工作区，这里工作区名字为catkin_ws_rtk_test1

 修改资源管理器为Released并 点击ROS--->构建  相当于执行catkin_init_workspace,生成了CMakeList文件的结果。

 

 2、创建功能包

右键src选择 新建ros包

命名为integratednavigation回车，发现自动生成了CMakeList.txt和package.xml

 3、配置功能包依赖

 输入roscpp std_msgs rospy message_generation 点enter

4、添加节点文件main.cpp

右击integratednavigation功能包，选择 新建src文件夹

右键integratednavigation/src 新建cpp文件 输入main.cpp  按住tab键  弹出的窗口选择加入到新的可执行文件中

 main.cpp

#include <ros/ros.h>
#include <iostream>
#include <unistd.h>
#include <string>
#include <vector>   
#include <sstream> 
#include <fstream>

#include <integratednavigation/integratedNavigationMsg.h>
#include "integratednavigation/uarta.h"

/* buffer of receive */
char recvBuff[1024];

/* data of type of string be converted to type of number */
template <typename Type>
Type stringToNum(const std::string &str)
{
	std::stringstream iss(str);
	Type num;
	iss >> num;
	return num;
}


int main( int argc, char **argv )
{
	std::cout<<"Program begins ... "<<std::endl;
	
	int recvCount = 0;
	
	int previous = 0, rear = 0; // pointer to indicate the position of the exact data int a receive buffer.

	/* init the ros */
	ros::init( argc, argv, "IntegrateNavigationSystem" );
	ros::NodeHandle n;

	/* Publisher of the integrated navigation data */
	ros::Publisher pub = n.advertise<IntegratedNavigation::integratedNavigationMsg>( "/integratedNavigation/data", 1);


	/* open the uart device */
	int uart_fd = open_port();
	std::cout<<"uart fd = "<<uart_fd <<std::endl;
	if( uart_fd > 0 ){
		if( set_opt( uart_fd ) != true ){
			std::cerr<<"set port failed ... "<<std::endl;
			return false;
		}
	}
	else{
		std::cerr<<"open port failed ..."<<std::endl;
		exit(-1);
	}
	sleep( 1 );


	std::string s1; 
	std::vector<std::string> arr1; // define a vector of string
	int position = 0;	
	IntegratedNavigation::integratedNavigationMsg recvMsg;

	while(ros::ok()){
	std::cout<<"ros::ok() = "<<ros::ok() <<std::endl;
		memset( recvBuff, 0, sizeof( recvBuff ) );
		if( recvData( uart_fd, recvBuff, sizeof( recvBuff ) ) ){
			if( recvCount <= 1 ) recvCount ++;
			if( recvCount > 1 ){
				/* parse the one frame of message */
				s1 = recvBuff;
				std::cout<<"s1 = "<< s1 <<std::endl;
				std::cout<<"length = "<<s1.length()<<std::endl;
				do{
					std::string tmp_s;
					position = s1.find(","); //找到逗号的位置     
					tmp_s = s1.substr(0, position); //截取需要的字符串      
					s1.erase(0, position + 1); //将已读取的数据删去       
					arr1.push_back(tmp_s);   //将字符串压入容器中    
				} while (position != -1);
	
				int d0 = stringToNum<int>( arr1[1] ); // GPSWeek 
				//printf("GPSWeek = %d\r\n", d0);
				recvMsg.GPSWeek = d0;
				double d1 = stringToNum<double>( arr1[2] ); // GPSTime 
				//printf( "GPSTime = %f\r\n", d1 );
				recvMsg.GPSTime = d1;
				double d2 = stringToNum<double>( arr1[3] ); // Heading 
				//printf("heading = %f\r\n", d2);
				recvMsg.Heading = d2;
				double d3 = stringToNum<double>( arr1[4] ); // Pitch
				//printf( "pitch = %f\r\n", d3 ); 
				recvMsg.Pitch = d3;
				double d4 = stringToNum<double>( arr1[5] ); // Roll
				//printf( "roll = %f\r\n", d4 ); 
				recvMsg.Roll = d4;
				double d5 = stringToNum<double>( arr1[6] ); // gyroX
        	       	        //printf( "gyroX = %f\r\n", d5 );
				recvMsg.gyroX = d5;
				double d6 = stringToNum<double>( arr1[7] ); // gyroY
        	       	        //printf( "gyroY = %f\r\n", d6 );
				recvMsg.gyroY = d6;
				double d7 = stringToNum<double>( arr1[8] ); // gyroZ
               		        //printf( "gyroZ = %f\r\n", d7 );
				recvMsg.gyroZ = d7;
				double d8 = stringToNum<double>( arr1[9] ); // accX
        	                //printf( "accX = %f\r\n", d8 );
				recvMsg.accX = d8;
				double d9 = stringToNum<double>( arr1[10] ); // accY
                	        //printf( "accY = %f\r\n", d9 );
				recvMsg.accY = d9;
				double d10 = stringToNum<double>( arr1[11] ); // accZ
                	       	//printf( "accZ = %f\r\n", d10 );
				recvMsg.accZ = d10;
				double d11 = stringToNum<double>( arr1[12] ); // latitude
	       	                //printf( "latitude = %f\r\n", d11 );
				recvMsg.Lattitude = d11;
				double d12 = stringToNum<double>( arr1[13] ); // longitude
                	        //printf( "longtitude = %f\r\n", d12 );
				recvMsg.Longitude = d12;
				double d13 = stringToNum<double>( arr1[14] ); // attitude
                	    	//printf( "attitude = %f\r\n", d13 );
				recvMsg.Altitude = d13;
				double d14 = stringToNum<double>( arr1[15] ); // Ve
	       	                //printf( "Ve = %f\r\n", d14 );
				recvMsg.Ve = d14;
				double d15 = stringToNum<double>( arr1[16] ); // Vn
	       	                //printf( "Vn = %f\r\n", d15 );
				recvMsg.Vn = d15;
				double d16 = stringToNum<double>( arr1[17] ); // Vu
       		                //printf( "Vu = %f\r\n", d16 );
				recvMsg.Vu = d16;
				double d17 = stringToNum<double>( arr1[18] ); // V
        	      	        //printf( "V = %f\r\n", d17 );
				recvMsg.Baseline = d17;
				int d18 = stringToNum<int>( arr1[19] ); // NSV1 
                	       // printf( "NSV1 = %d\r\n", d18 );
				recvMsg.NSV1 = d18;
				int d19 = stringToNum<int>( arr1[20] ); // NSV2
	                        //printf( "NSV2 = %d\r\n", d19 );
				recvMsg.NSV2 = d19;
				char d20 = stringToNum<char>( arr1[21] ); // status
        	                //printf( "status = %d\r\n", d20 );
				recvMsg.Status = d20;
				double d21 = stringToNum<double>( arr1[22] ); // age
               		        //printf( "age = %f\r\n", d21 );
				recvMsg.Age = d21;
				for (size_t i = 0; i < 20; i++)
				{
					/* code */
					std::cout << "arr1[]" <<  i  << "::"<< arr1[i] << std::endl;
				}
				
				arr1.clear();
				recvMsg.header.stamp = ros::Time::now();
				pub.publish( recvMsg );
			}
		}
	}

	return 0;
}

5、添加include文件

右击integratednavigation功能包，选择 新建include文件夹

右键integratednavigation/include/integratednavigation 新建.h文件 输入integratedNavigationMsg.h 按住tab键 弹出的窗口选择加入到新的库文件中

 integratedNavigationMsg.h

// Generated by gencpp from file IntegratedNavigation/integratedNavigationMsg.msg
// DO NOT EDIT!


#ifndef INTEGRATEDNAVIGATION_MESSAGE_INTEGRATEDNAVIGATIONMSG_H
#define INTEGRATEDNAVIGATION_MESSAGE_INTEGRATEDNAVIGATIONMSG_H


#include <string>
#include <vector>
#include <memory>

#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>

#include <std_msgs/Header.h>

namespace IntegratedNavigation
{
template <class ContainerAllocator>
struct integratedNavigationMsg_
{
  typedef integratedNavigationMsg_<ContainerAllocator> Type;

  integratedNavigationMsg_()
    : header()
    , GPSWeek(0)
    , GPSTime(0.0)
    , Heading(0.0)
    , Pitch(0.0)
    , Roll(0.0)
    , gyroX(0.0)
    , gyroY(0.0)
    , gyroZ(0.0)
    , accX(0.0)
    , accY(0.0)
    , accZ(0.0)
    , Lattitude(0.0)
    , Longitude(0.0)
    , Altitude(0.0)
    , Ve(0.0)
    , Vn(0.0)
    , Vu(0.0)
    , Baseline(0.0)
    , NSV1(0)
    , NSV2(0)
    , Status(0)
    , Age(0.0)
    , warning(0)  {
    }
  integratedNavigationMsg_(const ContainerAllocator& _alloc)
    : header(_alloc)
    , GPSWeek(0)
    , GPSTime(0.0)
    , Heading(0.0)
    , Pitch(0.0)
    , Roll(0.0)
    , gyroX(0.0)
    , gyroY(0.0)
    , gyroZ(0.0)
    , accX(0.0)
    , accY(0.0)
    , accZ(0.0)
    , Lattitude(0.0)
    , Longitude(0.0)
    , Altitude(0.0)
    , Ve(0.0)
    , Vn(0.0)
    , Vu(0.0)
    , Baseline(0.0)
    , NSV1(0)
    , NSV2(0)
    , Status(0)
    , Age(0.0)
    , warning(0)  {
  (void)_alloc;
    }



   typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
  _header_type header;

   typedef int32_t _GPSWeek_type;
  _GPSWeek_type GPSWeek;

   typedef double _GPSTime_type;
  _GPSTime_type GPSTime;

   typedef double _Heading_type;
  _Heading_type Heading;

   typedef double _Pitch_type;
  _Pitch_type Pitch;

   typedef double _Roll_type;
  _Roll_type Roll;

   typedef double _gyroX_type;
  _gyroX_type gyroX;

   typedef double _gyroY_type;
  _gyroY_type gyroY;

   typedef double _gyroZ_type;
  _gyroZ_type gyroZ;

   typedef double _accX_type;
  _accX_type accX;

   typedef double _accY_type;
  _accY_type accY;

   typedef double _accZ_type;
  _accZ_type accZ;

   typedef double _Lattitude_type;
  _Lattitude_type Lattitude;

   typedef double _Longitude_type;
  _Longitude_type Longitude;

   typedef double _Altitude_type;
  _Altitude_type Altitude;

   typedef double _Ve_type;
  _Ve_type Ve;

   typedef double _Vn_type;
  _Vn_type Vn;

   typedef double _Vu_type;
  _Vu_type Vu;

   typedef double _Baseline_type;
  _Baseline_type Baseline;

   typedef int32_t _NSV1_type;
  _NSV1_type NSV1;

   typedef int32_t _NSV2_type;
  _NSV2_type NSV2;

   typedef int8_t _Status_type;
  _Status_type Status;

   typedef float _Age_type;
  _Age_type Age;

   typedef int8_t _warning_type;
  _warning_type warning;





  typedef boost::shared_ptr< ::IntegratedNavigation::integratedNavigationMsg_<ContainerAllocator> > Ptr;
  typedef boost::shared_ptr< ::IntegratedNavigation::integratedNavigationMsg_<ContainerAllocator> const> ConstPtr;

}; // struct integratedNavigationMsg_

typedef ::IntegratedNavigation::integratedNavigationMsg_<std::allocator<void> > integratedNavigationMsg;

typedef boost::shared_ptr< ::IntegratedNavigation::integratedNavigationMsg > integratedNavigationMsgPtr;
typedef boost::shared_ptr< ::IntegratedNavigation::integratedNavigationMsg const> integratedNavigationMsgConstPtr;

// constants requiring out of line definition



template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::IntegratedNavigation::integratedNavigationMsg_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::IntegratedNavigation::integratedNavigationMsg_<ContainerAllocator> >::stream(s, "", v);
return s;
}


template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::IntegratedNavigation::integratedNavigationMsg_<ContainerAllocator1> & lhs, const ::IntegratedNavigation::integratedNavigationMsg_<ContainerAllocator2> & rhs)
{
  return lhs.header == rhs.header &&
    lhs.GPSWeek == rhs.GPSWeek &&
    lhs.GPSTime == rhs.GPSTime &&
    lhs.Heading == rhs.Heading &&
    lhs.Pitch == rhs.Pitch &&
    lhs.Roll == rhs.Roll &&
    lhs.gyroX == rhs.gyroX &&
    lhs.gyroY == rhs.gyroY &&
    lhs.gyroZ == rhs.gyroZ &&
    lhs.accX == rhs.accX &&
    lhs.accY == rhs.accY &&
    lhs.accZ == rhs.accZ &&
    lhs.Lattitude == rhs.Lattitude &&
    lhs.Longitude == rhs.Longitude &&
    lhs.Altitude == rhs.Altitude &&
    lhs.Ve == rhs.Ve &&
    lhs.Vn == rhs.Vn &&
    lhs.Vu == rhs.Vu &&
    lhs.Baseline == rhs.Baseline &&
    lhs.NSV1 == rhs.NSV1 &&
    lhs.NSV2 == rhs.NSV2 &&
    lhs.Status == rhs.Status &&
    lhs.Age == rhs.Age &&
    lhs.warning == rhs.warning;
}

template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::IntegratedNavigation::integratedNavigationMsg_<ContainerAllocator1> & lhs, const ::IntegratedNavigation::integratedNavigationMsg_<ContainerAllocator2> & rhs)
{
  return !(lhs == rhs);
}


} // namespace IntegratedNavigation

namespace ros
{
namespace message_traits
{





template <class ContainerAllocator>
struct IsFixedSize< ::IntegratedNavigation::integratedNavigationMsg_<ContainerAllocator> >
  : FalseType
  { };

template <class ContainerAllocator>
struct IsFixedSize< ::IntegratedNavigation::integratedNavigationMsg_<ContainerAllocator> const>
  : FalseType
  { };

template <class ContainerAllocator>
struct IsMessage< ::IntegratedNavigation::integratedNavigationMsg_<ContainerAllocator> >
  : TrueType
  { };

template <class ContainerAllocator>
struct IsMessage< ::IntegratedNavigation::integratedNavigationMsg_<ContainerAllocator> const>
  : TrueType
  { };

template <class ContainerAllocator>
struct HasHeader< ::IntegratedNavigation::integratedNavigationMsg_<ContainerAllocator> >
  : TrueType
  { };

template <class ContainerAllocator>
struct HasHeader< ::IntegratedNavigation::integratedNavigationMsg_<ContainerAllocator> const>
  : TrueType
  { };


template<class ContainerAllocator>
struct MD5Sum< ::IntegratedNavigation::integratedNavigationMsg_<ContainerAllocator> >
{
  static const char* value()
  {
    return "041e1fa850daadf3d28954c7ff76c76d";
  }

  static const char* value(const ::IntegratedNavigation::integratedNavigationMsg_<ContainerAllocator>&) { return value(); }
  static const uint64_t static_value1 = 0x041e1fa850daadf3ULL;
  static const uint64_t static_value2 = 0xd28954c7ff76c76dULL;
};

template<class ContainerAllocator>
struct DataType< ::IntegratedNavigation::integratedNavigationMsg_<ContainerAllocator> >
{
  static const char* value()
  {
    return "IntegratedNavigation/integratedNavigationMsg";
  }

  static const char* value(const ::IntegratedNavigation::integratedNavigationMsg_<ContainerAllocator>&) { return value(); }
};

template<class ContainerAllocator>
struct Definition< ::IntegratedNavigation::integratedNavigationMsg_<ContainerAllocator> >
{
  static const char* value()
  {
    return "std_msgs/Header header\n"
"int32 GPSWeek\n"
"float64 GPSTime\n"
"float64 Heading\n"
"float64 Pitch\n"
"float64 Roll\n"
"float64 gyroX\n"
"float64 gyroY\n"
"float64 gyroZ\n"
"float64 accX\n"
"float64 accY\n"
"float64 accZ\n"
"float64 Lattitude\n"
"float64 Longitude\n"
"float64 Altitude\n"
"float64 Ve # velocity towards east\n"
"float64 Vn # velocity towards north\n"
"float64 Vu\n"
"float64 Baseline # Velocity of vehicle\n"
"int32 NSV1 # number of the settlelites\n"
"int32 NSV2\n"
"int8 Status\n"
"float32 Age\n"
"int8 warning\n"
"\n"
"\n"
"\n"
"\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/Header\n"
"# Standard metadata for higher-level stamped data types.\n"
"# This is generally used to communicate timestamped data \n"
"# in a particular coordinate frame.\n"
"# \n"
"# sequence ID: consecutively increasing ID \n"
"uint32 seq\n"
"#Two-integer timestamp that is expressed as:\n"
"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
"# time-handling sugar is provided by the client library\n"
"time stamp\n"
"#Frame this data is associated with\n"
"string frame_id\n"
;
  }

  static const char* value(const ::IntegratedNavigation::integratedNavigationMsg_<ContainerAllocator>&) { return value(); }
};

} // namespace message_traits
} // namespace ros

namespace ros
{
namespace serialization
{

  template<class ContainerAllocator> struct Serializer< ::IntegratedNavigation::integratedNavigationMsg_<ContainerAllocator> >
  {
    template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
    {
      stream.next(m.header);
      stream.next(m.GPSWeek);
      stream.next(m.GPSTime);
      stream.next(m.Heading);
      stream.next(m.Pitch);
      stream.next(m.Roll);
      stream.next(m.gyroX);
      stream.next(m.gyroY);
      stream.next(m.gyroZ);
      stream.next(m.accX);
      stream.next(m.accY);
      stream.next(m.accZ);
      stream.next(m.Lattitude);
      stream.next(m.Longitude);
      stream.next(m.Altitude);
      stream.next(m.Ve);
      stream.next(m.Vn);
      stream.next(m.Vu);
      stream.next(m.Baseline);
      stream.next(m.NSV1);
      stream.next(m.NSV2);
      stream.next(m.Status);
      stream.next(m.Age);
      stream.next(m.warning);
    }

    ROS_DECLARE_ALLINONE_SERIALIZER
  }; // struct integratedNavigationMsg_

} // namespace serialization
} // namespace ros

namespace ros
{
namespace message_operations
{

template<class ContainerAllocator>
struct Printer< ::IntegratedNavigation::integratedNavigationMsg_<ContainerAllocator> >
{
  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::IntegratedNavigation::integratedNavigationMsg_<ContainerAllocator>& v)
  {
    s << indent << "header: ";
    s << std::endl;
    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
    s << indent << "GPSWeek: ";
    Printer<int32_t>::stream(s, indent + "  ", v.GPSWeek);
    s << indent << "GPSTime: ";
    Printer<double>::stream(s, indent + "  ", v.GPSTime);
    s << indent << "Heading: ";
    Printer<double>::stream(s, indent + "  ", v.Heading);
    s << indent << "Pitch: ";
    Printer<double>::stream(s, indent + "  ", v.Pitch);
    s << indent << "Roll: ";
    Printer<double>::stream(s, indent + "  ", v.Roll);
    s << indent << "gyroX: ";
    Printer<double>::stream(s, indent + "  ", v.gyroX);
    s << indent << "gyroY: ";
    Printer<double>::stream(s, indent + "  ", v.gyroY);
    s << indent << "gyroZ: ";
    Printer<double>::stream(s, indent + "  ", v.gyroZ);
    s << indent << "accX: ";
    Printer<double>::stream(s, indent + "  ", v.accX);
    s << indent << "accY: ";
    Printer<double>::stream(s, indent + "  ", v.accY);
    s << indent << "accZ: ";
    Printer<double>::stream(s, indent + "  ", v.accZ);
    s << indent << "Lattitude: ";
    Printer<double>::stream(s, indent + "  ", v.Lattitude);
    s << indent << "Longitude: ";
    Printer<double>::stream(s, indent + "  ", v.Longitude);
    s << indent << "Altitude: ";
    Printer<double>::stream(s, indent + "  ", v.Altitude);
    s << indent << "Ve: ";
    Printer<double>::stream(s, indent + "  ", v.Ve);
    s << indent << "Vn: ";
    Printer<double>::stream(s, indent + "  ", v.Vn);
    s << indent << "Vu: ";
    Printer<double>::stream(s, indent + "  ", v.Vu);
    s << indent << "Baseline: ";
    Printer<double>::stream(s, indent + "  ", v.Baseline);
    s << indent << "NSV1: ";
    Printer<int32_t>::stream(s, indent + "  ", v.NSV1);
    s << indent << "NSV2: ";
    Printer<int32_t>::stream(s, indent + "  ", v.NSV2);
    s << indent << "Status: ";
    Printer<int8_t>::stream(s, indent + "  ", v.Status);
    s << indent << "Age: ";
    Printer<float>::stream(s, indent + "  ", v.Age);
    s << indent << "warning: ";
    Printer<int8_t>::stream(s, indent + "  ", v.warning);
  }
};

} // namespace message_operations
} // namespace ros

#endif // INTEGRATEDNAVIGATION_MESSAGE_INTEGRATEDNAVIGATIONMSG_H

同样操作新建头文件 uarta.h

#ifndef __UARTA_H_
#define __UARTA_H_

#include <iostream>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <termios.h>
#include <string.h>

int open_port();
int set_opt( int fd );
bool recvData( int fd, char *recvbuff, int n );
bool send_Byte( int fd, char byte );

int open_port()
{
    char *dev = "/dev/ttyUSB0";
    int fd = open( dev, O_RDWR | O_NOCTTY | O_NDELAY );
    if( fd == -1 ){
        std::cout<<"error1 ..."<<std::endl;
        return false;
    }
    if( fcntl( fd, F_SETFL, 0 ) < 0 ){
        std::cout<<"error2 ..."<<std::endl;
        return false;
    }
    if( isatty( STDIN_FILENO ) == 0 ){
        std::cout<<"error3 ..."<<std::endl;
        return false;
    }
    std::cout<<"open port successfully ..."<<std::endl;
    return fd;
}

int set_opt( int fd )
{
    struct termios newtio, oldtio;
    if( tcgetattr( fd, &oldtio ) != 0 ){
        std::cout<<"read old serial attributions failed ..."<<std::endl;
        return false;
    }
    bzero( &newtio, sizeof( newtio ) );

    newtio.c_cflag |= CLOCAL | CREAD;

    newtio.c_cflag &= ~CSIZE;
    newtio.c_cflag |= CS8;

    newtio.c_cflag &= ~PARENB;

    cfsetispeed( &newtio, B115200 );
    cfsetospeed( &newtio, B115200 );
    
    newtio.c_cflag &= ~CSTOPB;

    newtio.c_cc[VTIME] = 0;
    newtio.c_cc[VMIN] = 1;

    tcflush( fd, TCIFLUSH );
    
    if( ( tcsetattr( fd, TCSANOW, &newtio ) ) != 0 ){
        std::cout<<"com set error ... "<<std::endl;
        return false;
    }
    std::cout<<"set port successfully ..."<<std::endl;
    return true;
}

bool recvData( int fd, char *recvBuff, int n )
{
        int count = 1;
        read( fd, &recvBuff[0], 1 );
        if( recvBuff[0] == '$' ){
                do{
                        read( fd, &recvBuff[ count ], 1 );
                        count ++ ;
		}while( recvBuff[count - 1] != 0x0D && recvBuff[count] != 0x0A );// "count < n " should not be exist in here, maybe, waiting for a test

                std::cout<<"count is: "<<count<<std::endl;
		//for( int i = 1; i < count; i ++ )
		//	std::cout<<"recvBuff["<<i<<"] = "<<recvBuff[i]<<std::endl;
                count = 1;
        }
	else{
		return false;
	}
	return true;
}


bool send_Byte( int fd, char byte )
{
	if( write( fd, &byte, 1 ) != 1){
		return false;
	}
	else{
		return true;
		std::cout<<"send commander successfully ..."<<std::endl;
	}
}

#endif

同4、5添加src文件夹和include文件夹，创建msg文件夹

并新建msg文件integratednavigation.msg

integratednavigation.msg

std_msgs/Header header
int32 GPSWeek
float64 GPSTime
float64 Heading
float64 Pitch
float64 Roll
float64 gyroX
float64 gyroY
float64 gyroZ
float64 accX
float64 accY
float64 accZ
float64 Lattitude
float64 Longitude
float64 Altitude
float64 Ve # velocity towards east
float64 Vn # velocity towards north
float64 Vu
float64 Baseline # Velocity of vehicle
int32 NSV1 # number of the settlelites
int32 NSV2
int8 Status
float32 Age
int8 warning

6、编译执行

快捷键 ctrl + `调起终端，在工作空间下编译：

$ catkin_make
$ souce devel/setup.bash
$ catkin_make
#一开始编译有报错 把功能包下面除src之外的文件删除  重新点击ros-构建 之后编译正常

 新建终端  运行roscore

 可以看到ROS节点已经出现在这里  并执行rosrun

$ rosrun integratednavigation main

 

TravisWong
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
ROS学习（15）RoboWare Studio的安装使用
韩若熙的博客
05-05 3530
RoboWareStudio是一个ROS集成开发环境.使ROS开发更加直观、简单，并且易于操作.可进行ROS工作空间及包的管理，代码编辑、构建及调试。可惜的是，目前已经停更。。。右键点击learning_topic功能包，新建Msg文件夹右键点击生成的msg文件夹，新建msg文件，命名为Person.msguint8sexuint8age如上所述，我们分别新建person_publisher.cpp和person_subscriber.cpp文件。rosrosros。...
RoboWare-Studio:用于ROS开发的IDE环境
05-11
RoboWare Studio-开源 是用于ROS开发的IDE环境，它使ROS开发可视，简单且易于管理，提供ROS工作区管理，代码编辑，构建和调试，它是一个IDE，但不仅仅是一个IDE！ 发展 有关详细信息，请参阅。这里是中文版： 执照 版权所有（c）济南东尼机器人有限公司。保留所有权利。 根据许可获得许可。
RTK数据读取解析
07-23
RTK标准数据读取与解析，测试平台windows10,vs2013，配详细代码说明，
ROS学习笔记 --RoboWare的安装和使用
m0_75132158的博客
04-03 357
RoboWare是一款直观、简单，并且易于操作的ROS集成开发环 境，可进行ROS工作空间及包的管理、代码编辑、构建及调试。
HW_for_AgOpenGPS：AgOpenGPS QtOpenGuidance的自动转向和RTK-GNSS单元
02-18
AgOpenGPS / QtOpenGuidance的中央自动转向装置和屋顶装置 （德国语中的信息） 这两个单元带来了用于自动转向的所有电子功能。 / 项目。 主机具有自动转向的所有功能，还包括一个4端口USB集线器。 基于RTK-GNSS的双接收机 ，是一个单独的单元。 该单元不是必需的。 Ardusimple模块/ Bynav模块也可以安装在中央单元内部。 此设置不包括新功能，但提供了可以由专业EMS提供商制造的强大的单体设备。 中央单元与兼容，而屋顶单元与兼容。 如果ESP32选项用于自动转向或RTK，则必须分别修改和或的引脚定义。 特别关注坚固的外壳和工业M12 / M8连接器（可选）。 PushIn连接器也可用于单线连接）。 PCB项目是使用可免费使用的EDA程序“ EasyEDA”设置的。 尚未检查Altium导出。 订购方法JLCPCB 浏览到并单击“立即报价”
GPS-RTK技术用于开采沉陷观测试验数据处理及精度分析
07-12
GPS-RTK实时动态定位技术目前被广泛应用于地形测量、地籍测量及一些工程放样等工程测量工作中,根据需要可同时测得点的平面坐标及高程值。其所能达到的精度是自该技术开发应用以来一直研究探讨的问题,文中试验是在铁法矿区的两个地表移动观测站上进行,在应用常规水准观测各测点的同时,应用GPS-RTK进行观测,试验GPS-RTK技术用于开采沉陷观测的可行性,对其观测结果及精度进行了对比分析,取得了满意的效果。
关于RTK定位的理解
qq_41879010的博客
07-15 234
更不可接受的是，传统RTK中卫星定位误差的空间相关性随移动站距离基准站的距离增加而逐渐失去线性，因此在超长距离下（约>30km），经过载波相位差分运算后，有可能无法解算出载波相位的整周模糊度，从而导致定位精度直接变为分米级或米级。码差分法中，基准站一方面基于观测值计算出伪距，另一方面基于基准站已知坐标和各卫星的坐标，求出每颗卫星每一时刻到基准站的真实距离，将真实距离与伪距作差，得出伪距改正信息，并广播给接收机。但是对于服务商来说，要想提供大范围的无缝覆盖，无论是RTK还是NRTK，建设成本都极高。
ROS IDE —— RoboWare Studio
Dream_cc的博客
02-02 2万+
RoboWare Studio的简单使用，详细内容可以跟着官网的使用文档来。
RoboWare Studio 安装教程与可能问题解决
weixin_43728093的博客
08-27 3521
一、下载RoboWare源码 途径1：官方GitHub连接：https://github.com/TonyRobotics/RoboWare 途径2：RoboWare官网：http://www.roboware.me/#/home （我选择了途径1） 下载完后解压，我们可以看到文件夹\RoboWare-master\Studio有如下内容： 在其他博主的帖子里我看到同样是ubuntu18.04版本的系统，他们选择了红框内的roboware版本，因此我选择了红框内的版本。 只需要将红框内.
ROS：安装RoboWare studio、解决字体显示不清楚
weixin_44190648的博客
06-02 199
ROS：安装RoboWare studio、解决字体显示不清楚
roboware studio教程_RoboWare-Studio
weixin_42350411的博客
12-30 842
RoboWare Studio 开发指南开发者可参照本文档进行所需功能的开发。RoboWare Studio 基于 Visual Studio Code 的源代码进行二次开发，最新版本是 RoboWare Studio 1.2.0 基于 vscode 1.15.1。由于 RoboWare Studio 与 ROS 功能紧密结合，所以它只有 Linux deb 版本的，只能在 ubuntu 14.0...
rtk-query：Redux Toolkit的实验数据获取和缓存插件
02-05
RTK Query是一种高级的数据获取和缓存工具，旨在简化在Web应用程序中加载数据的常见情况。 它基于构建，内部使用Redux作为其体系结构。 它具有以下特点： 声明性API定义 在每个框架上运行 支持任何协议 快取 自动...
海星达RTK-CORS连接操作.pdf
03-20
海星达RTK-CORS连接操作.pdf海星达RTK-CORS连接操作.pdf海星达RTK-CORS连接操作.pdf海星达RTK-CORS连接操作.pdf海星达RTK-CORS连接操作.pdf
rtk_sensor_damagezfw_rtk_ROS_gpsrtkros_msf-ekf_
09-30
ros RTK驱动，可用于ROS开发，需要建立ROS工作空间
RTK学习
m0_37769093的博客
06-21 325
RTK 板卡和接收机出厂默认设置为基准站(1)+流动站(1)， 其中基准站的串口 0 发送差分数据,串口 1 输出位置、速度和基准站坐标数据； 流动站串口 0 和串口 1 都接收差分数据，串口 1 输出位置、速度数据。 单电台配置流程步骤 接上天线 板卡外部串口0接用户电台（电平为3.3V） 板卡供电（3.3V-5V）如果已知基准站天线准确的坐标，可进行第四步操作，如果不确定基准站天线的准确坐标，板卡会通过滤波确定一个基准站坐标，幵通过串口 1 输出。 板卡的外部串口 1 与 PC 相连，对基准站进行相关
RTK+GPS提高定位精度原理解析（一个小白写给另一个小白系列）
热门推荐
LEEANG121的博客
07-07 5万+
RTK+GPS提高定位精度原理解析（一个小白写给另一个小白系列）GPS定位原理回顾RTK基本概念RTK组成RTK传输差分示意RTK数据链接坐标转换RTK应用后记 我们在上一篇文章导航定位系统的原理解析（一个小白写给另一个小白）中跟大家介绍了GPS定位的基本原理，但是实际情况是，GPS单独使用的精度非常低，因此需要配合其他的辅助技术提高定位精度，今天我们将为大家介绍其中最重要也是最常见的辅助技术RTK定位的基本原理。 为了方便小白玩家的理解，本文尽量以图文结合的形式、不带公式的跟大家做一个关于RTK的介绍。
RoboWare Studio安装教程
追求卓越583的博客
11-26 2万+
RoboWare官网：http://www.roboware.me/#/home 网盘链接: https://pan.baidu.com/s/18NJqUEoYzK4y23zFmKl5XA 提取码: nibq 官方GitHub连接：https://github.com/TonyRobotics/RoboWare 选择合适的版本下载，注意32位与64位之分。下载完以后先不要着急安装，为了更好地...
C++ 使用matplot++ 处理数据生成svg图表
最新发布
小蝈蝈的博客
05-13 157
python的图表库很丰富，C++依赖于python的 matplotlib的库却有很多功能不足，显得很鸡肋，其他的一些库没有过多的研究，Matplot++编译需要依赖一堆第三方库，可以参考官网，但是github上也提供了编译好的静态库，使用Matplot++同时需要下载安装gnuplot，并将gnuplot的bin加入到环境变量。将include、lib加入到对应的位置，并配置好路径和库连接，这部分不多说了。这里主要说说不依赖于python的纯C++ 的图表库 Matplot++
解析RTK串口数据 GTIMU为标准imu数据
06-09
将RTK串口数据解析成标准IMU数据需要以下步骤： 1. 读取串口数据：使用串口通信协议读取串口数据，一般是通过串口的读取函数来完成。 2. 提取数据：将读取到的数据提取出需要解析的部分，一般是以$开头，*结尾的一...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值