移植MAVLINK到STM32详细教程之三

在前面教程的基础上继续移植优化，之前的没有加缓冲区，没有接收函数功能，这里进行统一的讲解                            作者：恒久力行  qq:624668529

缓冲区对于接受来说很有必要，为了数据的稳定性和实时性必须要加上缓冲。没有缓冲很容易造成数据丢失

一：利用之前移植好的工程，在其基础上进行改动

   1.将两个文件mavlink_usart_fifo.h  mavlink_usart_fifo.c添加到工程里（都是关于缓冲区的底层串口加缓冲区函数）

 mavlink_usart_fifo.h

1. #ifndef _USART_FIFO_H_//作者：恒久力行 qq:624668529
2. #define _USART_FIFO_H_
3. #include"stdint.h"
4. #definetrue1
5. #definefalse0
6. typedefstruct _fifo {
7. uint8_t* buf;
8. uint16_t length;
9. uint16_t head;
10. uint16_t tail;
11. }fifo_t;
12. uint8_t fifo_read_ch(fifo_t* fifo,uint8_t* ch);
13. uint8_t fifo_write_ch(fifo_t* fifo,uint8_t ch);
14. uint16_t fifo_free(fifo_t* fifo);
15. uint16_t fifo_used(fifo_t* fifo);
16. void fifo_init(fifo_t* fifo,uint8_t* buf,uint16_t length);
17. uint8_t serial_write_buf(uint8_t* buf,uint16_t length);
18. uint8_t serial_read_ch(void);
19. uint16_t serial_free(void);
20. uint16_t serial_available(void);
21. #endif/*_USART_FIFO_H_*/

 

mavlink_usart_fifo.c

1. #include"sys.h"//作者：恒久力行 qq:624668529
2. #include"mavlink_usart_fifo.h"
4. #define UART_TX_BUFFER_SIZE 255
5. #define UART_RX_BUFFER_SIZE 255
6. fifo_t uart_rx_fifo, uart_tx_fifo;
7. uint8_t uart_tx_buf[UART_TX_BUFFER_SIZE], uart_rx_buf[UART_RX_BUFFER_SIZE];
9. /** @brief 读FIFO
10. * @param fifo 待读缓冲区
11. * *ch 读到的数据
12. * @return
13. * 正确读取，1； 无数据，0
14. */
15. uint8_t fifo_read_ch(fifo_t* fifo,uint8_t* ch)
16. {
17. if(fifo->tail == fifo->head)returnfalse;
18. *ch = fifo->buf[fifo->tail];
20. if(++fifo->tail >= fifo->length) fifo->tail =0;
21. returntrue;
22. }
24. /** @brief 写一字节数据到FIFO
25. * @param fifo 待写入缓冲区
26. * ch 待写入的数据
27. * @return
28. * 正确，1； 缓冲区满，0
29. */
30. uint8_t fifo_write_ch(fifo_t* fifo,uint8_t ch)
31. {
32. uint16_t h = fifo->head;
34. if(++h >= fifo->length) h =0;
35. if(h == fifo->tail)returnfalse;
37. fifo->buf[fifo->head]= ch;
38. fifo->head = h;
39. returntrue;
40. }
42. /** @brief 返回缓冲区剩余字节长度
43. * @param fifo
44. * @return
45. * 剩余空间
46. *
47. * @note 剩余字节长度大于等于2时，才可写入数据
48. */
49. uint16_t fifo_free(fifo_t* fifo)
50. {
51. uint16_t free;
53. if(fifo->head >= fifo->tail) free = fifo->tail +(fifo->length - fifo->head);
54. else free = fifo->tail - fifo->head;
56. return free;
57. }
59. uint16_t fifo_used(fifo_t* fifo)
60. {
61. uint16_t used;
63. if(fifo->head >= fifo->tail) used = fifo->head - fifo->tail;
64. else used = fifo->head +(fifo->length - fifo->tail);
66. return used;
67. }
70. /** @brief 初始化缓冲区
71. * @param *fifo
72. * *buf
73. * length
74. */
75. void fifo_init(fifo_t* fifo,uint8_t* buf,uint16_t length)
76. {
77. uint16_t i;
79. fifo->buf = buf;
80. fifo->length = length;
81. fifo->head =0;
82. fifo->tail =0;
84. for(i=0; i<length; i++) fifo->buf[i]=0;
85. }
87. /** @brief 写数据到串口，启动发射
88. *
89. * @note 数据写入发射缓冲区后，启动发射中断，在中断程序，数据自动发出
90. */
91. uint8_t serial_write_buf(uint8_t* buf,uint16_t length){
92. uint16_t i;
94. if(length ==0)returnfalse;
95. for(i =0; length >0; length--, i++){
96. fifo_write_ch(&uart_tx_fifo, buf[i]);
97. }
98. USART_ITConfig(USART1, USART_IT_TXE, ENABLE);
100. returntrue;
101. }
102. /** @brief 自串口读数据
103. * @return 一字节数据
104. */
105. uint8_t serial_read_ch(void){
106. uint8_t ch;
107. fifo_read_ch(&uart_rx_fifo,&ch);
108. return ch;
109. }
110. /** @breif 检测发射缓冲区剩余字节长度
111. * @return 剩余字节长度
112. */
113. uint16_t serial_free(void){
114. return fifo_free(&uart_tx_fifo);
115. }
116. uint16_t serial_available(void){
117. return fifo_used(&uart_rx_fifo);
118. }
121. void USART1_IRQHandler(void)
122. {
123. uint8_t c;
124. if(USART_GetITStatus(USART1, USART_IT_RXNE)!= RESET)//数据接收终端
125. {
126. c = USART_ReceiveData(USART1);
127. fifo_write_ch(&uart_rx_fifo, c);
128. //USART_ITConfig(USART1, USART_IT_RXNE, DISABLE);
129. }
130. if(USART_GetITStatus(USART1, USART_IT_TXE)!= RESET)//数据发送中断
131. {
132. if(fifo_read_ch(&uart_tx_fifo,&c))
133. USART_SendData(USART1, c);
134. else
135. USART_SendData(USART1,0x55);
136. if(fifo_used(&uart_tx_fifo)==0)// Check if all data is transmitted . if yes disable transmitter UDRE interrupt
137. {
138. // Disable the EVAL_COM1 Transmit interrupt
139. USART_ITConfig(USART1, USART_IT_TXE, DISABLE);
140. }
141. }
142. }

 

2.在usart.c中屏蔽USART1_IRQHandler函数
usart.c全代码

1. #include"sys.h"//作者：恒久力行 qq:624668529
2. #include"usart.h"
3. //////////////////////////////////////////////////////////////////////////////////
4. //如果使用ucos,则包括下面的头文件即可.
5. #if SYSTEM_SUPPORT_OS
6. #include"includes.h"//ucos 使用
7. #endif
8. //////////////////////////////////////////////////////////////////////////////////
9. //本程序只供学习使用，未经作者许可，不得用于其它任何用途
10. //ALIENTEK STM32F4探索者开发板
11. //串口1初始化
12. //正点原子@ALIENTEK
13. //技术论坛:www.openedv.com
14. //修改日期:2014/6/10
15. //版本：V1.5
16. //版权所有，盗版必究。
17. //Copyright(C) 广州市星翼电子科技有限公司 2009-2019
18. //All rights reserved
19. //********************************************************************************
20. //V1.3修改说明
21. //支持适应不同频率下的串口波特率设置.
22. //加入了对printf的支持
23. //增加了串口接收命令功能.
24. //修正了printf第一个字符丢失的bug
25. //V1.4修改说明
26. //1,修改串口初始化IO的bug
27. //2,修改了USART_RX_STA,使得串口最大接收字节数为2的14次方
28. //3,增加了USART_REC_LEN,用于定义串口最大允许接收的字节数(不大于2的14次方)
29. //4,修改了EN_USART1_RX的使能方式
30. //V1.5修改说明
31. //1,增加了对UCOSII的支持
32. //////////////////////////////////////////////////////////////////////////////////
34. //////////////////////////////////////////////////////////////////
35. //加入以下代码,支持printf函数,而不需要选择use MicroLIB
36. #if 1
37. #pragmaimport(__use_no_semihosting)
38. //标准库需要的支持函数
39. struct __FILE
40. {
41. int handle;
42. };
43. FILE __stdout;
44. //定义_sys_exit()以避免使用半主机模式
45. _sys_exit(int x)
46. {
47. x = x;
48. }
49. //重定义fputc函数
50. int fputc(int ch,FILE*f)
51. {
52. while((USART1->SR&0X40)==0);//循环发送,直到发送完毕
53. USART1->DR =(u8) ch;
54. return ch;
55. }
56. #endif
58. #if EN_USART1_RX //如果使能了接收
59. //串口1中断服务程序
60. //注意,读取USARTx->SR能避免莫名其妙的错误
61. u8 USART_RX_BUF[USART_REC_LEN];//接收缓冲,最大USART_REC_LEN个字节.
62. //接收状态
63. //bit15， 接收完成标志
64. //bit14， 接收到0x0d
65. //bit13~0， 接收到的有效字节数目
66. u16 USART_RX_STA=0;//接收状态标记
67. //初始化IO 串口1
68. //bound:波特率
69. void uart_init(u32 bound){
70. //GPIO端口设置
71. GPIO_InitTypeDef GPIO_InitStructure;
72. USART_InitTypeDef USART_InitStructure;
73. NVIC_InitTypeDef NVIC_InitStructure;
75. RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA,ENABLE);//使能GPIOA时钟
76. RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);//使能USART1时钟
78. //串口1对应引脚复用映射
79. GPIO_PinAFConfig(GPIOA,GPIO_PinSource9,GPIO_AF_USART1);//GPIOA9复用为USART1
80. GPIO_PinAFConfig(GPIOA,GPIO_PinSource10,GPIO_AF_USART1);//GPIOA10复用为USART1
82. //USART1端口配置
83. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9 | GPIO_Pin_10;//GPIOA9与GPIOA10
84. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用功能
85. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;//速度50MHz
86. GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;//推挽复用输出
87. GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
88. GPIO_Init(GPIOA,&GPIO_InitStructure);//初始化PA9，PA10
89. //USART1 初始化设置
90. USART_InitStructure.USART_BaudRate = bound;//波特率设置
91. USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
92. USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
93. USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
94. USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
95. USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;//收发模式
96. USART_Init(USART1,&USART_InitStructure);//初始化串口1
98. USART_Cmd(USART1, ENABLE);//使能串口1
100. //USART_ClearFlag(USART1, USART_FLAG_TC);
102. #if EN_USART1_RX
103. USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启相关中断
104. //Usart1 NVIC 配置
105. NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;//串口1中断通道
106. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3;//抢占优先级3
107. NVIC_InitStructure.NVIC_IRQChannelSubPriority =3;//子优先级3
108. NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;//IRQ通道使能
109. NVIC_Init(&NVIC_InitStructure);//根据指定的参数初始化VIC寄存器、
110. #endif
112. }
113. //void USART1_IRQHandler(void) //串口1中断服务程序
114. //{
115. // u8 Res;
116. //#if SYSTEM_SUPPORT_OS //如果SYSTEM_SUPPORT_OS为真，则需要支持OS.
117. // OSIntEnter();
118. //#endif
119. // if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) //接收中断(接收到的数据必须是0x0d 0x0a结尾)
120. // {
121. // Res =USART_ReceiveData(USART1);//(USART1->DR); //读取接收到的数据
122. //
123. // if((USART_RX_STA&0x8000)==0)//接收未完成
124. // {
125. // if(USART_RX_STA&0x4000)//接收到了0x0d
126. // {
127. // if(Res!=0x0a)USART_RX_STA=0;//接收错误,重新开始
128. // else USART_RX_STA|=0x8000; //接收完成了
129. // }
130. // else //还没收到0X0D
131. // {
132. // if(Res==0x0d)USART_RX_STA|=0x4000;
133. // else
134. // {
135. // USART_RX_BUF[USART_RX_STA&0X3FFF]=Res ;
136. // USART_RX_STA++;
137. // if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//接收数据错误,重新开始接收
138. // }
139. // }
140. // }
141. // }
142. //#if SYSTEM_SUPPORT_OS //如果SYSTEM_SUPPORT_OS为真，则需要支持OS.
143. // OSIntExit();
144. //#endif
145. //}
146. #endif

 

3.添加mavlink_avoid_errors.h里面的代码如下，这个代码是用来避免错误的，跟mdk编译器相关的

1. /** @file mavlink_avoid_errors.h//作者：恒久力行 qq:624668529
2. * @简介：本文件是由624668529添加，用来统一解决mavlink报错信息
3. * @see QQ624668529
4. */
5. #ifndef MAVLINK_AVOID_ERRORS_H
6. #define MAVLINK_AVOID_ERRORS_H
7. #include"stdio.h"
8. #include"stdint.h"
10. /*解决..MAVLINKcommon../mavlink_types.h(53): error: #20: identifier "pack" is undefined*/
11. #define MAVPACKED( __Declaration__ ) __Declaration__
13. /*解决..MAVLINKcommon../mavlink_types.h(53): error: #3092: anonymous unions are only supported in --gnu mode, or when enabled with #pragma anon_unions*/
14. #pragma anon_unions
17. #defineinline __inline
19. //#ifndef memset//由624668529添加 2018-08-24
20. //void *memset(void *dest, int data, size_t length) {
21. // uint32_t i;
22. // int *point = dest;
23. // for(i=0; i<length; i++) point[i] = data;
24. // return dest;
25. //}
26. //#endif
27. //#ifndef memcpy//由624668529添加 2018-08-24
28. //void *memcpy(void *dest, const void *src, size_t n)
29. //{
30. // unsigned char *pout = (unsigned char*)dest;
31. // unsigned char *pin = (unsigned char*)src;
32. // while (n-- > 0) *pout++ = *pin++;
33. // return dest;
34. //}
35. //#endif
38. #include"mavlink_types.h"
39. #define MAVLINK_USE_CONVENIENCE_FUNCTIONS
40. //#define MAVLINK_SEPARATE_HELPERS
41. //mavlink_system_t mavlink_system = {0,0};
42. //mavlink_system_t mavlink_system = {
43. // 1,
44. // 1
45. //}; // System ID, 1-255, Component/Subsystem ID, 1-255
49. //void comm_send_ch(mavlink_channel_t chan, uint8_t buf)
50. //{
51. // chan=chan;
52. // USART_SendData(USART1, buf); //向串口1发送数据
53. // while(USART_GetFlagStatus(USART1,USART_FLAG_TC)!=SET);//等待发送结束
54. //}
59. #include"mavlink.h"
60. #include"mavlink_helpers.h"
61. #endif//AVLINK_AVOID_ERRORS_H

 

4.添加open_tel_mavlink.h 和open_tel_mavlink.c 这两个函数是测试mavlink通信的上层代码

open_tel_mavlink.h

2. #ifndef __OPEN_TEL_MAVLINK_H//作者：恒久力行  qq:624668529
3. #define __OPEN_TEL_MAVLINK_H
6. //#include "./minimal/minimal/minimal.h"
7. #include"define.h"
8. #include"mavlink_avoid_errors.h"
9. #include"stdint.h"
13. void mavlink_send_message(mavlink_channel_t chan,enum ap_message id,uint16_t packet_drops);
14. void update(void);
15. void handleMessage(mavlink_message_t* msg);
17. #endif/*__OPENTEL_MAVLINK_H*/

open_tel_mavlink.c

3. #include"open_tel_mavlink.h"//作者：恒久力行  qq:624668529
4. ////#include "mavlink_usart_fifo.h"
5. //#include "mavlink_avoid_errors.h"
6. //#include "mavlink_types.h"
7. //#include "mavlink_avoid_errors.h"
8. #include"define.h"
9. #include"stdint.h"
11. ////Add By BigW
12. typedefuint8_tbool;
13. //typedef struct {
14. // char c;
15. //} prog_char_t;
16. //
17. // This is the state of the flight control system
18. // There are multiple states defined such as STABILIZE, ACRO,
19. staticint8_t control_mode = STABILIZE;
20. mavlink_channel_t chan;
21. //uint16_t packet_drops;
23. mavlink_heartbeat_t heartbeat;
24. mavlink_attitude_t attitude;
25. mavlink_global_position_int_t position;
26. //mavlink_ahrs_t ahrs;
28. uint8_t buf[100];
29. ////End Add By BigW
32. //// -*- tab- 4; Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*-
34. // this costs us 51 bytes, but means that low priority
35. // messages don't block the CPU
36. staticmavlink_statustext_t pending_status;
38. // true when we have received at least 1 MAVLink packet
39. staticbool mavlink_active;
41. // check if a message will fit in the payload space available
42. #define CHECK_PAYLOAD_SIZE(id)if(payload_space < MAVLINK_MSG_ID_ ## id ## _LEN) return false
44. void handleMessage(mavlink_message_t* msg);
46. /*
47. * !!NOTE!!
48. *
49. * the use of NOINLINE separate functions for each message type avoids
50. * a compiler bug in gcc that would cause it to use far more stack
51. * space than is needed. Without the NOINLINE we use the sum of the
52. * stack needed for each message type. Please be careful to follow the
53. * pattern below when adding any new messages
54. */
56. static NOINLINE void send_heartbeat(mavlink_channel_t chan)
57. {
58. uint8_t base_mode = MAV_MODE_FLAG_CUSTOM_MODE_ENABLED;
59. uint8_t system_status = MAV_STATE_ACTIVE;
60. uint32_t custom_mode = control_mode;
62. // work out the base_mode. This value is not very useful
63. // for APM, but we calculate it as best we can so a generic
64. // MAVLink enabled ground station can work out something about
65. // what the MAV is up to. The actual bit values are highly
66. // ambiguous for most of the APM flight modes. In practice, you
67. // only get useful information from the custom_mode, which maps to
68. // the APM flight mode and has a well defined meaning in the
69. // ArduPlane documentation
70. base_mode = MAV_MODE_FLAG_STABILIZE_ENABLED;
71. switch(control_mode){
72. case AUTO:
73. case RTL:
74. case LOITER:
75. case GUIDED:
76. case CIRCLE:
77. base_mode |= MAV_MODE_FLAG_GUIDED_ENABLED;
78. // note that MAV_MODE_FLAG_AUTO_ENABLED does not match what
79. // APM does in any mode, as that is defined as "system finds its own goal
80. // positions", which APM does not currently do
81. break;
82. }
84. // all modes except INITIALISING have some form of manual
85. // override if stick mixing is enabled
86. base_mode |= MAV_MODE_FLAG_MANUAL_INPUT_ENABLED;
88. #if HIL_MODE != HIL_MODE_DISABLED
89. base_mode |= MAV_MODE_FLAG_HIL_ENABLED;
90. #endif
92. // we are armed if we are not initialising
93. if(0){//motors.armed()) {
94. base_mode |= MAV_MODE_FLAG_SAFETY_ARMED;
95. }
97. // indicate we have set a custom mode
98. base_mode |= MAV_MODE_FLAG_CUSTOM_MODE_ENABLED;
100. mavlink_msg_heartbeat_send(
101. chan,
102. MAV_TYPE_QUADROTOR,
103. MAV_AUTOPILOT_ARDUPILOTMEGA,
104. base_mode,
105. custom_mode,
106. system_status);
107. }
109. static NOINLINE void send_attitude(mavlink_channel_t chan)
110. {
111. mavlink_msg_attitude_send(
112. chan,
113. ++buf[1],//millis(),
114. ++buf[2],//ahrs.roll,
115. ++buf[3],//ahrs.pitch,
116. ++buf[4],//ahrs.yaw,
117. ++buf[5],//omega.x,
118. ++buf[6],//omega.y,
119. ++buf[7]);//omega.z);
120. }
122. staticvoid NOINLINE send_location(mavlink_channel_t chan)
123. {
124. //Matrix3f rot = ahrs.get_dcm_matrix(); // neglecting angle of attack for now
125. mavlink_msg_global_position_int_send(
126. chan,
127. 1,//millis(),
128. 2,//current_loc.lat, // in 1E7 degrees
129. 3,//current_loc.lng, // in 1E7 degrees
130. 4,//g_gps->altitude * 10, // millimeters above sea level
131. 5,//(current_loc.alt - home.alt) * 10, // millimeters above ground
132. 6,//g_gps->ground_speed * rot.a.x, // X speed cm/s
133. 7,//g_gps->ground_speed * rot.b.x, // Y speed cm/s
134. 8,//g_gps->ground_speed * rot.c.x,
135. 9);//g_gps->ground_course); // course in 1/100 degree
136. }
138. //static void NOINLINE send_ahrs(mavlink_channel_t chan)
139. //{
140. // //Vector3f omega_I = ahrs.get_gyro_drift();
141. // mavlink_msg_ahrs_send(
142. // chan,
143. // ++buf[8],//omega_I.x,
144. // ++buf[9],//omega_I.y,
145. // ++buf[10],//omega_I.z,
146. // 1,
147. // 0,
148. // ++buf[11],//ahrs.get_error_rp(),
149. // ++buf[12]);//ahrs.get_error_yaw());
150. //}
153. staticvoid NOINLINE send_statustext(mavlink_channel_t chan)
154. {
155. }
157. // are we still delaying telemetry to try to avoid Xbee bricking?
158. staticbool telemetry_delayed(mavlink_channel_t chan)
159. {
160. returnfalse;
161. }
164. // try to send a message, return false if it won't fit in the serial tx buffer
165. staticbool mavlink_try_send_message(mavlink_channel_t chan,enum ap_message id,uint16_t packet_drops)
166. {
167. int16_t payload_space = serial_free();
169. if(telemetry_delayed(chan)){
170. returnfalse;
171. }
173. switch(id){
174. case MSG_HEARTBEAT:
175. CHECK_PAYLOAD_SIZE(HEARTBEAT);
176. send_heartbeat(chan);
177. break;
179. case MSG_ATTITUDE:
180. CHECK_PAYLOAD_SIZE(ATTITUDE);
181. send_attitude(chan);
182. break;
184. case MSG_LOCATION:
185. CHECK_PAYLOAD_SIZE(GLOBAL_POSITION_INT);
186. send_location(chan);
187. break;
189. // case MSG_AHRS:
190. // CHECK_PAYLOAD_SIZE(AHRS);
191. // send_ahrs(chan);
192. // break;
194. case MSG_STATUSTEXT:
195. CHECK_PAYLOAD_SIZE(STATUSTEXT);
196. send_statustext(chan);
197. break;
199. default:
200. break;
201. }
202. returntrue;
203. }
206. #define MAX_DEFERRED_MESSAGES MSG_RETRY_DEFERRED
207. staticstruct mavlink_queue {
208. enum ap_message deferred_messages[MAX_DEFERRED_MESSAGES];
209. uint8_t next_deferred_message;
210. uint8_t num_deferred_messages;
211. } mavlink_queue[2];
213. // send a message using mavlink
214. void mavlink_send_message(mavlink_channel_t chan,enum ap_message id,uint16_t packet_drops)
215. {
216. uint8_t i, nextid;
217. struct mavlink_queue *q =&mavlink_queue[(uint8_t)chan];
219. // see if we can send the deferred messages, if any
220. while(q->num_deferred_messages !=0){
221. if(!mavlink_try_send_message(chan,
222. q->deferred_messages[q->next_deferred_message],
223. packet_drops)){
224. break;
225. }
226. q->next_deferred_message++;
227. if(q->next_deferred_message == MAX_DEFERRED_MESSAGES){
228. q->next_deferred_message =0;
229. }
230. q->num_deferred_messages--;
231. }
233. if(id == MSG_RETRY_DEFERRED){
234. return;
235. }
237. // this message id might already be deferred
238. for(i=0, nextid = q->next_deferred_message; i < q->num_deferred_messages; i++){
239. if(q->deferred_messages[nextid]== id){
240. // its already deferred, discard
241. return;
242. }
243. nextid++;
244. if(nextid == MAX_DEFERRED_MESSAGES){
245. nextid =0;
246. }
247. }
249. if(q->num_deferred_messages !=0||
250. !mavlink_try_send_message(chan, id, packet_drops)){
251. // can't send it now, so defer it
252. if(q->num_deferred_messages == MAX_DEFERRED_MESSAGES){
253. // the defer buffer is full, discard
254. return;
255. }
256. nextid = q->next_deferred_message + q->num_deferred_messages;
257. if(nextid >= MAX_DEFERRED_MESSAGES){
258. nextid -= MAX_DEFERRED_MESSAGES;
259. }
260. q->deferred_messages[nextid]= id;
261. q->num_deferred_messages++;
262. }
263. }
265. void mavlink_send_text(mavlink_channel_t chan,enum gcs_severity severity,char*str)
266. {
267. if(telemetry_delayed(chan)){
268. return;
269. }
271. if(severity == SEVERITY_LOW){
272. // send via the deferred queuing system
273. pending_status.severity =(uint8_t)severity;
274. mav_array_memcpy((char*)pending_status.text, str,sizeof(pending_status.text));
275. mavlink_send_message(chan, MSG_STATUSTEXT,0);
276. }else{
277. // send immediately
278. mavlink_msg_statustext_send(
279. chan,
280. severity,
281. str);
282. }
283. }
286. void update(void)
287. {
288. // receive new packets
289. mavlink_message_t msg;
290. mavlink_status_t status;
291. status.packet_rx_drop_count =0;
293. // process received bytes
294. while(serial_available())
295. {
296. uint8_t c = serial_read_ch();
298. // Try to get a new message
299. if(mavlink_parse_char(chan, c,&msg,&status)){
300. mavlink_active =true;
302. //printf("%c",c);
303. printf("Received message with ID %d, sequence: %d from component %d of system %d",
304. msg.msgid, msg.seq, msg.compid, msg.sysid);
305. handleMessage(&msg);
306. }
307. }
308. }
311. void handleMessage(mavlink_message_t* msg)
312. {
313. //struct Location tell_command = {}; // command for telemetry
314. switch(msg->msgid){
315. case MAVLINK_MSG_ID_HEARTBEAT:{
316. mavlink_msg_heartbeat_decode(msg,&heartbeat);
317. break;
318. }
320. case MAVLINK_MSG_ID_ATTITUDE:{
321. mavlink_msg_attitude_decode(msg,&attitude);
322. break;
323. }
325. case MAVLINK_MSG_ID_GLOBAL_POSITION_INT:{
326. mavlink_msg_global_position_int_decode(msg,&position);
327. break;
328. }
329. //
330. // case MAVLINK_MSG_ID_AHRS: {
331. // mavlink_msg_ahrs_decode(msg, &ahrs);
332. // break;
333. // }
335. default:
336. break;
337. }// end switch
339. }// end handle mavlink

5.添加define.h函数，这里是上层函数的一些结构类型定义，为避免上层报错就添加上（有兴趣的可以自己精简）

1. // -*- tab- 4; Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*-
3. #ifndef _DEFINES_H//作者：恒久力行  qq:624668529
4. #define _DEFINES_H
6. // this avoids a very common config error
7. #define ENABLE ENABLED
8. #define DISABLE DISABLED
10. // Flight modes
11. // ------------
12. #define YAW_HOLD 0
13. #define YAW_ACRO 1
14. #define YAW_AUTO 2
15. #define YAW_LOOK_AT_HOME 3
16. #define YAW_TOY 4// THOR This is the Yaw mode
19. #define ROLL_PITCH_STABLE 0
20. #define ROLL_PITCH_ACRO 1
21. #define ROLL_PITCH_AUTO 2
22. #define ROLL_PITCH_STABLE_OF 3
23. #define ROLL_PITCH_TOY 4// THOR This is the Roll and Pitch
24. // mode
26. #define THROTTLE_MANUAL 0
27. #define THROTTLE_HOLD 1
28. #define THROTTLE_AUTO 2
31. // active altitude sensor
32. // ----------------------
33. #define SONAR 0
34. #define BARO 1
36. #define SONAR_SOURCE_ADC 1
37. #define SONAR_SOURCE_ANALOG_PIN 2
39. // CH 7 control
40. #define CH7_DO_NOTHING 0
41. #define CH7_SET_HOVER 1
42. #define CH7_FLIP 2
43. #define CH7_SIMPLE_MODE 3
44. #define CH7_RTL 4
45. #define CH7_AUTO_TRIM 5
46. #define CH7_ADC_FILTER 6
47. #define CH7_SAVE_WP 7
48. #define CH7_MULTI_MODE 8
51. // Frame types
52. #define QUAD_FRAME 0
53. #define TRI_FRAME 1
54. #define HEXA_FRAME 2
55. #define Y6_FRAME 3
56. #define OCTA_FRAME 4
57. #define HELI_FRAME 5
58. #define OCTA_QUAD_FRAME 6
60. #define PLUS_FRAME 0
61. #define X_FRAME 1
62. #define V_FRAME 2
64. // LED output
65. #define NORMAL_LEDS 0
66. #define AUTO_TRIM_LEDS 1
69. #define CH_7_PWM_TRIGGER 1800
70. #define CH_6_PWM_TRIGGER_HIGH 1800
71. #define CH_6_PWM_TRIGGER 1500
72. #define CH_6_PWM_TRIGGER_LOW 1200
74. // Internal defines, don't edit and expect things to work
75. // -------------------------------------------------------
77. #define TRUE 1
78. #define FALSE 0
79. #defineToRad(x)(x*0.01745329252)// *pi/180
80. #defineToDeg(x)(x*57.2957795131)// *180/pi
82. #define DEBUG 0
83. #define LOITER_RANGE 60// for calculating power outside of loiter radius
85. #define T6 1000000
86. #define T7 10000000
88. // GPS type codes - use the names, not the numbers
89. #define GPS_PROTOCOL_NONE -1
90. #define GPS_PROTOCOL_NMEA 0
91. #define GPS_PROTOCOL_SIRF 1
92. #define GPS_PROTOCOL_UBLOX 2
93. #define GPS_PROTOCOL_IMU 3
94. #define GPS_PROTOCOL_MTK 4
95. #define GPS_PROTOCOL_HIL 5
96. #define GPS_PROTOCOL_MTK16 6
97. #define GPS_PROTOCOL_AUTO 7
99. #define CH_ROLL CH_1
100. #define CH_PITCH CH_2
101. #define CH_THROTTLE CH_3
102. #define CH_RUDDER CH_4
103. #define CH_YAW CH_4
105. #define RC_CHANNEL_ANGLE 0
106. #define RC_CHANNEL_RANGE 1
107. #define RC_CHANNEL_ANGLE_RAW 2
109. // HIL enumerations
110. #define HIL_MODE_DISABLED 0
111. #define HIL_MODE_ATTITUDE 1
112. #define HIL_MODE_SENSORS 2
114. #define ASCENDING 1
115. #define DESCENDING -1
116. #define REACHED_ALT 0
118. // Auto Pilot modes
119. // ----------------
120. #define STABILIZE 0// hold level position
121. #define ACRO 1// rate control
122. #define ALT_HOLD 2// AUTO control
123. #define AUTO 3// AUTO control
124. #define GUIDED 4// AUTO control
125. #define LOITER 5// Hold a single location
126. #define RTL 6// AUTO control
127. #define CIRCLE 7// AUTO control
128. #define POSITION 8// AUTO control
129. #define LAND 9// AUTO control
130. #define OF_LOITER 10// Hold a single location using optical flow
131. // sensor
132. #define TOY_A 11// THOR Enum for Toy mode
133. #define TOY_M 12// THOR Enum for Toy mode
134. #define NUM_MODES 13
136. #define SIMPLE_1 1
137. #define SIMPLE_2 2
138. #define SIMPLE_3 4
139. #define SIMPLE_4 8
140. #define SIMPLE_5 16
141. #define SIMPLE_6 32
143. // CH_6 Tuning
144. // -----------
145. #define CH6_NONE 0
146. // Attitude
147. #define CH6_STABILIZE_KP 1
148. #define CH6_STABILIZE_KI 2
149. #define CH6_STABILIZE_KD 29// duplicate with CH6_DAMP
150. #define CH6_YAW_KP 3
151. #define CH6_YAW_KI 24
152. // Rate
153. #define CH6_ACRO_KP 25
154. #define CH6_RATE_KP 4
155. #define CH6_RATE_KI 5
156. #define CH6_RATE_KD 21
157. #define CH6_YAW_RATE_KP 6
158. #define CH6_YAW_RATE_KD 26
159. // Altitude rate controller
160. #define CH6_THROTTLE_KP 7
161. // Extras
162. #define CH6_TOP_BOTTOM_RATIO 8
163. #define CH6_RELAY 9
164. // Navigation
165. #define CH6_TRAVERSE_SPEED 10// maximum speed to next way point
166. #define CH6_NAV_KP 11
167. #define CH6_LOITER_KP 12
168. #define CH6_LOITER_KI 27
170. // Trad Heli specific
171. #define CH6_HELI_EXTERNAL_GYRO 13
173. // altitude controller
174. #define CH6_THR_HOLD_KP 14
175. #define CH6_Z_GAIN 15
176. #define CH6_DAMP 16// duplicate with CH6_YAW_RATE_KD
178. // optical flow controller
179. #define CH6_OPTFLOW_KP 17
180. #define CH6_OPTFLOW_KI 18
181. #define CH6_OPTFLOW_KD 19
183. #define CH6_NAV_I 20
184. #define CH6_LOITER_RATE_KP 22
185. #define CH6_LOITER_RATE_KI 28
186. #define CH6_LOITER_RATE_KD 23
188. #define CH6_AHRS_YAW_KP 30
189. #define CH6_AHRS_KP 31
192. // nav byte mask
193. // -------------
194. #define NAV_LOCATION 1
195. #define NAV_ALTITUDE 2
196. #define NAV_DELAY 4
199. // Commands - Note that APM now uses a subset of the MAVLink protocol
200. // commands. See enum MAV_CMD in the GCS_Mavlink library
201. #define CMD_BLANK 0// there is no command stored in the mem location
202. // requested
203. #define NO_COMMAND 0
206. #define LOITER_MODE 1
207. #define WP_MODE 2
208. #define CIRCLE_MODE 3
209. #define NO_NAV_MODE 4
210. #define TOY_MODE 5// THOR This mode defines the Virtual
211. // WP following mode
213. // TOY mixing options
214. #define TOY_LOOKUP_TABLE 0
215. #define TOY_LINEAR_MIXER 1
216. #define TOY_EXTERNAL_MIXER 2
219. // Waypoint options
220. #define MASK_OPTIONS_RELATIVE_ALT 1
221. #define WP_OPTION_ALT_CHANGE 2
222. #define WP_OPTION_YAW 4
223. #define WP_OPTION_ALT_REQUIRED 8
224. #define WP_OPTION_RELATIVE 16
225. //#define WP_OPTION_ 32
226. //#define WP_OPTION_ 64
227. #define WP_OPTION_NEXT_CMD 128
229. //repeating events
230. #define NO_REPEAT 0
231. #define CH_5_TOGGLE 1
232. #define CH_6_TOGGLE 2
233. #define CH_7_TOGGLE 3
234. #define CH_8_TOGGLE 4
235. #define RELAY_TOGGLE 5
236. #define STOP_REPEAT 10
238. // GCS Message ID's
239. /// NOTE: to ensure we never block on sending MAVLink messages
240. /// please keep each MSG_ to a single MAVLink message. If need be
241. /// create new MSG_ IDs for additional messages on the same
242. /// stream
243. enum ap_message {
244. MSG_HEARTBEAT,
245. MSG_ATTITUDE,
246. MSG_LOCATION,
247. MSG_EXTENDED_STATUS1,
248. MSG_EXTENDED_STATUS2,
249. MSG_NAV_CONTROLLER_OUTPUT,
250. MSG_CURRENT_WAYPOINT,
251. MSG_VFR_HUD,
252. MSG_RADIO_OUT,
253. MSG_RADIO_IN,
254. MSG_RAW_IMU1,
255. MSG_RAW_IMU2,
256. MSG_RAW_IMU3,
257. MSG_GPS_STATUS,
258. MSG_GPS_RAW,
259. MSG_SERVO_OUT,
260. MSG_NEXT_WAYPOINT,
261. MSG_NEXT_PARAM,
262. MSG_STATUSTEXT,
263. MSG_LIMITS_STATUS,
264. MSG_AHRS,
265. MSG_SIMSTATE,
266. MSG_HWSTATUS,
267. MSG_RETRY_DEFERRED // this must be last
268. };
270. enum gcs_severity {
271. SEVERITY_LOW=1,
272. SEVERITY_MEDIUM,
273. SEVERITY_HIGH,
274. SEVERITY_CRITICAL
275. };
277. // Logging parameters
278. #define TYPE_AIRSTART_MSG 0x00
279. #define TYPE_GROUNDSTART_MSG 0x01
280. #define LOG_ATTITUDE_MSG 0x01
281. #define LOG_GPS_MSG 0x02
282. #define LOG_MODE_MSG 0x03
283. #define LOG_CONTROL_TUNING_MSG 0x04
284. #define LOG_NAV_TUNING_MSG 0x05
285. #define LOG_PERFORMANCE_MSG 0x06
286. #define LOG_RAW_MSG 0x07
287. #define LOG_CMD_MSG 0x08
288. #define LOG_CURRENT_MSG 0x09
289. #define LOG_STARTUP_MSG 0x0A
290. #define LOG_MOTORS_MSG 0x0B
291. #define LOG_OPTFLOW_MSG 0x0C
292. #define LOG_DATA_MSG 0x0D
293. #define LOG_PID_MSG 0x0E
294. #define LOG_ITERM_MSG 0x0F
295. #define LOG_DMP_MSG 0x10
296. #define LOG_INDEX_MSG 0xF0
297. #define MAX_NUM_LOGS 50
299. #define MASK_LOG_ATTITUDE_FAST (1<<0)
300. #define MASK_LOG_ATTITUDE_MED (1<<1)
301. #define MASK_LOG_GPS (1<<2)
302. #define MASK_LOG_PM (1<<3)
303. #define MASK_LOG_CTUN (1<<4)
304. #define MASK_LOG_NTUN (1<<5)
305. #define MASK_LOG_MODE (1<<6)
306. #define MASK_LOG_RAW (1<<7)
307. #define MASK_LOG_CMD (1<<8)
308. #define MASK_LOG_CUR (1<<9)
309. #define MASK_LOG_MOTORS (1<<10)
310. #define MASK_LOG_OPTFLOW (1<<11)
311. #define MASK_LOG_PID (1<<12)
312. #define MASK_LOG_ITERM (1<<13)
315. // Waypoint Modes
316. // ----------------
317. #define ABS_WP 0
318. #define REL_WP 1
320. // Command Queues
321. // ---------------
322. #define COMMAND_MUST 0
323. #define COMMAND_MAY 1
324. #define COMMAND_NOW 2
326. // Events
327. // ------
328. #define EVENT_WILL_REACH_WAYPOINT 1
329. #define EVENT_SET_NEW_WAYPOINT_INDEX 2
330. #define EVENT_LOADED_WAYPOINT 3
331. #define EVENT_LOOP 4
333. // Climb rate calculations
334. #define ALTITUDE_HISTORY_LENGTH 8//Number of (time,altitude) points to
335. // regress a climb rate from
337. #define BATTERY_VOLTAGE(x)(x*(g.input_voltage/1024.0))*g.volt_div_ratio
338. #define CURRENT_AMPS(x)((x*(g.input_voltage/1024.0))-CURR_AMPS_OFFSET)*g.curr_amp_per_volt
340. //#define BARO_FILTER_SIZE 8
342. /* ************************************************************** */
343. /* Expansion PIN's that people can use for various things. */
345. // AN0 - 7 are located at edge of IMU PCB "above" pressure sensor and
346. // Expansion port
347. // AN0 - 5 are also located next to voltage dividers and sliding SW2 switch
348. // AN0 - 3 has 10kOhm resistor in serial, include 3.9kOhm to make it as
349. // voltage divider
350. // AN4 - 5 are direct GPIO pins from atmega1280 and they are the latest pins
351. // next to SW2 switch
352. // Look more ArduCopter Wiki for voltage dividers and other ports
353. #define AN0 54// resistor, vdiv use, divider 1 closest to relay
354. #define AN1 55// resistor, vdiv use, divider 2
355. #define AN2 56// resistor, vdiv use, divider 3
356. #define AN3 57// resistor, vdiv use, divider 4 closest to SW2
357. #define AN4 58// direct GPIO pin, default as analog input, next to SW2
358. // switch
359. #define AN5 59// direct GPIO pin, default as analog input, next to SW2
360. // switch
361. #define AN6 60// direct GPIO pin, default as analog input, close to
362. // Pressure sensor, Expansion Ports
363. #define AN7 61// direct GPIO pin, default as analog input, close to
364. // Pressure sensor, Expansion Ports
366. // AN8 - 15 are located at edge of IMU PCB "above" pressure sensor and
367. // Expansion port
368. // AN8 - 15 PINs are not connected anywhere, they are located as last 8 pins
369. // on edge of the board above Expansion Ports
370. // even pins (8,10,12,14) are at edge of board, Odd pins (9,11,13,15) are on
371. // inner row
372. #define AN8 62// NC
373. #define AN9 63// NC
374. #define AN10 64// NC
375. #define AN11 65// NC
376. #define AN12 66// NC
377. #define AN13 67// NC
378. #define AN14 68// NC
379. #define AN15 69// NC
381. #define RELAY_PIN 47
383. #define PIEZO_PIN AN5 //Last pin on the back ADC connector
387. // sonar
388. //#define SonarToCm(x) (x*1.26) // Sonar raw value to centimeters
390. // RADIANS
391. #define RADX100 0.000174532925
392. #define DEGX100 5729.57795
395. // EEPROM addresses
396. #define EEPROM_MAX_ADDR 4096
397. // parameters get the first 1536 bytes of EEPROM, remainder is for waypoints
398. #define WP_START_BYTE 0x600// where in memory home WP is stored + all other
399. // WP
400. #define WP_SIZE 15
402. #define ONBOARD_PARAM_NAME_LENGTH 15
404. // fence points are stored at the end of the EEPROM
405. #define MAX_FENCEPOINTS 6
406. #define FENCE_WP_SIZE sizeof(Vector2l)
407. #define FENCE_START_BYTE (EEPROM_MAX_ADDR-(MAX_FENCEPOINTS*FENCE_WP_SIZE))
409. #define MAX_WAYPOINTS ((FENCE_START_BYTE - WP_START_BYTE)/ WP_SIZE)-1// -
410. // 1
411. // to
412. // be
413. // safe
415. // mark a function as not to be inlined
416. #define NOINLINE __attribute__((noinline))
418. // IMU selection
419. #define CONFIG_IMU_OILPAN 1
420. #define CONFIG_IMU_MPU6000 2
422. // APM Hardware selection
423. #define APM_HARDWARE_APM1 1
424. #define APM_HARDWARE_APM2 2
426. #define AP_BARO_BMP085 1
427. #define AP_BARO_MS5611 2
429. #define LOGGING_SIMPLE 1
430. #define LOGGING_VERBOSE 2
432. // Channel Config selection
434. #define CHANNEL_CONFIG_DEFAULT 1
435. #define CHANNEL_CONFIG_CUSTOM 2
437. #endif// _DEFINES_H//作者：恒久力行  qq:624668529

6.主函数也有更改这里是主函数代码

main.c

1. #include"sys.h"//作者：恒久力行  qq:624668529
2. #include"delay.h"
3. #include"usart.h"
4. #include"led.h"
5. #include"beep.h"
6. #include"key.h"
7. #include"mavlink_avoid_errors.h"
8. #include"mavlink_usart_fifo.h"
9. #include"open_tel_mavlink.h"
10. //ALIENTEK 探索者STM32F407开发板 实验4
11. //串口通信实验 -库函数版本
12. //技术支持：www.openedv.com
13. //淘宝店铺：http://eboard.taobao.com
14. //广州市星翼电子科技有限公司
15. //作者：正点原子 @ALIENTEK
16. mavlink_system_t mavlink_system;
17. #define UART_TX_BUFFER_SIZE 255
18. #define UART_RX_BUFFER_SIZE 255
19. externfifo_t uart_rx_fifo, uart_tx_fifo;
20. externuint8_t uart_tx_buf[UART_TX_BUFFER_SIZE], uart_rx_buf[UART_RX_BUFFER_SIZE];
21. int main(void)
22. {
24. NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
25. delay_init(168);//延时初始化
26. uart_init(115200);//串口初始化波特率为115200
27. LED_Init();//初始化与LED连接的硬件接口
29. fifo_init(&uart_tx_fifo, uart_tx_buf, UART_TX_BUFFER_SIZE);
30. fifo_init(&uart_rx_fifo, uart_rx_buf, UART_RX_BUFFER_SIZE);
32. mavlink_system.sysid = MAV_TYPE_GENERIC;
33. mavlink_system.compid = MAV_AUTOPILOT_GENERIC;
34. while(1)
35. {
36. mavlink_send_message(0, MSG_HEARTBEAT,0);
37. mavlink_send_message(0, MSG_LOCATION,0);
39. while(1)
40. {
41. // if(tranlTimer > 100)
42. // {
43. // tranlTimer = 0;
44. // mavlink_send_message(0, MSG_HEARTBEAT, 0);
45. // mavlink_send_message(0, MSG_ATTITUDE, 0);
46. // mavlink_send_message(0, MSG_AHRS, 0);
47. // }
48. update();
50. }
51. }
52. }

7.mavlink_helpers.h在以前基础上增加如下代码（如有重复函数，请屏蔽以前的函数）

跟原来官方不同的还有MAVLINK_HELPER uint16_t mavlink_msg_to_send_buffer(uint8_t*buffer,constmavlink_message_t*msg)

这个函数参数定义到函数最前面了。全代码是修改后的，有兴趣的可以去比较。不修改的话会报错。

1. #include"mavlink_usart_fifo.h"
2. externmavlink_system_t mavlink_system;
4. MAVLINK_HELPER void _mavlink_send_uart(mavlink_channel_t chan,constchar*buf,uint16_t len)
5. {
6. serial_write_buf((uint8_t*)buf, len);
7. }

 

mavlink_helpers.h全代码

1. #ifndef _MAVLINK_HELPERS_H_//作者：恒久力行  qq:624668529
2. #define _MAVLINK_HELPERS_H_
4. #include"string.h"
5. #include"checksum.h"
6. #include"mavlink_types.h"
7. #include"mavlink_conversions.h"
9. #ifndef MAVLINK_HELPER
10. #define MAVLINK_HELPER
11. #endif
13. externmavlink_system_t mavlink_system;
15. /*
16. * Internal function to give access to the channel status for each channel
17. */
18. #ifndef MAVLINK_GET_CHANNEL_STATUS
19. MAVLINK_HELPER mavlink_status_t* mavlink_get_channel_status(uint8_t chan)
20. {
21. #ifdef MAVLINK_EXTERNAL_RX_STATUS
22. // No m_mavlink_status array defined in function,
23. // has to be defined externally
24. #else
25. staticmavlink_status_t m_mavlink_status[MAVLINK_COMM_NUM_BUFFERS];
26. #endif
27. return&m_mavlink_status[chan];
28. }
29. #endif
31. /*
32. * Internal function to give access to the channel buffer for each channel
33. */
34. #ifndef MAVLINK_GET_CHANNEL_BUFFER
35. MAVLINK_HELPER mavlink_message_t* mavlink_get_channel_buffer(uint8_t chan)
36. {
38. #ifdef MAVLINK_EXTERNAL_RX_BUFFER
39. // No m_mavlink_buffer array defined in function,
40. // has to be defined externally
41. #else
42. staticmavlink_message_t m_mavlink_buffer[MAVLINK_COMM_NUM_BUFFERS];
43. #endif
44. return&m_mavlink_buffer[chan];
45. }
46. #endif
48. /**
49. * @brief Reset the status of a channel.
50. */
51. MAVLINK_HELPER void mavlink_reset_channel_status(uint8_t chan)
52. {
53. mavlink_status_t*status = mavlink_get_channel_status(chan);
54. status->parse_state = MAVLINK_PARSE_STATE_IDLE;
55. }
57. /**
58. * @brief Finalize a MAVLink message with channel assignment
59. *
60. * This function calculates the checksum and sets length and aircraft id correctly.
61. * It assumes that the message id and the payload are already correctly set. This function
62. * can also be used if the message header has already been written before (as in mavlink_msg_xxx_pack
63. * instead of mavlink_msg_xxx_pack_headerless), it just introduces little extra overhead.
64. *
65. * @param msg Message to finalize
66. * @param system_id Id of the sending (this) system, 1-127
67. * @param length Message length
68. */
69. #if MAVLINK_CRC_EXTRA
70. MAVLINK_HELPER uint16_t mavlink_finalize_message_chan(mavlink_message_t* msg,uint8_t system_id,uint8_t component_id,
71. uint8_t chan,uint8_t min_length,uint8_t length,uint8_t crc_extra)
72. #else
73. MAVLINK_HELPER uint16_t mavlink_finalize_message_chan(mavlink_message_t* msg,uint8_t system_id,uint8_t component_id,
74. uint8_t chan,uint8_t length)
75. #endif
76. {
77. // This is only used for the v2 protocol and we silence it here
78. (void)min_length;
79. // This code part is the same for all messages;
80. msg->magic = MAVLINK_STX;
81. msg->len = length;
82. msg->sysid = system_id;
83. msg->compid = component_id;
84. // One sequence number per channel
85. msg->seq = mavlink_get_channel_status(chan)->current_tx_seq;
86. mavlink_get_channel_status(chan)->current_tx_seq = mavlink_get_channel_status(chan)->current_tx_seq+1;
87. msg->checksum = crc_calculate(((constuint8_t*)(msg))+3, MAVLINK_CORE_HEADER_LEN);
88. crc_accumulate_buffer(&msg->checksum, _MAV_PAYLOAD(msg), msg->len);
89. #if MAVLINK_CRC_EXTRA
90. crc_accumulate(crc_extra,&msg->checksum);
91. #endif
92. mavlink_ck_a(msg)=(uint8_t)(msg->checksum &0xFF);
93. mavlink_ck_b(msg)=(uint8_t)(msg->checksum >>8);
95. return length + MAVLINK_NUM_NON_PAYLOAD_BYTES;
96. }
99. /**
100. * @brief Finalize a MAVLink message with MAVLINK_COMM_0 as default channel
101. */
102. #if MAVLINK_CRC_EXTRA
103. MAVLINK_HELPER uint16_t mavlink_finalize_message(mavlink_message_t* msg,uint8_t system_id,uint8_t component_id,
104. uint8_t min_length,uint8_t length,uint8_t crc_extra)
105. {
106. return mavlink_finalize_message_chan(msg, system_id, component_id, MAVLINK_COMM_0, min_length, length, crc_extra);
107. }
108. #else
109. MAVLINK_HELPER uint16_t mavlink_finalize_message(mavlink_message_t* msg,uint8_t system_id,uint8_t component_id,
110. uint8_t length)
111. {
112. return mavlink_finalize_message_chan(msg, system_id, component_id, MAVLINK_COMM_0, length);
113. }
114. #endif
116. #ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
117. MAVLINK_HELPER void _mavlink_send_uart(mavlink_channel_t chan,constchar*buf,uint16_t len);
119. /**
120. * @brief Finalize a MAVLink message with channel assignment and send
121. */
122. #if MAVLINK_CRC_EXTRA
123. MAVLINK_HELPER void _mav_finalize_message_chan_send(mavlink_channel_t chan,uint8_t msgid,constchar*packet,
124. uint8_t min_length,uint8_t length,uint8_t crc_extra)
125. #else
126. MAVLINK_HELPER void _mav_finalize_message_chan_send(mavlink_channel_t chan,uint8_t msgid,constchar*packet,uint8_t length)
127. #endif
128. {
129. uint16_t checksum;
130. uint8_t buf[MAVLINK_NUM_HEADER_BYTES];
131. uint8_t ck[2];
132. mavlink_status_t*status = mavlink_get_channel_status(chan);
133. buf[0]= MAVLINK_STX;
134. buf[1]= length;
135. buf[2]= status->current_tx_seq;
136. buf[3]= mavlink_system.sysid;
137. buf[4]= mavlink_system.compid;
138. buf[5]= msgid;
139. status->current_tx_seq++;
140. checksum = crc_calculate((constuint8_t*)&buf[1], MAVLINK_CORE_HEADER_LEN);
141. crc_accumulate_buffer(&checksum, packet, length);
142. #if MAVLINK_CRC_EXTRA
143. crc_accumulate(crc_extra,&checksum);
144. #endif
145. ck[0]=(uint8_t)(checksum &0xFF);
146. ck[1]=(uint8_t)(checksum >>8);
148. MAVLINK_START_UART_SEND(chan, MAVLINK_NUM_NON_PAYLOAD_BYTES +(uint16_t)length);
149. _mavlink_send_uart(chan,(constchar*)buf, MAVLINK_NUM_HEADER_BYTES);
150. _mavlink_send_uart(chan, packet, length);
151. _mavlink_send_uart(chan,(constchar*)ck,2);
152. MAVLINK_END_UART_SEND(chan, MAVLINK_NUM_NON_PAYLOAD_BYTES +(uint16_t)length);
153. }
155. /**
156. * @brief re-send a message over a uart channel
157. * this is more stack efficient than re-marshalling the message
158. */
159. MAVLINK_HELPER void _mavlink_resend_uart(mavlink_channel_t chan,constmavlink_message_t*msg)
160. {
161. uint8_t ck[2];
163. ck[0]=(uint8_t)(msg->checksum &0xFF);
164. ck[1]=(uint8_t)(msg->checksum >>8);
165. // XXX use the right sequence here
167. MAVLINK_START_UART_SEND(chan, MAVLINK_NUM_NON_PAYLOAD_BYTES + msg->len);
168. _mavlink_send_uart(chan,(constchar*)&msg->magic, MAVLINK_NUM_HEADER_BYTES);
169. _mavlink_send_uart(chan, _MAV_PAYLOAD(msg), msg->len);
170. _mavlink_send_uart(chan,(constchar*)ck,2);
171. MAVLINK_END_UART_SEND(chan, MAVLINK_NUM_NON_PAYLOAD_BYTES + msg->len);
172. }
173. #endif// MAVLINK_USE_CONVENIENCE_FUNCTIONS
175. /**
176. * @brief Pack a message to send it over a serial byte stream
177. */
178. MAVLINK_HELPER uint16_t mavlink_msg_to_send_buffer(uint8_t*buffer,constmavlink_message_t*msg)
179. {
180. uint8_t*ck;
181. memcpy(buffer,(constuint8_t*)&msg->magic, MAVLINK_NUM_HEADER_BYTES +(uint16_t)msg->len);
182. ck = buffer +(MAVLINK_NUM_HEADER_BYTES +(uint16_t)msg->len);
183. ck[0]=(uint8_t)(msg->checksum &0xFF);
184. ck[1]=(uint8_t)(msg->checksum >>8);
185. return MAVLINK_NUM_NON_PAYLOAD_BYTES +(uint16_t)msg->len;
186. }
188. union __mavlink_bitfield {
189. uint8_tuint8;
190. int8_tint8;
191. uint16_tuint16;
192. int16_tint16;
193. uint32_tuint32;
194. int32_tint32;
195. };
198. MAVLINK_HELPER void mavlink_start_checksum(mavlink_message_t* msg)
199. {
200. crc_init(&msg->checksum);
201. }
203. MAVLINK_HELPER void mavlink_update_checksum(mavlink_message_t* msg,uint8_t c)
204. {
205. crc_accumulate(c,&msg->checksum);
206. }
208. /**
209. * This is a varient of mavlink_frame_char() but with caller supplied
210. * parsing buffers. It is useful when you want to create a MAVLink
211. * parser in a library that doesn't use any global variables
212. *
213. * @param rxmsg parsing message buffer
214. * @param status parsing starus buffer
215. * @param c The char to parse
216. *
217. * @param returnMsg NULL if no message could be decoded, the message data else
218. * @param returnStats if a message was decoded, this is filled with the channel's stats
219. * @return 0 if no message could be decoded, 1 on good message and CRC, 2 on bad CRC
220. *
221. * A typical use scenario of this function call is:
222. *
223. * @code
224. * #include <mavlink.h>
225. *
226. * mavlink_message_t msg;
227. * int chan = 0;
228. *
229. *
230. * while(serial.bytesAvailable > 0)
231. * {
232. * uint8_t byte = serial.getNextByte();
233. * if (mavlink_frame_char(chan, byte, &msg) != MAVLINK_FRAMING_INCOMPLETE)
234. * {
235. * printf("Received message with ID %d, sequence: %d from component %d of system %d", msg.msgid, msg.seq, msg.compid, msg.sysid);
236. * }
237. * }
238. *
239. *
240. * @endcode
241. */
242. MAVLINK_HELPER uint8_t mavlink_frame_char_buffer(mavlink_message_t* rxmsg,
243. mavlink_status_t* status,
244. uint8_t c,
245. mavlink_message_t* r_message,
246. mavlink_status_t* r_mavlink_status)
247. {
248. /*
249. default message crc function. You can override this per-system to
250. put this data in a different memory segment
251. */
252. #if MAVLINK_CRC_EXTRA
253. #ifndef MAVLINK_MESSAGE_CRC
254. staticconstuint8_t mavlink_message_crcs[256]= MAVLINK_MESSAGE_CRCS;
255. #define MAVLINK_MESSAGE_CRC(msgid) mavlink_message_crcs[msgid]
256. #endif
257. #endif
259. /* Enable this option to check the length of each message.
260. This allows invalid messages to be caught much sooner. Use if the transmission
261. medium is prone to missing (or extra) characters (e.g. a radio that fades in
262. and out). Only use if the channel will only contain messages types listed in
263. the headers.
264. */
265. #ifdef MAVLINK_CHECK_MESSAGE_LENGTH
266. #ifndef MAVLINK_MESSAGE_LENGTH
267. staticconstuint8_t mavlink_message_lengths[256]= MAVLINK_MESSAGE_LENGTHS;
268. #define MAVLINK_MESSAGE_LENGTH(msgid) mavlink_message_lengths[msgid]
269. #endif
270. #endif
272. int bufferIndex =0;
274. status->msg_received = MAVLINK_FRAMING_INCOMPLETE;
276. switch(status->parse_state)
277. {
278. case MAVLINK_PARSE_STATE_UNINIT:
279. case MAVLINK_PARSE_STATE_IDLE:
280. if(c == MAVLINK_STX)
281. {
282. status->parse_state = MAVLINK_PARSE_STATE_GOT_STX;
283. rxmsg->len =0;
284. rxmsg->magic = c;
285. mavlink_start_checksum(rxmsg);
286. }
287. break;
289. case MAVLINK_PARSE_STATE_GOT_STX:
290. if(status->msg_received
291. /* Support shorter buffers than the
292. default maximum packet size */
293. #if (MAVLINK_MAX_PAYLOAD_LEN < 255)
294. || c > MAVLINK_MAX_PAYLOAD_LEN
295. #endif
296. )
297. {
298. status->buffer_overrun++;
299. status->parse_error++;
300. status->msg_received =0;
301. status->parse_state = MAVLINK_PARSE_STATE_IDLE;
302. }
303. else
304. {
305. // NOT counting STX, LENGTH, SEQ, SYSID, COMPID, MSGID, CRC1 and CRC2
306. rxmsg->len = c;
307. status->packet_idx =0;
308. mavlink_update_checksum(rxmsg, c);
309. status->parse_state = MAVLINK_PARSE_STATE_GOT_LENGTH;
310. }
311. break;
313. case MAVLINK_PARSE_STATE_GOT_LENGTH:
314. rxmsg->seq = c;
315. mavlink_update_checksum(rxmsg, c);
316. status->parse_state = MAVLINK_PARSE_STATE_GOT_SEQ;
317. break;
319. case MAVLINK_PARSE_STATE_GOT_SEQ:
320. rxmsg->sysid = c;
321. mavlink_update_checksum(rxmsg, c);
322. status->parse_state = MAVLINK_PARSE_STATE_GOT_SYSID;
323. break;
325. case MAVLINK_PARSE_STATE_GOT_SYSID:
326. rxmsg->compid = c;
327. mavlink_update_checksum(rxmsg, c);
328. status->parse_state = MAVLINK_PARSE_STATE_GOT_COMPID;
329. break;
331. case MAVLINK_PARSE_STATE_GOT_COMPID:
332. #ifdef MAVLINK_CHECK_MESSAGE_LENGTH
333. if(rxmsg->len != MAVLINK_MESSAGE_LENGTH(c))
334. {
335. status->parse_error++;
336. status->parse_state = MAVLINK_PARSE_STATE_IDLE;
337. break;
338. }
339. #endif
340. rxmsg->msgid = c;
341. mavlink_update_checksum(rxmsg, c);
342. if(rxmsg->len ==0)
343. {
344. status->parse_state = MAVLINK_PARSE_STATE_GOT_PAYLOAD;
345. }
346. else
347. {
348. status->parse_state = MAVLINK_PARSE_STATE_GOT_MSGID;
349. }
350. break;
352. case MAVLINK_PARSE_STATE_GOT_MSGID:
353. _MAV_PAYLOAD_NON_CONST(rxmsg)[status->packet_idx++]=(char)c;
354. mavlink_update_checksum(rxmsg, c);
355. if(status->packet_idx == rxmsg->len)
356. {
357. status->parse_state = MAVLINK_PARSE_STATE_GOT_PAYLOAD;
358. }
359. break;
361. case MAVLINK_PARSE_STATE_GOT_PAYLOAD:
362. #if MAVLINK_CRC_EXTRA
363. mavlink_update_checksum(rxmsg, MAVLINK_MESSAGE_CRC(rxmsg->msgid));
364. #endif
365. if(c !=(rxmsg->checksum &0xFF)){
366. status->parse_state = MAVLINK_PARSE_STATE_GOT_BAD_CRC1;
367. }else{
368. status->parse_state = MAVLINK_PARSE_STATE_GOT_CRC1;
369. }
370. _MAV_PAYLOAD_NON_CONST(rxmsg)[status->packet_idx]=(char)c;
371. break;
373. case MAVLINK_PARSE_STATE_GOT_CRC1:
374. case MAVLINK_PARSE_STATE_GOT_BAD_CRC1:
375. if(status->parse_state == MAVLINK_PARSE_STATE_GOT_BAD_CRC1 || c !=(rxmsg->checksum >>8)){
376. // got a bad CRC message
377. status->msg_received = MAVLINK_FRAMING_BAD_CRC;
378. }else{
379. // Successfully got message
380. status->msg_received = MAVLINK_FRAMING_OK;
381. }
382. status->parse_state = MAVLINK_PARSE_STATE_IDLE;
383. _MAV_PAYLOAD_NON_CONST(rxmsg)[status->packet_idx+1]=(char)c;
384. memcpy(r_message, rxmsg,sizeof(mavlink_message_t));
385. break;
386. }
388. bufferIndex++;
389. // If a message has been sucessfully decoded, check index
390. if(status->msg_received == MAVLINK_FRAMING_OK)
391. {
392. //while(status->current_seq != rxmsg->seq)
393. //{
394. // status->packet_rx_drop_count++;
395. // status->current_seq++;
396. //}
397. status->current_rx_seq = rxmsg->seq;
398. // Initial condition: If no packet has been received so far, drop count is undefined
399. if(status->packet_rx_success_count ==0) status->packet_rx_drop_count =0;
400. // Count this packet as received
401. status->packet_rx_success_count++;
402. }
404. r_message->len = rxmsg->len;// Provide visibility on how far we are into current msg
405. r_mavlink_status->parse_state = status->parse_state;
406. r_mavlink_status->packet_idx = status->packet_idx;
407. r_mavlink_status->current_rx_seq = status->current_rx_seq+1;
408. r_mavlink_status->packet_rx_success_count = status->packet_rx_success_count;
409. r_mavlink_status->packet_rx_drop_count = status->parse_error;
410. status->parse_error =0;
412. if(status->msg_received == MAVLINK_FRAMING_BAD_CRC){
413. /*
414. the CRC came out wrong. We now need to overwrite the
415. msg CRC with the one on the wire so that if the
416. caller decides to forward the message anyway that
417. mavlink_msg_to_send_buffer() won't overwrite the
418. checksum
419. */
420. r_message->checksum = _MAV_PAYLOAD(rxmsg)[status->packet_idx]|(_MAV_PAYLOAD(rxmsg)[status->packet_idx+1]<<8);
421. }
423. return status->msg_received;
424. }
426. /**
427. * This is a convenience function which handles the complete MAVLink parsing.
428. * the function will parse one byte at a time and return the complete packet once
429. * it could be successfully decoded. This function will return 0, 1 or
430. * 2 (MAVLINK_FRAMING_INCOMPLETE, MAVLINK_FRAMING_OK or MAVLINK_FRAMING_BAD_CRC)
431. *
432. * Messages are parsed into an internal buffer (one for each channel). When a complete
433. * message is received it is copies into *returnMsg and the channel's status is
434. * copied into *returnStats.
435. *
436. * @param chan ID of the current channel. This allows to parse different channels with this function.
437. * a channel is not a physical message channel like a serial port, but a logic partition of
438. * the communication streams in this case. COMM_NB is the limit for the number of channels
439. * on MCU (e.g. ARM7), while COMM_NB_HIGH is the limit for the number of channels in Linux/Windows
440. * @param c The char to parse
441. *
442. * @param returnMsg NULL if no message could be decoded, the message data else
443. * @param returnStats if a message was decoded, this is filled with the channel's stats
444. * @return 0 if no message could be decoded, 1 on good message and CRC, 2 on bad CRC
445. *
446. * A typical use scenario of this function call is:
447. *
448. * @code
449. * #include <mavlink.h>
450. *
451. * mavlink_message_t msg;
452. * int chan = 0;
453. *
454. *
455. * while(serial.bytesAvailable > 0)
456. * {
457. * uint8_t byte = serial.getNextByte();
458. * if (mavlink_frame_char(chan, byte, &msg) != MAVLINK_FRAMING_INCOMPLETE)
459. * {
460. * printf("Received message with ID %d, sequence: %d from component %d of system %d", msg.msgid, msg.seq, msg.compid, msg.sysid);
461. * }
462. * }
463. *
464. *
465. * @endcode
466. */
467. MAVLINK_HELPER uint8_t mavlink_frame_char(uint8_t chan,uint8_t c,mavlink_message_t* r_message,mavlink_status_t* r_mavlink_status)
468. {
469. return mavlink_frame_char_buffer(mavlink_get_channel_buffer(chan),
470. mavlink_get_channel_status(chan),
471. c,
472. r_message,
473. r_mavlink_status);
474. }
477. /**
478. * This is a convenience function which handles the complete MAVLink parsing.
479. * the function will parse one byte at a time and return the complete packet once
480. * it could be successfully decoded. This function will return 0 or 1.
481. *
482. * Messages are parsed into an internal buffer (one for each channel). When a complete
483. * message is received it is copies into *returnMsg and the channel's status is
484. * copied into *returnStats.
485. *
486. * @param chan ID of the current channel. This allows to parse different channels with this function.
487. * a channel is not a physical message channel like a serial port, but a logic partition of
488. * the communication streams in this case. COMM_NB is the limit for the number of channels
489. * on MCU (e.g. ARM7), while COMM_NB_HIGH is the limit for the number of channels in Linux/Windows
490. * @param c The char to parse
491. *
492. * @param returnMsg NULL if no message could be decoded, the message data else
493. * @param returnStats if a message was decoded, this is filled with the channel's stats
494. * @return 0 if no message could be decoded or bad CRC, 1 on good message and CRC
495. *
496. * A typical use scenario of this function call is:
497. *
498. * @code
499. * #include <mavlink.h>
500. *
501. * mavlink_message_t msg;
502. * int chan = 0;
503. *
504. *
505. * while(serial.bytesAvailable > 0)
506. * {
507. * uint8_t byte = serial.getNextByte();
508. * if (mavlink_parse_char(chan, byte, &msg))
509. * {
510. * printf("Received message with ID %d, sequence: %d from component %d of system %d", msg.msgid, msg.seq, msg.compid, msg.sysid);
511. * }
512. * }
513. *
514. *
515. * @endcode
516. */
517. MAVLINK_HELPER uint8_t mavlink_parse_char(uint8_t chan,uint8_t c,mavlink_message_t* r_message,mavlink_status_t* r_mavlink_status)
518. {
519. uint8_t msg_received = mavlink_frame_char(chan, c, r_message, r_mavlink_status);
520. if(msg_received == MAVLINK_FRAMING_BAD_CRC){
521. // we got a bad CRC. Treat as a parse failure
522. mavlink_message_t* rxmsg = mavlink_get_channel_buffer(chan);
523. mavlink_status_t* status = mavlink_get_channel_status(chan);
524. status->parse_error++;
525. status->msg_received = MAVLINK_FRAMING_INCOMPLETE;
526. status->parse_state = MAVLINK_PARSE_STATE_IDLE;
527. if(c == MAVLINK_STX)
528. {
529. status->parse_state = MAVLINK_PARSE_STATE_GOT_STX;
530. rxmsg->len =0;
531. mavlink_start_checksum(rxmsg);
532. }
533. return0;
534. }
535. return msg_received;
536. }
538. /**
539. * @brief Put a bitfield of length 1-32 bit into the buffer
540. *
541. * @param b the value to add, will be encoded in the bitfield
542. * @param bits number of bits to use to encode b, e.g. 1 for boolean, 2, 3, etc.
543. * @param packet_index the position in the packet (the index of the first byte to use)
544. * @param bit_index the position in the byte (the index of the first bit to use)
545. * @param buffer packet buffer to write into
546. * @return new position of the last used byte in the buffer
547. */
548. MAVLINK_HELPER uint8_t put_bitfield_n_by_index(int32_t b,uint8_t bits,uint8_t packet_index,uint8_t bit_index,uint8_t* r_bit_index,uint8_t* buffer)
549. {
550. uint16_t bits_remain = bits;
551. // Transform number into network order
552. int32_t v;
553. uint8_t i_bit_index, i_byte_index, curr_bits_n;
554. #if MAVLINK_NEED_BYTE_SWAP
555. union{
556. int32_t i;
557. uint8_t b[4];
558. } bin, bout;
559. bin.i = b;
560. bout.b[0]= bin.b[3];
561. bout.b[1]= bin.b[2];
562. bout.b[2]= bin.b[1];
563. bout.b[3]= bin.b[0];
564. v = bout.i;
565. #else
566. v = b;
567. #endif
569. // buffer in
570. // 01100000 01000000 00000000 11110001
571. // buffer out
572. // 11110001 00000000 01000000 01100000
574. // Existing partly filled byte (four free slots)
575. // 0111xxxx
577. // Mask n free bits
578. // 00001111 = 2^0 + 2^1 + 2^2 + 2^3 = 2^n - 1
579. // = ((uint32_t)(1 << n)) - 1; // = 2^n - 1
581. // Shift n bits into the right position
582. // out = in >> n;
584. // Mask and shift bytes
585. i_bit_index = bit_index;
586. i_byte_index = packet_index;
587. if(bit_index >0)
588. {
589. // If bits were available at start, they were available
590. // in the byte before the current index
591. i_byte_index--;
592. }
594. // While bits have not been packed yet
595. while(bits_remain >0)
596. {
597. // Bits still have to be packed
598. // there can be more than 8 bits, so
599. // we might have to pack them into more than one byte
601. // First pack everything we can into the current 'open' byte
602. //curr_bits_n = bits_remain << 3; // Equals bits_remain mod 8
603. //FIXME
604. if(bits_remain <=(uint8_t)(8- i_bit_index))
605. {
606. // Enough space
607. curr_bits_n =(uint8_t)bits_remain;
608. }
609. else
610. {
611. curr_bits_n =(8- i_bit_index);
612. }
614. // Pack these n bits into the current byte
615. // Mask out whatever was at that position with ones (xxx11111)
616. buffer[i_byte_index]&=(0xFF>>(8- curr_bits_n));
617. // Put content to this position, by masking out the non-used part
618. buffer[i_byte_index]|=((0x00<< curr_bits_n)& v);
620. // Increment the bit index
621. i_bit_index += curr_bits_n;
623. // Now proceed to the next byte, if necessary
624. bits_remain -= curr_bits_n;
625. if(bits_remain >0)
626. {
627. // Offer another 8 bits / one byte
628. i_byte_index++;
629. i_bit_index =0;
630. }
631. }
633. *r_bit_index = i_bit_index;
634. // If a partly filled byte is present, mark this as consumed
635. if(i_bit_index !=7) i_byte_index++;
636. return i_byte_index - packet_index;
637. }
639. #ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
641. // To make MAVLink work on your MCU, define comm_send_ch() if you wish
642. // to send 1 byte at a time, or MAVLINK_SEND_UART_BYTES() to send a
643. // whole packet at a time
645. /*
647. #include "mavlink_types.h"
649. void comm_send_ch(mavlink_channel_t chan, uint8_t ch)
650. {
651. if (chan == MAVLINK_COMM_0)
652. {
653. uart0_transmit(ch);
654. }
655. if (chan == MAVLINK_COMM_1)
656. {
657. uart1_transmit(ch);
658. }
659. }
660. */
661. #include"mavlink_usart_fifo.h"
662. MAVLINK_HELPER void _mavlink_send_uart(mavlink_channel_t chan,constchar*buf,uint16_t len)
663. {
664. serial_write_buf((uint8_t*)buf, len);
665. }
667. //MAVLINK_HELPER void _mavlink_send_uart(mavlink_channel_t chan, const char *buf, uint16_t len)
668. //{
669. //#ifdef MAVLINK_SEND_UART_BYTES
670. // /* this is the more efficient approach, if the platform
671. // defines it */
672. // MAVLINK_SEND_UART_BYTES(chan, (const uint8_t *)buf, len);
673. //#else
674. // /* fallback to one byte at a time */
675. // uint16_t i;
676. // for (i = 0; i < len; i++) {
677. // comm_send_ch(chan, (uint8_t)buf[i]);
678. // }
679. //#endif
680. //}
681. #endif// MAVLINK_USE_CONVENIENCE_FUNCTIONS
683. #endif/* _MAVLINK_HELPERS_H_ */

8.checksum未经任何修改（为了大家方便看附上全代码）

checksum.h

1. #ifdef __cplusplus//作者：恒久力行  qq:624668529
2. extern"C"{
3. #endif
5. #ifndef _CHECKSUM_H_
6. #define _CHECKSUM_H_
8. // Visual Studio versions before 2010 don't have stdint.h, so we just error out.
9. #if (defined _MSC_VER) && (_MSC_VER < 1600)
10. #error"The C-MAVLink implementation requires Visual Studio 2010 or greater"
11. #endif
13. #include<stdint.h>
15. /**
16. *
17. * CALCULATE THE CHECKSUM
18. *
19. */
21. #define X25_INIT_CRC 0xffff
22. #define X25_VALIDATE_CRC 0xf0b8
24. #ifndef HAVE_CRC_ACCUMULATE
25. /**
26. * @brief Accumulate the X.25 CRC by adding one char at a time.
27. *
28. * The checksum function adds the hash of one char at a time to the
29. * 16 bit checksum (uint16_t).
30. *
31. * @param data new char to hash
32. * @param crcAccum the already accumulated checksum
33. **/
34. staticinlinevoid crc_accumulate(uint8_t data,uint16_t*crcAccum)
35. {
36. /*Accumulate one byte of data into the CRC*/
37. uint8_t tmp;
39. tmp = data ^(uint8_t)(*crcAccum &0xff);
40. tmp ^=(tmp<<4);
41. *crcAccum =(*crcAccum>>8)^(tmp<<8)^(tmp <<3)^(tmp>>4);
42. }
43. #endif
46. /**
47. * @brief Initiliaze the buffer for the X.25 CRC
48. *
49. * @param crcAccum the 16 bit X.25 CRC
50. */
51. staticinlinevoid crc_init(uint16_t* crcAccum)
52. {
53. *crcAccum = X25_INIT_CRC;
54. }
57. /**
58. * @brief Calculates the X.25 checksum on a byte buffer
59. *
60. * @param pBuffer buffer containing the byte array to hash
61. * @param length length of the byte array
62. * @return the checksum over the buffer bytes
63. **/
64. staticinlineuint16_t crc_calculate(constuint8_t* pBuffer,uint16_t length)
65. {
66. uint16_t crcTmp;
67. crc_init(&crcTmp);
68. while(length--){
69. crc_accumulate(*pBuffer++,&crcTmp);
70. }
71. return crcTmp;
72. }
75. /**
76. * @brief Accumulate the X.25 CRC by adding an array of bytes
77. *
78. * The checksum function adds the hash of one char at a time to the
79. * 16 bit checksum (uint16_t).
80. *
81. * @param data new bytes to hash
82. * @param crcAccum the already accumulated checksum
83. **/
84. staticinlinevoid crc_accumulate_buffer(uint16_t*crcAccum,constchar*pBuffer,uint16_t length)
85. {
86. constuint8_t*p =(constuint8_t*)pBuffer;
87. while(length--){
88. crc_accumulate(*p++, crcAccum);
89. }
90. }
92. #endif/* _CHECKSUM_H_ */
94. #ifdef __cplusplus
95. }
96. #endif

9.mavlink_conversions.h修改了一个地方就是将参数定义提到前面了

（就是这个函数MAVLINK_HELPER void mavlink_dcm_to_quaternion(constfloat dcm[3][3],float quaternion[4])

mavlink_conversions.h全代码

1. #ifndef _MAVLINK_CONVERSIONS_H_//作者：恒久力行  qq:624668529
2. #define _MAVLINK_CONVERSIONS_H_
4. /* enable math defines on Windows */
5. #ifdef _MSC_VER
6. #ifndef _USE_MATH_DEFINES
7. #define _USE_MATH_DEFINES
8. #endif
9. #endif
10. #include<math.h>
12. #ifndef M_PI_2
13. #define M_PI_2 ((float)asin(1))
14. #endif
16. /**
17. * @file mavlink_conversions.h
18. *
19. * These conversion functions follow the NASA rotation standards definition file
20. * available online.
21. *
22. * Their intent is to lower the barrier for MAVLink adopters to use gimbal-lock free
23. * (both rotation matrices, sometimes called DCM, and quaternions are gimbal-lock free)
24. * rotation representations. Euler angles (roll, pitch, yaw) will be phased out of the
25. * protocol as widely as possible.
26. *
27. * @author James Goppert
28. * @author Thomas Gubler <thomasgubler@gmail.com>
29. */
32. /**
33. * Converts a quaternion to a rotation matrix
34. *
35. * @param quaternion a [w, x, y, z] ordered quaternion (null-rotation being 1 0 0 0)
36. * @param dcm a 3x3 rotation matrix
37. */
38. MAVLINK_HELPER void mavlink_quaternion_to_dcm(constfloat quaternion[4],float dcm[3][3])
39. {
40. double a = quaternion[0];
41. double b = quaternion[1];
42. double c = quaternion[2];
43. double d = quaternion[3];
44. double aSq = a * a;
45. double bSq = b * b;
46. double cSq = c * c;
47. double dSq = d * d;
48. dcm[0][0]= aSq + bSq - cSq - dSq;
49. dcm[0][1]=2*(b * c - a * d);
50. dcm[0][2]=2*(a * c + b * d);
51. dcm[1][0]=2*(b * c + a * d);
52. dcm[1][1]= aSq - bSq + cSq - dSq;
53. dcm[1][2]=2*(c * d - a * b);
54. dcm[2][0]=2*(b * d - a * c);
55. dcm[2][1]=2*(a * b + c * d);
56. dcm[2][2]= aSq - bSq - cSq + dSq;
57. }
60. /**
61. * Converts a rotation matrix to euler angles
62. *
63. * @param dcm a 3x3 rotation matrix
64. * @param roll the roll angle in radians
65. * @param pitch the pitch angle in radians
66. * @param yaw the yaw angle in radians
67. */
68. MAVLINK_HELPER void mavlink_dcm_to_euler(constfloat dcm[3][3],float* roll,float* pitch,float* yaw)
69. {
70. float phi, theta, psi;
71. theta = asin(-dcm[2][0]);
73. if(fabsf(theta -(float)M_PI_2)<1.0e-3f){
74. phi =0.0f;
75. psi =(atan2f(dcm[1][2]- dcm[0][1],
76. dcm[0][2]+ dcm[1][1])+ phi);
78. }elseif(fabsf(theta +(float)M_PI_2)<1.0e-3f){
79. phi =0.0f;
80. psi = atan2f(dcm[1][2]- dcm[0][1],
81. dcm[0][2]+ dcm[1][1]- phi);
83. }else{
84. phi = atan2f(dcm[2][1], dcm[2][2]);
85. psi = atan2f(dcm[1][0], dcm[0][0]);
86. }
88. *roll = phi;
89. *pitch = theta;
90. *yaw = psi;
91. }
94. /**
95. * Converts a quaternion to euler angles
96. *
97. * @param quaternion a [w, x, y, z] ordered quaternion (null-rotation being 1 0 0 0)
98. * @param roll the roll angle in radians
99. * @param pitch the pitch angle in radians
100. * @param yaw the yaw angle in radians
101. */
102. MAVLINK_HELPER void mavlink_quaternion_to_euler(constfloat quaternion[4],float* roll,float* pitch,float* yaw)
103. {
104. float dcm[3][3];
105. mavlink_quaternion_to_dcm(quaternion, dcm);
106. mavlink_dcm_to_euler((constfloat(*)[3])dcm, roll, pitch, yaw);
107. }
110. /**
111. * Converts euler angles to a quaternion
112. *
113. * @param roll the roll angle in radians
114. * @param pitch the pitch angle in radians
115. * @param yaw the yaw angle in radians
116. * @param quaternion a [w, x, y, z] ordered quaternion (null-rotation being 1 0 0 0)
117. */
118. MAVLINK_HELPER void mavlink_euler_to_quaternion(float roll,float pitch,float yaw,float quaternion[4])
119. {
120. float cosPhi_2 = cosf(roll /2);
121. float sinPhi_2 = sinf(roll /2);
122. float cosTheta_2 = cosf(pitch /2);
123. float sinTheta_2 = sinf(pitch /2);
124. float cosPsi_2 = cosf(yaw /2);
125. float sinPsi_2 = sinf(yaw /2);
126. quaternion[0]=(cosPhi_2 * cosTheta_2 * cosPsi_2 +
127. sinPhi_2 * sinTheta_2 * sinPsi_2);
128. quaternion[1]=(sinPhi_2 * cosTheta_2 * cosPsi_2 -
129. cosPhi_2 * sinTheta_2 * sinPsi_2);
130. quaternion[2]=(cosPhi_2 * sinTheta_2 * cosPsi_2 +
131. sinPhi_2 * cosTheta_2 * sinPsi_2);
132. quaternion[3]=(cosPhi_2 * cosTheta_2 * sinPsi_2 -
133. sinPhi_2 * sinTheta_2 * cosPsi_2);
134. }
137. /**
138. * Converts a rotation matrix to a quaternion
139. * Reference:
140. * - Shoemake, Quaternions,
141. * http://www.cs.ucr.edu/~vbz/resources/quatut.pdf
142. *
143. * @param dcm a 3x3 rotation matrix
144. * @param quaternion a [w, x, y, z] ordered quaternion (null-rotation being 1 0 0 0)
145. */
146. MAVLINK_HELPER void mavlink_dcm_to_quaternion(constfloat dcm[3][3],float quaternion[4])
147. {
148. int dcm_j,dcm_k;
149. float s;
150. float tr = dcm[0][0]+ dcm[1][1]+ dcm[2][2];
151. if(tr >0.0f){
152. float s = sqrtf(tr +1.0f);
153. quaternion[0]= s *0.5f;
154. s =0.5f/ s;
155. quaternion[1]=(dcm[2][1]- dcm[1][2])* s;
156. quaternion[2]=(dcm[0][2]- dcm[2][0])* s;
157. quaternion[3]=(dcm[1][0]- dcm[0][1])* s;
158. }else{
159. /* Find maximum diagonal element in dcm
160. * store index in dcm_i */
161. int dcm_i =0;
162. int i;
163. for(i =1; i <3; i++){
164. if(dcm[i][i]> dcm[dcm_i][dcm_i]){
165. dcm_i = i;
166. }
167. }
168. dcm_j =(dcm_i +1)%3;
169. dcm_k =(dcm_i +2)%3;
170. s = sqrtf((dcm[dcm_i][dcm_i]- dcm[dcm_j][dcm_j]-
171. dcm[dcm_k][dcm_k])+1.0f);
172. quaternion[dcm_i +1]= s *0.5f;
173. s =0.5f/ s;
174. quaternion[dcm_j +1]=(dcm[dcm_i][dcm_j]+ dcm[dcm_j][dcm_i])* s;
175. quaternion[dcm_k +1]=(dcm[dcm_k][dcm_i]+ dcm[dcm_i][dcm_k])* s;
176. quaternion[0]=(dcm[dcm_k][dcm_j]- dcm[dcm_j][dcm_k])* s;
177. }
178. }
181. /**
182. * Converts euler angles to a rotation matrix
183. *
184. * @param roll the roll angle in radians
185. * @param pitch the pitch angle in radians
186. * @param yaw the yaw angle in radians
187. * @param dcm a 3x3 rotation matrix
188. */
189. MAVLINK_HELPER void mavlink_euler_to_dcm(float roll,float pitch,float yaw,float dcm[3][3])
190. {
191. float cosPhi = cosf(roll);
192. float sinPhi = sinf(roll);
193. float cosThe = cosf(pitch);
194. float sinThe = sinf(pitch);
195. float cosPsi = cosf(yaw);
196. float sinPsi = sinf(yaw);
198. dcm[0][0]= cosThe * cosPsi;
199. dcm[0][1]=-cosPhi * sinPsi + sinPhi * sinThe * cosPsi;
200. dcm[0][2]= sinPhi * sinPsi + cosPhi * sinThe * cosPsi;
202. dcm[1][0]= cosThe * sinPsi;
203. dcm[1][1]= cosPhi * cosPsi + sinPhi * sinThe * sinPsi;
204. dcm[1][2]=-sinPhi * cosPsi + cosPhi * sinThe * sinPsi;
206. dcm[2][0]=-sinThe;
207. dcm[2][1]= sinPhi * cosThe;
208. dcm[2][2]= cosPhi * cosThe;
209. }
211. #endif

10.mavlink_types.h跟源代码相比较屏蔽了下面这段代码

（关于MAVPACKED相关定义在mavlink_avoid_errors.h中）

1. // Macro to define packed structures
2. //#ifdef __GNUC__
3. // #define MAVPACKED( __Declaration__ ) __Declaration__ __attribute__((packed))
4. //#else
5. // #define MAVPACKED( __Declaration__ ) __pragma( pack(push, 1) ) __Declaration__ __pragma( pack(pop) )
6. //#endif

mavlink_types.h全代码

1. #ifndef MAVLINK_TYPES_H_
2. #define MAVLINK_TYPES_H_
4. // Visual Studio versions before 2010 don't have stdint.h, so we just error out.
5. #if (defined _MSC_VER) && (_MSC_VER < 1600)
6. #error"The C-MAVLink implementation requires Visual Studio 2010 or greater"
7. #endif
9. #include<stdint.h>
11. // Macro to define packed structures
12. //#ifdef __GNUC__
13. // #define MAVPACKED( __Declaration__ ) __Declaration__ __attribute__((packed))
14. //#else
15. // #define MAVPACKED( __Declaration__ ) __pragma( pack(push, 1) ) __Declaration__ __pragma( pack(pop) )
16. //#endif
18. #ifndef MAVLINK_MAX_PAYLOAD_LEN
19. // it is possible to override this, but be careful!
20. #define MAVLINK_MAX_PAYLOAD_LEN 255///< Maximum payload length
21. #endif
23. #define MAVLINK_CORE_HEADER_LEN 5///< Length of core header (of the comm. layer): message length (1 byte) + message sequence (1 byte) + message system id (1 byte) + message component id (1 byte) + message type id (1 byte)
24. #define MAVLINK_NUM_HEADER_BYTES (MAVLINK_CORE_HEADER_LEN +1)///< Length of all header bytes, including core and checksum
25. #define MAVLINK_NUM_CHECKSUM_BYTES 2
26. #define MAVLINK_NUM_NON_PAYLOAD_BYTES (MAVLINK_NUM_HEADER_BYTES + MAVLINK_NUM_CHECKSUM_BYTES)
28. #define MAVLINK_MAX_PACKET_LEN (MAVLINK_MAX_PAYLOAD_LEN + MAVLINK_NUM_NON_PAYLOAD_BYTES)///< Maximum packet length
30. #define MAVLINK_MSG_ID_EXTENDED_MESSAGE 255
31. #define MAVLINK_EXTENDED_HEADER_LEN 14
33. #if (defined _MSC_VER) || ((defined __APPLE__) && (defined __MACH__)) || (defined __linux__)
34. /* full fledged 32bit++ OS */
35. #define MAVLINK_MAX_EXTENDED_PACKET_LEN 65507
36. #else
37. /* small microcontrollers */
38. #define MAVLINK_MAX_EXTENDED_PACKET_LEN 2048
39. #endif
41. #define MAVLINK_MAX_EXTENDED_PAYLOAD_LEN (MAVLINK_MAX_EXTENDED_PACKET_LEN - MAVLINK_EXTENDED_HEADER_LEN - MAVLINK_NUM_NON_PAYLOAD_BYTES)
44. /**
45. * Old-style 4 byte param union
46. *
47. * This struct is the data format to be used when sending
48. * parameters. The parameter should be copied to the native
49. * type (without type conversion)
50. * and re-instanted on the receiving side using the
51. * native type as well.
52. */
53. MAVPACKED(
54. typedefstruct param_union {
55. union{
56. float param_float;
57. int32_t param_int32;
58. uint32_t param_uint32;
59. int16_t param_int16;
60. uint16_t param_uint16;
61. int8_t param_int8;
62. uint8_t param_uint8;
63. uint8_t bytes[4];
64. };
65. uint8_t type;
66. })mavlink_param_union_t;
69. /**
70. * New-style 8 byte param union
71. * mavlink_param_union_double_t will be 8 bytes long, and treated as needing 8 byte alignment for the purposes of MAVLink 1.0 field ordering.
72. * The mavlink_param_union_double_t will be treated as a little-endian structure.
73. *
74. * If is_double is 1 then the type is a double, and the remaining 63 bits are the double, with the lowest bit of the mantissa zero.
75. * The intention is that by replacing the is_double bit with 0 the type can be directly used as a double (as the is_double bit corresponds to the
76. * lowest mantissa bit of a double). If is_double is 0 then mavlink_type gives the type in the union.
77. * The mavlink_types.h header will also need to have shifts/masks to define the bit boundaries in the above,
78. * as bitfield ordering isn’t consistent between platforms. The above is intended to be for gcc on x86,
79. * which should be the same as gcc on little-endian arm. When using shifts/masks the value will be treated as a 64 bit unsigned number,
80. * and the bits pulled out using the shifts/masks.
81. */
82. MAVPACKED(
83. typedefstruct param_union_extended {
84. union{
85. struct{
86. uint8_t is_double:1;
87. uint8_t mavlink_type:7;
88. union{
89. char c;
90. uint8_tuint8;
91. int8_tint8;
92. uint16_tuint16;
93. int16_tint16;
94. uint32_tuint32;
95. int32_tint32;
96. float f;
97. uint8_t align[7];
98. };
99. };
100. uint8_t data[8];
101. };
102. })mavlink_param_union_double_t;
104. /**
105. * This structure is required to make the mavlink_send_xxx convenience functions
106. * work, as it tells the library what the current system and component ID are.
107. */
108. MAVPACKED(
109. typedefstruct __mavlink_system {
110. uint8_t sysid;///< Used by the MAVLink message_xx_send() convenience function
111. uint8_t compid;///< Used by the MAVLink message_xx_send() convenience function
112. })mavlink_system_t;
114. MAVPACKED(
115. typedefstruct __mavlink_message {
116. uint16_t checksum;///< sent at end of packet
117. uint8_t magic;///< protocol magic marker
118. uint8_t len;///< Length of payload
119. uint8_t seq;///< Sequence of packet
120. uint8_t sysid;///< ID of message sender system/aircraft
121. uint8_t compid;///< ID of the message sender component
122. uint8_t msgid;///< ID of message in payload
123. uint64_t payload64[(MAVLINK_MAX_PAYLOAD_LEN+MAVLINK_NUM_CHECKSUM_BYTES+7)/8];
124. })mavlink_message_t;
126. MAVPACKED(
127. typedefstruct __mavlink_extended_message {
128. mavlink_message_t base_msg;
129. int32_t extended_payload_len;///< Length of extended payload if any
130. uint8_t extended_payload[MAVLINK_MAX_EXTENDED_PAYLOAD_LEN];
131. })mavlink_extended_message_t;
133. typedefenum{
134. MAVLINK_TYPE_CHAR =0,
135. MAVLINK_TYPE_UINT8_T =1,
136. MAVLINK_TYPE_INT8_T =2,
137. MAVLINK_TYPE_UINT16_T =3,
138. MAVLINK_TYPE_INT16_T =4,
139. MAVLINK_TYPE_UINT32_T =5,
140. MAVLINK_TYPE_INT32_T =6,
141. MAVLINK_TYPE_UINT64_T =7,
142. MAVLINK_TYPE_INT64_T =8,
143. MAVLINK_TYPE_FLOAT =9,
144. MAVLINK_TYPE_DOUBLE =10
145. }mavlink_message_type_t;
147. #define MAVLINK_MAX_FIELDS 64
149. typedefstruct __mavlink_field_info {
150. constchar*name;// name of this field
151. constchar*print_format;// printing format hint, or NULL
152. mavlink_message_type_t type;// type of this field
153. unsignedint array_length;// if non-zero, field is an array
154. unsignedint wire_offset;// offset of each field in the payload
155. unsignedint structure_offset;// offset in a C structure
156. }mavlink_field_info_t;
158. // note that in this structure the order of fields is the order
159. // in the XML file, not necessary the wire order
160. typedefstruct __mavlink_message_info {
161. constchar*name;// name of the message
162. unsigned num_fields;// how many fields in this message
163. mavlink_field_info_t fields[MAVLINK_MAX_FIELDS];// field information
164. }mavlink_message_info_t;
166. #define _MAV_PAYLOAD(msg)((constchar*)(&((msg)->payload64[0])))
167. #define _MAV_PAYLOAD_NON_CONST(msg)((char*)(&((msg)->payload64[0])))
169. // checksum is immediately after the payload bytes
170. #define mavlink_ck_a(msg)*((msg)->len +(uint8_t*)_MAV_PAYLOAD_NON_CONST(msg))
171. #define mavlink_ck_b(msg)*(((msg)->len+(uint16_t)1)+(uint8_t*)_MAV_PAYLOAD_NON_CONST(msg))
173. typedefenum{
174. MAVLINK_COMM_0,
175. MAVLINK_COMM_1,
176. MAVLINK_COMM_2,
177. MAVLINK_COMM_3
178. }mavlink_channel_t;
180. /*
181. * applications can set MAVLINK_COMM_NUM_BUFFERS to the maximum number
182. * of buffers they will use. If more are used, then the result will be
183. * a stack overrun
184. */
185. #ifndef MAVLINK_COMM_NUM_BUFFERS
186. #if (defined linux) | (defined __linux) | (defined __MACH__) | (defined _WIN32)
187. # define MAVLINK_COMM_NUM_BUFFERS 16
188. #else
189. # define MAVLINK_COMM_NUM_BUFFERS 4
190. #endif
191. #endif
193. typedefenum{
194. MAVLINK_PARSE_STATE_UNINIT=0,
195. MAVLINK_PARSE_STATE_IDLE,
196. MAVLINK_PARSE_STATE_GOT_STX,
197. MAVLINK_PARSE_STATE_GOT_SEQ,
198. MAVLINK_PARSE_STATE_GOT_LENGTH,
199. MAVLINK_PARSE_STATE_GOT_SYSID,
200. MAVLINK_PARSE_STATE_GOT_COMPID,
201. MAVLINK_PARSE_STATE_GOT_MSGID,
202. MAVLINK_PARSE_STATE_GOT_PAYLOAD,
203. MAVLINK_PARSE_STATE_GOT_CRC1,
204. MAVLINK_PARSE_STATE_GOT_BAD_CRC1
205. }mavlink_parse_state_t;///< The state machine for the comm parser
207. typedefenum{
208. MAVLINK_FRAMING_INCOMPLETE=0,
209. MAVLINK_FRAMING_OK=1,
210. MAVLINK_FRAMING_BAD_CRC=2
211. }mavlink_framing_t;
213. typedefstruct __mavlink_status {
214. uint8_t msg_received;///< Number of received messages
215. uint8_t buffer_overrun;///< Number of buffer overruns
216. uint8_t parse_error;///< Number of parse errors
217. mavlink_parse_state_t parse_state;///< Parsing state machine
218. uint8_t packet_idx;///< Index in current packet
219. uint8_t current_rx_seq;///< Sequence number of last packet received
220. uint8_t current_tx_seq;///< Sequence number of last packet sent
221. uint16_t packet_rx_success_count;///< Received packets
222. uint16_t packet_rx_drop_count;///< Number of packet drops
223. }mavlink_status_t;
225. #define MAVLINK_BIG_ENDIAN 0
226. #define MAVLINK_LITTLE_ENDIAN 1
228. #endif/* MAVLINK_TYPES_H_ */

11.protocol.h未做任何修改，附上全代码

protocol.h全代码

1. #ifndef _MAVLINK_PROTOCOL_H_//作者：恒久力行  qq:624668529
2. #define _MAVLINK_PROTOCOL_H_
4. #include"string.h"
5. #include"mavlink_types.h"
7. /*
8. If you want MAVLink on a system that is native big-endian,
9. you need to define NATIVE_BIG_ENDIAN
10. */
11. #ifdef NATIVE_BIG_ENDIAN
12. # define MAVLINK_NEED_BYTE_SWAP (MAVLINK_ENDIAN == MAVLINK_LITTLE_ENDIAN)
13. #else
14. # define MAVLINK_NEED_BYTE_SWAP (MAVLINK_ENDIAN != MAVLINK_LITTLE_ENDIAN)
15. #endif
17. #ifndef MAVLINK_STACK_BUFFER
18. #define MAVLINK_STACK_BUFFER 0
19. #endif
21. #ifndef MAVLINK_AVOID_GCC_STACK_BUG
22. # define MAVLINK_AVOID_GCC_STACK_BUG defined(__GNUC__)
23. #endif
25. #ifndef MAVLINK_ASSERT
26. #define MAVLINK_ASSERT(x)
27. #endif
29. #ifndef MAVLINK_START_UART_SEND
30. #define MAVLINK_START_UART_SEND(chan, length)
31. #endif
33. #ifndef MAVLINK_END_UART_SEND
34. #define MAVLINK_END_UART_SEND(chan, length)
35. #endif
37. /* option to provide alternative implementation of mavlink_helpers.h */
38. #ifdef MAVLINK_SEPARATE_HELPERS
40. #define MAVLINK_HELPER
42. /* decls in sync with those in mavlink_helpers.h */
43. #ifndef MAVLINK_GET_CHANNEL_STATUS
44. MAVLINK_HELPER mavlink_status_t* mavlink_get_channel_status(uint8_t chan);
45. #endif
46. MAVLINK_HELPER void mavlink_reset_channel_status(uint8_t chan);
47. #if MAVLINK_CRC_EXTRA
48. MAVLINK_HELPER uint16_t mavlink_finalize_message_chan(mavlink_message_t* msg,uint8_t system_id,uint8_t component_id,
49. uint8_t chan,uint8_t min_length,uint8_t length,uint8_t crc_extra);
50. MAVLINK_HELPER uint16_t mavlink_finalize_message(mavlink_message_t* msg,uint8_t system_id,uint8_t component_id,
51. uint8_t min_length,uint8_t length,uint8_t crc_extra);
52. #ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
53. MAVLINK_HELPER void _mav_finalize_message_chan_send(mavlink_channel_t chan,uint8_t msgid,constchar*packet,
54. uint8_t min_length,uint8_t length,uint8_t crc_extra);
55. #endif
56. #else
57. MAVLINK_HELPER uint16_t mavlink_finalize_message_chan(mavlink_message_t* msg,uint8_t system_id,uint8_t component_id,
58. uint8_t chan,uint8_t length);
59. MAVLINK_HELPER uint16_t mavlink_finalize_message(mavlink_message_t* msg,uint8_t system_id,uint8_t component_id,
60. uint8_t length);
61. #ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
62. MAVLINK_HELPER void _mav_finalize_message_chan_send(mavlink_channel_t chan,uint8_t msgid,constchar*packet,uint8_t length);
63. #endif
64. #endif// MAVLINK_CRC_EXTRA
65. MAVLINK_HELPER uint16_t mavlink_msg_to_send_buffer(uint8_t*buffer,constmavlink_message_t*msg);
66. MAVLINK_HELPER void mavlink_start_checksum(mavlink_message_t* msg);
67. MAVLINK_HELPER void mavlink_update_checksum(mavlink_message_t* msg,uint8_t c);
68. MAVLINK_HELPER uint8_t mavlink_frame_char_buffer(mavlink_message_t* rxmsg,
69. mavlink_status_t* status,
70. uint8_t c,
71. mavlink_message_t* r_message,
72. mavlink_status_t* r_mavlink_status);
73. MAVLINK_HELPER uint8_t mavlink_frame_char(uint8_t chan,uint8_t c,mavlink_message_t* r_message,mavlink_status_t* r_mavlink_status);
74. MAVLINK_HELPER uint8_t mavlink_parse_char(uint8_t chan,uint8_t c,mavlink_message_t* r_message,mavlink_status_t* r_mavlink_status);
75. MAVLINK_HELPER uint8_t put_bitfield_n_by_index(int32_t b,uint8_t bits,uint8_t packet_index,uint8_t bit_index,
76. uint8_t* r_bit_index,uint8_t* buffer);
77. #ifdef MAVLINK_USE_CONVENIENCE_FUNCTIONS
78. MAVLINK_HELPER void _mavlink_send_uart(mavlink_channel_t chan,constchar*buf,uint16_t len);
79. MAVLINK_HELPER void _mavlink_resend_uart(mavlink_channel_t chan,constmavlink_message_t*msg);
80. #endif
82. #else
84. #define MAVLINK_HELPER staticinline
85. #include"mavlink_helpers.h"
87. #endif// MAVLINK_SEPARATE_HELPERS
89. /**
90. * @brief Get the required buffer size for this message
91. */
92. staticinlineuint16_t mavlink_msg_get_send_buffer_length(constmavlink_message_t* msg)
93. {
94. return msg->len + MAVLINK_NUM_NON_PAYLOAD_BYTES;
95. }
97. #if MAVLINK_NEED_BYTE_SWAP
98. staticinlinevoid byte_swap_2(char*dst,constchar*src)
99. {
100. dst[0]= src[1];
101. dst[1]= src[0];
102. }
103. staticinlinevoid byte_swap_4(char*dst,constchar*src)
104. {
105. dst[0]= src[3];
106. dst[1]= src[2];
107. dst[2]= src[1];
108. dst[3]= src[0];
109. }
110. staticinlinevoid byte_swap_8(char*dst,constchar*src)
111. {
112. dst[0]= src[7];
113. dst[1]= src[6];
114. dst[2]= src[5];
115. dst[3]= src[4];
116. dst[4]= src[3];
117. dst[5]= src[2];
118. dst[6]= src[1];
119. dst[7]= src[0];
120. }
121. #elif!MAVLINK_ALIGNED_FIELDS
122. staticinlinevoid byte_copy_2(char*dst,constchar*src)
123. {
124. dst[0]= src[0];
125. dst[1]= src[1];
126. }
127. staticinlinevoid byte_copy_4(char*dst,constchar*src)
128. {
129. dst[0]= src[0];
130. dst[1]= src[1];
131. dst[2]= src[2];
132. dst[3]= src[3];
133. }
134. staticinlinevoid byte_copy_8(char*dst,constchar*src)
135. {
136. memcpy(dst, src,8);
137. }
138. #endif
140. #define_mav_put_uint8_t(buf, wire_offset, b) buf[wire_offset]=(uint8_t)b
141. #define_mav_put_int8_t(buf, wire_offset, b) buf[wire_offset]=(int8_t)b
142. #define _mav_put_char(buf, wire_offset, b) buf[wire_offset]= b
144. #if MAVLINK_NEED_BYTE_SWAP
145. #define_mav_put_uint16_t(buf, wire_offset, b) byte_swap_2(&buf[wire_offset],(constchar*)&b)
146. #define_mav_put_int16_t(buf, wire_offset, b) byte_swap_2(&buf[wire_offset],(constchar*)&b)
147. #define_mav_put_uint32_t(buf, wire_offset, b) byte_swap_4(&buf[wire_offset],(constchar*)&b)
148. #define_mav_put_int32_t(buf, wire_offset, b) byte_swap_4(&buf[wire_offset],(constchar*)&b)
149. #define_mav_put_uint64_t(buf, wire_offset, b) byte_swap_8(&buf[wire_offset],(constchar*)&b)
150. #define_mav_put_int64_t(buf, wire_offset, b) byte_swap_8(&buf[wire_offset],(constchar*)&b)
151. #define _mav_put_float(buf, wire_offset, b) byte_swap_4(&buf[wire_offset],(constchar*)&b)
152. #define _mav_put_double(buf, wire_offset, b) byte_swap_8(&buf[wire_offset],(constchar*)&b)
153. #elif!MAVLINK_ALIGNED_FIELDS
154. #define_mav_put_uint16_t(buf, wire_offset, b) byte_copy_2(&buf[wire_offset],(constchar*)&b)
155. #define_mav_put_int16_t(buf, wire_offset, b) byte_copy_2(&buf[wire_offset],(constchar*)&b)
156. #define_mav_put_uint32_t(buf, wire_offset, b) byte_copy_4(&buf[wire_offset],(constchar*)&b)
157. #define_mav_put_int32_t(buf, wire_offset, b) byte_copy_4(&buf[wire_offset],(constchar*)&b)
158. #define_mav_put_uint64_t(buf, wire_offset, b) byte_copy_8(&buf[wire_offset],(constchar*)&b)
159. #define_mav_put_int64_t(buf, wire_offset, b) byte_copy_8(&buf[wire_offset],(constchar*)&b)
160. #define _mav_put_float(buf, wire_offset, b) byte_copy_4(&buf[wire_offset],(constchar*)&b)
161. #define _mav_put_double(buf, wire_offset, b) byte_copy_8(&buf[wire_offset],(constchar*)&b)
162. #else
163. #define_mav_put_uint16_t(buf, wire_offset, b)*(uint16_t*)&buf[wire_offset]= b
164. #define_mav_put_int16_t(buf, wire_offset, b)*(int16_t*)&buf[wire_offset]= b
165. #define_mav_put_uint32_t(buf, wire_offset, b)*(uint32_t*)&buf[wire_offset]= b
166. #define_mav_put_int32_t(buf, wire_offset, b)*(int32_t*)&buf[wire_offset]= b
167. #define_mav_put_uint64_t(buf, wire_offset, b)*(uint64_t*)&buf[wire_offset]= b
168. #define_mav_put_int64_t(buf, wire_offset, b)*(int64_t*)&buf[wire_offset]= b
169. #define _mav_put_float(buf, wire_offset, b)*(float*)&buf[wire_offset]= b
170. #define _mav_put_double(buf, wire_offset, b)*(double*)&buf[wire_offset]= b
171. #endif
173. /*
174. like memcpy(), but if src is NULL, do a memset to zero
175. */
176. staticinlinevoid mav_array_memcpy(void*dest,constvoid*src,size_t n)
177. {
178. if(src == NULL){
179. memset(dest,0, n);
180. }else{
181. memcpy(dest, src, n);
182. }
183. }
185. /*
186. * Place a char array into a buffer
187. */
188. staticinlinevoid _mav_put_char_array(char*buf,uint8_t wire_offset,constchar*b,uint8_t array_length)
189. {
190. mav_array_memcpy(&buf[wire_offset], b, array_length);
192. }
194. /*
195. * Place a uint8_t array into a buffer
196. */
197. staticinlinevoid _mav_put_uint8_t_array(char*buf,uint8_t wire_offset,constuint8_t*b,uint8_t array_length)
198. {
199. mav_array_memcpy(&buf[wire_offset], b, array_length);
201. }
203. /*
204. * Place a int8_t array into a buffer
205. */
206. staticinlinevoid _mav_put_int8_t_array(char*buf,uint8_t wire_offset,constint8_t*b,uint8_t array_length)
207. {
208. mav_array_memcpy(&buf[wire_offset], b, array_length);
210. }
212. #if MAVLINK_NEED_BYTE_SWAP
213. #define _MAV_PUT_ARRAY(TYPE, V)
214. staticinlinevoid _mav_put_ ## TYPE ##_array(char *buf, uint8_t wire_offset, const TYPE *b, uint8_t array_length)
215. {
216. if(b == NULL){
217. memset(&buf[wire_offset],0, array_length*sizeof(TYPE));
218. }else{
219. uint16_t i;
220. for(i=0; i<array_length; i++){
221. _mav_put_## TYPE (buf, wire_offset+(i*sizeof(TYPE)), b[i]);
222. }
223. }
224. }
225. #else
226. #define _MAV_PUT_ARRAY(TYPE, V)
227. staticinlinevoid _mav_put_ ## TYPE ##_array(char *buf, uint8_t wire_offset, const TYPE *b, uint8_t array_length)
228. {
229. mav_array_memcpy(&buf[wire_offset], b, array_length*sizeof(TYPE));
230. }
231. #endif
233. _MAV_PUT_ARRAY(uint16_t, u16)
234. _MAV_PUT_ARRAY(uint32_t, u32)
235. _MAV_PUT_ARRAY(uint64_t, u64)
236. _MAV_PUT_ARRAY(int16_t, i16)
237. _MAV_PUT_ARRAY(int32_t, i32)
238. _MAV_PUT_ARRAY(int64_t, i64)
239. _MAV_PUT_ARRAY(float, f)
240. _MAV_PUT_ARRAY(double, d)
242. #define _MAV_RETURN_char(msg, wire_offset)(constchar)_MAV_PAYLOAD(msg)[wire_offset]
243. #define_MAV_RETURN_int8_t(msg, wire_offset)(int8_t)_MAV_PAYLOAD(msg)[wire_offset]
244. #define_MAV_RETURN_uint8_t(msg, wire_offset)(uint8_t)_MAV_PAYLOAD(msg)[wire_offset]
246. #if MAVLINK_NEED_BYTE_SWAP
247. #define _MAV_MSG_RETURN_TYPE(TYPE, SIZE)
248. staticinline TYPE _MAV_RETURN_## TYPE(const mavlink_message_t *msg, uint8_t ofs)
249. { TYPE r; byte_swap_## SIZE((char*)&r, &_MAV_PAYLOAD(msg)[ofs]); return r; }
251. _MAV_MSG_RETURN_TYPE(uint16_t,2)
252. _MAV_MSG_RETURN_TYPE(int16_t,2)
253. _MAV_MSG_RETURN_TYPE(uint32_t,4)
254. _MAV_MSG_RETURN_TYPE(int32_t,4)
255. _MAV_MSG_RETURN_TYPE(uint64_t,8)
256. _MAV_MSG_RETURN_TYPE(int64_t,8)
257. _MAV_MSG_RETURN_TYPE(float,4)
258. _MAV_MSG_RETURN_TYPE(double,8)
260. #elif!MAVLINK_ALIGNED_FIELDS
261. #define _MAV_MSG_RETURN_TYPE(TYPE, SIZE)
262. staticinline TYPE _MAV_RETURN_## TYPE(const mavlink_message_t *msg, uint8_t ofs)
263. { TYPE r; byte_copy_## SIZE((char*)&r, &_MAV_PAYLOAD(msg)[ofs]); return r; }
265. _MAV_MSG_RETURN_TYPE(uint16_t,2)
266. _MAV_MSG_RETURN_TYPE(int16_t,2)
267. _MAV_MSG_RETURN_TYPE(uint32_t,4)
268. _MAV_MSG_RETURN_TYPE(int32_t,4)
269. _MAV_MSG_RETURN_TYPE(uint64_t,8)
270. _MAV_MSG_RETURN_TYPE(int64_t,8)
271. _MAV_MSG_RETURN_TYPE(float,4)
272. _MAV_MSG_RETURN_TYPE(double,8)
273. #else// nicely aligned, no swap
274. #define _MAV_MSG_RETURN_TYPE(TYPE)
275. staticinline TYPE _MAV_RETURN_## TYPE(const mavlink_message_t *msg, uint8_t ofs)
276. {return*(const TYPE *)(&_MAV_PAYLOAD(msg)[ofs]);}
278. _MAV_MSG_RETURN_TYPE(uint16_t)
279. _MAV_MSG_RETURN_TYPE(int16_t)
280. _MAV_MSG_RETURN_TYPE(uint32_t)
281. _MAV_MSG_RETURN_TYPE(int32_t)
282. _MAV_MSG_RETURN_TYPE(uint64_t)
283. _MAV_MSG_RETURN_TYPE(int64_t)
284. _MAV_MSG_RETURN_TYPE(float)
285. _MAV_MSG_RETURN_TYPE(double)
286. #endif// MAVLINK_NEED_BYTE_SWAP
288. staticinlineuint16_t _MAV_RETURN_char_array(constmavlink_message_t*msg,char*value,
289. uint8_t array_length,uint8_t wire_offset)
290. {
291. memcpy(value,&_MAV_PAYLOAD(msg)[wire_offset], array_length);
292. return array_length;
293. }
295. staticinlineuint16_t _MAV_RETURN_uint8_t_array(constmavlink_message_t*msg,uint8_t*value,
296. uint8_t array_length,uint8_t wire_offset)
297. {
298. memcpy(value,&_MAV_PAYLOAD(msg)[wire_offset], array_length);
299. return array_length;
300. }
302. staticinlineuint16_t _MAV_RETURN_int8_t_array(constmavlink_message_t*msg,int8_t*value,
303. uint8_t array_length,uint8_t wire_offset)
304. {
305. memcpy(value,&_MAV_PAYLOAD(msg)[wire_offset], array_length);
306. return array_length;
307. }
309. #if MAVLINK_NEED_BYTE_SWAP
310. #define _MAV_RETURN_ARRAY(TYPE, V)
311. staticinlineuint16_t _MAV_RETURN_## TYPE ##_array(const mavlink_message_t *msg, TYPE *value,
312. uint8_t array_length,uint8_t wire_offset)
313. {
314. uint16_t i;
315. for(i=0; i<array_length; i++){
316. value[i]= _MAV_RETURN_## TYPE (msg, wire_offset+(i*sizeof(value[0])));
317. }
318. return array_length*sizeof(value[0]);
319. }
320. #else
321. #define _MAV_RETURN_ARRAY(TYPE, V)
322. staticinlineuint16_t _MAV_RETURN_## TYPE ##_array(const mavlink_message_t *msg, TYPE *value,
323. uint8_t array_length,uint8_t wire_offset)
324. {
325. memcpy(value,&_MAV_PAYLOAD(msg)[wire_offset], array_length*sizeof(TYPE));
326. return array_length*sizeof(TYPE);
327. }
328. #endif
330. _MAV_RETURN_ARRAY(uint16_t, u16)
331. _MAV_RETURN_ARRAY(uint32_t, u32)
332. _MAV_RETURN_ARRAY(uint64_t, u64)
333. _MAV_RETURN_ARRAY(int16_t, i16)
334. _MAV_RETURN_ARRAY(int32_t, i32)
335. _MAV_RETURN_ARRAY(int64_t, i64)
336. _MAV_RETURN_ARRAY(float, f)
337. _MAV_RETURN_ARRAY(double, d)
339. #endif// _MAVLINK_PROTOCOL_H_//作者：恒久力行  qq:624668529

12.其他代码均未修改，详细移植步骤请参考教程二和教程一。

 

现在代码已经移植成功。

 

二：实验测试代码是否移植成功

将代码下载到stm32f407的开发板中去。

打开串口调试助手，设置波特率115200,16进制显示接收到的数据。不细讲，看图

1.测试开发板发送功能

       然后重启或者复位开发板，会有数据返回（注意：选中16进制显示）。如图收到如图数据表示发送移植成功。复位一次返回一次同样的数据//作者：恒久力行  qq:624668529

        

 2.测试开发板接收功能

    将接收到的数据原封不动的拷贝下来，（复制下来的是16进制的哦，别弄成字符乱码了，注意从FE到结尾的空格都不能少），然后选中16进制发送 同时取消16进制显示。然后将数据粘贴在发送窗(发送窗一定要清空，不能有空格或者回车让光标删除到最前端)，先清空接收，点击发送，会有如下字符返回，如图表示接受移植成功。点击一次发送返回一次同样的字符//作者：恒久力行  qq:624668529

    

 

三：分析数据

1.下面是串口助手接收到的开发板发过来的数据

1. FE 0900000000000000000203510403855D FE 1C01000021010000000200000003000000040000000500000006000700080009002A16

2.下图是消息包的发送格式说明

 

3.将从开发板收到的16进制的数据以FE为分界将两条消息按格式展开如图

 

 

 

 

 

4分析

开发板发出的数据，首先都是以FE开头，先看第一帧数据的第二个字节，LEN代表有效载荷PAYLOAD的长度，经自己亲自数数PAYLOAD   确实是9个字节（注意16进制要转换成10进制），同理，再来看第二帧数据的第二个字节1C转换成10进制是28.数一数PAYLOAD的长度确实为28.表示移植数据发送成功。

 

开发板接收的数据是我们原封不动发回去的数据，其收到后，会对数据进行解析。其对两帧数据解析的结果是（即第二次发回来的字符）：

Received message with ID 0, sequence: 0 from component 0 of system 0

Received message with ID 33, sequence: 1 from component 0 of system 0

 

对比message with ID 即是 MSG   (10进制)

        sequence              既是SEQ

        component           既是COMP

        system                  既是SYS

 

对比之后发现数据一一对应。即开发板收到数据后成功的解析了数据。表示移植开发板接收部分成功

 

 

移植成功。作者：恒久力行 qq:624668529

 

  

附件列表