motor_ctl-4/tests/sim/sim_board/source/board.c

#include <math.h>

#include "board.h"
#include "isr.h"
#include "board_config.h"
#include "api_rt.h"

double BoardSampleTime       = 1e-6;
double BoardSampleRate       = 1000000;
int    BoardSampleTimeFactor = 72;

void AppInit();
void AppLoop();

/* 变量观测与控制参数Buffer */
double WatchBuffer[16];
double ControlBuffer[4];

/* 中断与时间片函数定义 */
void BackgroundTask(void *p);

/* 虚拟MCU初始化 */
void BoardInit(double ts)
{
    BoardSampleTime       = ts;
    BoardSampleRate       = 1 / ts;
    BoardSampleTimeFactor = (int)(HW_TIM_CLOCK_HZ / BoardSampleRate);

    /* 调度器初始化 */
    Sim_SchedulerInit(&scheduler);
    /* 外设初始化 */
    Sim_PwmInit(&pwm);
    Sim_AdcInit(&adc);
    Sim_AdcInit(&adc2);
    Sim_AdcInit(&adc3);
    Sim_GpioInit(&ledPin);
    Sim_GpioInit(&capPin);
    Sim_GpioInit(&switchHallA);
    Sim_GpioInit(&switchHallB);
    Sim_GpioInit(&switchHallC);
    Sim_GpioInit(&breakPin);
    Sim_GpioInit(&bikeBrakePin);
    Sim_TimerInit(&sysTick);
    Sim_TimerInit(&tbsTick);
    Sim_TimerInit(&tbcHalfUpdateTick);
    Sim_TimerInit(&event1MsTick);
    Sim_TimerInit(&sampleTrigTimer);
    Sim_TimerInit(&sampleTrigTimer2);
    Sim_DMAInit(&pwmLoadDma);
    Sim_CaptureInit(&cadenceCap);
    Sim_CaptureInit(&bikeSpdCap);
    Sim_CaptureInit(&switchhalCap);

    /* 调度器外设注册 */
    scheduler.Register(&scheduler, &pwm.Base);
    scheduler.Register(&scheduler, &adc.Base);
    scheduler.Register(&scheduler, &adc2.Base);
    scheduler.Register(&scheduler, &adc3.Base);
    scheduler.Register(&scheduler, &ledPin.Base);
    scheduler.Register(&scheduler, &capPin.Base);
    scheduler.Register(&scheduler, &switchHallA.Base);
    scheduler.Register(&scheduler, &switchHallB.Base);
    scheduler.Register(&scheduler, &switchHallC.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);
    scheduler.Register(&scheduler, &event1MsTick.Base);
    scheduler.Register(&scheduler, &sampleTrigTimer.Base);
    scheduler.Register(&scheduler, &sampleTrigTimer2.Base);
    scheduler.Register(&scheduler, &pwmLoadDma.Base);
    scheduler.Register(&scheduler, &cadenceCap.Base);
    scheduler.Register(&scheduler, &bikeSpdCap.Base);
    scheduler.Register(&scheduler, &switchhalCap.Base);
    /* Pwm配置 */
    pwm.CntMode             = SIM_PWM_UP_DOWN;
    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;
    pwm.OCPolarity[3]       = SIM_PWM_POLARITY_HIGH;
    pwm.OCPolarity[4]       = SIM_PWM_POLARITY_HIGH;
    pwm.OCPolarity[5]       = SIM_PWM_POLARITY_HIGH;
    pwm.CmpPreloadEnable[0] = 0;
    pwm.CmpPreloadEnable[1] = 0;
    pwm.CmpPreloadEnable[2] = 0;
    pwm.PeriodPreloadEnable = 1;
    pwm.TotalCntNumInput    = TICK_TRANS(HW_INIT_HPWM_PERIOD);
    pwm.TotalCntNumCurrent  = TICK_TRANS(HW_INIT_HPWM_PERIOD);
    pwm.CmpValueCurrent[0]  = TICK_TRANS(HW_INIT_HHPWM_PERIOD);
    pwm.CmpValueCurrent[1]  = TICK_TRANS(HW_INIT_HHPWM_PERIOD);
    pwm.CmpValueCurrent[2]  = TICK_TRANS(HW_INIT_HHPWM_PERIOD);
    pwm.CmpValueInput[0]    = TICK_TRANS(HW_INIT_HHPWM_PERIOD);
    pwm.CmpValueInput[1]    = TICK_TRANS(HW_INIT_HHPWM_PERIOD);
    pwm.CmpValueInput[2]    = TICK_TRANS(HW_INIT_HHPWM_PERIOD);
    pwm.TotalDeadNum        = TICK_TRANS(HW_DEADBAND_TIME);
    pwm.BridgeOffFlag[0]    = 0;
    pwm.BridgeOffFlag[1]    = 0;
    pwm.BridgeOffFlag[2]    = 0;
    // scheduler.TriggerBind(&scheduler, &pwm.Base, PwmTriggerOutUpdate, &adc.Base, AdcTriggerInSample);

    /* Pwm Break触发 */
    breakPin.Mode     = GPIO_MODE_IN;
    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;
    sampleTrigTimer.PreloadEnable        = 1;
    sampleTrigTimer.CountReloadInput     = TICK_TRANS(HW_INIT_HPWM_PERIOD * 2);
    sampleTrigTimer._CountReloadValue    = TICK_TRANS(HW_INIT_HPWM_PERIOD * 2);
    sampleTrigTimer.ComparePreloadEnable = 0;
    sampleTrigTimer._CompareValue        = TICK_TRANS(HW_SAMPLE_BEFORE_UPDATE_CNTS);
    sampleTrigTimer.CompareReloadInput   = TICK_TRANS(HW_SAMPLE_BEFORE_UPDATE_CNTS);
    scheduler.TriggerBind(&scheduler, &sampleTrigTimer.Base, TimerTriggerOutCCIF, &adc.Base, AdcTriggerInSample);

    /* 采样触发定时器配置2 */
    sampleTrigTimer2.CountMode            = TimerCenterAlignedMode2;
    sampleTrigTimer2.CountDir             = TimerCountUp;
    sampleTrigTimer2.PreloadEnable        = 1;
    sampleTrigTimer2.CountReloadInput     = TICK_TRANS(HW_INIT_HPWM_PERIOD);
    sampleTrigTimer2._CountReloadValue    = TICK_TRANS(HW_INIT_HPWM_PERIOD);
    sampleTrigTimer2.ComparePreloadEnable = 0;
    sampleTrigTimer2._CompareValue        = TICK_TRANS(HW_SAMPLE_BEFORE_UPDATE_CNTS);
    sampleTrigTimer2.CompareReloadInput   = TICK_TRANS(HW_SAMPLE_BEFORE_UPDATE_CNTS);
    scheduler.TriggerBind(&scheduler, &sampleTrigTimer2.Base, TimerTriggerOutCCIF, &adc2.Base, AdcTriggerInSample);
    // sampleTrigTimer2.Base.Enable = 0;

    /* 采样触发定时器配置3 */
    //scheduler.TriggerBind(&scheduler, &sampleTrigTimer2.Base, TimerTriggerOutCCIF, &adc3.Base, AdcTriggerInSample);
    
    /* Tbc半更新定时器配置 */
    tbcHalfUpdateTick.CountMode             = TimerEdgeAlignedMode;
    tbcHalfUpdateTick.CountDir              = TimerCountUp;
    tbcHalfUpdateTick.PreloadEnable         = 0;
    tbcHalfUpdateTick.CountReloadInput      = TICK_TRANS(HW_INIT_PWM_PERIOD - 1);

    /* Tbs定时器配置 */
    tbsTick.CountMode             = TimerEdgeAlignedMode;
    tbsTick.CountDir              = TimerCountUp;
    tbsTick.PreloadEnable         = 0;
    tbsTick.CountReloadInput      = TICK_TRANS(HW_TIM_CLOCK_HZ / HW_INIT_FTBS_HZ - 1);
    tbsTick.UpdateInterruptEnable = 1;
    //scheduler.InterruptBind(&scheduler, &tbsTick.Base, TimerInterruptOutUIF, TbsTimerIsr);

    /* Event1Ms定时器配置 */
    event1MsTick.CountMode             = TimerEdgeAlignedMode;
    event1MsTick.CountDir              = TimerCountUp;
    event1MsTick.PreloadEnable         = 0;
    event1MsTick.CountReloadInput      = TICK_TRANS(HW_TIM_CLOCK_HZ / 1000 - 1);
    event1MsTick.UpdateInterruptEnable = 1;
    
    /* SysTick定时器配置 */
    sysTick.CountMode             = TimerEdgeAlignedMode;
    sysTick.CountDir              = TimerCountDown;
    sysTick.PreloadEnable         = 0;
    sysTick.UpdateInterruptEnable = 1;
    sysTick.CountReloadInput      = TICK_TRANS(HW_TIM_CLOCK_HZ / 1000);
    //scheduler.InterruptBind(&scheduler, &sysTick.Base, TimerInterruptOutUIF, SystickIsr);

    /* Capture配置 */
    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;

    switchhalCap.CountMax                   = TICK_TRANS(HW_TIM_CLOCK_HZ / HW_INIT_FTBS_HZ - 1);
    switchhalCap.CounterInterruptEnable     = 1;
    switchhalCap.Channel[0].Edge            = CaptureRisingFallingEdge;
    switchhalCap.Channel[0].Enable          = 1;
    switchhalCap.Channel[0].InterruptEnable = 1;
    switchhalCap.Channel[1].Edge            = CaptureRisingFallingEdge;
    switchhalCap.Channel[1].Enable          = 1;
    switchhalCap.Channel[1].InterruptEnable = 1;
    switchhalCap.Channel[2].Edge            = CaptureRisingFallingEdge;
    switchhalCap.Channel[2].Enable          = 1;
    switchhalCap.Channel[2].InterruptEnable = 1;

    //scheduler.InterruptBind(&scheduler, &bikeSpdCap.Base, CaptureInterruptOut1, CaptureIsr);

    scheduler.AppTimeSlice.Add(&scheduler.AppTimeSlice, 1, 1, 0, BackgroundTask);

    iRt_Init();

    AppInit();

    iPwm_SetCountMax(0, HW_INIT_HPWM_PERIOD);
    iPwm_SetCompareValue(0, 0, HW_INIT_HHPWM_PERIOD);
    iPwm_SetCompareValue(0, 1, HW_INIT_HHPWM_PERIOD);
    iPwm_SetCompareValue(0, 2, HW_INIT_HHPWM_PERIOD);
    iPwm_SetCompareValueDelay(0, 0, HW_INIT_HHPWM_PERIOD);
    iPwm_SetCompareValueDelay(0, 1, HW_INIT_HHPWM_PERIOD);
    iPwm_SetCompareValueDelay(0, 2, HW_INIT_HHPWM_PERIOD);
    uint32_t ticks[3] = {2000, 4000, 6000};
    iPwm_SyncMultiSamplingCountUp(0, ticks, 3);
    iPwm_EnableSyncMultiSampling(0);
}

void BackgroundTask(void *p)
{
    /* 应用层软件循环 */
    AppLoop();
}