初步测试完成

zhyinch

2021-12-23 85cdaac35f9db30b91f45ead0d78c2c0ee3220cb

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

@@ -1,9 +1,10 @@
#include "Usart.h"
#include <string.h>
#include <stdarg.h>
#include <stdio.h>
#include "modbus.h"
#include "Rcc_Nvic_Systick.h"

#include "global_param.h"
//数据发送队列变量
EUART_Frame m_EUART_TxFrames[EUART_TX_FRM_SIZE];   //数据发送帧队列   
volatile int8_t m_EUART_TxFrm_Tail = 0;               //数据发送帧队列尾指针
@@ -12,7 +13,7 @@
//DMA数据接收缓存
uint8_t m_EUART_DMA_RXBuf[EUART_RX_BUF_SIZE];         //DMA数据接收缓存
volatile int32_t m_EUART_DMA_RXPtr = 0;               //当前数据地址
u16 DMA_rxtemp = 0;                                             //当前数据地址缓存
int16_t DMA_rxtemp = 0,DMA_rxtemp2 = 0;                                             //当前数据地址缓存
u16 datadelaycount = 0;                                       //剩余1位数据延时等待处理
//标志变量
volatile uint8_t m_bEUARTPushingFrms = 0;            //正在往发送队列存数据
@@ -25,7 +26,20 @@
{   
   m_EUART_TxFrm_FreeFrmLen = EUART_TX_FRM_SIZE-1;
}
 HIDO_DataStruct stPosState[4];
HIDO_INT32 GPS_ParseGGA(HIDO_CHAR *_pcData, HIDO_UINT32 _u32Len)
{

    if (HIDO_UtilParseFormat((HIDO_UINT8 *) _pcData, _u32Len, "$%*,%*,%p,%*,%p,%*,%p,%*,%*,%p,%*,%*,%*,%*,%**",
         &stPosState[0], &stPosState[1], &stPosState[2], &stPosState[3]) != 15)
    {
        return HIDO_ERR;
    }

    //l_u8PosState = atoi((HIDO_CHAR *)stPosState.m_pData);

    return HIDO_OK;
}
//UART DMA的配置
void UART_DMAConfiguration(void)
{
@@ -86,7 +100,7 @@
   
   //初始化管脚
   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);
   
@@ -124,15 +138,17 @@
   UART_DMAConfiguration();
   
}

u8 overrun_flag=0,receiveingdata_flag,gpsdataready_flag,waitggaend_flag,ggaend_idx;
u8 RTCMdata[2000];
u32 lastusartdata_timer;
u16 rtcm_i,gps_packlen;
u16 t1,t2,t3,t4;
extern volatile uint32_t time32_incr;
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;
@@ -145,115 +161,42 @@
      m_bEUARTCheckingRec = 0;
      return;
   }
	
   DMACnt = EUART_RX_BUF_SIZE - (EUART_RX_DMA_CH->CNDTR);//DMACnt是DMA通道接收到数据总长度,CNDTR是dma剩余未使用数量
	
   if(DMACnt!=m_EUART_DMA_RXPtr)
   if(time32_incr-lastusartdata_timer>300&&receiveingdata_flag)
   {
      //DMA有未处理数据
      DMA_rxtemp=m_EUART_DMA_RXPtr;
      DMA_rxtemp++;
      if( DMA_rxtemp >= EUART_RX_BUF_SIZE )
      gpsdataready_flag = 1;
      receiveingdata_flag = 0;
      gps_packlen = rtcm_i;
      rtcm_i = 0;
      t1++;
      waitggaend_flag = 1;
      if(g_com_map[DEV_ROLE])
      {
         DMA_rxtemp = 0;
         UWBSendOnePackData(RTCMdata,gps_packlen);
         gpsdataready_flag = 0;
      }
      DMACnt = EUART_RX_BUF_SIZE - (EUART_RX_DMA_CH->CNDTR);//DMACnt是DMA通道接收到数据总长度,CNDTR是dma剩余未使用数量
      if(DMACnt!=DMA_rxtemp)
   }
   DMACnt = EUART_RX_BUF_SIZE - (EUART_RX_DMA_CH->CNDTR);
   while( m_EUART_DMA_RXPtr != DMACnt && MaxDataLen > 0)
   {
      receiveingdata_flag = 1;
      lastusartdata_timer = time32_incr;
      //Usart1ParseDataCallback(m_EUART_DMA_RXBuf[m_EUART_DMA_RXPtr]);
      RTCMdata[rtcm_i++] = m_EUART_DMA_RXBuf[m_EUART_DMA_RXPtr];
//      if(waitggaend_flag&&m_EUART_DMA_RXBuf[m_EUART_DMA_RXPtr]=='*')
//      {
//         waitggaend_flag = 0;
//         ggaend_idx = rtcm_i;
//      }
      //delay_us(10);
      m_EUART_DMA_RXPtr++;
      if( m_EUART_DMA_RXPtr >= EUART_RX_BUF_SIZE )
      {
         //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==0))
         {
            //私有协议
            cmd_mode = 1;
         }
         else if((buftemp1==RS485_Addr)&&(cmd_mode==0))
         {
            if((buftemp2==03)||(buftemp2==06)||(buftemp2==16))//功能码正确
            {
               //modubs协议
               cmd_mode=2;
            }
            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;
                  }
             }
          }			
         m_EUART_DMA_RXPtr = 0;
      }
      else
      {
         //只有1位数据未处理
            if(++datadelaycount > WAITDELAYCOUNT)
            {   //超出等待次数
               datadelaycount = 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(1);//等待数据接收完成
         DMACnt = EUART_RX_BUF_SIZE - (EUART_RX_DMA_CH->CNDTR);		
         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;
//         }
            RS485_Service();				
         }				
      }

   m_bEUARTCheckingRec = 0;
      DMACnt = EUART_RX_BUF_SIZE - (EUART_RX_DMA_CH->CNDTR);
      MaxDataLen--;
   }
   m_bEUARTCheckingRec = 0;	
}

#ifndef EXUART_USE_TXDMA                     
@@ -282,6 +225,7 @@
         {
            OUT485_DISABLE;
            m_bEUARTTxEn = 0;
            t3++;
//            temp32 = GPIOC->CRH;         //C10悬空输入
//            temp32 &= ~(0x00000000F<<8);      
//            temp32 |= (0x000000004<<8);
@@ -296,7 +240,12 @@
   {
      m_bEUARTTxEn = 1;
       OUT485_ENABLE;
      delay_us(1000);
      t4++;
      #ifdef BAUDRATE_19200
      delay_us(500);
      #else
      delay_us(10);
      #endif
//      temp32 = GPIOC->CRH;         //C10复用推挽输出
//      temp32 &= ~(0x00000000F<<8);
//      temp32 |= (0x000000009<<8);
@@ -424,3 +373,222 @@
   return (ch);
}

HIDO_UINT32 HIDO_UtilParseFormat(HIDO_UINT8 *_pu8Src, HIDO_UINT32 _u32SrcLen, const HIDO_CHAR *_pcFmt, ...)
{
    va_list sArgPtr = { NULL };
    int nParseNum = 0;
    HIDO_CHAR cSign = ' ';
    HIDO_BOOL bReturn = HIDO_FALSE;

    if((NULL == _pu8Src) || (NULL == _pcFmt))
    {
        return 0;
    }

    va_start(sArgPtr, _pcFmt);

    while ((*_pcFmt) != '\0')
    {
        if(0 == _u32SrcLen)
        {
            if(!(('%' == *_pcFmt) && ('e' == *(_pcFmt + 1))))
            {
                break;
            }
        }

        if ((*_pcFmt) == '%')
        {
            _pcFmt++;
            cSign = *(_pcFmt++);

            switch (cSign)
            {
            case '*':
            {
                while (_u32SrcLen)
                {
                    if (*_pu8Src != *_pcFmt)
                    {
                        _pu8Src++;
                        _u32SrcLen--;
                    }
                    else
                    {
                        break;
                    }
                }

                nParseNum++;

                break;
            }
            case 'd':
            {
                HIDO_BOOL bNeg = HIDO_FALSE;
                HIDO_BOOL bBeg = HIDO_FALSE;

                HIDO_UINT32 nResult = 0;
                int *pInt = NULL;
                HIDO_CHAR c = ' ';

                pInt = va_arg(sArgPtr, INT32_PTR);

                while (_u32SrcLen)
                {
                    c = *_pu8Src;

                    if ((HIDO_FALSE == bBeg) && c == '-')
                    {
                        bNeg = HIDO_TRUE;
                        bBeg = HIDO_TRUE;
                    }
                    else if ((c >= '0') && (c <= '9'))
                    {
                        bBeg = HIDO_TRUE;
                        nResult = nResult * 10 + (c - '0');
                    }
                    else
                    {
                        break;
                    }

                    _pu8Src++;
                    _u32SrcLen--;
                }

                if (HIDO_TRUE == bNeg)
                {
                    nResult = (~nResult) + 1;
                }

                if (NULL != pInt)
                {
                    *pInt = nResult;
                }

                nParseNum++;

                break;
            }
            case 'x':
            {
                HIDO_UINT32 nResult = 0;
                HIDO_UINT32 *pUint = NULL;
                HIDO_CHAR c;

                pUint = va_arg(sArgPtr, UINT32_PTR);

                while (_u32SrcLen)
                {
                    c = *_pu8Src;

                    if ((c >= '0') && (c <= '9'))
                    {
                        nResult = (nResult << 4) + (c - '0');
                    }
                    else if ((c >= 'a') && (c <= 'f'))
                    {
                        nResult = (nResult << 4) + (c - 'a' + 0x0A);
                    }
                    else if ((c >= 'A') && (c <= 'F'))
                    {
                        nResult = (nResult << 4) + (c - 'A' + 0x0A);
                    }
                    else
                    {
                        break;
                    }

                    _pu8Src++;
                    _u32SrcLen--;
                }

                if (NULL != pUint)
                {
                    *pUint = nResult;
                }

                nParseNum++;

                break;
            }
            case 'p':
            {
                HIDO_DataStruct *pDptr = va_arg(sArgPtr, DATA_PTR);
                HIDO_UINT8 *pStart = NULL;
                HIDO_UINT32 nCount = 0;

                pStart = _pu8Src;

                while (_u32SrcLen)
                {
                    if (*_pu8Src != *_pcFmt)
                    {
                        nCount++;
                    }
                    else
                    {
                        break;
                    }

                    _pu8Src++;
                    _u32SrcLen--;
                }

                if(NULL != pDptr)
                {
                    pDptr->m_pData = pStart;
                    pDptr->m_u32Len = nCount;
                }

                nParseNum++;

                break;
            }
            case 'e':
            {
                HIDO_UINT8 **ppPtr = va_arg(sArgPtr, U8_PTR_PTR);

                if (ppPtr)
                {
                    *ppPtr = _pu8Src;
                }

                nParseNum++;
                bReturn = HIDO_TRUE;

                break;
            }
            default:
            {
                bReturn = HIDO_TRUE;
                nParseNum = 0;

                break;
            }
            }

            if(HIDO_TRUE == bReturn)
            {
                break;
            }
        }
        else if (*_pu8Src == *_pcFmt)
        {
            _pu8Src++;
            _pcFmt++;
            _u32SrcLen--;
        }
        else
        {
            nParseNum = 0;

            break;
        }
    }

    va_end(sArgPtr);

    return nParseNum;
}