Настройка SPI на STM32: полное руководство для разработчиков

// Определение структуры для настройки SPI
SPI_HandleTypeDef hspi1;

void SPI1_Init(void)
{
// 1. Включаем тактирование портов и SPI
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_SPI1_CLK_ENABLE();

// 2. Настраиваем пины GPIO
GPIO_InitTypeDef GPIO_InitStruct = {0};

// Настройка SCK, MISO, MOSI
GPIO_InitStruct.Pin = GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; // Альтернативная функция, push-pull
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF5_SPI1; // Альтернативная функция для SPI1
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

// Настройка пина NSS (если управляем программно)
GPIO_InitStruct.Pin = GPIO_PIN_4;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; // Обычный выход push-pull
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET); // Деактивируем SS (высокий уровень)

// 3. Конфигурация SPI
hspi1.Instance = SPI1;
hspi1.Init.Mode = SPI_MODE_MASTER; // Режим мастера
hspi1.Init.Direction = SPI_DIRECTION_2LINES; // Двунаправленная передача
hspi1.Init.DataSize = SPI_DATASIZE_8BIT; // 8-битные данные
hspi1.Init.CLKPolarity = SPI_POLARITY_LOW; // CPOL = 0
hspi1.Init.CLKPhase = SPI_PHASE_1EDGE; // CPHA = 0 (режим 0)
hspi1.Init.NSS = SPI_NSS_SOFT; // Программное управление NSS
hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16; // Предделитель частоты
hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB; // Старший бит первым
hspi1.Init.TIMode = SPI_TIMODE_DISABLE; // Режим TI выключен
hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE; // CRC выключен

// 4. Инициализация SPI
if (HAL_SPI_Init(&hspi1) != HAL_OK)
{
Error_Handler();
}
}

void SPI_Example(void)
{
uint8_t txData[2] = {0xAA, 0x55}; // Данные для отправки
uint8_t rxData[2] = {0}; // Буфер для приема данных

// Активируем ведомое устройство (низкий уровень на NSS)
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_RESET);

// Отправка и прием данных
HAL_StatusTypeDef status = HAL_SPI_TransmitReceive(&hspi1, txData, rxData, 2, 100);

// Деактивируем ведомое устройство (высокий уровень на NSS)
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET);

if (status != HAL_OK)
{
// Обработка ошибки
Error_Handler();
}
}

// Определение структур для DMA
DMA_HandleTypeDef hdma_spi1_tx;
DMA_HandleTypeDef hdma_spi1_rx;

void SPI1_DMA_Init(void)
{
// Включаем тактирование DMA
__HAL_RCC_DMA2_CLK_ENABLE();

// Настройка DMA для передачи
hdma_spi1_tx.Instance = DMA2_Stream3;
hdma_spi1_tx.Init.Channel = DMA_CHANNEL_3;
hdma_spi1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
hdma_spi1_tx.Init.PeriphInc = DMA_PERIPH_INC_DISABLE;
hdma_spi1_tx.Init.MemInc = DMA_MEMORY_INC_ENABLE;
hdma_spi1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
hdma_spi1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
hdma_spi1_tx.Init.Mode = DMA_NORMAL;
hdma_spi1_tx.Init.Priority = DMA_PRIORITY_LOW;
hdma_spi1_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
HAL_DMA_Init(&hdma_spi1_tx);

// Связывание DMA с SPI для передачи
__HAL_LINKDMA(&hspi1, hdmatx, hdma_spi1_tx);

// Настройка DMA для приема (аналогично)
hdma_spi1_rx.Instance = DMA2_Stream2;
// ... настройка параметров аналогично TX
HAL_DMA_Init(&hdma_spi1_rx);

// Связывание DMA с SPI для приема
__HAL_LINKDMA(&hspi1, hdmarx, hdma_spi1_rx);

// Настройка прерываний DMA
HAL_NVIC_SetPriority(DMA2_Stream3_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(DMA2_Stream3_IRQn);
HAL_NVIC_SetPriority(DMA2_Stream2_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(DMA2_Stream2_IRQn);
}

// Пример использования DMA для передачи/приема данных
void SPI_DMA_Example(uint8_t* txBuffer, uint8_t* rxBuffer, uint16_t size)
{
// Активируем ведомое устройство
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_RESET);

// Запускаем передачу/прием через DMA
HAL_SPI_TransmitReceive_DMA(&hspi1, txBuffer, rxBuffer, size);

// Обработчики прерываний будут вызваны автоматически по завершении
}

// Обработчик прерывания по завершении передачи/приема
void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *hspi)
{
if (hspi->Instance == SPI1)
{
// Деактивируем ведомое устройство
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET);

// Дополнительная обработка завершения передачи
}
}

// Активация ведомого устройства
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_RESET); // Низкий уровень

// Выполнение обмена данными...

// Деактивация ведомого устройства
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET); // Высокий уровень

// Выбор первого устройства
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_RESET); // CS1 активен
HAL_SPI_Transmit(&hspi1, data1, size1, timeout);
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET); // CS1 неактивен

// Выбор второго устройства
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_RESET); // CS2 активен
HAL_SPI_Transmit(&hspi1, data2, size2, timeout);
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_SET); // CS2 неактивен

// Массив конфигураций для тестирования всех режимов SPI
const uint8_t spiModes[4][2] = {
{SPI_POLARITY_LOW, SPI_PHASE_1EDGE}, // Режим 0
{SPI_POLARITY_LOW, SPI_PHASE_2EDGE}, // Режим 1
{SPI_POLARITY_HIGH, SPI_PHASE_1EDGE}, // Режим 2
{SPI_POLARITY_HIGH, SPI_PHASE_2EDGE} // Режим 3
};

void TestAllSPIModes(void)
{
uint8_t testData = 0xA5;
uint8_t receivedData = 0;

for (int i = 0; i < 4; i++)
{
// Реконфигурация SPI для текущего режима
HAL_SPI_DeInit(&hspi1);

hspi1.Init.CLKPolarity = spiModes[i][0];
hspi1.Init.CLKPhase = spiModes[i][1];

HAL_SPI_Init(&hspi1);

// Тестовая передача данных
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_RESET); // CS активен
HAL_SPI_TransmitReceive(&hspi1, &testData, &receivedData, 1, 100);
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET); // CS неактивен

// Анализ полученных данных
printf("Mode %d: Sent 0xA5, Received 0x%02X\n", i, receivedData);

HAL_Delay(100); // Пауза между тестами
}
}

uint32_t startTime, endTime, elapsedTime;

startTime = HAL_GetTick();
// Выполнение операции SPI
endTime = HAL_GetTick();
elapsedTime = endTime – startTime;

printf("SPI transfer time: %lu ms\n", elapsedTime);

// Инициализация SD-карты через SPI
FATFS SDFatFs;
char SDPath[4];

void SD_Card_Init(void)
{
// Низкоуровневая инициализация SPI
SPI1_Init();

// Монтирование файловой системы
if(f_mount(&SDFatFs, (TCHAR const*)SDPath, 0) != FR_OK)
{
Error_Handler();
}

// Теперь можно использовать функции FatFS для работы с файлами
}

// Пример записи данных на SD-карту
void WriteDataToSD(void)
{
FIL file;
uint32_t bytesWritten;
char data[] = "SPI Test Data";

// Открытие/создание файла
if(f_open(&file, "test.txt", FA_CREATE_ALWAYS | FA_WRITE) != FR_OK)
{
Error_Handler();
}

// Запись данных
if(f_write(&file, data, strlen(data), (void *)&bytesWritten) != FR_OK)
{
Error_Handler();
}

// Закрытие файла
f_close(&file);
}

// Инициализация OLED-дисплея SSD1306 через SPI
void SSD1306_Init(void)
{
// Инициализация SPI
SPI1_Init();

// Инициализация дополнительных пинов для управления дисплеем
GPIO_InitTypeDef GPIO_InitStruct = {0};

// Пин DC (Data/Command)
GPIO_InitStruct.Pin = OLED_DC_PIN;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(OLED_DC_PORT, &GPIO_InitStruct);

// Пин RES (Reset)
GPIO_InitStruct.Pin = OLED_RES_PIN;
HAL_GPIO_Init(OLED_RES_PORT, &GPIO_InitStruct);

// Сброс дисплея
HAL_GPIO_WritePin(OLED_RES_PORT, OLED_RES_PIN, GPIO_PIN_RESET);
HAL_Delay(10);
HAL_GPIO_WritePin(OLED_RES_PORT, OLED_RES_PIN, GPIO_PIN_SET);
HAL_Delay(10);

// Отправка команд инициализации
SSD1306_SendCommand(0xAE); // Выключение дисплея
SSD1306_SendCommand(0xD5); // Установка частоты обновления
SSD1306_SendCommand(0x80);
// ...другие команды инициализации...
SSD1306_SendCommand(0xAF); // Включение дисплея

// Очистка дисплея
SSD1306_Clear();
}

// Функция отправки команды
void SSD1306_SendCommand(uint8_t command)
{
HAL_GPIO_WritePin(OLED_DC_PORT, OLED_DC_PIN, GPIO_PIN_RESET); // Режим команд
HAL_GPIO_WritePin(OLED_CS_PORT, OLED_CS_PIN, GPIO_PIN_RESET); // Выбор устройства

HAL_SPI_Transmit(&hspi1, &command, 1, 100);

HAL_GPIO_WritePin(OLED_CS_PORT, OLED_CS_PIN, GPIO_PIN_SET); // Деактивация
}

// Функция отправки данных
void SSD1306_SendData(uint8_t* data, uint16_t size)
{
HAL_GPIO_WritePin(OLED_DC_PORT, OLED_DC_PIN, GPIO_PIN_SET); // Режим данных
HAL_GPIO_WritePin(OLED_CS_PORT, OLED_CS_PIN, GPIO_PIN_RESET); // Выбор устройства

HAL_SPI_Transmit(&hspi1, data, size, 1000);

HAL_GPIO_WritePin(OLED_CS_PORT, OLED_CS_PIN, GPIO_PIN_SET); // Деактивация
}

// Отрисовка пикселя
void SSD1306_DrawPixel(uint8_t x, uint8_t y, uint8_t color)
{
if(x >= SSD1306_WIDTH || y >= SSD1306_HEIGHT) return;

if(color)
SSD1306_Buffer[x + (y/8)*SSD1306_WIDTH] |= 1 << (y%8);
else
SSD1306_Buffer[x + (y/8)*SSD1306_WIDTH] &= ~(1 << (y%8));
}

// Обновление содержимого дисплея
void SSD1306_UpdateScreen(void)
{
for(uint8_t i = 0; i < 8; i++)
{
SSD1306_SendCommand(0xB0 + i); // Установка страницы
SSD1306_SendCommand(0x00); // Установка нижних 4 бит адреса
SSD1306_SendCommand(0x10); // Установка верхних 4 бит адреса

SSD1306_SendData(&SSD1306_Buffer[SSD1306_WIDTH * i], SSD1306_WIDTH);
}
}

// Инициализация датчика MAX31865
void MAX31865_Init(void)
{
// Инициализация SPI
SPI2_Init();

// Настройка пина CS для датчика
GPIO_InitTypeDef GPIO_InitStruct = {0};
GPIO_InitStruct.Pin = MAX_CS_PIN;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(MAX_CS_PORT, &GPIO_InitStruct);
HAL_GPIO_WritePin(MAX_CS_PORT, MAX_CS_PIN, GPIO_PIN_SET); // Деактивация

// Запись в конфигурационный регистр
uint8_t config = 0;
config |= MAX31865_CONFIG_BIAS; // Включение смещения
config |= MAX31865_CONFIG_MODEAUTO; // Автоматический режим
config |= MAX31865_CONFIG_3WIRE; // 3-проводной режим для PT100

MAX31865_WriteRegister(MAX31865_REG_CONFIG, config);
}

// Запись в регистр MAX31865
void MAX31865_WriteRegister(uint8_t reg, uint8_t value)
{
uint8_t tx[2];
tx[0] = reg | 0x80; // Установка бита записи
tx[1] = value;

HAL_GPIO_WritePin(MAX_CS_PORT, MAX_CS_PIN, GPIO_PIN_RESET); // Активация
HAL_SPI_Transmit(&hspi2, tx, 2, 100);
HAL_GPIO_WritePin(MAX_CS_PORT, MAX_CS_PIN, GPIO_PIN_SET); // Деактивация
}

// Чтение из регистра MAX31865
uint8_t MAX31865_ReadRegister(uint8_t reg)
{
uint8_t tx = reg & 0x7F; // Сброс бита записи
uint8_t rx;

HAL_GPIO_WritePin(MAX_CS_PORT, MAX_CS_PIN, GPIO_PIN_RESET); // Активация
HAL_SPI_Transmit(&hspi2, &tx, 1, 100);
HAL_SPI_Receive(&hspi2, &rx, 1, 100);
HAL_GPIO_WritePin(MAX_CS_PORT, MAX_CS_PIN, GPIO_PIN_SET); // Деактивация

return rx;
}

// Чтение температуры с MAX31865
float MAX31865_ReadTemperature(void)
{
// Чтение регистров RTD
uint8_t rtdRegAddrMSB = MAX31865_REG_RTD_MSB;
uint16_t rtd;
uint8_t rtdData[2];

HAL_GPIO_WritePin(MAX_CS_PORT, MAX_CS_PIN, GPIO_PIN_RESET); // Активация
HAL_SPI_Transmit(&hspi2, &rtdRegAddrMSB, 1, 100);
HAL_SPI_Receive(&hspi2, rtdData, 2, 100);
HAL_GPIO_WritePin(MAX_CS_PORT, MAX_CS_PIN, GPIO_PIN_SET); // Деактивация

rtd = (rtdData[0] << 8) | rtdData[1];
rtd >>= 1; // Удаление флага ошибки

// Расчет температуры для PT100
float temp = rtd;
temp /= 32.0;
temp -= 256.0; // Для PT100

return temp;
}

// Инициализация W25Q128
void W25Q128_Init(void)
{
// Инициализация SPI
SPI3_Init();

// Настройка пина CS
GPIO_InitTypeDef GPIO_InitStruct = {0};
GPIO_InitStruct.Pin = FLASH_CS_PIN;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(FLASH_CS_PORT, &GPIO_InitStruct);
HAL_GPIO_WritePin(FLASH_CS_PORT, FLASH_CS_PIN, GPIO_PIN_SET); // Деактивация

// Проверка ID устройства
uint32_t flashID = W25Q128_ReadID();
if((flashID & 0xFFFF0000) != 0xEF170000)
{
Error_Handler(); // Неправильный ID
}
}

// Чтение ID устройства
uint32_t W25Q128_ReadID(void)
{
uint8_t cmd[4] = {0x9F, 0, 0, 0}; // Команда JEDEC ID
uint8_t id[3];

HAL_GPIO_WritePin(FLASH_CS_PORT, FLASH_CS_PIN, GPIO_PIN_RESET); // Активация
HAL_SPI_Transmit(&hspi3, cmd, 1, 100);
HAL_SPI_Receive(&hspi3, id, 3, 100);
HAL_GPIO_WritePin(FLASH_CS_PORT, FLASH_CS_PIN, GPIO_PIN_SET); // Деактивация

return ((uint32_t)id[0] << 16) | ((uint32_t)id[1] << 8) | id[2];
}

// Чтение данных из памяти
void W25Q128_ReadData(uint32_t address, uint8_t* data, uint32_t size)
{
uint8_t cmd[4];
cmd[0] = 0x03; // Команда READ
cmd[1] = (address >> 16) & 0xFF;
cmd[2] = (address >> 8) & 0xFF;
cmd[3] = address & 0xFF;

HAL_GPIO_WritePin(FLASH_CS_PORT, FLASH_CS_PIN, GPIO_PIN_RESET); // Активация
HAL_SPI_Transmit(&hspi3, cmd, 4, 100);
HAL_SPI_Receive(&hspi3, data, size, 1000);
HAL_GPIO_WritePin(FLASH_CS_PORT, FLASH_CS_PIN, GPIO_PIN_SET); // Деактивация
}

// Запись данных в память (после стирания сектора)
void W25Q128_WritePage(uint32_t address, uint8_t* data, uint32_t size)
{
// Включение записи
HAL_GPIO_WritePin(FLASH_CS_PORT, FLASH_CS_PIN, GPIO_PIN_RESET);
uint8_t cmd = 0x06; // Write Enable
HAL_SPI_Transmit(&hspi3, &cmd, 1, 100);
HAL_GPIO_WritePin(FLASH_CS_PORT, FLASH_CS_PIN, GPIO_PIN_SET);

// Запись данных (максимум 256 байт на страницу)
HAL_GPIO_WritePin(FLASH_CS_PORT, FLASH_CS_PIN, GPIO_PIN_RESET);

cmd = 0x02; // Page Program
HAL_SPI_Transmit(&hspi3, &cmd, 1, 100);

uint8_t addrBytes[3];
addrBytes[0] = (address >> 16) & 0xFF;
addrBytes[1] = (address >> 8) & 0xFF;
addrBytes[2] = address & 0xFF;
HAL_SPI_Transmit(&hspi3, addrBytes, 3, 100);

HAL_SPI_Transmit(&hspi3, data, size, 1000);

HAL_GPIO_WritePin(FLASH_CS_PORT, FLASH_CS_PIN, GPIO_PIN_SET);

// Ожидание завершения записи
W25Q128_WaitForWriteEnd();
}

// Ожидание завершения операции записи
void W25Q128_WaitForWriteEnd(void)
{
uint8_t cmd = 0x05; // Read Status Register
uint8_t status;

do {
HAL_GPIO_WritePin(FLASH_CS_PORT, FLASH_CS_PIN, GPIO_PIN_RESET);
HAL_SPI_Transmit(&hspi3, &cmd, 1, 100);
HAL_SPI_Receive(&hspi3, &status, 1, 100);
HAL_GPIO_WritePin(FLASH_CS_PORT, FLASH_CS_PIN, GPIO_PIN_SET);
HAL_Delay(1);
} while ((status & 0x01) == 0x01); // Пока бит BUSY установлен
}