motor_ctl-4/tests/unit_test/test_bikespeed.cpp

#include "gtest/gtest.h"
#include <gtest/gtest.h>
#include <tuple>
#include "scope.h"
#include "test_user.h"

class BikeSpeedTest : public testing::Test
{
protected:
    static void SetUpTestSuite()
    {
        

    }
    virtual void SetUp() override
    {
        iRt_Init();
        iCap_BindDeviceInterrupt(0,IC_CountMaxISR);
        iCap_EnableDeviceInterrupt(0);
        iCap_BindChannelInterrupt(0,CAP_CH(3),IC_BikeSpdISR);
        iCap_EnableChannelInterrupt(0,CAP_CH(3));
        iCap_BindChannelInterrupt(0,CAP_CH(2),IC_CadenceISR);
        iCap_EnableChannelInterrupt(0,CAP_CH(2));

        cadence_voCadenceInit();
        bikespeed_voBikeSpeedInit();
    }
    virtual void TearDown() override
    {
    
    }
};

class BikeSpeedTest1 : public BikeSpeedTest, public testing::WithParamInterface<int>
{};

TEST_P(BikeSpeedTest1, FreCal)
{
    /* Coef Cal */
    bikespeed_voBikeSpeedCof();
    bikespeed_stFreGetCof.uwNumbersPulses = BIKESPEED_NUMBERS_PULSES;

    int timerPrd = TIM1CLK_KHZ * 1000 / (1000 / 25);  // cnt = 18000, same as STM32
    int timerCnt = 0;
    int bikeSpeedSignal = 0, bikeSpeedCnt = 0, bikeSpeedSignalLast = 0;
    int bikeSpeedPrd = GetParam();
    int capValue = 0; 

    /* BikeSpeed Freq Cal */
    int j = 0;
    for(int i = 0; i < 100000000; i++)
    {  
        /* Input BikeSpeed Signal */
        bikeSpeedCnt++;
        if(bikeSpeedCnt <= (bikeSpeedPrd/10))   // 10% duty
        {
            bikeSpeedSignal = 0;
        }
        else 
        {
            bikeSpeedSignal = 1;
            if(bikeSpeedPrd == 18000 && j == 0)
            {
                if(bikeSpeedCnt >= bikeSpeedPrd - 1)
                {
                    bikeSpeedCnt = 0;
                    j = 1;  
                }                                
            }
            else 
            {
                if(bikeSpeedCnt >= bikeSpeedPrd)
                {
                    bikeSpeedCnt = 0;
                }
            }
        }
        
        /* Timer */
        timerCnt ++ ;
        if(timerCnt >= timerPrd)
        {
            timerCnt = 0;
            testTimerIntFlg[TIMER1][TIMER_INT_FLAG_UP] = 1;
        }

        /* Capture: rising edge trigger*/
        if(bikeSpeedSignal - bikeSpeedSignalLast == -1)    
        {
            testCh3CapValue[TIMER1] = timerCnt;
            testTimerIntFlg[TIMER1][TIMER_INT_FLAG_CH3] = 1;
        }
        bikeSpeedSignalLast = bikeSpeedSignal;

        /* Interrupt: update and capture */       
        if(testTimerIntFlg[TIMER1][TIMER_INT_FLAG_UP])  
        {
            bikespeed_voBikeSpeedCal(1);
            testTimerIntFlg[TIMER1][TIMER_INT_FLAG_UP] = 0;
        }
        else if(testTimerIntFlg[TIMER1][TIMER_INT_FLAG_CH3])
        {
            bikespeed_voBikeSpeedCal(3);
            testTimerIntFlg[TIMER1][TIMER_INT_FLAG_CH3] = 0;
        }      
        //UdpScope::Send(0, bikespeed_stFreGetOut.uwFrequencyPu);       
    }

    double bikeSpeedFreqPu = (double)TIM1CLK_KHZ * 1000 * 1048576 / bikeSpeedPrd / FBASE / bikespeed_stFreGetCof.uwNumbersPulses;  // Q20

    if(bikeSpeedFreqPu > bikespeed_stFreGetCof.uwMaxBikeSpeedFre || bikespeed_stFreGetOut.uwCaputureOverflowCnt > bikespeed_stFreGetOut.uwCaputureOverflowMinCntTest)
    {
        EXPECT_NEAR(bikespeed_stFreGetOut.uwFrequencyPu, 0, 0.1);
    }
    else 
    {
        EXPECT_NEAR(bikespeed_stFreGetOut.uwFrequencyPu, bikeSpeedFreqPu, 2);
    }
}

INSTANTIATE_TEST_SUITE_P(DiffBikeSpeedPeriod, BikeSpeedTest1,
                         ::testing::Values(0, 500, 3000, 18000, 100000,10000000));

class BikeSpeedTest2 : public BikeSpeedTest, public testing::WithParamInterface<int>
{};

TEST_P(BikeSpeedTest2, IntSimultFreCal)
{
    /* Coef Cal */
    bikespeed_voBikeSpeedCof();
    bikespeed_stFreGetCof.uwNumbersPulses = BIKESPEED_NUMBERS_PULSES;
    switch_flg.SysCoef_Flag = TRUE;

    /* Test conditions */
    bikespeed_stFreGetOut.bikespeed_fsm = BIKESPEED_WORK;
    bikespeed_stFreGetOut.uwCaputureNumCnt = 1;
    bikespeed_stFreGetOut.uwCaputure1Cnt = 100;
    bikespeed_stFreGetOut.uwCaputureOverflowCnt = 3;

    double overflowCnt = bikespeed_stFreGetOut.uwCaputureOverflowCnt;
    double cap1Cnt = bikespeed_stFreGetOut.uwCaputure1Cnt;


    testCh3CapValue[TIMER1] = GetParam();

    /* Interrupt flag */ 
    testTimerIntFlag2[TIMER1] = 0x0011;
    
    /* Interrupt: update and capture */ 
    if(testTimerIntFlag2[TIMER1] != 0)  
    {
        iRtCap_Isr(0);
    }     

    if(testCh3CapValue[TIMER1] < (iCap_GetPeriod(0) >> 1))
    {
        overflowCnt++;
    }

    double bikeSpeedFreqPu =  overflowCnt * 18000 + bikespeed_stFreGetOut.uwCaputure2Cnt - cap1Cnt;
    bikeSpeedFreqPu = (double)TIM1CLK_KHZ * 1000 * 1048576 / bikeSpeedFreqPu / FBASE / bikespeed_stFreGetCof.uwNumbersPulses;  // Q20

    if(bikeSpeedFreqPu > bikespeed_stFreGetCof.uwMaxBikeSpeedFre || bikespeed_stFreGetOut.uwCaputureOverflowCnt > bikespeed_stFreGetOut.uwCaputureOverflowMinCnt)
    {
        EXPECT_NEAR(bikespeed_stFreGetOut.uwFrequencyPu, 0, 0.1);
    }
    else 
    {
        EXPECT_NEAR(bikespeed_stFreGetOut.uwFrequencyPu, bikeSpeedFreqPu, 2);
        if(testCh3CapValue[TIMER1] < (iCap_GetPeriod(0) >> 1))
        {
            EXPECT_EQ(bikespeed_stFreGetOut.uwCaputureOverflowCnt, 0);
        }
        else 
        {
            EXPECT_EQ(bikespeed_stFreGetOut.uwCaputureOverflowCnt, 1);
        }
    }
}

INSTANTIATE_TEST_SUITE_P(DiffBikeSpeedPeriod, BikeSpeedTest2,
                         ::testing::Values(200, 17900));


class BikeSpeedTest3 : public BikeSpeedTest, public testing::WithParamInterface<::std::tuple<int,int>>
{};

TEST_P(BikeSpeedTest3, IntSimultFreCal)
{
    /* Coef Cal */
    switch_flg.SysCoef_Flag = TRUE; 
    bikespeed_voBikeSpeedCof();
    bikespeed_stFreGetCof.uwNumbersPulses = BIKESPEED_NUMBERS_PULSES;

    cadence_voCadenceCof();
    cadence_stFreGetCof.uwNumbersPulses = CADENCE_NUMBERS_PULSES;

    /* Test conditions */
    bikespeed_stFreGetOut.bikespeed_fsm = BIKESPEED_WORK;
    bikespeed_stFreGetOut.uwCaputureNumCnt = 1;
    bikespeed_stFreGetOut.uwCaputure1Cnt = 100;
    bikespeed_stFreGetOut.uwCaputureOverflowCnt = 3;

    cadence_stFreGetOut.cadence_fsm = CADENCE_HFreWork;
    cadence_stFreGetOut.uwCaputureNumCnt = 1;
    cadence_stFreGetOut.uwCaputure1Cnt = 100;
    cadence_stFreGetOut.uwCaputureOverflowCnt = 1;  ///< OverflowCnt cant be 0
    testGpioBValue[GPIOB] = 0;

    double bsOverflowCnt = bikespeed_stFreGetOut.uwCaputureOverflowCnt;
    double bsCap1Cnt = bikespeed_stFreGetOut.uwCaputure1Cnt;

    double cadOverflowCnt = cadence_stFreGetOut.uwCaputureOverflowCnt;
    double cadCapCnt = cadence_stFreGetOut.uwCaputure1Cnt;
    
    /* Capture value */ 
    testCh2CapValue[TIMER1] = get<1>(GetParam());
    testCh3CapValue[TIMER1] = get<0>(GetParam());

    /* Interrupt flag */ 
    testTimerIntFlag2[TIMER1] = 0x0019;
    
    /* Interrupt: update and capture */ 
    if(testTimerIntFlag2[TIMER1] != 0)  
    {
        iRtCap_Isr(0);
    }     

    if(testCh3CapValue[TIMER1] < (iCap_GetPeriod(0) >> 1))
    {
        bsOverflowCnt++;
    }
    if(testCh2CapValue[TIMER1] < (iCap_GetPeriod(0) >> 1))
    {
        cadOverflowCnt++;
    }

    double bikeSpeedFreqPu =  bsOverflowCnt * 18000 + bikespeed_stFreGetOut.uwCaputure2Cnt - bsCap1Cnt;
    bikeSpeedFreqPu = (double)TIM1CLK_KHZ * 1000 * 1048576 / bikeSpeedFreqPu / FBASE / bikespeed_stFreGetCof.uwNumbersPulses;  // Q20

    if(bikeSpeedFreqPu > bikespeed_stFreGetCof.uwMaxBikeSpeedFre || bikespeed_stFreGetOut.uwCaputureOverflowCnt > bikespeed_stFreGetOut.uwCaputureOverflowMinCnt)
    {
        EXPECT_NEAR(bikespeed_stFreGetOut.uwFrequencyPu, 0, 0.1);
    }
    else 
    {
        EXPECT_NEAR(bikespeed_stFreGetOut.uwFrequencyPu, bikeSpeedFreqPu, 2);
        if(testCh3CapValue[TIMER1] < (iCap_GetPeriod(0) >> 1))
        {
            EXPECT_EQ(bikespeed_stFreGetOut.uwCaputureOverflowCnt, 0);
        }
        else 
        {
            EXPECT_EQ(bikespeed_stFreGetOut.uwCaputureOverflowCnt, 1);
        }
    }



    double capValErrLast = 0, capValErr = 0, cadFreqPu = 0;
    capValErrLast = capValErr;
    capValErr =  cadOverflowCnt * 18000 + cadence_stFreGetOut.uwCaputure2Cnt - cadCapCnt;
    cadFreqPu = (double)TIM1CLK_KHZ * 1000 * 1048576 / ((capValErr + capValErrLast) / 2)/ FBASE / cadence_stFreGetCof.uwNumbersPulses;  // Q20

    if(cadFreqPu > cadence_stFreGetCof.uwMaxCadenceFre || cadence_stFreGetOut.uwCaputureOverflowCnt > cadence_stFreGetCof.uwHfMaxTimeCnt || cadence_stFreGetOut.cadence_dir == 1)
    {
        EXPECT_NEAR(cadence_stFreGetOut.uwFrequencyPu, 0, 0.1);
    }
    else 
    {
        EXPECT_NEAR(cadence_stFreGetOut.uwFrequencyPu, cadFreqPu, 2);
        if(testCh2CapValue[TIMER1] < (iCap_GetPeriod(0) >> 1))
        {
            EXPECT_EQ(cadence_stFreGetOut.uwCaputureOverflowCnt, 0);
        }
        else 
        {
            EXPECT_EQ(cadence_stFreGetOut.uwCaputureOverflowCnt, 1);
        }
    }
}

INSTANTIATE_TEST_SUITE_P(DiffBikeSpeedPeriod, BikeSpeedTest3,
                        ::testing::Combine(::testing::Values(200, 17900), ::testing::Values(199, 201, 17800,17901)));