stm32-sbus数据接收，并通过CAN转发给车辆控制

1）串口程序,代码如下：

#include "sys.h"
#include "usart.h"	  
//
//uart2
int fputc(int ch,FILE *f)  
{    
    while(USART_GetFlagStatus(USART2,USART_FLAG_TC) != SET);   
    USART_SendData(USART2,(unsigned char)ch);      
    while(USART_GetFlagStatus(USART2,USART_FLAG_TC) != SET);    
    return (ch);    
} 
 
//串口1中断服务程序
//注意,读取USARTx->SR能避免莫名其妙的错误   	
u8 USART_RX_BUF[USART_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.
//接收状态
//bit15，	接收完成标志
//bit14，	接收到0x0d
//bit13~0，	接收到的有效字节数目
u16 USART_RX_STA=0;       //接收状态标记	  
  
//SBUS 相关变量定义
u8 RC_LEN=0;//接收数组字长
u16 sBUF[25];//缓冲buf
u16 Data[25];//存储BUF
u8 uart1RxFlag;
u16 data_22[22];//计算转换过度
unsigned char	data_b[176];//二进制存储
int data_ch[16];//最终存储
u8 ChannelDataChangeFlg=1;
int lastdata_ch[16];//最终存储

void Sbus_uart_init(u32 bound)
{
  //GPIO端口设置
  GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
	 
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA|RCC_APB2Periph_AFIO, ENABLE);	//使能USART1，GPIOA时钟以及复用功能时钟
	//USART1_TX   PA.9
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;	//复用推挽输出
	GPIO_Init(GPIOA, &GPIO_InitStructure);
 
	//USART1_RX	  PA.10
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
	GPIO_Init(GPIOA, &GPIO_InitStructure);  

 //Usart1 NVIC 配置

	NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;		//子优先级3
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//IRQ通道使能
	NVIC_Init(&NVIC_InitStructure);	//根据指定的参数初始化VIC寄存器
  
   //USART 初始化设置

	USART_InitStructure.USART_BaudRate = bound;//一般设置为100000;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
	USART_InitStructure.USART_StopBits = USART_StopBits_2;//一个停止位
	USART_InitStructure.USART_Parity = USART_Parity_Even;//偶校验
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;	//收发模式

	USART_Init(USART1, &USART_InitStructure); //初始化串口
	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启中断
	USART_Cmd(USART1, ENABLE);                    //使能串口 

}

void USART1_IRQHandler(void)                	//串口1中断服务程序
{
  u8 i;	
	if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
	{
			sBUF[RC_LEN++]=USART_ReceiveData(USART1);
			//if(sBUF[0]==0x0f&&sBUF[24]==0x08&&RC_LEN==25)//如果帧头和帧尾满足			0xF0开头，0x00结尾
			if(sBUF[0]==0x0f&&RC_LEN==25)//如果帧头和帧尾满足
			{
					RC_LEN=0;
					for(i=0;i<25;i++)
					{
							if(i==0) uart1RxFlag=0;
							Data[i]=0;
					}//清零数组
					for(i=0;i<25;i++)
					{
							Data[i]=sBUF[i];
					}
					uart1RxFlag=1;
			}
	}
} 

void Cal_RcData(void)//解析收到的通道数据
{
	u8 i,j=0;
	for(i=1;i<23;i++)
	{
			data_22[j++]=Data[i];//摘取22位通道数据
	}	
	
//	for(i=0;i<22;i++)
//	{
//		printf("%x ",data_22[i]);
//	}
//	printf("\r\n");
	
	for(i=0;i<22;i++)//转换位2进制存储
	{
			int k=1;
			for(j=0;j<8;j++)
			{	 
					data_b[j+8*i]=(data_22[i]&k)>>j;
					k<<=1;	
			} 	
	}
	
//	for(i=0;i<22;i++)
//	{
//		printf("%x ",data_b[i]);
//	}
//	printf("\r\n");
	
	for(i=0;i<16;i++)//清零过程，不清零莫名奇妙的错误
	{
			data_ch[i]=0x00;		
	}
	for(j=0;j<16;j++)//转换为SBUS要求的格式 
	{
			for(i=10;i>0;i--)
			{
				data_ch[j]=data_ch[j]|(data_b[i+j*11]<<i);
			}     
	}	
}

2）can程序,代码如下：

#include "can.h"
#include "stdio.h"
#include "oled.h"

typedef enum {FAILED = 0, PASSED = !FAILED} TestStatus;

/* 在中断处理函数中返回 */
__IO uint32_t ret = 0;

volatile TestStatus TestRx;	

/*CAN RX0 中断优先级配置  */
 void CAN_NVIC_Configuration(void)
{
    NVIC_InitTypeDef NVIC_InitStructure;

  	/* Configure the NVIC Preemption Priority Bits */  
  	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);

	#ifdef  VECT_TAB_RAM  
	  /* Set the Vector Table base location at 0x20000000 */ 
	  NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0); 
	#else  /* VECT_TAB_FLASH  */
	  /* Set the Vector Table base location at 0x08000000 */ 
	  NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);   
	#endif

	/* enabling interrupt */
  	NVIC_InitStructure.NVIC_IRQChannel=USB_LP_CAN1_RX0_IRQn;;
  	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  	NVIC_Init(&NVIC_InitStructure);
}

/*CAN GPIO 和时钟配置 */
 void CAN_GPIO_Config(void)
{
  GPIO_InitTypeDef GPIO_InitStructure; 
  /* 复用功能和GPIOA端口时钟使能*/	 
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);	                        											 
	
	/* CAN1 模块时钟使能 */
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE); 

  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_Init(GPIOA, &GPIO_InitStructure);   
 /* Configure CAN pin: RX */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; 
  GPIO_Init(GPIOA, &GPIO_InitStructure);   
	
}

/*	CAN初始化 */
 void CAN_INIT(void)
{
  CAN_InitTypeDef        CAN_InitStructure;
  CAN_FilterInitTypeDef  CAN_FilterInitStructure;
//  CanTxMsg TxMessage;  

  /* CAN register init */
  CAN_DeInit(CAN1);	//将外设CAN的全部寄存器重设为缺省值
  CAN_StructInit(&CAN_InitStructure);//把CAN_InitStruct中的每一个参数按缺省值填入

  /* CAN cell init */
  CAN_InitStructure.CAN_TTCM=DISABLE;//没有使能时间触发模式
  CAN_InitStructure.CAN_ABOM=ENABLE; //使能自动离线管理
  CAN_InitStructure.CAN_AWUM=DISABLE;//没有使能自动唤醒模式
  CAN_InitStructure.CAN_NART=DISABLE;//没有使能非自动重传模式
  CAN_InitStructure.CAN_RFLM=DISABLE;//没有使能接收FIFO锁定模式
  CAN_InitStructure.CAN_TXFP=DISABLE;//没有使能发送FIFO优先级
  CAN_InitStructure.CAN_Mode=CAN_Mode_Normal;//CAN设置为正常模式
	
  CAN_InitStructure.CAN_SJW=CAN_SJW_1tq; //重新同步跳跃宽度1个时间单位
  CAN_InitStructure.CAN_BS1=CAN_BS1_3tq; //时间段1为3个时间单位
  CAN_InitStructure.CAN_BS2=CAN_BS2_2tq; //时间段2为2个时间单位
  CAN_InitStructure.CAN_Prescaler=12;  //时间单位长度为12	
  CAN_Init(CAN1,&CAN_InitStructure);   //波特率为：72M/2/12(1+3+2)=0.5 即100K

  /* CAN filter init */
  CAN_FilterInitStructure.CAN_FilterNumber=1;//指定过滤器为1
  CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;//指定过滤器为标识符屏蔽位模式
  CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;//过滤器位宽为32位
  CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;// 过滤器标识符的高16位值
  CAN_FilterInitStructure.CAN_FilterIdLow=0x0000;//	 过滤器标识符的低16位值
  CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;//过滤器屏蔽标识符的高16位值
  CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;//	过滤器屏蔽标识符的低16位值
  CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0;// 设定了指向过滤器的FIFO为0
  CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;// 使能过滤器
  CAN_FilterInit(&CAN_FilterInitStructure);//	按上面的参数初始化过滤器

  /* CAN FIFO0 message pending interrupt enable */ 
  CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE); //使能FIFO0消息挂号中断
 
 }  
/* 发送两个字节的数据*/
void can_tx(u8 Data1,u8 Data2)
{ 
  CanTxMsg TxMessage;  

  TxMessage.StdId=0x636;	//标准标识符为0x636
  //TxMessage.ExtId=0x0000; //扩展标识符0x0000
  TxMessage.IDE=CAN_ID_STD;//使用标准标识符
  TxMessage.RTR=CAN_RTR_DATA;//为数据帧
  TxMessage.DLC=8;	//	消息的数据长度为8个字节
  TxMessage.Data[0]=Data1; //第一个字节数据
  TxMessage.Data[1]=Data2; //第二个字节数据 
  TxMessage.Data[2]=0x00;  //第三个字节数据
  TxMessage.Data[3]=0x00;  //第四个字节数据 
	TxMessage.Data[4]=0x00;  //第五个字节数据
  TxMessage.Data[5]=0x00;  //第六个字节数据 
  TxMessage.Data[6]=0x00;  //第七个字节数据
  TxMessage.Data[7]=0x00;  //第八个字节数据 	
  CAN_Transmit(CAN1,&TxMessage); //发送数据
}
/* USB中断和CAN接收中断服务程序，USB跟CAN公用I/O，这里只用到CAN的中断。 */
void USB_LP_CAN1_RX0_IRQHandler(void)
{  
  CanRxMsg RxMessage;

  RxMessage.StdId=0x646;
  RxMessage.ExtId=0x00;
  RxMessage.IDE=0;
  RxMessage.DLC=0;
  RxMessage.FMI=0;
  RxMessage.Data[0]=0x00;
  RxMessage.Data[1]=0x00;    

  CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据  
  if((RxMessage.Data[0]==0x55)&&(RxMessage.Data[1]==0x77))   
  { 
			//测试代码
			//printf("IRQ RxMessage.Data = %s\r\n", RxMessage.Data); 
	}
} 

3）主函数程序，代码如下：

#include "delay.h"
#include "sys.h"
#include "can.h"
#include "usart.h"

void LED_Init(void)
{
		GPIO_InitTypeDef GPIO_InitStructure;
		RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);	

		GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
		GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;  //配置GPIO_Speed为50MHz，必须加，否则不输出
		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;   
		GPIO_Init(GPIOB, &GPIO_InitStructure);
}

void uart_init2(u32 bound)
{
		//GPIO端口设置
		GPIO_InitTypeDef GPIO_InitStructure;
		USART_InitTypeDef USART_InitStructure;
		NVIC_InitTypeDef NVIC_InitStructure;
		 
		RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);	//使能USART2，GPIOA时钟
		RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,ENABLE);
		USART_DeInit(USART2);  //复位串口2
	 //USART2_TX   PA.2
		GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2; //PA.2
		GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;	//复用推挽输出
		GPIO_Init(GPIOA, &GPIO_InitStructure); //初始化PA2
	 
		//USART2_RX	  PA.3
		GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
		GPIO_Init(GPIOA, &GPIO_InitStructure);  //初始化PA3

		//Usart2 NVIC 配置
		NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
		NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3
		NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;		//子优先级3
		NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//IRQ通道使能
		NVIC_Init(&NVIC_InitStructure);	//根据指定的参数初始化VIC寄存器
		
		//USART 初始化设置
		USART_InitStructure.USART_BaudRate = bound;//一般设置为115200;
		USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
		USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
		USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
		USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
		USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;	//收发模式

		USART_Init(USART2, &USART_InitStructure); //初始化串口
		USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);//开启中断
		USART_Cmd(USART2, ENABLE);                    //使能串口 
}

/************************************************************************************************
*通道0  右侧遥杆(挨着C),  向左打死292，			向右打死1678
*
*通道1	右侧遥杆(挨着C),	向左打死540，			向后打死1294
*
*通道2	左侧遥杆(挨着B),	向前打死236,		 	向后打死1622
*
*通道3  左侧遥杆(挨着B),	向左打死330,		 	向右打死1716
*
*通道4	拨动按钮(就是F),	向下拨306，				向上拨1694
*
*通道5	左侧遥杆(挨着B),	向前打死306，			向后打死1694 这个通道的数据跟通道2的数据变化是一样的，冗余了，取一个值应该就可以了
*
*通道6	拨动按钮(就是C),	向前拨306，				拨中间1000，				向后拨1694
*
*通道7	选转按钮(挨着C),	逆时针旋转死306，	顺时针旋转死1694
*
*通道8	拨动按钮(就是B),	向前拨306，				向后拨1694
*
*通道9	拨动按钮(就是A),	向前拨306，				向后拨1694
*************************************************************************************************/

/***********************************************************************************************/
long int delayNum = 0;
uint8_t ledflag = 0;
int main(void)
{	
		int i = 0,k = 0;
		delay_init();	    	 //延时函数初始化	  
		LED_Init();			     //LED端口初始化
		NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
		Sbus_uart_init(100000);	 //串口初始化为115200 uart1 SBUS
		uart_init2(115200);  //uart2
		CAN_GPIO_Config();//CAN管脚初始化
		CAN_NVIC_Configuration(); //CAN中断初始化   
		CAN_INIT();//CA初始化N模块	
		delay_ms(1000);
		GPIO_SetBits(GPIOB,GPIO_Pin_12);
		while(1) 
		{	 
				if(uart1RxFlag == 1)
				{
						uart1RxFlag=0;				
						Cal_RcData();
						ChannelDataChangeFlg=0;
						for(i=0;i<10;i++)
						{
								if(lastdata_ch[i]!=data_ch[i])
								{
									ChannelDataChangeFlg=1;
									lastdata_ch[i]=data_ch[i];	
								}				
						}
						if(ChannelDataChangeFlg==1)		
						{
								for(k=0;k<10;k++)
								{	
									printf("%d: ",data_ch[k]);
									if(k == 9) printf("\r\n");
								}
								if(ledflag == 0)
								{
										ledflag = 1;
										GPIO_ResetBits(GPIOB,GPIO_Pin_12);
								}
								else if(ledflag == 1)
								{
										ledflag = 0;
										GPIO_SetBits(GPIOB,GPIO_Pin_12);
								}
								can_tx(0xAA,0XBB);								
						}	
				}
		}	  
}

void uart_send_test(void)
{
		delay_ms(100);
		USART_SendData(USART1, (uint8_t) 0x59);
		while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET) {}	  
		printf("IRQ RxMessage.Data =\r\n"); 
			
		delay_ms(100);
		USART_SendData(USART2, (uint8_t) 0x59);
		while(USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET) {}	   
}

4）串口接收后，验证结果如下：