motor_ctl-4/User project/3.BasicFunction/Source/i2c_master.c

/************************************************************************
 Project:               Welling Motor Control Paltform
 Filename:              i2c_master.c
 Partner Filename:      i2c_master.h
 Description:           I2C master driver
 Complier:              IAR Embedded Workbench for ARM 8.40.2
 CPU TYPE :             GD32F30x
*************************************************************************
 Copyright (c) 2022 Welling Motor Technology(Shanghai) Co. Ltd.
 All rights reserved.
*************************************************************************
*************************************************************************
 Revising History (ECL of this file):
 M0_20170410, by liyue, create this file;
************************************************************************/
/************************************************************************
 Beginning of File, do not put anything above here except notes
 Compiler Directives:
*************************************************************************/
#ifndef _I2C_MASTER_C_
#define _I2C_MASTER_C_
#endif

/************************************************************************
 Included File
*************************************************************************/
#include "i2c_master.h"
#include "api.h"
/*************************************************************************
 Exported Functions (N/A)
*************************************************************************/

/*************************************************************************
 Function:
 Description:
 Call by:
 Input Variables:
 Output/Return Variables:
 Subroutine Call:
 Reference:
*************************************************************************/
void i2c_voDefaultWriteBuffer(void)
{
    /* Parameter default value write*/ 
    UWORD *I2C_pBuffer;
    UBYTE i;

    I2C_pBuffer = &Syspara2.stMotorPara.uwPolePairs.uwDefault1;
    for (i = 0; i < I2C_MOTOR_PARA_N_WORDS; i++)
    {
        I2C_ubWriteBuffer[I2C_MOTOR_PARA_ARDDR + 2 * i] = (UBYTE)(*I2C_pBuffer >> 8);
        I2C_ubWriteBuffer[I2C_MOTOR_PARA_ARDDR + 2 * i + 1] = (UBYTE)(*I2C_pBuffer);
        I2C_pBuffer += I2C_PBUFFER_NWORDS; /* parasoft-suppress MISRA2004-17_1 "本项目无法更改，后续避免未指向数组的指针运算" */ /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
    }

    I2C_pBuffer = &Syspara2.stBikePara.uwWheelPerimeter.uwDefault1;
    for (i = 0; i < I2C_BIKE_PARA_N_WORDS; i++)
    {
        I2C_ubWriteBuffer[I2C_BIKE_PARA_ARDDR + 2 * i] = (UBYTE)(*I2C_pBuffer >> 8);
        I2C_ubWriteBuffer[I2C_BIKE_PARA_ARDDR + 2 * i + 1] = (UBYTE)(*I2C_pBuffer);
        I2C_pBuffer += I2C_PBUFFER_NWORDS; /* parasoft-suppress MISRA2004-17_1 "本项目无法更改，后续避免未指向数组的指针运算" */ /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
    }

    I2C_pBuffer = &Syspara2.stMControlPara.ParaFirstSetFlg.uwDefault1;
    for (i = 0; i < I2C_MCONTROL_PARA_N_WORDS; i++)
    {
        I2C_ubWriteBuffer[I2C_MCONTROL_PARA_ARDDR + 2 * i] = (UBYTE)(*I2C_pBuffer >> 8);
        I2C_ubWriteBuffer[I2C_MCONTROL_PARA_ARDDR + 2 * i + 1] = (UBYTE)(*I2C_pBuffer);
        I2C_pBuffer += I2C_PBUFFER_NWORDS; /* parasoft-suppress MISRA2004-17_1 "本项目无法更改，后续避免未指向数组的指针运算" */ /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
    }

    I2C_pBuffer = &Syspara2.stSensorPara.uwTorSensorOffsetOrigin.uwDefault1;
    for (i = 0; i < I2C_SENSOR_PARA_N_WORDS; i++)
    {
        I2C_ubWriteBuffer[I2C_SENSOR_PARA_ARDDR + 2 * i] = (UBYTE)(*I2C_pBuffer >> 8);
        I2C_ubWriteBuffer[I2C_SENSOR_PARA_ARDDR + 2 * i + 1] = (UBYTE)(*I2C_pBuffer);
        I2C_pBuffer += I2C_PBUFFER_NWORDS; /* parasoft-suppress MISRA2004-17_1 "本项目无法更改，后续避免未指向数组的指针运算" */ /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
    }

    I2C_pBuffer = &Syspara2.stAssistPara.uwStartupGain.uwDefault1;
    for (i = 0; i < I2C_ASSIST_PARA_N_WORDS; i++)
    {
        I2C_ubWriteBuffer[I2C_ASSIST_PARA_ARDDR + 2 * i] = (UBYTE)(*I2C_pBuffer >> 8);
        I2C_ubWriteBuffer[I2C_ASSIST_PARA_ARDDR + 2 * i + 1] = (UBYTE)(*I2C_pBuffer);
        I2C_pBuffer += I2C_PBUFFER_NWORDS; /* parasoft-suppress MISRA2004-17_1 "本项目无法更改，后续避免未指向数组的指针运算" */ /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
    }
    
    I2C_pBuffer = &Syspara2.stGearBoxPara.uwGearBoxNum.uwDefault1;
    for (i = 0; i < I2C_GEARBOX_PARA_N_WORDS; i++)
    {
        I2C_ubWriteBuffer[I2C_GEARBOX_PARA_ADDR + 2 * i] = (UBYTE)(*I2C_pBuffer >> 8);
        I2C_ubWriteBuffer[I2C_GEARBOX_PARA_ADDR + 2 * i + 1] = (UBYTE)(*I2C_pBuffer);
        I2C_pBuffer += I2C_PBUFFER_NWORDS;
    }

    I2C_pWriteBuffer = I2C_ubWriteBuffer;
    I2C_ubWriteBuffer[I2C_MOTOR_PARA_CRC_ARDDR] = (UBYTE)(i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_MOTOR_PARA_N_BYTES) >> 8);
    I2C_ubWriteBuffer[I2C_MOTOR_PARA_CRC_ARDDR + 1] = (UBYTE)(i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_MOTOR_PARA_N_BYTES));

    I2C_pWriteBuffer = I2C_ubWriteBuffer + I2C_BIKE_PARA_ARDDR; /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
    I2C_ubWriteBuffer[I2C_BIKE_PARA_CRC_ARDDR] = (UBYTE)(i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_BIKE_PARA_N_BYTES) >> 8);
    I2C_ubWriteBuffer[I2C_BIKE_PARA_CRC_ARDDR + 1] = (UBYTE)(i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_BIKE_PARA_N_BYTES));

    I2C_pWriteBuffer = I2C_ubWriteBuffer + I2C_MCONTROL_PARA_ARDDR; /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
    I2C_ubWriteBuffer[I2C_MCONTROL_PARA_CRC_ARDDR] = (UBYTE)(i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_MCONTROL_PARA_N_BYTES) >> 8);
    I2C_ubWriteBuffer[I2C_MCONTROL_PARA_CRC_ARDDR + 1] = (UBYTE)(i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_MCONTROL_PARA_N_BYTES));

    I2C_pWriteBuffer = I2C_ubWriteBuffer + I2C_SENSOR_PARA_ARDDR; /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
    I2C_ubWriteBuffer[I2C_SENSOR_PARA_CRC_ARDDR] = (UBYTE)(i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_SENSOR_PARA_N_BYTES) >> 8);
    I2C_ubWriteBuffer[I2C_SENSOR_PARA_CRC_ARDDR + 1] = (UBYTE)(i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_SENSOR_PARA_N_BYTES));

    I2C_pWriteBuffer = I2C_ubWriteBuffer + I2C_ASSIST_PARA_ARDDR; /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
    I2C_ubWriteBuffer[I2C_ASSIST_PARA_CRC_ARDDR] = (UBYTE)(i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_ASSIST_PARA_N_BYTES) >> 8);
    I2C_ubWriteBuffer[I2C_ASSIST_PARA_CRC_ARDDR + 1] = (UBYTE)(i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_ASSIST_PARA_N_BYTES));
    
    I2C_pWriteBuffer = I2C_ubWriteBuffer + I2C_GEARBOX_PARA_ADDR;
    I2C_ubWriteBuffer[I2C_GEARBOX_PARA_CRC_ADDR] = (UBYTE)(i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_GEARBOX_PARA_N_BYTES) >> 8);
    I2C_ubWriteBuffer[I2C_GEARBOX_PARA_CRC_ADDR + 1] = (UBYTE)(i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_GEARBOX_PARA_N_BYTES));
}
/*************************************************************************
 Function:
 Description:
 Call by:
 Input Variables:
 Output/Return Variables:
 Subroutine Call:
 Reference:
*************************************************************************/
void i2c_voParaWriteBuffer(void)
{
    /* Parameter real value write*/ 
    UWORD *I2C_pBuffer;
    UBYTE i;   
    
    I2C_pBuffer = &Syspara2.stMotorPara.uwPolePairs.uwDefault1;
    for (i = 0; i < I2C_MOTOR_PARA_N_WORDS; i++)
    {
        I2C_ubWriteBuffer[I2C_MOTOR_PARA_ARDDR + 2 * i] = (UBYTE)(*(I2C_pBuffer + 1) >> 8); /* parasoft-suppress MISRA2004-17_1 "本项目无法更改，后续避免未指向数组的指针运算" */ /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
        I2C_ubWriteBuffer[I2C_MOTOR_PARA_ARDDR + 2 * i + 1] = (UBYTE)(*(I2C_pBuffer + 1)); /* parasoft-suppress MISRA2004-17_1 "本项目无法更改，后续避免未指向数组的指针运算" */ /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
        I2C_pBuffer += I2C_PBUFFER_NWORDS; /* parasoft-suppress MISRA2004-17_1 "本项目无法更改，后续避免未指向数组的指针运算" */ /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
    }

    I2C_pBuffer = &Syspara2.stBikePara.uwWheelPerimeter.uwDefault1;
    for (i = 0; i < I2C_BIKE_PARA_N_WORDS; i++)
    {
        I2C_ubWriteBuffer[I2C_BIKE_PARA_ARDDR + 2 * i] = (UBYTE)(*(I2C_pBuffer + 1) >> 8); /* parasoft-suppress MISRA2004-17_1 "本项目无法更改，后续避免未指向数组的指针运算" */ /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
        I2C_ubWriteBuffer[I2C_BIKE_PARA_ARDDR + 2 * i + 1] = (UBYTE)(*(I2C_pBuffer + 1)); /* parasoft-suppress MISRA2004-17_1 "本项目无法更改，后续避免未指向数组的指针运算" */ /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
        I2C_pBuffer += I2C_PBUFFER_NWORDS; /* parasoft-suppress MISRA2004-17_1 "本项目无法更改，后续避免未指向数组的指针运算" */ /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
    }

    I2C_pBuffer = &Syspara2.stMControlPara.ParaFirstSetFlg.uwDefault1;
    for (i = 0; i < I2C_MCONTROL_PARA_N_WORDS; i++)
    {
        I2C_ubWriteBuffer[I2C_MCONTROL_PARA_ARDDR + 2 * i] = (UBYTE)(*(I2C_pBuffer + 1) >> 8); /* parasoft-suppress MISRA2004-17_1 "本项目无法更改，后续避免未指向数组的指针运算" */ /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
        I2C_ubWriteBuffer[I2C_MCONTROL_PARA_ARDDR + 2 * i + 1] = (UBYTE)(*(I2C_pBuffer + 1)); /* parasoft-suppress MISRA2004-17_1 "本项目无法更改，后续避免未指向数组的指针运算" */ /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
        I2C_pBuffer += I2C_PBUFFER_NWORDS; /* parasoft-suppress MISRA2004-17_1 "本项目无法更改，后续避免未指向数组的指针运算" */ /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
    }

    I2C_pBuffer = &Syspara2.stSensorPara.uwTorSensorOffsetOrigin.uwDefault1;
    for (i = 0; i < I2C_SENSOR_PARA_N_WORDS; i++)
    {
        I2C_ubWriteBuffer[I2C_SENSOR_PARA_ARDDR + 2 * i] = (UBYTE)(*(I2C_pBuffer + 1) >> 8); /* parasoft-suppress MISRA2004-17_1 "本项目无法更改，后续避免未指向数组的指针运算" */ /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
        I2C_ubWriteBuffer[I2C_SENSOR_PARA_ARDDR + 2 * i + 1] = (UBYTE)(*(I2C_pBuffer + 1)); /* parasoft-suppress MISRA2004-17_1 "本项目无法更改，后续避免未指向数组的指针运算" */ /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
        I2C_pBuffer += I2C_PBUFFER_NWORDS; /* parasoft-suppress MISRA2004-17_1 "本项目无法更改，后续避免未指向数组的指针运算" */ /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
    }

    I2C_pBuffer = &Syspara2.stAssistPara.uwStartupGain.uwDefault1;
    for (i = 0; i < I2C_ASSIST_PARA_N_WORDS; i++)
    {
        I2C_ubWriteBuffer[I2C_ASSIST_PARA_ARDDR + 2 * i] = (UBYTE)(*(I2C_pBuffer + 1) >> 8); /* parasoft-suppress MISRA2004-17_1 "本项目无法更改，后续避免未指向数组的指针运算" */ /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
        I2C_ubWriteBuffer[I2C_ASSIST_PARA_ARDDR + 2 * i + 1] = (UBYTE)(*(I2C_pBuffer + 1)); /* parasoft-suppress MISRA2004-17_1 "本项目无法更改，后续避免未指向数组的指针运算" */ /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
        I2C_pBuffer += I2C_PBUFFER_NWORDS; /* parasoft-suppress MISRA2004-17_1 "本项目无法更改，后续避免未指向数组的指针运算" */ /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
    }
    
    I2C_pBuffer = &Syspara2.stGearBoxPara.uwGearBoxNum.uwDefault1;
    for (i = 0; i < I2C_GEARBOX_PARA_N_WORDS; i++)
    {
        I2C_ubWriteBuffer[I2C_GEARBOX_PARA_ADDR + 2 * i] = (UBYTE)(*(I2C_pBuffer + 1) >> 8);
        I2C_ubWriteBuffer[I2C_GEARBOX_PARA_ADDR + 2 * i + 1] = (UBYTE)(*(I2C_pBuffer + 1));
        I2C_pBuffer += I2C_PBUFFER_NWORDS;
    }

    I2C_pWriteBuffer = I2C_ubWriteBuffer;
    I2C_ubWriteBuffer[I2C_MOTOR_PARA_CRC_ARDDR] = (UBYTE)(i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_MOTOR_PARA_N_BYTES) >> 8);
    I2C_ubWriteBuffer[I2C_MOTOR_PARA_CRC_ARDDR + 1] = (UBYTE)(i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_MOTOR_PARA_N_BYTES));

    I2C_pWriteBuffer = I2C_ubWriteBuffer + I2C_BIKE_PARA_ARDDR; /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
    I2C_ubWriteBuffer[I2C_BIKE_PARA_CRC_ARDDR] = (UBYTE)(i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_BIKE_PARA_N_BYTES) >> 8);
    I2C_ubWriteBuffer[I2C_BIKE_PARA_CRC_ARDDR + 1] = (UBYTE)(i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_BIKE_PARA_N_BYTES));

    I2C_pWriteBuffer = I2C_ubWriteBuffer + I2C_MCONTROL_PARA_ARDDR; /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
    I2C_ubWriteBuffer[I2C_MCONTROL_PARA_CRC_ARDDR] = (UBYTE)(i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_MCONTROL_PARA_N_BYTES) >> 8);
    I2C_ubWriteBuffer[I2C_MCONTROL_PARA_CRC_ARDDR + 1] = (UBYTE)(i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_MCONTROL_PARA_N_BYTES));

    I2C_pWriteBuffer = I2C_ubWriteBuffer + I2C_SENSOR_PARA_ARDDR; /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
    I2C_ubWriteBuffer[I2C_SENSOR_PARA_CRC_ARDDR] = (UBYTE)(i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_SENSOR_PARA_N_BYTES) >> 8);
    I2C_ubWriteBuffer[I2C_SENSOR_PARA_CRC_ARDDR + 1] = (UBYTE)(i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_SENSOR_PARA_N_BYTES));

    I2C_pWriteBuffer = I2C_ubWriteBuffer + I2C_ASSIST_PARA_ARDDR; /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
    I2C_ubWriteBuffer[I2C_ASSIST_PARA_CRC_ARDDR] = (UBYTE)(i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_ASSIST_PARA_N_BYTES) >> 8);
    I2C_ubWriteBuffer[I2C_ASSIST_PARA_CRC_ARDDR + 1] = (UBYTE)(i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_ASSIST_PARA_N_BYTES));
    
    I2C_pWriteBuffer = I2C_ubWriteBuffer + I2C_GEARBOX_PARA_ADDR;
    I2C_ubWriteBuffer[I2C_GEARBOX_PARA_CRC_ADDR] = (UBYTE)(i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_GEARBOX_PARA_N_BYTES) >> 8);
    I2C_ubWriteBuffer[I2C_GEARBOX_PARA_CRC_ADDR + 1] = (UBYTE)(i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_GEARBOX_PARA_N_BYTES));
}
/*************************************************************************
 Function:
 Description:
 Call by:
 Input Variables:
 Output/Return Variables:
 Subroutine Call:
 Reference:
*************************************************************************/
void i2c_voHistoryDefaultWriteBuffer(void)
{
    /* History default value write*/ 
    UWORD *I2C_pBuffer;
    UBYTE *I2C_pBuffer_byte;
    UBYTE  i;

    I2C_pBuffer = &Syspara2.stHistoryPara.uwAssModSelect.uwDefault1;
    for (i = 0; i < I2C_HISTORY_PARA_N_WORDS; i++)
    {
        I2C_ubHistoyWriteBuffer[I2C_HISTORY_PARA_ARDDR + 2 * i] = (UBYTE)(*(I2C_pBuffer) >> 8); /* parasoft-suppress MISRA2004-17_1 "本项目无法更改，后续避免未指向数组的指针运算" */ /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
        I2C_ubHistoyWriteBuffer[I2C_HISTORY_PARA_ARDDR + 2 * i + 1] = (UBYTE)(*(I2C_pBuffer)); /* parasoft-suppress MISRA2004-17_1 "本项目无法更改，后续避免未指向数组的指针运算" */ /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
        I2C_pBuffer += I2C_PBUFFER_NWORDS; /* parasoft-suppress MISRA2004-17_1 "本项目无法更改，后续避免未指向数组的指针运算" */ /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
    }
    
    I2C_pBuffer_byte = &Syspara2.stRidePara.ucAssistRatioGain1.ucDefault1;
    for (i = 0; i < I2C_RIDE_PARA_N_BYTES; i++)
    {
        I2C_ubHistoyWriteBuffer[I2C_RIDE_PARA_ADDR + i] = (UBYTE)(*I2C_pBuffer_byte);
        I2C_pBuffer_byte += I2C_PBUFFERBYTE_BYTES;
    }
    
    I2C_pBuffer = &Syspara2.stBikePara2.uwNoneOBCEnable.uwDefault1;
    for (i = 0; i < I2C_BIKE_PARA2_N_WORDS; i++)
    {
        I2C_ubHistoyWriteBuffer[I2C_BIKE_PARA2_ADDR + 2 * i] = (UBYTE)(*I2C_pBuffer >> 8);
        I2C_ubHistoyWriteBuffer[I2C_BIKE_PARA2_ADDR + 2 * i + 1] = (UBYTE)(*I2C_pBuffer);
        I2C_pBuffer += I2C_PBUFFER_NWORDS;
    }

    I2C_pHistoryWriteBuffer = I2C_ubHistoyWriteBuffer;
    I2C_ubHistoyWriteBuffer[I2C_HISTORY_PARA_CRC_ARDDR] = (UBYTE)(i2c_uwCRCCcitt(I2C_pHistoryWriteBuffer, I2C_HISTORY_PARA_N_BYTES) >> 8);
    I2C_ubHistoyWriteBuffer[I2C_HISTORY_PARA_CRC_ARDDR + 1] = (UBYTE)(i2c_uwCRCCcitt(I2C_pHistoryWriteBuffer, I2C_HISTORY_PARA_N_BYTES));
    
    I2C_pHistoryWriteBuffer = I2C_ubHistoyWriteBuffer + I2C_RIDE_PARA_ADDR;
    I2C_ubHistoyWriteBuffer[I2C_RIDE_PARA_CRC_ADDR] = (UBYTE)(i2c_uwCRCCcitt(I2C_pHistoryWriteBuffer, I2C_RIDE_PARA_N_BYTES) >> 8);
    I2C_ubHistoyWriteBuffer[I2C_RIDE_PARA_CRC_ADDR + 1] = (UBYTE)(i2c_uwCRCCcitt(I2C_pHistoryWriteBuffer, I2C_RIDE_PARA_N_BYTES));
    
    I2C_pHistoryWriteBuffer = I2C_ubHistoyWriteBuffer + I2C_BIKE_PARA2_ADDR;
    I2C_ubHistoyWriteBuffer[I2C_BIKE_PARA2_CRC_ADDR] = (UBYTE)(i2c_uwCRCCcitt(I2C_pHistoryWriteBuffer, I2C_BIKE_PARA2_N_BYTES) >> 8);
    I2C_ubHistoyWriteBuffer[I2C_BIKE_PARA2_CRC_ADDR + 1] = (UBYTE)(i2c_uwCRCCcitt(I2C_pHistoryWriteBuffer, I2C_BIKE_PARA2_N_BYTES));
}
/*************************************************************************
 Function:
 Description:
 Call by:
 Input Variables:
 Output/Return Variables:
 Subroutine Call:
 Reference:
*************************************************************************/
void i2c_voHistoryWriteBuffer(void)
{
    UWORD *I2C_pBuffer;
    UBYTE *I2C_pBuffer_byte;
    UBYTE  i;

    I2C_pBuffer = &Syspara2.stHistoryPara.uwAssModSelect.uwDefault1;
    for (i = 0; i < I2C_HISTORY_PARA_N_WORDS; i++)
    {
        I2C_ubHistoyWriteBuffer[I2C_HISTORY_PARA_ARDDR + 2 * i] = (UBYTE)(*(I2C_pBuffer + 1) >> 8);
        I2C_ubHistoyWriteBuffer[I2C_HISTORY_PARA_ARDDR + 2 * i + 1] = (UBYTE)(*(I2C_pBuffer + 1));
        I2C_pBuffer += I2C_PBUFFER_NWORDS;
    }
    
    I2C_pBuffer_byte = &Syspara2.stRidePara.ucAssistRatioGain1.ucDefault1;
    for (i = 0; i < I2C_RIDE_PARA_N_BYTES; i++)
    {
        I2C_ubHistoyWriteBuffer[I2C_RIDE_PARA_ADDR + i] = (UBYTE)(*(I2C_pBuffer_byte + 1));
        I2C_pBuffer_byte += I2C_PBUFFERBYTE_BYTES;
    }
    
    I2C_pBuffer = &Syspara2.stBikePara2.uwNoneOBCEnable.uwDefault1;
    for (i = 0; i < I2C_BIKE_PARA2_N_WORDS; i++)
    {
        I2C_ubHistoyWriteBuffer[I2C_BIKE_PARA2_ADDR + 2 * i] = (UBYTE)(*(I2C_pBuffer + 1) >> 8);
        I2C_ubHistoyWriteBuffer[I2C_BIKE_PARA2_ADDR + 2 * i + 1] = (UBYTE)(*(I2C_pBuffer + 1));
        I2C_pBuffer += I2C_PBUFFER_NWORDS;
    }

    I2C_pHistoryWriteBuffer = I2C_ubHistoyWriteBuffer;
    I2C_ubHistoyWriteBuffer[I2C_HISTORY_PARA_CRC_ARDDR] = (UBYTE)(i2c_uwCRCCcitt(I2C_pHistoryWriteBuffer, I2C_HISTORY_PARA_N_BYTES) >> 8);
    I2C_ubHistoyWriteBuffer[I2C_HISTORY_PARA_CRC_ARDDR + 1] = (UBYTE)(i2c_uwCRCCcitt(I2C_pHistoryWriteBuffer, I2C_HISTORY_PARA_N_BYTES));
    
    I2C_pHistoryWriteBuffer = I2C_ubHistoyWriteBuffer + I2C_RIDE_PARA_ADDR;
    I2C_ubHistoyWriteBuffer[I2C_RIDE_PARA_CRC_ADDR] = (UBYTE)(i2c_uwCRCCcitt(I2C_pHistoryWriteBuffer, I2C_RIDE_PARA_N_BYTES) >> 8);
    I2C_ubHistoyWriteBuffer[I2C_RIDE_PARA_CRC_ADDR + 1] = (UBYTE)(i2c_uwCRCCcitt(I2C_pHistoryWriteBuffer, I2C_RIDE_PARA_N_BYTES));
    
    I2C_pHistoryWriteBuffer = I2C_ubHistoyWriteBuffer + I2C_BIKE_PARA2_ADDR;
    I2C_ubHistoyWriteBuffer[I2C_BIKE_PARA2_CRC_ADDR] = (UBYTE)(i2c_uwCRCCcitt(I2C_pHistoryWriteBuffer, I2C_BIKE_PARA2_N_BYTES) >> 8);
    I2C_ubHistoyWriteBuffer[I2C_BIKE_PARA2_CRC_ADDR + 1] = (UBYTE)(i2c_uwCRCCcitt(I2C_pHistoryWriteBuffer, I2C_BIKE_PARA2_N_BYTES));
}
/*************************************************************************
 Function:
 Description:
 Call by:
 Input Variables:
 Output/Return Variables:
 Subroutine Call:
 Reference:
*************************************************************************/
void i2c_voInfoWrite2EE(const I2C_TX_COF *coef, I2C_TX_OUT *out)
{
    UBYTE ubNBytes;
    UBYTE ubReTX1;
    UBYTE ubSlaveAddr;
    UBYTE ubWriteAddr;

    ubNBytes = I2C_TX1_NBYTES;
    ubReTX1 = I2C_RETX1_TIMES;
#if(ubReTX1 >= 2)
     ubReTX1 = 2;
#endif
    ubWriteAddr = 0x00;
    ubSlaveAddr = I2C_SLAVEADDR_BLOCK1;

    while (ubReTX1 != 0)
    {
    	ubReTX1--;
        I2C_pWriteBuffer = I2C_ubWriteBuffer;
        if (ubReTX1 == 1)
        {
            ubSlaveAddr = I2C_SLAVEADDR_BLOCK2;
        }
        if (ubReTX1 == 0)
        {
            ubSlaveAddr = I2C_SLAVEADDR_BLOCK1;
        }

        iI2C_Write(0, ubSlaveAddr, ubWriteAddr, 8, I2C_pWriteBuffer, ubNBytes);
    }

    if ((ubReTX1 == 0) && (I2C_EE_ComuFltFlg != TRUE))
    {
        out->blTX1FinishFlg = TRUE;
    }
    else
    {
        out->blTX1FinishFlg = FALSE;
    }
}
/*************************************************************************
 Function:
 Description:
 Call by:
 Input Variables:
 Output/Return Variables:
 Subroutine Call:
 Reference:
*************************************************************************/
void i2c_voHistoryWrite2EE(const I2C_TX_COF *coef, I2C_TX_OUT *out)
{
    UBYTE ubNBytes;
    UBYTE ubReTX2;
    UBYTE ubSlaveAddr;
    UBYTE ubWriteAddr;

    ubNBytes = I2C_TX2_NBYTES;
    ubReTX2 = I2C_RETX2_TIMES;
#if(ubReTX2 >= 2)
	ubReTX2 = 2;
#endif

    ubSlaveAddr = I2C_SLAVEADDR_BLOCK3;
    ubWriteAddr = 0x00;

    while (ubReTX2 != 0)
    {
    	ubReTX2--;
        I2C_pHistoryWriteBuffer = I2C_ubHistoyWriteBuffer;
        if (ubReTX2 == 1)
        {
            ubSlaveAddr = I2C_SLAVEADDR_BLOCK4;
        }
        if (ubReTX2 == 0)
        {
            ubSlaveAddr = I2C_SLAVEADDR_BLOCK3;
        }
        
        iI2C_Write(0, ubSlaveAddr, ubWriteAddr, 8, I2C_pHistoryWriteBuffer, ubNBytes);
    }
    if ((ubReTX2 == 0) && (I2C_EE_ComuFltFlg != TRUE))
    {
        out->blTX2FinishFlg = TRUE;
    }
    else
    {
        out->blTX2FinishFlg = FALSE;
    }
}

/*************************************************************************
 Function:
 Description:
 Call by:
 Input Variables:
 Output/Return Variables:
 Subroutine Call:
 Reference:
*************************************************************************/
void i2c_voSysparaReadFromEE(I2C_RXCRC_OUT *out) /* parasoft-suppress METRICS-28 "本项目圈复杂度无法更改，后续避免" */
{
   UBYTE ubRdNBytes = 0, ubRdSlaveAddr = 0, ubRdAddr = 0;
   UBYTE ubRdCnt = 2;
   UBYTE *p_buffer;
   
    while(ubRdCnt != 0)
    {
   	 ubRdCnt--;

       if (ubRdCnt == 1)
       {
           ubRdSlaveAddr = I2C_SLAVEADDR_BLOCK1;
           ubRdAddr = 0x00;
           ubRdNBytes = I2C_RX1_NBYTES;           
           p_buffer = I2C_ubReadBuffer[0];
       }
       else if (ubRdCnt == 0)
       {
           ubRdSlaveAddr = I2C_SLAVEADDR_BLOCK3;
           ubRdAddr = 0x00;
           ubRdNBytes = I2C_RX2_NBYTES;
           p_buffer = I2C_ubReadBuffer[1];
       }
       else
       {
       	//do nothing
       }

       iI2C_Read(0, ubRdSlaveAddr, ubRdAddr, 8, p_buffer, ubRdNBytes);
   }

    i2c_voReadBufferCRC(out);

    i2c_voGetValueFrmBuffer(out);

    out->ReadFinishFlg = TRUE;
}

/*************************************************************************
 Function:
 Description:
 Call by:
 Input Variables:
 Output/Return Variables:
 Subroutine Call:
 Reference:
*************************************************************************/
UWORD i2c_uwCRCCcitt(const UBYTE *ptubBuf, UWORD length)
{
    UBYTE b = 0;
    UWORD crc = 0xffff;
    UWORD i, j;
    for (i = 0; i < length; i++)
    {
        for (j = 0; j < 8; j++)
        {
            b = (UBYTE)(((ptubBuf[i] << j) & 0x80) ^ ((crc & 0x8000) >> 8)); /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
            crc <<= 1;
            if (b != 0)
            {
                crc ^= 0x1021; // crc = crc^(0x10000^0x11021)
            }
        }
    }
    return crc;
}
/*************************************************************************
 Function:
 Description:
 Call by:
 Input Variables:
 Output/Return Variables:
 Subroutine Call:
 Reference:
*************************************************************************/
void  i2c_voReadBufferCRC(I2C_RXCRC_OUT *out)
{
    UWORD uwMotorParaCRC, uwBikeParaCRC, uwMControlParaCRC;
    UWORD uwSensorParaCRC, uwAssistParaCRC, uwGearBoxParaCRC, uwHistoryParaCRC, uwRideParaCRC, uwBikePara2CRC;
    UWORD uwMotorParaRdCRC, uwBikeParaRdCRC, uwMControlParaRdCRC;
    UWORD uwSensorParaRdCRC, uwAssistParaRdCRC, uwGearBoxParaRdCRC, uwHistoryParaRdCRC, uwRideParaRdCRC, uwBikePara2RdCRC;

    I2C_pReadBuffer = I2C_ubReadBuffer[0];
    uwMotorParaCRC = i2c_uwCRCCcitt(I2C_pReadBuffer, I2C_MOTOR_PARA_N_BYTES);
    uwBikeParaCRC = i2c_uwCRCCcitt(I2C_pReadBuffer + I2C_BIKE_PARA_ARDDR, I2C_BIKE_PARA_N_BYTES); /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
    uwMControlParaCRC = i2c_uwCRCCcitt(I2C_pReadBuffer + I2C_MCONTROL_PARA_ARDDR, I2C_MCONTROL_PARA_N_BYTES); /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
    uwSensorParaCRC = i2c_uwCRCCcitt(I2C_pReadBuffer + I2C_SENSOR_PARA_ARDDR, I2C_SENSOR_PARA_N_BYTES); /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
    uwAssistParaCRC = i2c_uwCRCCcitt(I2C_pReadBuffer + I2C_ASSIST_PARA_ARDDR, I2C_ASSIST_PARA_N_BYTES); /* parasoft-suppress MISRA2004-17_4 "本项目无法更改，后续避免非数组索引指针运算" */
    uwGearBoxParaCRC = i2c_uwCRCCcitt(I2C_pReadBuffer + I2C_GEARBOX_PARA_ADDR, I2C_GEARBOX_PARA_N_BYTES);
    
    I2C_pReadBuffer = I2C_ubReadBuffer[1];
    uwHistoryParaCRC = i2c_uwCRCCcitt(I2C_pReadBuffer, I2C_HISTORY_PARA_N_BYTES);
    uwRideParaCRC = i2c_uwCRCCcitt(I2C_pReadBuffer + I2C_RIDE_PARA_ADDR, I2C_RIDE_PARA_N_BYTES);
    uwBikePara2CRC = i2c_uwCRCCcitt(I2C_pReadBuffer + I2C_BIKE_PARA2_ADDR, I2C_BIKE_PARA2_N_BYTES);

    uwMotorParaRdCRC = (UWORD)((UWORD)I2C_ubReadBuffer[0][I2C_MOTOR_PARA_CRC_ARDDR] << 8) + I2C_ubReadBuffer[0][I2C_MOTOR_PARA_CRC_ARDDR + 1];
    uwBikeParaRdCRC = (UWORD)((UWORD)I2C_ubReadBuffer[0][I2C_BIKE_PARA_CRC_ARDDR] << 8) + I2C_ubReadBuffer[0][I2C_BIKE_PARA_CRC_ARDDR + 1];
    uwMControlParaRdCRC = (UWORD)((UWORD)I2C_ubReadBuffer[0][I2C_MCONTROL_PARA_CRC_ARDDR] << 8) + I2C_ubReadBuffer[0][I2C_MCONTROL_PARA_CRC_ARDDR + 1];
    uwSensorParaRdCRC = (UWORD)((UWORD)I2C_ubReadBuffer[0][I2C_SENSOR_PARA_CRC_ARDDR] << 8) + I2C_ubReadBuffer[0][I2C_SENSOR_PARA_CRC_ARDDR + 1];
    uwAssistParaRdCRC = (UWORD)((UWORD)I2C_ubReadBuffer[0][I2C_ASSIST_PARA_CRC_ARDDR] << 8) + I2C_ubReadBuffer[0][I2C_ASSIST_PARA_CRC_ARDDR + 1];
    uwGearBoxParaRdCRC = (UWORD)((UWORD)I2C_ubReadBuffer[0][I2C_GEARBOX_PARA_CRC_ADDR] << 8) + I2C_ubReadBuffer[0][I2C_GEARBOX_PARA_CRC_ADDR + 1];
    uwHistoryParaRdCRC = (UWORD)((UWORD)I2C_ubReadBuffer[1][I2C_HISTORY_PARA_CRC_ARDDR] << 8) + I2C_ubReadBuffer[1][I2C_HISTORY_PARA_CRC_ARDDR + 1];
    uwRideParaRdCRC = (UWORD)((UWORD)I2C_ubReadBuffer[1][I2C_RIDE_PARA_CRC_ADDR] << 8) + I2C_ubReadBuffer[1][I2C_RIDE_PARA_CRC_ADDR + 1];
    uwBikePara2RdCRC = (UWORD)((UWORD)I2C_ubReadBuffer[1][I2C_BIKE_PARA2_CRC_ADDR] << 8) + I2C_ubReadBuffer[1][I2C_BIKE_PARA2_CRC_ADDR + 1];

    if (uwMotorParaCRC != uwMotorParaRdCRC)
    {
        out->blMotorParaFltFlg = TRUE;
    }
    if (uwBikeParaCRC != uwBikeParaRdCRC)
    {
        out->blBikeParaFltFlg = TRUE;
    }
    if (uwMControlParaCRC != uwMControlParaRdCRC)
    {
        out->blMControlParaFltFlg = TRUE;
    }
    if (uwSensorParaCRC != uwSensorParaRdCRC)
    {
        out->blSensorParaFltFlg = TRUE;
    }
    if (uwAssistParaCRC != uwAssistParaRdCRC)
    {
        out->blAssistParaFltFlg = TRUE;
    }
    if (uwGearBoxParaCRC != uwGearBoxParaRdCRC)
    {
        out->blGearBoxParaFltFlg = TRUE;
    }
    if (uwHistoryParaCRC != uwHistoryParaRdCRC)
    {
        out->blHistoryParaFltFlg = TRUE;
    }
    if (uwRideParaCRC != uwRideParaRdCRC)
    {
        out->blRideParaFltFlg = TRUE;
    }
    if (uwBikePara2CRC != uwBikePara2RdCRC)
    {
        out->blBikePara2FltFlg = TRUE;
    }
}
/*************************************************************************
 Function:
 Description:
 Call by:
 Input Variables:
 Output/Return Variables:
 Subroutine Call:
 Reference:
*************************************************************************/
void i2c_voGetValueFrmBuffer(const I2C_RXCRC_OUT *out)
{

    UBYTE j = 0;

    if (out->blMotorParaFltFlg != TRUE)
    {
        for (j = 0; j < I2C_MOTOR_PARA_N_WORDS; j++)
        {
            I2C_uwMotorParaRead[j] = (UWORD)((UWORD)I2C_ubReadBuffer[0][I2C_MOTOR_PARA_ARDDR + 2 * j] << 8) + I2C_ubReadBuffer[0][I2C_MOTOR_PARA_ARDDR + 2 * j + 1];
        }
    }
    else
    {}

    if (out->blBikeParaFltFlg != TRUE)
    {
        for (j = 0; j < I2C_BIKE_PARA_N_WORDS; j++)
        {
            I2C_uwBikeParaRead[j] = (UWORD)((UWORD)I2C_ubReadBuffer[0][I2C_BIKE_PARA_ARDDR + 2 * j] << 8) + I2C_ubReadBuffer[0][I2C_BIKE_PARA_ARDDR + 2 * j + 1];
        }
    }
    else
    {}

    if (out->blMControlParaFltFlg != TRUE)
    {
        for (j = 0; j < I2C_MCONTROL_PARA_N_WORDS; j++)
        {
            I2C_uwMControlRead[j] =
            		(UWORD)((UWORD)I2C_ubReadBuffer[0][I2C_MCONTROL_PARA_ARDDR + 2 * j] << 8) + I2C_ubReadBuffer[0][I2C_MCONTROL_PARA_ARDDR + 2 * j + 1];
        }
    }
    else
    {}

    if (out->blSensorParaFltFlg != TRUE)
    {
        for (j = 0; j < I2C_SENSOR_PARA_N_WORDS; j++)
        {
            I2C_uwSensorRead[j] = (UWORD)((UWORD)I2C_ubReadBuffer[0][I2C_SENSOR_PARA_ARDDR + 2 * j] << 8) + I2C_ubReadBuffer[0][I2C_SENSOR_PARA_ARDDR + 2 * j + 1];
        }
    }
    else
    {}

    if (out->blAssistParaFltFlg != TRUE)
    {
        for (j = 0; j < I2C_ASSIST_PARA_N_WORDS; j++)
        {
            I2C_uwAssistParaRead[j] =
            		(UWORD)((UWORD)I2C_ubReadBuffer[0][I2C_ASSIST_PARA_ARDDR + 2 * j] << 8) + I2C_ubReadBuffer[0][I2C_ASSIST_PARA_ARDDR + 2 * j + 1];
        }
    }
    else
    {}

    if (out->blGearBoxParaFltFlg != TRUE)
    {
        for (j = 0; j < I2C_GEARBOX_PARA_N_WORDS; j++)
        {
            I2C_uwGearBoxParaRead[j] =
                        (UWORD)((UWORD)I2C_ubReadBuffer[0][I2C_GEARBOX_PARA_ADDR + 2 * j] << 8) + I2C_ubReadBuffer[0][I2C_GEARBOX_PARA_ADDR + 2 * j + 1];
        }
    }
    else
    {}
    
    if (out->blHistoryParaFltFlg != TRUE)
    {
        for (j = 0; j < I2C_HISTORY_PARA_N_WORDS; j++)
        {
            I2C_uwHistoryParaRead[j] =
            		(UWORD)((UWORD)I2C_ubReadBuffer[1][I2C_HISTORY_PARA_ARDDR + 2 * j] << 8) + I2C_ubReadBuffer[1][I2C_HISTORY_PARA_ARDDR + 2 * j + 1];
        }
    }
    else
    {}
    
    if (out->blRideParaFltFlg != TRUE)
    {
        for (j = 0; j < I2C_RIDE_PARA_N_WORDS; j++)
        {
            I2C_uwRideParaRead[j] =
                        (UWORD)((UWORD)I2C_ubReadBuffer[1][I2C_RIDE_PARA_ADDR + 2 * j] << 8) + I2C_ubReadBuffer[1][I2C_RIDE_PARA_ADDR + 2 * j + 1];
        }
    }
    else
    {}
    
    if (out->blBikePara2FltFlg != TRUE)
    {
        for (j = 0; j < I2C_BIKE_PARA2_N_WORDS; j++)
        {
            I2C_uwBikePara2Read[j] =
                        (UWORD)((UWORD)I2C_ubReadBuffer[1][I2C_BIKE_PARA2_ADDR + 2 * j] << 8) + I2C_ubReadBuffer[1][I2C_BIKE_PARA2_ADDR + 2 * j + 1];
        }
    }
    else
    {}

    Syspara2.stMotorPara.uwPolePairs.uwReal = I2C_uwMotorParaRead[0];
    Syspara2.stMotorPara.uwRsmOhm.uwReal = I2C_uwMotorParaRead[1];
    Syspara2.stMotorPara.uwLduH.uwReal = I2C_uwMotorParaRead[2];
    Syspara2.stMotorPara.uwLquH.uwReal = I2C_uwMotorParaRead[3];
    Syspara2.stMotorPara.uwFluxmWb.uwReal = I2C_uwMotorParaRead[4];
    Syspara2.stMotorPara.uwIdMaxA.uwReal = I2C_uwMotorParaRead[5];
    Syspara2.stMotorPara.uwIdMinA.uwReal = I2C_uwMotorParaRead[6];
    Syspara2.stMotorPara.uwRSpdRpm.uwReal = I2C_uwMotorParaRead[7];
    Syspara2.stMotorPara.uwRPwrWt.uwReal = I2C_uwMotorParaRead[8];
    Syspara2.stMotorPara.uwRCurA.uwReal = I2C_uwMotorParaRead[9];
    Syspara2.stMotorPara.uwRVolV.uwReal = I2C_uwMotorParaRead[10];
    Syspara2.stMotorPara.uwJD.uwReal = I2C_uwMotorParaRead[11];
    Syspara2.stMotorPara.uwTorMaxNm.uwReal = I2C_uwMotorParaRead[12];

    Syspara2.stBikePara.uwWheelPerimeter.uwReal = I2C_uwBikeParaRead[0];
    Syspara2.stBikePara.uwMechRationMotor.uwReal = I2C_uwBikeParaRead[1];
    Syspara2.stBikePara.uwThrottleMaxSpdKmH.uwReal = I2C_uwBikeParaRead[2];
    Syspara2.stBikePara.uwCartSpdKmH.uwReal = I2C_uwBikeParaRead[3];
    Syspara2.stBikePara.uwNmFrontChainring.uwReal = I2C_uwBikeParaRead[4];
    Syspara2.stBikePara.uwNmBackChainring.uwReal = I2C_uwBikeParaRead[5];
    Syspara2.stBikePara.uwAssistSelect1.uwReal = I2C_uwBikeParaRead[6];
    Syspara2.stBikePara.uwAssistSelect2.uwReal = I2C_uwBikeParaRead[7];
    Syspara2.stBikePara.uwLightVoltage.uwReal = I2C_uwBikeParaRead[8];
    Syspara2.stBikePara.swDeltPerimeter.swReal = (SWORD)I2C_uwBikeParaRead[9];
    Syspara2.stBikePara.uwStartMode.uwReal = I2C_uwBikeParaRead[10];
    Syspara2.stBikePara.uwAutoPowerOffTime.uwReal = I2C_uwBikeParaRead[11];
    Syspara2.stBikePara.uwThrottleSmooth.uwReal = I2C_uwBikeParaRead[12];

    Syspara2.stMControlPara.ParaFirstSetFlg.uwReal = I2C_uwMControlRead[0];
    Syspara2.stMControlPara.SpiOffsetFirstSetFlg.uwReal = I2C_uwMControlRead[1];
    Syspara2.stMControlPara.uwSPIPosOffsetOrigin.uwReal = I2C_uwMControlRead[2];
    Syspara2.stMControlPara.uwSPIPosOffsetNow.uwReal = I2C_uwMControlRead[3];
    Syspara2.stMControlPara.uwIPeakMaxA.uwReal = I2C_uwMControlRead[4];
    Syspara2.stMControlPara.uwAlamOCurA.uwReal = I2C_uwMControlRead[5];
    Syspara2.stMControlPara.uwAlamOVolV.uwReal = I2C_uwMControlRead[6];
    Syspara2.stMControlPara.uwAlamUVolV.uwReal = I2C_uwMControlRead[7];
    Syspara2.stMControlPara.uwAlamOverSpdRpm.uwReal = I2C_uwMControlRead[8];
    Syspara2.stMControlPara.uwAlamOverHeatCe.uwReal = I2C_uwMControlRead[9];
    Syspara2.stMControlPara.uwAlamRecHeatCe.uwReal = I2C_uwMControlRead[10];
    Syspara2.stMControlPara.uwPwrLimitStartCe.uwReal = I2C_uwMControlRead[11];
    Syspara2.stMControlPara.uwControlFunEN.uwReal = I2C_uwMControlRead[15];
    Syspara2.stMControlPara.uwThrottleGearEN.uwReal = I2C_uwMControlRead[16];

    Syspara2.stSensorPara.uwTorSensorOffsetOrigin.uwReal = I2C_uwSensorRead[0];
    Syspara2.stSensorPara.uwTorSensorOffsetNow1.uwReal = I2C_uwSensorRead[1];
    Syspara2.stSensorPara.uwTorSensorOffsetNow2.uwReal = I2C_uwSensorRead[2];
    Syspara2.stSensorPara.uwTorSensorOffsetNow3.uwReal = I2C_uwSensorRead[3];
    Syspara2.stSensorPara.uwTorSensorOffsetNow4.uwReal = I2C_uwSensorRead[4];
    Syspara2.stSensorPara.uwBikeTorMaxNm.uwReal = I2C_uwSensorRead[5];
    Syspara2.stSensorPara.uwBikeTor1StepRealNm.uwReal = I2C_uwSensorRead[6];
    Syspara2.stSensorPara.uwBikeTor1StepADC.uwReal = I2C_uwSensorRead[7];
    Syspara2.stSensorPara.uwBikeTor2StepRealNm.uwReal = I2C_uwSensorRead[8];
    Syspara2.stSensorPara.uwBikeTor2StepADC.uwReal = I2C_uwSensorRead[9];
    Syspara2.stSensorPara.uwBikeTor3StepRealNm.uwReal = I2C_uwSensorRead[10];
    Syspara2.stSensorPara.uwBikeTor3StepADC.uwReal = I2C_uwSensorRead[11];
    Syspara2.stSensorPara.uwBikeTor4StepRealNm.uwReal = I2C_uwSensorRead[12];
    Syspara2.stSensorPara.uwBikeTor4StepADC.uwReal = I2C_uwSensorRead[13];
    Syspara2.stSensorPara.uwCadSensorPulseNm.uwReal = I2C_uwSensorRead[14];
    Syspara2.stSensorPara.uwBikeSpdSensorPulseNm.uwReal = I2C_uwSensorRead[15];

    Syspara2.stAssistPara.uwStartupGain.uwReal = I2C_uwAssistParaRead[0];
    Syspara2.stAssistPara.uwStartcruiseGain.uwReal = I2C_uwAssistParaRead[1];
    Syspara2.stAssistPara.uwAssistStartNm.uwReal = I2C_uwAssistParaRead[2];
    Syspara2.stAssistPara.uwAssistStopNm.uwReal = I2C_uwAssistParaRead[3];
    Syspara2.stAssistPara.uwStartUpGainStep.uwReal = I2C_uwAssistParaRead[4];
    Syspara2.stAssistPara.uwStartUpCadNm.uwReal = I2C_uwAssistParaRead[5];
    Syspara2.stAssistPara.uwTorLPFCadNm.uwReal = I2C_uwAssistParaRead[6];
    Syspara2.stAssistPara.uwSpeedAssistSpdRpm.uwReal = I2C_uwAssistParaRead[7];
    Syspara2.stAssistPara.uwSpeedAssistIMaxA.uwReal = I2C_uwAssistParaRead[8];
    Syspara2.stAssistPara.uwAssistLimitBikeSpdStart.uwReal = I2C_uwAssistParaRead[9];
    Syspara2.stAssistPara.uwAssistLimitBikeSpdStop.uwReal = I2C_uwAssistParaRead[10];
    Syspara2.stAssistPara.uwCadenceAssistWeight.uwReal = I2C_uwAssistParaRead[11];
    
    Syspara2.stGearBoxPara.uwGearBoxNum.uwReal = I2C_uwGearBoxParaRead[0];
    Syspara2.stGearBoxPara.uwGearBoxCadenceMin.uwReal = I2C_uwGearBoxParaRead[1];
    Syspara2.stGearBoxPara.uwGearBoxCadenceMax.uwReal = I2C_uwGearBoxParaRead[2];
    
    Syspara2.stRidePara.ucAssistRatioGain1.ucReal = (UBYTE)(I2C_uwRideParaRead[0]>>8);
    Syspara2.stRidePara.ucAssistAccelerationGain1.ucReal = (UBYTE)(I2C_uwRideParaRead[0]);
    Syspara2.stRidePara.ucAssistRatioGain2.ucReal = (UBYTE)(I2C_uwRideParaRead[1]>>8);
    Syspara2.stRidePara.ucAssistAccelerationGain2.ucReal = (UBYTE)(I2C_uwRideParaRead[1]);
    Syspara2.stRidePara.ucAssistRatioGain3.ucReal = (UBYTE)(I2C_uwRideParaRead[2]>>8);
    Syspara2.stRidePara.ucAssistAccelerationGain3.ucReal = (UBYTE)(I2C_uwRideParaRead[2]);
    Syspara2.stRidePara.ucAssistRatioGain4.ucReal = (UBYTE)(I2C_uwRideParaRead[3]>>8);
    Syspara2.stRidePara.ucAssistAccelerationGain4.ucReal = (UBYTE)(I2C_uwRideParaRead[3]);
    Syspara2.stRidePara.ucAssistRatioGain5.ucReal = (UBYTE)(I2C_uwRideParaRead[4]>>8);
    Syspara2.stRidePara.ucAssistAccelerationGain5.ucReal = (UBYTE)(I2C_uwRideParaRead[4]);
    Syspara2.stRidePara.ucMaxCurrentGain1.ucReal = (UBYTE)(I2C_uwRideParaRead[5]>>8);
    Syspara2.stRidePara.ucMaxTorqueGain1.ucReal = (UBYTE)(I2C_uwRideParaRead[5]);
    Syspara2.stRidePara.ucMaxCurrentGain2.ucReal = (UBYTE)(I2C_uwRideParaRead[6]>>8);
    Syspara2.stRidePara.ucMaxTorqueGain2.ucReal = (UBYTE)(I2C_uwRideParaRead[6]);
    Syspara2.stRidePara.ucMaxCurrentGain3.ucReal = (UBYTE)(I2C_uwRideParaRead[7]>>8);
    Syspara2.stRidePara.ucMaxTorqueGain3.ucReal = (UBYTE)(I2C_uwRideParaRead[7]);
    Syspara2.stRidePara.ucMaxCurrentGain4.ucReal = (UBYTE)(I2C_uwRideParaRead[8]>>8);
    Syspara2.stRidePara.ucMaxTorqueGain4.ucReal = (UBYTE)(I2C_uwRideParaRead[8]);
    Syspara2.stRidePara.ucMaxCurrentGain5.ucReal = (UBYTE)(I2C_uwRideParaRead[9]>>8);
    Syspara2.stRidePara.ucMaxTorqueGain5.ucReal = (UBYTE)(I2C_uwRideParaRead[9]);
       
    Syspara2.stBikePara2.uwNoneOBCEnable.uwReal = I2C_uwBikePara2Read[0];
    Syspara2.stBikePara2.uwRearLightCycle.uwReal = I2C_uwBikePara2Read[1];
    Syspara2.stBikePara2.uwRearLightDuty.uwReal = I2C_uwBikePara2Read[2];
    Syspara2.stBikePara2.swDeltaBikeSpeedLimit.swReal = I2C_uwBikePara2Read[3];

    Syspara2.stHistoryPara.uwAssModSelect.uwReal = I2C_uwHistoryParaRead[0];
    Syspara2.stHistoryPara.uwOpenTimes.uwReal = I2C_uwHistoryParaRead[1];
    Syspara2.stHistoryPara.uwUsedTimeH.uwReal = I2C_uwHistoryParaRead[2];
    Syspara2.stHistoryPara.uwUsedTimeL.uwReal = I2C_uwHistoryParaRead[3];
    Syspara2.stHistoryPara.uwNTCTempMaxCe.uwReal = I2C_uwHistoryParaRead[4];
    Syspara2.stHistoryPara.uwNTCTempMinCe.uwReal = I2C_uwHistoryParaRead[5];
    Syspara2.stHistoryPara.uwAlamHOcurTimes.uwReal = I2C_uwHistoryParaRead[6];
    Syspara2.stHistoryPara.uwAlamSOcurTimes.uwReal = I2C_uwHistoryParaRead[7];
    Syspara2.stHistoryPara.uwAlamOHeatTimes.uwReal = I2C_uwHistoryParaRead[8];
    Syspara2.stHistoryPara.uwAlamRotorLockTimes.uwReal = I2C_uwHistoryParaRead[9];
    Syspara2.stHistoryPara.uwAlamPhsLossTimes.uwReal = I2C_uwHistoryParaRead[10];
    Syspara2.stHistoryPara.uwAlamOVolTimes.uwReal = I2C_uwHistoryParaRead[11];
    Syspara2.stHistoryPara.uwAlamUVolTimes.uwReal = I2C_uwHistoryParaRead[12];
    Syspara2.stHistoryPara.uwAlamComOTimeTimes.uwReal = I2C_uwHistoryParaRead[13];

    Syspara2.stHistoryPara.uwG1AvgPwrConsumption.uwReal = I2C_uwHistoryParaRead[14];
    Syspara2.stHistoryPara.uwG2AvgPwrConsumption.uwReal = I2C_uwHistoryParaRead[15];
    Syspara2.stHistoryPara.uwG3AvgPwrConsumption.uwReal = I2C_uwHistoryParaRead[16];
    Syspara2.stHistoryPara.uwG4AvgPwrConsumption.uwReal = I2C_uwHistoryParaRead[17];
    Syspara2.stHistoryPara.uwG5AvgPwrConsumption.uwReal = I2C_uwHistoryParaRead[18];

    Syspara2.stHistoryPara.uwODOTripH.uwReal = I2C_uwHistoryParaRead[19];
    Syspara2.stHistoryPara.uwODOTripL.uwReal = I2C_uwHistoryParaRead[20];
    Syspara2.stHistoryPara.uwODOTimeH.uwReal = I2C_uwHistoryParaRead[21];
    Syspara2.stHistoryPara.uwODOTimeL.uwReal = I2C_uwHistoryParaRead[22];

    Syspara2.stHistoryPara.uwTripSumH.uwReal = I2C_uwHistoryParaRead[23];
    Syspara2.stHistoryPara.uwTripSumL.uwReal = I2C_uwHistoryParaRead[24];
    Syspara2.stHistoryPara.uwTripSumTimeH.uwReal = I2C_uwHistoryParaRead[25];
    Syspara2.stHistoryPara.uwTripSumTimeL.uwReal = I2C_uwHistoryParaRead[26];

    Syspara2.stHistoryPara.uwTorSensorAlamTimes.uwReal = I2C_uwHistoryParaRead[27];
    Syspara2.stHistoryPara.uwCadSensorAlamTimes.uwReal = I2C_uwHistoryParaRead[28];
    Syspara2.stHistoryPara.uwBikeSpdSensorAlamTimes.uwReal = I2C_uwHistoryParaRead[29];
    Syspara2.stHistoryPara.uwPosSensorAlamTimes.uwReal = I2C_uwHistoryParaRead[30];
    
    Syspara2.stHistoryPara.uwRealODOTripH.uwReal = I2C_uwHistoryParaRead[31];
    Syspara2.stHistoryPara.uwRealODOTripL.uwReal = I2C_uwHistoryParaRead[32];
    Syspara2.stHistoryPara.uwRealODOTimeH.uwReal = I2C_uwHistoryParaRead[33];
    Syspara2.stHistoryPara.uwRealODOTimeL.uwReal = I2C_uwHistoryParaRead[34];
}


/*************************************************************************
 Copyright (c) 2018 Welling Motor Technology(Shanghai) Co. Ltd.
 All rights reserved.
*************************************************************************/
#ifdef _I2C_MASTER_C_
#undef _I2C_MASTER_C_ /* parasoft-suppress MISRA2004-19_6 "本项目中无法更改，后续避免使用" */
#endif
/*************************************************************************
 End of this File (EOF)!
 Do not put anything after this part!
*************************************************************************/