void init(void)
{
    i2c.max_rx_count = sizeof(incoming);
    i2c.state = st_idle;
    uint_fast32_t bus_clk;    
    uint_fast32_t scale;
    static const struct gpio_configuration pinconf =
    {
      .open_drain=1,
      .output=0,
      .analog=0,
      .alter=1,
      .speed=0,
      .pullup=0, // было 1
      .pulldn=0,
      .altfunc = 1, // convenient i2c
      .lock=0
    };

    RCC->AHBENR |= RCC_AHBENR_GPIOBEN;
    gpio_pin_conf(GPIOB, 6,1,&pinconf);
    gpio_pin_conf(GPIOB, 7,1,&pinconf);
    RCC->APB1RSTR |= RCC_APB1RSTR_I2C1RST;
    RCC->APB1RSTR ^= RCC_APB1RSTR_I2C1RST;
    RCC->APB1ENR |= RCC_APB1ENR_I2C1EN;
    SystemCoreClockUpdate();
// get sysclk for apb1
    if((RCC->CFGR3 & RCC_CFGR3_I2C1SW) == 0) // RCC_CFGR3_I2C1SW если 1, то от SystemCoreClock
    {
        bus_clk = HSI_VALUE;
    }
    else
    {
        bus_clk = SystemCoreClock;
        if(RCC->CFGR & RCC_CFGR_PPRE_2)
        {
            uint_fast32_t factor = RCC->CFGR & (RCC_CFGR_PPRE_0 | RCC_CFGR_PPRE_1);
            if(factor & RCC_CFGR_PPRE_0) factor |= 1;
            if(factor & RCC_CFGR_PPRE_1) factor |= 2;
            factor &= 3;
            bus_clk >>= factor + 1;
        }
    }
// general scale factor to 8mhz
scale = bus_clk / (HSI_VALUE/2);
scale -= 1;    
scale &= 0x0f;
myI2C->TIMINGR = scale << 28;
// tclk = 250ns refman page 556 - place config from table 100khz
myI2C->TIMINGR |= 0x13 //scll
        |    (0x0f << 8) //sclh
        |    (0x02 << 16) //sdadel
        | (0x04 << 20); //    scldel
//conf i2c
    NVIC_EnableIRQ(I2C1_IRQn);
//set int mask
    myI2C->CR1 = I2C_CR1_ADDRIE
                        | I2C_CR1_RXIE
                          | I2C_CR1_TXIE

                        //|    I2C_CR1_NACKIE
                        |    I2C_CR1_STOPIE
                        |    I2C_CR1_TCIE
                        |    I2C_CR1_ERRIE;
// enable analog noise filtering or digital
//    myI2C->CR1 |= I2C_CR1_ANFOFF;// currently analog
// clock stretch enabled

// set own address
    myI2C->OAR1 = I2C_OAR1_OA1EN | ((get_slave_address() & 0x7F) << 1);
// enable
    myI2C->CR1 |= I2C_CR1_PE;
}

void gpio_pin_conf(
    GPIO_TypeDef *gp,
    uint8_t    num,
    uint8_t    value,
    const struct gpio_configuration *conf)
{
    volatile uint32_t *altreg;
    uint32_t msk2 = 1 << (num*2);
    uint32_t msk4 = 1 << ((num & 0x07)*4);
    num &= 0x0f;
    gp->MODER &= ~(3*msk2);
    if(conf->output) gp->MODER |= msk2;
    if(conf->analog) gp->MODER |= 3*msk2;
    if(conf->alter) gp->MODER |= 2*msk2;

    if(conf->open_drain) gp->OTYPER |= 1 << num;
    else gp->OTYPER &= ~(1 << num);

    gp->OSPEEDR &= ~(3*msk2);
    gp->OSPEEDR |= conf->speed * msk2;

    gp->PUPDR &= ~(3*msk2);
    if(conf->pullup) gp->PUPDR |= msk2;
    if(conf->pulldn) gp->PUPDR |= 2*msk2;

    //set value
    gp->BSRR |= 1 << (num + value?0:16);
    //set af
    altreg = &gp->AFR[(num >= 8)];
    *altreg &= ~(0x0F * msk4);
    *altreg |= conf->altfunc * msk4;
}

RCC->AHBENR |= RCC_AHBENR_GPIOBEN;

RCC->AHBENR |= RCC_AHBENR_GPIOBEN;
RCC->APB1ENR |= RCC_APB1ENR_I2C1EN;
gpio_pin_conf(GPIOB, 6,1,&pinconf);
gpio_pin_conf(GPIOB, 7,1,&pinconf);
RCC->APB1RSTR |= RCC_APB1RSTR_I2C1RST;
RCC->APB1RSTR ^= RCC_APB1RSTR_I2C1RST;

.pullup=0, // было 1

NVIC_SetPriority(I2C1_IRQn, 0); // так не сделано

if(NeedSleep)
{
  Sleep();
  NeedSleep = 0;
}

if(NeedSleep)

__disable_irq();
if(NeedSleep)
{
  Sleep();
  NeedSleep = 0;
}
__enable_irq();

void I2C1_IRQHandler(void){

void handler ( void ) {
    uint8_t  byte;
    
    if (_i2c->ISR & I2C_ISR_ADDR) {  // пришел ADDR
      _i2c->ICR = I2C_ISR_ADDR;                                        
    } else if (_i2c->ISR & I2C_ISR_RXNE) {  // прием байта
      byte = _i2c->RXDR;
      _buf_rx.push(byte);
    } else if (_i2c->ISR & I2C_ISR_TXIS) {  // запрос байта
      _buf_tx.pop(byte);
      _i2c->TXDR = byte;
    } else if (_i2c->ISR & I2C_ISR_NACKF) { // трансфер закончен, пришел NACK
      _i2c->ICR = I2C_ISR_NACKF;
    } else if (_i2c->ISR & I2C_ISR_STOPF) { // пришел STOP
      _i2c->ISR |= I2C_ISR_TXE;
      _i2c->ICR = I2C_ISR_STOPF;
    } else if (_i2c->ISR & I2C_ISR_BERR) {  // I2C Bus Error
      _i2c->ICR = I2C_ISR_BERR;
    } else if (_i2c->ISR & I2C_ISR_OVR) {  // I2C Over-Run/Under-Run
      _i2c->ICR = I2C_ISR_OVR;
    } else if (_i2c->ISR & I2C_ISR_ARLO) {  // I2C Arbitration Loss
      _i2c->ICR = I2C_ISR_ARLO;
    }    
  }

else if (_i2c->ISR & I2C_ISR_RXNE) {  // прием байта
      byte = _i2c->RXDR;
      _buf_rx.push(byte);
    }