[0] STM32F0 - GPIO oraz UART

Tym razem przedstawię szybki post dotyczący mikrokontrolerów STM32F0 w którym przedstawię podstawowe operacje na portach GPIO w oparciu o mikrokontroler STM32F030P6.

Program dla GPIO

Nie ma tutaj żadnych odkrywczych rzeczy, wobec czego przejdę od razu do kodu:

Rozpocząć należy standardowo od deklaracji bibliotek. Następnie włączenie zegarów oraz inicjalizacja pinów mikrokontrolera:

1. #include "stm32f0xx.h"
2. #include <stm32f0xx_rcc.h>
3. #include <stm32f0xx_gpio.h>
4. //===========================================================================================================
5. GPIO_InitTypeDef GPIO_Init;
6. //===========================================================================================================
7. void delay(int a);
8. //===========================================================================================================
9. int main(void)
10. {
11.   RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);
12.  
13.   GPIO_Init.GPIO_Pin = GPIO_Pin_4;
14.   GPIO_Init.GPIO_Mode = GPIO_Mode_OUT;
15.   GPIO_Init.GPIO_OType = GPIO_OType_PP;
16.   GPIO_Init.GPIO_PuPd = GPIO_PuPd_NOPULL;
17.   GPIO_Init.GPIO_Speed = GPIO_Speed_Level_1;
18.   GPIO_Init(GPIOA, &GPIO_Init);
19.  
20.   while(1)
21.   {
22.       GPIO_SetBits(GPIOA, GPIO_Pin_4);
23.       delay(30000);
24.       GPIO_ResetBits(GPIOA, GPIO_Pin_4);
25.       delay(30000);
26.   }
27. }
28. void delay(int a)
29. {
30.     volatile int i,j;
31.  
32.     for (i=0 ; i < a ; i++) { j++; }
33.     return;
34. }

Układ w obudowie jaką stosuje nie zawiera wiele wyprowadzeń w związku z tym dobrze jest wykorzystywać wewnętrzny oscylator, który włączy się automatycznie. Aby korzystać z pinów od kwarcu to należy wyłączyć wcześniej HSE. Dopiero po tej operacji, można z nich korzystać bez przeszkód.

Program dla UART:

1. #include "stm32f0xx.h"
2. #include <stm32f0xx_rcc.h>
3. #include <stm32f0xx_usart.h>
4. #include <stm32f0xx_gpio.h>
5. #include <stm32f0xx_tim.h>
6. #include <stm32f0xx_exti.h>
7. //===========================================================================================================
8. #define RCC_USART RCC_APB2Periph_USART1
9. #define RCC_GPIOA RCC_AHBPeriph_GPIOA
10.  
11. #define USART_PIN_SOURCE_1 GPIO_PinSource9
12. #define USART_PIN_SOURCE_2 GPIO_PinSource10
13.  
14. #define PIN_1_USART GPIO_Pin_9
15. #define PIN_2_USART GPIO_Pin_10
16. #define USART_LINE GPIOA
17.  
18. #define PIN_1_DIODE GPIO_Pin_4
19. #define DIODE_LINE GPIOA
20. //===========================================================================================================
21. uint8_t buff[20];
22. //===========================================================================================================
23. USART_InitTypeDef USART_InitStructure;
24. GPIO_InitTypeDef GPIO_InitStructure;
25. //===========================================================================================================
26. void init_GPIO_USART(void);
27. //===========================================================================================================
28. void delay(int a);
29. //===========================================================================================================
30. void SEND_NUMBER_UART(uint32_t x);
31. //===========================================================================================================
32. void SendPacket(uint8_t *data, uint16_t length) //Przeslanie ciagu danych
33. //===========================================================================================================
34. uint32_t Send_Byte(uint8_t c)
35. //===========================================================================================================
36. int main (void)
37. {
38.   init_GPIO_USART();
39.  
40.   GPIO_SetBits(DIODE_LINE, PIN_1_DIODE);
41.    
42.   Send_Byte('r');
43.   delay(4000);
44.   SEND_NUMBER_UART(86);
45.  
46.   while(1) { }
47. }
48. //===========================================================================================================
49. void init_GPIO_USART(void)
50. {
51.     RCC_AHBPeriphClockCmd(RCC_GPIOA, ENABLE);
52.     RCC_APB2PeriphClockCmd(RCC_USART,ENABLE);
53.  
54.     GPIO_PinAFConfig(USART_LINE, USART_PIN_SOURCE_1, GPIO_AF_1);
55.     GPIO_PinAFConfig(USART_LINE, USART_PIN_SOURCE_2, GPIO_AF_1);
56.  
57.     GPIO_Init.GPIO_Pin = PIN_1_DIODE;
58.     GPIO_Init.GPIO_Mode = GPIO_Mode_OUT;
59.     GPIO_Init.GPIO_OType = GPIO_OType_PP;
60.     GPIO_Init.GPIO_PuPd = GPIO_PuPd_NOPULL;
61.     GPIO_Init.GPIO_Speed = GPIO_Speed_Level_1;
62.     GPIO_Init(DIODE_LINE, & GPIO_InitStructure);
63.  
64.     GPIO_InitStructure.GPIO_Pin =  PIN_1_USART | PIN_2_USART;
65.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_Level_1;
66.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
67.     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
68.     GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
69.     GPIO_Init(USART_LINE, &GPIO_InitStructure);
70.  
71.     USART_InitStructure.USART_BaudRate = 9600;
72.     USART_InitStructure.USART_WordLength = USART_WordLength_8b;
73.     USART_InitStructure.USART_StopBits = USART_StopBits_1;
74.     USART_InitStructure.USART_Parity = USART_Parity_No;
75.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
76.     USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
77.     USART_Init(USART1, &USART_InitStructure);
78.  
79.     USART_Cmd(USART1,ENABLE);
80. }
81. //===========================================================================================================
82. void delay(int a)
83. {
84.     volatile int i,j;
85.  
86.     for (i=0 ; i < a ; i++) { j++; }
87.     return;
88. }
89. //===========================================================================================================
90. void SEND_NUMBER_UART(uint32_t x)
91. {
92.   char value[10]; //a temp array to hold results of conversion
93.   int i = 0; //loop index
94.  
95.   do
96.   {
97.     value[i++] = (char)(x % 10) + '0'; //convert integer to character
98.     x /= 10;
99.   } while(x);
100.  
101.   while(i) //send data
102.   {
103.     Send_Byte(value[--i]);
104.   }
105. }
106. //===========================================================================================================
107. void SendPacket(uint8_t *data, uint16_t length) //Przeslanie ciagu danych
108. {
109.   uint16_t i;
110.   i = 0;
111.   while (i < length)
112.   {
113.     Send_Byte(data[i]);
114.     i++;
115.   }
116. }
117. //===========================================================================================================
118. uint32_t Send_Byte(uint8_t c)
119. {
120.     while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
121.     USART_SendData(USART1, c);
122.     return 0;
123. }