BatterySwap/System/Vehicle/AppFunc.c

/*
 * @Author       : ChenJie
 * @Date         : 2021-12-15 10:40:06
 * @Version      : V3.0
 * @LastEditors  : ChenJie
 * @LastEditTime : 2021-12-29 15:49:58
 * @Description  : AppFunc
 * @FilePath     : \VehicleControl\VehicleControl\src\System\Vehicle\AppFunc.c
 */
#include "string.h"
#include "stdlib.h"
#include "HardwareLib.h"
#include "CanVar.h"
#include "math.h"
#include "AppFunc.h"
#include "Std_Types.h"
/**
 * @brief : 互锁检测函数
 * @param {*}
 * @return {*}
 */
void GetHVLockState(void)
{
	UINT8 m_flg_HVlock1 = 0,m_flg_HVlock2 = 0;
    // PWM输出，互锁1检测，频率100HZ，占空比30%
    uint16 VehCo_fTestUI = 1000;
    uint16 VehCo_rTestUW = 3000;
    uint32 PwmFreAcq = 0;
    uint16 PwmDutyAcq = 0;
    PPWMDrv_Interface(_PPWM_INDEX_HVLOCK2, VehCo_fTestUI, VehCo_rTestUW);
    PulseAcqDrv_GetChanFreq(_PULSEACQ_INDEX_HVLOCK2, &PwmFreAcq, &PwmDutyAcq);
    if (abs(PwmFreAcq - VehCo_fTestUI) < 100 && abs(PwmDutyAcq - VehCo_rTestUW) < 500)
    {
    	m_flg_HVlock1 = 1;
    }
    else
    {
    	m_flg_HVlock1 = 0;
    }
    //互锁2检测，配置高有效，悬空为0则未接入，高电平为1则接入，
    DINDrv_SetChanThres(_DIN_INDEX_PLUGHVLOCK, 0, 4095 * 3);
    m_flg_HVlock2 = DINDrv_GetChanState(_DIN_INDEX_PLUGHVLOCK);
}
/**
 * @brief : 数字量传感器信号检测函数
 * @param {*}
 * @return {*}
 */
void GetDIOState(void)
{
    uint8 temp[4];
    //松开传感器检测，配置低有效，底层悬空为1，触发为0,应用层输出悬空为0，触发为1
    memset(temp, 0x00, 4);
    DINDrv_SetChanThres(_DIN_INDEX_UNLOCKSENSOR1, 1, 4095U);
    DINDrv_SetChanThres(_DIN_INDEX_UNLOCKSENSOR2, 1, 4095U);
    DINDrv_SetChanThres(_DIN_INDEX_UNLOCKSENSOR3, 1, 4095U);
    DINDrv_SetChanThres(_DIN_INDEX_UNLOCKSENSOR4, 1, 4095U);
    temp[0] = !DINDrv_GetChanState(_DIN_INDEX_UNLOCKSENSOR1);
    temp[1] = !DINDrv_GetChanState(_DIN_INDEX_UNLOCKSENSOR2);
    temp[2] = !DINDrv_GetChanState(_DIN_INDEX_UNLOCKSENSOR3);
    temp[3] = !DINDrv_GetChanState(_DIN_INDEX_UNLOCKSENSOR4);
    ebcd_st_unlockSensor = (getbit(temp[3], 0) << 3) | (getbit(temp[2], 0) << 2) | (getbit(temp[1], 0) << 1) | (getbit(temp[0], 0) << 0);

    //夹紧传感器检测，配置低有效，底层悬空为1，触发为0,应用层输出悬空为0，触发为1
    memset(temp, 0x00, 4);
    DINDrv_SetChanThres(_DIN_INDEX_LOCKSENSOR1, 1, 4095U);
    DINDrv_SetChanThres(_DIN_INDEX_LOCKSENSOR2, 1, 4095U);
    DINDrv_SetChanThres(_DIN_INDEX_LOCKSENSOR3, 1, 4095U);
    DINDrv_SetChanThres(_DIN_INDEX_LOCKSENSOR4, 1, 4095U);
    temp[0] = !DINDrv_GetChanState(_DIN_INDEX_LOCKSENSOR1);
    temp[1] = !DINDrv_GetChanState(_DIN_INDEX_LOCKSENSOR2);
    temp[2] = !DINDrv_GetChanState(_DIN_INDEX_LOCKSENSOR3);
    temp[3] = !DINDrv_GetChanState(_DIN_INDEX_LOCKSENSOR4);
    ebcd_st_lockSensor = (getbit(temp[3], 0) << 3) | (getbit(temp[2], 0) << 2) | (getbit(temp[1], 0) << 1) | (getbit(temp[0], 0) << 0);

    //落座传感器检测，配置高有效，悬空为0则未接入，高电平为1则接入
    memset(temp, 0x00, 4);
    DINDrv_SetChanThres(_DIN_INDEX_READYSENSOR1, 0, 4095 * 3);
    DINDrv_SetChanThres(_DIN_INDEX_READYSENSOR2, 0, 4095 * 3);
    temp[0] = DINDrv_GetChanState(_DIN_INDEX_READYSENSOR1);
    temp[1] = DINDrv_GetChanState(_DIN_INDEX_READYSENSOR1);
    ebcd_st_pedstSensor = (getbit(temp[1], 0) << 1) | (getbit(temp[0], 0) << 0);
}

/**
 * @brief : 获取模拟量输入值，并进行转换
 * @param {*}
 * @return {*}
 */
void GetAIOValue(void)
{
    uint16 AirPressureTemp_Vol = 0;
    uint16 PluginTemp1_Vol = 0;
    uint32 PluginTemp1_R = 0;
    uint16 PluginTemp2_Vol = 0;
    uint32 PluginTemp2_R = 0;
    uint16 PluginTemp3_Vol = 0;
    uint32 PluginTemp3_R = 0;
    uint16 PluginTemp4_Vol = 0;
    uint32 PluginTemp4_R = 0;

    AirPressureTemp_Vol = ATDDrv_GetChanResult(_ATD_INDEX_AIRPRESSURE);
    /*气压数据转换*/
    ebcd_P_airSensor = (uint16)(AirPressureTemp_Vol * 1000 / 4095.0);
    /*温度采集获取*/
    PluginTemp1_Vol = ATDDrv_GetChanResult(_ATD_INDEX_PLUGINTEMP1);
    PluginTemp2_Vol = ATDDrv_GetChanResult(_ATD_INDEX_PLUGINTEMP2);
    PluginTemp3_Vol = ATDDrv_GetChanResult(_ATD_INDEX_PLUGINTEMP3);
    PluginTemp4_Vol = ATDDrv_GetChanResult(_ATD_INDEX_PLUGINTEMP4);
    PluginTemp1_R = (uint32)((PluginTemp1_Vol / (5.0 * 4095 - PluginTemp1_Vol)) * 1000.0);
    PluginTemp2_R = (uint32)((PluginTemp2_Vol / (5.0 * 4095 - PluginTemp2_Vol)) * 1000.0);
    PluginTemp3_R = (uint32)((PluginTemp3_Vol / (5.0 * 4095 - PluginTemp3_Vol)) * 1000.0);
    PluginTemp4_R = (uint32)((PluginTemp4_Vol / (5.0 * 4095 - PluginTemp4_Vol)) * 1000.0);
    ebcd_T_plugin[0] = (uint8)Look1_u32u16(PluginTemp1_R, R_table, T_table, 240);
    ebcd_T_plugin[1] = (uint8)Look1_u32u16(PluginTemp2_R, R_table, T_table, 240);
    ebcd_T_plugin[2] = (uint8)Look1_u32u16(PluginTemp3_R, R_table, T_table, 240);
    ebcd_T_plugin[3] = (uint8)Look1_u32u16(PluginTemp4_R, R_table, T_table, 240);
}
/**
 * @brief : lookUp Table Fun
 * @param {uint32} u0 x
 * @param {uint32} bp0 x_table
 * @param {uint16} table y_table
 * @param {uint16} maxIndex
 * @return {*}
 */
uint16 Look1_u32u16(uint32 u0, uint32 *bp0, uint16 *table, uint16 MaxLen)
{
    uint32 bpIdx = 0;
    uint32 iLeft = 0;
    uint32 iRght = 0;
    uint16 y = 0;
    uint32 yL_0d0 = 0;
    uint32 yR_0d0 = 0;
    uint32 maxIndex = MaxLen - 1;
    if (u0 <= bp0[0U])
    {
        iLeft = 0U;
        iRght = 0U;
    }
    else if (u0 < bp0[maxIndex])
    {
        //对折法寻找u0的位置
        bpIdx = maxIndex >> 1U;
        iLeft = 0U;
        iRght = maxIndex;
        while ((iRght - iLeft) > 1)
        {
            if (u0 < bp0[bpIdx])
            {
                iRght = bpIdx;
            }
            else
            {
                iLeft = bpIdx;
            }
            bpIdx = (iRght + iLeft) >> 1U;
        }
    }
    else
    {
        iLeft = maxIndex;
        iRght = maxIndex;
    }
    //找到位置以后计算插值
    if (iLeft != iRght)
    {
        //线性插值
        yR_0d0 = table[iLeft + 1U];
        yL_0d0 = table[iLeft];
        if (yR_0d0 >= yL_0d0)
        {
            y = (uint16)(((uint32)(u0 - bp0[iLeft]) * (yR_0d0 - yL_0d0)) / (bp0[iLeft + 1] - bp0[iLeft]) + yL_0d0);
        }
        else
        {
            y = (uint16)(yL_0d0 - ((uint32)(u0 - bp0[iLeft]) * (yL_0d0 - yR_0d0)) / (bp0[iLeft + 1] - bp0[iLeft]));
        }
    }
    else
    {
        y = (uint16)table[iLeft];
    }
    return y;
}
#ifdef _APP_TEST_CODE
void TestDeviceFun(void)
{
    uint8 ManuEnable = 0;
    //控制算法
    AccPedCD_Update();
    AccPedCD_Monitor();

    PulseAcqDrv_GetChanFreq(_PULSEACQ_INDEX_CP_CHAN, &VehCo_fInputUIA[0], &VehCo_rInputUWA[0]);

    // DODrv_SetChanState(_DO_INDEX_CPCTL_CHAN,(uint8)VehCo_bTestCPCtrlUW_C);

    uint16 DistenceBufferV[2] = {0, 0}, DistenceBufferR[2] = {0, 0};
    //开关1采集
    DINDrv_SetChanThres(_DIN_INDEX_BAK1_CHAN, 1, 4095U);
    Switch1 = !DINDrv_GetChanState(_DIN_INDEX_BAK1_CHAN);
    //手动控制采集
    DINDrv_SetChanThres(_DIN_INDEX_BAK2_CHAN, 1, 4095U);
    ManuEnable = !DINDrv_GetChanState(_DIN_INDEX_BAK2_CHAN);
    //位移量采集
    DistenceBufferV[0] = ATDDrv_GetChanResult(_ATD_INDEX_BAK3_CHAN);
    DistenceBufferR[0] = (uint16)((DistenceBufferV[0] / (5.0 * 4095 - DistenceBufferV[0])) * 1000.0);
    Distence1 = (uint16)((2132 - DistenceBufferR[0]) * (0.1219));
    //压力采集
    PressureValueBuffer = ATDDrv_GetChanResult(_ATD_INDEX_ACCPED1_CHAN);
    PressureValue = (uint32)(PressureValueBuffer * 1000 / 4095.0);
    //控制输出
    VehCo_ctEEPTestUI += 10;
    VehCo_ctEEPTestUB += 10;
    if (VehCo_ctEEPTestUI >= 4 * 1000)
    {
        PSwtDrv_Interface(_PSWT_INDEX_HBAK1_CHAN, 1); //输出 解锁持续9-4s
        ControlState = 1;                             //解锁
    }
    else
    {
        PSwtDrv_Interface(_PSWT_INDEX_HBAK1_CHAN, 0); //不输出
        ControlState = 2;                             //锁定 4 秒
    }
    if (VehCo_ctEEPTestUI >= 9 * 1000)
    {
        Control_Times++;
        VehCo_ctEEPTestUI = 0;
    }
    if (ManuEnable == 0)
    {
        Control_Times = 0;
        VehCo_ctEEPTestUI = 0;
    }
}
#endif