[14] STM32F4 - Discovery - Obsługa SPI na bibliotekach API&HAL

We wcześniejszym poście opisałem obsługę czujnika LIS302DL poprzez SPI. Tym razem chciałem przybliżyć uruchamianie samego interfejsu za pomocą bibliotek HAL oraz API. 

Biblioteki API

W tej części definiuje się część włączającą SPI oraz odpowiednie GPIO. Następnie należy zdefiniować funkcje za pomocą których dane będą wysyłane oraz odbierane.

Włączenie pinów z diodami wbudowanymi:

1. void LED_GPIO_INIT(void)
2. {
3.     GPIO_InitTypeDef GPIOINITSTRUCT;
4.    
5.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
7.     GPIOINITSTRUCT.GPIO_Pin = GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
8.      
9.     GPIOINITSTRUCT.GPIO_OType = GPIO_OType_PP;
10.     GPIOINITSTRUCT.GPIO_Mode = GPIO_Mode_OUT;
11.     GPIOINITSTRUCT.GPIO_PuPd = GPIO_PuPd_NOPULL;
12.     GPIOINITSTRUCT.GPIO_Speed = GPIO_Speed_100MHz;
13.     GPIO_Init(GPIOD, &GPIOINITSTRUCT);
14. }

Włączenie SPI2 wraz z GPIO:

1. void SPI_InitFLASH()
2. {
3.     GPIO_InitTypeDef GPIOINITSTRUCT;
4.     SPI_InitTypeDef SPIINITSTRUCT;
5.    
6.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
7.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
8.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
9.      
10.     SPI_I2S_DeInit(SPI2);
11.      
12.     SPIINITSTRUCT.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
13.     SPIINITSTRUCT.SPI_Mode = SPI_Mode_Master;    
14.     SPIINITSTRUCT.SPI_DataSize = SPI_DataSize_8b;
15.     SPIINITSTRUCT.SPI_CPOL = SPI_CPOL_Low;        
16.     SPIINITSTRUCT.SPI_CPHA = SPI_CPHA_1Edge;      
17.     SPIINITSTRUCT.SPI_NSS = SPI_NSS_Soft;                  
18.     SPIINITSTRUCT.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2;
19.     SPIINITSTRUCT.SPI_FirstBit = SPI_FirstBit_MSB;
20.     SPI_Init( SPI2, &SPIINITSTRUCT);
22.     SPI_Cmd( SPI2, ENABLE);
23.    
24.     //SCK MISO MOSI
25.     GPIOINITSTRUCT.GPIO_Pin = ( GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15 );
26.     GPIOINITSTRUCT.GPIO_Mode = GPIO_Mode_AF;
27.     GPIOINITSTRUCT.GPIO_OType = GPIO_OType_PP;
28.     GPIOINITSTRUCT.GPIO_Speed = GPIO_Speed_50MHz;
29.     GPIOINITSTRUCT.GPIO_PuPd = GPIO_PuPd_UP;
30.     GPIO_Init(GPIOB, &GPIOINITSTRUCT);
31.    
32.     //Piny SPI2 jako alternatywne
33.     GPIO_PinAFConfig(GPIOB, GPIO_PinSource13, GPIO_AF_SPI2);
34.     GPIO_PinAFConfig(GPIOB, GPIO_PinSource14, GPIO_AF_SPI2);
35.     GPIO_PinAFConfig(GPIOB, GPIO_PinSource15, GPIO_AF_SPI2);
37.     //CS
38.     GPIOINITSTRUCT.GPIO_Pin = GPIO_Pin_1;
39.      
40.     GPIOINITSTRUCT.GPIO_OType = GPIO_OType_PP;
41.     GPIOINITSTRUCT.GPIO_Mode = GPIO_Mode_OUT;
42.     GPIOINITSTRUCT.GPIO_PuPd = GPIO_PuPd_NOPULL;
43.     GPIOINITSTRUCT.GPIO_Speed = GPIO_Speed_100MHz;
44.     GPIO_Init(GPIOD, &GPIOINITSTRUCT);
45. }

Funkcja wysyłająca oraz odbierająca dane, taka sama będzie w dla bibliotek HAL-a:

1. uint8_t SPI2_SEND_DATA(uint8_t data)
2. {
3.     if (!((SPI2)->CR1 & SPI_CR1_SPE)) {return 0;}
4.    
5.     while ((SPI2->SR & SPI_FLAG_TXE) == 0 || (SPI2->SR & SPI_FLAG_BSY));
6.    
7.     SPI2->DR = data;
8.    
9.     while ((SPI2->SR & SPI_FLAG_RXNE) == 0 || (SPI2->SR & SPI_FLAG_BSY));
10.    
11.     return SPI2->DR;
12. }

Główna pętla programu:

1. uint8_t wyslij[15];
2. uint8_t odbierz[15];
4. int main(void)
5. {
6.     uint8_t i;
7.    
8.     SystemInit();
9.    
10.     LED_GPIO_INIT();
11.    
12.     SPI_InitFLASH();
13.    
14.     for(i = 0; i<15;i++)
15.     {
16.         wyslij[i] = 0xAB;
17.         odbierz[i] = SPI2_SEND_DATA(wyslij[i]);
18.     }
19.    
20.   /* Memory compare */
21.   if (memcmp(wyslij, odbierz, 15) == 0)
22.     {
23.         GPIO_SetBits(GPIOD, GPIO_Pin_12);
24.         GPIO_SetBits(GPIOD, GPIO_Pin_13);
25.   }
26.     else {  GPIO_SetBits(GPIOD, GPIO_Pin_14);   }
27.    
28.   while(1) { }
29. }

Do porównania wykorzystałem funkcje memcmp, która jest zdefiniowana w bibliotece string.h. Może ona zwracać trzy rodzaje wartości, liczbę mniejszą od zera gdy wyslij jest mniejsze od odbierz. Zwróci 0 gdy wartości będą sobie równe albo wartość większą od zera gdy wyślij będzie większe od odbierz. 

Biblioteki HAL

Podobnie jak poprzednio należy zdefiniować włączenie odpowiedniego SPI wraz z funkcjami wysyłającymi i odbierającymi dane poprzez SPI. Tylko tym razem zostanie to wykonane z wykorzystaniem bibliotek HAL. 

W pierwszej kolejności zostanie włączony GPIO odpowiedzialny za sterowanie diodami wbudowanymi, która dla bibliotek HAL-a wygląda następująco:

1. void LED_GPIOD_WLACZ(void)
2. {
3.      GPIO_InitTypeDef GPIO_InitDef;
4.      
5.      __GPIOD_CLK_ENABLE();
6.      
7.      GPIO_InitDef.Pin = GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
8.            
9.      GPIO_InitDef.Mode = GPIO_MODE_OUTPUT_PP;
10.      GPIO_InitDef.Pull = GPIO_NOPULL;
11.      GPIO_InitDef.Speed = GPIO_SPEED_LOW;
12.      HAL_GPIO_Init(GPIOD, &GPIO_InitDef);
13. }

Następnie włączenie SPI2 oraz odpowiednich portów GPIO:

1. void SPI2_WLACZENIE()
2. {
3.     GPIO_InitTypeDef GPIO_InitStruct;
4.     SPI_HandleTypeDef SPIHandle;
5.    
6.     SPIHandle.Instance = SPI2;
7.    
8.     //Wlaczenie zegara dla GPIOA & GPIOB
9.     __GPIOA_CLK_ENABLE();
10.     __GPIOB_CLK_ENABLE();
11.    
12.     //Wlaczenie zegara dla SPI2
13.     __HAL_RCC_SPI2_CLK_ENABLE();
14.    
15.     //SPI2 PIN PACK 2
16.     //PB13     ------> SPI1_SCK
17.     //PB14     ------> SPI1_MISO
18.     //PB15     ------> SPI1_MOSI
19.    
20.     GPIO_InitStruct.Pin = GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15;
21.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
22.     GPIO_InitStruct.Pull = GPIO_NOPULL;
23.     GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
24.     GPIO_InitStruct.Alternate = GPIO_AF5_SPI2;
25.     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
26.    
27.     //Konfiguracja PB2
28.     GPIO_InitStruct.Pin = GPIO_PIN_1;
29.     GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
30.     GPIO_InitStruct.Pull = GPIO_NOPULL;
31.     GPIO_InitStruct.Speed = GPIO_SPEED_LOW;
32.     HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
34.     SPIHandle.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;    
35.     SPIHandle.Init.FirstBit = SPI_FIRSTBIT_MSB;                                
36.     SPIHandle.Init.Mode = SPI_MODE_MASTER;                                     
37.     SPIHandle.Init.Direction = SPI_DIRECTION_2LINES;                   
38.     SPIHandle.Init.DataSize = SPI_DATASIZE_8BIT;
39.    
40.     SPIHandle.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
41.     SPIHandle.Init.CRCPolynomial = 7;
42.     SPIHandle.Init.TIMode = SPI_TIMODE_DISABLE;
43.     SPIHandle.Init.CLKPolarity = SPI_POLARITY_LOW;                 
44.     SPIHandle.Init.CLKPhase = SPI_PHASE_1EDGE;                             
45.     SPIHandle.Init.NSS = SPI_NSS_SOFT;                                                     
46.    
47.     //Wylaczenie SPI
48.     __HAL_SPI_DISABLE(&SPIHandle);
49.    
50.     //Init SPI
51.     HAL_SPI_Init(&SPIHandle);
53.     //Wlaczenie SPI
54.     __HAL_SPI_ENABLE(&SPIHandle);
55. }

Teraz czas na funkcję odbierającą dane przez SPI:

1. uint8_t SPI2_SEND_DATA(uint8_t data)
2. {
3.     if (!((SPI2)->CR1 & SPI_CR1_SPE)) {return 0;}
4.    
5.     while ((SPI2->SR & SPI_FLAG_TXE) == 0 || (SPI2->SR & SPI_FLAG_BSY));
6.    
7.     SPI2->DR = data;
8.    
9.     while ((SPI2->SR & SPI_FLAG_RXNE) == 0 || (SPI2->SR & SPI_FLAG_BSY));
10.    
11.     return SPI2->DR;
12. }

Właściwie na tym można zakończyć główna funkcja programu wygląda następująco:

1. uint8_t wyslij[15];
2. uint8_t odbierz[15];
4. int main(void)
5. {
6.     uint8_t i, pomocnicza;
7.     uint8_t pomocnicza = 0;
8.     //Ustawienie zegarow
9.     RCC_ON();
10.    
11.     //Wlaczenie hala
12.     HAL_Init();
13.    
14.     //Wlaczenie led
15.     LED_GPIOD_WLACZ();
16.    
17.     //Wlaczenie SPI
18.     SPI2_WLACZENIE();
19.    
20.     //Wypelnienie bufora danymi oraz przeslanie ich
21.     for(i = 0; i<15;i++)
22.     {
23.         wyslij[i] = 0xAB;
24.         odbierz[i] = SPI2_SEND_DATA(wyslij[i]);
25.     }
26.    
27.     //Sprawdzenie poprawnosci danych
28.    
29.     i=0;
30.     while(i<15)
31.     {
32.         if(wyslij[i]==odbierz[i])
33.         {
34.             pomocnicza++;
35.         }
36.         else{ }
37.         i++;
38.     }
39.    
40.     if(pomocnicza==15)
41.     {
42.         HAL_GPIO_WritePin(GPIOD, GPIO_Pin_12, GPIO_PIN_SET);
43.         HAL_GPIO_WritePin(GPIOD, GPIO_Pin_13, GPIO_PIN_SET);
44.     }
45.     else
46.     {
47.         HAL_GPIO_WritePin(GPIOD, GPIO_Pin_14, GPIO_PIN_SET);
48.     }
50.     while (1) {}
51. }

W programie dla API wykorzystałem porównywanie danych funkcją memcmp, dla hala natomiast porównuje wartości między sobą. Jeśli wszystkie będą takie same to zostaną zapalone odpowiednie diody.