1

zhyinch

2021-04-06 246d94e2de20b12287f48f40b750697c33222c91

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

@@ -1,62 +1,8 @@
#include "Usart.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);

//    /* 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);

//}

//uint16_t Checksum_u16(uint8_t *pdata, uint32_t len)
//{
//    uint16_t sum = 0;
//    uint32_t i;
//    for(i = 0; i < len; i++)
//        sum += pdata[i];
//    sum = ~sum;
//    return sum;
//}



///////////////////////////////////
#include <string.h>
#include <stdio.h>
#include "modbus.h"
#include "Rcc_Nvic_Systick.h"

//数据发送队列变量
EUART_Frame m_EUART_TxFrames[EUART_TX_FRM_SIZE];   //数据发送帧队列   
@@ -66,6 +12,8 @@
//DMA数据接收缓存
uint8_t m_EUART_DMA_RXBuf[EUART_RX_BUF_SIZE];         //DMA数据接收缓存
volatile int32_t m_EUART_DMA_RXPtr = 0;               //当前数据地址
int16_t DMA_rxtemp = 0,DMA_rxtemp2 = 0;                                             //当前数据地址缓存
u16 datadelaycount = 0;                                       //剩余1位数据延时等待处理
//标志变量
volatile uint8_t m_bEUARTPushingFrms = 0;            //正在往发送队列存数据
volatile uint8_t m_bEUARTCheckingSend = 0;            //正在确认数据发送
@@ -73,7 +21,6 @@
volatile uint8_t m_bEUARTTxEn = 0;                  //使能发送

void (*Usart1ParseDataCallback)(uint8_t);

void Usart1InitVariables(void)
{   
   m_EUART_TxFrm_FreeFrmLen = EUART_TX_FRM_SIZE-1;
@@ -139,14 +86,18 @@
   
   //初始化管脚
   GPIO_InitStructure.GPIO_Pin = EU_RX_PIN;
   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;                     //Rx上拉输入
   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;                     //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_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
@@ -166,19 +117,23 @@
   
   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();
   
}

u8 overrun_flag=0;
u16 t1,t2,t3,t4;
void UART_CheckReceive(void)
{
   int32_t DMACnt = 0;
   int32_t MaxDataLen = EUART_RX_BUF_SIZE;   
	
   u8 rxbuf_len = 0;
   u8 buftemp1 = 0;
   u8 buftemp2 = 0;
   u8 i = 0;
   //如果正在往发送队列中添加数据，退出
   if(m_bEUARTPushingFrms)
      return;
@@ -191,21 +146,128 @@
      m_bEUARTCheckingRec = 0;
      return;
   }
   DMACnt = EUART_RX_BUF_SIZE - (EUART_RX_DMA_CH->CNDTR);
   while( m_EUART_DMA_RXPtr != DMACnt && MaxDataLen > 0)
	
   DMACnt = EUART_RX_BUF_SIZE - (EUART_RX_DMA_CH->CNDTR);//DMACnt是DMA通道接收到数据总长度,CNDTR是dma剩余未使用数量
	
   if(DMACnt!=m_EUART_DMA_RXPtr)
   {
      Usart1ParseDataCallback(m_EUART_DMA_RXBuf[m_EUART_DMA_RXPtr]);
      m_EUART_DMA_RXPtr++;
      if( m_EUART_DMA_RXPtr >= EUART_RX_BUF_SIZE )
      //DMA有未处理数据
      DMA_rxtemp=m_EUART_DMA_RXPtr+1;
      delay_us(10);
      overrun_flag=0;
      if( DMA_rxtemp >= EUART_RX_BUF_SIZE )
      {
         m_EUART_DMA_RXPtr = 0;
         DMA_rxtemp = 0;
      }
      DMACnt = EUART_RX_BUF_SIZE - (EUART_RX_DMA_CH->CNDTR);
      MaxDataLen--;
   }
   m_bEUARTCheckingRec = 0;	
}
      DMACnt = EUART_RX_BUF_SIZE - (EUART_RX_DMA_CH->CNDTR);//DMACnt是DMA通道接收到数据总长度,CNDTR是dma剩余未使用数量
      if(DMACnt!=DMA_rxtemp&&(cmd_mode==0))
      {
         //DMA有超过2位数据未处理
         DMA_rxtemp = 0;//清空数组指针
         datadelaycount = 0;//等待次数清零
         buftemp1 = m_EUART_DMA_RXBuf[m_EUART_DMA_RXPtr];
         buftemp2 = m_EUART_DMA_RXBuf[m_EUART_DMA_RXPtr+1];
         if((buftemp1==0x55)&&(buftemp2==0xAA))
         {
            //私有协议
            cmd_mode = 1;
         }
         else if(buftemp1==RS485_Addr)
         {
            if((buftemp2==03)||(buftemp2==06)||(buftemp2==16))//功能码正确
            {
               //modubs协议
               t1++;
               cmd_mode=2;
               DMA_rxtemp2=m_EUART_DMA_RXPtr+7;
               if( DMA_rxtemp2 >= EUART_RX_BUF_SIZE-1 )
                  {
                     DMA_rxtemp2 -= EUART_RX_BUF_SIZE;
                     overrun_flag=1;
                  }
            }
            else
            {
               m_EUART_DMA_RXPtr+=2;
               if( m_EUART_DMA_RXPtr >= EUART_RX_BUF_SIZE )
               {
                  m_EUART_DMA_RXPtr = 0;
               }					
            }
         }
         else
         {
            //无效码，干扰码
            if(cmd_mode==0)
            {
                  m_EUART_DMA_RXPtr+=2;
                  if( m_EUART_DMA_RXPtr >= EUART_RX_BUF_SIZE )
                  {
                     m_EUART_DMA_RXPtr = 0;
                  }
             }
          }			
      }
      else
      {
         //只有1位数据未处理
            if(++datadelaycount > WAITDELAYCOUNT)
            {   //超出等待次数
               datadelaycount = 0;
               cmd_mode=0;
               m_EUART_DMA_RXPtr++;
               if( m_EUART_DMA_RXPtr >= EUART_RX_BUF_SIZE )
               {
                  m_EUART_DMA_RXPtr = 0;
               }					
            }
      }
      if(cmd_mode==1)
      {
         //私有协议
         while( m_EUART_DMA_RXPtr != DMACnt && MaxDataLen > 0)
         {	
            Usart1ParseDataCallback(m_EUART_DMA_RXBuf[m_EUART_DMA_RXPtr]);
            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--;	
         }
      }		
      else if(cmd_mode==2)
      {
         //modbus协议
         delay_ms(10);//等待数据接收完成
         DMACnt = EUART_RX_BUF_SIZE - (EUART_RX_DMA_CH->CNDTR);	
      if((overrun_flag==0&&DMACnt>DMA_rxtemp2)||(overrun_flag==1&&DMACnt<DMA_rxtemp&&DMACnt>DMA_rxtemp2))			
      {   while(m_EUART_DMA_RXPtr != DMACnt && MaxDataLen > 0)
         {
            RS485_RX_BUFF[i] = m_EUART_DMA_RXBuf[m_EUART_DMA_RXPtr];
            m_EUART_DMA_RXPtr++;
            if(++i >= EUART_RX_BUF_SIZE)i = 0;
            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_EUART_DMA_RXPtr++;//数据指向下一位
//         if( m_EUART_DMA_RXPtr >= EUART_RX_BUF_SIZE )
//         {
//            m_EUART_DMA_RXPtr = 0;
//         }
         t2++;
            RS485_Service();	
      }			
         }				
      }

   m_bEUARTCheckingRec = 0;
}

#ifndef EXUART_USE_TXDMA                     
//查询方式发送数据
@@ -231,7 +293,9 @@
      {
         if(m_bEUARTTxEn)
         {
            OUT485_DISABLE;
            m_bEUARTTxEn = 0;
            t3++;
//            temp32 = GPIOC->CRH;         //C10悬空输入
//            temp32 &= ~(0x00000000F<<8);      
//            temp32 |= (0x000000004<<8);
@@ -241,14 +305,23 @@
      m_bEUARTCheckingSend = 0;
      return;
   }
	
   if(!m_bEUARTTxEn)
   {
      m_bEUARTTxEn = 1;
       OUT485_ENABLE;
      t4++;
      #ifdef BAUDRATE_19200
      delay_us(500);
      #else
      delay_us(10);
      #endif
//      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++;
@@ -344,4 +417,29 @@
      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);
}