/* SPI2 De Initialization */
SPI_I2S_DeInit(SPI2);

/* SPI2 configuration */
SPI_InitTypeDef SPI2_InitStructure;

SPI2_InitStructure.SPI_Mode = SPI_Mode_Slave;
SPI2_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
SPI2_InitStructure.SPI_DataSize = SPI_DataSize_16b;
SPI2_InitStructure.SPI_CPOL = SPI_CPOL_Low;
SPI2_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
SPI2_InitStructure.SPI_NSS = SPI_NSS_Soft;
SPI2_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI2_InitStructure.SPI_CRCPolynomial = 7;
SPI2_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;

SPI_Init(SPI2, &SPI2_InitStructure);

/* FIFO threshold */
SPI_RxFIFOThresholdConfig(SPI2, SPI_RxFIFOThreshold_HF);

/* Interrupt handler priority */
NVIC_InitTypeDef NVIC_SPI2_InitStructure;

NVIC_SPI2_InitStructure.NVIC_IRQChannel = SPI2_IRQn;
NVIC_SPI2_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_SPI2_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_SPI2_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_SPI2_InitStructure);

/* RXNE interrupt enable */
NVIC_EnableIRQ(SPI2_IRQn);
SPI_I2S_ITConfig(SPI2, SPI_I2S_IT_RXNE, ENABLE);

/* Enable DMA Tx requests */
SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx, ENABLE);

/* Enable SPI2 */
SPI_Cmd(SPI2, ENABLE);

/*SPI3 configuration structure*/
SPI_InitTypeDef SPI3_InitStructure;

/*Default parameters*/
SPI_StructInit(&SPI3_InitStructure);

/*Configure SPI3*/
SPI3_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
SPI3_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI3_InitStructure.SPI_DataSize = SPI_DataSize_16b;
SPI3_InitStructure.SPI_CPOL = SPI_CPOL_Low;
SPI3_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
SPI3_InitStructure.SPI_NSS = SPI_NSS_Soft;
SPI3_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_64;
SPI3_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI3_InitStructure.SPI_CRCPolynomial = 7;

SPI_Init(SPI3, &SPI3_InitStructure);

/*Enable SPI3*/
SPI_Cmd(SPI3, ENABLE);

void SPI2_IRQHandler()
{
    SPI_FLAG = SPI_I2S_ReceiveData16(SPI2);
    
    if(SPI_FLAG == 0x0001)
    {
         DMA_Cmd(DMA1_Channel5, ENABLE);
    }
}

void SPI2_IRQHandler()
{
    SPI_FLAG = SPI_I2S_ReceiveData16(SPI2);

        /* Disable RXNE interrupt*/
    SPI_I2S_ITConfig(SPI2, SPI_I2S_IT_RXNE, DISABLE);

    if(SPI_FLAG == 0x0001)
    {
        DMA_Cmd(DMA1_Channel5, ENABLE);
    }
}

// STM32F040 - Slave
int main(void) {
    RCC->APB2RSTR = 0x00075A40;        // Reset almost all on APB2
    RCC->APB2RSTR = 0;
    RCC->APB1RSTR = 0x10FE4932;        // Reset all on APB1
    RCC->APB1RSTR = 0;
    RCC->AHBENR = 0x00020001;        // GPIOA Enable, DMA Enable
    GPIOA->PUPDR |= 0x00000100;        // GPIOA[4] PullUp.
    RCC->APB2ENR = RCC_APB2ENR_SPI1EN;    // SPI1 Enable
    GPIOA->MODER = 0x6555AA54;        // GPIOA.MODER = [OAOO OOOO AAAA OOOI]
    GPIOA->AFR[0] = 0;            // GPIOA[4-7].Alternate -> SPI1
    SPI1->CR1 = 0;
    SPI1->CR2 = 0742;            // 8 bit, DMA-TX enabled
    SPI1->CR1 = SPI_CR1_SPE;        // Channel enabled, slave.
    SPI1->CR2 = 0742;            // 8 bit, DMA-TX enabled
    DMA1_Channel3->CPAR = (uint32_t)&(SPI1->DR);
    DMA1_Channel3->CMAR = (uint32_t)&(ButtonsPressed[0]);
    DMA1_Channel3->CCR = (DMA_CCR_MINC | DMA_CCR_CIRC | DMA_CCR_DIR | DMA_CCR_TCIE);
    DMA1_Channel3->CNDTR = 8;
    DMA1_Channel3->CCR |= DMA_CCR_EN;
    NVIC_SetPriority(DMA1_Channel2_3_IRQn, 1);
    NVIC_EnableIRQ(DMA1_Channel2_3_IRQn);
    NVIC_SetPriority(SysTick_IRQn, 0x00);    // Настраиваем SYSTick. Наивысший приоритет.
    NVIC_EnableIRQ(SysTick_IRQn);        // Включаем прерывание SYSTick.
    NVIC_SetPriority(SPI1_IRQn, 0x01);    // Приоритет SPI1 ниже чем SysTick
    NVIC_EnableIRQ(SPI1_IRQn);        // Включаем.
    while(1) {
        __WFI();
    };
};

void SPI1_IRQHandler(void) {
    if (SPI1->SR & SPI_SR_MODF) {
        SPI1->CR1 = SPI1->CR1; // Вы таки не поверите, но это очищает некоторые флаги ошибки
    };
    while(SPI1->SR & 0x0600) {
        (void)(SPI1->DR); // Если есть данные - читаем их. Они нам не нужны :(
    };
};
void DMA1_Channel2_3_IRQHandler(void) {
    if (DMA1->ISR & DMA_ISR_TCIF3) {
        DMA1->IFCR = DMA_IFCR_CTEIF3; // Очищаем флаг
        DMA1_Channel3->CCR &= ~DMA_CCR_EN; // Отключаем канал
        DMA1_Channel3->CNDTR = 8;  // Снова вводим 8 байт на отправку
        DMA1_Channel3->CCR |= DMA_CCR_EN; // Переводим канал в состояние готовности
    };
    if (DMA1->ISR & DMA_ISR_GIF3) {
        DMA1->IFCR = DMA_IFCR_CGIF3; // Очищаем флаг
    };
};

        while (hdr < 2) {
            // Ищем заголовок сообщения (если был сбой синхронизации). Теоретически должен сразу ловить заголовок, а сбой может быть только при первой передаче (или неподлюченом ведомом).
            for (i=0;i<16;i++) {
                GPIOE->BSRR = GPIO_BSRR_BS_11;        // Deselect Keyboadr on SPI4
                GPIOE->BSRR = GPIO_BSRR_BR_11;        // Select Keyboadr on SPI4
                SPI4->CR1 &= ~SPI_CR1_SPE;        // Disable SPI4 and deselect slave
                SPI4->CR1 |= SPI_CR1_SPE;        // Enable SPI4 and select slave
                SPI4->DR = 0xFF;            // dummy
                while (!(SPI4->SR & SPI_SR_RXNE));    // Delay until read/write operation
                v = SPI4->DR;
                if (v == 0xAA) {
                    hdr = 1;
                    break;
                };
            };
            SPI4->DR = 0xFF;            // dummy
            while (!(SPI4->SR & SPI_SR_RXNE));    // Delay until read/write operation
            v = SPI4->DR;
            if (v == 0x55) {
                hdr++;
            } else {
                hdr = 0;
            };
        };
        // Считываем текущее состояние
        for (i=0;i<6;i++) {
            SPI4->DR = 0xFF;            // dummy
            while (!(SPI4->SR & SPI_SR_RXNE));    // Delay until read/write operation
            v = SPI4->DR;
            DataBuff[i+2] = v;
        };