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 "syspar.h"
#include "i2c_master.h"
#include "gd32f30x_dma.h"

/*************************************************************************
 Exported Functions (N/A)
*************************************************************************/

/*************************************************************************
 Function:
 Description:
 Call by:
 Input Variables:
 Output/Return Variables:
 Subroutine Call:
 Reference:
*************************************************************************/
UWORD i2c_pvt_uwWaitCnt = 0, i2c_pvt_uwWaitCnt2 = 0;
void  i2c_voWaitEEReady(UBYTE SlaveAddr)
{
    /* Wait at least 5ms */
    while (i2c_pvt_uwWaitCnt2 < 2)
    {
        i2c_pvt_uwWaitCnt++;
        if (i2c_pvt_uwWaitCnt == 10000)
        {
            i2c_pvt_uwWaitCnt2++;
            i2c_pvt_uwWaitCnt = 0;
        }
    }
    i2c_pvt_uwWaitCnt2 = 0;
  
//    /* GD MCU has ACK detect function */    
//    ULONG ulTimeCnt = 0;
//    UWORD uwTimeoutNum = 0, uwTimeoutNum2;
//    
//    while(!I2C_EE_ComuFltFlg)
//    {
//        /* write to EEPROM enable*/
//        IO_WRITE2EE_ENABLE;
//        /* wait until I2C bus is idle */
//        while(i2c_flag_get(I2C0, I2C_FLAG_I2CBSY) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));
//        if(ulTimeCnt == I2C_SHORT_TIMEOUT)
//        {
//           uwTimeoutNum ++;
//        }
//        ulTimeCnt = 0;
//        /* send a start condition to I2C bus */
//        i2c_start_on_bus(I2C0);
//        /* wait until SBSEND bit is set */
//        while((!i2c_flag_get(I2C0, I2C_FLAG_SBSEND)) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));
//        if(ulTimeCnt == I2C_SHORT_TIMEOUT)
//        {
//           uwTimeoutNum ++;
//        }
//        ulTimeCnt = 0;
//        /* send slave address to I2C bus */
//        i2c_master_addressing(I2C0, SlaveAddr, I2C_TRANSMITTER);
//        /* wait until ADDSEND bit is set */
//        while((!((i2c_flag_get(I2C0, I2C_FLAG_ADDSEND)) || (i2c_flag_get(I2C0, I2C_FLAG_AERR))))&& (++ulTimeCnt < I2C_SHORT_TIMEOUT));
//        if(ulTimeCnt < I2C_SHORT_TIMEOUT)
//        {
//            if(i2c_flag_get(I2C0, I2C_FLAG_ADDSEND)) 
//            {
//                ulTimeCnt = 0;
//              /* clear the bit of I2C_FLAG_ADDSEND */
//                i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
//                /* send a stop condition to I2C bus */
//                i2c_stop_on_bus(I2C0);
//                /* wait until stop condition generate */ 
//                while((I2C_CTL0(I2C0)&I2C_CTL0_STOP) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));
//                if(ulTimeCnt == I2C_SHORT_TIMEOUT)
//                {
//                   uwTimeoutNum ++;
//                }
//                ulTimeCnt = 0;
//                /* exit the function */
//                I2C_EE_ComuFltFlg = FALSE;
//                break;
//            } 
//            else 
//            {
//                /* clear the bit of I2C_FLAG_AERR */
//                i2c_flag_clear(I2C0, I2C_FLAG_AERR);
//                /* send a stop condition to I2C bus */
//                i2c_stop_on_bus(I2C0);    
//                /* wait until stop condition generate */ 
//                while((I2C_CTL0(I2C0)&I2C_CTL0_STOP) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));
//                if(ulTimeCnt == I2C_SHORT_TIMEOUT)
//                {
//                   uwTimeoutNum ++;
//                }
//                ulTimeCnt = 0;
//            }
//        }
//        else
//        {
//             ulTimeCnt = 0;
//             uwTimeoutNum2 ++;
//             if(uwTimeoutNum2 > 4)
//             {
//                I2C_EE_ComuFltFlg = TRUE;
//                break;
//             }
//        }
//        
//        /* I2C communication timeout fault */
//        if(uwTimeoutNum > 3 )
//        {
//           I2C_EE_ComuFltFlg = TRUE;
//        }        
//    }
//    /* write to EEPROM disable */
//    IO_WRITE2EE_DISABLE;
    
}
/*************************************************************************
 Function:
 Description:
 Call by:
 Input Variables:
 Output/Return Variables:
 Subroutine Call:
 Reference:
*************************************************************************/
void i2c_voTXCoef(I2C_TX_COF *out)
{
    out->ubTX1NPages = I2C_TX1_NBYTES / I2C_EE_PAGESIZE_NBYTES;
    out->ubTX1NSingleBytes = I2C_TX1_NBYTES % I2C_EE_PAGESIZE_NBYTES;
    if (out->ubTX1NSingleBytes != 0)
    {
        out->ubTX1NPages += 1;
    }  
}
/*************************************************************************
 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] = *I2C_pBuffer >> 8;
        I2C_ubWriteBuffer[I2C_MOTOR_PARA_ARDDR + 2 * i + 1] = *I2C_pBuffer;
        I2C_pBuffer += I2C_PBUFFER_NWORDS;
    }

    I2C_pBuffer = &Syspara2.stBikePara.uwWheelPerimeter.uwDefault1;
    for (i = 0; i < I2C_BIKE_PARA_N_WORDS; i++)
    {
        I2C_ubWriteBuffer[I2C_BIKE_PARA_ARDDR + 2 * i] = *I2C_pBuffer >> 8;
        I2C_ubWriteBuffer[I2C_BIKE_PARA_ARDDR + 2 * i + 1] = *I2C_pBuffer;
        I2C_pBuffer += I2C_PBUFFER_NWORDS;
    }

    I2C_pBuffer = &Syspara2.stMControlPara.ParaFirstSetFlg.uwDefault1;
    for (i = 0; i < I2C_MCONTROL_PARA_N_WORDS; i++)
    {
        I2C_ubWriteBuffer[I2C_MCONTROL_PARA_ARDDR + 2 * i] = *I2C_pBuffer >> 8;
        I2C_ubWriteBuffer[I2C_MCONTROL_PARA_ARDDR + 2 * i + 1] = *I2C_pBuffer;
        I2C_pBuffer += I2C_PBUFFER_NWORDS;
    }

    I2C_pBuffer = &Syspara2.stSensorPara.uwTorSensorOffsetOrigin.uwDefault1;
    for (i = 0; i < I2C_SENSOR_PARA_N_WORDS; i++)
    {
        I2C_ubWriteBuffer[I2C_SENSOR_PARA_ARDDR + 2 * i] = *I2C_pBuffer >> 8;
        I2C_ubWriteBuffer[I2C_SENSOR_PARA_ARDDR + 2 * i + 1] = *I2C_pBuffer;
        I2C_pBuffer += I2C_PBUFFER_NWORDS;
    }

    I2C_pBuffer = &Syspara2.stAssistPara.uwStartupGain.uwDefault1;
    for (i = 0; i < I2C_ASSIST_PARA_N_WORDS; i++)
    {
        I2C_ubWriteBuffer[I2C_ASSIST_PARA_ARDDR + 2 * i] = *I2C_pBuffer >> 8;
        I2C_ubWriteBuffer[I2C_ASSIST_PARA_ARDDR + 2 * i + 1] = *I2C_pBuffer;
        I2C_pBuffer += I2C_PBUFFER_NWORDS;
    }

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

    I2C_pWriteBuffer = I2C_ubWriteBuffer + I2C_BIKE_PARA_ARDDR;
    I2C_ubWriteBuffer[I2C_BIKE_PARA_CRC_ARDDR] = i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_BIKE_PARA_N_BYTES) >> 8;
    I2C_ubWriteBuffer[I2C_BIKE_PARA_CRC_ARDDR + 1] = i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_BIKE_PARA_N_BYTES);

    I2C_pWriteBuffer = I2C_ubWriteBuffer + I2C_MCONTROL_PARA_ARDDR;
    I2C_ubWriteBuffer[I2C_MCONTROL_PARA_CRC_ARDDR] = i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_MCONTROL_PARA_N_BYTES) >> 8;
    I2C_ubWriteBuffer[I2C_MCONTROL_PARA_CRC_ARDDR + 1] = i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_MCONTROL_PARA_N_BYTES);

    I2C_pWriteBuffer = I2C_ubWriteBuffer + I2C_SENSOR_PARA_ARDDR;
    I2C_ubWriteBuffer[I2C_SENSOR_PARA_CRC_ARDDR] = i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_SENSOR_PARA_N_BYTES) >> 8;
    I2C_ubWriteBuffer[I2C_SENSOR_PARA_CRC_ARDDR + 1] = i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_SENSOR_PARA_N_BYTES);

    I2C_pWriteBuffer = I2C_ubWriteBuffer + I2C_ASSIST_PARA_ARDDR;
    I2C_ubWriteBuffer[I2C_ASSIST_PARA_CRC_ARDDR] = i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_ASSIST_PARA_N_BYTES) >> 8;
    I2C_ubWriteBuffer[I2C_ASSIST_PARA_CRC_ARDDR + 1] = i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_ASSIST_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] = *(I2C_pBuffer + 1) >> 8;
        I2C_ubWriteBuffer[I2C_MOTOR_PARA_ARDDR + 2 * i + 1] = *(I2C_pBuffer + 1);
        I2C_pBuffer += I2C_PBUFFER_NWORDS;
    }

    I2C_pBuffer = &Syspara2.stBikePara.uwWheelPerimeter.uwDefault1;
    for (i = 0; i < I2C_BIKE_PARA_N_WORDS; i++)
    {
        I2C_ubWriteBuffer[I2C_BIKE_PARA_ARDDR + 2 * i] = *(I2C_pBuffer + 1) >> 8;
        I2C_ubWriteBuffer[I2C_BIKE_PARA_ARDDR + 2 * i + 1] = *(I2C_pBuffer + 1);
        I2C_pBuffer += I2C_PBUFFER_NWORDS;
    }

    I2C_pBuffer = &Syspara2.stMControlPara.ParaFirstSetFlg.uwDefault1;
    for (i = 0; i < I2C_MCONTROL_PARA_N_WORDS; i++)
    {
        I2C_ubWriteBuffer[I2C_MCONTROL_PARA_ARDDR + 2 * i] = *(I2C_pBuffer + 1) >> 8;
        I2C_ubWriteBuffer[I2C_MCONTROL_PARA_ARDDR + 2 * i + 1] = *(I2C_pBuffer + 1);
        I2C_pBuffer += I2C_PBUFFER_NWORDS;
    }

    I2C_pBuffer = &Syspara2.stSensorPara.uwTorSensorOffsetOrigin.uwDefault1;
    for (i = 0; i < I2C_SENSOR_PARA_N_WORDS; i++)
    {
        I2C_ubWriteBuffer[I2C_SENSOR_PARA_ARDDR + 2 * i] = *(I2C_pBuffer + 1) >> 8;
        I2C_ubWriteBuffer[I2C_SENSOR_PARA_ARDDR + 2 * i + 1] = *(I2C_pBuffer + 1);
        I2C_pBuffer += I2C_PBUFFER_NWORDS;
    }

    I2C_pBuffer = &Syspara2.stAssistPara.uwStartupGain.uwDefault1;
    for (i = 0; i < I2C_ASSIST_PARA_N_WORDS; i++)
    {
        I2C_ubWriteBuffer[I2C_ASSIST_PARA_ARDDR + 2 * i] = *(I2C_pBuffer + 1) >> 8;
        I2C_ubWriteBuffer[I2C_ASSIST_PARA_ARDDR + 2 * i + 1] = *(I2C_pBuffer + 1);
        I2C_pBuffer += I2C_PBUFFER_NWORDS;
    }

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

    I2C_pWriteBuffer = I2C_ubWriteBuffer + I2C_BIKE_PARA_ARDDR;
    I2C_ubWriteBuffer[I2C_BIKE_PARA_CRC_ARDDR] = i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_BIKE_PARA_N_BYTES) >> 8;
    I2C_ubWriteBuffer[I2C_BIKE_PARA_CRC_ARDDR + 1] = i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_BIKE_PARA_N_BYTES);

    I2C_pWriteBuffer = I2C_ubWriteBuffer + I2C_MCONTROL_PARA_ARDDR;
    I2C_ubWriteBuffer[I2C_MCONTROL_PARA_CRC_ARDDR] = i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_MCONTROL_PARA_N_BYTES) >> 8;
    I2C_ubWriteBuffer[I2C_MCONTROL_PARA_CRC_ARDDR + 1] = i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_MCONTROL_PARA_N_BYTES);

    I2C_pWriteBuffer = I2C_ubWriteBuffer + I2C_SENSOR_PARA_ARDDR;
    I2C_ubWriteBuffer[I2C_SENSOR_PARA_CRC_ARDDR] = i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_SENSOR_PARA_N_BYTES) >> 8;
    I2C_ubWriteBuffer[I2C_SENSOR_PARA_CRC_ARDDR + 1] = i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_SENSOR_PARA_N_BYTES);

    I2C_pWriteBuffer = I2C_ubWriteBuffer + I2C_ASSIST_PARA_ARDDR;
    I2C_ubWriteBuffer[I2C_ASSIST_PARA_CRC_ARDDR] = i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_ASSIST_PARA_N_BYTES) >> 8;
    I2C_ubWriteBuffer[I2C_ASSIST_PARA_CRC_ARDDR + 1] = i2c_uwCRCCcitt(I2C_pWriteBuffer, I2C_ASSIST_PARA_N_BYTES);
}
/*************************************************************************
 Function:
 Description:
 Call by:
 Input Variables:
 Output/Return Variables:
 Subroutine Call:
 Reference:
*************************************************************************/
void i2c_voHistoryWriteBuffer(void)
{
    UWORD *I2C_pBuffer;
    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] = *(I2C_pBuffer + 1) >> 8;
        I2C_ubHistoyWriteBuffer[I2C_HISTORY_PARA_ARDDR + 2 * i + 1] = *(I2C_pBuffer + 1);
        I2C_pBuffer += I2C_PBUFFER_NWORDS;
    }

    I2C_pHistoryWriteBuffer = I2C_ubHistoyWriteBuffer;
    I2C_ubHistoyWriteBuffer[I2C_HISTORY_PARA_CRC_ARDDR] = i2c_uwCRCCcitt(I2C_pHistoryWriteBuffer, I2C_HISTORY_PARA_N_BYTES) >> 8;
    I2C_ubHistoyWriteBuffer[I2C_HISTORY_PARA_CRC_ARDDR + 1] = i2c_uwCRCCcitt(I2C_pHistoryWriteBuffer, I2C_HISTORY_PARA_N_BYTES);
}
/*************************************************************************
 Function:
 Description:
 Call by:
 Input Variables:
 Output/Return Variables:
 Subroutine Call:
 Reference:
*************************************************************************/
void i2c_voByteWrite2EE(UBYTE SlaveAddr, UBYTE WriteAddr, UBYTE Data)
{
    ULONG ulTimeCnt = 0;
    UWORD uwTimeoutNum = 0;
    
    if(!I2C_EE_ComuFltFlg)
    {
        /* write to EEPROM enable*/
        IO_WRITE2EE_ENABLE;
        /* wait until I2C bus is idle */
        while(i2c_flag_get(I2C0, I2C_FLAG_I2CBSY) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));
        if(ulTimeCnt == I2C_SHORT_TIMEOUT)
        {
           uwTimeoutNum ++;
        }
        ulTimeCnt = 0;
        /* send a start condition to I2C bus */
        i2c_start_on_bus(I2C0);
        /* wait until SBSEND bit is set */
        while((!i2c_flag_get(I2C0, I2C_FLAG_SBSEND)) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));
        if(ulTimeCnt == I2C_SHORT_TIMEOUT)
        {
           uwTimeoutNum ++;
        }
        ulTimeCnt = 0;
        /* send slave address to I2C bus */
        i2c_master_addressing(I2C0, SlaveAddr, I2C_TRANSMITTER);
        /* wait until ADDSEND bit is set */
        while((!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND)) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));
        if(ulTimeCnt == I2C_SHORT_TIMEOUT)
        {
           uwTimeoutNum ++;
        }
        ulTimeCnt = 0;
        i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
        /* wait until the transmit data buffer is empty */
        while((!i2c_flag_get(I2C0, I2C_FLAG_TBE)) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));
        if(ulTimeCnt == I2C_SHORT_TIMEOUT)
        {
           uwTimeoutNum ++;
        }
        ulTimeCnt = 0;
        /* writeAddr transmission */
        i2c_data_transmit(I2C0, WriteAddr);
        /* wait until the BTC bit is set */
        while((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));
        if(ulTimeCnt == I2C_SHORT_TIMEOUT)
        {
           uwTimeoutNum ++;
        }
        ulTimeCnt = 0;
        /* data transmission */
        i2c_data_transmit(I2C0, Data);
        /* wait until the BTC bit is set */
        while((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));
        if(ulTimeCnt == I2C_SHORT_TIMEOUT)
        {
           uwTimeoutNum ++;
        }
        ulTimeCnt = 0;
        /* send a stop condition to I2C bus */
        i2c_stop_on_bus(I2C0);    
        /* wait until stop condition generate */ 
        while((I2C_CTL0(I2C0)&I2C_CTL0_STOP) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));
        if(ulTimeCnt == I2C_SHORT_TIMEOUT)
        {
           uwTimeoutNum ++;
        }
        ulTimeCnt = 0;
        /* write to EEPROM disable */
        IO_WRITE2EE_DISABLE;
        
        /* I2C EEPROM communication timeout fault */
        if(uwTimeoutNum > 0)
        {
           I2C_EE_ComuFltFlg = TRUE;
        } 
    }
    else
    {}
}
/*************************************************************************
 Function:
 Description:
 Call by:
 Input Variables:
 Output/Return Variables:
 Subroutine Call:
 Reference:
*************************************************************************/
void i2c_voPageWrite2EE(UBYTE *pBuffer, UBYTE SlaveAddr, UBYTE WriteAddr, UBYTE NBytesToWrite)
{
    ULONG ulTimeCnt = 0;
    UWORD uwTimeoutNum = 0;
    
    if(!I2C_EE_ComuFltFlg)
    {
        /* write to EEPROM enable*/
        IO_WRITE2EE_ENABLE;
        /* wait until I2C bus is idle */
        while(i2c_flag_get(I2C0, I2C_FLAG_I2CBSY) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));
        if(ulTimeCnt == I2C_SHORT_TIMEOUT)
        {
           uwTimeoutNum ++;
        }
        ulTimeCnt = 0;
        /* send a start condition to I2C bus */
        i2c_start_on_bus(I2C0);
        /* wait until SBSEND bit is set */
        while((!i2c_flag_get(I2C0, I2C_FLAG_SBSEND)) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));
        if(ulTimeCnt == I2C_SHORT_TIMEOUT)
        {
           uwTimeoutNum ++;
        }
        ulTimeCnt = 0;
        /* send slave address to I2C bus */
        i2c_master_addressing(I2C0, SlaveAddr, I2C_TRANSMITTER);
        /* wait until ADDSEND bit is set */
        while((!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND)) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));
        if(ulTimeCnt == I2C_SHORT_TIMEOUT)
        {
           uwTimeoutNum ++;
        }
        ulTimeCnt = 0;
        i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
        /* wait until the transmit data buffer is empty */
        while((!i2c_flag_get(I2C0, I2C_FLAG_TBE)) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));
        if(ulTimeCnt == I2C_SHORT_TIMEOUT)
        {
           uwTimeoutNum ++;
        }
        ulTimeCnt = 0;
        /* writeAddr transmission */
        i2c_data_transmit(I2C0, WriteAddr);
        /* wait until the BTC bit is set */
        while((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));
        if(ulTimeCnt == I2C_SHORT_TIMEOUT)
        {
           uwTimeoutNum ++;
        }
        ulTimeCnt = 0;
        /* data transmission */
        while (NBytesToWrite--)
        {
            i2c_data_transmit(I2C0, *pBuffer);
            pBuffer++;
            /* wait until the BTC bit is set */
            while((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));
            if(ulTimeCnt == I2C_SHORT_TIMEOUT)
            {
               uwTimeoutNum ++;
            }
            ulTimeCnt = 0;
            /* I2C communication timeout fault */
            if(uwTimeoutNum > 3 )
            {
               I2C_EE_ComuFltFlg = TRUE;
               break;
            }  
        }
        /* send a stop condition to I2C bus */
        i2c_stop_on_bus(I2C0);    
        /* wait until stop condition generate */ 
        while((I2C_CTL0(I2C0)&I2C_CTL0_STOP) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));
        if(ulTimeCnt == I2C_SHORT_TIMEOUT)
        {
           uwTimeoutNum ++;
        }
        ulTimeCnt = 0;
         /* I2C EEPROM communication timeout fault */
        if(uwTimeoutNum > 0)
        {
           I2C_EE_ComuFltFlg = TRUE;
        }  
        /* write to EEPROM disable */
        IO_WRITE2EE_DISABLE;
    }
    else
    {}
}
/*************************************************************************
 Function:
 Description:
 Call by:
 Input Variables:
 Output/Return Variables:
 Subroutine Call:
 Reference:
*************************************************************************/
void i2c_voBufferWrite2EE(UBYTE *pBuffer, UBYTE SlaveAddr, UBYTE WriteAddr, UBYTE NBytesToWrite)
{
    UBYTE ubNPages = 0, ubNSingleBytes = 0, ubAddr = 0, ubCnt = 0, ubTemp = 0;
    
    ubAddr = WriteAddr % I2C_EE_PAGESIZE_NBYTES;
    ubCnt = I2C_EE_PAGESIZE_NBYTES - ubAddr; // Cnt datas away from page alignment
    ubNPages = NBytesToWrite / I2C_EE_PAGESIZE_NBYTES;
    ubNSingleBytes = NBytesToWrite % I2C_EE_PAGESIZE_NBYTES;    

    if (ubAddr == 0)
    {
        if (ubNPages == 0)
        {
            i2c_voPageWrite2EE(pBuffer, SlaveAddr, WriteAddr, ubNSingleBytes);
            i2c_voWaitEEReady(SlaveAddr);
        }
        else
        {
            while (ubNPages--)
            {
                i2c_voPageWrite2EE(pBuffer, SlaveAddr, WriteAddr, I2C_EE_PAGESIZE_NBYTES);
                i2c_voWaitEEReady(SlaveAddr);
                WriteAddr += I2C_EE_PAGESIZE_NBYTES;
                pBuffer += I2C_EE_PAGESIZE_NBYTES;
            }
            if (ubNSingleBytes != 0)
            {
                i2c_voPageWrite2EE(pBuffer, SlaveAddr, WriteAddr, ubNSingleBytes);
                i2c_voWaitEEReady(SlaveAddr);
            }
        }
    }
    else
    {
        if (ubNPages == 0)
        {
            if (ubNSingleBytes > ubCnt)
            {
                ubTemp = ubNSingleBytes - ubCnt;
                i2c_voPageWrite2EE(pBuffer, SlaveAddr, WriteAddr, ubCnt);
                i2c_voWaitEEReady(SlaveAddr);
                WriteAddr += ubCnt;
                pBuffer += ubCnt;

                i2c_voPageWrite2EE(pBuffer, SlaveAddr, WriteAddr, ubTemp);
                i2c_voWaitEEReady(SlaveAddr);
            }
            else
            {
                i2c_voPageWrite2EE(pBuffer, SlaveAddr, WriteAddr, NBytesToWrite);
                i2c_voWaitEEReady(SlaveAddr);
            }
        }
        else
        {
            NBytesToWrite -= ubCnt;
            ubNPages = NBytesToWrite / I2C_EE_PAGESIZE_NBYTES;
            ubNSingleBytes = NBytesToWrite % I2C_EE_PAGESIZE_NBYTES;
            if (ubCnt != 0)
            {
                /* Write the remaining bytes of the page where WriteAddr is located */
                i2c_voPageWrite2EE(pBuffer, SlaveAddr, WriteAddr, ubCnt);
                i2c_voWaitEEReady(SlaveAddr);
                WriteAddr += ubCnt;
                pBuffer += ubCnt;
            }
            while (ubNPages--)
            {
                i2c_voPageWrite2EE(pBuffer, SlaveAddr, WriteAddr, I2C_EE_PAGESIZE_NBYTES);
                i2c_voWaitEEReady(SlaveAddr);
                WriteAddr += I2C_EE_PAGESIZE_NBYTES;
                pBuffer += I2C_EE_PAGESIZE_NBYTES;
            }
            if (ubNSingleBytes != 0)
            {
                i2c_voPageWrite2EE(pBuffer, SlaveAddr, WriteAddr, I2C_EE_PAGESIZE_NBYTES);
                i2c_voWaitEEReady(SlaveAddr);
            }
        }
    }

}

/*************************************************************************
 Function:
 Description:
 Call by:
 Input Variables:
 Output/Return Variables:
 Subroutine Call:
 Reference:
*************************************************************************/
void i2c_voInfoWrite2EE(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;
    }
    ubWriteAddr = 0x00;

    while (ubReTX1--)
    {
        I2C_pWriteBuffer = I2C_ubWriteBuffer;
        if (ubReTX1 == 1)
        {
            ubSlaveAddr = I2C_SLAVEADDR_BLOCK2;
        }
        if (ubReTX1 == 0)
        {
            ubSlaveAddr = I2C_SLAVEADDR_BLOCK1;
        }
        i2c_voBufferWrite2EE(I2C_pWriteBuffer, ubSlaveAddr, ubWriteAddr, 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(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;
    }
    ubWriteAddr = 0x00;

    while (ubReTX2--)
    {
        I2C_pHistoryWriteBuffer = I2C_ubHistoyWriteBuffer;
        if (ubReTX2 == 1)
        {
            ubSlaveAddr = I2C_SLAVEADDR_BLOCK4;
        }
        if (ubReTX2 == 0)
        {
            ubSlaveAddr = I2C_SLAVEADDR_BLOCK3;
        }
        i2c_voBufferWrite2EE(I2C_pHistoryWriteBuffer, ubSlaveAddr, ubWriteAddr, 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_bus_reset()
{
    i2c_deinit(I2C0);
    /* configure SDA/SCL for GPIO */
    GPIO_BC(GPIOB) |= GPIO_PIN_6;
    GPIO_BC(GPIOB) |= GPIO_PIN_7;
    gpio_init(GPIOB, GPIO_MODE_OUT_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_6);
    gpio_init(GPIOB, GPIO_MODE_OUT_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_7);
    __NOP();
    __NOP();
    __NOP();
    __NOP();
    __NOP();
    GPIO_BOP(GPIOB) |= GPIO_PIN_6;
    __NOP();
    __NOP();
    __NOP();
    __NOP();
    __NOP();
    GPIO_BOP(GPIOB) |= GPIO_PIN_7;
    /* connect I2C_SCL_PIN to I2C_SCL */
    /* connect I2C_SDA_PIN to I2C_SDA */
    gpio_init(GPIOB, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_6);
    gpio_init(GPIOB, GPIO_MODE_AF_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_7);
    /* configure the I2CX interface */
        /* configure I2C0 clock */
    i2c_clock_config(I2C0, 100000, I2C_DTCY_2);
    
    /* configure I2C0 address */
    i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C_SLAVEADDR_BLOCK1);
    
    /* enable acknowledge */
    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
    
//    /* enable I2C0 DMA */
//    i2c_dma_config(I2C0, I2C_DMA_ON); 
       
    /* enable I2C0 */
    i2c_enable(I2C0);
}
/*************************************************************************
 Function:
 Description:
 Call by:
 Input Variables:
 Output/Return Variables:
 Subroutine Call:
 Reference:
*************************************************************************/
void i2c_voSysparaReadFromEE(I2C_RXCRC_OUT *out)
{
  
    UWORD timeout = 0;
    UBYTE ubRdNBytes = 0, ubRdSlaveAddr = 0, ubRdAddr = 0;
    UBYTE state = I2C_START;
    UBYTE read_cycle = 0;
    UBYTE ubRdCnt = 2;
   
    UBYTE i2c_timeout_flag = 0;
    UBYTE *p_buffer;
     while(ubRdCnt--)
     {
        /* enable acknowledge */
        i2c_ack_config(I2C0, I2C_ACK_ENABLE);

        if (ubRdCnt == 1)
        {
            ubRdSlaveAddr = I2C_SLAVEADDR_BLOCK1;
            ubRdAddr = 0x00;
            ubRdNBytes = I2C_RX1_NBYTES;           
            p_buffer = I2C_ubReadBuffer[0];
            i2c_timeout_flag = 0;
        }
        else if (ubRdCnt == 0)
        {
            ubRdSlaveAddr = I2C_SLAVEADDR_BLOCK3;
            ubRdAddr = 0x00;
            ubRdNBytes = I2C_RX2_NBYTES;
            p_buffer = I2C_ubReadBuffer[1];
            i2c_timeout_flag = 0;
        }
        else
        {}
        
        while(!(i2c_timeout_flag))
        {
            switch(state) 
            {
            case I2C_START:
                if(RESET == read_cycle) 
                {
                    /* disable I2C0 */
                    i2c_disable(I2C0);
                    /* enable I2C0 */
                    i2c_enable(I2C0);
                    /* enable acknowledge */
                    i2c_ack_config(I2C0, I2C_ACK_ENABLE);
                    /* i2c master sends start signal only when the bus is idle */
                    while(i2c_flag_get(I2C0, I2C_FLAG_I2CBSY) && (timeout < I2C_SHORT_TIMEOUT)) 
                    {
                        timeout++;
                    }
                    
                    if(timeout < I2C_SHORT_TIMEOUT) 
                    {
                        /* send the start signal */
                        i2c_start_on_bus(I2C0);
                        timeout = 0;
                        state = I2C_SEND_ADDRESS;
                    } 
                    else 
                    {
                        i2c_bus_reset();
                        timeout = 0;
                        state = I2C_START;
                       
                    }
                } 
                else 
                {
                    i2c_start_on_bus(I2C0);
                    timeout = 0;
                    state = I2C_SEND_ADDRESS;
                }
                break;
            case I2C_SEND_ADDRESS:
                /* i2c master sends START signal successfully */
                while((! i2c_flag_get(I2C0, I2C_FLAG_SBSEND)) && (timeout < I2C_SHORT_TIMEOUT)) 
                {
                    timeout++;
                }
                if(timeout < I2C_SHORT_TIMEOUT) 
                {
                    if(RESET == read_cycle) 
                    {
                        i2c_master_addressing(I2C0, ubRdSlaveAddr, I2C_TRANSMITTER);
                        state = I2C_CLEAR_ADDRESS_FLAG;
                    } 
                    else 
                    {
                        i2c_master_addressing(I2C0, ubRdSlaveAddr, I2C_RECEIVER);
                        state = I2C_CLEAR_ADDRESS_FLAG;
                    }
                    timeout = 0;
                } 
                else 
                {
                    timeout = 0;
                    state = I2C_START;
                    read_cycle = 0;
                    
                }
                break;
            case I2C_CLEAR_ADDRESS_FLAG:
                /* address flag set means i2c slave sends ACK */
                while((!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND)) && (timeout < I2C_SHORT_TIMEOUT)) 
                {
                    timeout++;
                }
                if(timeout < I2C_SHORT_TIMEOUT) 
                {
                    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
                    timeout = 0;
                    state = I2C_TRANSMIT_DATA;
                } else 
                {
                    timeout = 0;
                    state = I2C_START;
                    read_cycle = 0;
                    
                }
                break;
            case I2C_TRANSMIT_DATA:
                if(RESET == read_cycle) 
                {
                    /* wait until the transmit data buffer is empty */
                    while((! i2c_flag_get(I2C0, I2C_FLAG_TBE)) && (timeout < I2C_SHORT_TIMEOUT)) 
                    {
                        timeout++;
                    }
                    if(timeout < I2C_SHORT_TIMEOUT) 
                    {
                        /* send the EEPROM's internal address to write to : only one byte address */
                        i2c_data_transmit(I2C0, ubRdAddr);
                        timeout = 0;
                    } 
                    else 
                    {
                        timeout = 0;
                        state = I2C_START;
                        read_cycle = 0;
                        
                    }
                    /* wait until BTC bit is set */
                    while((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (timeout < I2C_SHORT_TIMEOUT)) 
                    {
                        timeout++;
                    }
                    if(timeout < I2C_SHORT_TIMEOUT) 
                    {
                        timeout = 0;
                        state = I2C_START;
                        read_cycle++;
                    } else 
                    {
                        timeout = 0;
                        state = I2C_START;
                        read_cycle = 0;
                        
                    }
                } 
                else 
                {
                    /* one byte master reception procedure (polling) */
                    if(ubRdNBytes < 2) 
                    {
                        /* disable acknowledge */
                        i2c_ack_config(I2C0, I2C_ACK_DISABLE);
                        /* clear ADDSEND register by reading I2C_STAT0 then I2C_STAT1 register (I2C_STAT0 has already been read) */
                        i2c_flag_get(I2C0, I2C_FLAG_ADDSEND);
                        /* send a stop condition to I2C bus*/
                        i2c_stop_on_bus(I2C0);
                        /* wait for the byte to be received */
                        while(!i2c_flag_get(I2C0, I2C_FLAG_RBNE));
                        /* read the byte received from the EEPROM */
                        *p_buffer = i2c_data_receive(I2C0);
                        /* decrement the read bytes counter */
                        ubRdNBytes--;
                        timeout = 0;
                        state = I2C_STOP;
                    } 
                    else 
                    {  /* more than one byte master reception procedure (DMA) */                   
                        dma_transfer_number_config(DMA0, DMA_CH6, ubRdNBytes);
                        
                        DMA_CH6MADDR(DMA0) = (ULONG)p_buffer;
                    
                        i2c_dma_last_transfer_config(I2C0, I2C_DMALST_ON);
                        /* enable I2C0 DMA */
                        i2c_dma_config(I2C0, I2C_DMA_ON);
                        /* enable DMA0 channel5 */
                        dma_channel_enable(DMA0, DMA_CH6);
                        /* wait until BTC bit is set */
                        while(!dma_flag_get(DMA0, DMA_CH6, DMA_FLAG_FTF));

                        state = I2C_STOP; 
                    }
                }
                break;
            case I2C_STOP:
                /* send a stop condition to I2C bus */
                i2c_stop_on_bus(I2C0);
                /* i2c master sends STOP signal successfully */
                while((I2C_CTL0(I2C0) & I2C_CTL0_STOP) && (timeout < I2C_SHORT_TIMEOUT)) 
                {
                    timeout++;
                }
                if(timeout < I2C_SHORT_TIMEOUT)
                {
                    timeout = 0;                 
                    i2c_timeout_flag = 1;
                    state = I2C_START;
                   
                    /* disable DMA0 CH6 */
                    dma_channel_disable(DMA0, DMA_CH6);
                    /* disable I2C0 DMA */
                    i2c_dma_config(I2C0, I2C_DMA_OFF); 
                    i2c_dma_last_transfer_config(I2C0, I2C_DMALST_OFF);
                } 
                else 
                {
                     timeout = 0;
                    //state = I2C_START;
                     state = I2C_STOP;
                     read_cycle = 0;
                }
                                              
                break;
            default:
                state = I2C_START;
                read_cycle = 0;
                i2c_timeout_flag = 1;
                timeout = 0;
                
                break;
            }
        }
        
     }
    
    i2c_voReadBufferCRC(out);

    i2c_voGetValueFrmBuffer(out);

    out->ReadFinishFlg = TRUE;
    
}
/*************************************************************************
 Function:
 Description:
 Call by:
 Input Variables:
 Output/Return Variables:
 Subroutine Call:
 Reference:
*************************************************************************/
UWORD i2c_uwCRCCcitt(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 = ((ptubBuf[i] << j) & 0x80) ^ ((crc & 0x8000) >> 8);
            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, uwHistoryParaCRC;
    UWORD uwMotorParaRdCRC, uwBikeParaRdCRC, uwMControlParaRdCRC;
    UWORD uwSensorParaRdCRC, uwAssistParaRdCRC, uwHistoryParaRdCRC;

    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);
    uwMControlParaCRC = i2c_uwCRCCcitt(I2C_pReadBuffer + I2C_MCONTROL_PARA_ARDDR, I2C_MCONTROL_PARA_N_BYTES);
    uwSensorParaCRC = i2c_uwCRCCcitt(I2C_pReadBuffer + I2C_SENSOR_PARA_ARDDR, I2C_SENSOR_PARA_N_BYTES);
    uwAssistParaCRC = i2c_uwCRCCcitt(I2C_pReadBuffer + I2C_ASSIST_PARA_ARDDR, I2C_ASSIST_PARA_N_BYTES);

    I2C_pReadBuffer = I2C_ubReadBuffer[1];
    uwHistoryParaCRC = i2c_uwCRCCcitt(I2C_pReadBuffer, I2C_HISTORY_PARA_N_BYTES);

    uwMotorParaRdCRC = (I2C_ubReadBuffer[0][I2C_MOTOR_PARA_CRC_ARDDR] << 8) + I2C_ubReadBuffer[0][I2C_MOTOR_PARA_CRC_ARDDR + 1];
    uwBikeParaRdCRC = (I2C_ubReadBuffer[0][I2C_BIKE_PARA_CRC_ARDDR] << 8) + I2C_ubReadBuffer[0][I2C_BIKE_PARA_CRC_ARDDR + 1];
    uwMControlParaRdCRC = (I2C_ubReadBuffer[0][I2C_MCONTROL_PARA_CRC_ARDDR] << 8) + I2C_ubReadBuffer[0][I2C_MCONTROL_PARA_CRC_ARDDR + 1];
    uwSensorParaRdCRC = (I2C_ubReadBuffer[0][I2C_SENSOR_PARA_CRC_ARDDR] << 8) + I2C_ubReadBuffer[0][I2C_SENSOR_PARA_CRC_ARDDR + 1];
    uwAssistParaRdCRC = (I2C_ubReadBuffer[0][I2C_ASSIST_PARA_CRC_ARDDR] << 8) + I2C_ubReadBuffer[0][I2C_ASSIST_PARA_CRC_ARDDR + 1];
    uwHistoryParaRdCRC = (I2C_ubReadBuffer[1][I2C_HISTORY_PARA_CRC_ARDDR] << 8) + I2C_ubReadBuffer[1][I2C_HISTORY_PARA_CRC_ARDDR + 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 (uwHistoryParaCRC != uwHistoryParaRdCRC)
    {
        out->blHistoryParaFltFlg = TRUE;
    }
}
/*************************************************************************
 Function:
 Description:
 Call by:
 Input Variables:
 Output/Return Variables:
 Subroutine Call:
 Reference:
*************************************************************************/
void i2c_voGetValueFrmBuffer(I2C_RXCRC_OUT *out)
{

    UBYTE j = 0;

    if (out->blMotorParaFltFlg != TRUE)
    {
        for (j = 0; j < I2C_MOTOR_PARA_N_WORDS; j++)
        {
            I2C_uwMotorParaRead[j] = (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] = (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] =
                (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] = (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] =
                (I2C_ubReadBuffer[0][I2C_ASSIST_PARA_ARDDR + 2 * j] << 8) + I2C_ubReadBuffer[0][I2C_ASSIST_PARA_ARDDR + 2 * j + 1];
        }
    }
    else
    {}

    if (out->blHistoryParaFltFlg != TRUE)
    {
        for (j = 0; j < I2C_HISTORY_PARA_N_WORDS; j++)
        {
            I2C_uwHistoryParaRead[j] =
                (I2C_ubReadBuffer[1][I2C_HISTORY_PARA_ARDDR + 2 * j] << 8) + I2C_ubReadBuffer[1][I2C_HISTORY_PARA_ARDDR + 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.uwAssistMaxSpdKmH.uwReal = I2C_uwBikeParaRead[2];
    Syspara2.stBikePara.uwThrottleMaxSpdKmH.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 = I2C_uwBikeParaRead[9];
    Syspara2.stBikePara.uwStartMode.uwReal = I2C_uwBikeParaRead[10];
    Syspara2.stBikePara.uwAutoPowerOffTime.uwReal = I2C_uwBikeParaRead[11];

    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.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.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];

}
/*************************************************************************
 Function:
 Description:
 Call by:
 Input Variables:
 Output/Return Variables:
 Subroutine Call:
 Reference:
*************************************************************************/
void  i2c_voWriteTest(void)
{
    UBYTE WriteBuffer[4];
    UBYTE  *pBuffer;
    
    WriteBuffer[0] = 0x06;
    WriteBuffer[1] = 0x08;  
    WriteBuffer[2] = 0x0A;
    WriteBuffer[3] = 0x01;
    pBuffer = WriteBuffer;
    i2c_voPageWrite2EE(pBuffer, I2C_SLAVEADDR_BLOCK1, 0x00, 4);
}

/*************************************************************************
 Function:
 Description:
 Call by:
 Input Variables:
 Output/Return Variables:
 Subroutine Call:
 Reference:
*************************************************************************/
void  i2c_voReadTest(void)
{
    UBYTE  ReadBuffer[6];
    
    ULONG ulTimeCnt = 0;
    UWORD uwTimeoutNum = 0;
    UWORD uwReadNBytes = 6;
    
    /* wait until I2C bus is idle */
    while(i2c_flag_get(I2C0, I2C_FLAG_I2CBSY) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));
    if(ulTimeCnt == I2C_SHORT_TIMEOUT)
    {
       uwTimeoutNum ++;
    }
    ulTimeCnt = 0;
    /* send a start condition to I2C bus */
    i2c_start_on_bus(I2C0);
    /* wait until SBSEND bit is set */
    while((!i2c_flag_get(I2C0, I2C_FLAG_SBSEND)) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));
    if(ulTimeCnt == I2C_SHORT_TIMEOUT)
    {
       uwTimeoutNum ++;
    }
    ulTimeCnt = 0;
    /* send slave address to I2C bus */
    i2c_master_addressing(I2C0, I2C_SLAVEADDR_BLOCK1, I2C_TRANSMITTER);
    /* wait until ADDSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));
    if(ulTimeCnt == I2C_SHORT_TIMEOUT)
    {
       uwTimeoutNum ++;
    }
    ulTimeCnt = 0;
    /* clear ADDSEND bit */
    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
    /* wait until the TBE bit is set */
    while((!i2c_flag_get(I2C0, I2C_FLAG_TBE)) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));       
    if(ulTimeCnt == I2C_SHORT_TIMEOUT)
    {
       uwTimeoutNum ++;
    }
    ulTimeCnt = 0;
    /* readAddr transmission */
    i2c_data_transmit(I2C0, 0x00);
    /* wait until the BTC bit is set */
    while((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));
    if(ulTimeCnt == I2C_SHORT_TIMEOUT)
    {
       uwTimeoutNum ++;
    }
    ulTimeCnt = 0;
    
    /* send a start condition to I2C bus */
    i2c_start_on_bus(I2C0);
    /* wait until SBSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_SBSEND) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));
    if(ulTimeCnt == I2C_SHORT_TIMEOUT)
    {
       uwTimeoutNum ++;
    }
    ulTimeCnt = 0;
    /* send slave address to I2C bus */
    i2c_master_addressing(I2C0, I2C_SLAVEADDR_BLOCK1, I2C_RECEIVER);
    /* wait until ADDSEND bit is set */
    while(!i2c_flag_get(I2C0, I2C_FLAG_ADDSEND) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));
    if(ulTimeCnt == I2C_SHORT_TIMEOUT)
    {
       uwTimeoutNum ++;
    }
    ulTimeCnt = 0;
    /* clear ADDSEND bit */
    i2c_flag_clear(I2C0, I2C_FLAG_ADDSEND);
    
    while(uwReadNBytes--)
    {
        if(2 == uwReadNBytes) 
        {
            /* wait until BTC bit is set */
            while((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));
            if(ulTimeCnt == I2C_SHORT_TIMEOUT)
            {
               uwTimeoutNum ++;
            }
            ulTimeCnt = 0;
            /* disable acknowledge */
            i2c_ack_config(I2C0, I2C_ACK_DISABLE);
        }
        if(1 == uwReadNBytes) 
        {
            /* wait until BTC bit is set */
            while((!i2c_flag_get(I2C0, I2C_FLAG_BTC)) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));
            if(ulTimeCnt == I2C_SHORT_TIMEOUT)
            {
               uwTimeoutNum ++;
            }
            ulTimeCnt = 0;
            /* send a stop condition to I2C bus */
            i2c_stop_on_bus(I2C0);
         }
        
        while((!i2c_flag_get(I2C0, I2C_FLAG_RBNE)) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));
        if(ulTimeCnt == I2C_SHORT_TIMEOUT)
        {
           uwTimeoutNum ++;
        }
        ulTimeCnt = 0;
        ReadBuffer[5 - uwReadNBytes] = i2c_data_receive(I2C0);
    }
       
    
    /* wait until stop condition generate */ 
    while((I2C_CTL0(I2C0)&I2C_CTL0_STOP) && (++ulTimeCnt < I2C_SHORT_TIMEOUT));
    if(ulTimeCnt == I2C_SHORT_TIMEOUT)
    {
       uwTimeoutNum ++;
    }
    ulTimeCnt = 0;
    
    if(uwTimeoutNum > 3)
    {
        I2C_EE_ComuFltFlg = TRUE;
    }
}
/*************************************************************************
 Copyright (c) 2018 Welling Motor Technology(Shanghai) Co. Ltd.
 All rights reserved.
*************************************************************************/
#ifdef _I2C_MASTER_C_
#undef _I2C_MASTER_C_
#endif
/*************************************************************************
 End of this File (EOF)!
 Do not put anything after this part!
*************************************************************************/