[stm32] UART 실습

1. 🌏 실습 목표

1. PC - MCU Uart Polling & Interrupt 두가지 방식 문자열 송수신 테스트  
2. PC - MCU Uart 통신 연결을 위한 uart.c 파일 생성

3. Command Line Interface (CLI)의 기능 구현을 위한 cli.c 파일 생성
4. 수행할 동작 led.c, pwm.c 파일 생성

 

2. 🌏 Uart 세팅

여기서 USART는 각종 통신 프로토콜(e.g. UART, SPI, I2C 등..)을 구현하고 서비스하는 포트이지 USART 통신이 아니다.

 

1. UART 세팅

 1.1 Word Length 
 한 번의 데이터 전송에서 사용할 수 있는 비트 수를 설정  8비트이면 0부터 255까지의 값이므로 대부분의 값을 표현할 수
 있으며 더 낮거나 더 높을 경우 호환성, 효율성 등 문제가 발생할 수 있어 8비트를 사용한다.
 1.2 Parity
 전송할 데이터 bit 수가 짝수, 홀수 인지를 맨 끝 비트를 통해 표시하여 수신 시 짝수 홀수 맞는지 확인
 1.3 Data Direction
 해당 MCU로부터 데이터가 흘러가는 방향을 설정하며 송신, 수신, 송/수신 중 하나를 선택한다. 
 1.4 Over Sampling
 송/수신의 정확도를 높이는 데 사용되며 보통 16배를 사용한다.

2. 데이터 시트에 적혀있는 대로 PD8  핀 -> TX 핀으로, PD9 핀 -> RX 핀으로 세팅하였으며
3. USART3 와 System Core NVIC에서 인터럽트 송수신을 위한 Global interrupt를 Enable로 세팅하였음

USART3 송수신 포트 지정

3. 🌏 실습 결과

ㅈhttps://github.com/Tobbyvv/stm32-project/tree/main/uart_cli

3.1. PC - MCU Uart Polling & Interrupt 방식으로 문자열 송수신 테스트

 1.1 Polling 방식 

      

      

      

    
    

      <bash />
    
uint8_t text = 'Hello';
while(1)
{   //1. MCU에서 수신(Receive) 성공 시 발생하는 HAL_OK 신호를 while 문을 통해 무한히 체크
   if(HAL_UART_Receive(&huart3, &text, 1, 10) == HAL_OK){
    //2. 수신 성공 시 받은 메세지를 PC로 송신(Transmit) 
     HAL_UART_Transmit(&huart3, &text, 1, 10);
    }}

 1.2 Interrupt 방식

      

      

      

    
    

      <bash />
    
uint8_t rx_buffer; 

//인터럽트 발생 시 하던 작업을 멈추고 해당 메소드가 실행됨
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{   
   if(huart->Instance==USART3){
        //IT : 비 블로킹(수신 대기 중 동시에 해야할 다른 작업 수행)
      HAL_UART_Receive_IT(&huart3, &rx3_data, 1);  
        //인터럽트(it) 수신 함수, 1byte가 들어올 때마다 확인함
      HAL_UART_Transmit(&huart3, &rx3_data, 1, 10); 
        //들어온 데이터를 1byte 씩 보낸다.
   }}

Polling 방식, 인터럽트 방식 모두 Hello를 보내면 Hello가 출력됨

3.2. PC - MCU Uart 통신을 위한 uart.c 파일 생성

      

      

      

    
    

      <cpp />
    
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <stdbool.h>

#include "main.h"
#include "uart.h"
#include "cli.h"

extern UART_HandleTypeDef huart3;  // UART 통신 핸들러 선언

#define D_BUF_MAX 100  // 데이터를 저장할 버퍼의 최대 크기 정의

// 데이터를 저장할 구조체 정의
typedef struct {
  uint8_t buf[D_BUF_MAX+1];  // 데이터 버퍼 변수
  uint8_t idx;               // 버퍼 인덱스 변수
  uint8_t flag;              // 수신 완료 플래그
} BUF_T;

BUF_T gBufObj[2];  // 두 개의 버퍼 구조체 배열로 선언
static UART_CBF uart_cbf;  // UART 수신 콜백 함수 포인터 선언
uint8_t rxd;  // 수신한 바이트 데이터를 저장할 변수

void uart_init(void)
{
  gBufObj[0].idx = 0;
  gBufObj[0].flag = false;
  // UART 수신 인터럽트 활성화 및 첫 번째 바이트(데아터) 수신 대기
  HAL_UART_Receive_IT(&huart3, (uint8_t *)&rxd, 1);
  printf("UART Initialized...\r\n");
  fflush(stdout);  // printf 후 출력 버퍼 비움
}
// UART 수신 콜백 함수 등록
void uart_regcbf(UART_CBF cbf)
{
  uart_cbf = cbf;  // 전달된 콜백 함수를 uart_cbf에 등록
}
// UART 수신된 데이터 처리 함수
void uart_proc(void)
{
  BUF_T *p = (BUF_T *)&gBufObj[0];
  if (p->flag == true) {
    printf("%s:%s", __func__, p->buf);  // 디버깅용 수신된 데이터 출력
    if (uart_cbf != NULL) uart_cbf(p->buf); // UART 데이터 파싱 함수 호출 (등록된 콜백 함수)
    p->idx = 0;  // 다음 데이터 수신을 위한 버퍼 인덱스 초기화
    p->flag = false;  // 수신 완료 플래그 초기화
  }}
// UART 수신 완료 콜백 함수
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
  if (huart == &huart3) {
    BUF_T *p = (BUF_T *)&gBufObj[0];
    if (p->flag == false) {
      p->buf[p->idx] = rxd;  // 수신한 데이터를 버퍼에 저장
      if (p->idx < D_BUF_MAX) {
        p->idx++;  // 버퍼 인덱스 증가
      }
      if (rxd == '\r' || rxd == '\n') {
        p->buf[p->idx] = '\0';  // 수신 데이터의 끝에 NULL 문자 추가
        p->flag = true;  // 수신 완료 플래그 설정
      }}
    uart_proc();  // 수신된 데이터 처리 함수 호출
    HAL_UART_Receive_IT(&huart3, (uint8_t *)&rxd, 1);  // 다음 수신 대기
  }}
// UART 표준 입출력 함수
int __io_putchar(int ch)
{
  HAL_UART_Transmit(&huart3, (uint8_t *)&ch, 1, 0xffff);  // 문자 전송
  return ch;
}

3.3. Command Line Interface (CLI)의 기능 구현을 위한 cli.c 파일 생성

      

      

      

    
    

      <cpp />
    
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <stdbool.h>
#include <string.h>

#include "main.h"
#include "uart.h"
#include "led.h"
#include "pwm.h"
#include "cli.h"

#define D_DELIMITER	" ,\r\n" //공백, 쉼표, 구분자 정의

// 명령어 처리 함수의 시그니처 정의
typedef int (*CMD_FUNC_T)(int argc, char **argv);

// 명령어와 해당 명령어를 처리할 함수 정보를 저장하는 구조체 정의
typedef struct {
  char *cmd;        // 명령어 문자열
  uint8_t no;       // 명령어 번호 (고유 식별자)
  CMD_FUNC_T cbf;   // 명령어를 처리할 함수 포인터
  char *remark;     // 명령어에 대한 설명 문자열
} CMD_LIST_T;

// 각 명령어에 대한 처리 함수 선언
static int cli_help(int argc, char *argv[]);
static int cli_echo(int argc, char *argv[]);
static int cli_led(int argc, char *argv[]);
static int cli_pwm(int argc, char *argv[]);

// 명령어와 함수 정보를 저장하는 배열 선언 및 초기화
const CMD_LIST_T gCmdListObj[] = {
  { "help",  1, cli_help,  "help" },
  { "echo",  2, cli_echo,  "echo [echo data]" },
  { "led",   3, cli_led,   "led [2/3] [on/off]" },
  { "pwm",   4, cli_pwm,   "pwm [0] [0~100]" },
  { NULL,    0, NULL,      NULL }
};

// help 명령어 처리 함수
static int cli_help(int argc, char *argv[])
{
  // 등록된 모든 명령어에 대한 설명 문자열 출력
  for (int i = 0; gCmdListObj[i].cmd != NULL; i++) {
    printf("%s\r\n", gCmdListObj[i].remark);
  }
  return 0;
}
// echo 명령어 처리 함수
static int cli_echo(int argc, char *argv[])
{
  if (argc < 2) printf("Need more arguments\r\n");
  printf("%s\r\n", argv[1]); // 입력된 데이터 그대로 출력
  return 0;
}

// led 명령어 처리 함수
static int cli_led(int argc, char *argv[])
{
  if (argc < 3) printf("Need more arguments\r\n");
  long no = strtol(argv[1], NULL, 10);  // 문자 -> 숫자 변환
  int onoff = strcasecmp(argv[2], "off"); // off이면 0을 반환
  if (onoff != 0) onoff = 1;              // 0이 아니면 1로 변환						
  led_onoff((uint8_t)no, (uint8_t)onoff);   // LED 제어 함수 호출
  return 0;
}

// pwm 명령어 처리 함수
static int cli_pwm(int argc, char *argv[])
{
  if (argc < 3) printf("Need more arguments\r\n");
  // 문자 -> 숫자 변환
  long no = strtol(argv[1], NULL, 10); 
  long duty = strtol(argv[2], NULL, 10);
  // duty 주기 값이 유효 범위를 벗어난 경우 조정
  if (duty > 100) duty = 100;
  if (duty < 0) duty = 0;
  pwm_dimming((uint8_t)no, (uint8_t)duty);  // PWM 제어 함수 호출
  return 0;
}
// 명령어 문자열 분석, 해당 명령어의 처리 함수 호출을 위한 함수
bool cli_parser(uint8_t *buf)
{
#if 1
  int argc = 0;	// 명령어의 갯수
  char *argv[10]; // 명령어를 저장할 배열
  char *ptr; // 문자열 분리를 위한 포인터 변수

  // 입력된 문자열을 공백 및 구분자로 분리하여 argv 배열에 저장
  ptr = strtok((char *)buf, D_DELIMITER);
  if (ptr == NULL) return false;

  while(ptr != NULL) {
    argv[argc] = ptr;
    argc++;
    ptr = strtok(NULL, D_DELIMITER);
  }

  // 입력된 명령어와 등록된 명령어를 비교하여 해당 명령어의 처리 함수 호출
  for (int i=0; gCmdListObj[i].cmd != NULL; i++) {
    if (strcasecmp(gCmdListObj[i].cmd, argv[0]) == 0) {
      printf("Calling %s function with argc=%d\n", gCmdListObj[i].cmd, argc);
      gCmdListObj[i].cbf(argc, argv);  // 해당 명령어의 처리 함수 호출
      return true;
    }}
  printf("Unsupported command..\r\n"); 

#else
  char *ptr = strtok(buf, " ");    //첫번째 strtok 사용.
  while (ptr != NULL)              //ptr이 NULL일때까지 (strtok 함수가 NULL을 반환할때까지)
  {
      printf("%s\n", ptr);         //자른 문자 출력
      ptr = strtok(NULL, " ");     //자른 문자 다음부터 구분자 또 찾기
  }
  uart_regcbf(cli_parser);  // UART 수신 콜백 함수 등록
#endif
  return true;
}
// CLI 초기화 함수 (UART 수신 콜백 함수 등록)
void cli_init(void)
{
  uart_regcbf(cli_parser);
}

3.4. 수행할 동작 led.c, pwm.c 파일 생성

 4.1 led.c

      

      

      

    
    

      <cpp />
    
#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>

#include "main.h"
#include "led.h"

void led_init(void)
{
  printf("LED initialized...\r\n"); // LED 초기화 메시지 출력
}
//led on/off 함수
bool led_onoff(uint8_t no, uint8_t onoff)
{
  GPIO_PinState sts = onoff ? GPIO_PIN_SET : GPIO_PIN_RESET; 
  switch (no) { // 전달된 값에 따라 LED 상태 설정
    case 2 :
      HAL_GPIO_WritePin(LD2_GPIO_Port, LD2_Pin, sts);
      break;
    case 3 :
      HAL_GPIO_WritePin(LD3_GPIO_Port, LD3_Pin, sts); 
      break;
    default :
      return false;
  }
  return true; // 처리 결과 반환 (성공: true, 실패: false)
}

  4.2 pwm.c

      

      

      

    
    

      <cpp />
    
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#include <stdint.h>

#include "main.h"

extern TIM_HandleTypeDef htim3; // 타이머 핸들러 변수 선언

void pwm_init(void)
{
  printf("Timer3 PWM start\r\n"); 
  HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_3); // TIM3 채널3 PWM 시작
}
// PWM 신호로 밝기 조절하는 함수
bool pwm_dimming(uint8_t no, uint8_t duty)
{
  bool res = true; // 반환용 결과 변수 선언
  uint16_t ccr = (uint16_t)duty * 10; // duty 주기를 타이머의 Compare/Capture 레지스터 값으로 변환
  switch (no) {
    case 0 :
      __HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_3, ccr); 
    // TIM3의 채널 3의 Compare/Capture 레지스터에 ccr 값을 설정하여 밝기 조절
      break;
    default :
      res = false;
  }
  return res; // 처리 결과 반환 (성공: true, 실패: false)
}

4. 🌏 결과 사진

1, help 명령어

help 명령어 전달 결과

2. echo 명령어

echo 명령어 전달 결과

3. led on/off 명령어

led 2 on 명령어 전달 결과

4. pwm duty 변경 명령어

pwm 0 2 명령어 전달 결과(LD1의 세기가 약해짐)