修改部分bug，串口做输出接口。

zhyinch

2020-03-25 b32ba27dec812f8233cfddde10f562d8c3366b26

 Ô´Âë/ºËÐÄ°å/Src/OnChipDevices/Usart.c

@@ -1,56 +1,325 @@
#include "Usart.h"
#include <string.h>
#include <stdio.h>

void Usart_Init(void)
{
   USART_InitTypeDef USART_InitStructure;
    GPIO_InitTypeDef GPIO_InitStructure;
	
   /* Enable GPIO clock */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO, ENABLE);
   /* Enable USART clock */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
	
   /* Configure USART Tx as alternate function push-pull */
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Pin = USART_TX_pin;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(USART_GPIO, &GPIO_InitStructure);
//数据发送队列变量
EUART_Frame m_EUART_TxFrames[EUART_TX_FRM_SIZE];   //数据发送帧队列	
volatile int8_t m_EUART_TxFrm_Tail = 0;               //数据发送帧队列尾指针
volatile int8_t m_EUART_TxFrm_Head = 0;               //数据发送帧队列头指针
volatile int8_t m_EUART_TxFrm_FreeFrmLen = 0;         //数据发送帧队列剩余帧数
//DMA数据接收缓存
uint8_t m_EUART_DMA_RXBuf[EUART_RX_BUF_SIZE];         //DMA数据接收缓存
volatile int32_t m_EUART_DMA_RXPtr = 0;               //当前数据地址
//标志变量
volatile uint8_t m_bEUARTPushingFrms = 0;            //正在往发送队列存数据
volatile uint8_t m_bEUARTCheckingSend = 0;            //正在确认数据发送
volatile uint8_t m_bEUARTCheckingRec = 0;            //正在确认接收数据
volatile uint8_t m_bEUARTTxEn = 0;                  //使能发送

    /* Configure USART Rx as input floating */
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_InitStructure.GPIO_Pin = USART_RX_pin;
    GPIO_Init(USART_GPIO, &GPIO_InitStructure);

    /* USARTx configured as follow:
         - BaudRate = 115200 baud
         - Word Length = 8 Bits
         - One Stop Bit
         - No parity
         - Hardware flow control disabled (RTS and CTS signals)
         - Receive and transmit enabled
    */
    USART_InitStructure.USART_BaudRate = BAUD_RATE ;
    USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    USART_InitStructure.USART_StopBits = USART_StopBits_1;
    USART_InitStructure.USART_Parity = USART_Parity_No;
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;

    /* USART configuration */
    USART_Init(EXT_USART, &USART_InitStructure);

    /* Enable USART */
    USART_Cmd(EXT_USART, ENABLE);

void (*Usart1ParseDataCallback)(uint8_t);
void Usart1InitVariables(void)
{	
   m_EUART_TxFrm_FreeFrmLen = EUART_TX_FRM_SIZE-1;
}

uint16_t Checksum_u16(uint8_t *pdata, uint32_t len)
//UART DMA的配置
void UART_DMAConfiguration(void)
{
    uint16_t sum = 0;
    uint32_t i;
    for(i = 0; i < len; i++)
        sum += pdata[i];
    sum = ~sum;
    return sum;
   DMA_InitTypeDef DMA_InitStructure;

   RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
	
   //UART的DMA数据接收初始化
   DMA_DeInit(EUART_RX_DMA_CH);
   DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)( &(EXT_UART->DR));         //外设数据寄存器
   DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)m_EUART_DMA_RXBuf;            //数据Buf
   DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;                     //外设作源头
   DMA_InitStructure.DMA_BufferSize = EUART_RX_BUF_SIZE;                  //Buf大小
   DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;         //外设地址不增加
   DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;                  //内存地址增加
   DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;      //字节
   DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;            //字节（注意与上一个变量名称不同！！）
   DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;                        //循环模式
   DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;                  //优先级
   DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;                        //非内存到内存
   DMA_Init(EUART_RX_DMA_CH, &DMA_InitStructure);
   USART_DMACmd(EXT_UART, USART_DMAReq_Rx, ENABLE);							
   DMA_Cmd(EUART_RX_DMA_CH, ENABLE);			
	
#ifdef EXUART_USE_TXDMA
   //UART的DMA数据发送初始化
   DMA_DeInit(EUART_TX_DMA_CH);
   DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)(&(EXT_UART->DR));         //外设数据寄存器
   DMA_InitStructure.DMA_MemoryBaseAddr = 0;                           //数据Buf
   DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;                     //外设作目标
   DMA_InitStructure.DMA_BufferSize = 0;                              //Buf大小
   DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;         //外设地址寄存器不递增
   DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;                  //内存地址递增
   DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;      //外设字节为单位
   DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;            //内存字节为单位（注意与上一个变量名称不同！！）
   DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;                        //普通模式
   DMA_InitStructure.DMA_Priority = DMA_Priority_High;                     //优先级
   DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;                        //非内存到内存
   DMA_Init(EUART_TX_DMA_CH, &DMA_InitStructure);

//   DMA_ITConfig(EUART_TX_DMA_CH, DMA_IT_TC, ENABLE);                     //DMA传输完成中断
   USART_DMACmd(EXT_UART,USART_DMAReq_Tx,ENABLE);                        //外设使能DMA  // */
#endif						
}

void Uart1_Init(void)
{
   GPIO_InitTypeDef GPIO_InitStructure;
   USART_InitTypeDef USART_InitStructure;
   USART_ClockInitTypeDef USART_ClockInitStructure;
	
   /* Enable GPIO clock */
    RCC_APB2PeriphClockCmd(EU_RCC_GPIO | RCC_APB2Periph_AFIO, ENABLE);
   /* Enable USART clock */
    RCC_APB2PeriphClockCmd(EXT_UART_RCC, ENABLE);
	
   Usart1InitVariables();
	
   //初始化管脚
   GPIO_InitStructure.GPIO_Pin = EU_RX_PIN;
   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                     //Rx上拉输入
   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   GPIO_Init(EU_RX_GPIO, &GPIO_InitStructure);
	
   GPIO_InitStructure.GPIO_Pin = EU_TX_PIN;
   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;                     //Tx推挽复用输出 GPIO_Mode_AF_PP
   GPIO_Init(EU_TX_GPIO, &GPIO_InitStructure);
	
   GPIO_InitStructure.GPIO_Pin = EU_485_PIN;
   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                     //Tx推挽复用输出 GPIO_Mode_AF_PP
   GPIO_Init(EU_485_GPIO, &GPIO_InitStructure);
   OUT485_DISABLE;
#ifdef UART_GPIO_REMAP_ENABLE
   GPIO_PinRemapConfig(UART_GPIO_REMAP, ENABLE);
#endif
	
   USART_DeInit(EXT_UART);
   USART_InitStructure.USART_BaudRate = EXUART_BAUD_RADE;
   USART_InitStructure.USART_WordLength = USART_WordLength_8b;
   USART_InitStructure.USART_StopBits = USART_StopBits_1;
   USART_InitStructure.USART_Parity = USART_Parity_No;
   USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
   USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
		
   USART_ClockInitStructure.USART_Clock = USART_Clock_Disable;
   USART_ClockInitStructure.USART_CPOL = USART_CPOL_Low;
   USART_ClockInitStructure.USART_CPHA = USART_CPHA_2Edge;
   USART_ClockInitStructure.USART_LastBit = USART_LastBit_Disable;
	
   USART_ClockInit(EXT_UART, &USART_ClockInitStructure);
   USART_Init(EXT_UART, &USART_InitStructure);
//   USART_ITConfig(EXT_UART, USART_IT_RXNE, ENABLE);//??????,????? ??????????
   // Enable the USARTx 
   USART_Cmd(EXT_UART, ENABLE); 
   //DMA配置（须放到UART初始化之后）
   UART_DMAConfiguration();
	
}

void UART_CheckReceive(void)
{
   int32_t DMACnt = 0;
   int32_t MaxDataLen = EUART_RX_BUF_SIZE;	
	
   //如果正在往发送队列中添加数据，退出
   if(m_bEUARTPushingFrms)
      return;
   //判断是否正在Check
   if(m_bEUARTCheckingRec)
      return;
   m_bEUARTCheckingRec = 1;
   if(EUART_RX_DMA_CH->CNDTR == 0)
   {
      m_bEUARTCheckingRec = 0;
      return;
   }
   DMACnt = EUART_RX_BUF_SIZE - (EUART_RX_DMA_CH->CNDTR);
   while( m_EUART_DMA_RXPtr != DMACnt && MaxDataLen > 0)
   {
      Usart1ParseDataCallback(m_EUART_DMA_RXBuf[m_EUART_DMA_RXPtr]);
      delay_us(10);
      m_EUART_DMA_RXPtr++;
      if( m_EUART_DMA_RXPtr >= EUART_RX_BUF_SIZE )
      {
         m_EUART_DMA_RXPtr = 0;
      }
      DMACnt = EUART_RX_BUF_SIZE - (EUART_RX_DMA_CH->CNDTR);
      MaxDataLen--;
   }
   m_bEUARTCheckingRec = 0;	
}


#ifndef EXUART_USE_TXDMA							
//查询方式发送数据
void UART_CheckSend(void)
{
   static int32_t s_count = 0;
//   uint32_t temp32 = 0;

   if(m_bEUARTPushingFrms || m_bEUARTCheckingSend)
      return;
   m_bEUARTCheckingSend = 1;

   //判断队列是否为空以及DMA是否空闲
   if ((EXT_UART->SR & USART_FLAG_TXE) == (uint16_t)RESET)   //上次发送未完成
   {
      m_bEUARTCheckingSend = 0;
      return;
   }
	
   if(m_EUART_TxFrm_Head == m_EUART_TxFrm_Tail)               //队列为空
   {
      if((EXT_UART->SR & USART_FLAG_TC) != (uint16_t)RESET)       //发送完毕
      {
         if(m_bEUARTTxEn)
         {
            OUT485_DISABLE;
            m_bEUARTTxEn = 0;
//            temp32 = GPIOC->CRH;         //C10悬空输入
//            temp32 &= ~(0x00000000F<<8);		
//            temp32 |= (0x000000004<<8);
//            GPIOC->CRH = temp32;// */
         }
      }
      m_bEUARTCheckingSend = 0;
      return;
   }
	
   if(!m_bEUARTTxEn)
   {
      m_bEUARTTxEn = 1;
       OUT485_ENABLE;
      delay_us(10);
//      temp32 = GPIOC->CRH;         //C10复用推挽输出
//      temp32 &= ~(0x00000000F<<8);
//      temp32 |= (0x000000009<<8);
//      GPIOC->CRH = temp32;// */
   }
	
   //发送一个字节数据
   EXT_UART->DR = m_EUART_TxFrames[m_EUART_TxFrm_Tail].buf[s_count];		
   s_count++;
   if(s_count >= m_EUART_TxFrames[m_EUART_TxFrm_Tail].len)      //一帧数据发送完毕
   {
      s_count = 0;
      m_EUART_TxFrm_Tail++;
      if(m_EUART_TxFrm_Tail == EUART_TX_FRM_SIZE)
         m_EUART_TxFrm_Tail = 0;
      m_EUART_TxFrm_FreeFrmLen++;
   }
   m_bEUARTCheckingSend = 0;
 }         // */

#else
 /*
//检查是否数据帧需要发送
void UART_CheckSend(void)
{
   //判断是否正在Check
   if(m_bEUARTPushingFrms || m_bEUARTCheckingSend)
      return;
   m_bEUARTCheckingSend = 1;

   //判断DMA通道是否正在工作
   if((EUART_TX_DMA_CH->CCR & 0x01) != 0)   //通道正在工作
   {
      if((EUART_DMA->ISR & EUART_TX_DMA_IT_TC) == (uint32_t)RESET)    //传输未完成
      {
         m_bEUARTCheckingSend = 0;
         return;
      }
      else
      {
         EUART_DMA->IFCR = EUART_TX_DMA_IT_TC;            //清除标志（注意寄存器和标志名称）
         EUART_TX_DMA_CH->CCR &= ~((uint32_t)0x01);   //禁用DMA
      }
   }
	
   //判断队列是否为空
   if(m_EUART_TxFrm_Head == m_EUART_TxFrm_Tail)
   {
      m_bEUARTCheckingSend = 0;
      return;
   }
	
   //开启一次数据发送
   EUART_TX_DMA_CH->CMAR = (uint32_t)m_EUART_TxFrames[m_EUART_TxFrm_Tail].buf;   //要发送的内存地址 
   EUART_TX_DMA_CH->CNDTR = m_EUART_TxFrames[m_EUART_TxFrm_Tail].len;      //要发送的字节数
   EUART_TX_DMA_CH->CCR |= 0x01;                                 //开启一次DMA  
   m_EUART_TxFrm_Tail++;
   if(m_EUART_TxFrm_Tail == EUART_TX_FRM_SIZE)
      m_EUART_TxFrm_Tail = 0;	
   m_EUART_TxFrm_FreeFrmLen++;
   m_bEUARTCheckingSend = 0;	 
}               // */	
#endif


//将一帧数据压入发送队列
void UART_PushFrame(uint8_t* pdata, int32_t data_len)
{
//   uint8_t temp8 = 0;
   if(m_bEUARTPushingFrms || m_bEUARTCheckingSend)
      return;
   m_bEUARTPushingFrms = 1;
	
   if(data_len > EUART_TX_FRMBUF_SIZE || m_EUART_TxFrm_FreeFrmLen <= 0)      //帧长度超范围或缓存已满
   {
      m_bEUARTPushingFrms = 0;
      return;
   }

   //将要发送的数据帧压入队列
   m_EUART_TxFrames[m_EUART_TxFrm_Head].len = data_len;
   memcpy((uint8_t*)m_EUART_TxFrames[m_EUART_TxFrm_Head].buf, (uint8_t*)pdata, data_len);
   m_EUART_TxFrm_Head++;
   if(m_EUART_TxFrm_Head == EUART_TX_FRM_SIZE)
      m_EUART_TxFrm_Head = 0;
   m_EUART_TxFrm_FreeFrmLen--;
   m_bEUARTPushingFrms = 0;	
}

//将最新一帧数据Pop出队列
void UART_PopFrame(void)
{
   if(m_bEUARTPushingFrms || m_bEUARTCheckingSend)
      return;
   if(m_EUART_TxFrm_FreeFrmLen >= EUART_TX_FRM_SIZE-1)
      return;
   m_EUART_TxFrm_Head--;
   if(m_EUART_TxFrm_Head < 0)
      m_EUART_TxFrm_Head = EUART_TX_FRM_SIZE-1;
   m_EUART_TxFrm_FreeFrmLen++;
}
void USART_putc(char c)
{
   //while(!(USART2->SR & 0x00000040));
   //USART_SendData(USART2,c);
   /* e.g. write a character to the USART */
   USART_SendData(USART1, c);

   /* Loop until the end of transmission */
   while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET)   ;
}
void USART_puts(uint8_t *s,uint8_t len)
{
   int i;
   for(i=0; i<len; i++)
   {
      USART_putc(s[i]);
   }
}
int fputc(int ch, FILE *f)
{
	
   USART_SendData(USART1, (unsigned char) ch);// USART1 ???? USART2 ?
   while (!(USART1->SR & USART_FLAG_TXE));
   return (ch);
}