Chinaunix首页 | 论坛 | 博客
  • 博客访问: 9412291
  • 博文数量: 1748
  • 博客积分: 12961
  • 博客等级: 上将
  • 技术积分: 20070
  • 用 户 组: 普通用户
  • 注册时间: 2009-01-09 11:25
个人简介

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

文章分类

全部博文(1748)

文章存档

2024年(24)

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)

分类: 其他平台

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. }

阅读(5875) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~