Главная » Микроконтроллеры » STM32 с нуля » STM32 с нуля. Интерфейс SPI.

STM32 с нуля. Интерфейс SPI.

Опубликовано 28.02.2013 автором Aveal

Сегодня мы будем помогать двум микроконтроллерам подружиться с помощью SPI. Для начала обсудим, что же такое вообще SPI, а потом и программку набросаем Так вот, этот интерфейс позволяет связать между собой два и более устройств. Большой плюс SPI – большое быстродействие, так что большой объем данных улетит в легкую ) Но в SPI, в отличие, например от I2C, для подключения N устройств потребуется большое количество линий (3+N), а не 2, как в I2C. Да короче, на самом деле, есть и плюсы и минусы, как и во всем, так что идем дальше.

Существуют несколько типов подключения к шине, но в общем-то, алгоритм работы при любом подключении практически один и тот же. Ведущий генерирует тактовый сигнал с вывода SCLK и синхронно с этим сигналом передает данные по линии MOSI. В то же время подчиненное устройство передает данные в обратном направлении по линии MISO. Получается, что все сыты и довольны ) Хотя используется также подключение, при котором подчиненный только кушает байты данных, а сам ничего не шлет. А при подключении нескольких устройств возможно два варианта – независимое и каскадное. При независимом требуется больше линий, но такое подключение используется чаще.

Что же нам предлагает STM в плане SPI?

Возможно использование контроллера, как в качестве ведущего, так и в качестве подчиненного (ну это и так понятно)
Формат кадра – 8 или 16 бит
Возможность работы в режиме MultiMaster
Наличие огромного количества разных флагов – как для индикации окончания приема и передачи, так и для отлавливания разнообразных ошибок
Соответствующие прерывания
Возможна работа с использованием DMA
Аппаратное управление пином NSS для выбора подчиненного

В общем, все на месте )

Список прерываний для SPI:

Давайте посмотрим, как можно настроить SPI в STM32 для работы в нужном режиме. Как и раньше мы будем использовать Standard Peripheral Library. Лезем в библиотеку, находим и открываем файл stm32f10x_spi.h. Прямо в начале файла все, что нам понадобится:

typedef struct
{
  uint16_t SPI_Direction;   
  uint16_t SPI_Mode;          
  uint16_t SPI_DataSize;            
  uint16_t SPI_CPOL;                
  uint16_t SPI_CPHA;                
  uint16_t SPI_NSS;                 
  uint16_t SPI_BaudRatePrescaler;   
  uint16_t SPI_FirstBit;            
  uint16_t SPI_CRCPolynomial;       
}SPI_InitTypeDef;

Назначив всем этим полям структуры SPI_InitTypeDef определенные значения, мы можем настроить модуль SPI STM32. Тут вроде бы все понятно, но давайте по традиции разберем для чего нужно каждое отдельное поле:

uint16_t SPI_Direction – направление передачи данных, возможные значения:

SPI_Direction_2Lines_FullDuplex 
SPI_Direction_2Lines_RxOnly     
SPI_Direction_1Line_Rx          
SPI_Direction_1Line_Tx

Ну, тут все очевидно

uint16_t SPI_Mode — режим работы, раб или господин – то есть подчиненный или ведущий (master или slave)

uint16_t SPI_DataSize – DataSize и этим все сказано ) размер данных – 8 или 16 бит

uint16_t SPI_CPOL
uint16_t SPI_CPHA
А это настройки тактового сигнала

uint16_t SPI_NSS – тут мы выбираем, как будет управляться сигнал NSS – аппаратно или программно. Соответственно возможные значения поля:

SPI_NSS_Soft                    
SPI_NSS_Hard

uint16_t SPI_BaudRatePrescaler – предделитель

uint16_t SPI_FirstBit – здесь выбираем с какого бита начнется передача (младшего или старшего)

uint16_t SPI_CRCPolynomial – контрольная сумма

Все возможные значения для всех полей написаны все в том же файле stm32f10x_spi.h чуть ниже определения структуры.

В другом файле из SPL — stm32f10x_spi.c – функции для работы с SPI, их мы рассмотрим по мере того как они нам понадобятся.

Итак, предлагаю написать небольшую программку для обмена данными между двумя контроллерами по SPI. Будем писать программу и для ведущего и для подчиненного.

Что бы такое замутить, чтобы не просто гонять бесполезные данные….

Хм, давайте так: одному контроллеру на вход дается аналоговое напряжение. Он запускает АЦП и в зависимости от полученного значения выдает на шину SPI значение. Значения могут быть такими:

Напряжение       Отсылаемое значение
0 < U < 1В            0х00
1В < U < 2В    0х01
2В < U < 3В          0х02
3В < U < 3.3В       0х03
3.3В < U               0х04

Второй контроллер в зависимости от принятых данных зажигает светодиоды. Если принимает 0х01 – зажигает один диод, если принимает 0х02 – зажигает два, ну дальше вы поняли;)

Небольшое лирическое отступление — тут мы будем пользоваться тем, что изучали ранее — вот тут про создание проекта, а здесь про использование АЦП

Задача поставлена, начинаем реализовывать. Сначала напишем программу для ведущего (SPI Master). Создаем проект, не забыв добавить файлы из SPL для работы с SPI, и пишем следующий код:

/****************************spi master.c****************************/
#include "stm32f10x.h" 
#include "stm32f10x_rcc.h"
#include "stm32f10x_gpio.h"
#include "stm32f10x_spi.h"
#include "stm32f10x_adc.h"
 
 
 
/*******************************************************************/
//Объявляем переменные
GPIO_InitTypeDef port;
SPI_InitTypeDef spi;
ADC_InitTypeDef adc;
uint8_t sendData;
uint16_t counter;
uint16_t data;
 
 
 
/*******************************************************************/
void initAll()
{	
    //Тут абсолютно вся инициализация
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);	
 
    port.GPIO_Mode = GPIO_Mode_AF_PP;
    port.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;
    port.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &port);	
 
    ADC_StructInit(&adc);
    adc.ADC_ContinuousConvMode = ENABLE;
    adc.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
    ADC_Init(ADC1, &adc);	
 
    SPI_StructInit(&spi);
    spi.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
    spi.SPI_Mode = SPI_Mode_Master;
    spi.SPI_DataSize = SPI_DataSize_8b;
    spi.SPI_CPOL = SPI_CPOL_Low;
    spi.SPI_CPHA = SPI_CPHA_2Edge;
    spi.SPI_NSS = SPI_NSS_Soft;
    spi.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
    spi.SPI_FirstBit = SPI_FirstBit_MSB;
    spi.SPI_CRCPolynomial = 7;
    SPI_Init(SPI1, &spi);
 
    GPIO_StructInit(&port);
    port.GPIO_Mode = GPIO_Mode_IPD;
    port.GPIO_Pin = GPIO_Pin_0;
    port.GPIO_Speed = GPIO_Speed_2MHz;
    GPIO_Init(GPIOA, &port);
}
 
 
 
/*******************************************************************/
int main()
{
    __enable_irq();	
    initAll();
    //Включаем АЦП
    ADC_Cmd(ADC1, ENABLE);	
    ADC_SoftwareStartConvCmd(ADC1, ENABLE);
    //И конечно же включаем SPI
    SPI_Cmd(SPI1, ENABLE);
    while(1)
    {
        //Это просто счетчик, чтобы отсылать на шину данные только когда счетчик 
	//досчитает до 15000, число взято абсолютно "от балды" ))
        counter++;	
	data = ADC_GetConversionValue(ADC1);
        //Сделали АЦП, анализируем данные
	if (data == 0xFFF)
	{
    	    sendData = 0x04;
	}
	else if (data > 0xE8B)
	{
            sendData = 0x03;
	}
	else if (data > 0x9B2)
	{
	    sendData = 0x02;
	}
	else if (data > 0x4D9)
	{
	    sendData = 0x01;
	}
	else
	{
	    sendData = 0x00;
	}
        if(counter == 15000)
	{			
            //Отсылаем, ради этого все и затеивалось
	    SPI_I2S_SendData(SPI1, sendData);
	}	
    }		
}
 
 
 
/****************************End of file****************************/

Master готов, пишем программу для SPI Slave.

/****************************spi slave.c****************************/
#include "stm32f10x.h" 
#include "stm32f10x_rcc.h"
#include "stm32f10x_gpio.h"
#include "stm32f10x_spi.h"
 
 
 
/*******************************************************************/
GPIO_InitTypeDef port;
SPI_InitTypeDef spi;
uint8_t data;
uint8_t needUpdate;
 
 
 
/*******************************************************************/
void initAll()
{
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
 
    port.GPIO_Mode = GPIO_Mode_AF_PP;
    port.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
    port.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOB, &port);
 
    port.GPIO_Mode = GPIO_Mode_Out_PP;
    port.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3;
    port.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &port);
 
    SPI_StructInit(&spi);
    spi.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
    spi.SPI_Mode = SPI_Mode_Slave;
    spi.SPI_DataSize = SPI_DataSize_8b;
    spi.SPI_CPOL = SPI_CPOL_Low;
    spi.SPI_CPHA = SPI_CPHA_2Edge;
    spi.SPI_NSS = SPI_NSS_Soft;
    spi.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
    spi.SPI_FirstBit = SPI_FirstBit_MSB;
    spi.SPI_CRCPolynomial = 7;
    SPI_Init(SPI2, &spi);
}
 
 
 
/*******************************************************************/
int main()
{
    __enable_irq();
    initAll();
    SPI_Cmd(SPI2, ENABLE);
    NVIC_EnableIRQ(SPI2_IRQn);
    //Тут мы разрешаем прерывание по приему
    SPI_I2S_ITConfig(SPI2, SPI_I2S_IT_RXNE, ENABLE);
    //Ну вот приняли, теперь просто зажигаем диоды
    while(1)
    {
	if (needUpdate == 1)
	{
            GPIO_ResetBits(GPIOA, GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3); 
	    if (data == 0x01)
	    {
	        GPIO_SetBits(GPIOA, GPIO_Pin_0);
	    }
	    if (data == 0x02)
	    {
		GPIO_SetBits(GPIOA, GPIO_Pin_0 | GPIO_Pin_1);
	    }
	    if (data == 0x03)
	    {
		GPIO_SetBits(GPIOA, GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2);
	    }
	    if (data == 0x04)
	    {
		GPIO_SetBits(GPIOA, GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3);
	    }
	    needUpdate = 0;
	}
    }
}
 
 
 
/*******************************************************************/
void SPI2_IRQHandler()
{
    data = SPI_I2S_ReceiveData(SPI2);	
    needUpdate = 1;
}
 
 
 
/****************************End of file****************************/

Здесь вся работа с SPI в прерывании. Когда взлетает флаг, сигнализирующий о принятии байта, бежим в прерывание и читаем данные. Приняли данные – надо обновить состояние светодиодов – выставляем переменную needUpdate в единицу. В главном цикле после этого зажигаются нужные светодиоды. Вот как то так =)

Собственно, вроде бы вот и все, две программки написали, достаточно на сегодня Конечно, это тестовые программы, просто для знакомства с интерфейсом, поэтому все так «в лоб» сделано =) Наверное, в ближайшее время поковыряем еще и I2C, заодно сравним интерфейс с уже известным нам интерфейсом SPI, так что до скорых встреч!

Пн	Вт	Ср	Чт	Пт	Сб	Вс
« Апр
		1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30	31

STM32 с нуля. Интерфейс SPI.

Похожие статьи:

Понравилась статья? Поделись с друзьями!

Добавить комментарий Отменить ответ