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...
    }
}

...
  Init_I2C(1, 100000);// Реально все инициализируется. Пробовал стандартными функциями отправлять - работает, но при работе                       //с прерываниями все равно виснет
    DWT_Init();// счетчик ядра - крутая вещь!
...

u8_t ReadReg(u8_t deviceAddr, u8_t Reg, u8_t* Data) {
    unsigned char buffer[2+1];
  unsigned int result;
    
    buffer[0] = deviceAddr;
    buffer[1] = Reg;
    buffer[2] = 0;

    result = ReadW_I2C(1, buffer, 1, 1);

  if(result != 1)
        return MEMS_ERROR;
  else  {
        Data = &buffer[2];
        return MEMS_SUCCESS;
    }
}

...

//  ATTENTION! - since 03.11.11. does not work without the simple
//               case I2C_EVENT_MASTER_BYTE_TRANSMITTING below as if
//               I2C_EVENT_MASTER_BYTE_TRANSMITTING occures sometimes
//               before I2C_EVENT_MASTER_BYTE_TRANSMITTED.
//               Possible reasons (due to the following changes):
//               1). Interrupt priority of I2C has been changed to the highest one;
//               2). The I2C speed has been reduced down to 100kHz from 400kHz,
//                   the driver has been tested before.
//                  
        case I2C_EVENT_MASTER_BYTE_TRANSMITTING:    // Data being SENT; TRA, BSY, MSL and
        {                                           // TxE but BTF are set.
            uint8_t ex = 0;
            int32_t tp = I2C_SBTimeoutInit(port, 2*BITS_ONE_BYTE);   // Two I2C bytes to wait
    
            while (!I2C_BTF(i2c) &&
                   !(ex = I2C_SBTimeoutExpired(&tp)));  // Wait for BTF! It MUST arrive else
                                                        // it were a severe hardware error...
            if (ex) // BTF still off: expired!
            {
                I2C_ERROR_HANDLER(port, ctrl->code = ctrl->evnt);
                break;
            }

                // Send I2C ID (slave Address to receive)
                                                // with R/W bit ==1
                I2C_SEND_ADDR(i2c, ctrl->ptr[0] | I2C_Direction_Receiver);

                // Prevent reading of SR2 to avoid resetting of ADDR bit,
                // if two or less bytes to read (cases N == 1 or N == 2).
                // See RM0008.PDF, Doc ID 13902 Rev 12, Page 739.

                if (ctrl->icnt <= 2)
                    ctrl->readsr2 = 0;