follow sim

User project/1.FrameLayer/Source/TimeTask_Event.c

@@ -211,7 +211,7 @@ void  Event_1ms(void)
         // spd assist model flg
         if((cp_stFlg.RunModelSelect == CityBIKE) || (cp_stFlg.RunModelSelect == MountainBIKE))
         {
-            if(cp_stBikeRunInfoPara.uwBikeGear == 0x22)
+            if((cp_stBikeRunInfoPara.uwBikeGear == 0x22) && ((BikeBrake_blGetstate() | bikegearsensor_blBikeGetState()) == FALSE))
             {
                 Event_pvt_uwAssistCnt ++;
                 if(Event_pvt_uwAssistCnt > 200 && cp_stFlg.RunPermitFlg == TRUE)

User project/1.FrameLayer/Source/gd32f30x_it.c

@@ -184,52 +184,6 @@ void TIMER1_IRQHandler(void)
     clasB_uwTIM1Cnt++;
     
     iRtCap_Isr(0);
-//    UWORD uwIntSource = 0;
-//    if (timer_interrupt_flag_get(TIMER1, TIMER_INT_FLAG_UP) != 0)
-//    {
-//        if(switch_flg.SysCoef_Flag == TRUE)
-//        {
-//            uwIntSource = 1;
-//            cadence_voCadenceCal(uwIntSource);
-//            bikespeed_voBikeSpeedCal(uwIntSource);
-//        }
-//        timer_interrupt_flag_clear(TIMER1, TIMER_INT_FLAG_UP);
-//    }
-//    else if (timer_interrupt_flag_get(TIMER1, TIMER_INT_FLAG_CH2) != 0)
-//    {
-//        if(switch_flg.SysCoef_Flag == TRUE)
-//        {
-//            uwIntSource = 2;        
-//            cadence_voCadenceCal(uwIntSource);
-//            /* Select rising or falling edge trigger */ 
-//            if(gpio_input_bit_get(GPIOB, GPIO_PIN_10) != 0)
-//            {
-//               /* reset the CH2P and CH2NP bits */
-//               TIMER_CHCTL2(TIMER1) &= ~(uint32_t)(TIMER_CHCTL2_CH2P|TIMER_CHCTL2_CH2NP);
-//               TIMER_CHCTL2(TIMER1) |= (uint32_t)((uint32_t)(TIMER_IC_POLARITY_FALLING) << 8U);
-//            }
-//            else
-//            {
-//               /* reset the CH2P and CH2NP bits */
-//               TIMER_CHCTL2(TIMER1) &= ~(uint32_t)(TIMER_CHCTL2_CH2P|TIMER_CHCTL2_CH2NP);
-//               TIMER_CHCTL2(TIMER1) |= (uint32_t)((uint32_t)(TIMER_IC_POLARITY_RISING) << 8U);       
-//            }
-//        }      
-//        timer_interrupt_flag_clear(TIMER1, TIMER_INT_FLAG_CH2);
-//    }
-//    else if (timer_interrupt_flag_get(TIMER1, TIMER_INT_FLAG_CH3) != 0)
-//    {
-//        if(switch_flg.SysCoef_Flag == TRUE)
-//        {
-//            uwIntSource = 3;
-//            bikespeed_voBikeSpeedCal(uwIntSource);
-//        }
-//        timer_interrupt_flag_clear(TIMER1, TIMER_INT_FLAG_CH3);
-//    }
-//    else
-//    {
-//    	//do nothing
-//    }
 }
 /*!
     \brief      
@@ -267,29 +221,7 @@ void TIMER5_IRQHandler(void)
 */
 void DMA1_Channel2_IRQHandler(void)
 {
-
-    
     iRtUart_RxIsr(0);
-//    /* Read PC Conmand */
-//    if (dma_flag_get(DMA1, DMA_CH2, DMA_INT_FLAG_FTF) != 0)
-//    {
-//        UART_voCBDoneRead(UART_ERR_OK, 22);
-//        DMA_CH2CTL(DMA1) &= ~DMA_CHXCTL_CHEN;
-//        //dma_flag_clear(DMA1, DMA_CH2, DMA_INT_FLAG_FTF);
-//        DMA_INTC(DMA1) |= DMA_FLAG_ADD(DMA_INT_FLAG_FTF, DMA_CH2);
-//        uwTempCount = 22 - DMA_CH2CNT(DMA1);  
-//        DMA_CH2CNT(DMA1) = uwTempCount;
-//        DMA_CH2CTL(DMA1) |= DMA_CHXCTL_CHEN;
-//    }
-//    /* RX error */
-//    if (dma_flag_get(DMA1, DMA_CH2, DMA_FLAG_ERR) != 0)
-//    {
-//        DMA_CH2CTL(DMA1) &= ~DMA_CHXCTL_CHEN;
-//        //dma_flag_clear(DMA1, DMA_CH2, DMA_FLAG_ERR);
-//        DMA_INTC(DMA1) |= DMA_FLAG_ADD(DMA_FLAG_ERR, DMA_CH2); 
-//        DMA_CH2CNT(DMA1) = 22;
-//        DMA_CH2CTL(DMA1) |= DMA_CHXCTL_CHEN;
-//    }
 }
 
 

User project/2.MotorDrive/Source/alarm.c

@@ -1236,7 +1236,7 @@ void alm_voDetec200MS(const ALM_BIKE_IN *in, const ALM_DETEC200MS_COF *coef) /*
 { 
     /** Bike sensors judge each other **/
     /* Bike speed sensor fault */
-    if(in->uwCadenceFreqPu > 200)//8rpm
+    if(in->uwCadenceFreqPu > 0)
     {
         if(in->uwBikeSpdPu == 0)
         {
@@ -1264,7 +1264,7 @@ void alm_voDetec200MS(const ALM_BIKE_IN *in, const ALM_DETEC200MS_COF *coef) /*
     }
     
     /* Bike cadence sensor fault */
-    if(in->uwBikeSpdPu > 449)//(2.19m轮径下  2.36km/h )
+    if(in->uwBikeSpdPu > 0)
     {
         if(in->uwTroqPu > ass_stCalCoef.uwAssThreshold)
         {

User project/3.BasicFunction/Source/switchhall.c

@@ -80,30 +80,30 @@ static void switchhall_voSectorJudge(void)
 {
     /* HALLA(PC8), HALLB(PC7), PHALLC(PC6), wzy */
   
-    if(gpio_input_bit_get(GPIOC,GPIO_PIN_6) != 0)
-    {
-      switchhall_stOut.uwSectorNum = 0;
-    }
-    else
-    {
-      switchhall_stOut.uwSectorNum = 1;
-    }
-    if(gpio_input_bit_get(GPIOC,GPIO_PIN_8) != 0)
-    {
-      switchhall_stOut.uwSectorNum |= 0<<1;
-    }
-    else
-    {
-      switchhall_stOut.uwSectorNum |= 1<<1;
-    }
-    if(gpio_input_bit_get(GPIOC,GPIO_PIN_7) != 0)
-    {
-      switchhall_stOut.uwSectorNum |= 0<<2;
-    }
-    else
-    {
-      switchhall_stOut.uwSectorNum |= 1<<2;
-    }
+//    if(iGpio_Read(HW_GPIO_HALL_A_PIN) != 0)
+//    {
+//      switchhall_stOut.uwSectorNum = 0;
+//    }
+//    else
+//    {
+//      switchhall_stOut.uwSectorNum = 1;
+//    }
+//    if(iGpio_Read(HW_GPIO_HALL_B_PIN) != 0)
+//    {
+//      switchhall_stOut.uwSectorNum |= 0<<1;
+//    }
+//    else
+//    {
+//      switchhall_stOut.uwSectorNum |= 1<<1;
+//    }
+//    if(iGpio_Read(HW_GPIO_HALL_C_PIN) != 0)
+//    {
+//      switchhall_stOut.uwSectorNum |= 0<<2;
+//    }
+//    else
+//    {
+//      switchhall_stOut.uwSectorNum |= 1<<2;
+//    }
     
     
 //    switchhall_stOut.uwSectorNum = GPIO_ReadInputDataBit(GPIOC, GPIO_Pin_6);
@@ -135,49 +135,50 @@ void   switchhall_voTim3Int(void)
     /* Capture Value */    
     if (timer_interrupt_flag_get(TIMER2, TIMER_INT_FLAG_UP) == SET)
     {
-        if(curSpeed_state.state == StartUp || curSpeed_state.state == Open2Clz || curSpeed_state.state == ClzLoop)
-        {     
-          if (timer_interrupt_flag_get(TIMER2, TIMER_INT_FLAG_CH0) == SET)
-          {
-              switchhall_stCap.uwState = (UWORD)timer_channel_capture_value_register_read(TIMER2, TIMER_INT_FLAG_CH0);
-              timer_interrupt_flag_clear(TIMER2, TIMER_INT_FLAG_CH0);
-          }
-          else if (timer_interrupt_flag_get(TIMER2, TIMER_INT_FLAG_CH1) == SET)
-          {
-              switchhall_stCap.uwState = (UWORD)timer_channel_capture_value_register_read(TIMER2, TIMER_INT_FLAG_CH1);
-              timer_interrupt_flag_clear(TIMER2, TIMER_INT_FLAG_CH1);
-          }
-          else if (timer_interrupt_flag_get(TIMER2, TIMER_INT_FLAG_CH2) == SET)
-          {
-              switchhall_stCap.uwState = (UWORD)timer_channel_capture_value_register_read(TIMER2, TIMER_INT_FLAG_CH2);
-              timer_interrupt_flag_clear(TIMER2, TIMER_INT_FLAG_CH2);
-          }
-          else
-          {
-              switchhall_stCap.uwState=0;
-          }  
-          
-          if (switchhall_stCap.uwState > timer_counter_read(TIMER2))
-          {
-              switchhall_stCap.ulCapValue = switchhall_stCap.uwState;
-              switchhall_stCap.slCapValueDelta = (SLONG)switchhall_stCap.uwCaptureOverFlowCnt * 60000 + (SLONG)switchhall_stCap.ulCapValue - (SLONG)switchhall_stCap.ulCapValuePre;
-              switchhall_stCap.uwCaptureOverFlowCnt ++;              
-          }
-          else
-          {
-            switchhall_stCap.uwCaptureOverFlowCnt ++;
-          }
-          
-          if (switchhall_stCap.uwCaptureOverFlowCnt > 3000)
-          {
-            switchhall_stCap.uwCaptureOverFlowCnt=0;
-          }
-        }
-        else
-        {
-          switchhall_stCap.uwCaptureOverFlowCnt = 0;
-        }
+//        if(curSpeed_state.state == StartUp || curSpeed_state.state == Open2Clz || curSpeed_state.state == ClzLoop)
+//        {     
+//          if (timer_interrupt_flag_get(TIMER2, TIMER_INT_FLAG_CH0) == SET)
+//          {
+//              switchhall_stCap.uwState = (UWORD)timer_channel_capture_value_register_read(TIMER2, TIMER_INT_FLAG_CH0);
+//              timer_interrupt_flag_clear(TIMER2, TIMER_INT_FLAG_CH0);
+//          }
+//          else if (timer_interrupt_flag_get(TIMER2, TIMER_INT_FLAG_CH1) == SET)
+//          {
+//              switchhall_stCap.uwState = (UWORD)timer_channel_capture_value_register_read(TIMER2, TIMER_INT_FLAG_CH1);
+//              timer_interrupt_flag_clear(TIMER2, TIMER_INT_FLAG_CH1);
+//          }
+//          else if (timer_interrupt_flag_get(TIMER2, TIMER_INT_FLAG_CH2) == SET)
+//          {
+//              switchhall_stCap.uwState = (UWORD)timer_channel_capture_value_register_read(TIMER2, TIMER_INT_FLAG_CH2);
+//              timer_interrupt_flag_clear(TIMER2, TIMER_INT_FLAG_CH2);
+//          }
+//          else
+//          {
+//              switchhall_stCap.uwState=0;
+//          }  
+//          
+//          if (switchhall_stCap.uwState > timer_counter_read(TIMER2))
+//          {
+//              switchhall_stCap.ulCapValue = switchhall_stCap.uwState;
+//              switchhall_stCap.slCapValueDelta = (SLONG)switchhall_stCap.uwCaptureOverFlowCnt * 60000 + (SLONG)switchhall_stCap.ulCapValue - (SLONG)switchhall_stCap.ulCapValuePre;
+//              switchhall_stCap.uwCaptureOverFlowCnt ++;              
+//          }
+//          else
+//          {
+//            switchhall_stCap.uwCaptureOverFlowCnt ++;
+//          }
+//          
+//          if (switchhall_stCap.uwCaptureOverFlowCnt > 3000)
+//          {
+//            switchhall_stCap.uwCaptureOverFlowCnt=0;
+//          }
+//        }
+//        else
+//        {
+//          switchhall_stCap.uwCaptureOverFlowCnt = 0;
+//        }
         
+        switchhall_stCap.uwCaptureOverFlowCnt ++;
         timer_interrupt_flag_clear(TIMER2, TIMER_INT_FLAG_UP);
     }
     else if (timer_interrupt_flag_get(TIMER2, TIMER_INT_FLAG_CH0)== SET)

User project/3.BasicFunction/Source/torquesensor.c

@@ -161,7 +161,7 @@ void torsensor_voTorSensorCof(void)
         torsensor_stTorSensorCof.uwTorqueOffsetConfirmFlg = TRUE;
     }
     
-#ifdef RUN_ARCH_SIM
+#ifdef RUN_ARCH_SIM_2
     torsensor_stTorSensorCof.uwTorqueOffset = 868;
     torsensor_stTorSensorCof.uwBikeTorStep1ADC = 1427;
     torsensor_stTorSensorCof.uwBikeTorStep1RealNm = 250;

User project/4.BasicHardwSoftwLayer/2.BasicSoftwLayer/Include/syspar.h

@@ -70,11 +70,11 @@ Update Time
 /*======================================================================*
    ADC Maximum Value
 *=======================================================================*/
-#if ((MOTOR_ID_SEL == MOTOR_WELLING_CITY_36V) || (MOTOR_ID_SEL == MOTOR_WELLING_MTB_36V))
-#define ADC_IPHASE_CUR_MAX_AP  15600 //13400
-#elif ((MOTOR_ID_SEL == MOTOR_WELLING_CITY_48V) || (MOTOR_ID_SEL == MOTOR_WELLING_MTB_48V))
-#define ADC_IPHASE_CUR_MAX_AP  7500 //13400
-#endif
+//#if ((MOTOR_ID_SEL == MOTOR_WELLING_CITY_36V) || (MOTOR_ID_SEL == MOTOR_WELLING_MTB_36V))
+//#define ADC_IPHASE_CUR_MAX_AP  15600 //13400
+//#elif ((MOTOR_ID_SEL == MOTOR_WELLING_CITY_48V) || (MOTOR_ID_SEL == MOTOR_WELLING_MTB_48V))
+//#define ADC_IPHASE_CUR_MAX_AP  7500 //13400
+//#endif
 
 #define ADC_IDC_CUR_MAX_AP     9524//10476//11640//9524 //10476
 #define ADC_ISENSOR_CUR_MAX_AP 6005

User project/4.BasicHardwSoftwLayer/2.BasicSoftwLayer/Include/user.h

@@ -49,8 +49,19 @@ Update Time
 
 #define MOTOR_ID_SEL              MOTOR_WELLING_MTB_36V    ///< syspar.h笢珩剒猁恁寁36V/48V炵苀
 
-#define TEST  //only use for testing
+//#define TEST  //only use for testing
 
+/*======================================================================*
+   ADC Maximum Value
+*=======================================================================*/
+#if (MOTOR_ID_SEL == MOTOR_WELLING_MTB_36V || MOTOR_ID_SEL == MOTOR_WELLING_CITY_36V)
+#define ADC_IPHASE_CUR_MAX_AP  15600 
+#define ADC_IPHASE_CUR_OVER_K  780   // SWORD��憭抒㩞瘚�/��甅��憭抒㩞瘚�=120A/156A=0.769=787(Q10) 
+#else
+#define ADC_IPHASE_CUR_MAX_AP  7500  
+#define ADC_IPHASE_CUR_OVER_K  1024
+#endif
+  
 /*======================================================================*
     Motor Parameters
 *=======================================================================*/

User project/5.Api_rt/api_rt_pwm.c

@@ -496,22 +496,22 @@ void iPwm_DisableOutput(uint8_t devIndex)
 
 int8_t iPwm_GetChannelEnableState(uint8_t devIndex, uint8_t channelIndex)
 {
-    ASSERT_LESS(devIndex, 1);
-    ////ASSERT_LESS(channelIndex, 4);
-    
-    uint32_t base = Pwms[devIndex].PwmBase;
-    uint32_t value = 0;
-
-    if (channelIndex < 64)
-    {
-        value = ((uint32_t)0x01) << (channelIndex * 4);
-    }
-    else
-    {
-        value = ((uint32_t)0x04) << ((channelIndex - 64) * 4);
-    }
-    
-    return ((TIMER_CHCTL2(base) & value) >> value);
+//    ASSERT_LESS(devIndex, 1);
+//    ////ASSERT_LESS(channelIndex, 4);
+//    
+//    uint32_t base = Pwms[devIndex].PwmBase;
+//    uint32_t value = 0;
+//
+//    if (channelIndex < 64)
+//    {
+//        value = ((uint32_t)0x01) << (channelIndex * 4);
+//    }
+//    else
+//    {
+//        value = ((uint32_t)0x04) << ((channelIndex - 64) * 4);
+//    }
+//    
+//    return ((TIMER_CHCTL2(base) & value) >> value);
 }
 
 void iPwm_EnableChannelOutput(uint8_t devIndex, uint8_t channelIndex)

tests/sim/init_model.m

@@ -10,6 +10,21 @@ Psif=0.0048;
 J=2500e-7;
 InerRate=1;
 
+% Load Parameter 
+Trans_ratio=35;
+J_Gear=J*Trans_ratio*Trans_ratio;
+JL = 0.3;   %负载转动惯量
+Bm = 0.1;     %传动轴阻尼系数
+Chain_stiff = 2.5e5;
+K = Chain_stiff / 160;     %柔性连接弹性系数
+m = 1;  %骑行者质量
+
+% Control Parameter 
+J_ctrl=2500e-7*2;
+w0 = 12*2*pi;
+delta1=0.005;
+delta2=0.5;
+
 % AC Voltage 
 Vac=310;
 
@@ -26,6 +41,6 @@ we=Freq*2*pi;
 MaxIphase = 140; % Code = 156
 MaxIdc = 95.24;
 MaxVdc = 60.5;
-
+MaxTorq = 145;
 load('injection_dtype.mat');
 

tests/sim/m_sequence.m

@@ -0,0 +1,18 @@
+f = 500;
+Ts = 1/f;    %设置采样周期
+n = 12;        %设置数据个数
+Mag = 0.1;       %设置幅值 
+p = 2^n-1;
+ms = Mag * idinput(p,'prbs');
+t = 0:Ts:Ts*(p-1);
+%M =[t',ms];   %生成M序列
+t2 =  0:Ts:Ts*(20*p-1);
+ms2 = [ms;ms;ms;ms;ms;ms;ms;ms;ms;ms;ms;ms;ms;ms;ms;ms;ms;ms;ms;ms];
+M =[t2',ms2];   %生成M序列
+
+
+% figure (1)
+% plot(t',ms)
+% ylim([-1.5*Mag,1.5*Mag])
+% simulatetime = Ts*(p-1);
+sampletime = Ts;

tests/sim/sim_board/api_rt/api_rt_cap.c

@@ -3,42 +3,48 @@
 #include "api_rt_dbg.h"
 #include "board.h"
 
-ApiRtCap_Handle Caps[1];
+ApiRtCap_Handle Caps[3];
 
 void iRtCap_Init()
 {
-    Caps[0].CapBase                 = &inputCap;
-    Caps[0].CapBase->Base.Prescaler = 1;
+    Caps[0].CapBase                 = &cadenceCap;
+    Caps[0].CapBase->Base.Prescaler = 100;
+
+    Caps[1].CapBase                 = &bikeSpdCap;
+    Caps[1].CapBase->Base.Prescaler = 100;
+
+
 }
+      
 
 uint32_t iCap_GetClock(uint8_t devIndex)
 {
-    return HW_CAP_TIM_HZ;
+    return HW_TIM_CLOCK_HZ / 100;
 }
 
 void iCap_SetEdgeType(uint8_t devIndex, uint8_t channelIndex, ApiCap_EdgeType edge)
 {
 
-    switch (edge)
-    {
-    case ApiCap_NoneEdge:
-        Caps[devIndex].CapBase->Channel[channelIndex].Enable = 0;
-        break;
-    case ApiCap_RisingEdge:
-        Caps[devIndex].CapBase->Channel[channelIndex].Enable = 1;
-        Caps[devIndex].CapBase->Channel[channelIndex].Edge   = CaptureRisingEdge;
-        break;
-    case ApiCap_FallingEdge:
-        Caps[devIndex].CapBase->Channel[channelIndex].Enable = 1;
-        Caps[devIndex].CapBase->Channel[channelIndex].Edge   = CaptureFallingEdge;
-        break;
-    case ApiCap_BothEdge:
-        Caps[devIndex].CapBase->Channel[channelIndex].Enable = 1;
-        Caps[devIndex].CapBase->Channel[channelIndex].Edge   = CaptureRisingFallingEdge;
-        break;
-    default:
-        break;
-    }
+    // switch (edge)
+    // {
+    // case ApiCap_NoneEdge:
+    //     Caps[devIndex].CapBase->Channel[channelIndex].Enable = 0;
+    //     break;
+    // case ApiCap_RisingEdge:
+    //     Caps[devIndex].CapBase->Channel[channelIndex].Enable = 1;
+    //     Caps[devIndex].CapBase->Channel[channelIndex].Edge   = CaptureRisingEdge;
+    //     break;
+    // case ApiCap_FallingEdge:
+    //     Caps[devIndex].CapBase->Channel[channelIndex].Enable = 1;
+    //     Caps[devIndex].CapBase->Channel[channelIndex].Edge   = CaptureFallingEdge;
+    //     break;
+    // case ApiCap_BothEdge:
+    //     Caps[devIndex].CapBase->Channel[channelIndex].Enable = 1;
+    //     Caps[devIndex].CapBase->Channel[channelIndex].Edge   = CaptureRisingFallingEdge;
+    //     break;
+    // default:
+    //     break;
+    // }
 }
 
 void iCap_Enable(uint8_t devIndex)
@@ -53,17 +59,17 @@ void iCap_Disable(uint8_t devIndex)
 
 void iCap_SetPeriod(uint8_t devIndex, uint32_t prd)
 {
-    Caps[devIndex].CapBase->CountMax = TICK_TRANS2(prd, iCap_GetClock(devIndex));
+    Caps[devIndex].CapBase->CountMax = TICK_TRANS(prd);
 }
 
 uint32_t iCap_GetPeriod(uint8_t devIndex)
 {
-    return INV_TICK_TRANS2(Caps[devIndex].CapBase->CountMax, iCap_GetClock(devIndex));
+    return INV_TICK_TRANS(Caps[devIndex].CapBase->CountMax);
 }
 
 uint32_t iCap_GetCaptureValue(uint8_t devIndex, uint8_t channelIndex)
 {
-    return INV_TICK_TRANS2(Caps[devIndex].CapBase->Channel[channelIndex]._CapturedValue, iCap_GetClock(devIndex));
+    return INV_TICK_TRANS(Caps[devIndex].CapBase->Channel[channelIndex]._CapturedValue);
 }
 
 void iCap_EnableCaptureReset(uint8_t devIndex, uint8_t channelIndex)
@@ -88,8 +94,16 @@ void iCap_DisableDeviceInterrupt(uint8_t devIndex)
 }
 
 void iCap_BindDeviceInterrupt(uint8_t devIndex, void (*action)())
-{
-    scheduler.InterruptBind(&scheduler, &Caps[devIndex].CapBase->Base, CaptureInterruptCounter, action);
+{   
+    if(devIndex == 0)
+    {
+        scheduler.InterruptBind(&scheduler, &Caps[devIndex].CapBase->Base, CaptureInterruptCounter, action);
+    }
+    else 
+    {
+        scheduler.InterruptBind(&scheduler, &Caps[2].CapBase->Base, CaptureInterruptCounter, action);
+    }
+   
 }
 
 void iCap_EnableChannelInterrupt(uint8_t devIndex, uint8_t channelIndex)
@@ -105,5 +119,16 @@ void iCap_DisableChannelInterrupt(uint8_t devIndex, uint8_t channelIndex)
 
 void iCap_BindChannelInterrupt(uint8_t devIndex, uint8_t channelIndex, void (*action)())
 {
-    scheduler.InterruptBind(&scheduler, &Caps[devIndex].CapBase->Base, CaptureInterruptOut1 + channelIndex, action);
+    if(devIndex == 0 && channelIndex == 3)
+    {
+        scheduler.InterruptBind(&scheduler, &Caps[1].CapBase->Base, CaptureInterruptOut1 + channelIndex, action);
+    }
+    else if(devIndex == 2) 
+    {
+        scheduler.InterruptBind(&scheduler, &Caps[2].CapBase->Base, CaptureInterruptOut1 + channelIndex, action);
+    }
+    else 
+    {
+        scheduler.InterruptBind(&scheduler, &Caps[devIndex].CapBase->Base, CaptureInterruptOut1 + channelIndex, action);
+    }
 }

tests/sim/sim_board/api_rt/api_rt_cap.h

@@ -12,9 +12,11 @@ extern "C" {
 typedef struct
 {
     struct Sim_Capture *CapBase;
+    ApiRt_Interrupt CountMaxISR;
+    ApiRt_Interrupt ChannelISR[4];
 } ApiRtCap_Handle;
 
-extern ApiRtCap_Handle Caps[1];
+extern ApiRtCap_Handle Caps[3];
 
 void iRtCap_Init();
 

tests/sim/sim_board/api_rt/api_rt_gpio.c

@@ -14,7 +14,7 @@ void iRtGpioLow_Init()
     Gpios[3].GpioBase = &ledPin;
     Gpios[4].GpioBase = &ledPin;
     Gpios[5].GpioBase = &ledPin;
-    Gpios[6].GpioBase = &ledPin;
+    Gpios[6].GpioBase = &bikeBrakePin;
     Gpios[7].GpioBase = &ledPin;
     Gpios[8].GpioBase = &ledPin;
     Gpios[9].GpioBase = &ledPin;

tests/sim/sim_board/api_rt/api_rt_gpio.h

@@ -9,7 +9,7 @@
 extern "C" {
 #endif // __cplusplus
 
-#define GPIO_PIN_COUNT 16
+#define GPIO_PIN_COUNT 19
 
 typedef struct
 {

tests/sim/sim_board/api_rt/api_rt_pwm.c

@@ -175,7 +175,7 @@ ApiPwm_CompareMode iPwm_GetCompareMode(uint8_t devIndex, uint8_t channelIndex)
     struct Sim_Pwm *base = Pwms[devIndex].PwmBase;
 
     ApiPwm_CompareMode mode = ApiPwm_NoAction;
-    switch (base->PwmMode)
+    switch (base->PwmMode[channelIndex])
     {
     case SIM_PWM_PWMMODE1:
         mode = ApiPwm_HigherClear;
@@ -197,10 +197,10 @@ void iPwm_SetCompareMode(uint8_t devIndex, uint8_t channelIndex, ApiPwm_CompareM
     switch (mode)
     {
     case ApiPwm_HigherSet:
-        base->PwmMode = SIM_PWM_PWMMODE2;
+        base->PwmMode[channelIndex] = SIM_PWM_PWMMODE2;
         break;
     case ApiPwm_HigherClear:
-        base->PwmMode = SIM_PWM_PWMMODE1;
+        base->PwmMode[channelIndex] = SIM_PWM_PWMMODE1;
         break;
     default:
         break;

tests/sim/sim_board/include/board.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #define TICK_TRANS(X)     ((X) / BoardSampleTimeFactor)
-#define INV_TICK_TRANS(X) ((X)*BoardSampleTimeFactor)
+#define INV_TICK_TRANS(X) ((X) * BoardSampleTimeFactor)
 
 #define TICK_TRANS2(X, CLOCK)     ((long)((X) / ((CLOCK) / BoardSampleRate)))
 #define INV_TICK_TRANS2(X, CLOCK) ((long)((X) * ((CLOCK) / BoardSampleRate)))

tests/sim/sim_board/include/mcu_instance.h

@@ -9,6 +9,7 @@ extern struct Sim_Adc       adc3;
 extern struct Sim_Gpio      ledPin;
 extern struct Sim_Gpio      capPin;
 extern struct Sim_Gpio      breakPin;
+extern struct Sim_Gpio      bikeBrakePin;
 extern struct Sim_Timer     sysTick;
 extern struct Sim_Timer     tbsTick;
 extern struct Sim_Timer     tbcHalfUpdateTick;
@@ -16,4 +17,5 @@ extern struct Sim_Timer     event1MsTick;
 extern struct Sim_Timer     sampleTrigTimer;
 extern struct Sim_Timer     sampleTrigTimer2;
 extern struct Sim_DMA       pwmLoadDma;
-extern struct Sim_Capture   inputCap;
+extern struct Sim_Capture   cadenceCap;
+extern struct Sim_Capture   bikeSpdCap;

tests/sim/sim_board/source/board.c

@@ -36,6 +36,7 @@ void BoardInit(double ts)
     Sim_GpioInit(&ledPin);
     Sim_GpioInit(&capPin);
     Sim_GpioInit(&breakPin);
+    Sim_GpioInit(&bikeBrakePin);
     Sim_TimerInit(&sysTick);
     Sim_TimerInit(&tbsTick);
     Sim_TimerInit(&tbcHalfUpdateTick);
@@ -43,7 +44,10 @@ void BoardInit(double ts)
     Sim_TimerInit(&sampleTrigTimer);
     Sim_TimerInit(&sampleTrigTimer2);
     Sim_DMAInit(&pwmLoadDma);
-    Sim_CaptureInit(&inputCap);
+    Sim_CaptureInit(&cadenceCap);
+    Sim_CaptureInit(&bikeSpdCap);
+
+
     /* 调度器外设注册 */
     scheduler.Register(&scheduler, &pwm.Base);
     scheduler.Register(&scheduler, &adc.Base);
@@ -52,6 +56,7 @@ void BoardInit(double ts)
     scheduler.Register(&scheduler, &ledPin.Base);
     scheduler.Register(&scheduler, &capPin.Base);
     scheduler.Register(&scheduler, &breakPin.Base);
+    scheduler.Register(&scheduler, &bikeBrakePin.Base);
     scheduler.Register(&scheduler, &sysTick.Base);
     scheduler.Register(&scheduler, &tbsTick.Base);
     scheduler.Register(&scheduler, &tbcHalfUpdateTick.Base);
@@ -59,10 +64,14 @@ void BoardInit(double ts)
     scheduler.Register(&scheduler, &sampleTrigTimer.Base);
     scheduler.Register(&scheduler, &sampleTrigTimer2.Base);
     scheduler.Register(&scheduler, &pwmLoadDma.Base);
-    scheduler.Register(&scheduler, &inputCap.Base);
+    scheduler.Register(&scheduler, &cadenceCap.Base);
+    scheduler.Register(&scheduler, &bikeSpdCap.Base);
+
     /* Pwm配置 */
     pwm.CntMode             = SIM_PWM_UP_DOWN;
-    pwm.PwmMode             = SIM_PWM_PWMMODE2;
+    pwm.PwmMode[0]          = SIM_PWM_PWMMODE2;
+    pwm.PwmMode[1]          = SIM_PWM_PWMMODE2;
+    pwm.PwmMode[2]          = SIM_PWM_PWMMODE2;
     pwm.OCPolarity[0]       = SIM_PWM_POLARITY_HIGH;
     pwm.OCPolarity[1]       = SIM_PWM_POLARITY_HIGH;
     pwm.OCPolarity[2]       = SIM_PWM_POLARITY_HIGH;
@@ -92,6 +101,9 @@ void BoardInit(double ts)
     breakPin.EdgeType = GpioRisingEdge;
     scheduler.TriggerBind(&scheduler, &breakPin.Base, GpioMainTrigger, &pwm.Base, PwmTriggerInBreak);
 
+    /* Bike Brake IO配置 */
+    bikeBrakePin.Mode     = GPIO_MODE_IN;
+
     /* 采样触发定时器配置 */
     sampleTrigTimer.CountMode            = TimerCenterAlignedMode1;
     sampleTrigTimer.CountDir             = TimerCountUp;
@@ -148,15 +160,19 @@ void BoardInit(double ts)
     //scheduler.InterruptBind(&scheduler, &sysTick.Base, TimerInterruptOutUIF, SystickIsr);
 
     /* Capture配置 */
-    inputCap.CountMax                   = TICK_TRANS(HW_TIM_CLOCK_HZ / 100 / HW_CAP_TIM_HZ);
-    inputCap.CounterInterruptEnable     = 1;
-    inputCap.Channel[2].Edge            = CaptureRisingFallingEdge;
-    inputCap.Channel[2].Enable          = 1;
-    inputCap.Channel[2].InterruptEnable = 1;
-    inputCap.Channel[3].Edge            = CaptureRisingEdge;
-    inputCap.Channel[3].Enable          = 1;
-    inputCap.Channel[3].InterruptEnable = 1;
-    //scheduler.InterruptBind(&scheduler, &inputCap.Base, CaptureInterruptOut1, CaptureIsr);
+    cadenceCap.CountMax                   = TICK_TRANS(HW_TIM_CLOCK_HZ / 100 / HW_CAP_TIM_HZ);
+    cadenceCap.CounterInterruptEnable     = 1;
+    cadenceCap.Channel[2].Edge            = CaptureRisingFallingEdge;
+    cadenceCap.Channel[2].Enable          = 1;
+    cadenceCap.Channel[2].InterruptEnable = 1;
+    
+    bikeSpdCap.CountMax                   = TICK_TRANS(HW_TIM_CLOCK_HZ / 100 / HW_CAP_TIM_HZ);
+    bikeSpdCap.CounterInterruptEnable     = 1;
+    bikeSpdCap.Channel[3].Edge            = CaptureRisingEdge;
+    bikeSpdCap.Channel[3].Enable          = 1;
+    bikeSpdCap.Channel[3].InterruptEnable = 1;
+
+    //scheduler.InterruptBind(&scheduler, &bikeSpdCap.Base, CaptureInterruptOut1, CaptureIsr);
 
     scheduler.AppTimeSlice.Add(&scheduler.AppTimeSlice, 1, 1, 0, BackgroundTask);
 

tests/sim/sim_board/source/mcu_instance.c

@@ -8,6 +8,7 @@ struct Sim_Adc       adc3;
 struct Sim_Gpio      ledPin;
 struct Sim_Gpio      capPin;
 struct Sim_Gpio      breakPin;
+struct Sim_Gpio      bikeBrakePin;
 struct Sim_Timer     sysTick;
 struct Sim_Timer     tbsTick;
 struct Sim_Timer     tbcHalfUpdateTick;
@@ -15,4 +16,5 @@ struct Sim_Timer     event1MsTick;
 struct Sim_Timer     sampleTrigTimer;
 struct Sim_Timer     sampleTrigTimer2;
 struct Sim_DMA       pwmLoadDma;
-struct Sim_Capture   inputCap;
+struct Sim_Capture   cadenceCap;
+struct Sim_Capture   bikeSpdCap;

tests/sim/sim_board/source/sfun_wrapper.c

@@ -16,13 +16,13 @@ void McuRun(const double *ain, const int32_t *din, const injection_dtype *ctrl,
     adc.ChannelInput[2] = 0;      // 5V
     adc.ChannelInput[3] = 1.5;    // PCB温度
     adc.ChannelInput[4] = 1.5;    // 电机温度
-    adc.ChannelInput[4] = 0;      // 12V
-    adc.ChannelInput[4] = 0;      // 转把
-    adc.ChannelInput[4] = 1.5;    // 力矩传感器
+    adc.ChannelInput[5] = 0;      // 12V
+    adc.ChannelInput[6] = 0;      // 转把
+    adc.ChannelInput[7] = ain[9];    // 力矩传感器
 
     adc2.ChannelInput[0] = ain[4];              // A相电流
     adc2.ChannelInput[1] = ain[3];              // B相电流
-    adc2.ChannelInput[2] = 0 - ain[4] - ain[3]; // C相电流
+    adc2.ChannelInput[2] = 1.65*3 - ain[4] - ain[3]; // C相电流
     adc2.ChannelInput[3] = ain[8];              // 母线电流
 
     // adc.ChannelInput[5] = ain[0]; // C相电压
@@ -37,8 +37,12 @@ void McuRun(const double *ain, const int32_t *din, const injection_dtype *ctrl,
 
     /* Cap 输入 */
     capPin.IOIn = din[1];
-    inputCap.PWMIn = din[1];
+    cadenceCap.PWMIn = din[2];
+    bikeSpdCap.PWMIn = din[3];
 
+    /* BikeBrake 输入 */
+    bikeBrakePin.IOIn = din[4];
+    
     /* 注入变量 */
     for (int i = 0; i < 8; i++)
     {

tests/sim/sim_board/xmake.lua

@@ -40,6 +40,8 @@ target("sim_sfunc")
     --  temp
     add_includedirs("$(projectdir)/tests/unit_test")
     add_files("$(projectdir)/tests/unit_test/*.c")
+    add_defines("RUN_ARCH_SIM_2")
+
 
 
     add_linkdirs("$(env MATLABROOT)/extern/lib/win64/microsoft")

tests/sim/sweep_etfe.m

@@ -0,0 +1,53 @@
+% 参数配置
+% Simulink配置：输入可选择M序列或随机信号，若为M序列，需要导入M数据
+% Simulink配置：M序列默认为16384个数据，仿真时间对应为1.6383，第12行对应N为16384
+% Simulink配置：将输入和输出信号接入同一个Scope，变量名‘spd’，与第8、9行对应，array格式
+% 第11行：M序列时间间隔默认为200us，T设置为0.0002
+
+figure()
+T = 0.002;
+N = 2^12;
+
+u=out.spd1(:,2);    %输入信号
+y=out.spd1(:,3);    %输出信号
+% for i=1:1:4100
+% y(i,1)=-4000;
+% end
+data = iddata(y,u,T);
+me1 = etfe(data,512,N);
+
+% u=out.spd2(:,2);    %输入信号
+% y=out.spd2(:,3);    %输出信号
+% data = iddata(y,u,T);
+% me2 = etfe(data,512,N);
+% 
+% u=out.spd3(:,2);    %输入信号
+% y=out.spd3(:,3);    %输出信号
+% data = iddata(y,u,T);
+% me3 = etfe(data,512,N);
+% me2 = me2-me3;
+
+% u=out.spd5(:,2);    %输入信号
+% y=out.spd5(:,3);    %输出信号
+% data = iddata(y,u,T);
+% me5 = etfe(data,512,N);
+
+% u=out.spd6(:,2);    %输入信号
+% y=out.spd6(:,3);    %输出信号
+% data = iddata(y,u,T);
+% me6 = etfe(data,512,N);
+% 
+% u=out.spd7(:,2);    %输入信号
+% y=out.spd7(:,3);    %输出信号
+% data = iddata(y,u,T);
+% me7 = etfe(data,512,N);
+% me6 = me6-me7;
+
+
+P = bodeoptions;
+P.FreqUnits='Hz';
+
+bode(me1,P,'b')
+
+
+% title('Random')

tests/unit_test/board_sim/api_rt/api_rt_cap.c

@@ -15,7 +15,62 @@ void iRtCap_Init(void)
     Caps[0].CapBase = TIMER1;
 }
 
+void iRtCap_Isr(uint8_t devIndex)
+{   
+    uint32_t base = Caps[devIndex].CapBase;
+    uint16_t  capValues[5]={0,0,0,0,0};
+    uint8_t  results[5]={0,1,2,3,4};
+    uint16_t tmpIntf;
 
+    tmpIntf = TIMER_INTF(base);   
+    for (int i = 1; i < 5; i++)
+    {
+        if (tmpIntf & (0x01 << i ))
+        {
+            capValues[i] = iCap_GetCaptureValue(devIndex,(i-1));
+        }
+    }
+    if (tmpIntf & 0x01)
+    {      
+        capValues[0] = iCap_GetPeriod(devIndex) >> 1;
+    }
+
+    for(int i = 0; i < 4; i++)
+    { 
+        for(int j = 0;j < (4-i); j++)
+        {
+           if(capValues[results[j]]< capValues[results[j + 1]])
+           {
+               uint8_t tmp = results[j];
+               results[j] = results[j + 1];
+               results[j + 1] = tmp;
+           }
+        }
+    }
+    for(int i = 0; i < 5; i++)
+    { 
+          if (tmpIntf & (0x01 << results[i]))
+          {
+              if(results[i]==0)
+              {
+                  if (Caps[devIndex].CountMaxISR.Enable && Caps[devIndex].CountMaxISR.Action != 0)
+                  {
+                      Caps[devIndex].CountMaxISR.Action();
+                  }
+                  TIMER_INTF(base) &= ~0x01;
+              }
+              else
+              {
+                    if (Caps[devIndex].ChannelISR[results[i]-1].Enable && Caps[devIndex].ChannelISR[results[i]-1].Action != 0)
+                    {
+                        Caps[devIndex].ChannelISR[results[i]-1].Action();
+                    }
+                    TIMER_INTF(base) &= ~(0x01 << results[i]);
+              }
+              
+          }
+    }
+}
 
 /* ========================================================================== */
 /* ============================== API Functions ============================= */
@@ -45,6 +100,36 @@ uint32_t iCap_GetCaptureValue(uint8_t devIndex, uint8_t channelIndex)
     }
     return value;
 }
-    
+
+uint32_t iCap_GetPeriod(uint8_t devIndex)
+{
+    return (HW_TIM_CLOCK_HZ / 100 / 40);
+}
+
+void iCap_BindDeviceInterrupt(uint8_t devIndex, void (*action)())
+{
+    Caps[devIndex].CountMaxISR.Action = action;
+}
+
+void iCap_BindChannelInterrupt(uint8_t devIndex, uint8_t channelIndex, void (*action)())
+{
+    Caps[devIndex].ChannelISR[channelIndex].Action = action;
+}
+
+void iCap_EnableDeviceInterrupt(uint8_t devIndex)
+{
+    Caps[devIndex].CountMaxISR.Enable = 1;
+}
+
+void iCap_EnableChannelInterrupt(uint8_t devIndex, uint8_t channelIndex)
+{
+    Caps[devIndex].ChannelISR[channelIndex].Enable = 1;
+}
+
+void iCap_SetEdgeType(uint8_t devIndex, uint8_t channelIndex, ApiCap_EdgeType edge)
+{}
+
+
+
 
 

tests/unit_test/board_sim/api_rt/api_rt_cap.h

@@ -3,12 +3,18 @@
 
 #include "api_cap.h"
 #include <stdint.h>
+#include "api_rt_common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
 
 
 typedef struct 
 {
     uint32_t            CapBase;
-
+    ApiRt_Interrupt CountMaxISR;
+    ApiRt_Interrupt ChannelISR[4];
 } ApiRtCap_Handle;
 
 extern ApiRtCap_Handle Caps[1];
@@ -16,4 +22,8 @@ extern ApiRtCap_Handle Caps[1];
 void iRtCap_Init(void);
 void iRtCap_Isr(uint8_t devIndex);
 
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
 #endif

tests/unit_test/board_sim/api_rt/api_rt_common.h

@@ -0,0 +1,22 @@
+#ifndef _API_RT_COMMON_H_
+#define _API_RT_COMMON_H_
+
+#include "stdint.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+typedef struct
+{
+    uint8_t Enable;
+    void (*Action)();
+} ApiRt_Interrupt;
+
+void iRt_Init();
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+#endif

tests/unit_test/main.cpp

@@ -19,7 +19,7 @@ int main(int argc, char **argv)
 {
     // ::testing::GTEST_FLAG(output) = "xml:unittest.xml";
     ::testing::InitGoogleTest(&argc, argv);
-    UdpScope::Init(50000);
+    UdpScope::Init(56789);
     MotorSimHelper::StoreDefaultParam();
     auto res = RUN_ALL_TESTS();
     UdpScope::Deinit();

tests/unit_test/test_bikespeed.cpp

@@ -9,16 +9,25 @@ class BikeSpeedTest : public testing::Test
 protected:
     static void SetUpTestSuite()
     {
-        bikespeed_voBikeSpeedInit();
-        iRt_Init();
+        
+
     }
     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
     {
-        bikespeed_voBikeSpeedInit();
+    
     }
 };
 
@@ -112,36 +121,41 @@ TEST_P(BikeSpeedTest1, FreCal)
 INSTANTIATE_TEST_SUITE_P(DiffBikeSpeedPeriod, BikeSpeedTest1,
                          ::testing::Values(0, 500, 3000, 18000, 100000,10000000));
 
-TEST_F(BikeSpeedTest, FreCal2)
+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 = 0;
+    bikespeed_stFreGetOut.uwCaputure1Cnt = 100;
     bikespeed_stFreGetOut.uwCaputureOverflowCnt = 3;
 
     double overflowCnt = bikespeed_stFreGetOut.uwCaputureOverflowCnt;
     double cap1Cnt = bikespeed_stFreGetOut.uwCaputure1Cnt;
 
-    testTimerIntFlg[TIMER1][TIMER_INT_FLAG_UP] = 1;
-    testCh3CapValue[TIMER1] = 17900;
-    testTimerIntFlg[TIMER1][TIMER_INT_FLAG_CH3] = 1;
 
-    /* Interrupt: update and capture */       
-    if(testTimerIntFlg[TIMER1][TIMER_INT_FLAG_UP])  
+    testCh3CapValue[TIMER1] = GetParam();
+
+    /* Interrupt flag */ 
+    testTimerIntFlag2[TIMER1] = 0x0011;
+    
+    /* Interrupt: update and capture */ 
+    if(testTimerIntFlag2[TIMER1] != 0)  
     {
-        bikespeed_voBikeSpeedCal(1);
-        testTimerIntFlg[TIMER1][TIMER_INT_FLAG_UP] = 0;
-    }
-    else if(testTimerIntFlg[TIMER1][TIMER_INT_FLAG_CH3])
+        iRtCap_Isr(0);
+    }     
+
+    if(testCh3CapValue[TIMER1] < (iCap_GetPeriod(0) >> 1))
     {
-        bikespeed_voBikeSpeedCal(3);
-        testTimerIntFlg[TIMER1][TIMER_INT_FLAG_CH3] = 0;
-    }        
+        overflowCnt++;
+    }
 
     double bikeSpeedFreqPu =  overflowCnt * 18000 + bikespeed_stFreGetOut.uwCaputure2Cnt - cap1Cnt;
     bikeSpeedFreqPu = (double)TIM1CLK_KHZ * 1000 * 1048576 / bikeSpeedFreqPu / FBASE / bikespeed_stFreGetCof.uwNumbersPulses;  // Q20
@@ -153,5 +167,118 @@ TEST_F(BikeSpeedTest, FreCal2)
     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)));

tests/unit_test/test_cadence.cpp

@@ -9,19 +9,25 @@ class CadenceTest : public testing::Test
 protected:
     static void SetUpTestSuite()
     {
-        cadence_voCadenceInit();
-        iRt_Init();
+
     }
     virtual void SetUp() override
     {
+        iRt_Init();
+        iCap_BindDeviceInterrupt(0,IC_CountMaxISR);
+        iCap_EnableDeviceInterrupt(0);
+        iCap_BindChannelInterrupt(0,CAP_CH(2),IC_CadenceISR);
+        iCap_EnableChannelInterrupt(0,CAP_CH(2));
 
+        cadence_voCadenceInit();
     }
     virtual void TearDown() override
     {
-        cadence_voCadenceInit();
+
     }
 };
 
+/* 踏频不同频率计算测试 */
 class CadenceTest1 : public CadenceTest, public testing::WithParamInterface<::std::tuple<int,int>>
 {};
 
@@ -36,6 +42,7 @@ TEST_P(CadenceTest1, FreCal)
     int cadenceSignal = 0, cadCnt = 0, cadenceSignalLast = 0;
     int cadencePrd = get<0>(GetParam());
     int capValue = 0; 
+    int capOverflowCnt = 0, capOverflowCnt2 = 0;
 
     testGpioBValue[GPIOB] = get<1>(GetParam());
 
@@ -76,11 +83,14 @@ TEST_P(CadenceTest1, FreCal)
         /* Interrupt: update and capture */       
         if(testTimerIntFlg[TIMER1][TIMER_INT_FLAG_UP])  
         {
+            capOverflowCnt ++;
             cadence_voCadenceCal(1);
             testTimerIntFlg[TIMER1][TIMER_INT_FLAG_UP] = 0;
         }
         else if(testTimerIntFlg[TIMER1][TIMER_INT_FLAG_CH2])
         {
+            capOverflowCnt2 = capOverflowCnt;
+            capOverflowCnt = 0;
             cadence_voCadenceCal(2);
             testTimerIntFlg[TIMER1][TIMER_INT_FLAG_CH2] = 0;
         }      
@@ -89,9 +99,9 @@ TEST_P(CadenceTest1, FreCal)
 
     double cadFreqPu = (double)TIM1CLK_KHZ * 1000 * 2 * 1048576 / cadencePrd / FBASE / cadence_stFreGetCof.uwNumbersPulses;  // Q20
 
-    if(cadFreqPu > cadence_stFreGetCof.uwMaxCadenceFre || cadence_stFreGetOut.uwCaputureOverflowCnt > cadence_stFreGetCof.uwHfMaxTimeCnt || cadence_stFreGetOut.cadence_dir == 1)
+    if(cadFreqPu > cadence_stFreGetCof.uwMaxCadenceFre || capOverflowCnt2 > cadence_stFreGetCof.uwHfMaxTimeCnt || cadence_stFreGetOut.cadence_dir == 1)
     {
-        EXPECT_NEAR(cadence_stFreGetOut.uwFrequencyPu, 0, 0.1);
+        EXPECT_EQ(cadence_stFreGetOut.uwFrequencyPu, 0);
     }
     else 
     {
@@ -102,40 +112,49 @@ TEST_P(CadenceTest1, FreCal)
 INSTANTIATE_TEST_SUITE_P(DiffCadencePeriod, CadenceTest1,
                          ::testing::Combine(::testing::Values(0, 500, 3000, 18002, 100000,1000000), ::testing::Values(0,0x0004)));
 
-TEST_F(CadenceTest, FreCal2)
+
+/* 踏频更新中断与捕获中断同时到达测试 */
+class CadenceTest2 : public CadenceTest, public testing::WithParamInterface<int>
+{};
+
+TEST_P(CadenceTest2, IntSimultFreCal)
 {
     /* Coef Cal */
     cadence_voCadenceCof();
     cadence_stFreGetCof.uwNumbersPulses = CADENCE_NUMBERS_PULSES;
+    switch_flg.SysCoef_Flag = TRUE;
+    bikespeed_voBikeSpeedCof(); ///< timer更新中断函数中有bikespeed函数，防止运行时除0
 
     /* Test conditions */
     cadence_stFreGetOut.cadence_fsm = CADENCE_HFreWork;
     cadence_stFreGetOut.uwCaputureNumCnt = 1;
-    cadence_stFreGetOut.uwCaputure1Cnt = 0;
-    cadence_stFreGetOut.uwCaputureOverflowCnt = 0;
+    cadence_stFreGetOut.uwCaputure1Cnt = 100;
+    cadence_stFreGetOut.uwCaputureOverflowCnt = 1;  ///< OverflowCnt cant be 0
     testGpioBValue[GPIOB] = 0;
 
     double overflowCnt = cadence_stFreGetOut.uwCaputureOverflowCnt;
     double cap1Cnt = cadence_stFreGetOut.uwCaputure1Cnt;
 
-    testTimerIntFlg[TIMER1][TIMER_INT_FLAG_UP] = 1;
-    testCh2CapValue[TIMER1] = 17900;
-    testTimerIntFlg[TIMER1][TIMER_INT_FLAG_CH2] = 1;
+    testCh2CapValue[TIMER1] = GetParam();
+
+    /* Interrupt flag */ 
+    testTimerIntFlag2[TIMER1] = 0x0009;
 
-    /* Interrupt: update and capture */       
-    if(testTimerIntFlg[TIMER1][TIMER_INT_FLAG_UP])  
+    /* Interrupt: update and capture */ 
+    if(testTimerIntFlag2[TIMER1] != 0)  
     {
-        cadence_voCadenceCal(1);
-        testTimerIntFlg[TIMER1][TIMER_INT_FLAG_UP] = 0;
+        iRtCap_Isr(0);
     }
-    else if(testTimerIntFlg[TIMER1][TIMER_INT_FLAG_CH2])
+
+    if(testCh2CapValue[TIMER1] < (iCap_GetPeriod(0) >> 1))
     {
-        cadence_voCadenceCal(2);
-        testTimerIntFlg[TIMER1][TIMER_INT_FLAG_CH2] = 0;
-    }        
+        overflowCnt++;
+    }
 
-    double cadFreqPu =  overflowCnt * 18000 + cadence_stFreGetOut.uwCaputure2Cnt - cap1Cnt;
-    cadFreqPu = (double)TIM1CLK_KHZ * 1000 * 2 * 1048576 / cadFreqPu / FBASE / cadence_stFreGetCof.uwNumbersPulses;  // Q20
+    double capValErrLast = 0, capValErr = 0, cadFreqPu = 0;
+    capValErrLast = capValErr;
+    capValErr =  overflowCnt * 18000 + cadence_stFreGetOut.uwCaputure2Cnt - cap1Cnt;
+    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)
     {
@@ -144,5 +163,232 @@ TEST_F(CadenceTest, FreCal2)
     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(DiffCadencePeriod, CadenceTest2,
+                         ::testing::Values(200, 17900));
+
+/* 踏频模块状态机切换测试 */
+class CadenceTest3 : public CadenceTest, public testing::WithParamInterface<int>
+{};
+
+TEST_P(CadenceTest3, FsmSwitch)
+{
+    /* Coef Cal */
+    cadence_voCadenceCof();
+    cadence_stFreGetCof.uwNumbersPulses = CADENCE_NUMBERS_PULSES;
+
+    int timerPrd = TIM1CLK_KHZ * 1000 / (1000 / 25);  ///< period=25ms, cnt=18000, same as actual timer
+    int timerCnt = 0;
+    int cadenceSignal = 0, cadCnt = 0, cadenceSignalLast = 0;
+    int cadencePrd = 5000;
+    int capValue = 0; 
+    int capOverflowCnt = 0, capOverflowCnt2 = 0;
+
+    testGpioBValue[GPIOB] = GetParam();
+
+    for(int i = 0; i < cadencePrd; i++) 
+    {  
+        /* Input Cadence Signal: only one rising edge */
+        cadCnt++;
+        if(cadCnt <= (cadencePrd/2))   ///< 50% duty cycle squre wave, same as actual sensor
+        {
+            cadenceSignal = 0;
+        }
+        else 
+        {
+            cadenceSignal = 1;
+            if(cadCnt >= cadencePrd)
+            {
+                cadCnt = 0;
+            }
+        }
+        
+        /* Timer */
+        timerCnt ++ ;
+        if(timerCnt >= timerPrd - 1)
+        {
+            timerCnt = 0;
+            testTimerIntFlg[TIMER1][TIMER_INT_FLAG_UP] = 1;
+        }
+
+        /* Capture: rising and falling edge trigger*/
+        if(cadenceSignal - cadenceSignalLast != 0)    
+        {
+            testCh2CapValue[TIMER1] = timerCnt;
+            testTimerIntFlg[TIMER1][TIMER_INT_FLAG_CH2] = 1;
+        }
+        cadenceSignalLast = cadenceSignal;
+
+        /* Interrupt: update and capture */       
+        if(testTimerIntFlg[TIMER1][TIMER_INT_FLAG_UP])  
+        {
+            capOverflowCnt ++;
+            cadence_voCadenceCal(1);
+            testTimerIntFlg[TIMER1][TIMER_INT_FLAG_UP] = 0;
+        }
+        else if(testTimerIntFlg[TIMER1][TIMER_INT_FLAG_CH2])
+        {
+            capOverflowCnt2 = capOverflowCnt;
+            capOverflowCnt = 0;
+            cadence_voCadenceCal(2);
+            testTimerIntFlg[TIMER1][TIMER_INT_FLAG_CH2] = 0;
+        }     
+        else
+        {
+            // do nothing
+        } 
     }
-}
+
+    if (iGpio_Read(HW_GPIO_CADDIR_PIN) != 0)
+    {
+        /* 一个正向脉冲到来，后踏频反向则切换至反向状态 */
+        EXPECT_EQ(cadence_stFreGetOut.cadence_fsm, CADENCE_BACKWOR);
+        EXPECT_EQ(cadence_stFreGetOut.uwFrequencyPu, 0);
+    }  
+    else 
+    {
+        /* 一个正向脉冲到来，且踏频未反向切换至正常工作状态 */
+        EXPECT_EQ(cadence_stFreGetOut.cadence_fsm, CADENCE_HFreWork);
+        EXPECT_EQ(cadence_stFreGetOut.uwFrequencyPu, 0);
+    }  
+
+    for(int i = cadencePrd; i < 500000; i++) 
+    {          
+        if(i > 200000)
+        {
+            /* 踏频方向改为正 */
+            testGpioBValue[GPIOB] = 0;
+        }
+
+        /* Timer */
+        timerCnt ++ ;
+        if(timerCnt >= timerPrd - 1)
+        {
+            timerCnt = 0;
+            testTimerIntFlg[TIMER1][TIMER_INT_FLAG_UP] = 1;
+        }
+
+        /* Interrupt: update */       
+        if(testTimerIntFlg[TIMER1][TIMER_INT_FLAG_UP])  
+        {
+            capOverflowCnt ++;
+            cadence_voCadenceCal(1);
+            testTimerIntFlg[TIMER1][TIMER_INT_FLAG_UP] = 0;
+        }
+    }
+    
+    if (iGpio_Read(HW_GPIO_CADDIR_PIN) != 0)
+    {
+        /* 一直反踏则维持反向状态 */
+        EXPECT_EQ(cadence_stFreGetOut.cadence_fsm, CADENCE_BACKWOR);
+        EXPECT_EQ(cadence_stFreGetOut.uwFrequencyPu, 0);
+    }  
+    else 
+    {
+        /* 后续一段时间没有正向脉冲，且未反踏则进入空闲状态 */
+        EXPECT_EQ(cadence_stFreGetOut.cadence_fsm, CADENCE_IDLE);
+        EXPECT_EQ(cadence_stFreGetOut.uwFrequencyPu, 0);
+    }  
+
+    cadencePrd = 500;
+
+    for(int i = 0; i < (cadencePrd * 5); i++) 
+    {  
+        /* Input Cadence Signal: only one rising edge */
+        cadCnt++;
+        if(cadCnt <= (cadencePrd/2))   ///< 50% duty cycle squre wave, same as actual sensor
+        {
+            cadenceSignal = 0;
+        }
+        else 
+        {
+            cadenceSignal = 1;
+            if(cadCnt >= cadencePrd)
+            {
+                cadCnt = 0;
+            }
+        }
+        
+        /* Timer */
+        timerCnt ++ ;
+        if(timerCnt >= timerPrd - 1)
+        {
+            timerCnt = 0;
+            testTimerIntFlg[TIMER1][TIMER_INT_FLAG_UP] = 1;
+        }
+
+        /* Capture: rising and falling edge trigger*/
+        if(cadenceSignal - cadenceSignalLast != 0)    
+        {
+            testCh2CapValue[TIMER1] = timerCnt;
+            testTimerIntFlg[TIMER1][TIMER_INT_FLAG_CH2] = 1;
+        }
+        cadenceSignalLast = cadenceSignal;
+
+        /* Interrupt: update and capture */       
+        if(testTimerIntFlg[TIMER1][TIMER_INT_FLAG_UP])  
+        {
+            capOverflowCnt ++;
+            cadence_voCadenceCal(1);
+            testTimerIntFlg[TIMER1][TIMER_INT_FLAG_UP] = 0;
+        }
+        else if(testTimerIntFlg[TIMER1][TIMER_INT_FLAG_CH2])
+        {
+            capOverflowCnt2 = capOverflowCnt;
+            capOverflowCnt = 0;
+            cadence_voCadenceCal(2);
+            testTimerIntFlg[TIMER1][TIMER_INT_FLAG_CH2] = 0;
+        }     
+        else
+        {
+            // do nothing
+        } 
+    }
+
+    if (iGpio_Read(HW_GPIO_CADDIR_PIN) != 0)
+    {
+        /* 一个正向脉冲到来，后踏频反向则切换至反向状态 */
+        EXPECT_EQ(cadence_stFreGetOut.cadence_fsm, CADENCE_BACKWOR);
+        EXPECT_EQ(cadence_stFreGetOut.uwFrequencyPu, 0);
+    }  
+    else 
+    {
+        /* 踏频过高，则进入error状态 */
+        EXPECT_EQ(cadence_stFreGetOut.cadence_fsm, CADENCE_ERROR);
+        EXPECT_EQ(cadence_stFreGetOut.uwFrequencyPu, 0);
+    }  
+
+    for(int i = cadencePrd; i < 5000000; i++) 
+    {          
+        /* Timer */
+        timerCnt ++ ;
+        if(timerCnt >= timerPrd - 1)
+        {
+            timerCnt = 0;
+            testTimerIntFlg[TIMER1][TIMER_INT_FLAG_UP] = 1;
+        }
+
+        /* Interrupt: update */       
+        if(testTimerIntFlg[TIMER1][TIMER_INT_FLAG_UP])  
+        {
+            capOverflowCnt ++;
+            cadence_voCadenceCal(1);
+            testTimerIntFlg[TIMER1][TIMER_INT_FLAG_UP] = 0;
+        }
+    }
+
+    /* error状态5s后，则重新进入idle状态 */
+    EXPECT_EQ(cadence_stFreGetOut.cadence_fsm, CADENCE_IDLE);
+    EXPECT_EQ(cadence_stFreGetOut.uwFrequencyPu, 0);
+}
+INSTANTIATE_TEST_SUITE_P(DiffCadenceDir, CadenceTest3,::testing::Values(0,0x0004));

tests/unit_test/test_cursample_calib.cpp

@@ -227,7 +227,7 @@ TEST_P(CurSampleCalibTest1, SingResCalib)
                 pwm_voGen(&pwm_stGenIn, &pwm_stGenCoef, &pwm_stGenOut);
 
                 /* Scope */ 
-                UdpScope::Send(0, adc_stDownOut.slSampIcPu, adc_stUpOut.swCalibIcPu, adc_stDownOut.swIcPu);
+                // UdpScope::Send(0, adc_stDownOut.slSampIaPu, adc_stUpOut.swCalibIaPu, adc_stDownOut.swIaPu);
                 //UdpScope::Send(0, scm_uwSpdFbkLpfAbsPu, pwm_stGenOut.blSampleCalibFlag);
 
                 /* Determine whether the unit test pass */
@@ -235,18 +235,12 @@ TEST_P(CurSampleCalibTest1, SingResCalib)
                 {
                     if (!adc_stCof.blCalibCalFlag)
                     {
-                        if(adc_stDownOut.ulISamplePeakPu > 32767)  
+                        if(adc_stDownOut.ulISamplePeakPu > 32767)  ///< 采样电流溢出SWORD情况
                         {
                             EXPECT_NEAR((double)adc_stDownOut.slSampIaPu * 780 / 1024, adc_stDownOut.swIaPu, 10);   ///< 系数为立即数，程序中更改后测试用例需要随之更改
                             EXPECT_NEAR((double)adc_stDownOut.slSampIbPu * 780 / 1024, adc_stDownOut.swIbPu, 10);
                             EXPECT_NEAR((double)adc_stDownOut.slSampIcPu * 780 / 1024, adc_stDownOut.swIcPu, 10);
                         }
-                        // else if(adc_stDownOut.ulISamplePeakPu > 25800) 
-                        // {
-                        //     EXPECT_NEAR((double)adc_stDownOut.slSampIaPu * 1024 / 1024, adc_stDownOut.swIaPu, 10);  ///< 系数为立即数，程序中更改后测试用例需要随之更改
-                        //     EXPECT_NEAR((double)adc_stDownOut.slSampIbPu * 1024 / 1024, adc_stDownOut.swIbPu, 10);
-                        //     EXPECT_NEAR((double)adc_stDownOut.slSampIcPu * 1024 / 1024, adc_stDownOut.swIcPu, 10);
-                        // }
                         else
                         {
                             EXPECT_NEAR((double)adc_stDownOut.slSampIaPu * 1024 / 1024, adc_stDownOut.swIaPu, 10);  ///< 系数为立即数，程序中更改后测试用例需要随之更改
@@ -258,11 +252,11 @@ TEST_P(CurSampleCalibTest1, SingResCalib)
                     {
                         if (1024 / rdsonCoef < adc_stCof.uwCalibcoefMin)
                         {
-                            if (currentMod * rdsonCoef * 100 >= ADC_IPHASE_CUR_MAX_AP)
+                            if (currentMod * rdsonCoef * 100 >= ADC_IPHASE_CUR_MAX_AP) ///< 电流采样削顶
                             {
-                                EXPECT_NEAR((double)adc_stDownOut.slSampIaPu * 780 / 1024, adc_stDownOut.swIaPu, 50);
-                                EXPECT_NEAR((double)adc_stDownOut.slSampIbPu * 780 / 1024, adc_stDownOut.swIbPu, 50);
-                                EXPECT_NEAR((double)adc_stDownOut.slSampIcPu * 780 / 1024, adc_stDownOut.swIcPu, 50);
+                                EXPECT_NEAR((double)adc_stDownOut.slSampIaPu * ADC_IPHASE_CUR_OVER_K / 1024, adc_stDownOut.swIaPu, 50);
+                                EXPECT_NEAR((double)adc_stDownOut.slSampIbPu * ADC_IPHASE_CUR_OVER_K / 1024, adc_stDownOut.swIbPu, 50);
+                                EXPECT_NEAR((double)adc_stDownOut.slSampIcPu * ADC_IPHASE_CUR_OVER_K / 1024, adc_stDownOut.swIcPu, 50);
                             }
                             else
                             {
@@ -279,17 +273,26 @@ TEST_P(CurSampleCalibTest1, SingResCalib)
                         }
                         else
                         {
-                            if (currentMod < 20)
+                            if (currentMod * rdsonCoef * 100 >= ADC_IPHASE_CUR_MAX_AP) ///< 电流采样削顶
                             {
-                                EXPECT_NEAR(ia * 100 * 16384 / IBASE, adc_stDownOut.swIaPu, 0.5 * 100 * 16384 / IBASE);
-                                EXPECT_NEAR(ib * 100 * 16384 / IBASE, adc_stDownOut.swIbPu, 0.5 * 100 * 16384 / IBASE);
-                                EXPECT_NEAR(ic * 100 * 16384 / IBASE, adc_stDownOut.swIcPu, 0.5 * 100 * 16384 / IBASE);
+                                EXPECT_NEAR((double)adc_stDownOut.slSampIbPu * ADC_IPHASE_CUR_OVER_K / 1024, adc_stDownOut.swIbPu, 50);
+                                EXPECT_NEAR((double)adc_stDownOut.slSampIcPu * ADC_IPHASE_CUR_OVER_K / 1024, adc_stDownOut.swIcPu, 50);
                             }
-                            else
+                            else 
                             {
-                                EXPECT_NEAR(ia * 100 * 16384 / IBASE, adc_stDownOut.swIaPu, 1.5 * 100 * 16384 / IBASE); 
-                                EXPECT_NEAR(ib * 100 * 16384 / IBASE, adc_stDownOut.swIbPu, 1.5 * 100 * 16384 / IBASE);
-                                EXPECT_NEAR(ic * 100 * 16384 / IBASE, adc_stDownOut.swIcPu, 1.5 * 100 * 16384 / IBASE);
+                                if (currentMod < 20)  
+                                {
+                                    EXPECT_NEAR(ia * 100 * 16384 / IBASE, adc_stDownOut.swIaPu, 0.5 * 100 * 16384 / IBASE);
+                                    EXPECT_NEAR(ib * 100 * 16384 / IBASE, adc_stDownOut.swIbPu, 0.5 * 100 * 16384 / IBASE);
+                                    EXPECT_NEAR(ic * 100 * 16384 / IBASE, adc_stDownOut.swIcPu, 0.5 * 100 * 16384 / IBASE);
+                                }
+                                else
+                                {
+                                    EXPECT_NEAR(ia * 100 * 16384 / IBASE, adc_stDownOut.swIaPu, 1.5 * 100 * 16384 / IBASE); 
+                                    EXPECT_NEAR(ib * 100 * 16384 / IBASE, adc_stDownOut.swIbPu, 1.5 * 100 * 16384 / IBASE);
+                                    EXPECT_NEAR(ic * 100 * 16384 / IBASE, adc_stDownOut.swIcPu, 1.5 * 100 * 16384 / IBASE);
+                                }
+                            
                             }
                         }
                     }

tests/unit_test/test_user.c

@@ -5,6 +5,7 @@ int testAdcInjectData1[2];
 int testAdcInjectData2[2];
 int testAdcIntFlg[2][2];
 int testTimerIntFlg[2][4];
+int testTimerIntFlag2[2];
 int testCh2CapValue[2];
 int testCh3CapValue[2];
 int testGpioBValue[2];
@@ -21,6 +22,8 @@ UWORD adc_uwRdsonVReg;
 UWORD adc_uwRdsonWReg;
 UWORD adc_uwADDMAPhase1;
 
+SYS_FMS_FLAG   switch_flg;
+
 int timer_interrupt_flag_get(int timer_periph, int interrupt)
 {
     return testTimerIntFlg[timer_periph][interrupt];

tests/unit_test/test_user.h

@@ -1,4 +1,5 @@
 #include "Cadence.h"
+#include "InputCapture.h"
 #include "bikespeed.h"
 #include "torquesensor.h"
 #include "adc.h"
@@ -19,6 +20,7 @@
 #include "Temp.h"
 #include "spdctrmode.h"
 #include "user.h"
+#include "FSM_1st.h"
 
 
 #include "api_rt.h"
@@ -51,9 +53,10 @@ extern "C" {
 #define ADC_IDATA0(adcx)   testAdcInjectData0[adcx]
 #define ADC_IDATA1(adcx)   testAdcInjectData1[adcx]
 #define ADC_IDATA2(adcx)   testAdcInjectData2[adcx]
-#define TIMER_CH2CV(timex) testCh2CapValue[timex]
-#define TIMER_CH3CV(timex) testCh3CapValue[timex]
+#define TIMER_CH2CV(timerx) testCh2CapValue[timerx]
+#define TIMER_CH3CV(timerx) testCh3CapValue[timerx]
 #define GPIO_ISTAT(gpiox)  testGpioBValue[gpiox]
+#define TIMER_INTF(timerx)  testTimerIntFlag2[timerx]
 
 //#define ABS(x) ((x) >= 0 ? (x) : (-(x)))
 
@@ -62,6 +65,7 @@ extern int testAdcInjectData1[2];
 extern int testAdcInjectData2[2];
 extern int testAdcIntFlg[2][2];
 extern int testTimerIntFlg[2][4];
+extern int testTimerIntFlag2[2];
 extern int testCh2CapValue[2];
 extern int testCh3CapValue[2];
 extern int testGpioBValue[2];