MENU
  1. ホーム
  2. C 언어
  3. C언어로 구현하는 임베디드 리눅스의 UART 시리얼 통신 방법

C언어로 구현하는 임베디드 리눅스의 UART 시리얼 통신 방법

C 언어

UART(Universal Asynchronous Receiver/Transmitter)는 데이터를 직렬 방식으로 송수신하는 비동기 통신 프로토콜입니다. 임베디드 시스템에서 UART는 간단한 하드웨어 연결과 신뢰성 높은 통신으로 널리 활용되며, 센서 데이터 전송, 장치 간 데이터 교환, 디버깅 용도 등 다양한 응용 분야에서 핵심적인 역할을 합니다. 본 기사에서는 C언어를 사용해 임베디드 리눅스 환경에서 UART 통신을 설정하고 구현하는 방법을 단계별로 설명합니다.

목차
  1. UART 통신이란 무엇인가
    1. UART의 동작 원리
    2. UART의 주요 특징
  2. 임베디드 리눅스에서의 UART 활용
    1. 임베디드 리눅스에서 UART의 역할
    2. UART의 일반적인 응용 사례
    3. 임베디드 리눅스에서 UART 활용 시의 장점
  3. UART 설정: 필수 요소
    1. UART 설정의 주요 매개변수
    2. UART 설정 방법
    3. 설정 시 주의사항
  4. C언어로 UART 초기화 코드 작성하기
    1. UART 초기화를 위한 단계
    2. 초기화 코드
    3. 코드 설명
    4. 초기화 테스트
    5. 결론
  5. 데이터 송수신 구현
    1. UART 데이터를 송수신하는 방법
    2. 데이터 송신 코드
    3. 데이터 수신 코드
    4. 통합 테스트 코드
    5. 코드 설명
    6. 주의사항
  6. 오류 처리와 디버깅
    1. UART 통신에서 발생할 수 있는 주요 오류
    2. 오류 처리 방법
    3. 디버깅 기법
    4. 사례별 문제 해결
    5. 결론
  7. 실제 응용 예제: 센서 데이터 수집
    1. UART를 활용한 센서 데이터 수집 개요
    2. 사용된 하드웨어 및 환경
    3. 전체 구현 흐름
    4. UART 센서 데이터 수집 코드
    5. 코드 설명
    6. 결과 예시
    7. 확장 아이디어
    8. 결론
  8. 고급 기능: DMA를 이용한 UART
    1. DMA(Direct Memory Access)란 무엇인가
    2. DMA를 활용한 UART의 장점
    3. DMA를 활용한 UART 구성
    4. 코드 예제: DMA를 활용한 UART 송수신
    5. 코드 설명
    6. 고급 사용 사례
    7. 결론
  9. 요약

UART 통신이란 무엇인가


UART(Universal Asynchronous Receiver/Transmitter)는 직렬 통신 방식을 통해 데이터를 송수신하는 하드웨어 모듈입니다. 이 방식은 비동기적으로 작동하며, 송신자와 수신자가 동일한 전송 속도(보드레이트)로 데이터를 교환합니다.

UART의 동작 원리


UART는 데이터를 직렬 형태로 전송하며, 이를 위해 시작 비트(Start Bit), 데이터 비트(Data Bits), 패리티 비트(Parity Bit), 스톱 비트(Stop Bit)를 사용합니다.

  • 시작 비트: 데이터 전송의 시작을 알림.
  • 데이터 비트: 전송할 실제 데이터(일반적으로 8비트).
  • 패리티 비트: 오류 검출용으로 선택적 사용.
  • 스톱 비트: 데이터 전송의 종료를 표시.

UART의 주요 특징

  • 단순성: 별도의 클럭 신호 없이 동작.
  • 호환성: 다양한 마이크로컨트롤러와 주변 장치에서 지원.
  • 비동기 통신: 송신과 수신이 독립적으로 작동.
  • 저렴한 하드웨어 요구사항: 최소한의 핀과 회로로 구현 가능.

UART는 임베디드 시스템에서 디버깅, 센서 데이터 전송, 기기 간 통신 등 다양한 응용 사례에서 사용됩니다. 이 기술의 이해는 임베디드 시스템 개발에 필수적입니다.

임베디드 리눅스에서의 UART 활용

임베디드 리눅스에서 UART의 역할


임베디드 리눅스는 다양한 주변 장치와 통신하기 위해 UART를 자주 사용합니다. UART는 소형화된 하드웨어 환경에서 신뢰성 있는 데이터 전송을 보장하며, 다음과 같은 역할을 수행합니다.

  • 디버깅 및 로그 출력: UART를 통해 시스템 로그나 디버깅 정보를 출력.
  • 장치 간 데이터 교환: 센서, 액추에이터, 모듈 등과 통신.
  • 펌웨어 업데이트: UART를 이용해 시스템 펌웨어를 업로드.

UART의 일반적인 응용 사례

  1. 센서 데이터 수집: UART를 통해 센서에서 데이터를 읽고 처리.
  2. 무선 모듈 통신: GSM, GPS, Bluetooth 모듈과 UART로 통신.
  3. 산업용 기기 통합: PLC, 로봇 팔, 기타 산업 장비와 데이터 교환.
  4. 터미널 연결: 임베디드 장치의 콘솔에 접근해 명령 실행.

임베디드 리눅스에서 UART 활용 시의 장점

  • 유연성: 다양한 기기와 쉽게 연결 가능.
  • 표준화된 인터페이스: 소프트웨어와 하드웨어 모두에서 지원.
  • 간단한 설정: 보드레이트와 통신 매개변수만으로 초기화 가능.

UART는 임베디드 리눅스에서 다른 통신 방식보다 간단하고 범용적인 옵션을 제공하여 많은 프로젝트에서 기본 통신 수단으로 사용됩니다.

UART 설정: 필수 요소

UART 설정의 주요 매개변수


UART 통신을 설정할 때는 다음과 같은 매개변수를 고려해야 합니다.

  • 보드레이트 (Baud Rate)
    데이터를 초당 전송하는 속도로, 송신자와 수신자가 동일한 속도로 설정되어야 합니다. 예: 9600, 115200.
  • 데이터 비트 (Data Bits)
    한 번에 전송되는 데이터의 비트 수로, 일반적으로 8비트(1바이트)가 사용됩니다.
  • 패리티 비트 (Parity Bit)
    데이터 전송의 오류를 검출하기 위한 비트로, 사용 여부를 선택할 수 있습니다. (예: None, Even, Odd)
  • 스톱 비트 (Stop Bit)
    데이터 프레임의 종료를 나타내는 비트로, 일반적으로 1비트 또는 2비트가 사용됩니다.

UART 설정 방법


임베디드 리눅스에서 UART 설정은 주로 termios 라이브러리를 통해 이루어집니다.

  1. UART 디바이스 파일 열기
    UART 디바이스는 일반적으로 /dev/ttyS0, /dev/ttyUSB0와 같은 파일로 나타납니다.
   int uart_fd = open("/dev/ttyS0", O_RDWR | O_NOCTTY);
   if (uart_fd < 0) {
       perror("Failed to open UART device");
       return -1;
   }
  1. 보드레이트 및 매개변수 설정
    보드레이트를 포함한 통신 설정은 termios 구조체로 설정합니다.
   struct termios options;
   tcgetattr(uart_fd, &options); // 현재 설정 읽기
   cfsetispeed(&options, B115200); // 입력 보드레이트
   cfsetospeed(&options, B115200); // 출력 보드레이트
   options.c_cflag |= (CLOCAL | CREAD); // 로컬 연결 및 수신 활성화
   options.c_cflag &= ~PARENB; // 패리티 비트 없음
   options.c_cflag &= ~CSTOPB; // 스톱 비트 1
   options.c_cflag &= ~CSIZE; 
   options.c_cflag |= CS8; // 데이터 비트 8
   tcsetattr(uart_fd, TCSANOW, &options); // 설정 적용
  1. 읽기 및 쓰기 모드 설정
    UART의 입력/출력을 비차단 모드 또는 차단 모드로 설정할 수 있습니다.

설정 시 주의사항

  • 송신자와 수신자는 동일한 설정을 사용해야 정상적으로 통신 가능합니다.
  • 잘못된 보드레이트나 설정 값은 데이터 손실이나 전송 오류를 유발할 수 있습니다.
  • 하드웨어 연결 상태도 반드시 확인해야 합니다.

UART 설정은 통신의 신뢰성을 보장하는 핵심 단계로, 프로젝트 요구사항에 맞게 정확히 구성해야 합니다.

C언어로 UART 초기화 코드 작성하기

UART 초기화를 위한 단계


UART를 초기화하려면 디바이스 파일을 열고, termios를 사용해 통신 설정을 구성해야 합니다. 다음은 UART 초기화 코드를 단계별로 설명합니다.

초기화 코드

#include <stdio.h>
#include <fcntl.h>
#include <termios.h>
#include <unistd.h>

int initialize_uart(const char *device, int baudrate) {
    // UART 디바이스 파일 열기
    int uart_fd = open(device, O_RDWR | O_NOCTTY | O_NDELAY);
    if (uart_fd == -1) {
        perror("Failed to open UART device");
        return -1;
    }

    // UART 설정 읽기
    struct termios options;
    if (tcgetattr(uart_fd, &options) < 0) {
        perror("Failed to get UART attributes");
        close(uart_fd);
        return -1;
    }

    // 보드레이트 설정
    speed_t baud;
    switch (baudrate) {
        case 9600: baud = B9600; break;
        case 19200: baud = B19200; break;
        case 115200: baud = B115200; break;
        default:
            fprintf(stderr, "Unsupported baud rate\n");
            close(uart_fd);
            return -1;
    }
    cfsetispeed(&options, baud);
    cfsetospeed(&options, baud);

    // 데이터 비트, 패리티, 스톱 비트 설정
    options.c_cflag &= ~PARENB; // 패리티 없음
    options.c_cflag &= ~CSTOPB; // 스톱 비트 1
    options.c_cflag &= ~CSIZE;
    options.c_cflag |= CS8; // 데이터 비트 8

    // 로컬 연결 및 데이터 수신 활성화
    options.c_cflag |= (CLOCAL | CREAD);

    // 로우 모드 설정
    options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); // Raw 입력
    options.c_oflag &= ~OPOST; // Raw 출력

    // 설정 적용
    if (tcsetattr(uart_fd, TCSANOW, &options) < 0) {
        perror("Failed to set UART attributes");
        close(uart_fd);
        return -1;
    }

    // 비차단 모드 설정
    fcntl(uart_fd, F_SETFL, FNDELAY);

    return uart_fd;
}

코드 설명

  1. open 함수: UART 디바이스 파일을 엽니다. O_RDWR로 읽기와 쓰기를 모두 활성화하고, O_NOCTTY로 이 디바이스가 제어 터미널이 되지 않도록 설정합니다.
  2. termios 구조체: UART 설정을 구성하기 위한 구조체입니다.
  3. 보드레이트 설정: cfsetispeed, cfsetospeed를 사용해 입력 및 출력 보드레이트를 설정합니다.
  4. Raw 모드 설정: 데이터를 가공하지 않고 그대로 전달하기 위해 Raw 모드를 활성화합니다.
  5. 비차단 모드 설정: fcntl을 사용해 UART 디바이스를 비차단 모드로 설정합니다.

초기화 테스트

int main() {
    int uart_fd = initialize_uart("/dev/ttyS0", 9600);
    if (uart_fd < 0) {
        printf("UART initialization failed\n");
        return -1;
    }

    printf("UART initialized successfully\n");
    close(uart_fd);
    return 0;
}

결론


위 코드는 UART 초기화를 위해 필요한 모든 주요 설정을 포함하고 있습니다. 프로젝트 요구사항에 따라 보드레이트나 통신 매개변수를 조정해 사용할 수 있습니다. UART 초기화는 통신의 안정성을 보장하는 중요한 단계입니다.

데이터 송수신 구현

UART 데이터를 송수신하는 방법


C언어를 사용하여 UART를 통해 데이터를 송수신하려면 write 함수와 read 함수를 활용합니다. 이를 통해 데이터를 전송하거나 수신할 수 있으며, 비차단 모드에서는 읽기와 쓰기가 대기 없이 수행됩니다.

데이터 송신 코드


UART를 통해 데이터를 송신하려면 write를 사용합니다.

#include <stdio.h>
#include <unistd.h>
#include <string.h>

int send_data(int uart_fd, const char *data) {
    int length = strlen(data); // 전송할 데이터 길이 계산
    int bytes_written = write(uart_fd, data, length); // 데이터 전송

    if (bytes_written < 0) {
        perror("Failed to send data");
        return -1;
    }

    printf("Sent %d bytes: %s\n", bytes_written, data);
    return bytes_written;
}

데이터 수신 코드


UART에서 데이터를 수신하려면 read를 사용합니다.

#include <stdio.h>
#include <unistd.h>

int receive_data(int uart_fd, char *buffer, int buffer_size) {
    int bytes_read = read(uart_fd, buffer, buffer_size - 1); // 데이터 읽기

    if (bytes_read < 0) {
        perror("Failed to receive data");
        return -1;
    }

    buffer[bytes_read] = '\0'; // 문자열 끝에 NULL 문자 추가
    printf("Received %d bytes: %s\n", bytes_read, buffer);
    return bytes_read;
}

통합 테스트 코드


다음은 데이터를 송수신하는 통합 예제입니다.

#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>

#define BUFFER_SIZE 256

int main() {
    // UART 초기화
    int uart_fd = open("/dev/ttyS0", O_RDWR | O_NOCTTY | O_NDELAY);
    if (uart_fd < 0) {
        perror("Failed to open UART device");
        return -1;
    }

    char send_buffer[] = "Hello, UART!";
    char receive_buffer[BUFFER_SIZE];

    // 데이터 송신
    if (send_data(uart_fd, send_buffer) < 0) {
        close(uart_fd);
        return -1;
    }

    // 데이터 수신
    usleep(100000); // 대기 (필요 시 조정)
    if (receive_data(uart_fd, receive_buffer, BUFFER_SIZE) < 0) {
        close(uart_fd);
        return -1;
    }

    close(uart_fd);
    return 0;
}

코드 설명

  1. write 함수: 데이터를 송신하며, 전송한 바이트 수를 반환합니다.
  2. read 함수: 데이터를 수신하며, 읽어들인 바이트 수를 반환합니다.
  3. 버퍼 관리: 수신된 데이터를 저장할 충분한 크기의 버퍼를 설정해야 합니다.
  4. 타이밍: 송신 및 수신 간의 적절한 타이밍을 유지해야 데이터 손실을 방지할 수 있습니다.

주의사항

  • 버퍼 크기: 수신 버퍼가 충분히 커야 데이터가 손실되지 않습니다.
  • 타이밍 문제: 비동기 통신에서는 타이밍에 따라 데이터가 손실될 수 있으므로 적절한 대기를 삽입해야 합니다.
  • 오류 처리: 읽기 또는 쓰기 중 오류를 확인하고 적절히 처리해야 합니다.

위 코드를 통해 UART 데이터 송수신을 안정적으로 구현할 수 있습니다. 이를 확장해 센서 데이터 전송, 로그 기록 등 다양한 응용에 활용할 수 있습니다.

오류 처리와 디버깅

UART 통신에서 발생할 수 있는 주요 오류


UART 통신은 신뢰성이 높지만, 설정 오류나 하드웨어 문제로 인해 다양한 문제가 발생할 수 있습니다. 주요 오류는 다음과 같습니다.

  1. 보드레이트 불일치
    송신자와 수신자의 보드레이트가 다르면 데이터가 손상되거나 읽히지 않습니다.
  2. 패리티 오류
    패리티 비트 설정이 일치하지 않으면 데이터 무결성이 깨질 수 있습니다.
  3. 버퍼 오버플로우
    수신 버퍼가 가득 차면 새로운 데이터가 손실됩니다.
  4. 노이즈에 의한 데이터 손상
    하드웨어 연결 상태가 불안정하거나 전기적 노이즈가 발생하면 데이터가 손상될 수 있습니다.
  5. 파일 디스크립터 오류
    UART 디바이스 파일이 잘못 열리거나 닫히지 않은 경우 통신이 실패합니다.

오류 처리 방법

  1. 보드레이트 및 설정 확인
    송신자와 수신자의 보드레이트, 데이터 비트, 패리티, 스톱 비트 설정이 일치하는지 확인합니다.
   if (cfgetispeed(&options) != cfgetospeed(&options)) {
       fprintf(stderr, "Input and output baud rates do not match\n");
   }
  1. 수신 버퍼 비우기
    데이터를 읽기 전에 수신 버퍼를 비워 이전 데이터가 남아 있지 않도록 처리합니다.
   tcflush(uart_fd, TCIFLUSH); // 수신 버퍼 비우기
  1. 오류 반환값 확인
    read와 write 함수의 반환값을 확인해 오류를 즉시 감지하고 대응합니다.
   if (bytes_written < 0) {
       perror("Write error");
   }
   if (bytes_read < 0) {
       perror("Read error");
   }
  1. 연결 상태 점검
    하드웨어 연결 상태를 점검하고, 결함이 있는 케이블이나 핀의 접촉 문제를 해결합니다.

디버깅 기법

  1. UART 통신 분석 도구 사용
    로직 분석기나 시리얼 모니터를 활용해 송수신되는 데이터를 캡처하고 분석합니다.
  2. 로그 출력
    통신 과정에서 주요 데이터를 출력해 문제가 발생한 지점을 추적합니다.
   printf("Sent data: %s\n", send_buffer);
   printf("Received data: %s\n", receive_buffer);
  1. 시스템 로그 확인
    Linux 시스템 로그에서 UART 디바이스 관련 오류 메시지를 확인합니다.
   dmesg | grep tty
  1. 통신 테스트 코드 작성
    최소한의 설정으로 데이터를 송수신하는 간단한 코드를 작성해 기본 통신이 정상적으로 작동하는지 테스트합니다.

사례별 문제 해결

  • 데이터가 손상됨: 보드레이트와 패리티 설정을 점검하고, 노이즈 방지용 필터를 추가합니다.
  • 데이터가 전송되지 않음: 파일 디스크립터가 올바르게 열렸는지 확인합니다.
  • 수신 데이터가 누락됨: 버퍼 크기를 조정하거나 DMA(Direct Memory Access) 방식으로 전환합니다.

결론


UART 통신에서 오류를 처리하고 디버깅하는 것은 안정적이고 신뢰성 있는 시스템 구축의 핵심입니다. 적절한 설정과 문제 해결 기법을 통해 효율적인 통신을 구현할 수 있습니다.

실제 응용 예제: 센서 데이터 수집

UART를 활용한 센서 데이터 수집 개요


UART는 센서와 마이크로컨트롤러 또는 임베디드 시스템 간의 데이터 교환에 널리 사용됩니다. 이 예제에서는 임베디드 리눅스에서 UART를 통해 온도 센서 데이터를 수집하고 출력하는 과정을 설명합니다.

사용된 하드웨어 및 환경

  • 센서: UART 인터페이스를 지원하는 온도 센서(예: DHT22 또는 유사 장치).
  • 임베디드 시스템: Raspberry Pi 또는 BeagleBone과 같은 플랫폼.
  • UART 포트: /dev/ttyS0.

전체 구현 흐름

  1. UART 디바이스 초기화.
  2. 센서 명령 전송.
  3. 센서 데이터 수신 및 파싱.
  4. 데이터를 출력하거나 저장.

UART 센서 데이터 수집 코드

#include <stdio.h>
#include <fcntl.h>
#include <termios.h>
#include <unistd.h>
#include <string.h>

#define BUFFER_SIZE 128

// UART 초기화 함수
int initialize_uart(const char *device, int baudrate) {
    int uart_fd = open(device, O_RDWR | O_NOCTTY | O_NDELAY);
    if (uart_fd < 0) {
        perror("Failed to open UART device");
        return -1;
    }

    struct termios options;
    tcgetattr(uart_fd, &options);
    cfsetispeed(&options, B9600); // 센서 보드레이트에 맞춤
    cfsetospeed(&options, B9600);

    options.c_cflag &= ~PARENB; // 패리티 없음
    options.c_cflag &= ~CSTOPB; // 스톱 비트 1
    options.c_cflag &= ~CSIZE;
    options.c_cflag |= CS8;     // 데이터 비트 8
    options.c_cflag |= (CLOCAL | CREAD); // 로컬 연결 및 데이터 읽기 활성화

    tcsetattr(uart_fd, TCSANOW, &options);
    return uart_fd;
}

// 센서 데이터 요청 및 수신 함수
void collect_sensor_data(int uart_fd) {
    char send_command[] = "GET_TEMP\n"; // 센서 명령
    char receive_buffer[BUFFER_SIZE];
    int bytes_written, bytes_read;

    // 센서 명령 전송
    bytes_written = write(uart_fd, send_command, strlen(send_command));
    if (bytes_written < 0) {
        perror("Failed to send command to sensor");
        return;
    }

    // 데이터 수신
    usleep(100000); // 센서 응답 대기
    bytes_read = read(uart_fd, receive_buffer, BUFFER_SIZE - 1);
    if (bytes_read < 0) {
        perror("Failed to receive data from sensor");
        return;
    }

    receive_buffer[bytes_read] = '\0'; // 문자열 종료
    printf("Sensor Data: %s\n", receive_buffer);
}

int main() {
    const char *device = "/dev/ttyS0";
    int uart_fd = initialize_uart(device, 9600);
    if (uart_fd < 0) {
        return -1;
    }

    // 센서 데이터 수집
    collect_sensor_data(uart_fd);

    close(uart_fd);
    return 0;
}

코드 설명

  1. UART 초기화
    initialize_uart 함수는 센서 보드레이트(9600bps)에 맞게 UART를 설정합니다.
  2. 센서 명령 전송
    센서와 통신하기 위한 명령(GET_TEMP)을 전송합니다.
  3. 데이터 수신 및 파싱
    센서에서 전송된 데이터를 읽어 버퍼에 저장하고 출력합니다.

결과 예시


센서가 UART를 통해 전송한 데이터를 출력합니다.

Sensor Data: TEMP:25.3°C

확장 아이디어

  1. 데이터 로그
    수집된 데이터를 파일에 저장하거나 데이터베이스에 기록합니다.
  2. 다중 센서 통합
    여러 UART 포트를 사용해 다양한 센서의 데이터를 동시에 수집합니다.
  3. 오류 검출 및 재시도
    데이터를 수신하지 못했을 경우 자동으로 재시도합니다.

결론


이 코드는 UART를 통해 센서 데이터를 수집하는 기본적인 방법을 보여줍니다. 이를 활용해 다양한 임베디드 응용 프로그램에 적용할 수 있습니다.

고급 기능: DMA를 이용한 UART

DMA(Direct Memory Access)란 무엇인가


DMA는 CPU의 개입 없이 메모리와 주변 장치 간 데이터를 고속으로 전송할 수 있도록 지원하는 기술입니다. UART에서 DMA를 활용하면 데이터 전송 중 CPU 부하를 줄이고, 실시간 성능을 개선할 수 있습니다.

DMA를 활용한 UART의 장점

  1. 고속 데이터 전송
    대량의 데이터를 효율적으로 처리할 수 있습니다.
  2. CPU 부하 감소
    데이터 전송 작업을 DMA 컨트롤러가 처리하므로 CPU가 다른 작업을 수행할 수 있습니다.
  3. 실시간 데이터 처리
    UART와 같은 비동기 장치에서 실시간 데이터 처리 성능을 개선합니다.

DMA를 활용한 UART 구성


DMA 기반 UART는 일반적으로 임베디드 하드웨어의 특정 드라이버 또는 라이브러리를 통해 설정됩니다. 아래는 DMA를 설정하는 일반적인 흐름을 설명합니다.

코드 예제: DMA를 활용한 UART 송수신


아래는 DMA를 지원하는 STM32와 같은 임베디드 시스템을 가정한 코드입니다.

#include "stm32f4xx_hal.h"

UART_HandleTypeDef huart2;  // UART 핸들러
DMA_HandleTypeDef hdma_usart2_rx;  // DMA 핸들러

#define BUFFER_SIZE 256
uint8_t uart_rx_buffer[BUFFER_SIZE];  // 수신 버퍼

// DMA와 UART 초기화 함수
void UART_DMA_Init(void) {
    __HAL_RCC_USART2_CLK_ENABLE();  // UART 클럭 활성화
    __HAL_RCC_DMA1_CLK_ENABLE();    // DMA 클럭 활성화

    // UART 초기화
    huart2.Instance = USART2;
    huart2.Init.BaudRate = 9600;
    huart2.Init.WordLength = UART_WORDLENGTH_8B;
    huart2.Init.StopBits = UART_STOPBITS_1;
    huart2.Init.Parity = UART_PARITY_NONE;
    huart2.Init.Mode = UART_MODE_TX_RX;
    huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    HAL_UART_Init(&huart2);

    // DMA 초기화
    hdma_usart2_rx.Instance = DMA1_Stream5;
    hdma_usart2_rx.Init.Channel = DMA_CHANNEL_4;
    hdma_usart2_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
    hdma_usart2_rx.Init.PeriphInc = DMA_PINC_DISABLE;
    hdma_usart2_rx.Init.MemInc = DMA_MINC_ENABLE;
    hdma_usart2_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
    hdma_usart2_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
    hdma_usart2_rx.Init.Mode = DMA_CIRCULAR;
    hdma_usart2_rx.Init.Priority = DMA_PRIORITY_HIGH;
    HAL_DMA_Init(&hdma_usart2_rx);

    // UART와 DMA 연결
    __HAL_LINKDMA(&huart2, hdmarx, hdma_usart2_rx);

    // DMA를 통한 UART 수신 활성화
    HAL_UART_Receive_DMA(&huart2, uart_rx_buffer, BUFFER_SIZE);
}

// 데이터 송신 함수
void UART_DMA_Send(const char *data) {
    HAL_UART_Transmit(&huart2, (uint8_t *)data, strlen(data), HAL_MAX_DELAY);
}

// 수신 데이터 처리 함수
void Process_UART_Data(void) {
    printf("Received Data: %s\n", uart_rx_buffer);
}

int main(void) {
    HAL_Init();  // HAL 초기화
    UART_DMA_Init();  // UART와 DMA 초기화

    UART_DMA_Send("Hello via DMA!\n");

    while (1) {
        Process_UART_Data();
    }
}

코드 설명

  1. DMA 설정
    DMA 채널, 방향(주변 장치 -> 메모리), 버퍼 크기, 데이터 정렬 등 DMA 초기화 작업을 수행합니다.
  2. UART와 DMA 연결
    __HAL_LINKDMA 매크로를 사용해 UART와 DMA 핸들러를 연결합니다.
  3. 순환 모드
    DMA 순환 모드로 설정하여 데이터가 지속적으로 수신되도록 구성합니다.
  4. 데이터 송수신
    HAL_UART_Transmit과 HAL_UART_Receive_DMA를 사용해 데이터를 송수신합니다.

고급 사용 사례

  1. 실시간 데이터 스트리밍
    센서 데이터 수집과 같은 고속 데이터 스트리밍에 활용.
  2. 멀티 태스킹 환경에서의 효율성
    CPU 부하를 줄여 다른 작업과 동시에 수행.
  3. 대용량 데이터 처리
    파일 전송이나 멀티미디어 데이터 전송 등에 적합.

결론


DMA를 활용한 UART는 성능과 효율성을 극대화할 수 있는 고급 통신 방법입니다. 이는 고속 통신이나 실시간 응용 프로그램에서 특히 유용하며, 임베디드 시스템 개발에서 중요한 기술로 자리 잡고 있습니다.

요약


본 기사에서는 C언어를 활용해 임베디드 리눅스 환경에서 UART 시리얼 통신을 설정하고 구현하는 방법을 다뤘습니다. UART의 기본 원리와 설정, 데이터 송수신 구현부터 오류 처리 및 고급 기능인 DMA 활용까지 설명하였습니다. 이를 통해 다양한 임베디드 응용 프로그램에서 효율적이고 신뢰성 있는 통신 시스템을 구축할 수 있습니다.

C 언어
C언어 UART 시리얼 통신 임베디드 리눅스
목차
  1. UART 통신이란 무엇인가
    1. UART의 동작 원리
    2. UART의 주요 특징
  2. 임베디드 리눅스에서의 UART 활용
    1. 임베디드 리눅스에서 UART의 역할
    2. UART의 일반적인 응용 사례
    3. 임베디드 리눅스에서 UART 활용 시의 장점
  3. UART 설정: 필수 요소
    1. UART 설정의 주요 매개변수
    2. UART 설정 방법
    3. 설정 시 주의사항
  4. C언어로 UART 초기화 코드 작성하기
    1. UART 초기화를 위한 단계
    2. 초기화 코드
    3. 코드 설명
    4. 초기화 테스트
    5. 결론
  5. 데이터 송수신 구현
    1. UART 데이터를 송수신하는 방법
    2. 데이터 송신 코드
    3. 데이터 수신 코드
    4. 통합 테스트 코드
    5. 코드 설명
    6. 주의사항
  6. 오류 처리와 디버깅
    1. UART 통신에서 발생할 수 있는 주요 오류
    2. 오류 처리 방법
    3. 디버깅 기법
    4. 사례별 문제 해결
    5. 결론
  7. 실제 응용 예제: 센서 데이터 수집
    1. UART를 활용한 센서 데이터 수집 개요
    2. 사용된 하드웨어 및 환경
    3. 전체 구현 흐름
    4. UART 센서 데이터 수집 코드
    5. 코드 설명
    6. 결과 예시
    7. 확장 아이디어
    8. 결론
  8. 고급 기능: DMA를 이용한 UART
    1. DMA(Direct Memory Access)란 무엇인가
    2. DMA를 활용한 UART의 장점
    3. DMA를 활용한 UART 구성
    4. 코드 예제: DMA를 활용한 UART 송수신
    5. 코드 설명
    6. 고급 사용 사례
    7. 결론
  9. 요약