[5a] STM32F4 - Discovery - CubeMx - USART, komunikacja z komputera na mikrokontroler

Ten post będzie kontynuacją wcześniejszego, dotyczącego komunikacji poprzez USART. Tym razem przedstawię odwrotny sposób transmisji czyli od komputera do mikrokontrolera.

Program

Na samym początku po włączeniu zegarów w programie CubeMx, należy włączyć obsługę USART2 w trybie asynchronicznym, po czym uruchomić przerwania NVIC dla niego.



Wygenerowana funkcja dla ustawienia taktowania zegara oraz uruchomienia USART-u wygląda następująco:

1. /** System Clock Configuration
2. */
3. void SystemClock_Config(void)
4. {
6.   RCC_OscInitTypeDef RCC_OscInitStruct;
7.   RCC_ClkInitTypeDef RCC_ClkInitStruct;
9.   __PWR_CLK_ENABLE();
11.   __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
13.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
14.   RCC_OscInitStruct.HSEState = RCC_HSE_ON;
15.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
16.   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
17.   RCC_OscInitStruct.PLL.PLLM = 8;
18.   RCC_OscInitStruct.PLL.PLLN = 336;
19.   RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
20.   RCC_OscInitStruct.PLL.PLLQ = 4;
21.   HAL_RCC_OscConfig(&RCC_OscInitStruct);
23.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
24.                               |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
25.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
26.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
27.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
28.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
29.   HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5);
31.   HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000);
33.   HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);
35.   /* SysTick_IRQn interrupt configuration */
36.   HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
37. }
38. /* USART2 init function */
39. void MX_USART2_UART_Init(void)
40. {
41.   huart2.Instance = USART2;
42.   huart2.Init.BaudRate = 9600;
43.   huart2.Init.WordLength = UART_WORDLENGTH_8B;
44.   huart2.Init.StopBits = UART_STOPBITS_1;
45.   huart2.Init.Parity = UART_PARITY_NONE;
46.   huart2.Init.Mode = UART_MODE_TX_RX;
47.   huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
48.   huart2.Init.OverSampling = UART_OVERSAMPLING_16;
49.   HAL_UART_Init(&huart2);
50. }

Następnie jeśli projekt był robiony nie na modelu płytki STM32F4 - Discovery, tylko na zwykłym mikrokontrolerze to należy uruchomić dodatkowo wszystkie diody wbudowane.

1. void MX_GPIO_Init(void)
2. {
3.   GPIO_InitTypeDef GPIO_InitStruct;
5.   /* GPIO Ports Clock Enable */
6.   __GPIOH_CLK_ENABLE();
7.   __GPIOA_CLK_ENABLE();
8.   __GPIOD_CLK_ENABLE();
10.   /*Configure GPIO pin Output Level */
11.   HAL_GPIO_WritePin(GPIOD, GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15, GPIO_PIN_RESET);
13.   /*Configure GPIO pins : PD12 PD13 PD14 PD15 */
14.   GPIO_InitStruct.Pin = GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15;
15.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
16.   GPIO_InitStruct.Pull = GPIO_NOPULL;
17.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
18.   HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
19. }

Kolejnym etapem jest przygotowanie funkcji obsługujące odebrane dane oraz zdeklarowanie zmiennej globalnej przechowujące zdeklarowane dane.

Zdeklarowana zmienna:

2. volatile uint8_t Odebrane;

Funkcja działająca:

1. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
2. {
3.     uint8_t Wyswietl[30];
4.     uint16_t rozmiar = 0;
5.    
6.     //Odebranie znaku i sprawdzenie czy odpowiada znakom ponizej
7.     switch(Odebrane)
8.     {
9.     case '0':
10.     {
11.         rozmiar = sprintf(Wyswietl, "Wylaczenie wszystkich diod\n\r");
12.       HAL_GPIO_WritePin(GPIOD, GPIO_PIN_12, GPIO_PIN_RESET);
13.         HAL_GPIO_WritePin(GPIOD, GPIO_PIN_13, GPIO_PIN_RESET);
14.       HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_RESET);
15.       HAL_GPIO_WritePin(GPIOD, GPIO_PIN_15, GPIO_PIN_RESET);
16.         break;
17.     }
18.     case '1':
19.     {
20.         rozmiar = sprintf(Wyswietl, "Swieci dioda zielona: \n\r");
21.         HAL_GPIO_WritePin(GPIOD, GPIO_PIN_12, GPIO_PIN_SET);
22.         break;
23.     }
24.    
25.     case '2':
26.     {
27.         rozmiar = sprintf(Wyswietl, "Swieci dioda pomaranczowa: \n\r");
28.         HAL_GPIO_WritePin(GPIOD, GPIO_PIN_13, GPIO_PIN_SET);
29.         break;
30.     }
32.     case '3':
33.     {
34.         rozmiar = sprintf(Wyswietl, "Swieci dioda czerwona: \n\r");
35.         HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14, GPIO_PIN_SET);
36.         break;
37.     }
38.        
39.     case '4':
40.     {
41.         rozmiar = sprintf(Wyswietl, "Swieci dioda niebieska: \n\r");
42.         HAL_GPIO_WritePin(GPIOD, GPIO_PIN_15, GPIO_PIN_SET);
43.         break;
44.     }
45.    
46.     default:
47.     {
48.         rozmiar = sprintf(Wyswietl, "Odebrano zly znak: '%c'\n\r", Odebrane);
49.         break;
50.     }
51.     }
52.    
53.     //Wyslanie danych
54.     HAL_UART_Transmit_IT(&huart2, Wyswietl, rozmiar); 
55.     //Czekanie na odebranie danych
56.     HAL_UART_Receive_IT(&huart2, &Odebrane, 1);
57. }

Następnie należy wprowadzić wywołanie funkcji odbierającej pojedynczy znak w funkcji main().

2. HAL_UART_Receive_IT(&huart2, &Odebrane, 1);

Poniżej okno programu terminal:

Rys. 1. Okno programu terminal

Drugi program będzie przedstawiał w jaki sposób dokonać zapisu całego ciągu znaków. Dane wysłane z komputera będą ponownie wysyłane z mikrokontrolera do komputera.

Aby komunikacja przeszła bezproblemowo należy zdefiniować tablice przechowującą przesłane znaki.

2. uint8_t Odebrane[5];

1. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
2. {
3.     uint8_t Wyswietl[20];
4.     uint16_t rozmiar = 0;
5.    
6.     rozmiar = sprintf(Wyswietl, "Dane: %s",Odebrane);
7.    
8.     //Wyslanie danych
9.     HAL_UART_Transmit_IT(&huart2, Wyswietl, rozmiar);
10.     //Czekanie na odebranie danych
11.     HAL_UART_Receive_IT(&huart2, Odebrane, 5);
12. }

1.    
2. HAL_UART_Receive_IT(&huart2, Odebrane, 5);