精华内容
下载资源
问答
  • 匿名地面站6.5版本传输协议,第六版本可用,包括详细的C文件以及头文件,本人已经全部测试完毕可以使用,相关说明可以查阅本人博客或私聊,如果你下载以后使用出现问题,可私聊解决
  • 匿名地面站V5

    2018-09-27 11:50:20
    匿名科创的上位机V5版本,功能强大,值得推荐!
  • 匿名地面站V6.5传输协议

    千次阅读 2019-04-11 15:43:56
    匿名地面站V6.5常用功能研究和传输协议。 因为做无人机功能的增加,以及不知道什么神奇的原因我的电脑打不开我们常用的V4.5版本,因此不得不使用更新一点的地面站。新版本的地面站相对于4.5版本(也是现在匿名官网...

    匿名地面站V6.5常用功能研究和传输协议。
    因为做无人机功能的增加,以及不知道什么神奇的原因我的电脑打不开我们常用的V4.5版本,因此不得不使用更新一点的地面站。新版本的地面站相对于4.5版本(也是现在匿名官网免费提供的版本),增加了飞行控制模块可供使用,而对于我们这些做比赛的学生狗而言,飞行控制功能要比遥控器实用多了,因此果断更新。
    然后,就开始了6.5版本的采坑之路。(此处默哀三分钟)首先是两个版本的传输协议不一样,需要更换传输协议,这可是折腾的我不轻,我可是之前一直以为两个版本是一样的传输协议的,白让我用新版本的数据传输试了好久,为啥死活收不到任何东西返回。然后才发现传输协议有这么大的不一样,真心难受。下面就让我们主要对比一下两个协议之间的区别来阐述一下代码该怎么写。至于源码(嘿嘿嘿)我花了那么久搞定的东西你们也得花点坑人的C币是把。我是链接

    传输协议对比讲述

    首先是规定的暗号变了,之前传输是固定的帧头的,现在的话是会因为你的设备不一样有所变化,不过如果你买的不是匿名的设备的话这个小区别就不要管了,我们直接规定好就OK这里以发送版本信息为例(我的代码是我们自己用的,只有常用功能,有些无关紧要的就没有再写,比如版本信息)
    版本信息
    基本的帧格式是这样子要求的,这里我们根据协议上面的样例来确定发送设备和接收设备,比如当下位机给上位机发送的时候,我们的S_ADDR=0X05,D_ADDR=0XAF。那么一帧数据的基本格式就OK了,这是传输一下基本的传感器数据然后看一下都OK,不会有问题。但是这个功能也不太够,至少加上个用户数据吧,我们好传输一些自己代码里面奇奇怪怪的东西进去,其实没有什么区别,就是把帧头功能码对应换一下就OK了,然后就可以使用高级收码来观察自己的数据啦,当然也可以用数据波形来看自己的数据啊,记得先点设置将波形更换为用户波形。
    当然有这些还是不太够,我们还需要PID的功能,就是这个玩意:PID
    低智商的我看着这个图,狂点写入飞控,一点反应都没有,可把我伤心的。经过多方丢人才咨询到,需要先点一下读取飞控才行。本以为就是点一下,没想到还得返回数据才行(那你倒是说清楚啊!!!)经过我不懈的努力,我终于发现这个神奇的东西该怎么用,原来点过读取飞控以后就会有信息传导下位机,而这个指令还是E0功能字的,可怕可怕(你明明说了E0功能字是用来传指令的不是读参数的哎)
    E0,E1
    反正无论如何,上位机发来查询指令以后,下午机就要返回对应的信息,啥子呢。。。。E1方式传输对应序号的指令,当时我可开心了,花了几个小时就搞定了(大家教我怎么输入微笑符号)之后数据通讯成功,神奇的一幕就发生了,写入飞控可以点击了,之后按照要求写就行了呗(哈哈哈)。
    在这里插入图片描述
    然后就是这个功能也比较重要,我们可以控制他怎么飞,这个模块使用的是E0功能,因此啥都不说,数据原样返回就行了,发过来的东西一解析,然后送回去就可以正常使用了。至于其他更高级的功能的话,由于本人暂时没有用到,因此也没写,等研究过来再来补上去吧。

    展开全文
  • 匿名地面站方便查看动态数据,而且便于调试系统参数,多用于基于单片机的系统调试。 由于项目需要基于ROS开发,考虑到系统参数调试工作量不小,便写了一个基于ROS的匿名地面站驱动。 文章目录安装串口驱动ROS发送...

    匿名地面站方便查看动态数据,而且便于调试系统参数,多用于基于单片机的系统调试。
    由于项目需要基于ROS开发,考虑到系统参数调试工作量不小,便写了一个基于ROS的匿名地面站驱动。

    安装串口驱动

    之前使用ubuntu 16.04的时候,可以直接使用
    $ sudo apt-get install ros-<版本号>-serial的命令安装基于ROS的串口工具包,如

    sudo apt-get install ros-kinetic-serial
    

    但是ubuntu 20.04和ros noetic似乎暂时没有将其集成,所以需要在工作空间内手动源码配置。
    工作空间文件夹为 catkin_ws,在工作空间文件夹下的src内,放入serial的源码,命令如下

    cd ~
    cd catkin_ws/src
    git clone https://github.com/wjwwood/serial.git
    

    进入克隆的serial文件夹内,执行编译安装

    cd serial
    make
    make install
    

    其他功能包引用serial的头文件时,需要进行如下配置

    (1)将serial文件夹下的CMakeLists.txt中的

    ## Include headers
    include_directories(include  ${catkin_INCLUDE_DIRS})
    

    修改为

    ## Include headers
    include_directories(include  ${catkin_INCLUDE_DIRS})
    

    (2)在其他功能包中的package.xml中添加

      <build_depend>serial</build_depend>
      <build_export_depend>serial</build_export_depend>
    

    (3)在其他功能包中的CMakeLists.txt中的find语句里,添加serial的依赖,如

    find_package(catkin REQUIRED COMPONENTS
      roscpp
      serial
      # 。。。
    )
    

    并添加头文件路径

    ## Include headers
    include_directories(include  ${catkin_INCLUDE_DIRS})
    

    匿名地面站驱动源码

    #ifndef _APP_ANO_H_
    #define _APP_ANO_H_
    
    #include "serial/serial.h"
    #include <stdint.h>
    #include <string>
    
    #define BYTE0(dwTemp)       ( *( (uint8_t *)(&dwTemp) + 0) )
    #define BYTE1(dwTemp)       ( *( (uint8_t *)(&dwTemp) + 1) )
    #define BYTE2(dwTemp)       ( *( (uint8_t *)(&dwTemp) + 2) )
    #define BYTE3(dwTemp)       ( *( (uint8_t *)(&dwTemp) + 3) )
    
    class SDK_ANO_TC_V4
    {
    public:
    	SDK_ANO_TC_V4()
    	{
    		state = 0;
    		_data_len = 0;
    		_data_cnt = 0;
    		send_pid_para = 0;
    	}
    	~SDK_ANO_TC_V4(){}
    
    	std::string m_port_name;
    	//std::string m_receive_from_ano_tc;
    	uint32_t state;
    	unsigned long m_baudrate;
    	uint8_t ano_data_to_send[100];
    	uint8_t ano_data_rec[100];
    	uint8_t _data_len, _data_cnt;
    	uint8_t send_pid_para;
    
    	struct ANO_CACHE{
    		float pid1_p, pid1_i, pid1_d;
    		float pid2_p, pid2_i, pid2_d;
    		float pid3_p, pid3_i, pid3_d;
    
    		float pid4_p, pid4_i, pid4_d;
    		float pid5_p, pid5_i, pid5_d;
    		float pid6_p, pid6_i, pid6_d;
    
    		float pid7_p, pid7_i, pid7_d;
    		float pid8_p, pid8_i, pid8_d;
    		float pid9_p, pid9_i, pid9_d;
    
    		float pid10_p, pid10_i, pid10_d;
    		float pid11_p, pid11_i, pid11_d;
    		float pid12_p, pid12_i, pid12_d;
    
    		float pid13_p, pid13_i, pid13_d;
    		float pid14_p, pid14_i, pid14_d;
    		float pid15_p, pid15_i, pid15_d;
    
    		float pid16_p, pid16_i, pid16_d;
    		float pid17_p, pid17_i, pid17_d;
    		float pid18_p, pid18_i, pid18_d;
    	};
    	struct ANO_CACHE ano_cache;
    
    	int8_t set_dev(serial::Serial* sp, const std::string& port_name, unsigned long baudrate)
    	{
    		    serial::Timeout to = serial::Timeout::simpleTimeout(100);
    		    sp->setPort(port_name);
    		    sp->setBaudrate(baudrate);
    		    sp->setTimeout(to);
    		    m_port_name = port_name;
    		    m_baudrate = baudrate;
    		    return 0;
    	}
    
    	int8_t open_dev(serial::Serial* sp)
    	{
    		try
    	    {
    	        sp->open();
    	    }
    	    catch(serial::IOException& e)
    	    {
    	        ROS_ERROR_STREAM("Unable to open port: " + m_port_name);
    	        return -1;
    	    }
    	    
    	    if(sp->isOpen())
    	    {
    	        ROS_INFO_STREAM(m_port_name + " is opened.");
    	    }
    	    else
    	    {
    	        return -1;
    	    }
    	}
    
    	int8_t close_dev(serial::Serial* sp)
    	{
    		sp->close();
    		ROS_INFO_STREAM(m_port_name + " is closed.");
    		return 0;
    	}
    
    	void send_15_data(	//int16_t : -32768~+32767
    		serial::Serial* sp,
    		int16_t a_x, int16_t a_y, int16_t a_z,
    		int16_t g_x, int16_t g_y, int16_t g_z,
    		int16_t m_x, int16_t m_y, int16_t m_z,
    		float angle_rol, float angle_pit, float angle_yaw,
    		int32_t alt, uint8_t fly_model, uint8_t armed)
    	{
    		uint8_t _cnt = 0;
    		int16_t _temp;
    		ano_data_to_send[_cnt++] = 0xAA;
    		ano_data_to_send[_cnt++] = 0xAA;
    		ano_data_to_send[_cnt++] = 0x02;
    		ano_data_to_send[_cnt++] = 0;
    
    		_temp = a_x;
    		ano_data_to_send[_cnt++] = BYTE1(_temp);
    		ano_data_to_send[_cnt++] = BYTE0(_temp);
    		_temp = a_y;
    		ano_data_to_send[_cnt++] = BYTE1(_temp);
    		ano_data_to_send[_cnt++] = BYTE0(_temp);
    		_temp = a_z;
    		ano_data_to_send[_cnt++] = BYTE1(_temp);
    		ano_data_to_send[_cnt++] = BYTE0(_temp);
    
    		_temp = g_x;
    		ano_data_to_send[_cnt++] = BYTE1(_temp);
    		ano_data_to_send[_cnt++] = BYTE0(_temp);
    		_temp = g_y;
    		ano_data_to_send[_cnt++] = BYTE1(_temp);
    		ano_data_to_send[_cnt++] = BYTE0(_temp);
    		_temp = g_z;
    		ano_data_to_send[_cnt++] = BYTE1(_temp);
    		ano_data_to_send[_cnt++] = BYTE0(_temp);
    
    		_temp = m_x;
    		ano_data_to_send[_cnt++] = BYTE1(_temp);
    		ano_data_to_send[_cnt++] = BYTE0(_temp);
    		_temp = m_y;
    		ano_data_to_send[_cnt++] = BYTE1(_temp);
    		ano_data_to_send[_cnt++] = BYTE0(_temp);
    		_temp = m_z;
    		ano_data_to_send[_cnt++] = BYTE1(_temp);
    		ano_data_to_send[_cnt++] = BYTE0(_temp);
    		/
    		_temp = 0;
    		ano_data_to_send[_cnt++] = BYTE1(_temp);
    		ano_data_to_send[_cnt++] = BYTE0(_temp);
    
    		ano_data_to_send[3] = _cnt - 4;
    
    		uint8_t sum = 0;
    		for (uint8_t i = 0; i < _cnt; i++)
    			sum += ano_data_to_send[i];
    		ano_data_to_send[_cnt++] = sum;
    
    
    		uint8_t _cnt2 = 0;
    		uint8_t _cnt3 = 0;
    		int32_t _temp2 = alt;
    		_cnt3 = _cnt;
    		ano_data_to_send[_cnt++] = 0xAA;
    		ano_data_to_send[_cnt++] = 0xAA;
    		ano_data_to_send[_cnt++] = 0x01;
    		_cnt2 = _cnt;
    		ano_data_to_send[_cnt++] = 0;
    
    		_temp = (int)(angle_rol * 100);
    		ano_data_to_send[_cnt++] = BYTE1(_temp);
    		ano_data_to_send[_cnt++] = BYTE0(_temp);
    		_temp = (int)(angle_pit * 100);
    		ano_data_to_send[_cnt++] = BYTE1(_temp);
    		ano_data_to_send[_cnt++] = BYTE0(_temp);
    		_temp = (int)(angle_yaw * 100);
    		ano_data_to_send[_cnt++] = BYTE1(_temp);
    		ano_data_to_send[_cnt++] = BYTE0(_temp);
    
    		ano_data_to_send[_cnt++] = BYTE3(_temp2);
    		ano_data_to_send[_cnt++] = BYTE2(_temp2);
    		ano_data_to_send[_cnt++] = BYTE1(_temp2);
    		ano_data_to_send[_cnt++] = BYTE0(_temp2);
    
    		ano_data_to_send[_cnt++] = fly_model;
    
    		ano_data_to_send[_cnt++] = armed;
    
    		ano_data_to_send[_cnt2] = _cnt - _cnt2 - 1;
    
    		sum = 0;
    		for (uint8_t i = _cnt3; i < _cnt; i++)
    			sum += ano_data_to_send[i];
    		ano_data_to_send[_cnt++] = sum;
    	        
    	        ano_data_to_send[_cnt++] = 0x0D;
    	        ano_data_to_send[_cnt++] = 0x0A;
    
    		sp->write(ano_data_to_send, _cnt);
    	}
    
    	void receive_info_from_ano_tc(serial::Serial* sp)
    	{
    		uint8_t data;
    		if(sp->available()!=0)
    		{
    			sp->read(&data,1);
    			//ROS_INFO("REC: %x state: %d",data, state);
    		}
    		// Header 0xAA 0xAF
    		if(state == 0)
    		{
    			if(data == 0xAA)
    			{
    				state = 1;
    				ano_data_rec[0] = data;
    				//ROS_INFO("%x ",data);
    				//ROS_INFO("state : %d ", state);
    			}
    			else
    			{
    				state = 0;
    			}
    			return;
    		}
    		if(state == 1)
    		{
    			//ROS_INFO("HAHHAHA");
    			//ROS_INFO("REC: %x state: %d",data, state);
    			if(data == 0xAF)
    			{
    				state = 2;
    				ano_data_rec[1] = data;
    				//ROS_INFO("%x ",data);
    				//ROS_INFO("state : %d ", state);
    			}
    			else
    			{
    				state = 0;
    			}
    			return;
    		}
    		// ID
    		if(state == 2)
    		{
    			state = 3;
    			ano_data_rec[2] = data;
    			return;
    		}
    		// LENGTH
    		if(state == 3)
    		{
    			if(data<50)
    			{
    				state = 4;
    				ano_data_rec[3] = data;
    				_data_len = data;
    				_data_cnt = 0;
    			}
    			else
    			{
    				state = 0;
    			}
    			return;
    		}
    		//
    		if(state == 4 && _data_len>0)
    		{
    			_data_len--;
    			ano_data_rec[4+_data_cnt++] = data;
    			if(_data_len==0)
    			{
    				state = 5;
    			}
    			return;
    		}
    		if(state == 5)
    		{
    			state = 0;
    			ano_data_rec[4+_data_cnt] = data;
    			receive_dataparser(sp, ano_data_rec, _data_cnt + 5);
    			return;
    		}
    	}
    
    	void receive_dataparser(serial::Serial* sp, uint8_t* data_buf, uint8_t num)
    	{
    		uint8_t sum = 0;
    		for (uint8_t i = 0; i<(num - 1); i++)
    			sum += *(data_buf + i);
    		if (!(sum == *(data_buf + num - 1)))
    		{
    			return;
    		}
    		if (!(*(data_buf) == 0xAA && *(data_buf + 1) == 0xAF))
    		{
    			return;
    		}
    		if (*(data_buf + 2) == 0X01)
    		{
    			if (*(data_buf + 4) == 0X01)
    			{
    				//button for accelerometer calibration
    				ROS_INFO("button for accelerometer calibration");
    			}
    			if (*(data_buf + 4) == 0X02)
    			{
    				//button for gyroscope calibration
    				ROS_INFO("button for gyroscope calibration");
    			}
    			if (*(data_buf + 4) == 0X05)
    			{
    				//button for barometer calibration
    				ROS_INFO("button for barometer calibration");
    			}
    			if (*(data_buf + 4) == 0X04)
    			{
    				//button for magnetometer calibration
    				ROS_INFO("button for magnetometer calibration");
    			}
    		}
    		if (*(data_buf + 2) == 0X02)
    		{
    			if (*(data_buf + 4) == 0X01)
    			{
    				//button for ReadFromFlyBoard
    				if(send_pid_para == 0)
    				{
    					send_pid_para = 1;
    				}
    	            send_pid_to_ano_tc(sp);
    	            ROS_INFO("button for ReadFromFlyBoard");
    			}
    			if (*(data_buf + 4) == 0XA1)
    			{
    				//button for RestoreDefaults
    	            ROS_INFO("button for RestoreDefaults");
    			}
    		}
    		//PID1
    		if (*(data_buf + 2) == 0X10)
    		{
    			ano_cache.pid1_p = 0.001f*((int)(*(data_buf + 4) << 8) | *(data_buf + 5));       
    			ano_cache.pid1_i = 0.001f*((int)(*(data_buf + 6) << 8) | *(data_buf + 7));       
    			ano_cache.pid1_d = 0.001f*((int)(*(data_buf + 8) << 8) | *(data_buf + 9));       
    
    			ano_cache.pid2_p = 0.001f*((int)(*(data_buf + 10) << 8) | *(data_buf + 11));     
    			ano_cache.pid2_i = 0.001f*((int)(*(data_buf + 12) << 8) | *(data_buf + 13));     
    			ano_cache.pid2_d = 0.001f*((int)(*(data_buf + 14) << 8) | *(data_buf + 15));     
    
    			ano_cache.pid3_p = 0.001f*((int)(*(data_buf + 16) << 8) | *(data_buf + 17));     
    			ano_cache.pid3_i = 0.001f*((int)(*(data_buf + 18) << 8) | *(data_buf + 19));     
    			ano_cache.pid3_d = 0.001f*((int)(*(data_buf + 20) << 8) | *(data_buf + 21));     
    			ano_dt_send_check(sp, *(data_buf + 2), sum);
    			ROS_INFO("PID1 update");
    		}
    		//PID2
    		if (*(data_buf + 2) == 0X11)
    		{
    			ano_cache.pid4_p = 0.001f*((int)(*(data_buf + 4) << 8) | *(data_buf + 5));       
    			ano_cache.pid4_i = 0.001f*((int)(*(data_buf + 6) << 8) | *(data_buf + 7));       
    			ano_cache.pid4_d = 0.001f*((int)(*(data_buf + 8) << 8) | *(data_buf + 9));       
    
    			ano_cache.pid5_p = 0.001f*((int)(*(data_buf + 10) << 8) | *(data_buf + 11));     
    			ano_cache.pid5_i = 0.001f*((int)(*(data_buf + 12) << 8) | *(data_buf + 13));     
    			ano_cache.pid5_d = 0.001f*((int)(*(data_buf + 14) << 8) | *(data_buf + 15));     
    
    			ano_cache.pid6_p = 0.001f*((int)(*(data_buf + 16) << 8) | *(data_buf + 17));     
    			ano_cache.pid6_i = 0.001f*((int)(*(data_buf + 18) << 8) | *(data_buf + 19));     
    			ano_cache.pid6_d = 0.001f*((int)(*(data_buf + 20) << 8) | *(data_buf + 21));     
    			ano_dt_send_check(sp, *(data_buf + 2), sum);
    		}
    		//PID3
    		if (*(data_buf + 2) == 0X12)
    		{
    			ano_cache.pid7_p = 0.001f*((int)(*(data_buf + 4) << 8) | *(data_buf + 5));       
    			ano_cache.pid7_i = 0.001f*((int)(*(data_buf + 6) << 8) | *(data_buf + 7));       
    			ano_cache.pid7_d = 0.001f*((int)(*(data_buf + 8) << 8) | *(data_buf + 9));       
    
    			ano_cache.pid8_p = 0.001f*((int)(*(data_buf + 10) << 8) | *(data_buf + 11));     
    			ano_cache.pid8_i = 0.001f*((int)(*(data_buf + 12) << 8) | *(data_buf + 13));     
    			ano_cache.pid8_d = 0.001f*((int)(*(data_buf + 14) << 8) | *(data_buf + 15));     
    
    			ano_cache.pid9_p = 0.001f*((int)(*(data_buf + 16) << 8) | *(data_buf + 17));     
    			ano_cache.pid9_i = 0.001f*((int)(*(data_buf + 18) << 8) | *(data_buf + 19));     
    			ano_cache.pid9_d = 0.001f*((int)(*(data_buf + 20) << 8) | *(data_buf + 21));     
    			ano_dt_send_check(sp, *(data_buf + 2), sum);
    		}
    		//PID4
    		if (*(data_buf + 2) == 0X13)
    		{
    			ano_cache.pid10_p = 0.001f*((int)(*(data_buf + 4) << 8) | *(data_buf + 5));      
    			ano_cache.pid10_i = 0.001f*((int)(*(data_buf + 6) << 8) | *(data_buf + 7));      
    			ano_cache.pid10_d = 0.001f*((int)(*(data_buf + 8) << 8) | *(data_buf + 9));      
    
    			ano_cache.pid11_p = 0.001f*((int)(*(data_buf + 10) << 8) | *(data_buf + 11));    
    			ano_cache.pid11_i = 0.001f*((int)(*(data_buf + 12) << 8) | *(data_buf + 13));    
    			ano_cache.pid11_d = 0.001f*((int)(*(data_buf + 14) << 8) | *(data_buf + 15));    
    
    			ano_cache.pid12_p = 0.001f*((int)(*(data_buf + 16) << 8) | *(data_buf + 17));    
    			ano_cache.pid12_i = 0.001f*((int)(*(data_buf + 18) << 8) | *(data_buf + 19));    
    			ano_cache.pid12_d = 0.001f*((int)(*(data_buf + 20) << 8) | *(data_buf + 21));    
    			ano_dt_send_check(sp, *(data_buf + 2), sum);
    		}
    		//PID5
    		if (*(data_buf + 2) == 0X14)
    		{
    			ano_cache.pid13_p = 0.001f*((int)(*(data_buf + 4) << 8) | *(data_buf + 5));
    			ano_cache.pid13_i = 0.001f*((int)(*(data_buf + 6) << 8) | *(data_buf + 7));
    			ano_cache.pid13_d = 0.001f*((int)(*(data_buf + 8) << 8) | *(data_buf + 9));
    
    			ano_cache.pid14_p = 0.001f*((int)(*(data_buf + 10) << 8) | *(data_buf + 11));
    			ano_cache.pid14_i = 0.001f*((int)(*(data_buf + 12) << 8) | *(data_buf + 13));
    			ano_cache.pid14_d = 0.001f*((int)(*(data_buf + 14) << 8) | *(data_buf + 15));
    
    			ano_cache.pid15_p = 0.001f*((int)(*(data_buf + 16) << 8) | *(data_buf + 17));
    			ano_cache.pid15_i = 0.001f*((int)(*(data_buf + 18) << 8) | *(data_buf + 19));
    			ano_cache.pid15_d = 0.001f*((int)(*(data_buf + 20) << 8) | *(data_buf + 21));
    			ano_dt_send_check(sp, *(data_buf + 2), sum);
    		}
    		//PID6
    		if (*(data_buf + 2) == 0X15)
    		{
    			ano_cache.pid16_p = 0.001f*((int)(*(data_buf + 4) << 8) | *(data_buf + 5));
    			ano_cache.pid16_i = 0.001f*((int)(*(data_buf + 6) << 8) | *(data_buf + 7));
    			ano_cache.pid16_d = 0.001f*((int)(*(data_buf + 8) << 8) | *(data_buf + 9));
    
    			ano_cache.pid17_p = 0.001f*((int)(*(data_buf + 10) << 8) | *(data_buf + 11));
    			ano_cache.pid17_i = 0.001f*((int)(*(data_buf + 12) << 8) | *(data_buf + 13));
    			ano_cache.pid17_d = 0.001f*((int)(*(data_buf + 14) << 8) | *(data_buf + 15));
    
    			ano_cache.pid18_p = 0.001f*((int)(*(data_buf + 16) << 8) | *(data_buf + 17));
    			ano_cache.pid18_i = 0.001f*((int)(*(data_buf + 18) << 8) | *(data_buf + 19));
    			ano_cache.pid18_d = 0.001f*((int)(*(data_buf + 20) << 8) | *(data_buf + 21));
    			ano_dt_send_check(sp, *(data_buf + 2), sum);
    		}
    	}
    
    	void ano_dt_send_check(serial::Serial* sp, uint8_t head, uint8_t check_sum)
    	{
    		ano_data_to_send[0] = 0xAA;
    		ano_data_to_send[1] = 0xAA;
    		ano_data_to_send[2] = 0xEF;
    		ano_data_to_send[3] = 2;
    		ano_data_to_send[4] = head;
    		ano_data_to_send[5] = check_sum;
    
    		uint8_t sum = 0;
    		for (uint8_t i = 0; i<6; i++)
    			sum += ano_data_to_send[i];
    		ano_data_to_send[6] = sum;
    
    		//ano_usart_send_data(ano_data_to_send, 7);
    		sp->write(ano_data_to_send, 7);
    	}
    
    	void send_pid_to_ano_tc(serial::Serial* sp)
    	{
    		if (send_pid_para)
    		{
    			if (send_pid_para == 1)
    			{
    				ano_dt_send_pid(sp, 1, ano_cache.pid1_p, ano_cache.pid1_i, ano_cache.pid1_d , ano_cache.pid2_p, ano_cache.pid2_i, ano_cache.pid2_d, ano_cache.pid3_p, ano_cache.pid3_i, ano_cache.pid3_d);
    				send_pid_para++;
    				//return;
    			}
    			if (send_pid_para == 2)
    			{
    				ano_dt_send_pid(sp, 2, ano_cache.pid4_p, ano_cache.pid4_i, ano_cache.pid4_d, ano_cache.pid5_p, ano_cache.pid5_i, ano_cache.pid5_d, ano_cache.pid6_p, ano_cache.pid6_i, ano_cache.pid6_d);
    				send_pid_para++;
    				//return;
    			}
    			if (send_pid_para == 3)
    			{
    				ano_dt_send_pid(sp, 3, ano_cache.pid7_p, ano_cache.pid7_i, ano_cache.pid7_d, ano_cache.pid8_p, ano_cache.pid8_i, ano_cache.pid8_d, ano_cache.pid9_p, ano_cache.pid9_i, ano_cache.pid9_d);
    				send_pid_para++;
    				//return;
    			}
    			if (send_pid_para == 4)
    			{
    				ano_dt_send_pid(sp, 4, ano_cache.pid10_p, ano_cache.pid10_i, ano_cache.pid10_d, ano_cache.pid11_p, ano_cache.pid11_i, ano_cache.pid11_d, ano_cache.pid12_p, ano_cache.pid12_i, ano_cache.pid12_d);
    				send_pid_para++;
    				//return;
    			}
    			if (send_pid_para == 5)
    			{
    				ano_dt_send_pid(sp, 5, ano_cache.pid13_p, ano_cache.pid13_i, ano_cache.pid13_d, ano_cache.pid14_p, ano_cache.pid14_i, ano_cache.pid14_d, ano_cache.pid15_p, ano_cache.pid15_i, ano_cache.pid15_d);
    				send_pid_para++;
    				//return;
    			}
    			if (send_pid_para == 6)
    			{
    				ano_dt_send_pid(sp, 6, ano_cache.pid16_p, ano_cache.pid16_i, ano_cache.pid16_d, ano_cache.pid17_p, ano_cache.pid17_i, ano_cache.pid17_d, ano_cache.pid18_p, ano_cache.pid18_i, ano_cache.pid18_d);
    				send_pid_para = 0;
    				//return;
    			}
    			//send_pid_para++;
    			return;
    		}
    	}
    
    	void ano_dt_send_pid(serial::Serial* sp, uint8_t group, float p1_p, float p1_i, float p1_d, float p2_p, float p2_i, float p2_d, float p3_p, float p3_i, float p3_d)
    	{
    		uint8_t _cnt = 0;
    		int16_t _temp;
    
    		ano_data_to_send[_cnt++] = 0xAA;
    		ano_data_to_send[_cnt++] = 0xAA;
    		ano_data_to_send[_cnt++] = 0x10 + group - 1;
    		ano_data_to_send[_cnt++] = 0;
    
    		_temp = (short)(p1_p * 1000);
    		ano_data_to_send[_cnt++] = BYTE1(_temp);
    		ano_data_to_send[_cnt++] = BYTE0(_temp);
    		_temp = (short)(p1_i * 1000);
    		ano_data_to_send[_cnt++] = BYTE1(_temp);
    		ano_data_to_send[_cnt++] = BYTE0(_temp);
    		_temp = (short)(p1_d * 1000);
    		ano_data_to_send[_cnt++] = BYTE1(_temp);
    		ano_data_to_send[_cnt++] = BYTE0(_temp);
    		_temp = (short)(p2_p * 1000);
    		ano_data_to_send[_cnt++] = BYTE1(_temp);
    		ano_data_to_send[_cnt++] = BYTE0(_temp);
    		_temp = (short)(p2_i * 1000);
    		ano_data_to_send[_cnt++] = BYTE1(_temp);
    		ano_data_to_send[_cnt++] = BYTE0(_temp);
    		_temp = (short)(p2_d * 1000);
    		ano_data_to_send[_cnt++] = BYTE1(_temp);
    		ano_data_to_send[_cnt++] = BYTE0(_temp);
    		_temp = (short)(p3_p * 1000);
    		ano_data_to_send[_cnt++] = BYTE1(_temp);
    		ano_data_to_send[_cnt++] = BYTE0(_temp);
    		_temp = (short)(p3_i * 1000);
    		ano_data_to_send[_cnt++] = BYTE1(_temp);
    		ano_data_to_send[_cnt++] = BYTE0(_temp);
    		_temp = (short)(p3_d * 1000);
    		ano_data_to_send[_cnt++] = BYTE1(_temp);
    		ano_data_to_send[_cnt++] = BYTE0(_temp);
    
    		ano_data_to_send[3] = _cnt - 4;
    
    		uint8_t sum = 0;
    		for (uint8_t i = 0; i<_cnt; i++)
    			sum += ano_data_to_send[i];
    
    		ano_data_to_send[_cnt++] = sum;
    
    		//ano_usart_send_data(ano_data_to_send, _cnt);
    		sp->write(ano_data_to_send, _cnt);
    	}
    
    };
    
    #endif
    
    

    ROS发送数据至匿名地面站

    //serial_port.cpp
    #include <ros/ros.h>
    #include "serial/serial.h"
    #include <iostream>
    #include <math.h>
    #include "ano_tc_v4/sdk_ano_tc_v4.hpp"
    
    SDK_ANO_TC_V4 ano_tc;
    serial::Serial sp;
    
    int main(int argc, char** argv)
    {
        ros::init(argc, argv, "serial_port");
        ros::NodeHandle nh;
        //
        ano_tc.set_dev(&sp,"/dev/ttyUSB1",57600);
        ano_tc.open_dev(&sp);
        // simulate sin data
        double t = 0.0f;
        ros::Rate loop_rate(20);	// 测试发送功能时,过高的频率会造成ubuntu系统异常
        while (ros::ok())
        {   
            ano_tc.receive_info_from_ano_tc(&sp);
            t = t + 0.001;
            int16_t sin_1 = 1000.0f*sin(1*t);
            int16_t sin_2 = 1000.0f*sin(2*t);
            int16_t sin_3 = 1000.0f*sin(3*t);
            int16_t sin_4 = 1000.0f*sin(4*t);
            int16_t sin_5 = 1000.0f*sin(5*t);
            int16_t sin_6 = 1000.0f*sin(6*t);
            int16_t sin_7 = 1000.0f*sin(7*t);
            int16_t sin_8 = 1000.0f*sin(8*t);
            int16_t sin_9 = 1000.0f*sin(9*t); 
            ano_tc.send_15_data(
                &sp,
                sin_1,sin_2,sin_3,
                sin_4,sin_5,sin_6,
                sin_7,sin_8,sin_9,
                10.0,11.0,12.0,
                0,0,0);
            ros::spinOnce();
            loop_rate.sleep();
        }
                       
        ano_tc.close_dev(&sp);
     
        return 0;
    }
    

    在这里插入图片描述

    匿名地面站发送数据至ROS

    删除上一小节main里while中的

    		t = t + 0.001;
            int16_t sin_1 = 1000.0f*sin(1*t);
            int16_t sin_2 = 1000.0f*sin(2*t);
            int16_t sin_3 = 1000.0f*sin(3*t);
            int16_t sin_4 = 1000.0f*sin(4*t);
            int16_t sin_5 = 1000.0f*sin(5*t);
            int16_t sin_6 = 1000.0f*sin(6*t);
            int16_t sin_7 = 1000.0f*sin(7*t);
            int16_t sin_8 = 1000.0f*sin(8*t);
            int16_t sin_9 = 1000.0f*sin(9*t); 
            ano_tc.send_15_data(
                &sp,
                sin_1,sin_2,sin_3,
                sin_4,sin_5,sin_6,
                sin_7,sin_8,sin_9,
                10.0,11.0,12.0,
                0,0,0);
    

    仅保留

    ano_tc.receive_info_from_ano_tc(&sp);
    

    最后,即正式使用的程序为

    //serial_port.cpp
    #include <ros/ros.h>
    #include "serial/serial.h"
    #include <iostream>
    #include <math.h>
    #include "ano_tc_v4/sdk_ano_tc_v4.hpp"
    
    SDK_ANO_TC_V4 ano_tc;
    serial::Serial sp;
    
    int main(int argc, char** argv)
    {
        ros::init(argc, argv, "serial_port");
        ros::NodeHandle nh;
        //
        ano_tc.set_dev(&sp,"/dev/ttyUSB1",57600);
        ano_tc.open_dev(&sp);
        // simulate sin data
        ros::Rate loop_rate(5760);	// 
        while (ros::ok())
        {   
            ano_tc.receive_info_from_ano_tc(&sp);
            ros::spinOnce();
            loop_rate.sleep();
        }
                       
        ano_tc.close_dev(&sp);
     
        return 0;
    }
    

    此处仅演示从ROS中获取数据显示在匿名地面站上的效果
    在这里插入图片描述

    展开全文
  • 匿名_地面站V3.1

    2018-04-21 18:21:28
    匿名地面站上位机V3.1.......................................
  • 匿名V7地面站协议代码,有发送有接受
  • 匿名上位机地面站-4.34
  • 匿名科创地面站.rar

    2017-09-29 09:36:09
    匿名科创地面站.rar ANO_TC匿名科创地面站v4.22.exe 无人机飞控程序开发所用的工具
  • 匿名四轴地面站V4.5使用方法研究

    千次阅读 2019-03-24 23:29:56
    匿名四轴作为一个玩四轴的人必备入门级工具,匿名地面站简直好用的一批,这里有匿名科创对他们的地面站的介绍和下载方法,匿名视频。可谓功能相当强大,使用起来及其方便,大家如果想获得资源可以直接从网上寻找下载...

    匿名四轴作为一个玩四轴的人必备入门级工具,匿名地面站简直好用的一批,这里有匿名科创对他们的地面站的介绍和下载方法,匿名视频。可谓功能相当强大,使用起来及其方便,大家如果想获得资源可以直接从网上寻找下载,本文主要对匿名地面站4.50版本进行协议解析,让大家理解相关的通讯协议,便于使用先进的资源进行小四轴的调试使用。

    地面站相关协议解析

    所谓的通讯协议,说白了就是一个暗号,你要和地面站进行通讯,就要按照地面站制定的规则进行通讯,首先要先向地面站汇报统一暗号(0xaaa)然后是你来的任务(编码位)有多少东西(数据位长度),你带来的东西(想要传输的数据),最终确认(校验值)。大家只需要按照这个已经约定好的暗号和地面站通讯,他就能理解我们带来了什么,同样地面站也会以另一种格式传输给我们相关的指令但是基本类似,只需要按照约定好的内容对传来的指令进行解析就能得到相应的数据。

    数据传输指令
    
    /
    //Data_Exchange函数处理各种数据发送请求,比如想实现每5ms发送一次传感器数据至上位机,即在此函数内实现
    void ANO_DT_Data_Exchange(void)
    {
        static u8 cnt = 0;
        static u8 senser_cnt    = 10;
        static u8 status_cnt    = 15;
        static u8 rcdata_cnt    = 20;
        static u8 motopwm_cnt   = 20;
        static u8 power_cnt     =   50;
        
        if((cnt % senser_cnt) == (senser_cnt-1))
            f.send_senser = 1;  
    
        if((cnt % status_cnt) == (status_cnt-1))
            f.send_status = 1;  
        
        if((cnt % rcdata_cnt) == (rcdata_cnt-1))
            f.send_rcdata = 1;  
        
        if((cnt % motopwm_cnt) == (motopwm_cnt-1))
            f.send_motopwm = 1; 
        
        if((cnt % power_cnt) == (power_cnt-1))
            f.send_power = 1;       
        
        cnt++;
    /
        if(f.send_version)
        {
            f.send_version = 0;
            ANO_DT_Send_Version(4,300,100,400,0);
        }
    /
        else if(f.send_status)
        {
            f.send_status = 0;
            ANO_DT_Send_Status(Roll,Pitch,Yaw,baroAlt,0,fly_ready);
        }   
    /
        else if(f.send_senser)
        {
            f.send_senser = 0;
            ANO_DT_Send_Senser(mpu6050.Acc.x,mpu6050.Acc.y,mpu6050.Acc.z, mpu6050.Gyro.x,mpu6050.Gyro.y,mpu6050.Gyro.z,ak8975.Mag_Adc.x,ak8975.Mag_Adc.y,ak8975.Mag_Adc.z,0);
        }   
    /
        else if(f.send_rcdata)
        {
            f.send_rcdata = 0;
            ANO_DT_Send_RCData(Rc_Pwm_In[0],Rc_Pwm_In[1],Rc_Pwm_In[2],Rc_Pwm_In[3],Rc_Pwm_In[4],Rc_Pwm_In[5],Rc_Pwm_In[6],Rc_Pwm_In[7],0,0);
        }   
    /   
        else if(f.send_motopwm)
        {
            f.send_motopwm = 0;
            ANO_DT_Send_MotoPWM(1,2,3,4,5,6,7,8);
        }   
    /
        else if(f.send_power)
        {
            f.send_power = 0;
            ANO_DT_Send_Power(123,456);
        }
    /
        else if(f.send_pid1)
        {
            f.send_pid1 = 0;
            ANO_DT_Send_PID(1,ctrl_1.PID[PIDROLL].kp,ctrl_1.PID[PIDROLL].ki,ctrl_1.PID[PIDROLL].kd,ctrl_1.PID[PIDPITCH].kp,ctrl_1.PID[PIDPITCH].ki,ctrl_1.PID[PIDPITCH].kd,ctrl_1.PID[PIDYAW].kp,ctrl_1.PID[PIDYAW].ki,ctrl_1.PID[PIDYAW].kd);
        }   
    /
        else if(f.send_pid2)
        {
            f.send_pid2 = 0;
            ANO_DT_Send_PID(2,ctrl_1.PID[PID4].kp,ctrl_1.PID[PID4].ki,ctrl_1.PID[PID4].kd,ctrl_1.PID[PID5].kp,ctrl_1.PID[PID5].ki,ctrl_1.PID[PID5].kd, ctrl_1.PID[PID6].kp,ctrl_1.PID[PID6].ki,ctrl_1.PID[PID6].kd);
        }
    /
        else if(f.send_pid3)
        {
            f.send_pid3 = 0;
            ANO_DT_Send_PID(3,ctrl_2.PID[PIDROLL].kp,ctrl_2.PID[PIDROLL].ki,ctrl_2.PID[PIDROLL].kd,ctrl_2.PID[PIDPITCH].kp,ctrl_2.PID[PIDPITCH].ki,ctrl_2.PID[PIDPITCH].kd,ctrl_2.PID[PIDYAW].kp,ctrl_2.PID[PIDYAW].ki,ctrl_2.PID[PIDYAW].kd);
        }
    /
    }
    

    这个函数执行的功能其实就是判断一下我多久该发一次数据,有些数据比较重要(比如姿态信息)需要经常传输一下,有些相对而言更新慢一点没有太大问题(比如电压),而有一些只需要等待接收到发送指令以后再发送就OK(比如PID信息),然后得到相应的命令以后将数据按照约定的格式传输给上位机。

    数据传输
    
        void ANO_DT_Send_Power(u16 votage, u16 current)
    {
        u8 _cnt=0;
        u16 temp;
        
        data_to_send[_cnt++]=0xAA;
        data_to_send[_cnt++]=0xAA;
        data_to_send[_cnt++]=0x05;
        data_to_send[_cnt++]=0;
        
        temp = votage;
        data_to_send[_cnt++]=BYTE1(temp);
        data_to_send[_cnt++]=BYTE0(temp);
        temp = current;
        data_to_send[_cnt++]=BYTE1(temp);
        data_to_send[_cnt++]=BYTE0(temp);
        
        data_to_send[3] = _cnt-4;
        
        u8 sum = 0;
        for(u8 i=0;i<_cnt;i++)
            sum += data_to_send[i];
        
        data_to_send[_cnt++]=sum;
        
        ANO_DT_Send_Data(data_to_send, _cnt);
    }
    
    

    这个是传输电压和电源的传输协议,协议内容也是按照前面已经规定的格式进行传输的,发送帧头,功能码,数据内容,校验值等相关的内容。函数任务就是将这些信息都整合到一个数组里面,然后将相关的内容通过使用的数据传输方式进行数据传输。传输其他的内容乃至高级数据都是通过类似的方式完成的。在此不多做介绍。

    传输方式定义并传输
    void ANO_DT_Send_Data(u8 *dataToSend , u8 length)
    {
    #ifdef ANO_DT_USE_USB_HID
        Usb_Hid_Adddata(data_to_send,length);
    #endif
    #ifdef ANO_DT_USE_USART2
        Usart2_Send(data_to_send, length);
    #endif
    }
    

    这个其实就是一个传输函数,前面两个函数已经确定了数据格式,这里只需要根据相关的东西进行数据传输,传输格式可以根据自己方便进行选择,比如USB,或者串口模块等等。

    接收数据解析
    void ANO_DT_Data_Receive_Prepare(u8 data)
    {
        static u8 RxBuffer[50];
        static u8 _data_len = 0,_data_cnt = 0;
        static u8 state = 0;
        
        if(state==0&&data==0xAA)
        {
            state=1;
            RxBuffer[0]=data;
        }
        else if(state==1&&data==0xAF)
        {
            state=2;
            RxBuffer[1]=data;
        }
        else if(state==2&&data<0XF1)
        {
            state=3;
            RxBuffer[2]=data;
        }
        else if(state==3&&data<50)
        {
            state = 4;
            RxBuffer[3]=data;
            _data_len = data;
            _data_cnt = 0;
        }
        else if(state==4&&_data_len>0)
        {
            _data_len--;
            RxBuffer[4+_data_cnt++]=data;
            if(_data_len==0)
                state = 5;
        }
        else if(state==5)
        {
            state = 0;
            RxBuffer[4+_data_cnt]=data;
            ANO_DT_Data_Receive_Anl(RxBuffer,_data_cnt+5);
        }
        else
            state = 0;
    }
    

    首先将接收到的数据进行解析,解析主要是一位一位进行解析,层层递进,将解析得到的数据传过来,和相应的协议进行对比,如果正确就将数据传输到下一个模块

    数据赋值
    void ANO_DT_Data_Receive_Anl(u8 *data_buf,u8 num)
    {
        u8 sum = 0;
        for(u8 i=0;i<(num-1);i++)
            sum += *(data_buf+i);
        if(!(sum==*(data_buf+num-1)))       return;     //判断sum
        if(!(*(data_buf)==0xAA && *(data_buf+1)==0xAF))     return;     //判断帧头
        
        if(*(data_buf+2)==0X01)
        {
            if(*(data_buf+4)==0X01)
                mpu6050.Acc_CALIBRATE = 1;
            if(*(data_buf+4)==0X02)
                mpu6050.Gyro_CALIBRATE = 1;
            if(*(data_buf+4)==0X03)
            {
                mpu6050.Acc_CALIBRATE = 1;      
                mpu6050.Gyro_CALIBRATE = 1;         
            }
        }
        
        if(*(data_buf+2)==0X02)
        {
            if(*(data_buf+4)==0X01)
            {
                f.send_pid1 = 1;
                f.send_pid2 = 1;
                f.send_pid3 = 1;
                f.send_pid4 = 1;
                f.send_pid5 = 1;
                f.send_pid6 = 1;
            }
            if(*(data_buf+4)==0X02)
            {
                
            }
            if(*(data_buf+4)==0XA0)     //读取版本信息
            {
                f.send_version = 1;
            }
            if(*(data_buf+4)==0XA1)     //恢复默认参数
            {
                Para_ResetToFactorySetup();
            }
        }
    
        if(*(data_buf+2)==0X10)                             //PID1
        {
            ctrl_1.PID[PIDROLL].kp  = 0.001*( (vs16)(*(data_buf+4)<<8)|*(data_buf+5) );
            ctrl_1.PID[PIDROLL].ki  = 0.001*( (vs16)(*(data_buf+6)<<8)|*(data_buf+7) );
            ctrl_1.PID[PIDROLL].kd  = 0.001*( (vs16)(*(data_buf+8)<<8)|*(data_buf+9) );
            ctrl_1.PID[PIDPITCH].kp = 0.001*( (vs16)(*(data_buf+10)<<8)|*(data_buf+11) );
            ctrl_1.PID[PIDPITCH].ki = 0.001*( (vs16)(*(data_buf+12)<<8)|*(data_buf+13) );
            ctrl_1.PID[PIDPITCH].kd = 0.001*( (vs16)(*(data_buf+14)<<8)|*(data_buf+15) );
            ctrl_1.PID[PIDYAW].kp   = 0.001*( (vs16)(*(data_buf+16)<<8)|*(data_buf+17) );
            ctrl_1.PID[PIDYAW].ki   = 0.001*( (vs16)(*(data_buf+18)<<8)|*(data_buf+19) );
            ctrl_1.PID[PIDYAW].kd   = 0.001*( (vs16)(*(data_buf+20)<<8)|*(data_buf+21) );
            ANO_DT_Send_Check(*(data_buf+2),sum);
                    Param_SavePID();
        }
        if(*(data_buf+2)==0X11)                             //PID2
        {
            ctrl_1.PID[PID4].kp     = 0.001*( (vs16)(*(data_buf+4)<<8)|*(data_buf+5) );
            ctrl_1.PID[PID4].ki     = 0.001*( (vs16)(*(data_buf+6)<<8)|*(data_buf+7) );
            ctrl_1.PID[PID4].kd     = 0.001*( (vs16)(*(data_buf+8)<<8)|*(data_buf+9) );
            ctrl_1.PID[PID5].kp     = 0.001*( (vs16)(*(data_buf+10)<<8)|*(data_buf+11) );
            ctrl_1.PID[PID5].ki     = 0.001*( (vs16)(*(data_buf+12)<<8)|*(data_buf+13) );
            ctrl_1.PID[PID5].kd     = 0.001*( (vs16)(*(data_buf+14)<<8)|*(data_buf+15) );
            ctrl_1.PID[PID6].kp   = 0.001*( (vs16)(*(data_buf+16)<<8)|*(data_buf+17) );
            ctrl_1.PID[PID6].ki     = 0.001*( (vs16)(*(data_buf+18)<<8)|*(data_buf+19) );
            ctrl_1.PID[PID6].kd     = 0.001*( (vs16)(*(data_buf+20)<<8)|*(data_buf+21) );
            ANO_DT_Send_Check(*(data_buf+2),sum);
                    Param_SavePID();
        }
        if(*(data_buf+2)==0X12)                             //PID3
        {   
            ctrl_2.PID[PIDROLL].kp  = 0.001*( (vs16)(*(data_buf+4)<<8)|*(data_buf+5) );
            ctrl_2.PID[PIDROLL].ki  = 0.001*( (vs16)(*(data_buf+6)<<8)|*(data_buf+7) );
            ctrl_2.PID[PIDROLL].kd  = 0.001*( (vs16)(*(data_buf+8)<<8)|*(data_buf+9) );
            ctrl_2.PID[PIDPITCH].kp = 0.001*( (vs16)(*(data_buf+10)<<8)|*(data_buf+11) );
            ctrl_2.PID[PIDPITCH].ki = 0.001*( (vs16)(*(data_buf+12)<<8)|*(data_buf+13) );
            ctrl_2.PID[PIDPITCH].kd = 0.001*( (vs16)(*(data_buf+14)<<8)|*(data_buf+15) );
            ctrl_2.PID[PIDYAW].kp   = 0.001*( (vs16)(*(data_buf+16)<<8)|*(data_buf+17) );
            ctrl_2.PID[PIDYAW].ki   = 0.001*( (vs16)(*(data_buf+18)<<8)|*(data_buf+19) );
            ctrl_2.PID[PIDYAW].kd   = 0.001*( (vs16)(*(data_buf+20)<<8)|*(data_buf+21) );
            ANO_DT_Send_Check(*(data_buf+2),sum);
                    Param_SavePID();
        }
        if(*(data_buf+2)==0X13)                             //PID4
        {
            ANO_DT_Send_Check(*(data_buf+2),sum);
        }
        if(*(data_buf+2)==0X14)                             //PID5
        {
            ANO_DT_Send_Check(*(data_buf+2),sum);
        }
        if(*(data_buf+2)==0X15)                             //PID6
        {
            ANO_DT_Send_Check(*(data_buf+2),sum);
        }
    }
    
    

    本模块代码虽多,但执行的功能相对比较简单,主要是将传过来的八位数据转换成对应格式的数据然后更新到相对应的变量里面。

    展开全文
  • 匿名飞控地面站V6.0

    2018-05-22 17:41:41
    匿名飞控的地面站V6.0,适合于调匿名飞控的各项参数等,通过串口发送。
  • 匿名科创地面站

    2017-07-09 12:49:56
    分享更多需要的人
  • ANO_TC匿名科创地面站v4.06
  • 匿名飞控地面站

    2017-11-03 21:11:30
    哪位大神有匿名地面站开源代码?谢谢各位大神!
  • ANO_TC匿名科创地面站v4.34.zip
  • 匿名科创四轴通用地面站,各位需要的小伙伴欢迎下载,配合匿名开源四轴更好玩效果更好哦
  • ANO_TC匿名科创地面站v4.exe
  • 这个匿名的PC地面站,现在免费分享。

空空如也

空空如也

1 2 3
收藏数 59
精华内容 23
关键字:

匿名地面站