6165金沙总站STM32F4XX高效驱动篇1-UART

esp8266的STM32驱动,数据发送接收由DMA完成,释放CPU。

ESP8266与STM32通讯接收不到数据
ESP8266跟STM32通讯。ESP8266经过USB转串口手机发送的数据可以在串口助手里打印出来,STM32的串口和中断程序通过串口助手也可以响应中断,但是把ESP8266接到STM32的串口上,进行串口通讯STM32就不能读取到手机发送的数据。求大神指点,谢谢了

上一篇

http://www.geek-workshop.com/thread-27796-1-1.html
http://www.geek-workshop.com/thread-27452-1-1.html

之前一直在做驱动方面的整理工作,对驱动的高效性有一些自己的理解这里和大家分享一下。并奉驱动程序,本程序覆盖uart1-8。

  目前只能发送返回消息为成功或失败的AT命令,并判断是否成功,详见esp8266_cmd();其它返回消息不可预知的命令(如查看AP,IP等)未实现,也用不着。以查询的方式判断有无消息,是什么样的消息,返回消息类型,如果是收到了数据,则会保存在指定的地址,并给出长度,详见esp8266_parse();当连接建立后,给远程发送数据用esp8266_send(),它会在数据实际发送成功前返回,剩下的活由DMA完成,然后请耐心地等待消息,想知道结果就调用esp8266_parse(),它会根据返回的消息判断发送有无成功,并返回。

esp8266怎么配置
    esp8266和USB转TTL连接
esp8266简单介绍
esp8266连接路由器
esp8266通过路由器连接在同一局域网中的电脑,建立TCP连接
esp8266使用串口发送数据到电脑上的网络调试助手
esp8266使用串口通过局域网发送到电脑上自己写的Java程序
esp8266的透传模式
esp8266使用透传模式连接到电脑的网络调试助手
esp8266使用透传模式连接到电脑上的java程序

串口驱动,这是在每个单片机中可以说是必备接口。可以说大部分产品中都会使用,更有甚者一个产品中用到8个串口。这样一个高效的驱动是决定您产品优劣的关键因素。本文主要针对STM32F4XX系列芯片做的一个驱动接口层。以减少您在开发项目时驱动方面所花费时间,以及为程序达到高效的处理为目的。

  文中的“消息”是指ESP8266发的指示状态的,“数据”指通过网络收发的。

这一篇

从51,pic到现在的STM32,个人感觉STM32这方面做的非常突出,丰富的使用模式,强大的引脚映射功能,强大的处理能力等,给我留下的深刻的印象。

  代码和例子:
,标准库忽略掉了,如果没有的话,自己下载stm32f4_cubexxx.zip,使用示例:在Projects_new/stm32f407vet6/Examples/UART/UART_TwoBoards_ComDMA中,在这个例子是用来实现websocket的,如果没用到,把相关代码删掉,只看8266使用就行了。如果你要测试websocket,还要一些文件,请见:

esp8266与STM32连接,电脑通过STM32配置esp8266实现联网发送数据
具体流程如下图

关于串口的使用方式,个人总结出以下三种:

  由于驱动代码被多个工程用到,而代码经常修订,可能导致某些工程编译出错,要做些小改。这里上不了图片,就不传了,也放工程文件夹下了,还是github厚道。

6165金沙总站 1

1)        
中断接收,状态查询发送:这种方式在单片机时代用的比较多,那时候大部分芯片的处理速度不够快,工业控制接口中大部分使用的是9600波特率,程序简单也就对串口发送数据所用时间要求不高。

2=

2)        
中断接收,中断发送:这种方式一般会在对高效性要求较高,或软件实时性高的产品中使用。这种方式的好外在于完全释放了CPU在发送开始到结束这一时间CPU控制权。

esp8266怎么和STM32连接(引脚连接)?

3)        
中断接口,DMA发送:这种方式的使用场合和模式2相同,效率也相差不多。但这种方式确实比模式2CPU的占用时间会更少。

STM32CubeMx配置的usart2使用的PA2和PA3要与esp8266的TX和RX对应,但是得反过来接,要么根本发不出去,看来esp8266又印反了
3V3和EN得接到同一个3V上才可以,要不收到的老是error

举个例子来说明以上三种模式。假如要把一堆物品从A点运到B点通过传送带,在这个传送过程中传送带上一次只能运一个物品,模式一:把物品放到传送带A点上,然后等待物品由A点被传到B点,这时再放一个物品到传送带上,以此往复所有物品传送过去。模式二:把物品放到A点的传送带上然后就去忙别的事情,看到物品快被传到B点,马上回来再放一个物品到传送带上。很明显这种方式比模式一多了很多空余时间。模式三:这种模式就牛了,在把物品放到A点之前,直接去找了一个“闲杂人等”过来,把物品交给他由他去发,我们需要再发送时,先问下她是否以发完,如果发完了就把新的物品交给他,如果没发完就等一小回再来找他。哈哈,这样咱们就有更多的时间去忙更多的事情了,也不用一回跑来一回跑去。把跑路的时间给节约出来了。

STM32使用USART和电脑相互传输数据?

以上三种模式,很明显得出那种模式发送数据效率最高。我们下面说提供的程序就是使用模式三。

将STM32产生的数据发送到电脑的串口调试助手
    第一种方式:
        使用UASRT传输只需要重新定义fputc()函数,直接使用Printf函数就可以将字符串打印到电脑(即通过串口输出到电脑)
    第二种方式:
        使用HAL库中封装好的UASART函数  HAL_StatusTypeDef HAL_UART_Transmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout)也可以实现串口输出
电脑要发送字符串给STM32,那么STM32怎么收到数据,而且知道这个数据什么意思呢?
    第一种方式(只能接收定长字符串):
        HAL库依旧有封装好的函数HAL_StatusTypeDef HAL_UART_Receive(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size, uint32_t Timeout),但是使用这个函数有一个问题,这个函数的额第三个参数是收到的字符串的大小,可是我都没有发送,怎么提前把这个字符串的大小写入单片机呢?
            其实问题是STM32如何接收不定长的字符串?
        【STM32内部产生的数据或者从传感器中获取的数据,STM32如果要发送该数据可以直接使用sizeof获得数据长度作为第三个参数,但是当人为的发送给串口时,由于提前烧入的程序如果要使用HAL库的USART接收函数的话,需要确定一个字符串长度,那么这个程序就只能接收指定长度的字符串了,那要如何实现不定长也能接收呢?】
    第二种方式:
        DMA+接收结束判断。这接收结束判断可以是字节的timeout,也可以是USART_IT_IDLE线路空闲的标志等。这种方式对于需要整帧接收,且通信速度较快或需要占用cpu较少的情况
        【详细的处理方式可见串口USART 收发数据处理方式总结--DMA+USART+USART_Idle_Interrupt】

说完发送,再说说接收方式。大家一定发现数据接收都是采用中断方式,是的
本人使用过DMA方式进行过多次测试,在使用方面确实没有中断接收灵活。主要有以下两种情况,1,DMA接收数据的主要判断依据1是接收器满中断,这种情况在实际中很少用,除非您的数据是定长。这种方式同时还会存在一些安全隐患,假如噪声原因多接收到一个字节,那之后数据时序就会错位。2,DMA总线空闲中断,这种方式除非是半双工情况下使用。在全双工时被受到发送完成总线空闲的干扰。所以在数据接收方式上主要使用中断。

那么如何配置呢?

在数据接收中断方面还分二种方式,

        既然是DMA和空闲接收中断就需要设置DMA和UASRT的中断(即在中断处理函数中需要有DMA1 channel5 global interrupt和USART1 global interrupt)

        如果要使用printf输出到串口的话,就需要重定义fputc函数(定义在usart.c中)

        如果要用线路空闲来触发中断来结束接收的话,需要有判断线路是否空闲的函数,这个函数最好还需要在结束接收时将收到的数据保存到自己定义的变量中

方式1:顺序接收,在接收到第一个数据时就触发超时定时器,每接收到一个字节时就清一次定时器,都到一组数据接收完毕,定时器会因为触发超时中断。在超时中断中来判断一组数据被接收。这种方式一般会用到实时性的一些协议中,比如MODBUS。

那么如何实现不定长接收呢,不还是得知道接受的字符串的长度吗?

方式2:队列接收,申请一个缓冲区收尾相接,接收到数据时载入队列之中,用户只要定时的去队列中读数据,来使用这些数据。这种方式是window,linux的驱动主要接收方式。他的优点就在于在使用数据时无需关闭中断。也就不用怛心在处理上一组数据时了来新的数据会破坏上组数据内容。在方式1中需要考虑在处理数据时暂时性的关下中断。

    是需要知道,这里使用一个结构体来保存字符串和字符串的长度以及一个标记(用来表示一次接收完成,如果不放在结构体里面,使用全局变量的话会比较麻烦)
    具体的方法是这样的:在一开始接收的时候,将收到的字符串保存在结构体中的字符串数组中,而函数要求的大小这个参数设置为比较大的数字(可以是一次接收数据长度的最大值,这里是1024),在判断线路是否空闲的函数中,当线路空闲时(即一次接收完成时),将收到的字符串的长度保存到这个结构体中的字符串长度变量中,这样,当需要将收到的字符串再次发出时,就可以使用已知的长度进行发送了,由此实现了不定长接收。
    【其原理其实是用一个大空间去接收(看来接收空间够大就行,不需要定长接收),在接收完成时计算收到的数据长度保存起来(和收到的数据要一一对应,这也是使用结构体的好处),当需要再次发送出去时,就知道这个字符串的长度了,就可以定长发送了】

    结构体
        #define RX_LEN 1024  

        typedef struct  
        {  
        uint8_t  RX_flag:1;        //IDLE receive flag
        uint16_t RX_Size;          //receive length
        uint8_t  RX_pData[RX_LEN]; //DMA receive buffer
        }USART_RECEIVETYPE; 

        extern USART_RECEIVETYPE UsartType;

下面是程序的流程

    首先在main函数中使用HAL_UART_Receive_DMA(&huart1, UsartType.RX_pData, RX_LEN); 开始接收,接收的数据放到结构体中,长度为最大值
    然后打开中断,__HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);这个函数进行中断使能,

    具体介绍:
    /** @brief  Enable the specified UART interrupt.
    * @param  __HANDLE__: specifies the UART Handle.
    *         UART Handle selects the USARTx or UARTy peripheral 
    *         (USART,UART availability and x,y values depending on device).
    * @param  __INTERRUPT__: specifies the UART interrupt source to enable.
    *          This parameter can be one of the following values:
    *            @arg UART_IT_CTS:  CTS change interrupt
    *            @arg UART_IT_LBD:  LIN Break detection interrupt
    *            @arg UART_IT_TXE:  Transmit Data Register empty interrupt
    *            @arg UART_IT_TC:   Transmission complete interrupt
    *            @arg UART_IT_RXNE: Receive Data register not empty interrupt
    *            @arg UART_IT_IDLE: Idle line detection interrupt
    *            @arg UART_IT_PE:   Parity Error interrupt
    *            @arg UART_IT_ERR:  Error interrupt(Frame error, noise error, overrun error)
        * @retval None
        * */
            #define __HAL_UART_ENABLE_IT(__HANDLE__, __INTERRUPT__)
    之后是否需要延时防止接收不到或者防止其他错误的发生不是很清楚。

    在stm32f1xx_it.c的DMA和USART的中断函数中并没有需要重写的回调函数

    在usart.c中实现处理空闲的函数添加到USART的中断函数中,那么当线路产生空闲时,就会触发一个中断,这个空闲处理的函数,就会开始工作,先清空空闲标志以允许继续接收,然后使用HAL_StatusTypeDef HAL_UART_DMAStop(UART_HandleTypeDef *huart)停止此次接收,接着获得此次接收到的字符串的长度(这里比较深入,有寄存器的问题,不大理解),然后又调用了HAL_UART_Receive_DMA,这个应该和取得的长度是同一个结构体,那么之前的HAL_UART_Receive_DMA又是再干什么呢?(或许是为了解决第一次的传输问题,学的不够深入,还需要学的再深入)
    最后就可以使用获得的长度和字符串将收到的字符串发送出去了,这样就实现了不定长接收。

【问题】在结构体中定义的是一个uint8_t类型的数组,那么可以按字符串输出吗?

        可以,
        HAL_UART_Transmit(&huart1, UsartType.RX_pData, UsartType.RX_Size, 0xFFFF);
        printf("\n%s\n",UsartType.RX_pData);
        上面两句一样的效果
    具体代码:
        在usart.c中添加
            /* USER CODE BEGIN 1 */
            /**
              * @brief  Retargets the C library printf function to the USART.
              */
            int fputc(int ch,FILE *f)
            {
                HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 0xFFFF);
                return ch;
            }

            /**
              * @brief  This function handles USART1 IDLE interrupt.
              */
            void UsartReceive_IDLE(UART_HandleTypeDef *huart)  
            {  
                uint32_t temp;  

                if((__HAL_UART_GET_FLAG(huart,UART_FLAG_IDLE) != RESET))  
                {   
                    __HAL_UART_CLEAR_IDLEFLAG(&huart1);  
                    HAL_UART_DMAStop(&huart1);  
                    temp = huart1.hdmarx->Instance->CNDTR;  
                    UsartType.RX_Size =  RX_LEN - temp;   
                    UsartType.RX_flag=1;  
                    HAL_UART_Receive_DMA(&huart1,UsartType.RX_pData,RX_LEN);  
                }  
            }  
            /* USER CODE END 1 */
    在usart.c中实例化结构体
            /* USER CODE BEGIN 0 */
            USART_RECEIVETYPE UsartType; 
            /* USER CODE END 0 */

    在usart.h中定义结构体
            /* USER CODE BEGIN Private defines */
            #define RX_LEN 1024  

            typedef struct  
            {  
            uint8_t  RX_flag:1;        //IDLE receive flag
            uint16_t RX_Size;          //receive length
            uint8_t  RX_pData[RX_LEN]; //DMA receive buffer
            }USART_RECEIVETYPE;  

            extern USART_RECEIVETYPE UsartType; 
            /* USER CODE END Private defines */
    在stm32f1xx_it.c的中断函数中添加
            void USART1_IRQHandler(void)
            {
              /* USER CODE BEGIN USART1_IRQn 0 */
                UsartReceive_IDLE(&huart1);  
              /* USER CODE END USART1_IRQn 0 */
              HAL_UART_IRQHandler(&huart1);
              /* USER CODE BEGIN USART1_IRQn 1 */

              /* USER CODE END USART1_IRQn 1 */
            }
    在main.c中main函数中基本的初始化函数后添加
              /* USER CODE BEGIN 2 */
                HAL_UART_Receive_DMA(&huart1, UsartType.RX_pData, RX_LEN);  
                __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE); 
                HAL_Delay(1000);
              /* USER CODE END 2 */

以下程序则主要是使用到接收使用方式2,发送数据使用模式3的DMA发送,本驱动程序为可裁切,覆盖串口1-8,通过宏裁切。下面提供了一些接口,这里对接口做一个大概的说明。

STM32如何给esp8266发送AT指令?

打开串口

途径就为通过串口
那么怎么使用串口,
    是直接使用HAL库封装的相关函数
    还是需要一些驱动代码
电脑通过串口与STM32交流,STM32通过串口与esp8266交流
    既然上面实现了电脑与STM32使用USART相互传输数据,即STM32可以接收电脑发来的不定长数据,那么STM32也能接收esp8266返回的不定长数据(向esp8266发送不同的指令,返回消息不一样,长度也不一样)

void BSP_UartOpen(uint8_t COM,  uint32_t baud, uint8_t data,
uint8_t stop, uint8_t parity);

对于接收esp8266返回的信息也使用DMA加空闲中断的方式,那么向esp8266发送数据要怎么做呢?

关闭串口

        上面的代码已经可以接收来自电脑的不定长消息,然后再发给电脑,那么将这个消息直接发送给esp8266就可以了,两个不同的串口有不同的实例,只需要指定好串口就可以向这个串口发送数据了。【突然觉得自己写的好乱,没有条理,得改】
    其实具体的代码就是在什么那个处理STM2与电脑使用USART通信的代码上再增加一个STM与esp8266的USART交流流程就可以了,需要注意区分不同的串口,两个流程的交汇点在main函数中,当STM32收到电脑发来的不定长信息后,通过空闲中断处理函数获得长度,将该消息直接使用串口发送到连接esp8266的串口即可,如果STM32收到来自esp8266串口的消息,一样使用DMA加空闲中断的方式获得来自esp8266的不定长返回信息,在这里也是一样通过这个串口的空闲中断处理函数获得返回信息的长度,将这个返回信息发送给与电脑相连的串口就可以了,这样就完成了通过STM32配置esp8266的整个流程。

void BSP_UartClose(uint8_t COM);

其意义是什么呢?

向串口中写数据

    这样STM32本身就可以使用串口将获取的传感器信息通过esp8266发送到指定服务器,实现了STM32的联网,一样也实现了通过网络向STM32发送指令控制传感器的功能。

uint32_t BSP_UartWrite(uint8_t COM, uint8_t *buffter, uint32_t
len);

从串口中读数据

uint32_t BSP_UartRead(uint8_t COM, uint8_t *buffter, uint32_t
len);

 

查询串口发送忙碌状态

uint32_t BSP_UartTxIdleState(uint8_t COM);

这个接口主要用在,向串口写数据后,在进行下一次写数据之前需要进行查询。

 

具体接口的使用方法,函数都有详细的说明。

6165金沙总站 26165金沙总站 3

  1 /*
  2 ********************************************************************************
  3 *
  4 *                                 BSP_Uart.c
  5 *
  6 * File          : BSP_Uart.c
  7 * Version       : V1.0
  8 * Author        : whq
  9 * Mode          : Thumb2
 10 * Toolchain     : 
 11 * Description   : 串口驱动程序
 12 *                
 13 * History       :
 14 * Date          : 2013.08.12
 15 *******************************************************************************/
 16 #include <string.h>
 17 
 18 #include "misc.h"
 19 #include "stm32f4xx_gpio.h"
 20 #include "stm32f4xx_rcc.h"
 21 #include "stm32f4xx_usart.h"
 22 #include "stm32f4xx_dma.h"
 23 
 24 
 25 #include "Queue.h"
 26 #include "BSP_Uart.h"
 27 
 28 
 29 #if COM1_EN
 30 static uint8_t COM1_TX_BUFF[BSP_COM1_Tx_BUFF_SIZE] = {0};
 31 static uint8_t COM1_RX_BUFF[BSP_COM1_Rx_BUFF_SIZE] = {0};
 32 static QUEUE8_TYPE COM1_RX_QUEUE = {0};
 33 #endif
 34 
 35 #if COM2_EN
 36 static uint8_t COM2_TX_BUFF[BSP_COM2_Tx_BUFF_SIZE] = {0};
 37 static uint8_t COM2_RX_BUFF[BSP_COM2_Rx_BUFF_SIZE] = {0};
 38 static QUEUE8_TYPE COM2_RX_QUEUE = {0};
 39 #endif
 40 
 41 #if COM3_EN
 42 static uint8_t COM3_TX_BUFF[BSP_COM3_Tx_BUFF_SIZE] = {0};
 43 static uint8_t COM3_RX_BUFF[BSP_COM3_Rx_BUFF_SIZE] = {0};
 44 static QUEUE8_TYPE COM3_RX_QUEUE = {0};
 45 #endif
 46 
 47 #if COM4_EN
 48 static uint8_t COM4_TX_BUFF[BSP_COM4_Tx_BUFF_SIZE] = {0};
 49 static uint8_t COM4_RX_BUFF[BSP_COM4_Rx_BUFF_SIZE] = {0};
 50 static QUEUE8_TYPE COM4_RX_QUEUE = {0};
 51 #endif
 52 
 53 #if COM5_EN
 54 static uint8_t COM5_TX_BUFF[BSP_COM5_Tx_BUFF_SIZE] = {0};
 55 static uint8_t COM5_RX_BUFF[BSP_COM5_Rx_BUFF_SIZE] = {0};
 56 static QUEUE8_TYPE COM5_RX_QUEUE = {0};
 57 #endif
 58 
 59 #if COM6_EN
 60 static uint8_t COM6_TX_BUFF[BSP_COM6_Tx_BUFF_SIZE] = {0};
 61 static uint8_t COM6_RX_BUFF[BSP_COM6_Rx_BUFF_SIZE] = {0};
 62 static QUEUE8_TYPE COM6_RX_QUEUE = {0};
 63 #endif
 64 
 65 #if COM7_EN
 66 static uint8_t COM7_TX_BUFF[BSP_COM7_Tx_BUFF_SIZE] = {0};
 67 static uint8_t COM7_RX_BUFF[BSP_COM7_Rx_BUFF_SIZE] = {0};
 68 static QUEUE8_TYPE COM7_RX_QUEUE = {0};
 69 #endif
 70 
 71 #if COM8_EN
 72 static uint8_t COM8_TX_BUFF[BSP_COM8_Tx_BUFF_SIZE] = {0};
 73 static uint8_t COM8_RX_BUFF[BSP_COM8_Rx_BUFF_SIZE] = {0};
 74 static QUEUE8_TYPE COM8_RX_QUEUE = {0};
 75 #endif
 76 
 77 
 78 
 79 static USART_TypeDef* const COM_USART[COMn] = {  
 80 #if     COM1_EN
 81     BSP_COM1,
 82 #endif
 83 #if     COM2_EN
 84     BSP_COM2,
 85 #endif
 86 #if     COM3_EN
 87     BSP_COM3,
 88 #endif
 89 #if     COM4_EN
 90     BSP_COM4,
 91 #endif
 92 #if     COM5_EN
 93     BSP_COM5,
 94 #endif
 95 #if     COM6_EN
 96     BSP_COM6,
 97 #endif
 98 #if     COM7_EN
 99     BSP_COM7,
100 #endif
101 #if     COM8_EN
102     BSP_COM8,
103 #endif
104 }; 
105 
106 static const uint8_t COM_AF[COMn] = {
107 #if     COM1_EN
108     BSP_COM1_AF,
109 #endif
110 #if     COM2_EN
111     BSP_COM2_AF,
112 #endif
113 #if     COM3_EN
114     BSP_COM3_AF,
115 #endif
116 #if     COM4_EN
117     BSP_COM4_AF,
118 #endif
119 #if     COM5_EN
120     BSP_COM5_AF,
121 #endif
122 #if     COM6_EN
123     BSP_COM6_AF,
124 #endif
125 #if     COM7_EN
126     BSP_COM7_AF,
127 #endif
128 #if     COM8_EN
129     BSP_COM8_AF,
130 #endif
131 };
132                                                 
133 static const uint8_t COM_TX_AF_PIN[COMn] = {   
134 #if     COM1_EN
135     BSP_COM1_TX_AF_PIN,
136 #endif
137 #if     COM2_EN
138     BSP_COM2_TX_AF_PIN,
139 #endif
140 #if     COM3_EN
141     BSP_COM3_TX_AF_PIN,
142 #endif
143 #if     COM4_EN
144     BSP_COM4_TX_AF_PIN,
145 #endif
146 #if     COM5_EN
147     BSP_COM5_TX_AF_PIN,
148 #endif
149 #if     COM6_EN
150     BSP_COM6_TX_AF_PIN,
151 #endif
152 #if     COM7_EN
153     BSP_COM7_TX_AF_PIN,
154 #endif
155 #if     COM8_EN
156     BSP_COM8_TX_AF_PIN,
157 #endif
158 };
159 
160 static const uint8_t COM_RX_AF_PIN[COMn] = {   
161 #if     COM1_EN
162     BSP_COM1_RX_AF_PIN,
163 #endif
164 #if     COM2_EN
165     BSP_COM2_RX_AF_PIN,
166 #endif
167 #if     COM3_EN
168     BSP_COM3_RX_AF_PIN,
169 #endif
170 #if     COM4_EN
171     BSP_COM4_RX_AF_PIN,
172 #endif
173 #if     COM5_EN
174     BSP_COM5_RX_AF_PIN,
175 #endif
176 #if     COM6_EN
177     BSP_COM6_RX_AF_PIN,
178 #endif
179 #if     COM7_EN
180     BSP_COM7_RX_AF_PIN,
181 #endif
182 #if     COM8_EN
183     BSP_COM8_RX_AF_PIN,
184 #endif
185 };
186 
187 static GPIO_TypeDef* const COM_TX_PORT[COMn] = {  
188 #if     COM1_EN
189     BSP_COM1_TX_GPIO_PORT,
190 #endif
191 #if     COM2_EN
192     BSP_COM2_TX_GPIO_PORT,
193 #endif
194 #if     COM3_EN
195     BSP_COM3_TX_GPIO_PORT,
196 #endif
197 #if     COM4_EN
198     BSP_COM4_TX_GPIO_PORT,
199 #endif
200 #if     COM5_EN
201     BSP_COM5_TX_GPIO_PORT,
202 #endif
203 #if     COM6_EN
204     BSP_COM6_TX_GPIO_PORT,
205 #endif
206 #if     COM7_EN
207     BSP_COM7_TX_GPIO_PORT,
208 #endif
209 #if     COM8_EN
210     BSP_COM8_TX_GPIO_PORT,
211 #endif
212 };
213  
214 static GPIO_TypeDef* const COM_RX_PORT[COMn] = {     
215 #if     COM1_EN
216     BSP_COM1_RX_GPIO_PORT,
217 #endif
218 #if     COM2_EN
219     BSP_COM2_RX_GPIO_PORT,
220 #endif
221 #if     COM3_EN
222     BSP_COM3_RX_GPIO_PORT,
223 #endif
224 #if     COM4_EN
225     BSP_COM4_RX_GPIO_PORT,
226 #endif
227 #if     COM5_EN
228     BSP_COM5_RX_GPIO_PORT,
229 #endif
230 #if     COM6_EN
231     BSP_COM6_RX_GPIO_PORT,
232 #endif
233 #if     COM7_EN
234     BSP_COM7_RX_GPIO_PORT,
235 #endif
236 #if     COM8_EN
237     BSP_COM8_RX_GPIO_PORT,
238 #endif
239 };
240  
241 static const uint32_t COM_USART_CLK[COMn] = {   
242 #if     COM1_EN
243     BSP_COM1_CLK,
244 #endif
245 #if     COM2_EN
246     BSP_COM2_CLK,
247 #endif
248 #if     COM3_EN
249     BSP_COM3_CLK,
250 #endif
251 #if     COM4_EN
252     BSP_COM4_CLK,
253 #endif
254 #if     COM5_EN
255     BSP_COM5_CLK,
256 #endif
257 #if     COM6_EN
258     BSP_COM6_CLK,
259 #endif
260 #if     COM7_EN
261     BSP_COM7_CLK,
262 #endif
263 #if     COM8_EN
264     BSP_COM8_CLK,
265 #endif
266 };
267                 
268 static const uint32_t COM_TX_PORT_CLK[COMn] = { 
269 #if     COM1_EN
270     BSP_COM1_TX_GPIO_CLK,
271 #endif
272 #if     COM2_EN
273     BSP_COM2_TX_GPIO_CLK,
274 #endif
275 #if     COM3_EN
276     BSP_COM3_TX_GPIO_CLK,
277 #endif
278 #if     COM4_EN
279     BSP_COM4_TX_GPIO_CLK,
280 #endif
281 #if     COM5_EN
282     BSP_COM5_TX_GPIO_CLK,
283 #endif
284 #if     COM6_EN
285     BSP_COM6_TX_GPIO_CLK,
286 #endif
287 #if     COM7_EN
288     BSP_COM7_TX_GPIO_CLK,
289 #endif
290 #if     COM8_EN
291     BSP_COM8_TX_GPIO_CLK,
292 #endif
293 };
294  
295 static const uint32_t COM_RX_PORT_CLK[COMn] = {
296 #if     COM1_EN
297     BSP_COM1_RX_GPIO_CLK,
298 #endif
299 #if     COM2_EN
300     BSP_COM2_RX_GPIO_CLK,
301 #endif
302 #if     COM3_EN
303     BSP_COM3_RX_GPIO_CLK,
304 #endif
305 #if     COM4_EN
306     BSP_COM4_RX_GPIO_CLK,
307 #endif
308 #if     COM5_EN
309     BSP_COM5_RX_GPIO_CLK,
310 #endif
311 #if     COM6_EN
312     BSP_COM6_RX_GPIO_CLK,
313 #endif
314 #if     COM7_EN
315     BSP_COM7_RX_GPIO_CLK,
316 #endif
317 #if     COM8_EN
318     BSP_COM8_RX_GPIO_CLK,
319 #endif
320 };
321 
322 static const uint16_t COM_TX_PIN[COMn] = {      
323 #if     COM1_EN
324     BSP_COM1_TX_PIN,
325 #endif
326 #if     COM2_EN
327     BSP_COM2_TX_PIN,
328 #endif
329 #if     COM3_EN
330     BSP_COM3_TX_PIN,
331 #endif
332 #if     COM4_EN
333     BSP_COM4_TX_PIN,
334 #endif
335 #if     COM5_EN
336     BSP_COM5_TX_PIN,
337 #endif
338 #if     COM6_EN
339     BSP_COM6_TX_PIN,
340 #endif
341 #if     COM7_EN
342     BSP_COM7_TX_PIN,
343 #endif
344 #if     COM8_EN
345     BSP_COM8_TX_PIN,
346 #endif
347 };
348 
349 static const uint16_t COM_RX_PIN[COMn] = { 
350 #if     COM1_EN
351     BSP_COM1_RX_PIN,
352 #endif
353 #if     COM2_EN
354     BSP_COM2_RX_PIN,
355 #endif
356 #if     COM3_EN
357     BSP_COM3_RX_PIN,
358 #endif
359 #if     COM4_EN
360     BSP_COM4_RX_PIN,
361 #endif
362 #if     COM5_EN
363     BSP_COM5_RX_PIN,
364 #endif
365 #if     COM6_EN
366     BSP_COM6_RX_PIN,
367 #endif
368 #if     COM7_EN
369     BSP_COM7_RX_PIN,
370 #endif
371 #if     COM8_EN
372     BSP_COM8_RX_PIN,
373 #endif
374 };
375 
376 static const uint32_t COM_DMA_DR_BASE[COMn] = { 
377 #if     COM1_EN
378     BSP_COM1_DMA_DR_BASE,
379 #endif
380 #if     COM2_EN
381     BSP_COM2_DMA_DR_BASE,
382 #endif
383 #if     COM3_EN
384     BSP_COM3_DMA_DR_BASE,
385 #endif
386 #if     COM4_EN
387     BSP_COM4_DMA_DR_BASE,
388 #endif
389 #if     COM5_EN
390     BSP_COM5_DMA_DR_BASE,
391 #endif
392 #if     COM6_EN
393     BSP_COM6_DMA_DR_BASE,
394 #endif
395 #if     COM7_EN
396     BSP_COM7_DMA_DR_BASE,
397 #endif
398 #if     COM8_EN
399     BSP_COM8_DMA_DR_BASE,
400 #endif
401 };
402 
403 static const uint32_t COM_DMA_CLK[COMn] = {     
404 #if     COM1_EN
405     BSP_COM1_DMA_CLK,
406 #endif
407 #if     COM2_EN
408     BSP_COM2_DMA_CLK,
409 #endif
410 #if     COM3_EN
411     BSP_COM3_DMA_CLK,
412 #endif
413 #if     COM4_EN
414     BSP_COM4_DMA_CLK,
415 #endif
416 #if     COM5_EN
417     BSP_COM5_DMA_CLK,
418 #endif
419 #if     COM6_EN
420     BSP_COM6_DMA_CLK,
421 #endif
422 #if     COM7_EN
423     BSP_COM7_DMA_CLK,
424 #endif
425 #if     COM8_EN
426     BSP_COM8_DMA_CLK,
427 #endif
428 };
429 
430 static const uint32_t COM_DMA_TX_FLAG[COMn] = { 
431 #if     COM1_EN
432     BSP_COM1_Tx_DMA_FLAG,
433 #endif
434 #if     COM2_EN
435     BSP_COM2_Tx_DMA_FLAG,
436 #endif
437 #if     COM3_EN
438     BSP_COM3_Tx_DMA_FLAG,
439 #endif
440 #if     COM4_EN
441     BSP_COM4_Tx_DMA_FLAG,
442 #endif
443 #if     COM5_EN
444     BSP_COM5_Tx_DMA_FLAG,
445 #endif
446 #if     COM6_EN
447     BSP_COM6_Tx_DMA_FLAG,
448 #endif
449 #if     COM7_EN
450     BSP_COM7_Tx_DMA_FLAG,
451 #endif
452 #if     COM8_EN
453     BSP_COM8_Tx_DMA_FLAG,
454 #endif
455 };
456 
457 static const uint32_t COM_DMA_TX_CHANNEL[COMn] = { 
458 #if     COM1_EN
459     BSP_COM1_Tx_DMA_Channel,
460 #endif
461 #if     COM2_EN
462     BSP_COM2_Tx_DMA_Channel,
463 #endif
464 #if     COM3_EN
465     BSP_COM3_Tx_DMA_Channel,
466 #endif
467 #if     COM4_EN
468     BSP_COM4_Tx_DMA_Channel,
469 #endif
470 #if     COM5_EN
471     BSP_COM5_Tx_DMA_Channel,
472 #endif
473 #if     COM6_EN
474     BSP_COM6_Tx_DMA_Channel,
475 #endif
476 #if     COM7_EN
477     BSP_COM7_Tx_DMA_Channel,
478 #endif
479 #if     COM8_EN
480     BSP_COM8_Tx_DMA_Channel,
481 #endif
482 };
483 
484 static DMA_Stream_TypeDef * const COM_DMA_TX_STREAM[COMn] = { 
485 #if     COM1_EN
486     BSP_COM1_Tx_DMA_Stream,
487 #endif
488 #if     COM2_EN
489     BSP_COM2_Tx_DMA_Stream,
490 #endif
491 #if     COM3_EN
492     BSP_COM3_Tx_DMA_Stream,
493 #endif
494 #if     COM4_EN
495     BSP_COM4_Tx_DMA_Stream,
496 #endif
497 #if     COM5_EN
498     BSP_COM5_Tx_DMA_Stream,
499 #endif
500 #if     COM6_EN
501     BSP_COM6_Tx_DMA_Stream,
502 #endif
503 #if     COM7_EN
504     BSP_COM7_Tx_DMA_Stream,
505 #endif
506 #if     COM8_EN
507     BSP_COM8_Tx_DMA_Stream,
508 #endif
509 };
510 
511 
512 static const uint32_t COM_RX_IRQn[COMn] = {     
513 #if     COM1_EN
514     BSP_COM1_IRQn,
515 #endif
516 #if     COM2_EN
517     BSP_COM2_IRQn,
518 #endif
519 #if     COM3_EN
520     BSP_COM3_IRQn,
521 #endif
522 #if     COM4_EN
523     BSP_COM4_IRQn,
524 #endif
525 #if     COM5_EN
526     BSP_COM5_IRQn,
527 #endif
528 #if     COM6_EN
529     BSP_COM6_IRQn,
530 #endif
531 #if     COM7_EN
532     BSP_COM7_IRQn,
533 #endif
534 #if     COM8_EN
535     BSP_COM8_IRQn,
536 #endif
537 };
538 
539 static uint8_t * const COM_TX_BUFF[COMn] = {      
540 #if     COM1_EN
541     COM1_TX_BUFF,
542 #endif
543 #if     COM2_EN
544     COM2_TX_BUFF,
545 #endif
546 #if     COM3_EN
547     COM3_TX_BUFF,
548 #endif
549 #if     COM4_EN
550     COM4_TX_BUFF,
551 #endif
552 #if     COM5_EN
553     COM5_TX_BUFF,
554 #endif
555 #if     COM6_EN
556     COM6_TX_BUFF,
557 #endif
558 #if     COM7_EN
559     COM7_TX_BUFF,
560 #endif
561 #if     COM8_EN
562     COM8_TX_BUFF,
563 #endif
564 };
565                                                 
566 static const uint32_t COM_TX_BUFF_SIZE[COMn] = {  
567 #if     COM1_EN
568     BSP_COM1_Tx_BUFF_SIZE,
569 #endif
570 #if     COM2_EN
571     BSP_COM2_Tx_BUFF_SIZE,
572 #endif
573 #if     COM3_EN
574     BSP_COM3_Tx_BUFF_SIZE,
575 #endif
576 #if     COM4_EN
577     BSP_COM4_Tx_BUFF_SIZE,
578 #endif
579 #if     COM5_EN
580     BSP_COM5_Tx_BUFF_SIZE,
581 #endif
582 #if     COM6_EN
583     BSP_COM6_Tx_BUFF_SIZE,
584 #endif
585 #if     COM7_EN
586     BSP_COM7_Tx_BUFF_SIZE,
587 #endif
588 #if     COM8_EN
589     BSP_COM8_Tx_BUFF_SIZE,
590 #endif
591 };     
592 
593 static uint8_t * const COM_RX_BUFF[COMn] = {      
594 #if     COM1_EN
595     COM1_RX_BUFF,
596 #endif
597 #if     COM2_EN
598     COM2_RX_BUFF,
599 #endif
600 #if     COM3_EN
601     COM3_RX_BUFF,
602 #endif
603 #if     COM4_EN
604     COM4_RX_BUFF,
605 #endif
606 #if     COM5_EN
607     COM5_RX_BUFF,
608 #endif
609 #if     COM6_EN
610     COM6_RX_BUFF,
611 #endif
612 #if     COM7_EN
613     COM7_RX_BUFF,
614 #endif
615 #if     COM8_EN
616     COM8_RX_BUFF,
617 #endif
618 };
619                                                 
620 static const uint32_t COM_RX_BUFF_SIZE[COMn] = {  
621 #if     COM1_EN
622     BSP_COM1_Rx_BUFF_SIZE,
623 #endif
624 #if     COM2_EN
625     BSP_COM2_Rx_BUFF_SIZE,
626 #endif
627 #if     COM3_EN
628     BSP_COM3_Rx_BUFF_SIZE,
629 #endif
630 #if     COM4_EN
631     BSP_COM4_Rx_BUFF_SIZE,
632 #endif
633 #if     COM5_EN
634     BSP_COM5_Rx_BUFF_SIZE,
635 #endif
636 #if     COM6_EN
637     BSP_COM6_Rx_BUFF_SIZE,
638 #endif
639 #if     COM7_EN
640     BSP_COM7_Rx_BUFF_SIZE,
641 #endif
642 #if     COM8_EN
643     BSP_COM8_Rx_BUFF_SIZE,
644 #endif
645 };     
646 
647 static QUEUE8_TYPE * const COM_RX_QUEUE[COMn] = {    
648 #if     COM1_EN
649     &COM1_RX_QUEUE,
650 #endif
651 #if     COM2_EN
652     &COM2_RX_QUEUE,
653 #endif
654 #if     COM3_EN
655     &COM3_RX_QUEUE,
656 #endif
657 #if     COM4_EN
658     &COM4_RX_QUEUE,
659 #endif
660 #if     COM5_EN
661     &COM5_RX_QUEUE,
662 #endif
663 #if     COM6_EN
664     &COM6_RX_QUEUE,
665 #endif
666 #if     COM7_EN
667     &COM7_RX_QUEUE,
668 #endif
669 #if     COM8_EN
670     &COM8_RX_QUEUE,
671 #endif
672 };
673 
674 static const uint16_t parityArr[3] = {USART_Parity_No, USART_Parity_Odd, USART_Parity_Even};
675 
676 /*******************************************************************************
677 * Function Name :BSP_Uart1Open
678 * Description   :串口及引脚初始化
679 * Input         :   uartx: COM1,COM2,COM3....
680                     baud: 2400,4800,9600,19200,38400,57600,115200
681                     data: 数据位数  8,9,
682                     stop:停止位数  1,2
683                     parity:效验    0: 无效验,1:奇效验,2:偶效验
684 * Output        :
685 * Other         :
686 * Date          :2013.08.12
687 *******************************************************************************/
688 void BSP_UartOpen(uint8_t COM,  uint32_t baud, uint8_t data, uint8_t stop, uint8_t parity)
689 {
690     USART_InitTypeDef USART_InitStructure;
691     GPIO_InitTypeDef GPIO_InitStructure;
692     NVIC_InitTypeDef NvicInitdef;
693     DMA_InitTypeDef DMA_InitStructure;
694     
695     /* DMA clock enable */
696     RCC_AHB1PeriphClockCmd(COM_DMA_CLK[COM], ENABLE);
697 
698     /* Enable GPIO clock */
699     RCC_AHB1PeriphClockCmd(COM_TX_PORT_CLK[COM] | COM_RX_PORT_CLK[COM], ENABLE);
700 
701     /* Enable UART clock */
702     if ((COM_USART[COM] == USART1) || (COM_USART[COM] == USART6))
703     {
704         RCC_APB2PeriphClockCmd(COM_USART_CLK[COM], ENABLE); 
705     }
706     else
707     {
708         RCC_APB1PeriphClockCmd(COM_USART_CLK[COM], ENABLE);
709     }
710     USART_DeInit(COM_USART[COM]);
711     
712     /* Connect PXx to USARTx_Tx*/
713     GPIO_PinAFConfig(COM_TX_PORT[COM], COM_TX_AF_PIN[COM], COM_AF[COM]);
714     /* Connect PXx to USARTx_Rx*/
715     GPIO_PinAFConfig(COM_RX_PORT[COM], COM_RX_AF_PIN[COM], COM_AF[COM]);
716 
717     /* Configure USART Tx as alternate function push-pull */
718     GPIO_InitStructure.GPIO_Pin = COM_TX_PIN[COM];
719     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
720     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
721     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
722     GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
723     GPIO_Init(COM_TX_PORT[COM], &GPIO_InitStructure);
724 
725     /* Configure USART Rx as input floating */
726     GPIO_InitStructure.GPIO_Pin = COM_RX_PIN[COM];
727     GPIO_Init(COM_RX_PORT[COM], &GPIO_InitStructure);
728 
729     /* USART configuration */
730     USART_StructInit(&USART_InitStructure);
731     USART_InitStructure.USART_BaudRate = baud;
732     USART_InitStructure.USART_StopBits = (stop == 2)? USART_StopBits_2 : USART_StopBits_1;
733     USART_InitStructure.USART_WordLength = (data == 9)? USART_WordLength_9b : USART_WordLength_8b;
734     USART_InitStructure.USART_Parity = (parity < 3)? parityArr[parity] : USART_Parity_No;
735     USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
736     USART_Init(COM_USART[COM], &USART_InitStructure);
737     
738     /* Enable USART DMA_TX*/
739     USART_DMACmd(COM_USART[COM], USART_DMAReq_Tx, ENABLE);
740     
741     USART_ITConfig(COM_USART[COM], USART_IT_RXNE, ENABLE);
742     
743      /* Enable USART */
744     USART_Cmd(COM_USART[COM], ENABLE);   
745 
746     NvicInitdef.NVIC_IRQChannel = COM_RX_IRQn[COM];
747     NvicInitdef.NVIC_IRQChannelPreemptionPriority = 3;
748     NvicInitdef.NVIC_IRQChannelSubPriority = 0;
749     NvicInitdef.NVIC_IRQChannelCmd = ENABLE;
750     NVIC_Init( &NvicInitdef );
751 
752     QUEUE_PacketCreate(COM_RX_QUEUE[COM], COM_RX_BUFF[COM], COM_RX_BUFF_SIZE[COM]);
753     /* -------------------------------DMA发送------------------------------  */
754     /* DMA StreamX Config */
755     DMA_DeInit(COM_DMA_TX_STREAM[COM]);    
756     
757     /* DMA StreamX disable */
758     DMA_Cmd(COM_DMA_TX_STREAM[COM], DISABLE);
759 
760     DMA_StructInit(&DMA_InitStructure);
761     DMA_InitStructure.DMA_Channel = COM_DMA_TX_CHANNEL[COM];
762     DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)COM_DMA_DR_BASE[COM];
763     DMA_InitStructure.DMA_Memory0BaseAddr = (u32)COM_TX_BUFF[COM];
764     DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;
765     DMA_InitStructure.DMA_BufferSize = 0;
766     DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
767     DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
768     DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
769     DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
770     DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
771     DMA_InitStructure.DMA_Priority = DMA_Priority_High;
772     DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Enable;
773     DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
774     DMA_Init(COM_DMA_TX_STREAM[COM], &DMA_InitStructure);
775 
776     DMA_FlowControllerConfig(COM_DMA_TX_STREAM[COM], DMA_FlowCtrl_Memory);    //控制流 取决于缓存大小
777 }
778 
779 
780 /*******************************************************************************
781 * Function Name : void BSP_UartClose(uint8_t COMx)
782 * Description   : 串口关闭
783 * Input         : COMx:通道x
784 * Output        : 
785 * Other         : 
786 * Date          : 2013.08.12
787 *******************************************************************************/
788 void BSP_UartClose(uint8_t COM)
789 {
790     if ((COM_USART[COM] == USART1) || (COM_USART[COM] == USART6))
791     {
792         RCC_APB2PeriphClockCmd(COM_USART_CLK[COM], DISABLE); 
793     }
794     else
795     {
796         RCC_APB1PeriphClockCmd(COM_USART_CLK[COM], DISABLE);
797     }
798     
799     RCC_AHB1PeriphClockCmd(COM_DMA_CLK[COM], ENABLE);
800     DMA_Cmd(COM_DMA_TX_STREAM[COM], DISABLE);
801     USART_DMACmd(COM_USART[COM], USART_DMAReq_Tx, DISABLE);
802     USART_ITConfig(COM_USART[COM], USART_IT_RXNE, DISABLE);
803     USART_Cmd(COM_USART[COM], DISABLE);
804 }
805 
806 /*******************************************************************************
807 * Function Name : uint32_t BSP_UartWrite(uint8_t COMx, uint8_t *buffter, uint32_t len)
808 * Description   : 串口发送数据
809 * Input         :   COMx:通道x
810 * Output        : 
811 * Other         : 
812 * Date          : 2013.08.12
813 *******************************************************************************/
814 uint32_t BSP_UartWrite(uint8_t COM, uint8_t *buffter, uint32_t len)
815 {
816     if (COM >= COMn)
817         return 0;
818         
819     if (0 == len)
820         return 0;
821         
822     if ((DMA_GetCurrDataCounter(COM_DMA_TX_STREAM[COM]) == 0)
823         && (DMA_FIFOStatus_Empty == DMA_GetFIFOStatus(COM_DMA_TX_STREAM[COM])))
824     {
825         uint32_t resLen = 0;
826 
827         USART_ClearFlag(COM_USART[COM], USART_FLAG_TC);
828         resLen = (COM_TX_BUFF_SIZE[COM] > len)? len : COM_TX_BUFF_SIZE[COM];
829         memcpy((void *)(COM_TX_BUFF[COM]), buffter, resLen);       
830         DMA_Cmd(COM_DMA_TX_STREAM[COM], DISABLE);
831         DMA_ClearFlag(COM_DMA_TX_STREAM[COM], COM_DMA_TX_FLAG[COM]);
832         DMA_SetCurrDataCounter(COM_DMA_TX_STREAM[COM], resLen);                
833         DMA_Cmd(COM_DMA_TX_STREAM[COM], ENABLE);
834 
835         return resLen;
836     }
837     return 0;
838 }
839 
840 /*******************************************************************************
841 * Function Name : uint32_t BSP_UartRead(uint8_t COMx, uint8_t *buffter, uint32_t len)
842 * Description   : 串口读回数据
843 * Input         : COMx:通道x
844 * Output        : 
845 * Other         : 
846 * Date          : 2013.08.12
847 *******************************************************************************/
848 uint32_t BSP_UartRead(uint8_t COM, uint8_t *buffter, uint32_t len)
849 {
850     return QUEUE_PacketOut(COM_RX_QUEUE[COM], buffter, len);
851 }
852 
853 /*******************************************************************************
854 * Function Name : uint32_t BSP_UartTxIdleState(uint8_t COM)
855 * Description   : 查询 发送是否 发送完成
856 * Input         : 
857 * Output        :       1)忙碌      0)空闲
858 * Other         : 
859 * Date          : 2013.08.12
860 *******************************************************************************/
861 uint32_t BSP_UartTxIdleState(uint8_t COM)
862 {
863     return (DMA_GetCurrDataCounter(COM_DMA_TX_STREAM[COM])
864             || (USART_GetFlagStatus(COM_USART[COM], USART_FLAG_TC) != SET));
865 }
866 
867 
868 /*******************************************************************************
869 * Function Name : void _IRQHandler(uint8_t COM)
870 * Description   : 中断函数
871 * Input         : 
872 * Output        : 
873 * Other         : 
874 * Date          : 2013.08.12
875 *******************************************************************************/
876 void _IRQHandler(uint8_t COM)
877 {
878     if (USART_GetITStatus(COM_USART[COM], USART_IT_RXNE) != RESET)
879     {
880         u8 ch = USART_ReceiveData(COM_USART[COM]);  //读数据后 会自动清空标志
881         QUEUE_PacketIn(COM_RX_QUEUE[COM], &ch, 1);
882     }
883 }
884 
885 #if COM1_EN > 0
886 /*******************************************************************************
887 * Function Name  : USART1_IRQHandler
888 * Description    : This function handles USART1 global interrupt request.
889 * Input          : None
890 * Output         : None
891 * Return         : None
892 *******************************************************************************/
893 void USART1_IRQHandler(void)
894 {
895     _IRQHandler(COM1);
896 }
897 #endif //COM1_EN > 0
898 
899 #if COM2_EN > 0
900 /*******************************************************************************
901 * Function Name  : USART2_IRQHandler
902 * Description    : This function handles USART2 global interrupt request.
903 * Input          : None
904 * Output         : None
905 * Return         : None
906 *******************************************************************************/
907 void USART2_IRQHandler(void)
908 {
909     _IRQHandler(COM2);
910 }
911 #endif //COM2_EN > 0
912 
913 #if COM3_EN > 0
914 /*******************************************************************************
915 * Function Name  : USART3_IRQHandler
916 * Description    : This function handles USART3 global interrupt request.
917 * Input          : None
918 * Output         : None
919 * Return         : None
920 *******************************************************************************/
921 void USART3_IRQHandler(void)
922 {
923     _IRQHandler(COM3);
924 }
925 #endif //COM3_EN > 0
926 
927 #if COM4_EN > 0
928 /*******************************************************************************
929 * Function Name  : USART4_IRQHandler
930 * Description    : This function handles USART4 global interrupt request.
931 * Input          : None
932 * Output         : None
933 * Return         : None
934 *******************************************************************************/
935 void UART4_IRQHandler(void)
936 {
937     _IRQHandler(COM4);
938 }
939 #endif //COM4_EN > 0
940 
941 #if COM5_EN > 0
942 /*******************************************************************************
943 * Function Name  : USART5_IRQHandler
944 * Description    : This function handles USART5 global interrupt request.
945 * Input          : None
946 * Output         : None
947 * Return         : None
948 *******************************************************************************/
949 void UART5_IRQHandler(void)
950 {
951     _IRQHandler(COM5);
952 }
953 #endif //COM5_EN > 0
954 
955 #if COM6_EN > 0
956 /*******************************************************************************
957 * Function Name  : USART6_IRQHandler
958 * Description    : This function handles USART6 global interrupt request.
959 * Input          : None
960 * Output         : None
961 * Return         : None
962 *******************************************************************************/
963 void USART6_IRQHandler(void)
964 {
965     _IRQHandler(COM6);
966 }
967 #endif //COM6_EN > 0
968 
969 #if COM7_EN > 0
970 /*******************************************************************************
971 * Function Name  : USART7_IRQHandler
972 * Description    : This function handles USART7 global interrupt request.
973 * Input          : None
974 * Output         : None
975 * Return         : None
976 *******************************************************************************/
977 void UART7_IRQHandler(void)
978 {
979     _IRQHandler(COM7);
980 }
981 #endif //COM7_EN > 0
982 
983 #if COM8_EN > 0
984 /*******************************************************************************
985 * Function Name  : USART8_IRQHandler
986 * Description    : This function handles USART8 global interrupt request.
987 * Input          : None
988 * Output         : None
989 * Return         : None
990 *******************************************************************************/
991 void UART8_IRQHandler(void)
992 {
993     _IRQHandler(COM8);
994 }
995 #endif //COM8_EN > 0

BSP_Uart.c

6165金沙总站 26165金沙总站 5

  1   1 /*
  2   2 ********************************************************************************
  3   3 *
  4   4 *                                 BSP_Uart.h
  5   5 *
  6   6 * File          : BSP_Uart.h
  7   7 * Version       : V1.0
  8   8 * Author        : whq
  9   9 * Mode          : Thumb2
 10  10 * Toolchain     : 
 11  11 * Description   : 串口驱动头文件
 12  12 *                
 13  13 * History       :
 14  14 * Date          : 2013.08.12
 15  15 *******************************************************************************/
 16  16 
 17  17 #ifndef _BSP_UART_H_
 18  18 #define _BSP_UART_H_
 19  19 
 20  20 #include <stdint.h>
 21  21 
 22  22 
 23  23 #define COM1_EN         1
 24  24 #define COM2_EN         1
 25  25 #define COM3_EN         1
 26  26 #define COM4_EN         1
 27  27 #define COM5_EN         1
 28  28 #define COM6_EN         1
 29  29 #define COM7_EN         0
 30  30 #define COM8_EN         0
 31  31 
 32  32 
 33  33 
 34  34 #define COM_1_0                             //映射:COM_1_0,映射1:COM_1_1
 35  35 #define COM_2_0                             //映射:COM_2_0,映射1:COM_2_1
 36  36 #define COM_3_2                             //映射:COM_3_2,
 37  37 #define COM_4_0 
 38  38 #define COM_5_0 
 39  39 #define COM_6_0 
 40  40 #define COM_7_0 
 41  41 #define COM_8_0 
 42  42 
 43  43 
 44  44 
 45  45 #if !(COM1_EN || COM2_EN || COM3_EN || COM4_EN || COM5_EN || COM6_EN || COM7_EN || COM8_EN)
 46  46 #error  "请至少使能一路串口!"
 47  47 #endif
 48  48 
 49  49 
 50  50 typedef enum {
 51  51 #if     COM1_EN
 52  52         COM1,
 53  53 #endif
 54  54 #if     COM2_EN
 55  55         COM2,
 56  56 #endif
 57  57 #if     COM3_EN
 58  58         COM3,
 59  59 #endif
 60  60 #if     COM4_EN
 61  61         COM4,
 62  62 #endif
 63  63 #if     COM5_EN
 64  64         COM5,
 65  65 #endif
 66  66 #if     COM6_EN
 67  67         COM6,
 68  68 #endif
 69  69 #if     COM7_EN
 70  70         COM7,
 71  71 #endif
 72  72 #if     COM8_EN
 73  73         COM8,
 74  74 #endif
 75  75     COM_MAX
 76  76 }COM_PORT;
 77  77 
 78  78 /** @addtogroup STM3210E_BSP_LOW_LEVEL_COM
 79  79   * @{
 80  80   */
 81  81 #define COMn                                COM_MAX
 82  82 
 83  83 
 84  84 
 85  85 /**
 86  86  * @brief Definition for COM port1, connected to USART1
 87  87  */ 
 88  88 #define BSP_COM1                            USART1
 89  89 #define BSP_COM1_CLK                        RCC_APB2Periph_USART1
 90  90 #define BSP_COM1_AF                         GPIO_AF_USART1
 91  91 #ifdef COM_1_3
 92  92 #define BSP_COM1_TX_AF_PIN                  GPIO_PinSource6
 93  93 #define BSP_COM1_TX_PIN                     GPIO_Pin_6
 94  94 #define BSP_COM1_TX_GPIO_PORT               GPIOB
 95  95 #define BSP_COM1_TX_GPIO_CLK                RCC_AHB1Periph_GPIOB
 96  96 #define BSP_COM1_RX_AF_PIN                  GPIO_PinSource10
 97  97 #define BSP_COM1_RX_PIN                     GPIO_Pin_10
 98  98 #define BSP_COM1_RX_GPIO_PORT               GPIOA
 99  99 #define BSP_COM1_RX_GPIO_CLK                RCC_AHB1Periph_GPIOA
100 100 #elif defined(COM_1_2)
101 101 #define BSP_COM1_TX_AF_PIN                  GPIO_PinSource9
102 102 #define BSP_COM1_TX_PIN                     GPIO_Pin_9
103 103 #define BSP_COM1_TX_GPIO_PORT               GPIOA
104 104 #define BSP_COM1_TX_GPIO_CLK                RCC_AHB1Periph_GPIOA
105 105 #define BSP_COM1_RX_AF_PIN                  GPIO_PinSource7
106 106 #define BSP_COM1_RX_PIN                     GPIO_Pin_7
107 107 #define BSP_COM1_RX_GPIO_PORT               GPIOB
108 108 #define BSP_COM1_RX_GPIO_CLK                RCC_AHB1Periph_GPIOB
109 109 #elif defined(COM_1_1)
110 110 #define BSP_COM1_TX_AF_PIN                  GPIO_PinSource6
111 111 #define BSP_COM1_TX_PIN                     GPIO_Pin_6
112 112 #define BSP_COM1_TX_GPIO_PORT               GPIOB
113 113 #define BSP_COM1_TX_GPIO_CLK                RCC_AHB1Periph_GPIOB
114 114 #define BSP_COM1_RX_AF_PIN                  GPIO_PinSource7
115 115 #define BSP_COM1_RX_PIN                     GPIO_Pin_7
116 116 #define BSP_COM1_RX_GPIO_PORT               GPIOB
117 117 #define BSP_COM1_RX_GPIO_CLK                RCC_AHB1Periph_GPIOB
118 118 #else
119 119 #define BSP_COM1_TX_AF_PIN                  GPIO_PinSource9
120 120 #define BSP_COM1_TX_PIN                     GPIO_Pin_9
121 121 #define BSP_COM1_TX_GPIO_PORT               GPIOA
122 122 #define BSP_COM1_TX_GPIO_CLK                RCC_AHB1Periph_GPIOA
123 123 #define BSP_COM1_RX_AF_PIN                  GPIO_PinSource10
124 124 #define BSP_COM1_RX_PIN                     GPIO_Pin_10
125 125 #define BSP_COM1_RX_GPIO_PORT               GPIOA
126 126 #define BSP_COM1_RX_GPIO_CLK                RCC_AHB1Periph_GPIOA
127 127 #endif
128 128 
129 129 #define BSP_COM1_IRQn                       USART1_IRQn
130 130 
131 131 #define BSP_COM1_DMA_DR_BASE                0x40011004
132 132 #define BSP_COM1_DMA_CLK                    RCC_AHB1Periph_DMA2
133 133 #define BSP_COM1_Tx_DMA_FLAG                DMA_FLAG_TCIF7
134 134 #define BSP_COM1_Tx_DMA_Stream              DMA2_Stream7
135 135 #define BSP_COM1_Tx_DMA_Channel             DMA_Channel_4
136 136 
137 137 #define BSP_COM1_Tx_BUFF_SIZE               0x600       //发送缓冲区大小
138 138 #define BSP_COM1_Rx_BUFF_SIZE               0x600         //接收缓冲区大小
139 139 
140 140 
141 141 /**
142 142  * @brief Definition for COM port2, connected to USART2
143 143  */ 
144 144 #define BSP_COM2                            USART2
145 145 #define BSP_COM2_CLK                        RCC_APB1Periph_USART2
146 146 #define BSP_COM2_AF                         GPIO_AF_USART2
147 147 
148 148 #ifdef COM_2_3
149 149 #define BSP_COM2_TX_AF_PIN                  GPIO_PinSource2
150 150 #define BSP_COM2_TX_PIN                     GPIO_Pin_2
151 151 #define BSP_COM2_TX_GPIO_PORT               GPIOA
152 152 #define BSP_COM2_TX_GPIO_CLK                RCC_AHB1Periph_GPIOA
153 153 #define BSP_COM2_RX_AF_PIN                  GPIO_PinSource6
154 154 #define BSP_COM2_RX_PIN                     GPIO_Pin_6
155 155 #define BSP_COM2_RX_GPIO_PORT               GPIOD
156 156 #define BSP_COM2_RX_GPIO_CLK                RCC_AHB1Periph_GPIOD
157 157 #elif defined(COM_2_2)
158 158 #define BSP_COM2_TX_AF_PIN                  GPIO_PinSource5
159 159 #define BSP_COM2_TX_PIN                     GPIO_Pin_5
160 160 #define BSP_COM2_TX_GPIO_PORT               GPIOD
161 161 #define BSP_COM2_TX_GPIO_CLK                RCC_AHB1Periph_GPIOD
162 162 #define BSP_COM2_RX_AF_PIN                  GPIO_PinSource3
163 163 #define BSP_COM2_RX_PIN                     GPIO_Pin_3
164 164 #define BSP_COM2_RX_GPIO_PORT               GPIOA
165 165 #define BSP_COM2_RX_GPIO_CLK                RCC_AHB1Periph_GPIOA
166 166 #elif defined(COM_2_1)
167 167 #define BSP_COM2_TX_AF_PIN                  GPIO_PinSource5
168 168 #define BSP_COM2_TX_PIN                     GPIO_Pin_5
169 169 #define BSP_COM2_TX_GPIO_PORT               GPIOD
170 170 #define BSP_COM2_TX_GPIO_CLK                RCC_AHB1Periph_GPIOD
171 171 #define BSP_COM2_RX_AF_PIN                  GPIO_PinSource6
172 172 #define BSP_COM2_RX_PIN                     GPIO_Pin_6
173 173 #define BSP_COM2_RX_GPIO_PORT               GPIOD
174 174 #define BSP_COM2_RX_GPIO_CLK                RCC_AHB1Periph_GPIOD
175 175 #else
176 176 #define BSP_COM2_TX_AF_PIN                  GPIO_PinSource2
177 177 #define BSP_COM2_TX_PIN                     GPIO_Pin_2
178 178 #define BSP_COM2_TX_GPIO_PORT               GPIOA
179 179 #define BSP_COM2_TX_GPIO_CLK                RCC_AHB1Periph_GPIOA
180 180 #define BSP_COM2_RX_AF_PIN                  GPIO_PinSource3
181 181 #define BSP_COM2_RX_PIN                     GPIO_Pin_3
182 182 #define BSP_COM2_RX_GPIO_PORT               GPIOA
183 183 #define BSP_COM2_RX_GPIO_CLK                RCC_AHB1Periph_GPIOA
184 184 #endif
185 185     
186 186 #define BSP_COM2_IRQn                       USART2_IRQn
187 187     
188 188 #define BSP_COM2_DMA_DR_BASE                0x40004404
189 189 #define BSP_COM2_DMA_CLK                    RCC_AHB1Periph_DMA1
190 190 #define BSP_COM2_Tx_DMA_FLAG                DMA_FLAG_TCIF6
191 191 #define BSP_COM2_Tx_DMA_Stream              DMA1_Stream6
192 192 #define BSP_COM2_Tx_DMA_Channel             DMA_Channel_4
193 193 
194 194 #define BSP_COM2_Tx_BUFF_SIZE               0x400       //发送缓冲区大小
195 195 #define BSP_COM2_Rx_BUFF_SIZE               0x400       //接收缓冲区大小
196 196 
197 197 
198 198 
199 199 /**
200 200  * @brief Definition for COM port3, connected to USART3
201 201  */ 
202 202 #define BSP_COM3                            USART3
203 203 #define BSP_COM3_CLK                        RCC_APB1Periph_USART3
204 204 #define BSP_COM3_AF                         GPIO_AF_USART3
205 205 #ifdef COM_3_3                              //自由组合部分
206 206 #define BSP_COM3_TX_AF_PIN                  GPIO_PinSource8
207 207 #define BSP_COM3_TX_PIN                     GPIO_Pin_8
208 208 #define BSP_COM3_TX_GPIO_PORT               GPIOD
209 209 #define BSP_COM3_TX_GPIO_CLK                RCC_AHB1Periph_GPIOD
210 210 #define BSP_COM3_RX_AF_PIN                  GPIO_PinSource11
211 211 #define BSP_COM3_RX_PIN                     GPIO_Pin_11
212 212 #define BSP_COM3_RX_GPIO_PORT               GPIOC
213 213 #define BSP_COM3_RX_GPIO_CLK                RCC_AHB1Periph_GPIOC
214 214 #elif defined(COM_3_2)
215 215 #define BSP_COM3_TX_AF_PIN                  GPIO_PinSource8
216 216 #define BSP_COM3_TX_PIN                     GPIO_Pin_8
217 217 #define BSP_COM3_TX_GPIO_PORT               GPIOD
218 218 #define BSP_COM3_TX_GPIO_CLK                RCC_AHB1Periph_GPIOD
219 219 #define BSP_COM3_RX_AF_PIN                  GPIO_PinSource9
220 220 #define BSP_COM3_RX_PIN                     GPIO_Pin_9
221 221 #define BSP_COM3_RX_GPIO_PORT               GPIOD
222 222 #define BSP_COM3_RX_GPIO_CLK                RCC_AHB1Periph_GPIOD
223 223 #elif defined(COM_3_1)
224 224 #define BSP_COM3_TX_AF_PIN                  GPIO_PinSource10
225 225 #define BSP_COM3_TX_PIN                     GPIO_Pin_10
226 226 #define BSP_COM3_TX_GPIO_PORT               GPIOC
227 227 #define BSP_COM3_TX_GPIO_CLK                RCC_AHB1Periph_GPIOC
228 228 #define BSP_COM3_RX_AF_PIN                  GPIO_PinSource11
229 229 #define BSP_COM3_RX_PIN                     GPIO_Pin_11
230 230 #define BSP_COM3_RX_GPIO_PORT               GPIOC
231 231 #define BSP_COM3_RX_GPIO_CLK                RCC_AHB1Periph_GPIOC
232 232 #else
233 233 #define BSP_COM3_TX_AF_PIN                  GPIO_PinSource10
234 234 #define BSP_COM3_TX_PIN                     GPIO_Pin_10
235 235 #define BSP_COM3_TX_GPIO_PORT               GPIOB
236 236 #define BSP_COM3_TX_GPIO_CLK                RCC_AHB1Periph_GPIOB
237 237 #define BSP_COM3_RX_AF_PIN                  GPIO_PinSource11
238 238 #define BSP_COM3_RX_PIN                     GPIO_Pin_11
239 239 #define BSP_COM3_RX_GPIO_PORT               GPIOB
240 240 #define BSP_COM3_RX_GPIO_CLK                RCC_AHB1Periph_GPIOB
241 241 #endif
242 242     
243 243 #define BSP_COM3_IRQn                       USART3_IRQn
244 244     
245 245 #define BSP_COM3_DMA_DR_BASE                0x40004804
246 246 #define BSP_COM3_DMA_CLK                    RCC_AHB1Periph_DMA1
247 247 #define BSP_COM3_Tx_DMA_FLAG                DMA_FLAG_TCIF3
248 248 #define BSP_COM3_Tx_DMA_Stream              DMA1_Stream3
249 249 #define BSP_COM3_Tx_DMA_Channel             DMA_Channel_4
250 250 
251 251 #define BSP_COM3_Tx_BUFF_SIZE               0x400       //发送缓冲区大小
252 252 #define BSP_COM3_Rx_BUFF_SIZE               0x400       //接收缓冲区大小
253 253 
254 254 
255 255 /**
256 256  * @brief Definition for COM port4, connected to USART4
257 257  */ 
258 258 #define BSP_COM4                            UART4
259 259 #define BSP_COM4_CLK                        RCC_APB1Periph_UART4
260 260 #define BSP_COM4_AF                         GPIO_AF_UART4
261 261 #ifdef COM_4_3
262 262 #define BSP_COM4_TX_AF_PIN                  GPIO_PinSource10
263 263 #define BSP_COM4_TX_PIN                     GPIO_Pin_10
264 264 #define BSP_COM4_TX_GPIO_PORT               GPIOC
265 265 #define BSP_COM4_TX_GPIO_CLK                RCC_AHB1Periph_GPIOC
266 266 #define BSP_COM4_RX_AF_PIN                  GPIO_PinSource1
267 267 #define BSP_COM4_RX_PIN                     GPIO_Pin_1
268 268 #define BSP_COM4_RX_GPIO_PORT               GPIOA
269 269 #define BSP_COM4_RX_GPIO_CLK                RCC_AHB1Periph_GPIOA
270 270 #elif defined(COM_4_2)
271 271 #define BSP_COM4_TX_AF_PIN                  GPIO_PinSource0
272 272 #define BSP_COM4_TX_PIN                     GPIO_Pin_0
273 273 #define BSP_COM4_TX_GPIO_PORT               GPIOA
274 274 #define BSP_COM4_TX_GPIO_CLK                RCC_AHB1Periph_GPIOA
275 275 #define BSP_COM4_RX_AF_PIN                  GPIO_PinSource11
276 276 #define BSP_COM4_RX_PIN                     GPIO_Pin_11
277 277 #define BSP_COM4_RX_GPIO_PORT               GPIOC
278 278 #define BSP_COM4_RX_GPIO_CLK                RCC_AHB1Periph_GPIOC
279 279 #elif defined(COM_4_1)
280 280 #define BSP_COM4_TX_AF_PIN                  GPIO_PinSource10
281 281 #define BSP_COM4_TX_PIN                     GPIO_Pin_10
282 282 #define BSP_COM4_TX_GPIO_PORT               GPIOC
283 283 #define BSP_COM4_TX_GPIO_CLK                RCC_AHB1Periph_GPIOC
284 284 #define BSP_COM4_RX_AF_PIN                  GPIO_PinSource11
285 285 #define BSP_COM4_RX_PIN                     GPIO_Pin_11
286 286 #define BSP_COM4_RX_GPIO_PORT               GPIOC
287 287 #define BSP_COM4_RX_GPIO_CLK                RCC_AHB1Periph_GPIOC
288 288 #else
289 289 #define BSP_COM4_TX_AF_PIN                  GPIO_PinSource0
290 290 #define BSP_COM4_TX_PIN                     GPIO_Pin_0
291 291 #define BSP_COM4_TX_GPIO_PORT               GPIOA
292 292 #define BSP_COM4_TX_GPIO_CLK                RCC_AHB1Periph_GPIOA
293 293 #define BSP_COM4_RX_AF_PIN                  GPIO_PinSource1
294 294 #define BSP_COM4_RX_PIN                     GPIO_Pin_1
295 295 #define BSP_COM4_RX_GPIO_PORT               GPIOA
296 296 #define BSP_COM4_RX_GPIO_CLK                RCC_AHB1Periph_GPIOA
297 297 #endif
298 298         
299 299 #define BSP_COM4_IRQn                       UART4_IRQn
300 300         
301 301 #define BSP_COM4_DMA_DR_BASE                0x40004C04
302 302 #define BSP_COM4_DMA_CLK                    RCC_AHB1Periph_DMA1
303 303 #define BSP_COM4_Tx_DMA_FLAG                DMA_FLAG_TCIF4
304 304 #define BSP_COM4_Tx_DMA_Stream              DMA1_Stream4
305 305 #define BSP_COM4_Tx_DMA_Channel             DMA_Channel_4
306 306 
307 307 #define BSP_COM4_Tx_BUFF_SIZE               0x400       //发送缓冲区大小
308 308 #define BSP_COM4_Rx_BUFF_SIZE               0x400       //接收缓冲区大小
309 309 
310 310 
311 311 /**
312 312  * @brief Definition for COM port5, connected to USART5
313 313  */ 
314 314 #define BSP_COM5                            UART5
315 315 #define BSP_COM5_CLK                        RCC_APB1Periph_UART5
316 316 #define BSP_COM5_AF                         GPIO_AF_UART5
317 317 
318 318 #define BSP_COM5_TX_AF_PIN                  GPIO_PinSource12
319 319 #define BSP_COM5_TX_PIN                     GPIO_Pin_12
320 320 #define BSP_COM5_TX_GPIO_PORT               GPIOC
321 321 #define BSP_COM5_TX_GPIO_CLK                RCC_AHB1Periph_GPIOC
322 322 #define BSP_COM5_RX_AF_PIN                  GPIO_PinSource2
323 323 #define BSP_COM5_RX_PIN                     GPIO_Pin_2
324 324 #define BSP_COM5_RX_GPIO_PORT               GPIOD
325 325 #define BSP_COM5_RX_GPIO_CLK                RCC_AHB1Periph_GPIOD
326 326         
327 327 #define BSP_COM5_IRQn                       UART5_IRQn
328 328         
329 329 #define BSP_COM5_DMA_DR_BASE                0x40005004
330 330 #define BSP_COM5_DMA_CLK                    RCC_AHB1Periph_DMA1
331 331 #define BSP_COM5_Tx_DMA_FLAG                DMA_FLAG_TCIF7
332 332 #define BSP_COM5_Tx_DMA_Stream              DMA1_Stream7
333 333 #define BSP_COM5_Tx_DMA_Channel             DMA_Channel_4
334 334 
335 335 #define BSP_COM5_Tx_BUFF_SIZE               125     //发送缓冲区大小
336 336 #define BSP_COM5_Rx_BUFF_SIZE               125     //接收缓冲区大小
337 337 
338 338 
339 339 /**
340 340  * @brief Definition for COM port6, connected to USART6
341 341  */ 
342 342 #define BSP_COM6                            USART6
343 343 #define BSP_COM6_CLK                        RCC_APB2Periph_USART6
344 344 #define BSP_COM6_AF                         GPIO_AF_USART6
345 345 #ifdef COM_6_3
346 346 #define BSP_COM6_TX_AF_PIN                  GPIO_PinSource6
347 347 #define BSP_COM6_TX_PIN                     GPIO_Pin_6
348 348 #define BSP_COM6_TX_GPIO_PORT               GPIOC
349 349 #define BSP_COM6_TX_GPIO_CLK                RCC_AHB1Periph_GPIOC
350 350 #define BSP_COM6_RX_AF_PIN                  GPIO_PinSource9
351 351 #define BSP_COM6_RX_PIN                     GPIO_Pin_9
352 352 #define BSP_COM6_RX_GPIO_PORT               GPIOG
353 353 #define BSP_COM6_RX_GPIO_CLK                RCC_AHB1Periph_GPIOG
354 354 #elif defined(COM_6_2)
355 355 #define BSP_COM6_TX_AF_PIN                  GPIO_PinSource14
356 356 #define BSP_COM6_TX_PIN                     GPIO_Pin_14
357 357 #define BSP_COM6_TX_GPIO_PORT               GPIOG
358 358 #define BSP_COM6_TX_GPIO_CLK                RCC_AHB1Periph_GPIOG
359 359 #define BSP_COM6_RX_AF_PIN                  GPIO_PinSource7
360 360 #define BSP_COM6_RX_PIN                     GPIO_Pin_7
361 361 #define BSP_COM6_RX_GPIO_PORT               GPIOC
362 362 #define BSP_COM6_RX_GPIO_CLK                RCC_AHB1Periph_GPIOC
363 363 #elif defined(COM_6_1)
364 364 #define BSP_COM6_TX_AF_PIN                  GPIO_PinSource14
365 365 #define BSP_COM6_TX_PIN                     GPIO_Pin_14
366 366 #define BSP_COM6_TX_GPIO_PORT               GPIOG
367 367 #define BSP_COM6_TX_GPIO_CLK                RCC_AHB1Periph_GPIOG
368 368 #define BSP_COM6_RX_AF_PIN                  GPIO_PinSource9
369 369 #define BSP_COM6_RX_PIN                     GPIO_Pin_9
370 370 #define BSP_COM6_RX_GPIO_PORT               GPIOG
371 371 #define BSP_COM6_RX_GPIO_CLK                RCC_AHB1Periph_GPIOG
372 372 #else
373 373 #define BSP_COM6_TX_AF_PIN                  GPIO_PinSource6
374 374 #define BSP_COM6_TX_PIN                     GPIO_Pin_6
375 375 #define BSP_COM6_TX_GPIO_PORT               GPIOC
376 376 #define BSP_COM6_TX_GPIO_CLK                RCC_AHB1Periph_GPIOC
377 377 #define BSP_COM6_RX_AF_PIN                  GPIO_PinSource7
378 378 #define BSP_COM6_RX_PIN                     GPIO_Pin_7
379 379 #define BSP_COM6_RX_GPIO_PORT               GPIOC
380 380 #define BSP_COM6_RX_GPIO_CLK                RCC_AHB1Periph_GPIOC
381 381 #endif
382 382         
383 383 #define BSP_COM6_IRQn                       USART6_IRQn
384 384         
385 385 #define BSP_COM6_DMA_DR_BASE                0x40011404
386 386 #define BSP_COM6_DMA_CLK                    RCC_AHB1Periph_DMA2
387 387 #define BSP_COM6_Tx_DMA_FLAG                DMA_FLAG_TCIF6
388 388 #define BSP_COM6_Tx_DMA_Stream              DMA2_Stream6
389 389 #define BSP_COM6_Tx_DMA_Channel             DMA_Channel_5
390 390 
391 391         
392 392 #define BSP_COM6_Tx_BUFF_SIZE               0x400       //发送缓冲区大小
393 393 #define BSP_COM6_Rx_BUFF_SIZE               0x400       //接收缓冲区大小
394 394 
395 395 /**
396 396  * @brief Definition for COM port7, connected to USART7
397 397  */ 
398 398 #define BSP_COM7                            UART7
399 399 #define BSP_COM7_CLK                        RCC_APB1Periph_UART7
400 400 #define BSP_COM7_AF                         GPIO_AF_UART7
401 401 #ifdef COM_7_3
402 402 #define BSP_COM7_TX_AF_PIN                  GPIO_PinSource8
403 403 #define BSP_COM7_TX_PIN                     GPIO_Pin_8
404 404 #define BSP_COM7_TX_GPIO_PORT               GPIOE
405 405 #define BSP_COM7_TX_GPIO_CLK                RCC_AHB1Periph_GPIOE
406 406 #define BSP_COM7_RX_AF_PIN                  GPIO_PinSource6
407 407 #define BSP_COM7_RX_PIN                     GPIO_Pin_6
408 408 #define BSP_COM7_RX_GPIO_PORT               GPIOF
409 409 #define BSP_COM7_RX_GPIO_CLK                RCC_AHB1Periph_GPIOF
410 410 #elif defined(COM_7_2)
411 411 #define BSP_COM7_TX_AF_PIN                  GPIO_PinSource7
412 412 #define BSP_COM7_TX_PIN                     GPIO_Pin_7
413 413 #define BSP_COM7_TX_GPIO_PORT               GPIOF
414 414 #define BSP_COM7_TX_GPIO_CLK                RCC_AHB1Periph_GPIOF
415 415 #define BSP_COM7_RX_AF_PIN                  GPIO_PinSource7
416 416 #define BSP_COM7_RX_PIN                     GPIO_Pin_7
417 417 #define BSP_COM7_RX_GPIO_PORT               GPIOE
418 418 #define BSP_COM7_RX_GPIO_CLK                RCC_AHB1Periph_GPIOE
419 419 #elif defined(COM_7_1)
420 420 #define BSP_COM7_TX_AF_PIN                  GPIO_PinSource7
421 421 #define BSP_COM7_TX_PIN                     GPIO_Pin_7
422 422 #define BSP_COM7_TX_GPIO_PORT               GPIOF
423 423 #define BSP_COM7_TX_GPIO_CLK                RCC_AHB1Periph_GPIOF
424 424 #define BSP_COM7_RX_AF_PIN                  GPIO_PinSource6
425 425 #define BSP_COM7_RX_PIN                     GPIO_Pin_6
426 426 #define BSP_COM7_RX_GPIO_PORT               GPIOF
427 427 #define BSP_COM7_RX_GPIO_CLK                RCC_AHB1Periph_GPIOF
428 428 #else
429 429 #define BSP_COM7_TX_AF_PIN                  GPIO_PinSource8
430 430 #define BSP_COM7_TX_PIN                     GPIO_Pin_8
431 431 #define BSP_COM7_TX_GPIO_PORT               GPIOE
432 432 #define BSP_COM7_TX_GPIO_CLK                RCC_AHB1Periph_GPIOE
433 433 #define BSP_COM7_RX_AF_PIN                  GPIO_PinSource7
434 434 #define BSP_COM7_RX_PIN                     GPIO_Pin_7
435 435 #define BSP_COM7_RX_GPIO_PORT               GPIOE
436 436 #define BSP_COM7_RX_GPIO_CLK                RCC_AHB1Periph_GPIOE
437 437 #endif
438 438         
439 439 #define BSP_COM7_IRQn                       UART7_IRQn
440 440         
441 441 #define BSP_COM7_DMA_DR_BASE                0x40007804
442 442 #define BSP_COM7_DMA_CLK                    RCC_AHB1Periph_DMA1
443 443 #define BSP_COM7_Tx_DMA_FLAG                DMA_FLAG_TCIF1
444 444 #define BSP_COM7_Tx_DMA_Stream              DMA1_Stream1
445 445 #define BSP_COM7_Tx_DMA_Channel             DMA_Channel_5
446 446 
447 447 #define BSP_COM7_Tx_BUFF_SIZE               0x400       //发送缓冲区大小
448 448 #define BSP_COM7_Rx_BUFF_SIZE               0x400       //接收缓冲区大小
449 449 
450 450 /**
451 451  * @brief Definition for COM port8, connected to USART8
452 452  */ 
453 453 #define BSP_COM8                            UART8
454 454 #define BSP_COM8_CLK                        RCC_APB1Periph_UART8
455 455 #define BSP_COM8_AF                         GPIO_AF_UART8
456 456 
457 457 #define BSP_COM8_TX_AF_PIN                  GPIO_PinSource1
458 458 #define BSP_COM8_TX_PIN                     GPIO_Pin_1
459 459 #define BSP_COM8_TX_GPIO_PORT               GPIOE
460 460 #define BSP_COM8_TX_GPIO_CLK                RCC_AHB1Periph_GPIOE
461 461 #define BSP_COM8_RX_AF_PIN                  GPIO_PinSource0
462 462 #define BSP_COM8_RX_PIN                     GPIO_Pin_0
463 463 #define BSP_COM8_RX_GPIO_PORT               GPIOE
464 464 #define BSP_COM8_RX_GPIO_CLK                RCC_AHB1Periph_GPIOE
465 465         
466 466 #define BSP_COM8_IRQn                       UART8_IRQn
467 467         
468 468 #define BSP_COM8_DMA_DR_BASE                0x40007C04
469 469 #define BSP_COM8_DMA_CLK                    RCC_AHB1Periph_DMA1
470 470 #define BSP_COM8_Tx_DMA_FLAG                DMA_FLAG_TCIF0
471 471 #define BSP_COM8_Tx_DMA_Stream              DMA1_Stream0
472 472 #define BSP_COM8_Tx_DMA_Channel             DMA_Channel_5
473 473 
474 474 #define BSP_COM8_Tx_BUFF_SIZE               0x400       //发送缓冲区大小
475 475 #define BSP_COM8_Rx_BUFF_SIZE               0x400       //接收缓冲区大小
476 476 
477 477 
478 478 
479 479 /******************************函数声明****************************************/
480 480 void BSP_UartOpen(uint8_t COM,  uint32_t baud, uint8_t data, uint8_t stop, uint8_t parity);
481 481 void BSP_UartClose(uint8_t COM);
482 482 uint32_t BSP_UartWrite(uint8_t COM, uint8_t *buffter, uint32_t len);
483 483 uint32_t BSP_UartRead(uint8_t COM, uint8_t *buffter, uint32_t len);
484 484 uint32_t BSP_UartTxIdleState(uint8_t COM);
485 485 
486 486 
487 487 
488 488 #endif

BSP_Uart.h

6165金沙总站 26165金沙总站 7

  1   1 /*
  2   2 ********************************************************************************
  3   3 *
  4   4 *                                 Queue.c
  5   5 *
  6   6 * File          : Queue.c
  7   7 * Version       : V1.0
  8   8 * Author        : whq
  9   9 * Mode          : Thumb2
 10  10 * Toolchain     : 
 11  11 * Description   : 队列操作
 12  12 *                
 13  13 * History       :
 14  14 * Date          : 2013.07.22
 15  15 *******************************************************************************/
 16  16 
 17  17 #include <string.h>
 18  18 
 19  19 #include "Queue.h"
 20  20 /*******************************************************************************
 21  21 * Function Name : uint32_t QUEUE_PacketCreate(QUEUE8_TYPE *pQ8, uint8_t *pBuf, uint32_t lenSize)
 22  22 * Description   : 队列建立
 23  23 * Input         :   pQ8:    队列
 24  24                     pBuf:   队列缓冲区地址
 25  25                     bufSize:队列缓冲区大小
 26  26 * Output        : 
 27  27 * Other         : 
 28  28 * Date          : 2013.08.29
 29  29 *******************************************************************************/
 30  30 uint32_t QUEUE_PacketCreate(QUEUE8_TYPE *pQ8, uint8_t *pBuf, uint32_t bufSize)
 31  31 {
 32  32     ASSERT_PARAM(pQ8);
 33  33     ASSERT_PARAM(pBuf);
 34  34     ASSERT_PARAM(bufSize);
 35  35 
 36  36     pQ8->bufSize    = bufSize;
 37  37     pQ8->pBuf       = pBuf;
 38  38     pQ8->pStart     = pBuf;
 39  39     pQ8->pEnd       = pBuf;
 40  40 
 41  41     return 0;
 42  42 }
 43  43 
 44  44 /*******************************************************************************
 45  45 * Function Name : uint32_t QUEUE_PacketIn(QUEUE8_TYPE *pQ8, uint8_t *pData, uint32_t len)
 46  46 * Description   : 数据载入队列
 47  47 * Input         :   pQ8:    队列
 48  48                     pData:  要进队列的数据
 49  49                     len:    数据长度
 50  50 * Output        : 
 51  51 * Other         : 
 52  52 * Date          : 2013.08.29
 53  53 *******************************************************************************/
 54  54 uint32_t QUEUE_PacketIn(QUEUE8_TYPE *pQ8, uint8_t *pData, uint32_t len)
 55  55 {
 56  56     uint32_t dataLen = len;
 57  57     
 58  58     ASSERT_PARAM(pData);
 59  59     ASSERT_PARAM(pQ8);
 60  60     ASSERT_PARAM(pQ8->pStart);
 61  61     ASSERT_PARAM(pQ8->pEnd);
 62  62 
 63  63     while (dataLen--)
 64  64     {
 65  65         *pQ8->pEnd++ = *pData++;
 66  66         
 67  67         if (pQ8->pEnd >= pQ8->pBuf + pQ8->bufSize)      //指针指向栈尾
 68  68         {
 69  69             pQ8->pEnd = pQ8->pBuf;
 70  70         }
 71  71         
 72  72         if (pQ8->pEnd == pQ8->pStart)                   //缓冲区填满 覆盖最早的数据
 73  73         {
 74  74             pQ8->pStart++;
 75  75             if (pQ8->pStart >= pQ8->pBuf + pQ8->bufSize) 
 76  76             {
 77  77                 pQ8->pStart = pQ8->pBuf;
 78  78             }
 79  79         }
 80  80     }
 81  81     
 82  82     return len;
 83  83 }
 84  84 
 85  85 /*******************************************************************************
 86  86 * Function Name : uint32_t QUEUE_PacketOut(QUEUE8_TYPE *pQ8, uint8_t *pData, uint32_t dataLen)
 87  87 * Description   : 队列中取数据
 88  88 * Input         :   pQ8:    队列
 89  89                     pData:  缓冲区
 90  90                     dataLen:缓冲区大小
 91  91 * Output        : 
 92  92 * Other         : 
 93  93 * Date          : 2013.08.29
 94  94 *******************************************************************************/
 95  95 uint32_t QUEUE_PacketOut(QUEUE8_TYPE *pQ8, uint8_t *pData, uint32_t dataLen)
 96  96 {
 97  97     uint32_t index = 0;
 98  98     
 99  99     ASSERT_PARAM(pData);
100 100     ASSERT_PARAM(pQ8);
101 101     ASSERT_PARAM(pQ8->pStart);
102 102     ASSERT_PARAM(pQ8->pEnd);
103 103 
104 104     while ((pQ8->pStart != pQ8->pEnd) && (index < dataLen) && (index < pQ8->bufSize))
105 105     {
106 106         pData[index++] = *pQ8->pStart++;
107 107         if (pQ8->pStart >= pQ8->pBuf + pQ8->bufSize) 
108 108         {
109 109             pQ8->pStart = pQ8->pBuf;
110 110         }
111 111     }
112 112 
113 113     return index;
114 114 }
115 115 
116 116 /*******************************************************************************
117 117 * Function Name : uint32_t QUEUE_PacketSplit(QUEUE8_TYPE *pQ8, uint8_t startChar, uint8_t endChar, uint8_t *pData, uint32_t dataLen)
118 118 * Description   : 以起始符和结束符取队列中的数据 (取出的数据 包括起始符 和分隔符)
119 119 * Input         :   pQ8:        队列
120 120                     startChar:  起始符
121 121                     endChar:    结束符
122 122                     pData:      缓冲区
123 123                     dataLen:    缓冲区大小
124 124 * Output        : 
125 125 * Other         : 
126 126 * Date          : 2013.08.29
127 127 *******************************************************************************/
128 128 uint32_t QUEUE_PacketSplit(QUEUE8_TYPE *pQ8, uint8_t startChar, uint8_t endChar, uint8_t *pData, uint32_t dataLen)
129 129 {
130 130     int32_t count;
131 131     int32_t index;
132 132     volatile uint8_t *pStart;
133 133     volatile uint8_t *pEnd;
134 134     
135 135     ASSERT_PARAM(pData);
136 136     ASSERT_PARAM(pQ8);
137 137     ASSERT_PARAM(pQ8->pStart);
138 138     ASSERT_PARAM(pQ8->pEnd);
139 139 
140 140     pStart      = pQ8->pStart;
141 141     count       = pQ8->bufSize;
142 142     
143 143     while ((pStart != pQ8->pEnd) && count--)        //查找起始字符
144 144     {
145 145         if (startChar == *pStart) break;
146 146         if (++pStart >= pQ8->pBuf + pQ8->bufSize) pStart = pQ8->pBuf;
147 147     }
148 148 
149 149     if (pStart == pQ8->pEnd) return 0;              //未找到起始符
150 150     if (count == -1) return 0;
151 151     pEnd = pStart;
152 152     if (++pEnd >= pQ8->pBuf + pQ8->bufSize) pEnd = pQ8->pBuf;
153 153 
154 154     while ((pEnd != pQ8->pEnd) && count--)          //查找结束字符
155 155     {
156 156         if (endChar == *pEnd) break;
157 157         if (++pEnd >= pQ8->pBuf + pQ8->bufSize) pEnd = pQ8->pBuf;
158 158     }
159 159     
160 160     if (pEnd == pQ8->pEnd) return 0;                //未找结束符
161 161     if (count == -1) return 0;
162 162     if (++pEnd >= pQ8->pBuf + pQ8->bufSize) pEnd = pQ8->pBuf;
163 163     
164 164     count   = pQ8->bufSize - count;   
165 165     index   = 0;
166 166      //获取从起始字符到结束字符的数据
167 167     while ((pStart != pEnd) && (index < dataLen) && (index < pQ8->bufSize) && count--)
168 168     {
169 169         pData[index++] = *pStart++;
170 170         if (pStart >= pQ8->pBuf + pQ8->bufSize) pStart = pQ8->pBuf;
171 171     }
172 172 
173 173     pQ8->pStart = pEnd;
174 174     return index;
175 175 }
176 176 
177 177 /*******************************************************************************
178 178 * Function Name : uint32_t QUEUE_PacketCharSplit(QUEUE8_TYPE *pQ8, uint8_t splitChar, uint8_t *pData, uint32_t dataLen)
179 179 * Description   : 提取首尾双分隔符内的数据(包括分隔符)
180 180 * Input         :   pQ8:        队列
181 181                     startChar:  起始符
182 182                     endChar:    结束符
183 183                     pData:      缓冲区
184 184                     dataLen:    缓冲区大小
185 185 * Output        : 
186 186 * Other         : 
187 187 * Date          : 2013.08.30
188 188 *******************************************************************************/
189 189 uint32_t QUEUE_PacketDoubleByteSplit(QUEUE8_TYPE *pQ8, uint8_t splitChar, uint8_t *pData, uint32_t dataLen)
190 190 {
191 191     int32_t count;
192 192     int32_t index;
193 193     volatile uint8_t *pStart;
194 194     volatile uint8_t *pEnd;
195 195     
196 196     ASSERT_PARAM(pData);
197 197     ASSERT_PARAM(pQ8);
198 198     ASSERT_PARAM(pQ8->pStart);
199 199     ASSERT_PARAM(pQ8->pEnd);
200 200 
201 201     pStart      = pQ8->pStart;
202 202     count       = pQ8->bufSize;
203 203     
204 204     while ((pStart != pQ8->pEnd) && count--)        //查找起始字符
205 205     {
206 206         if (splitChar == *pStart) break;
207 207         if (++pStart >= pQ8->pBuf + pQ8->bufSize) pStart = pQ8->pBuf;
208 208     }
209 209 
210 210     if (pStart == pQ8->pEnd) return 0;              //未找到起始符
211 211     if (count == -1) return 0;
212 212     pEnd = pStart;
213 213     if (++pEnd >= pQ8->pBuf + pQ8->bufSize) pEnd = pQ8->pBuf;
214 214 
215 215     while ((pEnd != pQ8->pEnd) && count--)          //查找结束字符
216 216     {
217 217         if (splitChar == *pEnd) break;
218 218         if (++pEnd >= pQ8->pBuf + pQ8->bufSize) pEnd = pQ8->pBuf;
219 219     }
220 220     
221 221     if (pEnd == pQ8->pEnd) return 0;                //未找结束符
222 222     if (count == -1) return 0;
223 223     if (++pEnd >= pQ8->pBuf + pQ8->bufSize) pEnd = pQ8->pBuf;
224 224     
225 225     count   = pQ8->bufSize - count;   
226 226     index   = 0;
227 227      //获取从起始字符到结束字符的数据
228 228     while ((pStart != pEnd) && (index < dataLen) && (index < pQ8->bufSize) && count--)
229 229     {
230 230         pData[index++] = *pStart++;
231 231         if (pStart >= pQ8->pBuf + pQ8->bufSize) pStart = pQ8->pBuf;
232 232     }
233 233 
234 234     //如果取出的数据只包括分隔符,有可能是上次结束符和下次起始符,因此放弃上次结束符。
235 235     if (index <= 2)                                  
236 236     {
237 237         index = 0;
238 238         if (--pStart < pQ8->pBuf) pStart = pQ8->pBuf + pQ8->bufSize - 1;
239 239     }
240 240 
241 241     pQ8->pStart = pStart;
242 242     return index;
243 243 }
244 244 
245 245 /*******************************************************************************
246 246 * Function Name : uint32_t QUEUE_PacketCharSplit(QUEUE8_TYPE *pQ8, uint8_t splitChar, uint8_t *pData, uint32_t dataLen)
247 247 * Description   : 提取单结束分隔符的数据 (包括分隔符)
248 248 * Input         : 
249 249 * Output        : 
250 250 * Other         : 
251 251 * Date          : 2013.10.20
252 252 *******************************************************************************/
253 253 uint32_t QUEUE_PacketCharSplit(QUEUE8_TYPE *pQ8, uint8_t splitChar, uint8_t *pData, uint32_t dataLen)
254 254 {
255 255     int32_t count;
256 256     int32_t index;
257 257     volatile uint8_t *pStart;
258 258     volatile uint8_t *pEnd;
259 259     
260 260     ASSERT_PARAM(pData);
261 261     ASSERT_PARAM(pQ8);
262 262     ASSERT_PARAM(pQ8->pStart);
263 263     ASSERT_PARAM(pQ8->pEnd);
264 264 
265 265     pStart      = pQ8->pStart;
266 266     count       = pQ8->bufSize;
267 267 
268 268     while ((pStart != pQ8->pEnd) && count--)        //查找起始字符
269 269     {
270 270         if (splitChar == *pStart) break;
271 271         if (++pStart >= pQ8->pBuf + pQ8->bufSize) pStart = pQ8->pBuf;
272 272     }
273 273 
274 274     if (pStart == pQ8->pEnd) return 0;              //未找到起始符
275 275     if (count == -1) return 0;
276 276     pEnd = pStart;
277 277     if (++pEnd >= pQ8->pBuf + pQ8->bufSize) pEnd = pQ8->pBuf;
278 278     
279 279     pStart      = pQ8->pStart;
280 280     count       = pQ8->bufSize;
281 281     index       = 0;
282 282     while ((pStart != pEnd) && (index < dataLen) && count--)        //查找起始字符
283 283     {
284 284         pData[index++] = *pStart;
285 285         if (++pStart >= pQ8->pBuf + pQ8->bufSize) pStart = pQ8->pBuf;
286 286     }
287 287     
288 288     pQ8->pStart = pStart;
289 289     return index;
290 290 }
291 291 
292 292 /*******************************************************************************
293 293 * Function Name :QUEUE_PacketDoubleCharSplit
294 294 * Description   :提取双结束分隔符的数据 (包括分隔符)
295 295 * Input         :QUEUE8_TYPE * pQ8
296 296 * Input         :uint8_t splitChar1
297 297 * Input         :uint8_t splitChar2
298 298 * Input         :uint8_t * pData
299 299 * Input         :uint32_t dataLen
300 300 * Output        :uint32_t
301 301 * Other         :
302 302 * Date          :2014/03/27
303 303 *******************************************************************************/
304 304 uint32_t QUEUE_PacketDoubleCharSplit(QUEUE8_TYPE *pQ8, uint8_t splitChar1, uint8_t splitChar2, uint8_t *pData, uint32_t dataLen)
305 305 {
306 306     int32_t count;
307 307     int32_t index;
308 308     volatile uint8_t *pStart;
309 309     volatile uint8_t *pEnd;
310 310     uint8_t lastChar = 0;
311 311 
312 312     ASSERT_PARAM(pData);
313 313     ASSERT_PARAM(pQ8);
314 314     ASSERT_PARAM(pQ8->pStart);
315 315     ASSERT_PARAM(pQ8->pEnd);
316 316 
317 317     pStart      = pQ8->pStart;
318 318     count       = pQ8->bufSize;
319 319 
320 320     while ((pStart != pQ8->pEnd) && count--)        //查找起始字符
321 321     {
322 322         if ((splitChar1 == lastChar) && (splitChar2 == *pStart)) break;
323 323 
324 324         lastChar = *pStart;
325 325 
326 326         if (++pStart >= pQ8->pBuf + pQ8->bufSize) pStart = pQ8->pBuf;
327 327     }
328 328 
329 329     if (pStart == pQ8->pEnd) return 0;              //未找到起始符
330 330     if (count == -1) return 0;
331 331     pEnd = pStart;
332 332     if (++pEnd >= pQ8->pBuf + pQ8->bufSize) pEnd = pQ8->pBuf;
333 333 
334 334     pStart      = pQ8->pStart;
335 335     count       = pQ8->bufSize;
336 336     index       = 0;
337 337     while ((pStart != pEnd) && (index < dataLen) && count--)        //查找起始字符
338 338     {
339 339         pData[index++] = *pStart;
340 340         if (++pStart >= pQ8->pBuf + pQ8->bufSize) pStart = pQ8->pBuf;
341 341     }
342 342 
343 343     pQ8->pStart = pStart;
344 344     return index;
345 345 }
346 346 
347 347 
348 348 /*******************************************************************************
349 349 * Function Name : void ASSERT_FAILED(uint8_t* file, uint32_t line)
350 350 * Description   : 异常
351 351 * Input         : 
352 352 * Output        : 
353 353 * Other         : 
354 354 * Date          : 2013.08.29
355 355 *******************************************************************************/
356 356 void ASSERT_FAILED(uint8_t* file, uint32_t line)
357 357 {
358 358     uint8_t flg = 1;
359 359 
360 360     while (flg);
361 361 }

Queue.c

6165金沙总站 26165金沙总站 9

 1  1 /*
 2  2 ********************************************************************************
 3  3 *
 4  4 *                                 Queue.h
 5  5 *
 6  6 * File          : Queue.h
 7  7 * Version       : V1.0
 8  8 * Author        : whq
 9  9 * Mode          : Thumb2
10 10 * Toolchain     : 
11 11 * Description   : 队列操作头文件
12 12 *                
13 13 * History       :
14 14 * Date          : 2013.07.22
15 15 *******************************************************************************/
16 16 
17 17 
18 18 #ifndef _QUEUE_H_
19 19 #define _QUEUE_H_
20 20 
21 21 #ifdef  __cplusplus
22 22 extern "C"
23 23 {
24 24 #endif
25 25 
26 26 
27 27 
28 28 #include "stdint.h"
29 29 
30 30 #define DEBUG_FULL_ASSERT       0
31 31 
32 32 #ifdef DEBUG_FULL_ASSERT
33 33 #define ASSERT_PARAM(a)          ((a) ? (void)0 : ASSERT_FAILED((uint8_t *)__FILE__, __LINE__))
34 34 void ASSERT_FAILED(uint8_t* file, uint32_t line);
35 35 #else
36 36 #define ASSERT_PARAM(a)           if (a == NULL) return 0;
37 37 #endif
38 38 
39 39 
40 40 
41 41 
42 42 
43 43 typedef struct {
44 44     volatile uint32_t     bufSize;
45 45     volatile uint8_t      *pStart;
46 46     volatile uint8_t      *pEnd;
47 47     volatile uint8_t      *pBuf;
48 48 }QUEUE8_TYPE;
49 49 
50 50 
51 51 
52 52 
53 53 uint32_t QUEUE_PacketCreate(QUEUE8_TYPE *pQ8, uint8_t *pBuf, uint32_t bufSize);
54 54 uint32_t QUEUE_PacketIn(QUEUE8_TYPE *pQ8, uint8_t *pData, uint32_t len);
55 55 uint32_t QUEUE_PacketOut(QUEUE8_TYPE *pQ8, uint8_t *pData, uint32_t dataLen);
56 56 uint32_t QUEUE_PacketSplit(QUEUE8_TYPE *pQ8, uint8_t startChar, uint8_t endChar, uint8_t *pData, uint32_t dataLen);
57 57 uint32_t QUEUE_PacketDoubleByteSplit(QUEUE8_TYPE *pQ8, uint8_t splitChar, uint8_t *pData, uint32_t dataLen);
58 58 uint32_t QUEUE_PacketCharSplit(QUEUE8_TYPE *pQ8, uint8_t splitChar, uint8_t *pData, uint32_t dataLen);
59 59 uint32_t QUEUE_PacketDoubleCharSplit(QUEUE8_TYPE *pQ8, uint8_t splitChar1, uint8_t splitChar2, uint8_t *pData, uint32_t dataLen);
60 60 
61 61 
62 62 #ifdef  __cplusplus
63 63 }
64 64 #endif
65 65 
66 66 #endif

Queue.h

 

You may also like...

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图