[16] STM32F7 - RS485

Ten bardzo krótki post chciałbym poświęcić na opisanie sposobu komunikacji za pomocą RS485 przygotowanego w oparciu o UART7 na płytce STM32F7 - Discovery. Komunikacja będzie wykonana za pomocą układu ST3485EB. 

Wykorzystywane będą trzy linie, jedna nadająca, druga odbierająca, trzecia będzie służyła do wyboru trybu pracy, tzn czy będzie występowało nadanie czy odbieranie.

Wysyłanie i odbieranie danych będzie przebiegać w standardowy sposób. Jedyna różnica jaka dochodzi to sterowanie pinem określającym kierunek przepływu danych. Domyślnie aby układ mógł odebrać dane to ten pin musi być utrzymywany w stanie niskim. Aby wysłać dane do układu to należy ustawić go w stan wysoki, a potem zaraz po ich wysłaniu zmienić stan na niski.

CubeMx:

Tutaj wprowadzane będą podstawowe ustawienia, jeden pin będzie wykorzystywany jako wyjściowy, na którym będzie wykonywane sterowanie (użyłem dowolnego pinu do sterowania). Do tego celu posłużyłem się pinem GPIOF 10.

Drugą rzeczą do włączenia jest UART (ja wykorzystałem UART7, można użyć dowolnego). Wprowadzam go w standardowe ustawienia(Baud rate: 115200, Data bits: 8, Parity: none, Stop Bits 1. Handshaking: none).

Program:

Program jest dosyć prosty. Jeśli nie wykonywało się inicjalizacji za pomocą CubeMx to procedura ustawienia UART-a wygląda następująco:

1. void Initialization_Uart7(uint32_t baudRate)
2. {
3.     GPIO_InitTypeDef gpio_init_structure;
5.     PORT_CLOCK_ENABLE(USART7_GPIOF);
6.     Uart_Usart_Initialize_Clock(UART7);
8.     __HAL_RCC_UART7_CLK_ENABLE();
9.     __HAL_RCC_UART7_FORCE_RESET();
10.     __HAL_RCC_UART7_RELEASE_RESET();
12.     gpio_init_structure.Pin         = USART7_TX2;
13.     gpio_init_structure.Mode        = GPIO_MODE_AF_PP;
14.     gpio_init_structure.Speed       = GPIO_SPEED_FAST;
15.     gpio_init_structure.Pull        = GPIO_PULLUP;
16.     gpio_init_structure.Alternate   = GPIO_AF8_UART7;
17.     HAL_GPIO_Init(USART7_GPIOF, &gpio_init_structure);
19.     // GPIO RX
20.     gpio_init_structure.Pin         = USART7_RX2;
21.     gpio_init_structure.Mode        = GPIO_MODE_AF_PP;
22.     gpio_init_structure.Pull        = GPIO_PULLUP;
23.     gpio_init_structure.Alternate   = GPIO_AF8_UART7;
24.     HAL_GPIO_Init(USART7_GPIOF, &gpio_init_structure);
26.     #if UART_7_RS485==1
28.     /* Define initialize communication pin for RS485 */
29.     PORT_CLOCK_ENABLE(GPIOF);
30.     gpio_init_structure.Pin = GPIO_PIN_10;
31.     gpio_init_structure.Mode = GPIO_MODE_OUTPUT_PP;
32.     gpio_init_structure.Pull = GPIO_NOPULL;
33.     gpio_init_structure.Speed = GPIO_SPEED_HIGH;
34.     HAL_GPIO_Init(GPIOF, &gpio_init_structure);
35.     RS485_LOW_REC_DATA();
37.     #endif
39.     UART_Handle7.Instance                       = UART7;
40.     UART_Handle7.Init.BaudRate                  = USART7_BAUD;
41.     UART_Handle7.Init.WordLength                = UART_WORDLENGTH_8B;
42.     UART_Handle7.Init.StopBits                  = UART_STOPBITS_1;
43.     UART_Handle7.Init.Parity                    = UART_PARITY_NONE;
44.     UART_Handle7.Init.HwFlowCtl                 = UART_HWCONTROL_NONE;
45.     UART_Handle7.Init.Mode                      = UART_MODE_TX_RX;
46.     UART_Handle7.Init.OverSampling              = UART_OVERSAMPLING_8;
47.     UART_Handle7.Init.OneBitSampling            = UART_ONEBIT_SAMPLING_DISABLED;
48.     UART_Handle7.AdvancedInit.AdvFeatureInit    = UART_ADVFEATURE_NO_INIT;
50.     HAL_UART_Init(&UART_Handle7);
52.     HAL_NVIC_DisableIRQ(UART7_IRQn);
53.     HAL_NVIC_SetPriority(UART7_IRQn, 0, 1);
54.     HAL_NVIC_EnableIRQ(UART7_IRQn);
55.     HAL_NVIC_ClearPendingIRQ(UART7_IRQn);
57.     __HAL_UART_ENABLE_IT(&UART_Handle7, UART_IT_RXNE);
59.     UART7->CR1 |= USART_CR1_RXNEIE;
60. }

Przesyłanie danych wygląda następująco:

1. void Usart_Uart_SendString(USART_TypeDef* USARTx, char *ptr, UART_BYTEEND_t last_char)
2. {
3.   uint16_t length = 0;
5.   /* check data length */
6.   while (ptr[length] != '\0')   {   length++;   }
8.   if(USARTx == UART7) {
9.       #if UART_7_RS485==1
10.       RS485_HIGH_SEND_DATA();
11.       HAL_Delay(2);
12.       #endif
14.       for(uint8_t i = 0; i<length; i++) {
15.           Usart_Uart_SendByte(USARTx, ptr[i]);
16.       }
17.   }
19.   /* Send last line */
20.   if(last_char==LF_CR){
21.       Usart_Uart_SendByte(USARTx, d_LINEFEED);
22.       Usart_Uart_SendByte(USARTx, d_CARIAGERETURN);
23.   }
24.   else if(last_char==CR_LF){
25.       Usart_Uart_SendByte(USARTx, d_CARIAGERETURN);
26.       Usart_Uart_SendByte(USARTx, d_LINEFEED);
27.   }
28.   else if(last_char==LF_){
29.       Usart_Uart_SendByte(USARTx, d_LINEFEED);
30.   }
31.   else if(last_char==CR_){
32.       Usart_Uart_SendByte(USARTx, d_CARIAGERETURN);
33.   }
35.   #if UART_7_RS485==1
36.   HAL_Delay(5);
37.   RS485_LOW_REC_DATA();
38.   #endif
39. }

Funkcja wysyłająca dane do układu po jednym bajcie:

1. static inline void Usart_Uart_SendByte(USART_TypeDef* USARTx, volatile char c)
2. {
3.     if ((USARTx->CR1 & USART_CR1_UE))
4.     {
5.         while (!((USARTx)->ISR & USART_FLAG_TXE));
6.         /* Send data */
7.         (USARTx)->TDR = (uint16_t)(c & 0x01FF);
8.         while (!((USARTx)->ISR & USART_FLAG_TXE));
9.     }
10. }

Obsługa przerwania wygląda następująco:

1. void UART7_IRQHandler(void)
2. {
3.     static uint8_t dane;
5.     //Sprawdzenie czy przerwanie wywolane przez odebranie danych
6.     if (UART7->ISR & USART_ISR_RXNE){
7.         dane = ((UART7)->RDR);
9.         /* All data go to USART1*/
10.         Usart_Uart_SendByte(USART1, dane);
11.     }
13.     // Clear all USART flags
14.     #ifdef __HAL_UART_CLEAR_PEFLAG
15.         __HAL_UART_CLEAR_PEFLAG(&UART_Handle7);
16.     #endif
17.     #ifdef __HAL_UART_CLEAR_FEFLAG
18.         __HAL_UART_CLEAR_FEFLAG(&UART_Handle7);
19.     #endif
20.     #ifdef __HAL_UART_CLEAR_NEFLAG
21.         __HAL_UART_CLEAR_NEFLAG(&UART_Handle7);
22.     #endif
23.     #ifdef __HAL_UART_CLEAR_OREFLAG
24.         __HAL_UART_CLEAR_OREFLAG(&UART_Handle7);
25.     #endif
26.     #ifdef __HAL_UART_CLEAR_IDLEFLAG
27.         __HAL_UART_CLEAR_IDLEFLAG(&UART_Handle7);
28.     #endif
29.         HAL_NVIC_ClearPendingIRQ(UART7_IRQn);
30. }

Dane odebrane wypisywane są na USART1.