AVR로 시작하는 임베디드

템플릿 코드 생성 프로그램

Just4Fun — Fri, 7 Jun 2024 18:41:35 +0900

제법 규모가 있는 프로젝트의 경우 수많은 소스코드로 이루어져 있다. 비단 큰 프로젝트가 아니더라도 새로운 코드를 작성할 때 완전히 빈 화면에서부터 시작하여야 한다.

이런 경우 그냥 빈화면 보다는 뭔가 미리 필요한 내용이 기본으로 들어가 있으면 전체적인 코드의 모양도 일관성 있게되고 여러명의 개발자가 공동으로 작업하게 되더라도 이질감 없이 코드를 공유하기가 쉬워진다.

이번 글에서는 코드 확장자에 맞는 기본 템플릿 코드를 만드는 방법을 공유하고자 한다.

code generator

위의 그림은 d:\work\c\tmp 디렉토리에 hello.h hello.cpp 파일을 생성해주는 경우이다. cpp의 경우 class까지 같이 생성해 주려면 class name도 입력해주면 된다.

위와 같이 선택한 다음 Create 버튼을 눌러주면 다음과 같은 파일이 생성된다.

/*==============================================================================
Copyright (c) 2024, Just4Fun

Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this 
   list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice, 
   this list of conditions and the following disclaimer in the documentation 
   and/or other materials provided with the distribution.

3. Neither the name of the Just4Fun nor the names of its contributors may be 
   used to endorse or promote products derived from this software without 
   specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

$Id: $
==============================================================================*/

#ifndef _HELLO_H_
#define _HELLO_H_

class Helloclass
{
public:
    Helloclass();
    ~Helloclass();
};

#endif /* _HELLO_H_ */

// vim:ts=8:sts=4:sw=4:et:

hello.h

/* HELLO.CPP */
/*==============================================================================
Copyright (c) 2024, Just4Fun

Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this 
   list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice, 
   this list of conditions and the following disclaimer in the documentation 
   and/or other materials provided with the distribution.

3. Neither the name of the Just4Fun nor the names of its contributors may be 
   used to endorse or promote products derived from this software without 
   specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

$Id: $
==============================================================================*/

/*------------------------------------------------------------------------------
    HEADER FILE INCLUDE
------------------------------------------------------------------------------*/
#include <>

#include "hello.h"

/*------------------------------------------------------------------------------
    TYPEDEF & MACROS
------------------------------------------------------------------------------*/

/*------------------------------------------------------------------------------
    FUNCTION PROTOTYPES
------------------------------------------------------------------------------*/

/*------------------------------------------------------------------------------
    EXTERNAL VARIABLES
------------------------------------------------------------------------------*/

/*------------------------------------------------------------------------------
    LOCAL VARIABLES
------------------------------------------------------------------------------*/

/*------------------------------------------------------------------------------
    LOCAL FUNCTIONS
------------------------------------------------------------------------------*/

/*------------------------------------------------------------------------------
    EXTERNAL FUNCTIONS
------------------------------------------------------------------------------*/

Helloclass::Helloclass()
{
}

Helloclass::~Helloclass()
{
}


// vim:ts=8:sts=4:sw=4:et:

hello.cpp

헤더파일에는 HelloClass라는 class의 원형이 선언되어 있고, cpp 파일에는 실제 class의 생성자와 소멸자가 기본으로 들어가 있는것을 볼 수 있다.

code generator는 python으로 간단하게 만들었는데 필요한 경우 java나 python 코드 생성 기능을 추가하면 된다.

code_gen.py

0.01MB

빌드 버전과 시간 정보 추가

Just4Fun — Sat, 1 Jun 2024 17:12:01 +0900

임베디드 시스템 프로그램을 개발하다 보면 실제로 임베디드용 프로그램을 개발하는 머신과 빌드된 결과물이 동작되는 머신이 다름으로 인해서 생기는 문제가 가끔씩 발생한다.

새로운 기능을 추가하거나 발견된 오류를 수정해서 타겟 보드에 실행시켰는데 예상대로 동작하지 않는 경우가 있다. 그럴때에 코딩이 잘못되었다고 판단해서 아무리 이리저리 수정해도 전혀 개선되지 않아서 고생하는 경우가 있는데 결국 그 원인이 수정된 결과물 파일과 보드에 내린 파일이 달라서 그랬던걸 한참 뒤에서야 발견하게 되는 경우이다.

이번 글에서는 이런 문제를 조금이라도 줄여 볼 수 있는 방법에 대해서 알아본다.

#include <stdio.h>
#include <time.h>

int main(int argc, char** argv) 
{
    if (argc < 2)
    {
        printf("Usage: build_date <ver_file.c> [z]\n");
        printf("    z : Reset build count to zero of ver_file.c\n");
        return -1;
    }

    time_t cur_time = time(NULL);
    char build_time[128];
    strcpy(build_time, asctime(localtime(&cur_time)));

    // remove new line character at the end of string
    build_time[strlen(build_time)-1] = 0;

    int build_count = 0;
    char    build_str[64];

    FILE    *fp = fopen(argv[1], "rt");
    if (fp)
    {
        fgets(build_str, 64, fp);
        fclose(fp);

        sscanf(build_str, "/* Build [ %d ] */", &build_count);

        if (argc == 3 && argv[2][0] == 'z')
            build_count = 0;
        else
            ++build_count;
    }

    if (!(fp = fopen(argv[1], "wt")))
    {
        printf("Couldn't write '%s'\n", argv[1]);
        return -1;
    }

    fprintf(fp, "/* Build [ %d ] */\n", build_count);
    fprintf(fp, "/* Do not modify this file. */\n\n");
    fprintf(fp, "int  build_count_g = %d;\n", build_count);
    fprintf(fp, "char build_time_g[]  = \"%s\";\n", build_time);

    return 0;
}

먼저 위의 코드를 이용해서 실행파일을 만든다. 여기에서는 build_date.exe 파일로 만들었다고 가정한다.

build_date 실행 결과

위의 그림처럼 build_date를 실행할 때마다 version.c 파일의 build_count_g의 값이 1씩 증가되고 build_time_g의 내용은 build_date를 실행하는 순간의 날짜와 시간으로 업데이트 되는것을 볼 수 있다. 이 방법을 이용하면 타겟 보드용 프로젝트를 빌드할때마다 그 순간으로 업데이트 된 정보를 이용할 수 있게 된다.

제대로 동작되는지 간단한 윈도우 콘솔 프로그램 프로젝트를 이용해서 확인해 보도록 하겠다.

BUILD_DIR := build

all: ${BUILD_DIR}

${BUILD_DIR}: cmake
	@build_date version.c
	cmake --build ${BUILD_DIR}
	@head -n 1 version.c

cmake: ${BUILD_DIR}/Makefile

${BUILD_DIR}/Makefile:
	@cmake -B${BUILD_DIR}

clean:
	@rm -rf ${BUILD_DIR}
	@echo "Delete ${BUILD_DIR} directory"


.PHONY: all ${BUILD_DIR} cmake clean

위와 같이 Makefile을 만든다.

자세히 보면 cmake --build ${BUILD_DIR} 전후로 build_date를 실행하고 새로 업데이트된 내용을 출력하는것을 볼 수 있다.

#include <stdio.h>

#define MAJOR_VER   3
#define MINOR_VER   15

extern int  build_count_g;
extern char build_time_g[];

int main() 
{
  printf("Hello Program: [ %d.%d.%d ] - %s\n", 
          MAJOR_VER, MINOR_VER, build_count_g, build_time_g);

  return 0;
}

위의 코드에서 build_date에 만들어진 변수를 extern으로 불러 들여 출력하도록 만들었다.

make 명령으로 프로젝트를 빌드한 다음 만들어진 파일을 실행했을때 자동으로 빌드 정보가 업데이트가 되는것을 볼 수 있다.

cmake를 이용한 AVR 개발 환경

Just4Fun — Tue, 28 May 2024 21:50:14 +0900

주요 칩제조사들은 개발자들이 해당 칩에서 동작되는 프로그램을 쉽게 개발하도록 통합개발환경(IDE)을 무료로 혹은 일부 비용을 받고 전용 도구를 제공한다. 그러나 칩제조사에서 만드는 대부분의 칩을 지원하도록 하기위해서 개발도구의 프로그램도 커지고 컴퓨터의 자원도 많이 필요로한다.

무료로 제공되는 개발환경에 포함되는 컴파일러는 대부분 GCC 기반인 경우가 많기 때문에 전용도구 없이도 칩에서 동작되는 프로그램을 개발할수 있다.

이번 글에서는 윈도우 OS에서 cmake를 사용해서 AVR 칩용 프로그램을 개발하는 환경을 구성하는 방법에 대해서 설명한다.

필요한 파일은 AVR용 GCC toolchain과 make, cmake, git이다.

먼저 gcc를 다운받아서 설치한다.

AVR gcc download

설치하는 위치는 c:\tools 에 하는걸로 설명한다.

다음에는 make 프로그램을 다운로드한 후 설치한다.

make download

위의 그림에서 binaries와 dependencies모두 다운로드해서 같은 폴더에서 압축을 풀어주면 된다.

다음으로는 cmake 프로그램을 설치한다.

cmake download

이렇게 세개의 프로그램만 설치해도 되지만 윈도우에서 리눅스 명령어를 사용하기 위해서 git을 설치해 주도록 한다.

git download

설치가 완료된 폴더는 다음과 같은 모습이 될것이다. 폴더명은 가급적 간편하게 수정하였다.

모든 tool의 설치가 완료되면 각각의 tool을 바로 실행될수 있도록 환경변수설정을 해주어야 한다.

모든 tool이 제대로 동작되는지 확인해 본다.

> avr-gcc --version

> make --version

> cmake --version

위 명령을 차례대로 입력하여 각 tool의 버전이 제대로 출력되는지 확인한다.

필요한 tool이 제대로 설치되었으면 본격적으로 빌드 환경을 만들어 보겠다.

cmake가 동작되기 위해서는 CMakeLists.txt 파일이 필요하다.

그리고 AVR 컴파일러에 대한 설정을 위한 파일이 하나 더 필요하다. 그리고 좀더 간단한 명령으로 빌드되기 위해서 Makefile도 만들어 준다.

cmake_minimum_required(VERSION 3.28)

project(sample CXX)

set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)

file(GLOB_RECURSE PROJECT_SRC 
    src/*.cpp)

add_executable(${PROJECT_NAME} ${PROJECT_SRC})

target_include_directories(${PROJECT_NAME} PRIVATE
    ./inc)

target_compile_definitions(${PROJECT_NAME} PRIVATE
    F_CPU=1000000)

set(CPU_PARAM 
    -mmcu=attiny85)

target_compile_options(${PROJECT_NAME} PRIVATE
    ${CPU_PARAM}
    -funsigned-char
    -ffunction-sections
    -fdata-sections
    -Og -g2
    -Wall)

target_link_options(${PROJECT_NAME} PRIVATE
    ${CPU_PARAM}
    -Wl,-Map=${PROJECT_NAME}.map
    -Wl,--start-group
    -Wl,-lm
    -Wl,--end-group
    -Wl,--gc-sections)
    
add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
    COMMAND ${CMAKE_SIZE} $<TARGET_FILE:${PROJECT_NAME}>
    COMMAND ${CMAKE_OBJDUMP} -h -S ${PROJECT_NAME} > ${PROJECT_NAME}.lss
    COMMAND ${CMAKE_OBJCOPY} -O ihex $<TARGET_FILE:${PROJECT_NAME}> ${PROJECT_NAME}.hex
    COMMAND ${CMAKE_OBJCOPY} -O binary $<TARGET_FILE:${PROJECT_NAME}> ${PROJECT_NAME}.bin)

CMakeLists.txt

set(CMAKE_SYSTEM_NAME Generic)
set(CMAKE_SYSTEM_PROCESSOR avr)

set(TOOLCHAIN_PREFIX avr-)

set(CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}gcc)
set(CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}c++)
set(CMAKE_OBJCOPY ${TOOLCHAIN_PREFIX}objcopy)
set(CMAKE_SIZE ${TOOLCHAIN_PREFIX}size)
set(CMAKE_OBJDUMP ${TOOLCHAIN_PREFIX}objdump)

set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)

avr-gcc.make

BUILD_DIR := build

all: ${BUILD_DIR}

${BUILD_DIR}: cmake
	$(MAKE) -C ${BUILD_DIR} --no-print-directory

cmake: ${BUILD_DIR}/Makefile

${BUILD_DIR}/Makefile:
	cmake \
		-G "Unix Makefiles" \
		-B${BUILD_DIR} \
		-DCMAKE_TOOLCHAIN_FILE=avr-gcc.cmake

clean:
	@rm -rf ${BUILD_DIR}
	@echo "Delete ${BUILD_DIR} directory"


.PHONY: all ${BUILD_DIR} cmake clean

Makefile

AtTiny85 I2C에서 사용한 코드를 이용해서 빌드하면 다음과 같은 결과를 볼 수 있다.

usi_cmake.zip

0.01MB

GPS - 응용

Just4Fun — Fri, 3 Feb 2023 21:37:45 +0900

앞에서 알아 본 TIMEUTC와 POSLLH 메시지를 분석하여 현재 시간과 위치를 출력해서 제대로 동작되는 프로그램을 만들어 볼 것이다.

시간, 위치 출력 화면

위에 보이는 그림처럼 일정한 주기로 보내주는 시간과 위치 정보를 분석하여 콘솔화면에 출력해 보는 것이다.

void setup()
{
    uart0.init();
    uart1.init();

    stdout = std_inout;

    _delay_ms(500);

    printf("\x1B[2J\x1B[H GPS Test Program\n");

    send_cfg_prt();
    _delay_ms(100);
    gps.cfg_msg_utc();
    _delay_ms(100);
    gps.cfg_msg_loc();

    sei();
}

두개의 UART를 초기화 한다음 UART0로 디버깅 메시지를 출력해주기 위해서 stdout에 대한 설정을 해준다.

static int uart_put(char c, FILE* stream)
{
    if (c == '\n')
        uart0.put_char('\r');

    uart0.put_char(c);

    return 0;
}

extern "C"
{
static FILE* std_inout = fdevopen(uart_put, NULL);
}

UART 설정이 완료 되면 '$' 글자가 들어올 때까지 계속 모니터링 하다가 $가 수신되면 GPS모듈이 정상 동작 되고 있다고 판단해서 CFG-PRT 메시지를 송신한다.

static void send_cfg_prt()
{
    uint8_t ch;
    while (1)
    {
        if (uart1.get_char(ch))
        {
            if (ch == '$')
                break;
        }
    }

    gps.cfg_prt();
}

뒤 이어 TIMEUTC와 POSLLH 패킷을 주기적으로 보내줄 수 있도록 CFG-MSG 패킷을 연속으로 보낸다.

GPS 모듈이 이 두 메시지를 정상적으로 수신하게 되면 매초 두 메시지를 계속 보내주게 된다.

void Gps::cfg_msg_utc()
{
    struct cfg_msg_msg*  msg = (struct cfg_msg_msg*)&gps_data[6];
    uint32_t pkt_size = sizeof(struct cfg_msg_msg);

    make_header(CLASS_CFG, CFG_MSG, pkt_size);

    msg->cls_id = CLASS_NAV;
    msg->msg_id = NAV_TIMEUTC;
    msg->rate = 1;

    chksum(pkt_size);

    uart1.send_data(gps_data, pkt_size + 8);
}

void Gps::cfg_msg_loc()
{
    struct cfg_msg_msg*  msg = (struct cfg_msg_msg*)&gps_data[6];
    uint32_t pkt_size = sizeof(struct cfg_msg_msg);

    make_header(CLASS_CFG, CFG_MSG, pkt_size);

    msg->cls_id = CLASS_NAV;
    msg->msg_id = NAV_POSLLH;
    msg->rate = 1;

    chksum(pkt_size);

    uart1.send_data(gps_data, pkt_size + 8);
}

GPS로 부터 들어오는 데이터를 수신하기 위해서 인터럽트를 이용하도록 하였다.

ISR(_VECTOR(30))
{
    gps.rx_data(uart1.get_char());
}

UART1으로 들어오는 데이터를 처리하는 코드는 아래와 같다.

void Gps::rx_data(uint8_t data)
{
    if (prev_data == SYNC1 && data == SYNC2)
    {
        data_index = 0;
        remain_data = 64;   // set maximum value
    }
    else
    {
        gps_rx_data[data_index++] = data;
        if (data_index == 4) // just received payload length
        {
            remain_data = (gps_rx_data[3] << 8) | gps_rx_data[2];
        }

        if (remain_data-- == 0)
        {
            parse_msg();
        }
    }

    prev_data = data;
}

바로 직전에 들어온 데이터가 SYNC1(0xB5)이고 지금 수신된 데이터가 SYNC2(0x62)라면 패킷의 시작이라고 판단하여 data index값을 0으로 초기화 하고 앞으로 수신될 데이터의 크기를 최대값으로 설정해 둔다.

SYNC 데이터 이후에 수신된 데이터는 gps_rx_data 배열에 차례로 저장한다.

수신된 데이터가 4바이트가 되었다면 패킷의 크기까지 수신되었으므로 앞으로 수신될 패킷의 크기를 알수 있다.

마지막 데이터까지 수신이 완료되었으면 어떤 데이터인지 분석한다.

void Gps::parse_msg()
{
    if (gps_rx_data[0] == CLASS_NAV)
    {
        if (gps_rx_data[1] == NAV_POSLLH)
        {
            struct nav_posllh* msg = (struct nav_posllh*)&gps_rx_data[4];

            longitude = msg->longitude;
            latitude  = msg->latitude;

            loc_updated = true;
        }
        else if (gps_rx_data[1] == NAV_TIMEUTC)
        {
            struct nav_timeutc* msg = (struct nav_timeutc*)&gps_rx_data[4];

            year = msg->year;
            month = msg->month;
            day = msg->day;
            hour = msg->hour;
            min = msg->min;
            sec = msg->sec;

            time_updated = true;
        }
        else
        {
            printf("Not supported NAV MSG : %02X\n", gps_rx_data[1]);
        }
    }
    else if (gps_rx_data[0] == CLASS_ACK)
    {
        printf("ACK : %u\n", gps_rx_data[1]);
    }
    else
        printf("Not supported class ID : %02X\n", gps_rx_data[0]);
}

수신된 데이터의 첫번째와 두번째 데이터를 분석하여 어떤 데이터인지를 알아내어 필요한 데이터를 별도의 변수에 저장한다.

void loop()
{
    gps.update();
}

int main(void)
{
    setup();

    while (1) 
        loop();
}

초기화가 실행된 이후에는 계속 새로운 데이터가 수신되었는지 확인하여 데이터가 업데이트 되었으면 화면에 출력하면 된다.

void Gps::update()
{
    if (time_updated)
    {
        printf("\x1B[5;H\x1B[2K%4d-%2d-%2d %2d:%2d:%2d",
                year, month, day, hour, min, sec);
        time_updated = false;
    }

    if (loc_updated)
    {
        if (longitude && latitude)
        {
            int32_t tmp = longitude / 10000000;
            printf("\x1B[6;H\x1B[2K%3ld", tmp);
            tmp *= 10000000;
            tmp = longitude - tmp;
            printf(".%ld", tmp / 100000);

            tmp = latitude / 10000000;
            printf("\x1B[7;H\x1B[2K%3ld", tmp);
            tmp *= 10000000;
            tmp = latitude - tmp;
            printf(".%ld", tmp / 100000);
        }
        loc_updated = false;
    }
}

시간 정보 데이터가 업데이트 된경우 5번째 줄에 연월일, 시분초 순서로 출력한다.

위치정보가 수신된 경우 유효한 데이터인지 확인한 후 경도와 위도를 각각 출력한다.

gps.zip

0.00MB

GPS - CFG:MSG

Just4Fun — Sat, 28 Jan 2023 19:22:52 +0900

이전의 두개의 글에서 현재 시간을 가지고 오거나 현재 위치 정보를 가지고 오기 위해서는 매번 필요한 키를 입력해 주었다. GPS 모듈에 처음 전원이 들어왔을때 NMEA 메시지를 주기적으로 보내주는 것처럼 UBX 메시지도 주기적으로 보내주면 좋을것 같다.
이를 위해서 CFG-MSG 패킷을 이용하면 된다.
CFG-MSG 패킷에 원하는 메시지에 해당하는 class ID와 message ID를 넣어주면 된다.

void loop()
{
    uint8_t ch;

    if (uart0.getchar(ch))
    {
        if (ch == 'p')
            gps.cfg_prt();

        if (ch == 'm')
            gps.cfg_msg();

        if (ch == 'u')
            gps.nav_utc();

        if (ch == 'l')
            gps.nav_loc();
    }

    if (uart1.getchar(ch))
    {
        uart0.puthex(ch);
    }
}

void Gps::cfg_msg()
{
    struct cfg_msg_msg*  msg = (struct cfg_msg_msg*)&gps_data[6];
    uint32_t pkt_size = sizeof(struct cfg_msg_msg);

    make_header(CLASS_CFG, CFG_MSG, pkt_size);

    msg->cls_id = CLASS_NAV;
    msg->msg_id = NAV_TIMEUTC;
    msg->rate = 1;

    chksum(pkt_size);

    uart1.send_data(gps_data, pkt_size + 8);
}

'm' 키를 누르면 CFG-MSG 패킷을 내 보내도록 되어 있다. 이번 예제에서는 현재 시간을 주기적으로 받을수 있도록 NAV-TIMEUTC 메시지를 선택하도록 되어 있다.

위에 초록색으로 표시되어 있는 부분이 NAV-TIMEUTC 패킷이다. 동일한 구조의 메시지가 매초마다 한 번씩 들어오는 것을 볼수 있다. 만약 다른 메시지도 주기적으로 받기를 원하면 원하는 message ID를 알려주면 된다.

gps.zip

0.00MB

GPS - NAV:POSLLH

Just4Fun — Sat, 28 Jan 2023 19:05:30 +0900

현재 위치 정보를 가지고 오기 위한 UBX 메시지는 NAV-POSLLH 이다

void loop()
{
    uint8_t ch;

    if (uart0.getchar(ch))
    {
        if (ch == 'p')
            gps.cfg_prt();

        if (ch == 'u')
            gps.nav_utc();

        if (ch == 'l')
            gps.nav_loc();
    }

    if (uart1.getchar(ch))
    {
        uart0.puthex(ch);
    }
}

void Gps::nav_loc()
{
    make_header(CLASS_NAV, NAV_POSLLH, 0);

    chksum(0);

    uart1.send_data(gps_data, 8);
}

'l' 키를 누르면 NAV-POSLLH request 메시지를 내 보낸다.

오렌지 색으로 보이는 영역이 경도 데이터이고 초록색 부분이 위도 데이터이다.

gps.zip

0.00MB

GPS - NAV:TIMEUTC

Just4Fun — Sat, 28 Jan 2023 18:52:17 +0900

현재 시간을 알려주는 UBX 패킷은 NAV-TIMEUTC이다.

void loop()
{
    uint8_t ch;

    if (uart0.getchar(ch))
    {
        if (ch == 'p')
            gps.cfg_prt();

        if (ch == 'u')
            gps.nav_utc();
    }

    if (uart1.getchar(ch))
    {
        uart0.puthex(ch);
    }
}

void Gps::nav_utc()
{
    make_header(CLASS_NAV, NAV_TIMEUTC, 0);

    chksum(0);

    uart1.send_data(gps_data, 8);
}

'u' 키를 누르면 UTC time을 가지고 오는 패킷을 내보낸다. request 메시지는 payload없이 class ID와 message ID만 보내주면 된다.

빨간색으로 표시된 부분이 연,월,일에 해당되는 부분이고 초록색 부분이 시,분,초에 해당되는 부분이다.

그리고, 오렌지색 부분이 데이터의 유효성을 알려주는 플래그 바이트이다.

gps.zip

0.00MB

GPS - CFG:PRT

Just4Fun — Sat, 28 Jan 2023 18:29:05 +0900

첫번째로 구현할 UBX 패킷은 CFG-PRT이다.

GPS 모듈은 전원이 인가되면 기본적으로 몇개의 NMEA 메시지를 자동으로 송신하도록 되어 있다는 것은 앞에서 몇차례에 걸쳐서 얘기하였다.

UBX 패킷을 이용하기 위해서는 자동으로 송신되는 NMEA메시지를 보내지 않도록 해주어야 한다.

이를 위해서 CFG-PRT 패킷을 사용하면 된다.

위의 그림은 CFG-PRT 패킷의 구조를 설명하고 있는데 여기에서 중요한 부분은 Proto Mask 부분이다.

그림에 표시되어 있는것처럼 NMEA 메시지와 UBX 메시지를 enable/disable 할수 있다. CFG-PRT메시지를 보낼때 UBX 메시지만 송수신 할수 있도록 해주면 된다.

void loop()
{
    uint8_t ch;

    if (uart0.getchar(ch))
    {
        if (ch == 'p')
            gps.cfg_prt();
    }

    if (uart1.getchar(ch))
    {
        uart0.puthex(ch);
    }
}

UART0에서 p키를 누르면 CFG-PRT 메시지를 내 보내도록 되어 있다. GPS 모듈에서 들어오는 모든 데이터를 헥사값으로 출력하도록 하였다.

void Gps::cfg_prt()
{
    clear();

    struct cfg_prt_msg*  msg = (struct cfg_prt_msg*)&gps_data[6];
    uint32_t pkt_size = sizeof(struct cfg_prt_msg);

    make_header(CLASS_CFG, CFG_PRT, pkt_size);

    msg->port = UART_1;
    msg->mode = 0x08D0;
    msg->baud = 9600;
    msg->in_mask = PROTO_UBX;
    msg->out_mask = PROTO_UBX;

    chksum(pkt_size);

    uart1.send_data(gps_data, pkt_size + 8);
}

화면에 보이는 데이터들은 NMEA 메시지를 헥사값으로 출력한 것이다. ' p' 키를 누르면 CFG-PRT 패킷이 GPS로 송신되고 GPS는 CFG 패킷에 대한 ACK를 보내주도록 되어 있다. 위의 그림에 빨간색 박스가 ACK-ACK 패킷이다.

만약 CFG 패킷을 보냈을때 문제가 있거나 제대로 처리할 수 없는 상황이라면 ACK-NACK를 보내주게 된다.

위에서는 정상적으로 CFG-PRT가 처리되었음을 알려주고, 더이상 NMEA 메시지가 나오지 않게 된다.

gps.zip

0.00MB

GPS - UBX

Just4Fun — Sat, 28 Jan 2023 16:41:31 +0900

앞에 글에서 본 것처럼 GPS에서 보내는 데이터는 모두 $로 시작되는 문자열로 되어 있다.

콘솔창에 보이는 데이터는 NMEA protocol로 정해진 표준에따라 정의되어 있다.

NMEA protocal

위의 그림처럼 $로 하나의 프레임이 시작되고, 뒤이어 GP문자열이 나온다.

메세지 종류에 따라 세글자로 구분되어 진다.

예를 들어, 위치정보에 해당되는 메세지 코드는 GLL이며 다음과 같이 정의 된다.

GLL 메세지

$GPGLL,다음에 위도에 해당되는 값이 나오고, 북위 혹은 남위를 나타내는 글자가 나온다. 다음으로는 경도값이 나오고 동경, 서경을 구분하기 위한 글자가 뒤따른다. 그 다음에는 시간정보도 같이 나온다.

예를 들어 위와 같이 4717.11364N, 00833.91565E와 같은 데이터가 들어 왔다면 아래와 같은 방법으로 변환 하면된다.

이렇게 모든 데이터가 문자열로 이루어져 있으면 사람이 육안으로 직접 읽을때는 편하겠지만, 프로그램으로 읽어 들인 데이터를 가공하거나 다른 용도로 사용하기 위해서 메모리에 저장하려면 일일이 한글자씩 분석하여야 한다.

이러한 문자열 분석은 생각보다 더 까다롭고 오류가 날 가능성도 높아진다.

프로그램으로 처리하기 위한 데이터는 문자열 보다는 바이너리 형태의 패킷 송수신이 훨씬 편하고 효율적이다.

u-blox에서는 이러한 요구 조건을 충족하기 위하여 자체적으로 ubx라는 패킷 전송용 프로토콜을 제공한다.

UBX Packet structure

UBX 패킷은 2개의 연속된 sync 데이터(0xB5,0x62)로 시작되고 1바이트의 Class ID, 1바이트의 Message ID가 이어진다.

그 다음에는 2바이트의 payload 크기에 해당되는 값이 들어가고, 뒤이어 가변 크기의 payload data가 들어간다.

마지막으로 2바이트의 check sum 값으로 패킷을 끝내게 된다.

Class ID와 Message ID를 보면 payload가 어떻게 생겼는지 알수 있으므로 프로그램으로 GPS 데이터를 처리하는게 상당히 간편해 지게 된다.

GPS - UART

Just4Fun — Sat, 28 Jan 2023 14:08:24 +0900

프로젝트에 사용하는 GPS 모듈은 UART 통신을 사용하므로 UART 블럭이 2개 이상 지원되는 마이크로컨트롤러를 사용하는것이 프로그램 디버깅에 편리하다.

따라서 이번 프로젝트에서는 UART가 2개 들어있는 Atmega128A를 사용한다.

Toolchain 설정

Atmega128A 프로젝트를 생성하고 CPU 클럭을 위 그림처럼 보드에 맞게 설정해 준다. 참고로 C++ 프로젝트로 진행할것이기 때문에 AVR/GNU C++ Compiler에서 Symbols를 선택하였지만, 만약 C 프로젝트라면 AVR/GNU C Compiler에 있는 Symbols를 선택한 후 F_CPU값을 입력해 주어야 한다.

프로젝트 생성이 끝나면 UART0는 디버깅을 위하여 baudrate 값을 115200로 설정하고, UART1은 GPS와 연결하기 위하여 9600으로 설정한다.

기본적인 설정이 끝났으면, 각각 수신된 데이터를 바로 되돌려주어 UART0과 UART1이 제대로 동작되는지 확인한다.

#include "uart.h"

Uart    uart0(UART0, 115200);
Uart    uart1(UART1, 9600);

void setup()
{
}

void loop()
{
    uart0.putchar(uart0.getchar());
}

int main(void)
{
    setup();

    while (1) 
        loop();
}

위와 같이 코딩한 다음 실행 시켜 UART0의 정상동작 여부를 확인한다.

UART0 화면

키보드의 아무키나 눌러 누른키값이 화면에 제대로 출력 되는지 확인한다.

UART0이 문제 없는지 확인한 다음 UART1에 대해서도 같은 방법으로 확인한다.

void loop()
{
    uart1.putchar(uart1.getchar());
}

콘솔창의 baudrate를 9600으로 변경한 후 같은 방법으로 UART1의 동작을 확인한다.

UART0과 UART1의 정상 동작을 확인하였다면,

UART1에 GPS 모듈을 연결하고 코드를 아래와 같이 만든다.

void loop()
{
    uart0.putchar(uart1.getchar());
}

다시 콘솔프로그램의 baudrate를 115200으로 변경한 후 UART0에 연결한다.

GPS모듈에서 송신하는 데이터가 콘솔창에 바로 출력되는것을 볼수 있다.

이로써 기본적인 GPS 디버깅 환경이 갖추어졌으므로 다음 단계로 넘어갈 수 있다.

gps.zip

0.00MB