Chinaunix首页 | 论坛 | 博客

牛蹄印章_VX_iibull

首页　| 　博文目录　| 　关于我

iibull

  • 博客访问： 9393043
  • 博文数量： 1747
  • 博客积分： 12961
  • 博客等级： 上将
  • 技术积分： 20060
  • 用 户 组： 普通用户
  • 注册时间： 2009-01-09 11:25
个人简介

偷得浮生半桶水(半日闲), 好记性不如抄下来(烂笔头). 信息爆炸的时代, 学习是一项持续的工作.

文章分类

全部博文（1747）

文章存档

2024年（23）

2023年（26）

2022年（112）

2021年（217）

2020年（157）

2019年（192）

2018年（81）

2017年（78）

2016年（70）

2015年（52）

2014年（40）

2013年（51）

2012年（85）

2011年（45）

2010年（231）

2009年（287）

我的朋友
最近访客
推荐博文
相关博文
STM32串口3 映射和完全重映射 PB10 PB11 / PD8 PD9 / PC10 PC11

分类： 其他平台

2020-01-09 17:05:43

https://blog.csdn.net/qq_36958104/article/details/103496897

STM32F103共有五个串口，有时候在项目中，其他的引脚已经配置用了，重新改太麻烦


STM32串口3 映射和完全重映射 PB10 PB11 PD8 PD9  PC10 PC11


所有本次实验 使用了串口3的映射端口，配置和普通的类似 


只是注意要使用映射使能说明

GPIO_PinRemapConfig(GPIO_FullRemap_USART3  , ENABLE); 

点击(此处)折叠或打开

  1. void USART3_Configuration(u32 bound)
  2. {
  3.   //GPIO端口设置
  4.   GPIO_InitTypeDef GPIO_InitStructure;
  5.     USART_InitTypeDef USART_InitStructure;
  6.     NVIC_InitTypeDef NVIC_InitStructure;
  7.     
  8.  #if 1
  9.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOD|RCC_APB2Periph_AFIO, ENABLE); //remap时钟|RCC_APB2Periph_AFIO //开启GPIOB时钟
  10.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);//这里要分开打开 //USART3时钟 来自APB1
  11. #endif
  12.     
  13. #if 0
  14.     
  15.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3,ENABLE);
  16.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);//开启GPIOB和USART3时钟
  17.     
  18.         //USART3_TX GPIOB.10
  19.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; //PB.10
  20.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  21.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;    //复用推挽输出
  22.     GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIOA.10
  23.     
  24.     //USART3_RX     GPIOB.11初始化
  25.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;//PB11
  26.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
  27.     GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIOB.11
  28.     
  29. #endif    
  30.     
  31.  
  32. #if 0    //重映射
  33.  
  34.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOD|RCC_APB2Periph_AFIO, ENABLE); //remap时钟|RCC_APB2Periph_AFIO //开启GPIOB时钟
  35.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);//这里要分开打开 //USART3时钟 来自APB1
  36.     
  37.     //GPIO_PartialRemap_USART3 部分重映射 GPIOC_10 GPIOC_11
  38.     
  39.     GPIO_PinRemapConfig(GPIO_PartialRemap_USART3,ENABLE);
  40.     //USART3_TX GPIOC.10
  41.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; //
  42.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  43.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;    //复用推挽输出
  44.   GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化
  45.    
  46.   //USART3_RX     GPIOC.11初始化
  47.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;//
  48.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
  49.   GPIO_Init(GPIOC, &GPIO_InitStructure);//初始
  50. #endif
  51.  
  52.  
  53. #if 1
  54.  
  55.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD|RCC_APB2Periph_AFIO, ENABLE); //remap时钟|RCC_APB2Periph_AFIO //开启GPIOB时钟
  56.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);//这里要分开打开 //USART3时钟 来自APB1
  57.  
  58.      //GPIO_FullRemap_USART3 完全重映射 D8 D9
  59.      GPIO_PinRemapConfig(GPIO_FullRemap_USART3,ENABLE);
  60.     //USART3_TX GPIOD8
  61.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8; //
  62.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  63.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;    //复用推挽输出
  64.   GPIO_Init(GPIOD, &GPIO_InitStructure);//初始化
  65.    
  66.   //USART3_RX     GPIOD9
  67.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;//
  68.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
  69.   GPIO_Init(GPIOD, &GPIO_InitStructure);//初始
  70. #endif
  71.  
  72.  
  73.   //Usart3 NVIC 配置
  74.   NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
  75.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=1 ;//抢占优先级3
  76.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;        //子优先级3
  77.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;            //IRQ通道使能
  78.     NVIC_Init(&NVIC_InitStructure);    //根据指定的参数初始化VIC寄存器
  79.   
  80.    //USART 初始化设置
  81.  
  82.     USART_InitStructure.USART_BaudRate = bound;//串口波特率
  83.     USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
  84.     USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
  85.     USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
  86.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
  87.     USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;    //收发模式
  88.  
  89.   USART_Init(USART3, &USART_InitStructure); //初始化串口3
  90.   USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);//开启串口接受中断
  91.   USART_Cmd(USART3, ENABLE); //使能串口3
  92.  
  93. }

点击(此处)折叠或打开

  1. #include "sys.h"
  2. #include "usart.h"
  3. #include "timer.h"
  4. #include "stdint.h"
  5.  u8     checkdata[8];        //检测串口1接收的特定数据数据
  6. //发送上位机的数据
  7. //
  8. uint32_t crc16_data1[] = { 0x00,0x00, 0x00 };//饮水机数据
  9. uint32_t crc16_data2[] = { 0x00,0x00, 0x00 };//
  10. uint32_t crc16_data3[] = { 0x00,0x00, 0x00 };//
  11. uint32_t crc16_data4[] = { 0x00,0x00, 0x00 };//
  12. uint32_t crc16_data5[] = { 0x00,0x00, 0x00 };//
  13. uint32_t crc16_data6[] = { 0x00,0x00, 0x00 };//
  14. uint32_t crc16_data7[] = { 0x00,0x00, 0x00 };//
  15. uint32_t crc16_data8[] = { 0x00,0x00, 0x00 };//
  16. uint32_t crc16_data9[] = { 0x00,0x00, 0x00 };//
  17. uint32_t crc16_data10[]= { 0x00,0x00, 0x00 };//
  18.  
  19.  
  20. //串口1队列定义
  21. u8     UART1SendBuff[UART1BuffSize];        //发送数据
  22. u8     UART1ReceBuff[UART1BuffSize];        //接收数据？
  23. u16 UART1ReceIn = 0;//接收状态标记数据位    
  24. u8 UART1ReceFullFlag = 0;//接收完数据标志位
  25.  
  26.  
  27. //串口3队列定义
  28. u8     UART3SendBuff[UART3BuffSize];        //发送数据
  29. u8     UART3ReceBuff[UART3BuffSize];        //接收数据？
  30. u16 UART3ReceIn = 0;//接收状态标记数据位    
  31. u8 UART3ReceFullFlag = 0;//接收完数据标志位
  32.  
  33. void USART1_Configuration(u32 bound){
  34.   //GPIO端口设置
  35.   GPIO_InitTypeDef GPIO_InitStructure;
  36.     USART_InitTypeDef USART_InitStructure;
  37.     NVIC_InitTypeDef NVIC_InitStructure;
  38.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);    //使能USART1，GPIOA时钟
  39.   
  40.     //USART1_TX GPIOA.9
  41.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
  42.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  43.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;    //复用推挽输出
  44.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.9
  45.    
  46.   //USART1_RX     GPIOA.10初始化
  47.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
  48.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
  49.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.10
  50.  
  51.   //Usart1 NVIC 配置
  52.   NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
  53.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2 ;//抢占优先级3
  54.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;        //子优先级3
  55.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;            //IRQ通道使能
  56.     NVIC_Init(&NVIC_InitStructure);    //根据指定的参数初始化VIC寄存器
  57.   
  58.    //USART 初始化设置
  59.     USART_InitStructure.USART_BaudRate = bound;//串口波特率
  60.     USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
  61.     USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
  62.     USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
  63.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
  64.     USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;    //收发模式
  65.  
  66.   USART_Init(USART1, &USART_InitStructure); //初始化串口1
  67.   USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接受中断
  68.   USART_Cmd(USART1, ENABLE); //使能串口1
  69.  
  70. }
  71.  
  72. void USART3_Configuration(u32 bound)
  73. {
  74.   //GPIO端口设置
  75.   GPIO_InitTypeDef GPIO_InitStructure;
  76.     USART_InitTypeDef USART_InitStructure;
  77.     NVIC_InitTypeDef NVIC_InitStructure;
  78.     
  79.  #if 1
  80.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOD|RCC_APB2Periph_AFIO, ENABLE); //remap时钟|RCC_APB2Periph_AFIO //开启GPIOB时钟
  81.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);//这里要分开打开 //USART3时钟 来自APB1
  82. #endif
  83.     
  84. #if 0
  85.     
  86.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3,ENABLE);
  87.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);//开启GPIOB和USART3时钟
  88.     
  89.         //USART3_TX GPIOB.10
  90.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; //PB.10
  91.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  92.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;    //复用推挽输出
  93.     GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIOA.10
  94.     
  95.     //USART3_RX     GPIOB.11初始化
  96.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;//PB11
  97.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
  98.     GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIOB.11
  99.     
  100. #endif    
  101.     
  102.  
  103. #if 0    //重映射
  104.  
  105.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOD|RCC_APB2Periph_AFIO, ENABLE); //remap时钟|RCC_APB2Periph_AFIO //开启GPIOB时钟
  106.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);//这里要分开打开 //USART3时钟 来自APB1
  107.     
  108.     //GPIO_PartialRemap_USART3 部分重映射 GPIOC_10 GPIOC_11
  109.     
  110.     GPIO_PinRemapConfig(GPIO_PartialRemap_USART3,ENABLE);
  111.     //USART3_TX GPIOC.10
  112.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10; //
  113.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  114.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;    //复用推挽输出
  115.   GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化
  116.    
  117.   //USART3_RX     GPIOC.11初始化
  118.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;//
  119.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
  120.   GPIO_Init(GPIOC, &GPIO_InitStructure);//初始
  121. #endif
  122.  
  123.  
  124. #if 1
  125.  
  126.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD|RCC_APB2Periph_AFIO, ENABLE); //remap时钟|RCC_APB2Periph_AFIO //开启GPIOB时钟
  127.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);//这里要分开打开 //USART3时钟 来自APB1
  128.  
  129.      //GPIO_FullRemap_USART3 完全重映射 D8 D9
  130.      GPIO_PinRemapConfig(GPIO_FullRemap_USART3,ENABLE);
  131.     //USART3_TX GPIOD8
  132.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8; //
  133.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  134.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;    //复用推挽输出
  135.   GPIO_Init(GPIOD, &GPIO_InitStructure);//初始化
  136.    
  137.   //USART3_RX     GPIOD9
  138.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;//
  139.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
  140.   GPIO_Init(GPIOD, &GPIO_InitStructure);//初始
  141. #endif
  142.  
  143.  
  144.   //Usart3 NVIC 配置
  145.   NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
  146.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=1 ;//抢占优先级3
  147.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;        //子优先级3
  148.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;            //IRQ通道使能
  149.     NVIC_Init(&NVIC_InitStructure);    //根据指定的参数初始化VIC寄存器
  150.   
  151.    //USART 初始化设置
  152.  
  153.     USART_InitStructure.USART_BaudRate = bound;//串口波特率
  154.     USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
  155.     USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
  156.     USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
  157.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
  158.     USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;    //收发模式
  159.  
  160.   USART_Init(USART3, &USART_InitStructure); //初始化串口3
  161.   USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);//开启串口接受中断
  162.   USART_Cmd(USART3, ENABLE); //使能串口3
  163.  
  164. }
  165.  
  166.  
  167.  
  168.  
  169.  
  170.  
  171. //串口1发送一帧数据
  172. void USART1_SendOneData(uint32_t SendOneData)
  173. {
  174.     USART_SendData(USART1, SendOneData);
  175.     while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET)
  176.     {}
  177. }
  178. //串口2发送一帧数据
  179. void USART2_SendOneData(uint32_t SendOneData)
  180. {
  181.     USART_SendData(USART2, SendOneData);
  182.     while (USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET)
  183.     {}
  184. }
  185.  
  186. //串口3发送一帧数据
  187. void USART3_SendOneData(uint32_t SendOneData)
  188. {
  189.     USART_SendData(USART3, SendOneData);
  190.     while (USART_GetFlagStatus(USART3, USART_FLAG_TC) == RESET)
  191.     {}
  192. }
  193. //串口1发送一列数据
  194. void USART1_SendUnfixedData(uint32_t *Buffer, uint8_t Length)
  195. {
  196.     uint8_t i;
  197.     for(i=0;i<Length;i++)
  198.     {
  199.         USART1_SendOneData(*Buffer++);
  200.     }
  201. }
  202.  
  203. //串口2发送一列数据
  204. void USART2_SendUnfixedData(uint32_t *Buffer, uint8_t Length)
  205. {
  206.     uint8_t i;
  207.     for(i=0;i<Length;i++)
  208.     {
  209.         USART2_SendOneData(*Buffer++);
  210.     }
  211. }
  212.  
  213. //串口3发送一列数据
  214. void USART3_SendUnfixedData(uint32_t *Buffer, uint8_t Length)
  215. {
  216.     uint8_t i;
  217.     for(i=0;i<Length;i++)
  218.     {
  219.         USART3_SendOneData(*Buffer++);
  220.     }
  221. }
  222.  
  223.  
  224.  
  225. //串口1中断服务函数
  226. void USART1_IRQHandler(void)
  227. {
  228.     u8 Res;//数据暂存
  229.     if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) //接收中断
  230.     {
  231.         Res =USART_ReceiveData(USART1);    //读取接收到的数据        
  232.         switch(UART1ReceIn)//读取接收到的数据有几位 每一位对应的数据协议校验
  233.         {
  234.             case 0:
  235.                 if(Res==0xFE)
  236.                     UART1ReceBuff[UART1ReceIn++] = Res;
  237.                 else
  238.                     UART1ReceIn = 0;
  239.                 break;
  240.             case 1:
  241.                 if(Res==0xFE)
  242.                     UART1ReceBuff[UART1ReceIn++] = Res;
  243.                 else
  244.                     UART1ReceIn = 0;
  245.                 break;
  246.             case 2://此处为判断数据的位置 正反转
  247. //                if(Res==0x02)//在其他位置判断数据
  248. //                {UART1ReceBuff[UART1ReceIn++] = Res;
  249. //                    checkdata[0]=UART1ReceBuff[2];}
  250.             {UART1ReceBuff[UART1ReceIn++] = Res;
  251.             checkdata[0]=UART1ReceBuff[2];
  252.             
  253.             }
  254.             break;
  255.             case 3://此处为判断数据的位置 旋转角度
  256. //                if(Res==0x02)//在其他位置判断数据
  257. //                {UART1ReceBuff[UART1ReceIn++] = Res;
  258. //                    checkdata[0]=UART1ReceBuff[2];}
  259.             {UART1ReceBuff[UART1ReceIn++] = Res;
  260.             checkdata[1]=UART1ReceBuff[3];    //接收到的角度数据和实际齿轮数据不一致        
  261.             }    
  262.             break;            
  263.             case 4:
  264.                 if(Res==0xFD)
  265.                     UART1ReceBuff[UART1ReceIn++] = Res;
  266.                 else
  267.                     UART1ReceIn = 0;
  268.                 break;
  269.             case 5:
  270.                 if(Res==0xFD)
  271.                     UART1ReceBuff[UART1ReceIn++] = Res;
  272.                 else
  273.                     UART1ReceIn = 0;
  274.                 break;
  275.             default:
  276.                 UART1ReceBuff[UART1ReceIn++] = Res;
  277.                 break;
  278.         }
  279.  
  280.         if(UART1ReceIn >= 5)
  281.         {
  282.             UART1ReceFullFlag = 1;    //数据完整接受完
  283.                 UART1ReceIn = 0;
  284.              timer8flag=0;
  285.         }
  286. //        USART_ClearFlag(USART1, USART_IT_RXNE);//清除相对应的中断位 清除中断预处理位USART_ClearITPendingBit左移八位是USART_ClearFlag
  287.         USART_ClearITPendingBit(USART1, USART_IT_RXNE);//清除相对应的中断位 清除中断预处理位USART_ClearITPendingBit左移八位是USART_ClearFlag
  288. //        
  289.     }
  290.      if(USART_GetITStatus(USART1, USART_IT_TXE) != RESET)    // 发送中断 USART_GetITStatus
  291.     {
  292.     //    USART_ClearFlag(USART1, USART_IT_TXE);                    // clear interrupt 清除中断预处理位
  293.         USART_ClearITPendingBit(USART1, USART_IT_TXE);                    // clear interrupt 清除中断预处理位
  294.     }    
  295. //    if(USART_GetFlagStatus(USART1, USART_FLAG_ORE) != RESET)
  296. //    {    
  297. //        USART_ClearFlag(USART1, USART_FLAG_ORE);    
  298. //    }
  299.  
  300. }
  301.  
  302.  
  303. //串口3中断服务函数
  304. void USART3_IRQHandler(void)
  305. {
  306.     u8 Res;//数据暂存
  307.     if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET) //接收中断
  308.     {
  309.         Res =USART_ReceiveData(USART3);    //读取接收到的数据 USART_ReceiveData
  310.             USART_SendData(USART1,Res);//将读取到的数据通过串口1发送
  311.         switch(UART3ReceIn)//读取接收到的数据有几位 每一位对应的数据协议校验
  312.         {
  313.             case 0:
  314.                 if(Res==0XFE)
  315.                     UART3ReceBuff[UART3ReceIn++] = Res;
  316.                 else
  317.                     UART3ReceIn = 0;
  318.                 break;
  319.             case 10:
  320.                 if(Res==0xFF)
  321.                     UART3ReceBuff[UART3ReceIn++] = Res;
  322.                 else
  323.                     UART3ReceIn = 0;
  324.                 break;
  325.             default:
  326.                 UART3ReceBuff[UART3ReceIn++] = Res;
  327.                 break;
  328.         }
  329.  
  330.         if(UART3ReceIn >= 11)
  331.         {
  332.             UART3ReceFullFlag = 1;    //数据完整接受完
  333.         }
  334.         USART_ClearITPendingBit(USART3, USART_IT_RXNE);//清除相对应的中断位 清除中断预处理位USART_ClearITPendingBit左移八位是USART_ClearFlag
  335.     }
  336.     else if(USART_GetITStatus(USART3, USART_IT_TXE) != RESET)    // 发送中断 USART_GetITStatus
  337.     {
  338.         USART_ClearITPendingBit(USART3, USART_IT_TXE);                    // clear interrupt 清除中断预处理位
  339.     }    
  340. }
  341.  
  342. void send_data()
  343. {
  344.     //刷新位置信息
  345. if(timer8flag100ms==1)
  346. {
  347. timer8flag100ms=0;
  348.     
  349.             //发送协议头 FE FE D1
  350.             USART_SendData(USART1,0xFA);//向串口1发送数据
  351.             while(USART_GetFlagStatus(USART1,USART_FLAG_TC)!=SET);//等待发送结束
  352.             USART_SendData(USART1,0xFC);
  353.             while(USART_GetFlagStatus(USART1,USART_FLAG_TC)!=SET);//等待发送结束    
  354.             //发送数据内容1            
  355.             USART1_SendUnfixedData(crc16_data1,1);//空开1
  356.             while(USART_GetFlagStatus(USART1,USART_FLAG_TC)!=SET);//等待发送结束
  357.             //发送数据内容2    
  358.                 USART1_SendUnfixedData(crc16_data2,1);//空开2
  359.             while(USART_GetFlagStatus(USART1,USART_FLAG_TC)!=SET);//等待发送结束
  360.             //发送数据内容3        
  361.                 USART1_SendUnfixedData(crc16_data3,1);//空开3
  362.             while(USART_GetFlagStatus(USART1,USART_FLAG_TC)!=SET);//等待发送结束
  363.             //发送数据内容4        
  364.                 USART1_SendUnfixedData(crc16_data4,1);//空开4
  365.             while(USART_GetFlagStatus(USART1,USART_FLAG_TC)!=SET);//等待发送结束
  366.             //发送数据内容5            
  367.             USART1_SendUnfixedData(crc16_data5,2);//饮水机 空烧数据
  368.             while(USART_GetFlagStatus(USART1,USART_FLAG_TC)!=SET);//等待发送结束
  369.             //发送数据内容设备接地的数据 （过载实验）（1111 1111）（八个设备）
  370.                 USART1_SendUnfixedData(crc16_data6,1);
  371.             while(USART_GetFlagStatus(USART1,USART_FLAG_TC)!=SET);//等待发送结束
  372.             //发送数据内容7     接地触电 crc16_data7[0] 湿手触电 crc16_data7[1]
  373.                 USART1_SendUnfixedData(crc16_data7,1);
  374.             while(USART_GetFlagStatus(USART1,USART_FLAG_TC)!=SET);//等待发送结束
  375.             //发送数据内容8        发送给串口的数据
  376.                 USART1_SendUnfixedData(crc16_data8,1);
  377.             while(USART_GetFlagStatus(USART1,USART_FLAG_TC)!=SET);//等待发送结束                        
  378.             //发送协议尾 FD FD
  379.             USART_SendData(USART1,0xFD);//向串口1发送数据
  380.             while(USART_GetFlagStatus(USART1,USART_FLAG_TC)!=SET);//等待发送结束
  381.             USART_SendData(USART1,0xFD);
  382.             while(USART_GetFlagStatus(USART1,USART_FLAG_TC)!=SET);//等待发送结束
  383. }
  384.  
  385. }
  386.  
  387. void send_data_usart3(void)
  388. {
  389.     //刷新位置信息
  390. if(timer8flag200ms==1)
  391. {
  392. timer8flag200ms=0;
  393.     
  394.             //发送协议头 FE FE D1
  395.             USART_SendData(USART3,0xFA);//向串口1发送数据
  396.             while(USART_GetFlagStatus(USART3,USART_FLAG_TC)!=SET);//等待发送结束
  397.             USART_SendData(USART3,0xFC);
  398.             while(USART_GetFlagStatus(USART3,USART_FLAG_TC)!=SET);//等待发送结束    
  399.             //发送数据内容1            
  400.             USART3_SendUnfixedData(crc16_data1,1);//空开1
  401.             while(USART_GetFlagStatus(USART3,USART_FLAG_TC)!=SET);//等待发送结束
  402.             //发送数据内容2    
  403.                 USART3_SendUnfixedData(crc16_data2,1);//空开2
  404.             while(USART_GetFlagStatus(USART3,USART_FLAG_TC)!=SET);//等待发送结束
  405.             //发送数据内容3        
  406.                 USART3_SendUnfixedData(crc16_data3,1);//空开3
  407.             while(USART_GetFlagStatus(USART3,USART_FLAG_TC)!=SET);//等待发送结束
  408.             //发送数据内容4        
  409.                 USART3_SendUnfixedData(crc16_data4,1);//空开4
  410.             while(USART_GetFlagStatus(USART3,USART_FLAG_TC)!=SET);//等待发送结束
  411.             //发送数据内容5            
  412.              USART3_SendUnfixedData(crc16_data5,2);//饮水机 空烧数据
  413.             while(USART_GetFlagStatus(USART3,USART_FLAG_TC)!=SET);//等待发送结束
  414.             //发送数据内容设备接地的数据 （过载实验）（1111 1111）（八个设备）
  415.                 USART3_SendUnfixedData(crc16_data6,1);
  416.             while(USART_GetFlagStatus(USART3,USART_FLAG_TC)!=SET);//等待发送结束
  417.             //发送数据内容7     接地触电 crc16_data7[0] 湿手触电 crc16_data7[1]
  418.                 USART3_SendUnfixedData(crc16_data7,1);
  419.             while(USART_GetFlagStatus(USART3,USART_FLAG_TC)!=SET);//等待发送结束
  420.             //发送数据内容8        发送给串口的数据
  421.                 USART3_SendUnfixedData(crc16_data8,1);
  422.             while(USART_GetFlagStatus(USART3,USART_FLAG_TC)!=SET);//等待发送结束                        
  423.             //发送协议尾 FD FD
  424.             USART_SendData(USART3,0xFD);//向串口1发送数据
  425.             while(USART_GetFlagStatus(USART3,USART_FLAG_TC)!=SET);//等待发送结束
  426.             USART_SendData(USART3,0xFD);
  427.             while(USART_GetFlagStatus(USART3,USART_FLAG_TC)!=SET);//等待发送结束
  428. }
  429.  
  430. }

阅读(5785) | 评论(0) | 转发(0) |
0

上一篇：FreeRTOS三种数据结构区别（StreamBuffer，MessageBuffer，Queue）

下一篇：STM32 Uart 接收不定长数据

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6