SCHKOREA`s Blog Life

1. 개발 환경 설치

1.1. JDK (Java Development Kit) 설치

1.2. GNU Arm Embedded Toolchain 설치

1.3. 이클립스 (Eclipse) IDE 설치

1.3.1. Eclipse CDT용 플러그인 설치

1.3.2. GNU MCU Eclipse 설치 – STM32F series firmware compile 

1.3.3.  cygwin 설치 - 내용 추가

(1) Java platform으로 구동되는 이클립스 (Eclipse) 통합 개발 환경에서 GCC compile 관련 개발 및 실행하기 위해 JDK (Java Development Kit) 설치를 필요로 하며, 기존에 설치 되어 있을 경우 생략하여도 된다.

(2) 아래 경로에 접속을 하여서 JDK 관련 Setup 파일을 다운로드 한다.

https://www.oracle.com/technetwork/java/javase/downloads/index-jsp-138363.html#javasejdk

(3)  Accept License Agreement 라디오 버튼을 클릭 후, “jdk-13.0.1_windows-x64_bin.exe”를  다운로드 한 후에 해당 파일을 실행하여 설치 프로세스를 진행한다.

(4) 위와 같이 정상적으로 설치 프로세스를 진행하여 JDK 관련 설치를 종료한다. 

 (1) Windows 환경에서 GCC 컴파일을 하기 위해 GNU Arm Embedded Toolchain 관련 설치를 진행해야 하며, 아래 경로에서 해당 다운로드를 하여 관련 GCC 컴파일 환경 설정을 한다.
[GNU Arm Embedded Toolchain : ARM용 compiler, Linker, Debugger 등이 포함된 Toolchain]

https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-rm

(2) 해당 경로의 web page에서 “GNU-RM” 리스트 박스를 선택하여 ‘Downloads’ page로 이동을 한다.

(3) ‘Downloads’ page에서 가장 최신 version의 GNU Arm Embedded Toolchain을 다운로드한다.
※ 작성 시점의 version : GNU Arm Embedded Toolchain: 9-2019-q4-major November 06, 2019

(4) Windows 32-bit installer type과 Windows 32-bit ZIP package type를 선택하여 Toolchain 환경을 설치할 수가 있는데, ‘gcc-arm-none-eabi-9-2019-q4-major-win32.zip’를 선택하여 관련 설정을 하도록 한다.

(5) Windows 32-bit ZIP package을 원하는 폴더에 다운로드 하고 압축 해제를 한다.

(6) GNU Arm Embedded Toolchain 경로 설정을 위해 사용자 PC의 시스템 속성의 ‘환경변수’ 탭을 선택한다.

 (7) 환경변수의 ‘시스템 변수(S)’ 항목에서 ‘새로 만들기(W)’을 선택하여 변수 이름에는 ‘gcc-arm-none-eabi’를 입력하고, 변수 값에는 아래와 같이 GNU Arm Embedded Toolchain을 압축 해제한 경로를 입력하고 확인 버튼을 누른다.

(8) 이어서 환경변수의 ‘시스템 변수(S) -> Path 변수’ 항목의 편집을 선택하고, Path 환경변수 편집 창에서 새로 만들기를 누른 후에 ‘%gcc-arm-none-eabi%\bin’를 입력한다.

(9) 위와 같이 환경변수 관련 설정을 마치면, 아래와 같이 Command Window에서 ‘arm-none-eabi-gcc --version’를 실행하여 정상적으로 GNU Arm Embedded toolchain이 설정되어 있는지 확인할 수가 있다.

 (1) GNU Arm Embedded Toolchain 환경에서 STM32F series firmware를 gcc compiler 환경에서 compile를 하기위해 이클립스 (Eclipse) IDE를 설치해야 한다. 아래 경로에서 이클립스 IDE 설치 파일을 다운로드 한다.

https://www.eclipse.org/downloads/packages/release/2019-12/r
 

(2) 위의 사이트에서 ‘Eclipse IDE for C/C++ Developers’ 설치 파일을 다운 받는다.

(3) 위의 Eclipse portable 실행 파일을 원하는 디렉토리에 다운로드를 하고 ‘eclipse.exe’를 실행하면 아래와 같은 화면이 나타나며, 사용자 임의 ‘workspace’를 설정한다.

(4) 아래 그림은 정상적으로 Eclipse IDE 환경이 실행된 화면이다.

Eclipse는 C/C++뿐만 아니라 다양한 프로그래밍 언어 및 대상 플랫폼 개발 환경을 지원하며, ARM용 GCC를 위한 플러그-인을 추가로 설치한다. 참고로 Install New software 및 Eclipse marketplace에서 아래 플러그인들을 추가설치 하면, 대부분의 사이트에서 안내하는 ‘GNU MCU Eclipse - window build tool 설치’ 절차를 생략하여도 된다.

(1) Eclipse를 실행 후,

(2) 메뉴 항목, Help > Install New Software 선택 하면 ‘Install’ 창이 나타난다.

(3) ‘Work with’ 탭박스의 ‘Available Software Site’를 누르면 여러 사이트 주소창이 나오는데 아래 항목 선택

     "CDT - http://download.eclipse.org/tools/cdt/releases/9.10"

(4) 잠시 기다리면 CDT Main Features와 CDT Optional Features가 나오는데 순차적으로 선택을 한다.

# CDT Main Features     

▣ C/C++ Development Tools SDK 9.10.0.201912051559

# CDT Optional Features

▣ C/C++ Autotools support Developer Resources   9.10.0.201911192140

▣ C/C++ C99 LR Parser  9.10.0.201910281707

▣ C/C++ GCC Cross Compiler Support Developer Resources 9.10.0.201910171407

▣ C/C++ GDB Hardware Debugging Developer Resources   9.10.0.201911010936

▣ C/C++ Memory View Enhancements Developer Resources 9.10.0.201910171407

(5) ‘I accept the terms of the license agreement’를 선택하고 ‘Finish’를 누르면 Eclipse software 실행 화면 우측 하단에 아래와 같이 install progress bar를 확인할 수가 있다.

(6) 정상적으로 Eclipse IDE Install software 설치 완료 되었으면, 아래와 같은 창이 나타나는데 ‘Restart Now’를 선택해서 재시작을 한다.

(1) C/C++ Development Tools SDK 플러그인 설치 완료 후, GNU MCU Eclipse 관련 설치가 필요하며, 이를 설치하기 위해 메뉴 항목의 Help > Eclipse Marketplace를 선택한다.

(2) ‘Eclipse Marketplace’ 창의 ‘Search-Find’ 항목에 ‘GNU-MCU’를 입력하면 다음과 같이 검색이 된다.

(3)   ‘GNU MCU Eclipse 4.7.1’ 설치 항목은 대부분 설치를 하는 것을 권장하며 모두 선택한 후에 ‘Confirm’을 선택한다.

(4) ‘I accept the terms of the license agreement’를 선택하고 ‘Finish’를 누르고 정상적으로 설치가 되면 다음과 같은 창이 나타나는데 ‘Restart Now’를 선택하면 된다.

새로운 PC에 위의 과정(To. 1.3.2)을 최신 version 설치하면서, 기존 프로젝트를 불러온 후에, 아래와 같은 에러 메세지가 나타나면서 compile이 안되는 문제가 있었다.

아래와 같은 프로그램으로 리눅스 관련 명령어가 실행되도록 해야한다. 아래 사이트에 가서 설치하고, 환경설정을 하여주면된다.

https://www.cygwin.com/

 글을 남기는 시점에서 개발환경의 Version 은 아래와 같다.

Eclipse IDE 환경에서 printf() 함수 사용시에는 아래와 같이 hwconfig.c 에서 정의해야 한다.

#ifdef __GNUC__
	/* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
	 set to 'Yes') calls __io_putchar() */
	#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
	#define GETCHAR_PROTOTYPE int __io_getchar(int ch)
#else
	#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
	#define GETCHAR_PROTOTYPE int fgetc(FILE *f)
#endif /* __GNUC__ */

PUTCHAR_PROTOTYPE		// for printf use USART1
{
	// Write a character to the USART
	if( ch == '\n')
	{
		USART_SendData(USART1, '\r');
		while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
		USART_SendData(USART1, '\n');
	}
	else
	{
		USART_SendData(USART1, (uint8_t) ch);
	}

	// Loop until the end of transmission
	while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);

	return ch;
}

GETCHAR_PROTOTYPE		// for printf use USART1
{
	while (USART_GetFlagStatus(USART1, USART_FLAG_RXNE) == RESET){}; 
	return USART_ReceiveData(USART1);
}

그리고 특정 source file에 printf() 함수를 추가하고 build를 진행하면 아래와 같이 compile error가 발생하는데, 이 부분은 gcc compile system의 standard I/O function call에 따른 이슈로 인하여 발생되는 문제이며, 해결 방안은 syscalls.c 파일을 프로젝트에 추가하여 함께 build 하면 된다. (참고로 IAR compiler 환경에서는 해당 printf() 함수 사용 할 경우 optimization linking 및 compile 되어 build image가 생성된다.)

# compile error case

/usr/lib/gcc/arm-none-eabi/4.9.1/../../../../arm-none-eabi/lib/libc.a(lib_a-exit.o): In function `exit':
/build/arm-none-eabi-gcc/src/gcc-4.9.1/build/arm-none-eabi/newlib/libc/stdlib/../../../../../newlib/libc/stdlib/exit.c:70: undefined reference to `_exit'
/usr/lib/gcc/arm-none-eabi/4.9.1/../../../../arm-none-eabi/lib/libc.a(lib_a-sbrkr.o): In function `_sbrk_r':
/build/arm-none-eabi-gcc/src/gcc-4.9.1/build/arm-none-eabi/newlib/libc/reent/../../../../../newlib/libc/reent/sbrkr.c:58: undefined reference to `_sbrk'
/usr/lib/gcc/arm-none-eabi/4.9.1/../../../../arm-none-eabi/lib/libc.a(lib_a-writer.o): In function `_write_r':
/build/arm-none-eabi-gcc/src/gcc-4.9.1/build/arm-none-eabi/newlib/libc/reent/../../../../../newlib/libc/reent/writer.c:58: undefined reference to `_write'
/usr/lib/gcc/arm-none-eabi/4.9.1/../../../../arm-none-eabi/lib/libc.a(lib_a-closer.o): In function `_close_r':
/build/arm-none-eabi-gcc/src/gcc-4.9.1/build/arm-none-eabi/newlib/libc/reent/../../../../../newlib/libc/reent/closer.c:53: undefined reference to `_close'
/usr/lib/gcc/arm-none-eabi/4.9.1/../../../../arm-none-eabi/lib/libc.a(lib_a-fstatr.o): In function `_fstat_r':
/build/arm-none-eabi-gcc/src/gcc-4.9.1/build/arm-none-eabi/newlib/libc/reent/../../../../../newlib/libc/reent/fstatr.c:62: undefined reference to `_fstat'
/usr/lib/gcc/arm-none-eabi/4.9.1/../../../../arm-none-eabi/lib/libc.a(lib_a-isattyr.o): In function `_isatty_r':
/build/arm-none-eabi-gcc/src/gcc-4.9.1/build/arm-none-eabi/newlib/libc/reent/../../../../../newlib/libc/reent/isattyr.c:58: undefined reference to `_isatty'
/usr/lib/gcc/arm-none-eabi/4.9.1/../../../../arm-none-eabi/lib/libc.a(lib_a-lseekr.o): In function `_lseek_r':
/build/arm-none-eabi-gcc/src/gcc-4.9.1/build/arm-none-eabi/newlib/libc/reent/../../../../../newlib/libc/reent/lseekr.c:58: undefined reference to `_lseek'
/usr/lib/gcc/arm-none-eabi/4.9.1/../../../../arm-none-eabi/lib/libc.a(lib_a-readr.o): In function `_read_r':
/build/arm-none-eabi-gcc/src/gcc-4.9.1/build/arm-none-eabi/newlib/libc/reent/../../../../../newlib/libc/reent/readr.c:58: undefined reference to `_read'
collect2: error: ld returned 1 exit status

# syscall.c 새로 정의

#include <_ansi.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/fcntl.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <sys/time.h>
#include <sys/times.h>
#include <errno.h>
#include <reent.h>
#include <unistd.h>
#include <sys/wait.h>

#define FreeRTOS
#define MAX_STACK_SIZE 0x2000

extern int __io_putchar(int ch) __attribute__((weak));
extern int __io_getchar(void) __attribute__((weak));

#ifndef FreeRTOS
  register char * stack_ptr asm("sp");
#endif

caddr_t _sbrk(int incr)
{
  extern char end asm("end");
  static char *heap_end;
  char *prev_heap_end,*min_stack_ptr;

  if (heap_end == 0)
    heap_end = &end;

  prev_heap_end = heap_end;

#ifdef FreeRTOS
  /* Use the NVIC offset register to locate the main stack pointer. */
  min_stack_ptr = (char*)(*(unsigned int *)*(unsigned int *)0xE000ED08);
  /* Locate the STACK bottom address */
  min_stack_ptr -= MAX_STACK_SIZE;

  if (heap_end + incr > min_stack_ptr)
#else
  if (heap_end + incr > stack_ptr)
#endif
  {
//    write(1, "Heap and stack collision\n", 25);
//    abort();
    errno = ENOMEM;
    return (caddr_t) -1;
  }

  heap_end += incr;

  return (caddr_t) prev_heap_end;
}

/*
 * _gettimeofday primitive (Stub function)
 * */
int _gettimeofday (struct timeval * tp, struct timezone * tzp)
{
  /* Return fixed data for the timezone.  */
  if (tzp)
    {
      tzp->tz_minuteswest = 0;
      tzp->tz_dsttime = 0;
    }

  return 0;
}
void initialise_monitor_handles()
{
}

int _getpid(void)
{
  return 1;
}

int _kill(int pid, int sig)
{
  errno = EINVAL;
  return -1;
}

void _exit (int status)
{
  _kill(status, -1);
  while (1) {}
}

int _write(int file, char *ptr, int len)
{
  int DataIdx;

    for (DataIdx = 0; DataIdx < len; DataIdx++)
    {
       __io_putchar( *ptr++ );
    }
  return len;
}

int _close(int file)
{
  return -1;
}

int _fstat(int file, struct stat *st)
{
  st->st_mode = S_IFCHR;
  return 0;
}

int _isatty(int file)
{
  return 1;
}

int _lseek(int file, int ptr, int dir)
{
  return 0;
}

int _read(int file, char *ptr, int len)
{
  int DataIdx;

  for (DataIdx = 0; DataIdx < len; DataIdx++)
  {
    *ptr++ = __io_getchar();
  }

   return len;
}

int _open(char *path, int flags, ...)
{
  /* Pretend like we always fail */
  return -1;
}

int _wait(int *status)
{
  errno = ECHILD;
  return -1;
}

int _unlink(char *name)
{
  errno = ENOENT;
  return -1;
}

int _times(struct tms *buf)
{
  return -1;
}

int _stat(char *file, struct stat *st)
{
  st->st_mode = S_IFCHR;
  return 0;
}

int _link(char *old, char *new)
{
  errno = EMLINK;
  return -1;
}

int _fork(void)
{
  errno = EAGAIN;
  return -1;
}

int _execve(char *name, char **argv, char **env)
{
  errno = ENOMEM;
  return -1;
}

결론적으로 상용 컴파일러를 사용하지 않고, Eclipse IDE와 같은 무료 프로그램으로 충분히 compile를 할 수 있다는 것에 고무적인 결과이다. 조만간 STM32F103x processor를 사용한 hardware platform 기반 Eclipse IDE 환경에서의 setup guide post를 남겨보도록 하겠다.

참고로 일반적으로 잘 알려진 디버깅용 printf() 함수 사용과 비슷한 구현을 아래와 같이 공유한다.

void zPrintf(USART_TypeDef* usart_p, char *fmt, ...)
{
	va_list	arg_ptr;
	char		LocalText[64];
	uint8_t	cnt;
	
	for(cnt=0 ; cnt<64 ; cnt++) 
	{
		LocalText[cnt] = 0x00;
	}

	va_start(arg_ptr, fmt);
	vsprintf(LocalText, fmt, arg_ptr);
	va_end(arg_ptr);

	for(cnt=0 ; cnt<64 ; cnt++) 
	{
		if(LocalText[cnt] != 0)
		{
			USART_SendData(usart_p, LocalText[cnt]);
			while(USART_GetFlagStatus(usart_p, USART_FLAG_TXE) == RESET);
			
			if(LocalText[cnt] == KEYBOARD_LineFeed)
			{
				USART_SendData(usart_p, KEYBOARD_CarryRet);
				while(USART_GetFlagStatus(usart_p, USART_FLAG_TXE) == RESET);
			}
		}
		else		break;
	}	
}