SPI->CR1 =
            // Mode:                SPI_MODE_MASTER
            SPI_CR1_MSTR | SPI_CR1_SSI |
            // NSS:                 SPI_NSS_SOFT
            SPI_CR1_SSM |
            // BaudRatePrescaler:   SPI_BAUDRATEPRESCALER_8
            SPI_CR1_BR_2 | SPI_CR1_BR_1 | SPI_CR1_BR_0;

        /* Configure : NSS management, TI Mode */
        SPI->CR2 = SPI_CR2_FRXTH;

    void xfer(const uint8_t *dtx, uint8_t *drx, size_t sz) {
        if (sz > 1)
            CLEAR_BIT(SPI->CR2, SPI_CR2_FRXTH);
        while (sz > 0) {
            while (!(SPI->SR & SPI_SR_TXE)) asm("");
            if (sz > 1) {
                SPI->DR = *reinterpret_cast<const uint16_t *>(dtx);
                dtx+=2;
            }
            else {
                *reinterpret_cast<volatile uint8_t *>(&SPI->DR) = *dtx;
                dtx++;
            }

            while (!(SPI->SR & SPI_SR_RXNE)) asm("");
            if (sz > 1) {
                *reinterpret_cast<uint16_t *>(drx) = *reinterpret_cast<volatile uint16_t *>(&SPI->DR);
                drx+=2;
                sz-=2;
                if (sz == 1)
                    SET_BIT(SPI->CR2, SPI_CR2_FRXTH);
            }
            else {
                *drx = *reinterpret_cast<volatile uint8_t *>(&SPI->DR);
                drx++;
                sz--;
            }
        }
    }

    const uint8_t tx[4] = {0x9f};
    uint8_t rx[4];
    spi::xfer(tx, rx, sizeof(rx));
    uint32_t id = (rx[1] << 16) | (rx[2] << 8) | rx[3];

            while (SPI->SR & SPI_SR_FRLVL) {
                volatile auto v = SPI->DR;
                (void)v;
            }

    void send1(const uint8_t *dtx, size_t sz) { // пробовал две разные реализации send()
        while (sz > 0) {
            while (!(SPI->SR & SPI_SR_TXE)) asm("");
            if (sz > 1) {
                SPI->DR = *reinterpret_cast<const uint16_t *>(dtx);
                dtx+=2;
                sz-=2;
            }
            else {
                *reinterpret_cast<volatile uint8_t *>(&SPI->DR) = *dtx;
                dtx++;
                sz--;
            }
            while (SPI->SR & SPI_SR_FRLVL) {
                volatile auto v = SPI->DR;
                (void)v;
            }
        }
    }
    void send(const uint8_t *dtx, size_t sz) {
        uint8_t drx[sz];
        bzero(drx, sz);
        xfer(dtx, drx, sz);
    }


    const uint8_t tx[] = {0x9f};
    spi::send(tx, sizeof(tx));
    uint8_t tx0[3] = {0}, rx[3];
    spi::xfer(tx0, rx, sizeof(rx));

// Direction -> 0 = чтение / 1 = запись
// * Data - указатель на начало буфера
// Length - количество БАЙТ, которые нужно отправить.
void SPI_DMA_Data(uint8_t Direction, uint8_t * Data, uint16_t Length) {
   // Clean up DMA errors and statuses.
   DMA2->LIFCR = 0x0F200000;
   DMA2->HIFCR = 0x0000007D;
   if (Direction) {
      // From chip
      DMA2_Stream4->CR |=  (DMA_SxCR_MINC);
      DMA2_Stream4->M0AR = (uint32_t)Data;
      DMA2_Stream4->NDTR = Length;
      SPI5->CR2 |= SPI_CR2_TXDMAEN;
      DMA2_Stream4->CR |= DMA_SxCR_EN;
      while(DMA2_Stream4->CR & DMA_SxCR_EN) {};
      while (SPI5->SR & SPI_SR_FTLVL) {};
      while (SPI5->SR & SPI_SR_BSY) {};
      // Ignore SPI read
   } else {
      // To chip
      DevNull = 0;
      DMA2_Stream4->CR &= ~(DMA_SxCR_MINC);
      DMA2_Stream4->M0AR = (uint32_t)&(DevNull);
      DMA2_Stream4->NDTR = Length;
      DMA2_Stream3->M0AR = (uint32_t)Data;
      DMA2_Stream3->NDTR = Length;
      SPI5->CR2 |= SPI_CR2_TXDMAEN | SPI_CR2_RXDMAEN;
      DMA2_Stream4->CR |= DMA_SxCR_EN;
      DMA2_Stream3->CR |= DMA_SxCR_EN;
      while(DMA2_Stream3->CR & DMA_SxCR_EN) {};
   }
   SPI5->CR2 &= ~(SPI_CR2_TXDMAEN | SPI_CR2_RXDMAEN);
}

// ВНИМАНИЕ. Пин /CS НЕ МЕНЯЕТ СВОЁ СОСТОЯНИЕ после выхода из функции.