#include "bmser_can_j1939_send.h"
#include "j1939_map_db_obj_cfg.h"
#include "bmser_utils.h"
#include "bmser_db_control_db.h"
#include "bcu_db_addr.h"
#include "bmser_log.h"
#include "j1939.h"
#include "xieneng_can_supervisor.h"
#include "bmser_can_j1939_syn_data.h"
#include "bmser_can_j1939_recv.h"

#define BMS_FUNC_ENABLE_INQUIRE_DETAIL_INFO         1
#ifndef BMS_FUNC_ENABLE_INQUIRE_DETAIL_INFO
  #error BMS_FUNC_ENABLE_INQUIRE_DETAIL_INFO not define
#endif

#define HUB_REG_SEND_CFG_MSG_FRE                    2      /* 单位:10ms */
#define HUB_UPDATE_COMM_STATE_FRE                   100    /* 单位:10ms */
#define HUB_START_REQUEST_REG_LOOP_CNT              150    /* 单位:10ms,由于通信接收数据处理的地方，上电等待1S之后才进行处理，则HUB请求数据也要延时1.2S之后才开始请求 */
#define BMS_CANRBUS_WRITE_RESP_TIMEOUT              2      /* 单位:20ms */
#define BMS_CANRBUS_WRITE_RESP_TIMEOUT_MAX_TIMES    5
#define HUB_WAITE_MAIN_RESP_TIMEOUT_COUNT           5      /*通信响应超时,单位:S*/
#define HUB_WAITE_MAIN_RESP_TIMEOUT_RECOVER_COUNT   5      /*通信响应超时恢复,单位:S*/
#define REQUEST_NUM                                 128    
#define SWITCH_DETAIL_STEP_WAIT_LOOP_CNT            2      /*切入详细信息后，等待30ms后，若请求的周期到了，再进行请求详细信息:单位:10ms*/
#define SWITCH_OTHER_STEP_WAIT_LOOP_CNT             2      /*切入其他信息后，等待20ms后，再进行请求其他信息:单位:10ms*/
#define BMS_CANRBUS_FORWARD_TX_FIFO_SIZE            60
#define DETAIL_INQ_PERIOD_COMPRESS                  15     /* 多帧压缩详细信息请求周期，单位:10ms */
#define DETAIL_INQ_PERIOD                           25     /* 多帧非压缩详细信息请求周期，单位:10ms */
#define OTHER_INQ_PERIOD                            2      /* 单位:10ms */
#define INVALID_INDEX                               0xFF   /* 无效索引 */
#define HUB_QUERY_OTHER_INFO_INIT_CNT               3      /* 其他信息上电请求3次 */
#define HUB_QUERY_OTHER_INFO_MAX_CNT                40     /* 其他信息后续最多请求次数*/

typedef enum{
    HUB_MAIN_DB_INQUIRE_INFO_INIT,
    HUB_MAIN_DB_INQUIRE_SUMMARY_INFO,
    HUB_MAIN_DB_INQUIRE_DETAIL_INFO,
    HUB_MAIN_DB_INQUIRE_OTHER_INFO,

    /*不请求概要信息模式*/
    HUB_MAIN_DB_INQUIRE_DETAIL_INFO_ONLY,   //详细信息
    HUB_MAIN_DB_INQUIRE_OTHER_INFO_ONLY,    //其他信息
    
    HUB_MAIN_DB_INQUIRE_BUTT
}HUB_MAIN_DB_INQUIRE_STEP;

typedef struct{
    uint16_t tableIndex;
    uint16_t clusterIndex;
    uint16_t clusterStartIndex;    /*开始查询的簇地址*/
    uint16_t clusterEndIndex;      /*结束查询的簇地址*/
    uint32_t *inquireDetailMsgFlag;/*哪一位置1代表哪一簇收到*/
}HUB_MAIN_INQ_INFO;

typedef struct{
    uint32_t inquireCount;
    ComIf_Handle_Type canHandleId;
    uint32_t *lastInquireDetailLoopCnt;
    uint32_t *lastInquireSummaryLoopCnt;
}MAIN_BOARD_STRU;

typedef struct
{
    uint8_t mainInitIndex;         /*主控初始化完成需要*/
    uint8_t detailInqPeriod;       /*详细信息之间请求的周期*/
    uint8_t otherInqPeriod;        /*其他信息之间请求的周期*/
    uint8_t detailInqFlag;
    uint8_t lastMainInitIndex;
    uint16_t clusterNum;           /*每路can的查询簇数*/
    uint32_t inqCount;    
    uint32_t loopCnt;              /*请求时时间计数，unit:10ms*/ 
    uint32_t switchInqStepLoopCnt;/*切换请求状态时的时间*/
    uint32_t inquireDetailMsgRackInfo;/*每一位代表一簇*/
    HUB_MAIN_INQ_INFO curInqSummary;
    HUB_MAIN_INQ_INFO curInqDetail;
    HUB_MAIN_INQ_INFO curInqOther;
    HUB_MAIN_DB_INQUIRE_STEP curInqStep;
}J1939_TOTAL_MAIN_CAN_DATA_STRU;

typedef struct{

    uint32_t canId;
    uint32_t canRBusWriteTimeoutTimes;
    uint16_t canRBusWriteTimeoutCount;
    uint16_t canRBusWaitWiteRespFlag;
    uint8_t  dataLen;
    uint8_t  mainRegInqSummaryNum;
    uint8_t  mainRegInqDetailNum;
    uint8_t  mainRegInqOtherNum;
    uint8_t  cfgInfo[J1939_CFG_INFO_MSG_HEAD_LEN];
    CanMsg curRBusWriteMsg;
    uint8_t enable_rack_num;    // 使能的簇数
    uint8_t enable_can_num;     // 配置的can数量
    uint8_t detail_compress;    // 多帧是否压缩
    MAIN_BOARD_STRU mainBoard[BMS_CFG_ROCKSNUM_MAX];
    J1939_TOTAL_MAIN_CAN_DATA_STRU *totalMainCanInfo[CAN_OBJ_ID_MAX];
    Std_Bool_Enum isDebugMsg;
}J1939_MAIN_DATA_STRU;

J1939_MAIN_DATA_STRU *g_pJ1939MainData = NULL;
static uint32_t g_other_query_cnt = 0;

typedef struct{
#if(BMS_FUNC_ENABLE_INQUIRE_DETAIL_INFO == 1)
    J1939_INQUIRE_OPT_TYPE_ENUM msgType;/*请求消息类型*/
#else
    uint32_t msgType;/*请求消息类型*/
#endif
    uint16_t regNum;
    uint16_t triggerType;       /*消息触发类型*/
    uint16_t msgInquirePeriod;  /*请求时间周期，unit:10ms*/
    Std_Bool_Enum isMultipleFrame;/*是否是多帧消息*/
}J1939_BOARD_REG_INQUIRE_INFO_STRU;

typedef enum
{
    INQUIRE_PERIOD_500ms = 50,
    INQUIRE_PERIOD_1s = 100,
    INQUIRE_PERIOD_2s = 200,
    INQUIRE_PERIOD_4s = 400,
    INQUIRE_PERIOD_5s = 500,
    INQUIRE_PERIOD_10s = 1000,
    INQUIRE_PERIOD_11s = 1100,
    INQUIRE_PERIOD_15s = 1500,
    INQUIRE_PERIOD_17s = 1700,
    INQUIRE_PERIOD_32s = 3200,
    INQUIRE_PERIOD_100s = 10000,
    INQUIRE_PERIOD_305s = 30500,
    INQUIRE_PERIOD_BUTT = 50000,
}HUB_INQUIRE_INFO_PERIOD_ENUM;

typedef enum
{
    INQUIRE_INFO_TRIGGER_TYPE_PERIOD,/*周期请求*/
    INQUIRE_INFO_TRIGGER_TYPE_PERIOD_ACTIVE,/*周期请求+主动上报*/
    INQUIRE_INFO_TRIGGER_TYPE_PASSIVE_ACTIVE,/*被动请求+主动上报*/
    INQUIRE_INFO_TRIGGER_TYPE_PASSIVE,/*被动请求*/
    INQUIRE_INFO_TRIGGER_TYPE_BUTT,
}HUB_INQUIRE_INFO_TRIGGER_TYPE_ENUM;

/* DB查询表需根据概要信息和详细信息分类 */
#if(BMS_FUNC_ENABLE_INQUIRE_DETAIL_INFO == 1)
J1939_BOARD_REG_INQUIRE_INFO_STRU g_J1939SummaryPara[]=
{
    /*******************************************概要信息开始 500ms**************************/
    {J1939_INQUIRE_OPT_TYPE_ALARM_INFO,              0,  INQUIRE_INFO_TRIGGER_TYPE_PERIOD_ACTIVE,     INQUIRE_PERIOD_500ms,  Std_False},
    {J1939_INQUIRE_OPT_TYPE_CMD_INFO,                0,  INQUIRE_INFO_TRIGGER_TYPE_PERIOD,            INQUIRE_PERIOD_500ms,  Std_False},
    {J1939_INQUIRE_OPT_TYPE_STATISTICS_INFO,         0,  INQUIRE_INFO_TRIGGER_TYPE_PERIOD,            INQUIRE_PERIOD_500ms,  Std_False},
    {J1939_INQUIRE_OPT_TYPE_STATE_INFO,              0,  INQUIRE_INFO_TRIGGER_TYPE_PERIOD,            INQUIRE_PERIOD_500ms,  Std_False},
    {J1939_INQUIRE_OPT_TYPE_SAMPLE_INFO,             0,  INQUIRE_INFO_TRIGGER_TYPE_PERIOD,            INQUIRE_PERIOD_500ms,  Std_False},
    {J1939_INQUIRE_OPT_TYPE_CAPACITY_STATISTICS_INFO,0,  INQUIRE_INFO_TRIGGER_TYPE_PERIOD,            INQUIRE_PERIOD_10s,    Std_False},
    {J1939_INQUIRE_OPT_TYPE_PROJECT_INFO,            0,  INQUIRE_INFO_TRIGGER_TYPE_PERIOD,            INQUIRE_PERIOD_2s,     Std_False},
    {J1939_INQUIRE_OPT_TYPE_PROJECT_CFG_INFO,        0,  INQUIRE_INFO_TRIGGER_TYPE_PERIOD,            INQUIRE_PERIOD_5s,     Std_False},
    /*******************************************概要信息结束********************************/
};
#else

#define J1939_INQUIRE_OPT_TYPE_ALARM_CMD_INFO ((1<<J1939_INQUIRE_OPT_TYPE_ALARM_INFO)|(1<<J1939_INQUIRE_OPT_TYPE_CMD_INFO)) /*5+4*/
#define J1939_INQUIRE_OPT_TYPE_SAMPLE_STATE_INFO ((1<<J1939_INQUIRE_OPT_TYPE_SAMPLE_INFO)|(1<<J1939_INQUIRE_OPT_TYPE_STATE_INFO)) /*6+6*/
#define J1939_INQUIRE_OPT_TYPE_SUMMARY_INFO (1<<J1939_INQUIRE_OPT_TYPE_STATISTICS_INFO) /*9*/
#define J1939_INQUIRE_OPT_TYPE_CAPACITY_INFO (1<<J1939_INQUIRE_OPT_TYPE_CAPACITY_STATISTICS_INFO) /*3*/

#define J1939_INQUIRE_OPT_TYPE_PROJECT_STATE_INFO (1<<J1939_INQUIRE_OPT_TYPE_PROJECT_INFO)
#define J1939_INQUIRE_OPT_TYPE_PROJECT_CONFIG_INFO (1<<J1939_INQUIRE_OPT_TYPE_PROJECT_CFG_INFO)

J1939_BOARD_REG_INQUIRE_INFO_STRU g_J1939SummaryPara[]=
{
    /*******************************************概要信息开始 500ms**************************/
    {J1939_INQUIRE_OPT_TYPE_ALARM_CMD_INFO,                     0,  INQUIRE_INFO_TRIGGER_TYPE_PERIOD,           INQUIRE_PERIOD_500ms,  Std_False},
    {J1939_INQUIRE_OPT_TYPE_SAMPLE_STATE_INFO,                  0,  INQUIRE_INFO_TRIGGER_TYPE_PERIOD,           INQUIRE_PERIOD_500ms,  Std_False},
    {J1939_INQUIRE_OPT_TYPE_SUMMARY_INFO,                       0,  INQUIRE_INFO_TRIGGER_TYPE_PERIOD,           INQUIRE_PERIOD_500ms,  Std_False},
    {J1939_INQUIRE_OPT_TYPE_CAPACITY_INFO,                      0,  INQUIRE_INFO_TRIGGER_TYPE_PERIOD,           INQUIRE_PERIOD_10s,    Std_False},
    /*******************************************概要信息结束********************************/
};
#endif

J1939_BOARD_REG_INQUIRE_INFO_STRU g_J1939DetailPara[]=
{
    /*******************************************详细信息开始 1S*********************/
    {J1939_INQUIRE_OPT_TYPE_BAT_VOL_INFO,       MAX_BATTERY_NUM_IN_ONE_CLUSTER,                                       INQUIRE_INFO_TRIGGER_TYPE_PERIOD,         INQUIRE_PERIOD_1s,     Std_True},
    {J1939_INQUIRE_OPT_TYPE_BAT_TEMP,           MAX_BAT_TEMPERATURE_NUM_IN_ONE_CLUSTER,                               INQUIRE_INFO_TRIGGER_TYPE_PERIOD,         INQUIRE_PERIOD_4s,     Std_True},
    {J1939_INQUIRE_OPT_TYPE_POLARITY_TEMP_INFO, (ANODE_TEMP_NUM_IN_ONE_CLUSTER*2),                                    INQUIRE_INFO_TRIGGER_TYPE_PERIOD,         INQUIRE_PERIOD_4s,     Std_True},    
    // {J1939_INQUIRE_OPT_TYPE_BOARD_TEMP_INFO,    (PASSIVE_TEMP_NUM_IN_ONE_CLUSTER + PASSIVE_TEMP_NUM_IN_ONE_CLUSTER),   INQUIRE_INFO_TRIGGER_TYPE_PERIOD,         INQUIRE_PERIOD_11s,    Std_True},
    // {J1939_INQUIRE_OPT_TYPE_PACK_TOTAL_VOLTAGE, MAX_PACK_NUM_IN_ONE_CLUSTER,                                          INQUIRE_INFO_TRIGGER_TYPE_PERIOD,         INQUIRE_PERIOD_5s,     Std_True},   
    // {J1939_INQUIRE_OPT_TYPE_TEMP_RISE_INFO,     MAX_BAT_TEMPERATURE_NUM_IN_ONE_CLUSTER,                               INQUIRE_INFO_TRIGGER_TYPE_PERIOD,         INQUIRE_PERIOD_5s,     Std_True},
    // {J1939_INQUIRE_OPT_TYPE_BALANCE_STATE,      MAX_BATTERY_NUM_IN_ONE_CLUSTER,                                       INQUIRE_INFO_TRIGGER_TYPE_PERIOD,         INQUIRE_PERIOD_32s,    Std_True},
    {J1939_INQUIRE_OPT_TYPE_CELL_SOC,           MAX_BATTERY_NUM_IN_ONE_CLUSTER,                                       INQUIRE_INFO_TRIGGER_TYPE_PERIOD,         INQUIRE_PERIOD_17s,    Std_True},
    {J1939_INQUIRE_OPT_TYPE_CELL_SOH,           MAX_BATTERY_NUM_IN_ONE_CLUSTER,                                       INQUIRE_INFO_TRIGGER_TYPE_PERIOD,         INQUIRE_PERIOD_100s,   Std_True},
    {J1939_INQUIRE_OPT_TYPE_BAT_RES_INFO,       RESISTANCE_NUM_IN_ONE_CLUSTER,                                       INQUIRE_INFO_TRIGGER_TYPE_PERIOD,         INQUIRE_PERIOD_305s,   Std_True},
    /*******************************************详细信息结束******************************/
};

J1939_BOARD_REG_INQUIRE_INFO_STRU g_J1939OtherPara[]=
{
    /*******************************************告警参数及调试信息开始*********************/
    {J1939_INQUIRE_OPT_TYPE_ALARM_PROTECT_PARA,  0,  INQUIRE_INFO_TRIGGER_TYPE_PASSIVE,           0u,     Std_False},
    {J1939_INQUIRE_OPT_TYPE_FUN_PARA_CFG_INFO,   0,  INQUIRE_INFO_TRIGGER_TYPE_PASSIVE,           0u,     Std_False},
    {J1939_INQUIRE_OPT_TYPE_DEBUG_INFO,          0,  INQUIRE_INFO_TRIGGER_TYPE_PASSIVE,           0u,     Std_False},    
    {J1939_INQUIRE_OPT_TYPE_VERSION_INFO,        0,  INQUIRE_INFO_TRIGGER_TYPE_PASSIVE,           0u,     Std_False},    
    /*******************************************告警参数及调试信息结束*********************/
};

/**@brief       J1939CAN消息发送
 * @param[in]   ComIf_Handle_Type handle 通信的handleID
 * @param[in]   CanMsg *pTxMsg 发送的CAN消息内容
 * @return      void 
 * @retval      void
 * @par         修改日志:
 * Date         Author      Description           \n
 * 2023-05-09   jyg  Create        \n
 */
int32_t HubMainDbJ1939_SendMsg(ComIf_Handle_Type handle,CanMsg *pTxMsg)
{
    int32_t ret = 0;
    pTxMsg->IDE = CAN_ID_EXT;
    ret = canInf_sendMsg(handle, pTxMsg);
    
    return ret;
}

/**@brief       获取主控是否进行初始化的状态
 * @param[in]   uint32_t canIdIndex
 * @return      mainInitState  主控是否进行初始化状态
 * @retval      初始化主控的ID
 * @par         修改日志:
 * Date                Author     Description           \n
 * 2021/08/11          zzk        创建初始版本     \n
 * 2022/11/23          zar        增加传参canIdIndex(用于区分总控can1查询和can2查询)      \n
 * 2023/05/08          jyg        增加对CANID索引与指针的合法性判断及修正结构体的内容结构\n
 * 2023/09/06          jyg        修正BCU初始化状态获取方式\n
 */
static uint16_t HubMainDbJ1939_GetMainInitState(uint32_t canIdIndex)
{
    uint64_t mainInitState = 0;
    uint8_t clusterIndex = 0;

    if((canIdIndex >= CAN_OBJ_ID_MAX)||(g_pJ1939MainData == NULL)||(g_pJ1939MainData->totalMainCanInfo[canIdIndex] == NULL))
    {
        return 0;
    }

    for(clusterIndex = (g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqOther.clusterStartIndex+1); clusterIndex <= (g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqOther.clusterEndIndex + 1); clusterIndex++)
    {
        J1939MasterRecvMsg_GetBcuInitState(canIdIndex,&mainInitState);
        if((mainInitState & (1<<clusterIndex)) != 0u)
        {
            g_pJ1939MainData->totalMainCanInfo[canIdIndex]->mainInitIndex = clusterIndex;
            return mainInitState;
        }
    }
    return mainInitState;
}

/**@brief       判断其他信息是否收到
 * @param[in]   uint32_t devid
 * @param[in]   uint32_t canIdIndex
 * @return      0有效，表示其他信息收到
 * @retval      是否有效，是否收齐
 * @par         修改日志:
 * Date                Author     Description           \n
 */
static int HubMainDbJ1939_checkOtherInfo(uint32_t devid, uint32_t canIdIndex)
{
    uint16_t buff = 0;
    char valid = 0;
    int ret = 0;
    int tableListItemNum, i, j = 0;
    uint16_t bankId = 0,rackId = 0;
    EMS_DEV_REG_DATA_S regData = {0};
    
    if((canIdIndex >= CAN_OBJ_ID_MAX)||(g_pJ1939MainData == NULL)||(g_pJ1939MainData->totalMainCanInfo[canIdIndex] == NULL))
    {
        return 0;
    }
    tableListItemNum = DbObjCfgJ1939_GetOtherInfoTableListItemNum();
    bmser_dev_calcBankIdAndRackIdByDevId(devid,&bankId,&rackId);
    for(i = 0;i<tableListItemNum;i++)
    {
        for(j = 0;j<g_J1939_OtherInfoTableList[i].inquireOptTypeItemsNum;j++)
        {
            if(g_J1939_OtherInfoTableList[i].pfMapDbAddrTable[j].visualizationLevel == VISUALIZATION_LEVEL_O)
            {
                continue;
            }
            regData.bankId = bankId;
            regData.rackId = rackId;
            regData.startAddr = g_J1939_OtherInfoTableList[i].pfMapDbAddrTable[j].j1939_DbAddr;
            regData.regCount = 1;
            regData.len = regData.regCount*2;
            regData.dbValid = &valid;
            //通过DB有效值，判断其他信息是否收到
            if(BmserProtocolExt_ReadRegisterDb(&regData, (uint8_t*)&buff, regData.len) < 0)
            {
                ret = -1;
                break;
            }
        }
    }
    return ret;
}

/**@brief       20ms循环定时
 * @param[in]   void
 * @return      int32_t 
 * @retval      0：发送成功，非0：发送失败
 * @par         修改日志:
 * Date         Author      Description           \n
 * 2014-02-24   Wang Zheng  Create        \n
 * 2021-01-28   zwq         二代总控ram空间较大，可支持更多簇，调用周期减少为20ms（原30ms）
 * 2021-02-20   zwq         超时重发时间调整为40ms，多次后若仍旧没有写响应，不再发送该帧
 * 2022-11-28   zar          修复can1和can2串发报文的bug\n
 * 2023-02-16   zar          还原超时重发机制正常功能代码（修bug1091时被错误修改）\n
 * 2023-03-01   zzk         区分BAU最大簇数和使能簇数\n
 * 2023-05-08   jyg         增加对指针的合法性判断\n
 * 2023-05-09   jyg         修正簇索引计算及发送函数接口\n
 */
static int32_t HubMainDbJ1939_SerialSendCfgCanMsgToSlave(void)
{
    J1939_MAIN_DATA_STRU *pMainData = g_pJ1939MainData;
    uint32_t clusterIndex = 0;
    Std_Fault_State_Type timeoutCount = 0;

    if(pMainData == NULL)
    {
        return -1;
    }
    clusterIndex = ((pMainData->canId >> J1939_CANID_PS_POS) & 0xffu) - (J1939_PDU_BCUx_DEF_ADDR + 1);/*索引从0开始*/
    if(clusterIndex >= g_pJ1939MainData->enable_rack_num)
    {
        clusterIndex = 0;
    }
    /* 处于等待写响应的状态。如果超时了，重新发送上次发的消息 */
    if(pMainData->canRBusWaitWiteRespFlag == 1)
    {
        pMainData->canRBusWriteTimeoutCount++;
        if(pMainData->canRBusWriteTimeoutCount >= BMS_CANRBUS_WRITE_RESP_TIMEOUT)
        {
            pMainData->canRBusWriteTimeoutTimes++;
            if(pMainData->canRBusWriteTimeoutTimes >= BMS_CANRBUS_WRITE_RESP_TIMEOUT_MAX_TIMES)
            {
                timeoutCount++;
                pMainData->canRBusWriteTimeoutTimes = 0;
                pMainData->canRBusWaitWiteRespFlag = 0;
            }
            pMainData->canRBusWriteTimeoutCount = 0;
            HubMainDbJ1939_SendMsg(pMainData->mainBoard[clusterIndex].canHandleId, &pMainData->curRBusWriteMsg);
        }
    }
    return 0;
}

/**@brief       发送查询信息帧
 * @param[in]   clusterIndex 簇索引 (从0开始)
 * @param[in]   uint16_t msgType 请求消息类型
 * @param[in]   Std_Bool_Enum isMultipleFrame 请求消息是否是多帧
 * @return      int32_t
 * @retval      0:正常；-1:异常
 * @par         修改日志:
 * Date                Author     Description           \n
 * 2023/04/20          jyg        创建\n
 * 2023/05/08          jyg        增加对指针的合法性判断及修正结构体的内容结构\n
 * 2023/09/02          qzy        LINUX侧SA改为0xC1                         \n
 */   
static int32_t HubMainDbJ1939_InquireMainCanMsg(uint32_t clusterIndex, uint32_t msgOptType,Std_Bool_Enum isMultipleFrame)
{
    CanMsg txMsg = {0};
    J1939_CFG_INFO_STRU *pcfgInfo = NULL;
    uint8_t cmdOpt_PF = 0u,cmdOpt_PF_Offset = 0u,cmdOpt_P_Level = 0u;
    uint16_t tmpRegValue = 0u;

    if(g_pJ1939MainData == NULL)
    {
        return -1;
    }
    txMsg.CanId = ((J1939_PDU_LINUX_ADDR)|(((J1939_PDU_BCUx_DEF_ADDR + 1) + clusterIndex) <<J1939_CANID_PS_POS)| \
        (J1939_SINGLE_CFG_CMD_PF_VALUE << J1939_CANID_PF_POS)| (J1939_R_J1939<<J1939_CANID_R_POS)|(J1939_SINGLE_CFG_CMD_P_LEVEL_VALUE<<J1939_CANID_P_POS));

    if(msgOptType < (1<<J1939_INQUIRE_OPT_TYPE_ALARM_INFO))
    {
        /*指令1: 单体内阻,电池SOH,电池SOC,温升信息...*/
        cmdOpt_PF = J1939_CMD1_OPT_PF;
        cmdOpt_PF_Offset = J1939_CMD1_OPT_PF_OFFSET;
        cmdOpt_P_Level = J1939_CMD1_OPT_P;
    }
    else
    {
        /*指令2: 告警信息,指令信息,统计信息...*/
        cmdOpt_PF = J1939_CMD2_OPT_PF;
        cmdOpt_PF_Offset = J1939_CMD2_OPT_PF_OFFSET;
        cmdOpt_P_Level = J1939_CMD2_OPT_P;
        msgOptType = (uint32_t)((msgOptType >>16)<<2);/*其中有2位被传输类型及请求选项类型占用*/
    }
    
    pcfgInfo = (J1939_CFG_INFO_STRU *)txMsg.Data;
    pcfgInfo->operationType = J1939_CFG_OPT_TYPE_READ;
    pcfgInfo->priorityLevel = cmdOpt_P_Level;
    pcfgInfo->pfNum = cmdOpt_PF;
    pcfgInfo->offset = cmdOpt_PF_Offset;

    if(isMultipleFrame == Std_True)
    {
        if(g_pJ1939MainData->detail_compress)
        {
            /*多帧情况下，压缩方式请求*/
            tmpRegValue |=  (uint16_t)(1<<J1939_INQUIRE_OPT_TYPE_COMPRESSION_EN);
        }
        else
        {
            tmpRegValue |=  (uint16_t)(0<<J1939_INQUIRE_OPT_TYPE_COMPRESSION_EN);
        }
    }
    // 数据可视化等级(M和O),后续加入配置项
    // tmpRegValue |= (uint16_t)(1<<J1939_INQUIRE_OPT_TYPE_TRANSFER_MODE);
    tmpRegValue |= (uint16_t)msgOptType;/*请求消息类型*/
    pcfgInfo->cfgValue = HOST_TO_J1939_ENDIAN_16(tmpRegValue);
    txMsg.DLC = 6u;

    return HubMainDbJ1939_SendMsg(g_pJ1939MainData->mainBoard[clusterIndex].canHandleId,&txMsg);
}

/**@brief       修正上一次请求详细信息时的计时
 * @param[in]   int32_t canIdIndex 
 * @return      None
 * @retval      None
 * @par         修改日志:
 * Date                Author     Description           \n
 * 2023/08/16          jyg        创建初始版本     \n
 * 2023/08/22          jyg        修正重置修正条件，确保每种类型都请求过之后，再进行校准     \n
 */    
void HubMainDbJ1939_ResetLastInquireDetailLoopCnt(int32_t canIdIndex)
{
    uint16_t clusterIndex = 0u,tableIndex = 0u;
    uint16_t tmpMinDiffLoopCnt = 0u,tmpMaxDiffLoopCnt = 0u,tmpDiffLoopCnt = 0u;
    if((canIdIndex >= CAN_OBJ_ID_MAX)||(g_pJ1939MainData == NULL)||(g_pJ1939MainData->totalMainCanInfo[canIdIndex] == NULL))
    {
        return ;
    }

    for(tableIndex = 0u;tableIndex < g_pJ1939MainData->mainRegInqDetailNum;tableIndex++)
    {
        if(g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqDetail.inquireDetailMsgFlag[tableIndex] != g_pJ1939MainData->totalMainCanInfo[canIdIndex]->inquireDetailMsgRackInfo)
        {
            /*若本类型的详细信息的所有簇有部分簇没有查询过，则不进行重置*/
            continue;
        }
        if(g_J1939DetailPara[tableIndex].msgType == J1939_INQUIRE_OPT_TYPE_BAT_VOL_INFO)
        {
            /*同步电压不进行重置请求时的计时*/
            continue;
        }
        for(clusterIndex = 1u;clusterIndex < g_pJ1939MainData->totalMainCanInfo[canIdIndex]->clusterNum;clusterIndex++)
        {
            tmpMinDiffLoopCnt = g_J1939DetailPara[tableIndex].msgInquirePeriod/(2u*g_pJ1939MainData->totalMainCanInfo[canIdIndex]->clusterNum);
            tmpMaxDiffLoopCnt = (g_J1939DetailPara[tableIndex].msgInquirePeriod*3u)/(4u*g_pJ1939MainData->totalMainCanInfo[canIdIndex]->clusterNum);
            if(g_pJ1939MainData->mainBoard[clusterIndex].lastInquireDetailLoopCnt[tableIndex] > g_pJ1939MainData->mainBoard[clusterIndex -1u].lastInquireDetailLoopCnt[tableIndex])
            {
                tmpDiffLoopCnt = g_pJ1939MainData->mainBoard[clusterIndex].lastInquireDetailLoopCnt[tableIndex] - g_pJ1939MainData->mainBoard[clusterIndex -1u].lastInquireDetailLoopCnt[tableIndex];
            }
            else
            {
                tmpDiffLoopCnt = g_pJ1939MainData->mainBoard[clusterIndex -1u].lastInquireDetailLoopCnt[tableIndex] - g_pJ1939MainData->mainBoard[clusterIndex].lastInquireDetailLoopCnt[tableIndex];
            }
            if((tmpDiffLoopCnt < tmpMinDiffLoopCnt)||(tmpDiffLoopCnt > tmpMaxDiffLoopCnt))
            {
                g_pJ1939MainData->mainBoard[clusterIndex].lastInquireDetailLoopCnt[tableIndex] = g_pJ1939MainData->mainBoard[clusterIndex -1u].lastInquireDetailLoopCnt[tableIndex] + tmpMinDiffLoopCnt;
            }
        }
        /*校正过之前将请求的标志清空*/
        g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqDetail.inquireDetailMsgFlag[tableIndex] = 0u;
    }
}
    
/**@brief       状态转换器
 * @param[in]   state   下一个要转换的状态
 * @return      None
 * @retval      None
 * @par         修改日志:
 * Date                Author     Description           \n
 * 2023/04/20          jyg        创建初始版本     \n
 * 2023/05/08          jyg        增加对CANID索引与指针的合法性判断及修正结构体的内容结构\n
 * 2023/08/15          jyg        所有簇详细信息查询完毕后修正上一次请求详细信息时的计时\n
 */    
void HubMainDbJ1939_SwitchRegInquireMsgState(HUB_MAIN_DB_INQUIRE_STEP state, int32_t canIdIndex)
{
    if((canIdIndex >= CAN_OBJ_ID_MAX)||(g_pJ1939MainData == NULL)||(g_pJ1939MainData->totalMainCanInfo[canIdIndex] == NULL))
    {
        return ;
    }
    g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqStep = state;
    g_pJ1939MainData->totalMainCanInfo[canIdIndex]->inqCount = 0;
    g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqSummary.tableIndex = 0;
    g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqDetail.tableIndex = 0;
    g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqOther.tableIndex = 0;

    if(g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqSummary.clusterIndex >= (g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqSummary.clusterEndIndex + 1))
    {   
        g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqSummary.clusterIndex = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqSummary.clusterStartIndex;
    }   
    if(g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqDetail.clusterIndex >= (g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqDetail.clusterEndIndex + 1))
    {   
        g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqDetail.clusterIndex = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqDetail.clusterStartIndex;
        HubMainDbJ1939_ResetLastInquireDetailLoopCnt(canIdIndex);
    }
    if(g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqOther.clusterIndex >= (g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqOther.clusterEndIndex + 1))
    {   
        g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqOther.clusterIndex = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqOther.clusterStartIndex;
    }
    g_pJ1939MainData->totalMainCanInfo[canIdIndex]->switchInqStepLoopCnt = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->loopCnt;
}



/**@brief       初始化主动发送查询指令，周期10ms
 * @param[in]   CanId   总控查询使用的canID
 * @return      None
 * @retval      未使用
 * @par         修改日志:
 * Date                Author     Description           \n
 * 2023/04/23          jyg        创建初始版本     \n
 * 2023/05/08          jyg        增加对CANID索引与指针的合法性判断及修正结构体的内容结构\n
 * 2023/05/11          jyg        修正进入其他请求时的请求类型指令\n
 * 2023/05/11          jyg        修正进入其他请求时的要有时间间隔\n
 */
Std_Ret_Type HubMainDbJ1939_RegInquireMsg_Init(int32_t canIdIndex)
{
    uint32_t tableIndex = 0;
    uint32_t clusterIndex = 0;
    uint32_t msgOptType = 0;
 
    if((canIdIndex >= CAN_OBJ_ID_MAX)||(g_pJ1939MainData == NULL)||(g_pJ1939MainData->totalMainCanInfo[canIdIndex] == NULL))
    {
        return Std_Ret_ERR;
    } 
    clusterIndex = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqOther.clusterIndex;
    if(g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqSummary.tableIndex < g_pJ1939MainData->mainRegInqSummaryNum)  //先请求一簇的概要信息（30ms）
    {
        tableIndex = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqSummary.tableIndex;  
        msgOptType = (uint32_t)(1<<g_J1939SummaryPara[tableIndex].msgType);
        if(HubMainDbJ1939_InquireMainCanMsg(clusterIndex,msgOptType,g_J1939SummaryPara[tableIndex].isMultipleFrame) >= 0)
        {
            g_pJ1939MainData->mainBoard[clusterIndex].lastInquireSummaryLoopCnt[tableIndex] = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->loopCnt;
            g_pJ1939MainData->mainBoard[clusterIndex].inquireCount++;
        }
        g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqSummary.tableIndex++;
    }
    else
    {
        /*若该簇的概要信息请求完，则请求该簇其他信息（70ms）*/
        g_pJ1939MainData->totalMainCanInfo[canIdIndex]->inqCount++;
        if((g_pJ1939MainData->totalMainCanInfo[canIdIndex]->inqCount % g_pJ1939MainData->totalMainCanInfo[canIdIndex]->otherInqPeriod) > 0u)
        {
            return Std_Ret_OK;
        }
        tableIndex = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqOther.tableIndex;  
        msgOptType = (uint32_t)(1<<g_J1939OtherPara[tableIndex].msgType);
        if(HubMainDbJ1939_InquireMainCanMsg(clusterIndex,msgOptType,g_J1939OtherPara[tableIndex].isMultipleFrame) >= 0)
        {
            g_pJ1939MainData->mainBoard[clusterIndex].inquireCount++;
        }
        if(g_J1939OtherPara[tableIndex].regNum > REQUEST_NUM)
        {
            g_pJ1939MainData->totalMainCanInfo[canIdIndex]->otherInqPeriod = OTHER_INQ_PERIOD*2;
        }
        else
        {
            g_pJ1939MainData->totalMainCanInfo[canIdIndex]->otherInqPeriod = OTHER_INQ_PERIOD;
        }
        g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqOther.tableIndex++;
        if(g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqOther.tableIndex >= g_pJ1939MainData->mainRegInqOtherNum)    
        {
            /*若该簇的概要信息和其它信息都已查询完成，则簇ID++*/
            g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqOther.clusterIndex++;

            /*判断是否已查询完所有簇的概要信息和其它信息*/  
            if(g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqOther.clusterIndex >= (g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqOther.clusterEndIndex + 1))             
            {
                /*若已完成上电信息查询，则切换状态为概要*/
                HubMainDbJ1939_SwitchRegInquireMsgState(HUB_MAIN_DB_INQUIRE_SUMMARY_INFO,canIdIndex);    
            }
            else
            {
                /*为了清除TableIndex*/
                HubMainDbJ1939_SwitchRegInquireMsgState(HUB_MAIN_DB_INQUIRE_INFO_INIT,canIdIndex); 
            }         
        }
    }

    return Std_Ret_OK;
}

#if(BMS_FUNC_ENABLE_INQUIRE_DETAIL_INFO == 1)

/**@brief       概要信息主动发送查询指令
 * @param[in]   CanId   总控查询使用的canID
 * @return      None
 * @retval      未使用
 * @par         修改日志:
 * Date                Author     Description           \n
 * 2023/04/23          jyg        创建初始版本     \n
 * 2023/05/08          jyg        增加对CANID索引与指针的合法性判断及修正结构体的内容结构\n
 * 2023/08/21          jyg        在升级或者Debug导出时，降低发送周期\n
 */
Std_Ret_Type HubMainDbJ1939_RegInquireMsg_Summary(int32_t canIdIndex)
{
    uint32_t tableIndex = 0,clusterIndex = 0,msgOptCmd = 0;
    int32_t i = 0;  
    uint16_t tmpMsgInquirePeriod = 0u;
    
    if((canIdIndex >= CAN_OBJ_ID_MAX)||(g_pJ1939MainData == NULL)||(g_pJ1939MainData->totalMainCanInfo[canIdIndex] == NULL))
    {
        return Std_Ret_ERR;
    }
    tableIndex = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqSummary.tableIndex;
    for(i = tableIndex;i<g_pJ1939MainData->mainRegInqSummaryNum;i++)
    {
        tableIndex = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqSummary.tableIndex;
        clusterIndex = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqSummary.clusterIndex;
        /*消息触发的类型必须是周期性或者周期性+主动上传，且请求满足周期，即可请求，否则跳过本类型*/
        if(g_pJ1939MainData->isDebugMsg == Std_False)
        {
            tmpMsgInquirePeriod = g_J1939SummaryPara[tableIndex].msgInquirePeriod;
        }
        else
        {
            tmpMsgInquirePeriod = g_J1939SummaryPara[tableIndex].msgInquirePeriod *10;
        }
        if(((g_J1939SummaryPara[tableIndex].triggerType == INQUIRE_INFO_TRIGGER_TYPE_PERIOD)||(g_J1939SummaryPara[tableIndex].triggerType == INQUIRE_INFO_TRIGGER_TYPE_PERIOD_ACTIVE)) \
              &&((g_pJ1939MainData->totalMainCanInfo[canIdIndex]->loopCnt - g_pJ1939MainData->mainBoard[clusterIndex].lastInquireSummaryLoopCnt[tableIndex]) > tmpMsgInquirePeriod))
        {
            g_pJ1939MainData->mainBoard[clusterIndex].lastInquireSummaryLoopCnt[tableIndex] = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->loopCnt;
            msgOptCmd |= (uint32_t)(1<< g_J1939SummaryPara[tableIndex].msgType);
        }
                        
        g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqSummary.tableIndex++;
        if(g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqSummary.tableIndex >= g_pJ1939MainData->mainRegInqSummaryNum)  
        {
            /*若查询完一簇概要信息*/
            g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqSummary.clusterIndex++;
            if(g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqSummary.clusterIndex >= (g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqSummary.clusterEndIndex + 1))
            {
                /*若所有簇的概要信息均已查询完，且主控有复位，则查询其余信息*/
                if(HubMainDbJ1939_GetMainInitState(canIdIndex) != 0)
                {
                    HubMainDbJ1939_SwitchRegInquireMsgState(HUB_MAIN_DB_INQUIRE_OTHER_INFO,canIdIndex);
                }
                else
                {
                    HubMainDbJ1939_SwitchRegInquireMsgState(HUB_MAIN_DB_INQUIRE_DETAIL_INFO,canIdIndex);
                }
            }
            else
            {
                /*否则继续查询概要信息,为了清除TableIndex*/
                HubMainDbJ1939_SwitchRegInquireMsgState(HUB_MAIN_DB_INQUIRE_SUMMARY_INFO,canIdIndex);
            }
            if(msgOptCmd != 0)
            {
                HubMainDbJ1939_InquireMainCanMsg(clusterIndex,msgOptCmd,g_J1939SummaryPara[tableIndex].isMultipleFrame);
                msgOptCmd = 0;/*本簇发送完毕后清下发送指令*/
            }
            g_pJ1939MainData->mainBoard[clusterIndex].inquireCount++;
            break;
        }
    }
    return Std_Ret_OK;
}

#else

/**@brief       概要信息主动发送查询指令(概要信息分开查询)
 * @param[in]   CanId   总控查询使用的canID
 * @return      None
 * @retval      未使用
 * @par         修改日志:
 * Date                Author     Description           \n
 * 2023/08/21          jyg        创建初始版本     \n
 */
Std_Ret_Type HubMainDbJ1939_RegInquireMsg_Summary(int32_t canIdIndex)
{
    uint32_t tableIndex = 0u,clusterIndex = 0u,msgOptCmd = 0u;
    uint16_t tmpMsgInquirePeriod = 0u;
    int32_t i = 0;  
    
    if((canIdIndex >= CAN_OBJ_ID_MAX)||(g_pJ1939MainData == NULL)||(g_pJ1939MainData->totalMainCanInfo[canIdIndex] == NULL))
    {
        return Std_Ret_ERR;
    }

    clusterIndex = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqSummary.clusterIndex;   
    tableIndex = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqSummary.tableIndex;  
    if(tableIndex < g_pJ1939MainData->mainRegInqSummaryNum)
    {        
        /*消息触发的类型必须是周期性或者周期性+主动上传，且请求满足周期，即可请求，否则跳过本类型*/
        if(g_pJ1939MainData->isDebugMsg == Std_False)
        {
            tmpMsgInquirePeriod = g_J1939SummaryPara[tableIndex].msgInquirePeriod;
        }
        else
        {
            tmpMsgInquirePeriod = g_J1939SummaryPara[tableIndex].msgInquirePeriod *10;
        }

        for(i = tableIndex;i<g_pJ1939MainData->mainRegInqSummaryNum;i++)
        {
            if(((g_J1939SummaryPara[i].triggerType == INQUIRE_INFO_TRIGGER_TYPE_PERIOD)||(g_J1939SummaryPara[i].triggerType == INQUIRE_INFO_TRIGGER_TYPE_PERIOD_ACTIVE)) \
                  &&((g_pJ1939MainData->totalMainCanInfo[canIdIndex]->loopCnt - g_pJ1939MainData->mainBoard[clusterIndex].lastInquireSummaryLoopCnt[i])> tmpMsgInquirePeriod))
            {
                g_pJ1939MainData->mainBoard[clusterIndex].lastInquireSummaryLoopCnt[i] = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->loopCnt;
                msgOptCmd = (uint32_t)(g_J1939SummaryPara[i].msgType);
                HubMainDbJ1939_InquireMainCanMsg(clusterIndex,msgOptCmd,g_J1939SummaryPara[i].isMultipleFrame);
                i++;/*下面break是直接跳出，所以在此处要+1*/
                break;
            }
        }      
        g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqSummary.tableIndex = i;
    }
    if(g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqSummary.tableIndex >= g_pJ1939MainData->mainRegInqSummaryNum)  
    {
        /*若查询完一簇概要信息*/
        g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqSummary.clusterIndex++;
        if(g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqSummary.clusterIndex >= (g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqSummary.clusterEndIndex + 1))
        {
            /*若所有簇的概要信息均已查询完，且主控有复位，则查询其余信息*/
            if(HubMainDbJ1939_GetMainInitState(canIdIndex) != 0)
            {
                HubMainDbJ1939_SwitchRegInquireMsgState(HUB_MAIN_DB_INQUIRE_OTHER_INFO,canIdIndex);
            }
            else
            {
                HubMainDbJ1939_SwitchRegInquireMsgState(HUB_MAIN_DB_INQUIRE_SUMMARY_INFO,canIdIndex);
            }
        }
        else                                        
        {
            /*否则继续查询概要信息,为了清除TableIndex*/
            HubMainDbJ1939_SwitchRegInquireMsgState(HUB_MAIN_DB_INQUIRE_SUMMARY_INFO,canIdIndex);
        }
        g_pJ1939MainData->mainBoard[clusterIndex].inquireCount++;
    }

    return Std_Ret_OK;
}

#endif

/**@brief       详细信息主动发送查询指令
 * @param[in]   CanId   总控查询使用的canID
 * @return      Std_Ret_Type
 * @retval      Std_Ret_ERR：请求失败  Std_Ret_OK:请求成功
 * @par         修改日志:
 * Date                Author     Description           \n
 * 2023/04/23          jyg        创建初始版本     \n
 * 2023/05/08          jyg        增加对CANID索引与指针的合法性判断及修正结构体的内容结构,从其他状态切换到详细信息需要等待20ms,再进行详细信息操作\n
 * 2023/05/22          jyg        修正只有概要信息时间到或者在升级过程，才进行切换到概要信息请求，同时请求单体指令受其他地方控制\n
 * 2023/08/15          jyg        修正请求时间超过100ms或者can回路中没有多包数据传输时进行请求下一个类型数据\n
 * 2023/08/21          jyg        将判断是否DEBUG传输状态剥离出，同时记录每种详细请求的簇信息\n
 * 2023-09-13          jyg        修正详细信息使用压缩与非压缩的请求的策略\n
 */
Std_Ret_Type HubMainDbJ1939_RegInquireMsg_Detail(int32_t canIdIndex)
{
    uint32_t tableIndex = 0,clusterIndex = 0,msgOptCmd = 0;
    uint16_t tmpMsgInquirePeriod = 0,summaryStartClusterIndex = 0,summaryTableIndex = 0;
    uint8_t inqDetailTabIndex = 0; 
    Std_Bool_Enum isBreak = Std_False;
    Std_Swc_State_Type isEnQueryBatVolFlag = Std_False;
    TpStatus tpStatus = kTp_IDLE;
    
    if((canIdIndex >= CAN_OBJ_ID_MAX)||(g_pJ1939MainData == NULL)||(g_pJ1939MainData->totalMainCanInfo[canIdIndex] == NULL))
    {
        return Std_Ret_ERR;
    } 
    if((g_pJ1939MainData->totalMainCanInfo[canIdIndex]->loopCnt - g_pJ1939MainData->totalMainCanInfo[canIdIndex]->switchInqStepLoopCnt) <= SWITCH_DETAIL_STEP_WAIT_LOOP_CNT)
    {
        return Std_Ret_OK;
    }

    if(g_pJ1939MainData->detail_compress)
    {
         isEnQueryBatVolFlag = get_IsEnableSendQueryRequest();
    }
    else
    {
        isEnQueryBatVolFlag = Std_True;
    }
   
    tpStatus = J1939MasterRecvMsg_GetTpRecvState(canIdIndex);
    for(inqDetailTabIndex = 0;inqDetailTabIndex < g_pJ1939MainData->mainRegInqDetailNum;inqDetailTabIndex++)
    {
        tableIndex = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqDetail.tableIndex;
        clusterIndex = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqDetail.clusterIndex;
        if((g_J1939DetailPara[tableIndex].msgType == J1939_INQUIRE_OPT_TYPE_BAT_VOL_INFO)&&(isEnQueryBatVolFlag == Std_False))
        {
            /*若请求单体信息的标志没有使能，不进行请求单体电压，进而请求本簇下一个请求类型*/
            g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqDetail.tableIndex++;
            tableIndex = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqDetail.tableIndex;
        }
        if((((g_pJ1939MainData->totalMainCanInfo[canIdIndex]->inqCount % g_pJ1939MainData->totalMainCanInfo[canIdIndex]->detailInqPeriod) == 0u)||(tpStatus != kTp_DT))&&(tableIndex < g_pJ1939MainData->mainRegInqDetailNum))
        {
            /*消息触发的类型必须是周期性或者周期性+主动上传，且请求满足周期，即可请求，否则跳过本类型*/
            if(g_pJ1939MainData->isDebugMsg == Std_False)
            {
                tmpMsgInquirePeriod = g_J1939DetailPara[tableIndex].msgInquirePeriod;
            }
            else
            {
                tmpMsgInquirePeriod = g_J1939DetailPara[tableIndex].msgInquirePeriod *10;
            }
            if(((g_J1939DetailPara[tableIndex].triggerType == INQUIRE_INFO_TRIGGER_TYPE_PERIOD)||(g_J1939DetailPara[tableIndex].triggerType == INQUIRE_INFO_TRIGGER_TYPE_PERIOD_ACTIVE)) \
                  &&((g_pJ1939MainData->totalMainCanInfo[canIdIndex]->loopCnt - g_pJ1939MainData->mainBoard[clusterIndex].lastInquireDetailLoopCnt[tableIndex]) > tmpMsgInquirePeriod))
            {
                msgOptCmd = (uint32_t)(1 << g_J1939DetailPara[tableIndex].msgType);
                if(HubMainDbJ1939_InquireMainCanMsg(clusterIndex,msgOptCmd,g_J1939DetailPara[tableIndex].isMultipleFrame) >= 0)
                {
                    g_pJ1939MainData->mainBoard[clusterIndex].lastInquireDetailLoopCnt[tableIndex] = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->loopCnt;
                    g_pJ1939MainData->mainBoard[clusterIndex].inquireCount++;
                    g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqDetail.inquireDetailMsgFlag[tableIndex] |= 1<< clusterIndex;
                    isBreak = Std_True;
                }
            }
            g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqDetail.tableIndex++;  
        }
        else
        {
           /*时间不满足，直接跳出循环*/
           isBreak = Std_True;
        }
        if(g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqDetail.tableIndex >= g_pJ1939MainData->mainRegInqDetailNum)
        {
            if(((g_pJ1939MainData->totalMainCanInfo[canIdIndex]->inqCount % g_pJ1939MainData->totalMainCanInfo[canIdIndex]->detailInqPeriod) == (g_pJ1939MainData->totalMainCanInfo[canIdIndex]->detailInqPeriod -1u))||(tpStatus != kTp_DT))
            {
                g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqDetail.clusterIndex++;
                /*若详细信息已经查询完毕或者时间到了或者当前在升级就切入到概要信息*/
                summaryStartClusterIndex  = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqSummary.clusterStartIndex;
                summaryTableIndex = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqSummary.tableIndex;
                if(((g_pJ1939MainData->totalMainCanInfo[canIdIndex]->loopCnt - g_pJ1939MainData->mainBoard[summaryStartClusterIndex].lastInquireSummaryLoopCnt[summaryTableIndex]) \
                    > g_J1939SummaryPara[summaryTableIndex].msgInquirePeriod)||(g_pJ1939MainData->isDebugMsg == Std_True))
                {
                    HubMainDbJ1939_SwitchRegInquireMsgState(HUB_MAIN_DB_INQUIRE_SUMMARY_INFO,canIdIndex);
                }
                else
                {
                    /*继续请求详细信息*/
                    HubMainDbJ1939_SwitchRegInquireMsgState(HUB_MAIN_DB_INQUIRE_DETAIL_INFO,canIdIndex);    
                }
            }
            else
            {
                isBreak = Std_True;
            }
        }
        if(isBreak == Std_True)
        {
            g_pJ1939MainData->totalMainCanInfo[canIdIndex]->inqCount++; 
            break;
        }
    }

    return Std_Ret_OK;
}

/**@brief       详细信息主动发送查询指令(仅请求详细信息时使用)
 * @param[in]   canIdIndex   总控查询使用的canID
 * @return      None
 * @retval      未使用
 * @par         修改日志:
 * Date                Author     Description           \n
 * 2023/08/22          qzy        创建初始版本     \n
 * 2023-09-13          jyg        修正详细信息使用压缩与非压缩的请求的策略\n
 */
Std_Ret_Type HubMainDbJ1939_RegInquireMsg_Detail_Only(int32_t canIdIndex)
{
    uint32_t tableIndex = 0,clusterIndex = 0,msgOptCmd = 0;
    uint16_t tmpMsgInquirePeriod = 0,summaryStartClusterIndex = 0,summaryTableIndex = 0;
    uint8_t inqDetailTabIndex = 0; 
    Std_Bool_Enum isBreak = Std_False;
    Std_Swc_State_Type isEnQueryBatVolFlag = Std_False;
    uint64_t isRecvDetailInfoFlag = 0;

    if((canIdIndex >= CAN_OBJ_ID_MAX)||(g_pJ1939MainData == NULL)||(g_pJ1939MainData->totalMainCanInfo[canIdIndex] == NULL))
    {
        return Std_Ret_ERR;
    }
    if(g_pJ1939MainData->detail_compress)
    {
         isEnQueryBatVolFlag = get_IsEnableSendQueryRequest();
    }
    else
    {
        isEnQueryBatVolFlag = Std_True;
    }

    isRecvDetailInfoFlag = J1939MasterRecvMsg_GetRecvDetailInfoFlag(canIdIndex);
    for(inqDetailTabIndex = 0;inqDetailTabIndex < g_pJ1939MainData->mainRegInqDetailNum;inqDetailTabIndex++)
    {
        tableIndex = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqDetail.tableIndex;
        clusterIndex = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqDetail.clusterIndex;
        if(g_other_query_cnt <= HUB_QUERY_OTHER_INFO_MAX_CNT - 1)
        {
            if(HubMainDbJ1939_checkOtherInfo(clusterIndex + 1,canIdIndex) != 0)
            {
                /* 其他信息DB无效，切入其他信息再次请求，最多尝试40次 */
                g_other_query_cnt++;
                HubMainDbJ1939_SwitchRegInquireMsgState(HUB_MAIN_DB_INQUIRE_OTHER_INFO_ONLY,canIdIndex);
                return Std_Ret_OK;
            }
            else
            {
                /* 其他信息已请求完毕 */
                g_other_query_cnt = HUB_QUERY_OTHER_INFO_MAX_CNT;
            }
        }
        isRecvDetailInfoFlag = (isRecvDetailInfoFlag>>(clusterIndex+1)) & 0x01;
        if((g_J1939DetailPara[tableIndex].msgType == J1939_INQUIRE_OPT_TYPE_BAT_VOL_INFO)&&(isEnQueryBatVolFlag == Std_False))
        {
            /*若请求单体信息的标志没有使能，不进行请求单体电压，进而请求本簇下一个请求类型*/
            g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqDetail.tableIndex++;
            tableIndex = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqDetail.tableIndex;
        }
        if((((g_pJ1939MainData->totalMainCanInfo[canIdIndex]->inqCount % g_pJ1939MainData->totalMainCanInfo[canIdIndex]->detailInqPeriod) == 0u) \
            ||(isRecvDetailInfoFlag == Std_True)||(g_pJ1939MainData->totalMainCanInfo[canIdIndex]->detailInqFlag == (uint8_t)Std_False)) \
            &&(tableIndex < g_pJ1939MainData->mainRegInqDetailNum))
        {
            /*消息触发的类型必须是周期性或者周期性+主动上传，且请求满足周期，即可请求，否则跳过本类型*/
            if(g_pJ1939MainData->isDebugMsg == Std_False)
            {
                tmpMsgInquirePeriod = g_J1939DetailPara[tableIndex].msgInquirePeriod;
            }
            else
            {
                tmpMsgInquirePeriod = g_J1939DetailPara[tableIndex].msgInquirePeriod *10;
            }
            if(((g_J1939DetailPara[tableIndex].triggerType == INQUIRE_INFO_TRIGGER_TYPE_PERIOD)||(g_J1939DetailPara[tableIndex].triggerType == INQUIRE_INFO_TRIGGER_TYPE_PERIOD_ACTIVE)) \
                    &&((g_pJ1939MainData->totalMainCanInfo[canIdIndex]->loopCnt - g_pJ1939MainData->mainBoard[clusterIndex].lastInquireDetailLoopCnt[tableIndex]) > tmpMsgInquirePeriod))
            {
                msgOptCmd = (uint32_t)(1 << g_J1939DetailPara[tableIndex].msgType);
                if(HubMainDbJ1939_InquireMainCanMsg(clusterIndex,msgOptCmd,g_J1939DetailPara[tableIndex].isMultipleFrame) >= 0)
                {
                    g_pJ1939MainData->mainBoard[clusterIndex].lastInquireDetailLoopCnt[tableIndex] = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->loopCnt;
                    g_pJ1939MainData->mainBoard[clusterIndex].inquireCount++;
                    g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqDetail.inquireDetailMsgFlag[tableIndex] |= 1<< clusterIndex;
                    isBreak = Std_True;
                }
                g_pJ1939MainData->totalMainCanInfo[canIdIndex]->detailInqFlag = Std_True;
                J1939MasterRecvMsg_ResetRecvDetailInfoFlag(canIdIndex);
            }
            else
            {
                g_pJ1939MainData->totalMainCanInfo[canIdIndex]->detailInqFlag = Std_False;
            }
            g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqDetail.tableIndex++;
        }
        else
        {
           /*时间不满足，直接跳出循环*/
           isBreak = Std_True;
        }
        if(g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqDetail.tableIndex >= g_pJ1939MainData->mainRegInqDetailNum)
        {
            if((g_pJ1939MainData->totalMainCanInfo[canIdIndex]->inqCount % g_pJ1939MainData->totalMainCanInfo[canIdIndex]->detailInqPeriod) \
               == (g_pJ1939MainData->totalMainCanInfo[canIdIndex]->detailInqPeriod -1u)||(isRecvDetailInfoFlag == Std_True))
            {
                g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqDetail.clusterIndex++;
                /*若主控有复位，则查询其余信息,否则继续请求详细信息, 为了清除TableIndex*/
                if(HubMainDbJ1939_GetMainInitState(canIdIndex) != 0)
                {
                    HubMainDbJ1939_SwitchRegInquireMsgState(HUB_MAIN_DB_INQUIRE_OTHER_INFO_ONLY,canIdIndex);
                }
                else
                {
                    HubMainDbJ1939_SwitchRegInquireMsgState(HUB_MAIN_DB_INQUIRE_DETAIL_INFO_ONLY,canIdIndex);
                }
            }
            else
            {
                isBreak = Std_True;
            }
        }
        if(isBreak == Std_True)
        {
            g_pJ1939MainData->totalMainCanInfo[canIdIndex]->inqCount++; 
            break;
        }
    }

    return Std_Ret_OK;
}

/**@brief       其他信息主动发送查询指令
 * @param[in]   CanId   总控查询使用的canID
 * @return      None
 * @retval      未使用
 * @par         修改日志:
 * Date                Author     Description           \n
 * 2023/04/23          jyg        创建初始版本     \n
 * 2023/05/08          jyg        增加对CANID索引与指针的合法性判断及修正结构体的内容结构,从概要或者详细、或者初始化状态切换到其他信息需要等待20ms,再进行详细信息操作\n
 * 2023/05/22          jyg        修正其他信息数据较多时，等待的时间加长\n
 * 2023/09/06          jyg        修正该簇请求完其他信息后，清除下BCU初始化状态\n
 */
Std_Ret_Type HubMainDbJ1939_RegInquireMsg_Other(int32_t canIdIndex)
{
    uint32_t tableIndex = 0,clusterIndex = 0,msgOptCmd = 0;
    Std_Bool_Enum isSwitchState = Std_False;

    if((canIdIndex >= CAN_OBJ_ID_MAX)||(g_pJ1939MainData == NULL)||(g_pJ1939MainData->totalMainCanInfo[canIdIndex] == NULL))
    {
        return Std_Ret_ERR;
    }

    if((g_pJ1939MainData->totalMainCanInfo[canIdIndex]->loopCnt - g_pJ1939MainData->totalMainCanInfo[canIdIndex]->switchInqStepLoopCnt) < SWITCH_OTHER_STEP_WAIT_LOOP_CNT)
    {
        return Std_Ret_OK;
    }
    
    tableIndex = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqOther.tableIndex; 
    if(((g_pJ1939MainData->totalMainCanInfo[canIdIndex]->inqCount % g_pJ1939MainData->totalMainCanInfo[canIdIndex]->otherInqPeriod) == 0u)&&(tableIndex < g_pJ1939MainData->mainRegInqOtherNum))
    {   
        if(g_pJ1939MainData->totalMainCanInfo[canIdIndex]->mainInitIndex != INVALID_INDEX)
        {
            clusterIndex = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->mainInitIndex;
        }
        else
        {
            clusterIndex = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqOther.clusterIndex;
        }
        g_pJ1939MainData->totalMainCanInfo[canIdIndex]->lastMainInitIndex = clusterIndex;
        msgOptCmd = (uint32_t)(1<<g_J1939OtherPara[tableIndex].msgType);
        if(HubMainDbJ1939_InquireMainCanMsg(clusterIndex-1,msgOptCmd,g_J1939OtherPara[tableIndex].isMultipleFrame) >= 0)
        {
            if(g_J1939OtherPara[tableIndex].regNum > REQUEST_NUM)
            {
                g_pJ1939MainData->totalMainCanInfo[canIdIndex]->otherInqPeriod = OTHER_INQ_PERIOD*2;
            }
            else
            {
                g_pJ1939MainData->totalMainCanInfo[canIdIndex]->otherInqPeriod = OTHER_INQ_PERIOD;
            }
            g_pJ1939MainData->mainBoard[clusterIndex].inquireCount++;
        }
        g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqOther.tableIndex++;
    }
    
    if(g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqOther.tableIndex >= g_pJ1939MainData->mainRegInqOtherNum)
    {
        if((g_pJ1939MainData->totalMainCanInfo[canIdIndex]->inqCount % g_pJ1939MainData->totalMainCanInfo[canIdIndex]->otherInqPeriod) == (g_pJ1939MainData->totalMainCanInfo[canIdIndex]->otherInqPeriod -1u))
        {
            if(g_pJ1939MainData->totalMainCanInfo[canIdIndex]->mainInitIndex != INVALID_INDEX)
            {
                g_pJ1939MainData->totalMainCanInfo[canIdIndex]->mainInitIndex = INVALID_INDEX;
            }
            else
            {
                g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqOther.clusterIndex++;
            }
            J1939MasterRecvMsg_SetBcuInitState(canIdIndex,g_pJ1939MainData->totalMainCanInfo[canIdIndex]->lastMainInitIndex);
            HubMainDbJ1939_SwitchRegInquireMsgState(HUB_MAIN_DB_INQUIRE_SUMMARY_INFO,canIdIndex);
            isSwitchState = Std_True;
         }
    }
    if(isSwitchState == Std_False)
    {
        g_pJ1939MainData->totalMainCanInfo[canIdIndex]->inqCount++; 
    }
    return Std_Ret_OK;
}

/**@brief       其他信息主动发送查询指令(不请求概要信息模式使用,请求完切至详细信息,仅主控重启时再次请求)
 * @param[in]   CanId   总控查询使用的canID
 * @return      None
 * @retval      未使用
 * @par         修改日志:
 * Date                Author     Description           \n
 * 2023/04/23          jyg        创建初始版本     \n
 * 2023/05/08          jyg        增加对CANID索引与指针的合法性判断及修正结构体的内容结构,从概要或者详细、或者初始化状态切换到其他信息需要等待20ms,再进行详细信息操作\n
 * 2023/05/22          jyg        修正其他信息数据较多时，等待的时间加长\n
 */
Std_Ret_Type HubMainDbJ1939_RegInquireMsg_Other_Only(int32_t canIdIndex)
{
    uint32_t tableIndex = 0;
    uint32_t clusterIndex = 0;
    uint32_t msgOptType = 0;

    if((canIdIndex >= CAN_OBJ_ID_MAX)||(g_pJ1939MainData == NULL)||(g_pJ1939MainData->totalMainCanInfo[canIdIndex] == NULL))
    {
        return Std_Ret_ERR;
    } 
    clusterIndex = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqOther.clusterIndex;
    g_pJ1939MainData->totalMainCanInfo[canIdIndex]->inqCount++;
    if((g_pJ1939MainData->totalMainCanInfo[canIdIndex]->inqCount % g_pJ1939MainData->totalMainCanInfo[canIdIndex]->otherInqPeriod) > 0u)
    {
        return Std_Ret_OK;
    }
    tableIndex = g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqOther.tableIndex;  
    msgOptType = (uint32_t)(1<<g_J1939OtherPara[tableIndex].msgType);
    if(HubMainDbJ1939_InquireMainCanMsg(clusterIndex,msgOptType,g_J1939OtherPara[tableIndex].isMultipleFrame) >= 0)
    {
        g_pJ1939MainData->mainBoard[clusterIndex].inquireCount++;
    }
    if(g_J1939OtherPara[tableIndex].regNum > REQUEST_NUM)
    {
        g_pJ1939MainData->totalMainCanInfo[canIdIndex]->otherInqPeriod = OTHER_INQ_PERIOD*2;
    }
    else
    {
        g_pJ1939MainData->totalMainCanInfo[canIdIndex]->otherInqPeriod = OTHER_INQ_PERIOD;
    }
    g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqOther.tableIndex++;
    if(g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqOther.tableIndex >= g_pJ1939MainData->mainRegInqOtherNum)    
    {
        /*重置主控初始化状态*/
        J1939MasterRecvMsg_SetBcuInitState(canIdIndex, clusterIndex + 1);
        /*若该簇的其它信息都已查询完成，则簇ID++*/
        g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqOther.clusterIndex++;
        /*判断是否已查询完所有簇的其它信息*/
        if(g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqOther.clusterIndex >= (g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqOther.clusterEndIndex + 1))
        {
            if(g_other_query_cnt >= HUB_QUERY_OTHER_INFO_INIT_CNT - 1)
            {
                /*若已完成其他信息上电查询，则切换状态为详细*/
                HubMainDbJ1939_SwitchRegInquireMsgState(HUB_MAIN_DB_INQUIRE_DETAIL_INFO_ONLY,canIdIndex);
            }
            else
            {
                g_other_query_cnt++;
                /*继续请求其他信息*/
                HubMainDbJ1939_SwitchRegInquireMsgState(HUB_MAIN_DB_INQUIRE_OTHER_INFO_ONLY,canIdIndex); 
            }
        }
        else
        {
            /*为了清除TableIndex*/
            HubMainDbJ1939_SwitchRegInquireMsgState(HUB_MAIN_DB_INQUIRE_OTHER_INFO_ONLY,canIdIndex); 
        }
    }
    return Std_Ret_OK;
}

/**@brief       主动发送查询指令，周期10ms
 * @param[in]   void
 * @return      Std_Ret_Type
 * @retval      0:请求成功，非0请求失败
 * @par         修改日志:
 * Date                Author     Description           \n
 * 2023/04/23          jyg        创建初始版本     \n
 * 2023/05/08          jyg        修正函数传参为空，两路CAN都在本函数中请求，没有使能的CAN不进行请求\n
 */
Std_Ret_Type HubMainDbJ1939_RegInquireMsg_Step(void)
{
    int32_t canIdIndex = 0, ret = Std_Ret_OK;

    for(canIdIndex = 0;canIdIndex < CAN_OBJ_ID_MAX;canIdIndex++)
    {
        if((g_pJ1939MainData == NULL)||(g_pJ1939MainData->totalMainCanInfo[canIdIndex] == NULL) \
          || ((canIdIndex + 1) > g_pJ1939MainData->enable_can_num))
        {
            continue;
        }
        g_pJ1939MainData->totalMainCanInfo[canIdIndex]->loopCnt++;
        switch(g_pJ1939MainData->totalMainCanInfo[canIdIndex]->curInqStep)
        {
            case HUB_MAIN_DB_INQUIRE_INFO_INIT:
            {
                /*初始化阶段，直接请求所有簇概要信息和其他信息*/
                ret |= HubMainDbJ1939_RegInquireMsg_Init(canIdIndex);
                break;
            }
            case HUB_MAIN_DB_INQUIRE_SUMMARY_INFO:
            {
                /*请求所有簇的概要信息*/
                ret |= HubMainDbJ1939_RegInquireMsg_Summary(canIdIndex);
                break;
            }
            case HUB_MAIN_DB_INQUIRE_DETAIL_INFO:
            {
                /*请求所有簇的详细信息*/
                ret |= HubMainDbJ1939_RegInquireMsg_Detail(canIdIndex);
                break;
            }
            case HUB_MAIN_DB_INQUIRE_OTHER_INFO:
            {
                /*请求所有簇的其余信息*/
                ret |= HubMainDbJ1939_RegInquireMsg_Other(canIdIndex);
                break;
            }

            case HUB_MAIN_DB_INQUIRE_DETAIL_INFO_ONLY:
            {
                /* 请求簇的详细信息, 不请求概要信息模式使用 */
                ret |= HubMainDbJ1939_RegInquireMsg_Detail_Only(canIdIndex);
                break;
            }
            case HUB_MAIN_DB_INQUIRE_OTHER_INFO_ONLY:
            {
                /* 请求簇的其他信息, 不请求概要信息模式使用*/
                ret |= HubMainDbJ1939_RegInquireMsg_Other_Only(canIdIndex);
                break;
            }
            default:
                break;
        }
    }
    return ret;
}

/**@brief       给每簇的设备发送CAN消息打包
 * @param[in]   devId       簇ID
 * @param[in]   msgType     目前只支持CANRBUS_WRITE_REG
 * @param[in]   regAddr     DB地址
 * @param[in]   regValue    写入数据
 * @param[in]   CanMsg *txMsg can消息打包内容(出参)
 * @return      void
 * @retval      void
 * @par         修改日志:
 * Date         Author      Description           \n
 * 2023-04-26   jyg         创建初始版本\n
 * 2023-05-09   jyg         修正关于BCU的BD的OBJ的基地址计算\n
 * 2023-05-17   jyg         增加对广播信息处理\n
 * 2023-05-22   jyg         优化找不到对应的DB时，就不再回复\n
 * 2023-05-23   jyg         修正对广播配置的合法性判断\n
 * 2023-06-09   xlt      	增加J1939中DEBUG和保护参数信息的下发\n 
 */
Std_Ret_Type HubMainDbJ1939_SendClusterCanRbusMsgPack(uint16_t devId,uint16_t msgType,uint32_t regAddr, uint16_t regValue,CanMsg *txMsg)
{
    J1939_CFG_INFO_STRU *cfgInfo = NULL;
    uint32_t dstAddr = 0u;
    int32_t dbAddrTableListItemNum = 0,i = 0,j = 0;
    Std_Bool_Enum isFindDbObjFlag = Std_False; 
    Std_Ret_Type ret = Std_Ret_OK;

    if(txMsg == NULL)
    {
        return Std_Ret_ERR;
    }  

    if((devId < BMS_DB_DEV_MASTER)&&(devId != J1939_BROADCAST_DST_ADDR))
    {
        return Std_Ret_ERR;
    }

    if(devId == J1939_BROADCAST_DST_ADDR)
    {
        dstAddr = J1939_BROADCAST_DST_ADDR; 
        devId = BMS_DB_DEV_MASTER;
    }
    else
    {
        dstAddr = (uint32_t)(J1939_PDU_BCUx_DEF_ADDR+devId) ;
    }
    
    cfgInfo = (J1939_CFG_INFO_STRU *)txMsg->Data;
    dbAddrTableListItemNum = DbObjCfgJ1939_GetDbAddrTableListItemNum();
    for(i= 0;i<dbAddrTableListItemNum;i++)
    {
        if((g_J1939_PF_DbAddrTableList[i].inquireOptType == J1939_INQUIRE_OPT_TYPE_CMD_INFO)\
            || (g_J1939_PF_DbAddrTableList[i].inquireOptType == J1939_INQUIRE_OPT_TYPE_FUN_PARA_CFG_INFO)\
            || (g_J1939_PF_DbAddrTableList[i].inquireOptType == J1939_INQUIRE_OPT_TYPE_DEBUG_INFO)\
            || (g_J1939_PF_DbAddrTableList[i].inquireOptType == J1939_INQUIRE_OPT_TYPE_ALARM_PROTECT_PARA))
        {
            for(j = 0;j<g_J1939_PF_DbAddrTableList[i].inquireOptTypeItemsNum;j++)
            {
                // 直接根据db地址确定P,PF,offset
                if(g_J1939_PF_DbAddrTableList[i].pfMapDbAddrTable[j].j1939_DbAddr == regAddr)
                {
                    cfgInfo->priorityLevel = g_J1939_PF_DbAddrTableList[i].pfMapDbAddrTable[j].j1939_P_Level;
                    cfgInfo->pfNum = g_J1939_PF_DbAddrTableList[i].pfMapDbAddrTable[j].j1939_PF_BaseAddr;
                    cfgInfo->offset = g_J1939_PF_DbAddrTableList[i].pfMapDbAddrTable[j].j1939_PF_BaseAddrOffset;
                    isFindDbObjFlag = Std_True;
                    break;
                }
            }
        }
        if(isFindDbObjFlag == Std_True)
        {
            break;
        }         
    }
    if(isFindDbObjFlag == Std_False)
    {
        return Std_Ret_ERR;
    }

    if(msgType == FUNC_CODE_WRITE)
    {
        cfgInfo->operationType = J1939_CFG_OPT_TYPE_WRITE;
    }
    else if (msgType == FUNC_CODE_READ)
    {
        cfgInfo->operationType = J1939_CFG_OPT_TYPE_READ;
    }
    else
    {
        cfgInfo->operationType = J1939_CFG_OPT_TYPE_NONE;
    }
    cfgInfo->cfgValue = HOST_TO_J1939_ENDIAN_16(regValue);
    txMsg->CanId =  (J1939_PDU_LINUX_ADDR) |(dstAddr<<J1939_CANID_PS_POS)| \
                (J1939_SINGLE_CFG_CMD_PF_VALUE << J1939_CANID_PF_POS)| (J1939_R_J1939<<J1939_CANID_R_POS)|\
                (J1939_SINGLE_CFG_CMD_P_LEVEL_VALUE<<J1939_CANID_P_POS);
    txMsg->DLC = sizeof(J1939_CFG_INFO_STRU);

    return ret ;
}


/**@brief       给每簇的设备发送CAN消息(直接向下发送)
 * @param[in]   devId       主控设备ID，可参考BMS_DB_DEV_TYPE_ENUM
 * @param[in]   msgType     目前只支持CANRBUS_WRITE_REG(FUNC_CODE_WRITE)
 * @param[in]   regAddr     DB地址
 * @param[in]   regValue    写入数据
 * @return      void
 * @retval      void
 * @par         修改日志:
 * Date         Author      Description           \n
 * 2023-04-26   jyg         创建初始版本\n
 * 2023-05-08   jyg         增加对空指针与设备ID有效性判断，修正结构体中的内容\n
 * 2023-05-23   jyg         修正对广播配置的合法性判断\n
 * 2023-08-09   jyg         增加对广播发送时的CAN的handleID处理\n
 */
#if 0
Std_Ret_Type HubMainDbJ1939_SendClusterMsg(uint16_t devId,uint16_t msgType,uint32_t regAddr, uint16_t regValue)
{
    CanMsg txMsg = {0u};
    Std_Ret_Type ret = Std_Ret_OK;
    Std_Fault_State_Type txErrCount = 0;

    if((g_pJ1939MainData == NULL)||((devId < BMS_DB_DEV_MASTER)&&(devId != J1939_BROADCAST_DST_ADDR)))
    {
        return Std_Ret_ERR;
    }    
    ret = HubMainDbJ1939_SendClusterCanRbusMsgPack(devId,msgType,regAddr,regValue,&txMsg);
    if(ret ==  Std_Ret_ERR)
    {
        return ret;
    }
    // ret |= Fifo_AddData(g_pJ1939MainData->txFifo, (uint8_t*)&txMsg, 1, Std_False);
    if(ret == Std_Ret_ERR)
    {
        // Rte_Read_IFaultState_DbConfigFifoErr(&txErrCount);
        // txErrCount++;
        // Rte_Write_OFaultState_DbConfigFifoErr(txErrCount);
        // 广播暂只支持两路can
        if(devId == J1939_BROADCAST_DST_ADDR)
        {
            if(g_pJ1939MainData->totalMainCanInfo[CAN_OBJ_ID_1] != NULL)
            {
                ret |= HubMainDbJ1939_SendMsg(CAN_OBJ_ID_1, &txMsg);
            }

            if(g_pJ1939MainData->totalMainCanInfo[CAN_OBJ_ID_2] != NULL)
            {
                ret |= HubMainDbJ1939_SendMsg(CAN_OBJ_ID_2, &txMsg);
            }
        }
        else
        {
            ret |= HubMainDbJ1939_SendMsg(g_pJ1939MainData->mainBoard[(devId - BMS_DB_DEV_MASTER)].canHandleId, &txMsg);
        }
    }

    return ret ;
}
#endif

/**@brief       向主控can发送DB写入消息(不检查写响应)
 * @param[in]   devId       主控设备ID，可参考BMS_DB_DEV_TYPE_ENUM
 * @param[in]   msgType     目前只支持CANRBUS_WRITE_REG
 * @param[in]   regAddr     DB地址
 * @param[in]   regValue    写入数据
 * @return      void
 * @retval      void
 * @par         修改日志:
 * Date         Author      Description           \n
 * 2023-04-26   jyg         创建初始版本\n
 * 2023-05-08   jyg         增加对空指针与设备ID有效性判断，修正结构体中的内容\n
 * 2023-05-23   jyg         修正对广播配置的合法性判断\n
 * 2023-08-09   jyg         增加对广播发送时的CAN的handleID处理\n
 */
Std_Ret_Type HubMainDbJ1939_SendClusterMsgWithoutRespCheck(uint16_t devId,uint16_t msgType,uint32_t regAddr, uint16_t regValue)
{
    CanMsg txMsg = {0u};
    Std_Ret_Type ret = Std_Ret_OK;
    
    if((g_pJ1939MainData == NULL)||((devId < BMS_DB_DEV_MASTER)&&(devId != J1939_BROADCAST_DST_ADDR)))
    {
        return Std_Ret_ERR;
    } 
    ret = HubMainDbJ1939_SendClusterCanRbusMsgPack(devId,msgType,regAddr,regValue,&txMsg);
    if(ret ==  Std_Ret_ERR)
    {
        return ret;
    }
    // 广播暂只支持两路can
    if(devId == J1939_BROADCAST_DST_ADDR)
    {
        if(g_pJ1939MainData->totalMainCanInfo[CAN_OBJ_ID_1] != NULL)
        {
            ret |= HubMainDbJ1939_SendMsg(CAN_OBJ_ID_1, &txMsg);
        }

        if(g_pJ1939MainData->totalMainCanInfo[CAN_OBJ_ID_2] != NULL)
        {
            ret |= HubMainDbJ1939_SendMsg(CAN_OBJ_ID_2, &txMsg);
        }
    }
    else
    {
        ret = HubMainDbJ1939_SendMsg(g_pJ1939MainData->mainBoard[(devId - BMS_DB_DEV_MASTER)].canHandleId, &txMsg);
    }
    return ret;
}

/**@brief       向主控can连续发送多个DB写入消息(不检查写响应)
 * @param[in]   devId       主控设备ID，可参考BMS_DB_DEV_TYPE_ENUM
 * @param[in]   msgType     目前只支持CANRBUS_WRITE_REG
 * @param[in]   regAddr     DB地址
 * @param[in]   regNum      数据个数
 * @param[in]   *regValue   写入数据
 * @return      void
 * @retval      void
 * @par         修改日志:
 * Date         Author      Description           \n
 * 2023-04-26   jyg         创建初始版本\n
 * 2023-05-08   jyg         增加对空指针与设备ID有效性判断，修正结构体中的内容\n
 * 2023-05-23   jyg         修正对广播配置的合法性判断\n
 * 2023-08-09   jyg         增加对广播发送时的CAN的handleID处理\n
 */
Std_Ret_Type HubMainDbJ1939_SendClusterMultiMsgWithoutRespCheck(uint16_t devId,uint16_t msgType,uint32_t regAddr, uint16_t regNum, uint16_t* regValue)
{
    CanMsg txMsg;
    uint16_t start = 0u;
    Std_Ret_Type ret = Std_Ret_OK;
    
    if((g_pJ1939MainData == NULL)||((devId < BMS_DB_DEV_MASTER)&&(devId != J1939_BROADCAST_DST_ADDR)))
    {
        return Std_Ret_ERR;
    } 

    while(regNum > 0u)
    {
        memset(&txMsg,0,sizeof(CanMsg));
        ret = HubMainDbJ1939_SendClusterCanRbusMsgPack(devId,msgType,regAddr,regValue[start],&txMsg);
        if(ret ==  Std_Ret_ERR)
        {
            return ret;
        }
        if(devId == J1939_BROADCAST_DST_ADDR)
        {
            if(g_pJ1939MainData->totalMainCanInfo[CAN_OBJ_ID_1] != NULL)
            {
                ret |= HubMainDbJ1939_SendMsg(CAN_OBJ_ID_1, &txMsg);
            }

            if(g_pJ1939MainData->totalMainCanInfo[CAN_OBJ_ID_2] != NULL)
            {
                ret |= HubMainDbJ1939_SendMsg(CAN_OBJ_ID_2, &txMsg);
            }
        }
        else
        {
            ret = HubMainDbJ1939_SendMsg(g_pJ1939MainData->mainBoard[(devId - BMS_DB_DEV_MASTER)].canHandleId, &txMsg);
        }
        regNum -= 1u;
        start += 1u;
        regAddr += 1u;
    }
    return ret;
}

/**@brief       判断系统是否是debug消息(升级)
 * @param[in]   CanId   总控查询使用的canID
 * @return      Std_Ret_Type
 * @retval      Std_Ret_ERR:判断错误 Std_Ret_OK:判断OK
 * @par         修改日志:
 * Date                Author     Description           \n
 * 2023/08/21          jyg        创建初始版本     \n
 */
Std_Ret_Type HubMainDbJ1939_JudgeSysIsDebugMsg(void)
{
    g_pJ1939MainData->isDebugMsg = judgeSysIsUpdate();
    return  Std_Ret_OK;
}


/*-----------------------------------------------------------------------------------------
 * @brief      定时请求DB消息与更新通讯状态（周期10ms）
 * @param[in]   void
 * @return      int32_t
 * @retval      0:正常；-1:异常
 * @par         修改日志:
 * Date         Author      Description           \n
 * 2023-04-26               创建初始版本            \n
 * 2023-05-08               修正总控请求主控CAN消息的两路CAN不在本函数中区分            \n
*-----------------------------------------------------------------------------------------*/
void J1939SendMsg_Step_Runnable(void)
{
    static uint32_t loopCount = 0;
    if(g_pJ1939MainData == NULL)
    {
        return;
    }

    loopCount++;
    if(loopCount < HUB_START_REQUEST_REG_LOOP_CNT)
    {
        return;
    }

    if((loopCount % HUB_REG_SEND_CFG_MSG_FRE) == 1)
    {
        HubMainDbJ1939_SerialSendCfgCanMsgToSlave();
    }
    else if((loopCount % HUB_UPDATE_COMM_STATE_FRE) == 0)
    {
        HubMainDbJ1939_JudgeSysIsDebugMsg();
    }
    else
    {
        /**/
    }
    HubMainDbJ1939_RegInquireMsg_Step();
}

/**@brief       写响应消息发送
 * @param[in]   uint32_t canId
 * @param[in]   uint8_t *cfgInfo
 * @param[in]   uint8_t cfgInfoLen
 * @return      int32_t
 * @retval      0:正常；-1:异常
 * @par         修改日志:
 * Date         Author      Description           \n
 * 2023-04-15   jyg  创建初始版本\n
 * 2023-05-08   jyg         增加对空指针与设备ID有效性判断，修正结构体中的内容\n
 * 2023-05-09   jyg         修正匹配的类型\n
 */
int32_t J1939_WriteRespCallback(uint32_t canId,uint8_t *cfgInfo,uint8_t cfgInfoLen)
{
    uint8_t i = 0,tmpLen = 0;
    Std_Bool_Enum isResp = Std_True;

    if((cfgInfo == NULL)||(g_pJ1939MainData == NULL))
    {
        return -1;
    }

    tmpLen = MIN(J1939_CFG_INFO_MSG_HEAD_LEN,cfgInfoLen);
    /*配置消息内容必须匹配*/
    for(i = 1;i < tmpLen;i++)
    {
        if(g_pJ1939MainData->cfgInfo[i] != cfgInfo[i])
        {
            isResp = Std_False;
        }
    }
    /*配置消息目的地址必须匹配*/
    if(((g_pJ1939MainData->canId >>J1939_CANID_PS_POS)&0xff) != (canId & 0xff))
    {
        isResp = Std_False;
    }

    if(isResp == Std_True)
    {
        g_pJ1939MainData->canRBusWaitWiteRespFlag = 0;
    }

    return 0;
}

/**@brief       总控与主控交互(发送)的初始化
 * @param[in]   BMSER_CAN_BUS_CFG_TABLE_S
 * @return      int32_t
 * @retval      0:正常；-1:异常
 * @par         修改日志:
 * Date         Author      Description           \n
 * 2023-04-15   JYG  创建初始版本\n
 * 2023-05-08   JYG  重新修正结构体定义，同时没有使能CAN不进行初始化\n
 * 2023-08-16   JYG  重置详细信息中记录上一次请求的时间计数值\n
 * 2023-08-21   JYG  修正新增初始化信息\n
 */
int32_t J1939SendMsg_Init(BMSER_CAN_BUS_CFG_TABLE_S* cfg_table)
{
    int32_t ret = 0,i = 0,j = 0,dbAddrTableListItemNum = 0;
    uint32_t clusterIndex = 0;
    uint16_t clusterNum[CAN_OBJ_ID_MAX] = {0};                                   /*每路can查询簇数*/
    uint16_t startIndex[CAN_OBJ_ID_MAX] = {0};                                   /*每路can查询的起始簇*/
    uint16_t endIndex[CAN_OBJ_ID_MAX] = {0};                                     /*每路can查询的结束簇*/
    uint8_t detail_only = cfg_table->general_cfg.j1939_send_detail_only;         /*仅请求详细信息模式*/

    if(g_pJ1939MainData == NULL)
    {
        g_pJ1939MainData = (J1939_MAIN_DATA_STRU *)malloc(sizeof(J1939_MAIN_DATA_STRU));
        if(g_pJ1939MainData == NULL)
        {
            return -1;
        }
    }
    memset(g_pJ1939MainData,0,sizeof(J1939_MAIN_DATA_STRU));

    g_pJ1939MainData->canRBusWriteTimeoutCount = 0;
    g_pJ1939MainData->canRBusWaitWiteRespFlag = 0;
    g_pJ1939MainData->enable_rack_num = cfg_table->rack_num;
    g_pJ1939MainData->enable_can_num = cfg_table->num;
    g_pJ1939MainData->detail_compress = cfg_table->general_cfg.j1939_send_detail_compress;/*详细信息请求是否多帧*/

    /* can的簇配置信息从canbus_cfg.json获取 */
    for(i = 0;i < cfg_table->num ;i++)
    {
        //CAN未使能则跳过
        if(cfg_table->can_cfg[i].disable)
        {
            continue;
        }
        else
        {
            startIndex[i] = cfg_table->can_cfg[i].rack_id_start - 1;
            endIndex[i] = MIN(cfg_table->can_cfg[i].rack_id_end, g_pJ1939MainData->enable_rack_num) - 1;
        }
        clusterNum[i] = endIndex[i] - startIndex[i] + 1;
        if(clusterNum[i] <= 0)
        {
            continue;
        }
        g_pJ1939MainData->totalMainCanInfo[i] = (J1939_TOTAL_MAIN_CAN_DATA_STRU *)malloc(sizeof(J1939_TOTAL_MAIN_CAN_DATA_STRU));
        if(g_pJ1939MainData->totalMainCanInfo[i] == NULL)
        {
            return Std_Ret_ERR;
        }
        memset(g_pJ1939MainData->totalMainCanInfo[i], 0x00, sizeof(J1939_TOTAL_MAIN_CAN_DATA_STRU));
        g_pJ1939MainData->totalMainCanInfo[i]->curInqSummary.clusterStartIndex = startIndex[i];
        g_pJ1939MainData->totalMainCanInfo[i]->curInqSummary.clusterEndIndex = endIndex[i];
        g_pJ1939MainData->totalMainCanInfo[i]->curInqDetail.clusterStartIndex = startIndex[i];
        g_pJ1939MainData->totalMainCanInfo[i]->curInqDetail.clusterEndIndex = endIndex[i];
        g_pJ1939MainData->totalMainCanInfo[i]->curInqOther.clusterStartIndex = startIndex[i];
        g_pJ1939MainData->totalMainCanInfo[i]->curInqOther.clusterEndIndex = endIndex[i];
        g_pJ1939MainData->totalMainCanInfo[i]->clusterNum = clusterNum[i];

        g_pJ1939MainData->totalMainCanInfo[i]->curInqSummary.clusterIndex = g_pJ1939MainData->totalMainCanInfo[i]->curInqSummary.clusterStartIndex;
        g_pJ1939MainData->totalMainCanInfo[i]->curInqDetail.clusterIndex = g_pJ1939MainData->totalMainCanInfo[i]->curInqDetail.clusterStartIndex;
        g_pJ1939MainData->totalMainCanInfo[i]->curInqOther.clusterIndex = g_pJ1939MainData->totalMainCanInfo[i]->curInqOther.clusterStartIndex;
        g_pJ1939MainData->totalMainCanInfo[i]->mainInitIndex = INVALID_INDEX;
        g_pJ1939MainData->totalMainCanInfo[i]->otherInqPeriod = OTHER_INQ_PERIOD;
        if(g_pJ1939MainData->detail_compress)
        {
            g_pJ1939MainData->totalMainCanInfo[i]->detailInqPeriod = DETAIL_INQ_PERIOD_COMPRESS;
        }
        else
        {
            g_pJ1939MainData->totalMainCanInfo[i]->detailInqPeriod = DETAIL_INQ_PERIOD;
        }
        if(detail_only)
        {
            //不请求概要信息
            g_pJ1939MainData->totalMainCanInfo[i]->curInqStep = HUB_MAIN_DB_INQUIRE_OTHER_INFO_ONLY;
        }
        else
        {
            //正常流程
            g_pJ1939MainData->totalMainCanInfo[i]->curInqStep = HUB_MAIN_DB_INQUIRE_INFO_INIT;
        }
    }

    g_pJ1939MainData->mainRegInqSummaryNum = SIZE_OF_ARRAY(g_J1939SummaryPara);
#if(BMS_FUNC_ENABLE_INQUIRE_DETAIL_INFO == 1)
    dbAddrTableListItemNum = DbObjCfgJ1939_GetDbAddrTableListItemNum();
    for(i=0;i<g_pJ1939MainData->mainRegInqSummaryNum;i++)
    {
        for(j= 0;i<dbAddrTableListItemNum;j++)
        {
            if(g_J1939SummaryPara[i].msgType == g_J1939_PF_DbAddrTableList[j].inquireOptType)
            {
                g_J1939SummaryPara[i].regNum = g_J1939_PF_DbAddrTableList[j].inquireOptTypeItemsNum;
                break;
            }
        }
    }
#endif
    g_pJ1939MainData->mainRegInqOtherNum = SIZE_OF_ARRAY(g_J1939OtherPara);
    for(i=0;i<g_pJ1939MainData->mainRegInqOtherNum;i++)
    {
        for(j= 0;i<dbAddrTableListItemNum;j++)
        {
            if(g_J1939OtherPara[i].msgType == g_J1939_PF_DbAddrTableList[j].inquireOptType)
            {
                g_J1939OtherPara[i].regNum = g_J1939_PF_DbAddrTableList[j].inquireOptTypeItemsNum;
                break;
            }
        }
    }
    g_pJ1939MainData->mainRegInqDetailNum = SIZE_OF_ARRAY(g_J1939DetailPara); 

    for(clusterIndex = 0; clusterIndex < BMS_CFG_ROCKSNUM_MAX; clusterIndex++)
    {
        // 先默认最多2路can，后续修改
        if(clusterIndex < clusterNum[CAN_OBJ_ID_1])
        {
            /*使用can1查询*/
            g_pJ1939MainData->mainBoard[clusterIndex].canHandleId = CAN_OBJ_ID_1;
        }
        else
        {
            /*使用can2查询*/
            g_pJ1939MainData->mainBoard[clusterIndex].canHandleId = CAN_OBJ_ID_2;
        }

        if(g_pJ1939MainData->mainBoard[clusterIndex].lastInquireSummaryLoopCnt == NULL)
        {
            g_pJ1939MainData->mainBoard[clusterIndex].lastInquireSummaryLoopCnt = (uint32_t *)malloc((sizeof(uint32_t))*g_pJ1939MainData->mainRegInqSummaryNum);
        }
        if(g_pJ1939MainData->mainBoard[clusterIndex].lastInquireSummaryLoopCnt == NULL)
        {
            return Std_Ret_ERR;
        }
        memset(g_pJ1939MainData->mainBoard[clusterIndex].lastInquireSummaryLoopCnt, 0x00, (sizeof(uint32_t))*g_pJ1939MainData->mainRegInqSummaryNum);

        if(g_pJ1939MainData->mainBoard[clusterIndex].lastInquireDetailLoopCnt == NULL)
        {
            g_pJ1939MainData->mainBoard[clusterIndex].lastInquireDetailLoopCnt = (uint32_t *)malloc((sizeof(uint32_t))*g_pJ1939MainData->mainRegInqDetailNum);
        }
        if(g_pJ1939MainData->mainBoard[clusterIndex].lastInquireDetailLoopCnt == NULL)
        {
            return Std_Ret_ERR;
        }
    }
    for(i = 0;i<cfg_table->num;i++)
    {
        if(g_pJ1939MainData->totalMainCanInfo[i] == NULL)
        {
            continue;
        }
        for(clusterIndex = 0; clusterIndex < g_pJ1939MainData->totalMainCanInfo[i]->clusterNum; clusterIndex++)
        {
            for(j=0;j<g_pJ1939MainData->mainRegInqDetailNum;j++)
            {
                if(g_J1939DetailPara[j].msgType == J1939_INQUIRE_OPT_TYPE_BAT_VOL_INFO)
                {
                    g_pJ1939MainData->mainBoard[clusterIndex].lastInquireDetailLoopCnt[j] = 0u; 
                }
                else
                {                   
                    g_pJ1939MainData->mainBoard[clusterIndex].lastInquireDetailLoopCnt[j] = (g_J1939DetailPara[j].msgInquirePeriod *clusterIndex)/(2u * g_pJ1939MainData->totalMainCanInfo[i]->clusterNum); 
                }
            }
            g_pJ1939MainData->totalMainCanInfo[i]->inquireDetailMsgRackInfo |= 1<<clusterIndex;
        }
        g_pJ1939MainData->totalMainCanInfo[i]->curInqDetail.inquireDetailMsgFlag = (uint32_t *)malloc(sizeof(uint32_t)*g_pJ1939MainData->mainRegInqDetailNum);
        memset(g_pJ1939MainData->totalMainCanInfo[i]->curInqDetail.inquireDetailMsgFlag,0x00,sizeof(uint32_t)*g_pJ1939MainData->mainRegInqDetailNum);
    }
    return ret;
}