Подскажите, с чего начать реализовывать идею

void i2c::start(bus_address bus_address, sub_address sub_address, void const * buffer, size_t size, dma & dma)
{
    if((Hw->SR2 & I2C_SR2_BUSY) && !(Hw->CR1 & I2C_CR1_STOP))
    {
        // this function must set I2C_SCL to open drain output mode,
        // generate 9 clock cycles and return I2C_SCL to AF open drain mode
        // to flush possible unread zero-bits (which are pulling SDA low) from slave
        extern void generate_9_i2c_clocks();
 
        Hw->CR1 = 1 * I2C_CR1_SWRST;                // restart to prevent hang-up (sometimes unable to generate START)
        generate_9_i2c_clocks();
    }
    Hw->CR1 = 0;    // remove reset.
 
    Result = true;
    Result.reset();
    Address.Bus = bus_address;
    Address.Register = sub_address;
 
    dma.start(buffer, size);
 
    uint32_t const PCLK_FREQ = APB1CLK;
    uint32_t const SCLK_RISE_FREQ = 1 / 0.000001;
 
    Hw->TRISE = 0
        | (PCLK_FREQ / SCLK_RISE_FREQ + 1) * (I2C_TRISE_TRISE & -I2C_TRISE_TRISE)  // SCL rise timings
        ;
 
 
    uint32_t const SCLK_FREQ = 100000;
    Hw->CCR = 0
        | 0 * I2C_CCR_FS                        // 0 = slow speed (100 kHz), 1 = fast speed (400 kHz)
        | 0 * I2C_CCR_DUTY                      // fast speed duty cycle, Tlow/Thigh, 0 = 2:1, 1 = 16:9
        | PCLK_FREQ / SCLK_FREQ / 2 * (I2C_CCR_CCR & -I2C_CCR_CCR)      // Tlow, Thigh time ticks
        ;
 
    Hw->CR2 = 0
        | PCLK_FREQ / 1000000 * (I2C_CR2_FREQ & -I2C_CR2_FREQ)   // Peripheral Clock Frequency, MHz
        | 1 * I2C_CR2_ITERREN                   // Error Interrupt Enable
        | 1 * I2C_CR2_ITEVTEN                   // Event Interrupt Enable
        | 0 * I2C_CR2_ITBUFEN                   // Buffer Interrupt Enable
        | 1 * I2C_CR2_DMAEN                     // DMA Requests Enable
        | 1 * I2C_CR2_LAST                      // DMA Last Transfer
        ;
 
    Hw->CR1 = 0
        | 1 * I2C_CR1_PE                        // Peripheral enable
        | 0 * I2C_CR1_SMBUS                     // SMBus Mode
        | 0 * I2C_CR1_SMBTYPE                   // SMBus Type
        | 0 * I2C_CR1_ENARP                     // ARP Enable
        | 0 * I2C_CR1_ENPEC                     // PEC Enable
        | 0 * I2C_CR1_ENGC                      // General Call Enable
        | 0 * I2C_CR1_NOSTRETCH                 // Clock Stretching Disable (Slave mode)
        | 1 * I2C_CR1_START                     // Start Generation
        | 0 * I2C_CR1_STOP                      // Stop Generation
        | 0 * I2C_CR1_ACK                       // Acknowledge Enable
        | 0 * I2C_CR1_POS                       // Acknowledge/PEC Position (for data reception)
        | 0 * I2C_CR1_PEC                       // Packet Error Checking
        | 0 * I2C_CR1_ALERT                     // SMBus Alert
        | 0 * I2C_CR1_SWRST                     // Software Reset
        ;
}
 
bool i2c::send(bus_address bus_address, sub_address sub_address, void const * from, size_t size)
{
    Debug_i2c.printf(" tx %02X[%02X]:", bus_address, sub_address);
    // repeat if bus failed.
    for(auto attempts = 0; attempts < 10; ++attempts)
    {
        Mutex.lock();
        start(bus_address, sub_address, from, size, Tx_DMA);
        if(!Result.wait(RTOS_MS((size + 2) * 9 / 100 + 2)) && Result)    // Bus address+W, reg_address, data bytes. 100 bits per mS at 100 kHz bus rate
        {
            Tx_DMA.stop();
            Mutex.unlock();
        }
        else if(Result)
            break;
    }
 
    if(Result)
        Debug_i2c.dump_HEX(from, size);
    else
        Debug_i2c.write("NACK");
 
    return Result;
}
 
bool i2c::receive(bus_address bus_address, sub_address sub_address, void * to, size_t size)
{
    // repeat if bus failed.
    for(auto attempts = 0; attempts < 10; ++attempts)
    {
        Mutex.lock();
        start(bus_address, sub_address, to, size, Rx_DMA);
        if(!Result.wait(RTOS_MS((size + 4) * 9 / 100 + 2)))    // Bus address+W, reg_address, Bus address+R, data bytes. 100 bits per mS at 100 kHz bus rate
        {
            Rx_DMA.stop();
            Mutex.unlock();
        }
        else if(Result)
            break;
    }
 
    Debug_i2c.printf(" rx %02X[%02X]:", bus_address, sub_address);
    if(Result)
        Debug_i2c.dump_HEX(to, size);
    else
        Debug_i2c.write("NACK");
 
    return Result;
}
 
void i2c::rx_dma_handler()
{
    if(Rx_DMA.is_error())
        Result = false;
    Rx_DMA.stop();
    Hw->CR1 |= I2C_CR1_STOP;
    OS::TISRW isr;
    Result.send_isr();
    Mutex.unlock_isr();
    return;
}
 
void i2c::event_handler()
{
    uint32_t Flags = Hw->SR1;
 
    if(Flags & I2C_SR1_SB)
    {
        Hw->DR = Address.Bus;
        Hw->CR2 &= ~I2C_CR2_DMAEN;          // disable bit from prev.transfer to send register address
    }
    else if(Flags & I2C_SR1_ADDR)
    {
        if(!(Address.Bus & (1 << 0)))       // transmit phase
        {
            (void)Hw->SR2;                  // clear ADDR
            Hw->DR = Address.Register;      // start transmission (send register address)
 
            if(Rx_DMA.is_enabled())         // if master receive mode
            {
                Hw->CR1 |= I2C_CR1_START;   // generate Repeated START after address transmission
                Address.Bus |= (1 << 0);
            }
            else                            // master transmit mode
                Hw->CR2 |= I2C_CR2_DMAEN;   // enable DMA for data transfer
 
        }
        else                                // receive phase
        {
            Hw->CR2 |= I2C_CR2_DMAEN;       // enable DMA for data transfer
            if(Rx_DMA.data_size() > 1)
                Hw->CR1 |= I2C_CR1_ACK;
            (void)Hw->SR1;                  // GD32 workaroud to clear ADDR
            (void)Hw->SR2;                  // clear ADDR
        }
 
    }
    else if((Flags & I2C_SR1_BTF) && !Rx_DMA.is_enabled()) // Transmission, Tx done
    {
        Tx_DMA.stop();
        Hw->CR1 |= I2C_CR1_STOP;
        OS::TISRW isr;
        Result.send_isr();
        Mutex.unlock_isr();
        return;
    }
}
 
void i2c::error_handler()
{
    uint32_t Flags = Hw->SR1 & (I2C_SR1_AF | I2C_SR1_BERR | I2C_SR1_ARLO | I2C_SR1_OVR);
    Hw->SR1 = ~Flags;
    if(Flags & I2C_SR1_AF)
    {
        Rx_DMA.stop();
        Tx_DMA.stop();
        Hw->CR1 |= I2C_CR1_STOP;
    }
//    if(Flags == I2C_SR1_BERR)   // Errata 2.4.6
//        return;
    Result = false;
    OS::TISRW isr;
    Result.send_isr();
    Mutex.unlock_isr();
    return;
}