void API2C_Init( void ){
I2C_InitTypeDef I2C_InitStructure;

NVIC_InitTypeDef NVIC_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;

RCC_ClocksTypeDef RCC_Clocks;

RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB , ENABLE);
//I2C Peripheral clock enable
RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);

GPIO_PinAFConfig(GPIOB, GPIO_PinSource8, GPIO_AF_I2C1);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource9, GPIO_AF_I2C1);

RCC_APB1PeriphResetCmd(RCC_APB1Periph_I2C1, DISABLE);

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOB, &GPIO_InitStructure);


/* NVIC configuration */
/* Configure the Priority Group to 1 bit */
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);

/* Configure the I2C event priority */
NVIC_InitStructure.NVIC_IRQChannel = I2C1_EV_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);

/* Configure I2C error interrupt to have the higher priority */
NVIC_InitStructure.NVIC_IRQChannel = I2C1_ER_IRQn;
NVIC_Init(&NVIC_InitStructure);


RCC_GetClocksFreq(&RCC_Clocks);
SysTick_Config(RCC_Clocks.HCLK_Frequency / 100);


//#define I2C_SPEED 340000
#define I2C_SPEED 1000
#define I2C_DUTYCYCLE I2C_DutyCycle_16_9

/* I2C De-initialize */
I2C_DeInit(I2C1);

/*!< I2C Struct Initialize */
I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
I2C_InitStructure.I2C_DutyCycle = I2C_DUTYCYCLE;
I2C_InitStructure.I2C_OwnAddress1 = 0xA0;
I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
I2C_InitStructure.I2C_ClockSpeed = I2C_SPEED;

I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;

/*!< I2C Initialize */
I2C_Init(I2C1, &I2C_InitStructure);

/* Enable Error Interrupt */
I2C_ITConfig(I2C1, I2C_IT_ERR , ENABLE);

/* I2C ENABLE */
I2C_Cmd(I2C1, ENABLE);


/* Enable Error and Buffer Interrupts */
I2C_ITConfig(I2C1, (I2C_IT_EVT | I2C_IT_BUF), ENABLE);

API2C_SendCmd( I2CCMD_WRITE, LIS_ADDRESS, LIS_REG_CTRL1, LIS_REG_CTRL1_POWERON );

while( API2C_IsTransferDone() == 0);

}

lastEvent = I2C_Event( isReadSR2 );
#define E_ADDR (2) // SR1_1
#define E_SB (1) // SR1_0
#define E_BTF (4) // SR1_2
#define E_TxE (128) // SR1_2
#define E_RxNE (64) // SR1_2
if( CheckBit( lastEvent, E_SB ) ){
I2C_Send7bitAddress(I2C1, (uint8_t)curCmd.devAddr, I2C_Direction_Transmitter);
i2cstate = STATE_START;
isReadSR2 = 1;
return;
}
// Àäðåñ îòîñëàí è ñëåéâ ïîäòâåðäèë. Ïðîñòî ñáðàñûâàåì, æäåì TxE
if( CheckBit( lastEvent, E_ADDR ) ){
i2cstate = STATE_DATA1;
isReadSR2 = 1;
return;
}
// TxE -- áóôåð íà îòïðàâêó ïóñò, çàïîëíÿåì åãî ïåðâûì èëè âòîðûì áàéòîì.
if( CheckBit( lastEvent, E_TxE ) ){
if( i2cstate == STATE_DATA1 ){
I2C_SendData( I2C1, curCmd.regAddr );
i2cstate = STATE_DATA2;
isReadSR2 = 1;
return;
} else if( i2cstate == STATE_DATA2 ){
I2C_SendData( I2C1, curCmd.regVal );
i2cstate = STATE_NOTBUSY;
isReadSR2 = 1;
return;
}
}
if( CheckBit( lastEvent, E_BTF ) ){
if( i2cstate == STATE_NOTBUSY ){
I2C_GenerateSTOP(I2C1, ENABLE);
for( i = 0; i < 100; i++ );
isTransferDone = 1;
}
isReadSR2 = 1;
return;
}

{
    unsigned char buffer[1+10] = {0x58};
    int result;

    result = ReadW_I2C(1, buffer, 0, 10); // 0 bytes to write to before, 10 bytes to read
    if (result == 10)
    {
        // full success, all bytes read,
        // the received data are in buffer[1] to buffer[10]
        memcpy(myglobalbuffer, &buffer[1], result); // copy the received bytes to some global buffer
    } else {
        // some error occurred: the result contains an error code if < 0 or
        // maybe less than 10 bytes has been read if result >= 0 and < 10.
        // make a decision what to do...
    }
}

{
    unsigned char buffer[1+2+16] = {0xA0}; // one byte for the I2C ID, 2 bytes for memory address, 16 bytes for data.
    int result;

    buffer[1] = 0xAABB / 256; // MSB goes first!
    buffer[2] = 0xAABB % 256; // LSB

    result = ReadW_I2C(0, buffer, 2, 16); // 2 bytes of memory address to write to before, 16 bytes to read afterwards
    if (result == 16)
    {
        // full success, all bytes read,
        // the received data are in buffer[3] to buffer[18]
        memcpy(myglobalbuffer, &buffer[3], result); // copy the received bytes to some global buffer
    } else {
        // some error occurred: the result contains an error code if < 0 or
        // maybe less than 16 bytes has been read if result >= 0 and < 16.
        // make a decision what to do...
    }
}