IO_CALL_TYPE
DWORD
IO_CALL_OPTION
io_at45_read(void)
{
PSTM_SPI pspi = _AT_SPI_;
//
// В целях сохранения быстродействия не производим проверку
// синхроресурса в функциях самого нижнего уровня
//
// IO_ASSERT( at45_mutex.holder == tn_curr_run_task, "AT45 synch failure");
//
for(;;)
{
DWORD stat;
//
// Значительно более быстрый вариант - ждать TXE и немедленно
// запускать новый цикл на SPI если буфер передатчика готов
// Иначе контроллер делает паузы между символами. Чтобы не
// потерять принимаемый символ при вытеснении потока, запуск
// осуществляем при запрещенных прерываниях
//
stat = pspi->sSPI_SR;
if (stat & bSPI_TXE)
{
DWORD lock, ret;

lock = hal_lock_interrupt();
pspi->sSPI_DR = 0xFF;

for(;;)
{
//
// Ждем завершения предыдущего цикла
// и забираем принятые данные по готовности
//
if (stat & bSPI_RXNE)
{
ret = pspi->sSPI_DR;
break;
}
stat = pspi->sSPI_SR;
}
hal_unlock_interrupt(lock);
return ret & 0xFF;
}
}
}

GPIO_ResetBits( SD_CS_GPIO_PORT, SD_CS_PIN );
        
while( SPI_I2S_GetFlagStatus( SD_SPI, SPI_I2S_FLAG_TXE ) == RESET )            /*!< Wait until the transmit buffer is empty */
;
SPI_I2S_SendData( SD_SPI, 0xAA );            /*!< Send the byte */

GPIO_SetBits( SD_CS_GPIO_PORT, SD_CS_PIN );

GPIO_ResetBits( SD_CS_GPIO_PORT, SD_CS_PIN );
        
while( SPI_I2S_GetFlagStatus( SD_SPI, SPI_I2S_FLAG_TXE ) == RESET )            /*!< Wait until the transmit buffer is empty */
;
SPI_I2S_SendData( SD_SPI, 0xAA );            /*!< Send the byte */

__delay_cycles( 45 );

GPIO_SetBits( SD_CS_GPIO_PORT, SD_CS_PIN );

SPI3->DR=TransmitBuffer[0];
Tx_Data=1;

void SPI3_IRQHandler (void){
  if(Rx_Data>=6) {                     //Если все передали
    CS_SET1;
    return;
  }
  if(SPI3->SR&SPI_SR_RXNE){
    ReceiveBuffer[Rx_Data++]=SPI3->DR;             //Очищаем RXNE чтением DR
    SPI3->DR=TransmitBuffer[Tx_Data++];            //Передаем следующий байт
  }
}

Recycler=SPI3->DR;
SPI3->DR=TransmitBuffer[0];
Tx_Data=1;

void SPI3_IRQHandler (void){
  if(Rx_Data>=6) {                     //Если все передали
    CS_SET1;
    return;
  }
  if(SPI3->SR&SPI_SR_RXNE){
    ReceiveBuffer[Rx_Data++]=SPI3->DR;             //Очищаем RXNE чтением DR
    SPI3->DR=TransmitBuffer[Tx_Data++];            //Передаем следующий байт
  }
}

//********************************************************************************
*********    
//*Конфигурация SPI3
//********************************************************************************
*********
RCC->APB1ENR|=RCC_APB1ENR_SPI3EN;                            //Тактирование SPI3
SPI3->CR1|=SPI_CR1_BR_2
            |SPI_CR1_BR_1
            |SPI_CR1_BR_0                    //Скорость Fpclk/256 84 МГц/256=328,125 кГц
            |SPI_CR1_LSBFIRST                //LSB передается вперед
            |SPI_CR1_SSM                    //NSS управляется програмно
            |SPI_CR1_SSI;                    //NSS=1
SPI3->CR2|=SPI_CR2_SSOE;                    //NSS в качестве выхода                    
/*CPOL=0 (clock polarity) CK to 0 when idle; CPHA=0 (clock phase)
the first clock transition is the first data capture edge
DFF=0 (data frame format) 8-bit data format*/
SPI3->CR2|=SPI_CR2_RXNEIE;                    //Прерывания по окончанию приема и передачи
                        
SPI3->CR1|=SPI_CR1_MSTR;                    //SPI3 режим мастера    
    
NVIC_SetPriority(SPI3_IRQn, 3);                //Прерывание SPI3 третье по приоритету        
NVIC_EnableIRQ(SPI3_IRQn);                    //Разрешаем прерывания SPI3
    
SPI3->CR1|=SPI_CR1_SPE;                    //Разрешаем работу SPI3
CS_SET0;                                    //CS=0
Recycler=SPI3->DR;                            //Прочесть DR
SPI3->DR=MASTER_Buffer_Tx[0];                //Первый байт в буфер передачи
Tx_Data=1;
}

void SPI3_IRQHandler (void){
if(SPI3->SR&SPI_SR_RXNE){
   SLAVE_Buffer_Rx[Rx_Data++]=SPI3->DR;        //Очищаем RXNE чтением DR
   if(Rx_Data==6){
     CS_SET1;
     return;
   }
SPI3->DR=MASTER_Buffer_Tx[Tx_Data++];        //Следующий байт в буфер передачи
}
}

/* SPI1 -- связь с SFM M25PE40
8-bit, MSB first, SPEn, Fpclk2 / 4 (15 MHz), Master, CPOL=0, CPHA=0 */
SPI1->CR1 =
SPI_CR1_CPHA * 0 | // Clock Phase
SPI_CR1_CPOL * 0 | // Clock Polarity
SPI_CR1_MSTR * 1 | // Master Selection
SPI_CR1_BR_0 * 1 | // Baud Rate Control - fpclk2 / 4 = 15 MHz
SPI_CR1_BR_1 * 0 | //
SPI_CR1_BR_2 * 0 | //
SPI_CR1_SPE * 1 | // SPI Enable
SPI_CR1_LSBFIRST * 0 | // Frame Format
SPI_CR1_SSI * 1 | // Internal slave select
SPI_CR1_SSM * 1 | // Software slave management
SPI_CR1_RXONLY * 0 | // Receive only
SPI_CR1_DFF * 0 | // Data Frame Format
SPI_CR1_CRCNEXT * 0 | // Transmit CRC next
SPI_CR1_CRCEN * 0 | // Hardware CRC calculation enable
SPI_CR1_BIDIOE * 0 | // Output enable in bidirectional mode
SPI_CR1_BIDIMODE * 0; // Bidirectional data mode enable
SPI1->CR2 =
SPI_CR2_RXDMAEN * 0 | // Rx Buffer DMA Enable
SPI_CR2_TXDMAEN * 0 | // Tx Buffer DMA Enable
SPI_CR2_SSOE * 0 | // SS Output Enable
SPI_CR2_FRF * 0 | // Protocol format - 0: SPI Motorola mode, 1: SPI TI mode
SPI_CR2_ERRIE * 0 | // Error Interrupt Enable
SPI_CR2_RXNEIE * 0 | // RX buffer Not Empty Interrupt Enable
SPI_CR2_TXEIE * 0; // Tx buffer Empty Interrupt Enable

   do
             { 
// здесь то, что нужно                
             } while (--cnt);

            while(SPI2->SR & SPI_SR_BSY);        // Wait for SPI Rx Buffer Empty 

    RCC->APB1ENR |= RCC_APB1ENR_SPI2EN;
    SPIx->I2SCFGR &= ~SPI_I2SCFGR_I2SMOD;
    SPIx->CR2 = 0;
    SPIx->CR1 = SPI_CR1_MSTR | divisor | SPI_CR1_SSM | SPI_CR1_SSI | SPI_CR1_SPE | phase | cpol;

  SPI1->CR1 = SPI_CR1_SSI | SPI_CR1_BR_0 | SPI_CR1_MSTR;        // Fpclk/4
  SPI1->CR2 = SPI_CR2_SSOE;
...
  SPI_Cmd(SPI1, ENABLE);        // разрешить SPI1

inline uint8_t SFMByte_send(uint8_t data) {
  while (!(SPI1->SR & SPI_SR_TXE));    // ждать освобождения
  SPI1->DR = data;            // послать данные
  while (!(SPI1->SR & SPI_SR_RXNE));    // ждать байта в приемнике (конца передачи)
//  while (SPI1->SR & SPI_SR_BSY);    // другой способ дождаться конца передачи
  return SPI1->DR;