Режим ведомого

В примере будет проведена настройка SPI в режиме ведомого. Ведомый будет читать и передавать 12 байт.

Работа с конфигуратором (В разработке)

Для начала настроем в конфигураторе тактирование mik32, например, от внешнего кварца 32МГц. Затем настроем делители шины. Так как SPI тактируется от шины APB_P_CLK, то зададим делитель AHB_DIV и APB_P_CLK. В данном примере оставим делитель по умолчанию. В итоге вкладка с тактированием должна выглядеть так:

(Картинка тактирования из конфигуратора. В работе)

Затем перейдем к настройке самого SPI. Для этого откроем вкладку интерфейсы, выберем SPI и зададим режим работы ведомый. После этого появятся несколько настроек. Зададим им следующие значения:

• Фаза тактового сигнала - Тактовая частота неактивна вне слова;
• Полярность тактового сигнала вне слова - Тактовый сигнал удерживается на низком уровне;
• Длина передаваемой посылки - 8 бит.

В итоге настройки SPI в конфигураторе должны выглядеть как на рисунке.

Нажимаем кнопку сохранения и генерации. В итоге у нас появится проект для PlatformIo. Далее работа идет в visual studio code.

Использование библиотеки HAL_SPI

В сгенерированном проекте в файле main.c должна быть функция SPI0_Init, в которой будут заданы настройки для SPI. Выглядит она так:

static void SPI0_Init(void)
{
    hspi0.Instance = SPI_0;

    /* Режим SPI */
    hspi0.Init.SPI_Mode = HAL_SPI_MODE_SLAVE;

    /* Настройки */                       
    hspi0.Init.CLKPhase = SPI_PHASE_OFF;            
    hspi0.Init.CLKPolarity = SPI_POLARITY_LOW;         
    hspi0.Init.DataSize = SPI_DATASIZE_8BITS;  

    HAL_SPI_Init(&hspi0);

}

Кроме этого в функции SystemClock_Config приведены настройки для тактирования. Убедитесь что в PeriphClkInit.PMClockAPB_P присутствует PM_CLOCK_SPI_0_M. Сама функция должна выглядеть примерно так:

void SystemClock_Config(void)
{
    RCC_OscInitTypeDef RCC_OscInit = {0};
    RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};

    RCC_OscInit.OscillatorEnable = RCC_OSCILLATORTYPE_OSC32K | RCC_OSCILLATORTYPE_OSC32M;   
    RCC_OscInit.OscillatorSystem = RCC_OSCILLATORTYPE_OSC32M;                          
    RCC_OscInit.AHBDivider = 0;                             
    RCC_OscInit.APBMDivider = 0;                             
    RCC_OscInit.APBPDivider = 0;                             
    RCC_OscInit.HSI32MCalibrationValue = 0;                  
    RCC_OscInit.LSI32KCalibrationValue = 0;
    HAL_RCC_OscConfig(&RCC_OscInit);

    PeriphClkInit.PMClockAHB = PMCLOCKAHB_DEFAULT;    
    PeriphClkInit.PMClockAPB_M = PMCLOCKAPB_M_DEFAULT | PM_CLOCK_WU_M;     
    PeriphClkInit.PMClockAPB_P = PMCLOCKAPB_P_DEFAULT | PM_CLOCK_UART_0_M | PM_CLOCK_SPI_0_M;
    PeriphClkInit.RTCClockSelection = RCC_RTCCLKSOURCE_NO_CLK;
    PeriphClkInit.RTCClockCPUSelection = RCC_RTCCLKCPUSOURCE_NO_CLK;
    HAL_RCC_ClockConfig(&PeriphClkInit);
}

Для демонстрации вывода текста в PeriphClkInit.PMClockAPB_P присутствует PM_CLOCK_UART_0_M. У вас его может не быть так как UART нужно включить отдельно. Для этого нужно подключить библиотеки uart_lib и xprintf:

#include "mik32_hal_rcc.h"
#include "mik32_hal_spi.h"

#include "uart_lib.h"
#include "xprintf.h"

Для инициализации UART в функции main после функции тактирования SystemClock_Config следует написать

UART_Init(UART_0, 3333, UART_CONTROL1_TE_M | UART_CONTROL1_M_8BIT_M, 0, 0);

В начале main.c можно видеть объявление структуры с набором настроек для SPI, которую использует функция инициализации SPI0_Init.

SPI_HandleTypeDef hspi0;

void SystemClock_Config(void);
static void SPI0_Init(void);

Создадим в функции main массив slave_output, который будет содержать в себе 12 байт, которые ведомый будет отправлять ведущему. Создадим массив slave_input такого же размера как и slave_output для принятых данных.

Обмен данными запускается с помощью функции HAL_SPI_Exchange.

Функция main

int main()
{    

    SystemClock_Config();
    
    SPI0_Init();

    uint8_t slave_output[] = {0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xC0, 0xC1};
    uint8_t slave_input[sizeof(slave_output)]; 
    for (uint32_t i = 0; i < sizeof(slave_input); i++)
    {
        slave_input[i] = 0;
    }

    while (1)
    {    
        /* Передача и прием данных */
        HAL_SPI_Exchange(&hspi0, slave_output, slave_input, sizeof(slave_output));
              
        /* Вывод принятый данных и обнуление массива slave_input */
        for(uint32_t i = 0; i < sizeof(slave_input); i++)
        {
            xprintf("slave_input[%d] = %02x\n", i, slave_input[i]);
            slave_input[i] = 0;
        }
    }
       
}