motor_ctl-1/4.BasicHardwSoftwLayer/2.BasicSoftwLayer/Source/queue.c

/************************************************************************
 Project:             Welling Motor Control Paltform
 Filename:            queue.c
 Partner Filename:    queue.h
 Description:         The math function
 Complier:            IAR Embedded Workbench for ARM 7.80, IAR Systems.
 CPU TYPE :           GD32F3x0
*************************************************************************
 Copyright (c) 2018 Welling Motor Technology(Shanghai) Co. Ltd.
 All rights reserved.
*************************************************************************
*************************************************************************
Revising History (ECL of this file):

************************************************************************/

/************************************************************************
 Beginning of File, do not put anything above here except notes
 Compiler Directives:
*************************************************************************/
#ifndef _QUEUE_C_
#define _QUEUE_C_
#endif

/************************************************************************
 Included File:
*************************************************************************/
#include "queue.h"
#include "string.h"
#include "typedefine.h"
/******************************************************************************************************************************************************
**  \brief parameter
******************************************************************************************************************************************************/
ERROR_LOG         que_stErrorLog;
FLASH_ERROR_QUEUE que_stFlashErrorLog;
/******************************************************************************************************************************************************
**  \brief
******************************************************************************************************************************************************/
void que_voInit(FLASH_ERROR_QUEUE *Q)
{
    Q->ubHead = 0;
    Q->ubRear = 0;
    memset(Q->stLog, 0xFFFFFFFF, sizeof(ERROR_LOG) * QUEUE_SIZE);
}
/******************************************************************************************************************************************************
**  \brief
******************************************************************************************************************************************************/
static BOOL que_fgEmpty(const FLASH_ERROR_QUEUE *Q)
{
    BOOL ret = FALSE;
    if (Q->ubHead == Q->ubRear)
    {
        ret = TRUE;
    }
    return ret;
}
/******************************************************************************************************************************************************
**  \brief
**  \return
******************************************************************************************************************************************************/
static BOOL que_fgFull(const FLASH_ERROR_QUEUE *Q)
{
    BOOL ret = FALSE;
    if (((Q->ubHead - Q->ubRear) + QUEUE_SIZE) % QUEUE_SIZE == 1)
    {
        ret = TRUE;
    }
    return ret;
}
/******************************************************************************************************************************************************
**  \brief
******************************************************************************************************************************************************/
static UBYTE que_voEnter(FLASH_ERROR_QUEUE *Q, ERROR_LOG x)
{
    memcpy(&(Q->stLog[Q->ubRear]), &x, sizeof(ERROR_LOG));
    que_ubIndexIncrease(Q, &(Q->stLog[Q->ubRear].ErrorIndex));
    Q->ubRear = (Q->ubRear + 1) % QUEUE_SIZE;
    if (que_fgFull(Q) != FALSE) //队列满，覆盖队头数据
    {
        Q->ubHead = (Q->ubHead + 1) % QUEUE_SIZE;
        return (UBYTE)0;
    }
    else
    {
        return (UBYTE)1;
    }
}
/******************************************************************************************************************************************************
**  \brief
**  \return if queue is empty return 0 ,if not return 1
******************************************************************************************************************************************************/
static UBYTE que_voDelete(FLASH_ERROR_QUEUE *Q, ERROR_LOG *dat)
{
    if (que_fgEmpty(Q) != FALSE)
    {
        return (UBYTE)0;
    }

    *dat = Q->stLog[Q->ubHead];
    Q->ubHead = (Q->ubHead + 1) % QUEUE_SIZE;
    return (UBYTE)1;
}
/******************************************************************************************************************************************************
**  \brief
******************************************************************************************************************************************************/
UBYTE que_ubPushIn(FLASH_ERROR_QUEUE *Q, const ERROR_LOG *rxdata, UBYTE length)
{
    for (UBYTE i = 0; i < length; i++)
    {
        que_voEnter(Q, *rxdata);
        rxdata++;
    }

    return (UBYTE)1;
}
/******************************************************************************************************************************************************
**  \brief Variable Defination
******************************************************************************************************************************************************/
UBYTE que_ubPopOut(FLASH_ERROR_QUEUE *Q, ERROR_LOG buf[], UBYTE length)
{
    if (que_fgEmpty(Q) != FALSE)
    {
        return (UBYTE)0;
    }

    for (UBYTE i = 0; i < length; i++)
    {
        que_voDelete(Q, &buf[i]);
    }

    return (UBYTE)1;
}
/******************************************************************************************************************************************************
**  \brief
******************************************************************************************************************************************************/
void que_ubIndexIncrease(FLASH_ERROR_QUEUE *Q, UWORD* ErrorIndex)
{
    UBYTE i;
    UWORD Temp16;
    UWORD Index_pre = 0;

    for(i=0; i< QUEUE_SIZE; i++)
    {
        Temp16 = Q->stLog[i].ErrorIndex;
        if(Temp16 == 0xFFFF)
        {
            //确定当前故障的序列号
            if(i == 0)
            {
                *ErrorIndex = 1;
            }
            else
            {
                *ErrorIndex  = Q->stLog[i-1].ErrorIndex + 1;
            }
            return ;
        }
        else if(Index_pre > Temp16)
        {
            *ErrorIndex = Index_pre + 1;
            return ;
        }
        else
        {
            Index_pre = Temp16;
        }
    }
    *ErrorIndex = Index_pre + 1;
}
/******************************************************************************************************************************************************
 ** @brief
 ** @param[in]
 ** @Param[out]
 ** @returns
 ******************************************************************************************************************************************************/

/******************************************************************************************************************************************************
**  end of file
******************************************************************************************************************************************************/