[9] STM32F4 - Discovery - USART, printf

W tym poście opiszę sposób włączenia oraz obsługi USART-u poprzez płytkę Discovery.

Opis

UART i USART można podłączyć w następującej konfiguracji do pinów:

W odróżnieniu od płytki Nucleo, Discovery nie ma wbudowanego konwertera, w związku z tym należy się posłużyć zewnętrznym.

Dostępne piny dla tej magistrali przedstawiłem poniżej:

USART1 - Zestaw pinów 1: TX PA9, RX PA10; 2: TX PB6, RX PB7;
USART2 - Zestaw pinów 1: TX PA2, RX PA3; 2: TX PD5, RX PD6;
USART3 - Zestaw pinów 1: TX PB10, RX PB11; 2: TX PC10, RX PC11; 3: TX PD8, RX PD9;
UART4 -  Zestaw pinów 1: TX PA0, RX PA1; 2: TX PC10, RX PC11;
UART5 - Zestaw pinów 1: TX PC12, RX PD2;
USART6 - Zestaw pinów 1: TX PC6, RX PC7; 2: TX PG14, RX PG9;
UART7 - Zestaw pinów 1: TX PE8, RX PE7; 2: TX PF7, RX PF6;
UART8 - Zestaw pinów 1: TX PE1, RX PE0;

USART1 i USART6 taktowane są poprzez APB 2, pozostałe natomiast przez APB 1. TX odpowiada za transmisję danych, RX natomiast jest odpowiedzialny za odbieranie.

Płytka Discovery niestety nie posiada wbudowanego konwertera, w związku z tym w celu uzyskania komunikacji należy posłużyć się zewnętrznym układem podłączonym do odpowiednich wyprowadzeń.

Program:

W tym programie przedstawię sposób wykorzystania USARTU na przerwaniach. Do tego celu wykorzystac układ 1 z podłączeniem TX do PA9 oraz RX do PA10.

1. #include "stm32f4xx.h"
2. #include "stm32f4xx_gpio.h"
3. #include "stm32f4xx_rcc.h"
4. #include "stm32f4xx_usart.h"
5. #include "misc.h"
7. void SendChar(char);
8. void USART_Initialize(void);
9. void GPIO_Initialize(void);
10. void USART_Send(volatile char *s);
12. int main(void)
13. {
14.      //Inicjalizacja pinów
15.      GPIO_Initialize();
16.      //Inicjalizacja USARTU
17.      USART_Initialize();
18.      //Wyslanie danych
19.      USART_Send("1234");
20.      SendChar('1');
21.      while (1)
22.      {
23.      }
24. }
26. void USART_Initialize(void)
27. {
28.      //Inicjalizacja kontrolera przerwan
29.      NVIC_InitTypeDef NVIC_InitStruct;
30.    
31.      //konfiguracja ukladu USART
32.      USART_InitTypeDef USART_InitStructure;
33.      
34.      //Ustawienie kanalu IRQ
35.      NVIC_InitStruct.NVIC_IRQChannel = USART1_IRQn;
36.    
37.      //Wlaczenie zegara dla USART1
38.      RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
39.      
40.      //Ustawienie predkosci transmisji 9600bps
41.      USART_InitStructure.USART_BaudRate = 9600;
42.      //Dlugosc wysylanego slowa
43.      USART_InitStructure.USART_WordLength = USART_WordLength_8b;
44.      //Ustawienie jednego bitu stopu
45.      USART_InitStructure.USART_StopBits = USART_StopBits_1;
46.      //Kontrola parzystosci wylaczona
47.      USART_InitStructure.USART_Parity = USART_Parity_No;
48.      //Wylaczenie kontroli przeplywu danych
49.      USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
50.      //Tryb pracy linii odpowiednio odbior i nadawanie
51.      USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
52.      
53.      //Konfiguracja ukladu
54.      USART_Init(USART1, &USART_InitStructure);
55.      //Wlaczenie USART1
56.      USART_Cmd(USART1, ENABLE);
57.      
58.      //Wlaczenie przerwania na RX1
59.      USART1->CR1 |= USART_CR1_RXNEIE;
60.    
61.      //Wprowadzenie ustawien do przerwan
62.      NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
63.      NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1;
64.      NVIC_InitStruct.NVIC_IRQChannelSubPriority = 1;
65.      NVIC_Init(&NVIC_InitStruct);
66. }
68. void GPIO_Initialize(void)
69. {
70.      //konfigurowanie portow GPIO
71.      GPIO_InitTypeDef  GPIO_In;
72.      RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
73.      
74.      //TX dla pinu PB6
75.      GPIO_In.GPIO_Pin = GPIO_Pin_6;
76.      GPIO_In.GPIO_PuPd = GPIO_PuPd_UP;
77.      GPIO_In.GPIO_OType = GPIO_OType_PP;
78.      GPIO_In.GPIO_Mode = GPIO_Mode_AF;
79.      GPIO_In.GPIO_Speed = GPIO_Speed_100MHz;
80.      GPIO_Init(GPIOB, &GPIO_In);
81.      
82.      //RX dla pinu PB7
83.      GPIO_In.GPIO_Pin = GPIO_Pin_7;
84.      GPIO_In.GPIO_Mode = GPIO_Mode_AF;
85.      GPIO_In.GPIO_PuPd = GPIO_PuPd_UP;
86.      GPIO_In.GPIO_OType = GPIO_OType_PP;
87.      GPIO_In.GPIO_Speed = GPIO_Speed_100MHz;
88.      GPIO_Init(GPIOB, &GPIO_In);
89.      
90.      //Wlaczenie transmisji na podanych pinach
91.      GPIO_PinAFConfig(GPIOB, GPIO_PinSource6, GPIO_AF_USART1);
92.      GPIO_PinAFConfig(GPIOB, GPIO_PinSource7, GPIO_AF_USART1);
93. }
95. void USART_Send(volatile char *c)
96. {
97.      //Petla dziala do puki bedzie jakis znak do wyslania
98.      while(*c)
99.      {
100.         //Sprawdza czy rejestr danych zostal oprózniony
101.         while( !(USART1->SR & 0x00000040) );
102.         //Przeslij dane,
103.         USART_SendData(USART1, *c);
104.         *c++;
105.      }
106. }
108. void SendChar(char c)
109. {
110.      //Sprawdza czy bufor nadawczy jest pusty
111.      while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
112.      USART_SendData(USART1, c);
113. }

Drugi program będzie zawierał przykład, który będzie odbierał dane z komputera.

1. //Program wykorzystujacy funckje printf
2. #include "stm32f4xx.h"
3. #include "stm32f4xx_gpio.h"
4. #include "stm32f4xx_rcc.h"
5. #include "stm32f4xx_usart.h"
6. #include "stdio.h"
7. #include "misc.h"
9. //struktura FILE zawierajca jeden parametr
10. struct __FILE {
11.     int parametr;
12. };
14. //Stworzenie zmiennej z struktury FILE
15. //Parametr musi miec taka nazwe
16. FILE __stdout;
18. void send_char(char);
19. void USART_Initialize(void);
20. void GPIO_Initialize(void);
21. void USART_Send(volatile char *s);
22. int PutFile(int ch, FILE *f);
23. void Send_Charc(volatile char c);
25. int main(void)
26. {
27.       float Wartosc2 = 1.85456;
28.       //Inicjalizacja pinów
29.       GPIO_Initialize();
30.       //Inicjalizacja USARTU
31.       USART_Initialize();
32.       //Wyslanie danych
33.       USART_Send("\n1234 \n");
34.       printf("\nFunkcja printf \r\n");
35.       printf("Zmiennoprzecinkowa - %.3f \r\n", Wartosc2);
36.       while (1)
37.       {
38.        }
39. }
41. void USART_Initialize(void)
42. {
43.      //Inicjalizacja kontrolera przerwan
44.      NVIC_InitTypeDef NVIC_InitStruct;
45.    
46.      //konfiguracja ukladu USART
47.      USART_InitTypeDef USART_InitStructure;
48.      
49.      //Ustawienie kanalu IRQ
50.      NVIC_InitStruct.NVIC_IRQChannel = USART1_IRQn;
51.    
52.      //Wlaczenie zegara dla USART1
53.      RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
54.      
55.      //Ustawienie predkosci transmisji 9600bps
56.      USART_InitStructure.USART_BaudRate = 9600;
57.      //Dlugosc wysylanego slowa
58.      USART_InitStructure.USART_WordLength = USART_WordLength_8b;
59.      //Ustawienie jednego bitu stopu
60.      USART_InitStructure.USART_StopBits = USART_StopBits_1;
61.      //Kontrola parzystosci wylaczona
62.      USART_InitStructure.USART_Parity = USART_Parity_No;
63.      //Wylaczenie kontroli przeplywu danych
64.      USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
65.      //Tryb pracy linii odpowiednio odbior i nadawanie
66.      USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
67.      
68.      //Konfiguracja ukladu
69.      USART_Init(USART1, &USART_InitStructure);
70.      //Wlaczenie USART1
71.      USART_Cmd(USART1, ENABLE);
72.      
73.      //Wlaczenie przerwania na RX1
74.      USART1->CR1 |= USART_CR1_RXNEIE;
75.    
76.      //Wprowadzenie ustawien do przerwan
77.      NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
78.      NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 1;
79.      NVIC_InitStruct.NVIC_IRQChannelSubPriority = 1;
80.      NVIC_Init(&NVIC_InitStruct);
81. }
83. void GPIO_Initialize(void)
84. {
85.      //konfigurowanie portow GPIO
86.      GPIO_InitTypeDef  GPIO_In;
87.      RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
88.      
89.      //TX dla pinu PB6
90.      GPIO_In.GPIO_Pin = GPIO_Pin_6;
91.      GPIO_In.GPIO_PuPd = GPIO_PuPd_UP;
92.      GPIO_In.GPIO_OType = GPIO_OType_PP;
93.      GPIO_In.GPIO_Mode = GPIO_Mode_AF;
94.      GPIO_In.GPIO_Speed = GPIO_Speed_100MHz;
95.      GPIO_Init(GPIOB, &GPIO_In);
96.      
97.      //RX dla pinu PB7
98.      GPIO_In.GPIO_Pin = GPIO_Pin_7;
99.      GPIO_In.GPIO_Mode = GPIO_Mode_AF;
100.      GPIO_In.GPIO_PuPd = GPIO_PuPd_UP;
101.      GPIO_In.GPIO_OType = GPIO_OType_PP;
102.      GPIO_In.GPIO_Speed = GPIO_Speed_100MHz;
103.      GPIO_Init(GPIOB, &GPIO_In);
104.      
105.      //Wlaczenie transmisji na podanych pinach
106.      GPIO_PinAFConfig(GPIOB, GPIO_PinSource6, GPIO_AF_USART1);
107.      GPIO_PinAFConfig(GPIOB, GPIO_PinSource7, GPIO_AF_USART1);
108. }
110. void USART_Send(volatile char *c)
111. {
112.      //Petla dziala do puki bedzie jakis znak do wyslania
113.      while(*c)
114.      {
115.         //Sprawdza czy rejestr danych zostal oprózniony
116.         while( !(USART1->SR & 0x00000040) );
117.         //Przeslij dane,
118.         USART_SendData(USART1, *c);
119.         *c++;
120.      }
121. }
123. //Funkcja wysylajaca dane do strumienia
124. //Jej nazwy nie mozna zmieniac
125. int fputc(int ch, FILE *f)
126. {
127.     volatile char c = ch;
128.    
129.       //Wyslanie danych
130.         USART1->DR = (uint16_t)(c & 0x01FF);
131.         //Odczekanie az bufor zostanie oprozniony
132.       while (!((USART1)->SR & USART_FLAG_TXE))
133.         {}
134.        
135.     return ch;
136. }
138. void Send_Charc(volatile char c)
139. {
140.  while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
141.  USART_SendData(USART1, c);
142. }