USART1->CR1 =    1<<7 |                        //Bit 7 TXEIE: interrupt enable
                    1<<6 |                        //Bit 6 TCIE: Transmission complete interrupt enable
                    1<<5 |                        //Bit 5 RXNEIE: RXNE interrupt enable
                    1<<3 |                        //Bit 3 TE: Transmitter enable
                    1<<2 |                        //Bit 2 RE: Receiver enable
                    1<<0;                         //Bit 0 UE: USART enable
    USART1->CR2 =    1<<11;                         //Bit 11 CLKEN: Clock enable
    USART1->BRR =     0x271;                        //Tx/Rx baud =     f CK / BRR.  Oversampling by 16

NVIC->ISER[(((uint32_t)(int32_t)37) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)(int32_t)37) & 0x1FUL));

        USART1->TDR = 0x65;
        USART1->TDR = 0x85;

        USART1->TDR = 0x65;
        while((USART1->ISR & (1<<6)) == 0) {};
        USART1->TDR = 0x85;

void USART1_IRQHandler(void)
{

/* USER CODE BEGIN USART1_IRQn 0 */
        if(Led) {Led=0;    GPIOA->BSRR = 32;}
        else {Led=1;    GPIOA->BSRR = (32<<16);}
        if (USART1->ISR & (1<<6)) {USART1->ICR  |=(1<<6);}
        if (USART1->ISR & (1<<5)) {USART1->ICR  |=(1<<5); USART1->TDR = USART1->RDR;}
        //USART1->ICR |= (1<<6);


    /* USER CODE END USART1_IRQn 0 */
  //HAL_UART_IRQHandler(&huart1);
  /* USER CODE BEGIN USART1_IRQn 1 */

  /* USER CODE END USART1_IRQn 1 */
}

      USART1->CR1 |= (1<<6);    //translate
      USART1->CR1 |= (1<<5);    //recieve

HAL_UART_Transmit_IT(&UartHandle, (uint8_t*)aTxBuffer, TXBUFFERSIZE);

  huart1.Instance = USART1;
  huart1.Init.BaudRate = 115200;
  huart1.Init.WordLength = UART_WORDLENGTH_8B;
  huart1.Init.StopBits = UART_STOPBITS_1;
  huart1.Init.Parity = UART_PARITY_NONE;
  huart1.Init.Mode = UART_MODE_TX_RX;
  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  HAL_UART_Init(&huart1);

_ARMABI int printf(const char * __restrict /*format*/, ...) __attribute__((__nonnull__(1)));
struct __FILE { int handle;};
FILE __stdout;
int fputc(int ch, FILE *f)

struct __FILE {int dummy;};
FILE __stdout;
FILE __stdin;
int fputc(int ch, FILE *f)

  hspi2.Instance = SPI2;
  hspi2.Init.Mode = SPI_MODE_MASTER;
  hspi2.Init.Direction = SPI_DIRECTION_2LINES;
  hspi2.Init.DataSize = SPI_DATASIZE_9BIT;
  hspi2.Init.CLKPolarity = SPI_POLARITY_LOW;
  hspi2.Init.CLKPhase = SPI_PHASE_1EDGE;
  hspi2.Init.NSS = SPI_NSS_HARD_OUTPUT;
  hspi2.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;
  hspi2.Init.FirstBit = SPI_FIRSTBIT_MSB;
  hspi2.Init.TIMode = SPI_TIMODE_DISABLE;
  hspi2.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  hspi2.Init.CRCPolynomial = 7;
  hspi2.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;
  hspi2.Init.NSSPMode = SPI_NSS_PULSE_ENABLE;
  HAL_SPI_Init(&hspi2);

   //PB10: SPI2_CLK, PB14: SPI2_MISO, PB15: SPI2_MOSI
  GPIO_InitStructure.Pin = GPIO_PIN_10 | GPIO_PIN_14 | GPIO_PIN_15;
  GPIO_InitStructure.Alternate = GPIO_AF5_SPI2;
  GPIO_InitStructure.Mode  = GPIO_MODE_AF_PP;
  GPIO_InitStructure.Speed = GPIO_SPEED_MEDIUM,
  GPIO_InitStructure.Pull  = GPIO_NOPULL,
  GPIO_Init(GPIOB, &GPIO_InitStructure);

void HAL_SPI_MspInit(SPI_HandleTypeDef* hspi){
  GPIO_InitTypeDef GPIO_InitStruct;
  if(hspi->Instance==SPI1)
  {
    /* Peripheral clock enable */
    __SPI1_CLK_ENABLE();
  
  /**SPI1 GPIO Configuration  
  PA5   ------> SPI1_SCK
  PA6   ------> SPI1_MISO
  PA7   ------> SPI1_MOSI
  */
    GPIO_InitStruct.Pin = GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
    GPIO_InitStruct.Alternate = GPIO_AF5_SPI1;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  }
}

void HAL_SPI_MspDeInit(SPI_HandleTypeDef* hspi){
  if(hspi->Instance==SPI1)
  {
    /* Peripheral clock disable */
    __SPI1_CLK_DISABLE();
  
  /**SPI1 GPIO Configuration  
  PA5   ------> SPI1_SCK
  PA6   ------> SPI1_MISO
  PA7   ------> SPI1_MOSI
  */
    HAL_GPIO_DeInit(GPIOA, GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7);

  }
}

  GPIO_InitStruct.Pin = GPIO_PIN_10|GPIO_PIN_12;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF5_SPI2;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
  

  GPIO_InitStruct.Pin = GPIO_PIN_3;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF5_SPI2;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

    RCC->APB1ENR1 |= 1<<14;                    //Тактирование SPI2 стр. 228
    for (i = 0; i < 30000; i++ ){};
    RCC->AHB2ENR |= RCC_AHB2ENR_GPIOBEN;    //Разрешить тактирование GPIOB
    for (i = 0; i < 30000; i++ ){};
    RCC->AHB2ENR |= RCC_AHB2ENR_GPIOCEN;    //Разрешить тактирование GPIOC
    for (i = 0; i < 30000; i++ ){};
    GPIOB->MODER =     (2<<20)|                //PB10 - альтернативная функция SPI2_SCK
                    (2<<24)|                //PB12 - альтернативная функция SPI2_NSS
                    (1<<26);                 //PB13 - Программный CS push pull режим
    GPIOC->MODER =     (2<<6);                    //PC3 - альтернативная функция SPI2_MOSI
    GPIOB->AFR[1] = 5<<8|                    //Альтернативная функция 5 для PB10 стр. 268
                    5<<16;                    //Альтернативная функция 5 для PB12
    GPIOC->AFR[0] = 5<<12;                    //Альтернативная функция 5 для PC3

//PB10 = SPI2_SCK = AF5
//PB12 = SPI2_NSS = AF5
//PB13 = Soft NSS output push pull.
//PC3 = SPI2_MOSI = AF5

    SPI2->CR1 = 0<<0|    //Bit 0 CPHA: Clock phase
                0<<1|    //Bit1 CPOL: Clock polarity
                1<<2|    //Bit 2 MSTR: Master selection
                7<<3|    //Bits 5:3 BR[2:0]: Baud rate control 000b=2,001b=4,010b=8,011b=16,100b=32,101b=64,110b=128,111b=256
                1<<6|    //Bit 6 SPE: SPI enable
                0<<7|    //Bit 7 LSBFIRST: Frame format 0-MSB First
                0<<8|    //Bit 8 SSI: Internal slave select
                0<<9|    //Bit 9 SSM: Software slave management
                0<<10|    //Bit 10 RXONLY: Receive only mode enabled
                0<<11|    //Bit 11 CRCL: CRC length
                0<<12|    //Bit 12 CRCNEXT: Transmit CRC next
                0<<13|    //Bit 13 CRCEN: Hardware CRC calculation enable
                1<<14|    //Bit 14 BIDIOE: Output enable in bidirectional mode
                0<<15;    //Bit 15 BIDIMODE: Bidirectional data mode enable
    SPI2->CR2 = 0<<0|    //RXDMAEN: Rx buffer DMA enable
                0<<1|    //Bit 1 TXDMAEN: Tx buffer DMA enable
                1<<2|    //Bit 2 SSOE: SS output enable
                1<<3|    //Bit 3 NSSP: NSS pulse management
                0<<4|    //Bit 4 FRF: Frame format 0: SPI Motorola mode, 1 SPI TI mode
                0<<5|    //Bit 5 ERRIE: Error interrupt enable
                0<<6|    //Bit 6 RXNEIE: RX buffer not empty interrupt enable
                0<<7|    //Bit 7 TXEIE: Tx buffer empty interrupt enable
                8<<8|    //Bits 11:8 DS [3:0]: Data size. 8 - 9бит
                0<<12|    //Bit 12 FRXTH: FIFO reception threshold
                0<<13|    //Bit 13 LDMA_RX: Last DMA transfer for reception
                0<<14;    //Bit 14 LDMA_TX: Last DMA transfer for transmission

    SPI2->CR1 = 0<<0|    //Bit 0 CPHA: Clock phase
                0<<1|    //Bit1 CPOL: Clock polarity
                1<<2|    //Bit 2 MSTR: Master selection
                0<<3|    //Bits 5:3 BR[2:0]: Baud rate control 000b=2,001b=4,010b=8,011b=16,100b=32,101b=64,110b=128,111b=256
                1<<6|    //Bit 6 SPE: SPI enable
                0<<7|    //Bit 7 LSBFIRST: Frame format 0-MSB First
                0<<8|    //Bit 8 SSI: Internal slave select
                0<<9|    //Bit 9 SSM: Software slave management
                0<<10|    //Bit 10 RXONLY: Receive only mode enabled
                0<<11|    //Bit 11 CRCL: CRC length
                0<<12|    //Bit 12 CRCNEXT: Transmit CRC next
                0<<13|    //Bit 13 CRCEN: Hardware CRC calculation enable
                0<<14|    //Bit 14 BIDIOE: Output enable in bidirectional mode
                0<<15;    //Bit 15 BIDIMODE: Bidirectional data mode enable

void MX_GPIO_Init(void)
{

  GPIO_InitTypeDef GPIO_InitStruct;

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_SET);

  /*Configure GPIO pin : PA5 */
  GPIO_InitStruct.Pin = GPIO_PIN_5;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

}

  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();
  __HAL_RCC_GPIOD_CLK_ENABLE();

    /* Init the low level hardware : GPIO, CLOCK, NVIC... */
    HAL_SPI_MspInit(hspi);

__weak void HAL_SPI_MspInit(SPI_HandleTypeDef *hspi)
{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(hspi);

  /* NOTE : This function should not be modified, when the callback is needed,
            the HAL_SPI_MspInit should be implemented in the user file
   */
}

void HAL_SPI_MspInit(SPI_HandleTypeDef* hspi)
{

GPIO_InitTypeDef GPIO_InitStruct;
if(hspi->Instance==SPI2)
{
/* USER CODE BEGIN SPI2_MspInit 0 */

/* USER CODE END SPI2_MspInit 0 */
/* Peripheral clock enable */
__HAL_RCC_SPI2_CLK_ENABLE();

/**SPI2 GPIO Configuration
PC3 ------> SPI2_MOSI
PB10 ------> SPI2_SCK
PB12 ------> SPI2_NSS
*/
GPIO_InitStruct.Pin = GPIO_PIN_3;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF5_SPI2;
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

GPIO_InitStruct.Pin = GPIO_PIN_10|GPIO_PIN_12;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF5_SPI2;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

/* USER CODE BEGIN SPI2_MspInit 1 */

/* USER CODE END SPI2_MspInit 1 */
}

}

Куб в 90% генерит не рабочий код. Например для WatchDog куб как бы невзначай забыл про его разрешение: IWDG->KR = 0xCCCC; //Enable the IWDG

Для таймера - пищалки (пользуюсь при отладке) Куб забыл добавить это:
TIM3->CCMR2 = 3<<TIM_CCMR2_OC3FE; //OC3M[2:0] стр 917
TIM3->CCER = TIM_CCER_CC3E; //CC3E - разрешение работы capture/compare
TIM3->ARR = 0x97ff; //16 бит
TIM3->CCR3 = 0x96ff; //ARR > CCR3.

При инициализации SPI - DMA Куб забыл про это:
SPI2->CR1 |= SPI_CR1_SPE; //Bit 6 SPE: SPI enable
SPI2->CR2 |= SPI_CR2_TXDMAEN; //Bit 1 TXDMAEN: Tx buffer DMA enable Для DMA разрешить!!!

ADC: забыто это:
ADC1->CR |= ADC_CR_ADEN;     //Разрешить АЦП ADEN
ADC_CCR_CKMODE_0|    //Bits 17:16 CKMODE[1:0]: ADC clock mode
ADC1->IER |= ADC_IER_EOCIE;     //Разрешить прерывание по окончанию EOCIE(2) стр 505
NVIC->ISER[0] |= 1<<18;         //= 18, ADC12 global  Interrupt      
ADC1->CR |= ADC_CR_ADSTART;        //Начать преобразование ADSTART

#include <stdio.h>
#include <stdarg.h>

void LeF(char* format, ...)
{
  char szBuf[260];
  va_list argptr;
  va_start( argptr, format );
  vsnprintf( szBuf,260, format, argptr );
  va_end( argptr );
  HAL_UART_Transmit(&huart1, (uint8_t*)szBuf, strlen(szBuf), 100);
}