NTREXGO - 디바이스마트, 엔티렉스 컨텐츠 통합 사이트 » applications

[18호]JK전자와 함께하는 ARM 완전정복(4)-2

디바이스마트 매거진 — Fri, 10 May 2013 04:22:34 +0000

JK전자와 함/께/하/는 ARM 완전 정복

Ⅱ.ARM Applications – 2부

글 | JK전자

(7) Stack Pointer 초기화

각 프로세서 모드별(7개 동작모드)로 Processor Mode를 전환하면서 Stack을 초기화해야 합니다. 이전 강좌인 ARM Architecture의 ARM Register 부분을 다시 보시면 R13(SP)는 각 동작 모드별로 뱅크 되어 있는 레지스터임을 확인 할 수 있습니다. 여기서 주의해야 할 점은 User Mode Stack은 제일 마지막에 초기화해야 합니다. 왜 그럴까요? User Mode는 비특권 모드이므로 한번 User Mode로 진입을 하여 SWI 명령등을 사용하지 않으면 다시 특권 모드로 진입을 할 수 없어서 다른 Processor Mode의 Stack Pointer를 초기화할 수가 없습니다. 이런 이유로 해서 User Mode의 Stack Pointer를 제일 마지막에 초기화하도록 해야 합니다.

;function initializing stacks
InitStacks
;Don’t use DRAM,such as stmfd,ldmfd……
;SVCstack is initialized before
;Under toolkit ver 2.5, ‘msr cpsr,r1′ can be used instead of ‘msr cpsr_cxsf,r1′
mrs r0,cpsr
bic r0,r0,#MODEMASK
orr r1,r0,#UNDEFMODE|NOINT
msr cpsr_cxsf,r1 ;UndefMode
ldr sp,=UndefStackorr r1,r0,#ABORTMODE|NOINT
msr cpsr_cxsf,r1 ;AbortMode
ldr sp,=AbortStackorr r1,r0,#IRQMODE|NOINT
msr cpsr_cxsf,r1 ;IRQMode
ldr sp,=IRQStackorr r 1,r0,#FIQMODE|NOINT
msr cpsr_cxsf,r1 ;FIQMode
ldr sp,=FIQStack ;// 아래(System Mode Stack) 부분 추가 함.bic r0,r0,#MODEMASK|NOINT
orr r1,r0,#SYSMODE
msr cpsr_cxsf,r1 ;SYSMode
ldr sp,=SYSStackbic r0,r0,#MODEMASK|NOINT
orr r1,r0,#SVCMODE
msr cpsr_cxsf,r1 ;SVCMode
ldr sp,=SVCStack;USER mode has not be initialized. We use always SVC mode.mov pc,lr ;The LR register won’t be valid if the current mode is not SVC mode.

(8) Segment Initialization

ROM Binary가 만들어 지고 나서 프로그램이 실행되기 위해서는 반드시 RAM이 있어야 합니다. Segment Initialization은 RAM에서 프로그램이 올바른 데이터를 가지고 실행될 수 있도록 RAM 영역에 전역변수의 초기값들을 저장하는 일을 합니다. 좀 더 자세한 사항은 이전 강좌인 ARM Architecture 4.4 Linker 부분을 참조하시기 바랍니다.

위의 그림에서 왼쪽이 ROM Binary 이고 오른쪽이 RAM 영역입니다.
- .data : C언어 등에서 선언한 전역변수들의 초기값이 저장되어 있는 영역입니다.
- .bss : 0으로 초기화 되는 영역입니다. 초기값을 지정하지 않은 전역변수등이 여기에 해당합니다.
- .textrw : 컴파일러에 의해 생성된 RAM에서 실행되는 함수들 입니다.

#pragma segment = “.bss”
#pragma segment = “.data”
#pragma segment = “.data_init”
#pragma segment = “.rodata”
#pragma segment = “.textrw”
#pragma segment = “.textrw_init”
#pragma segment = “CSTACK”
void InitSegment()
{
unsigned int k, n;
unsigned char *pdst, *psrc;//
// initialize zero-initialized segment
//
n = (unsigned int)__section_end(“.bss”) – (unsigned int)__section_begin(“.bss”);
pdst = (unsigned char *)__section_begin(“.bss”);for(k=0; k {
*(pdst + k) = 0;
}
//
// initialize non-zero-initialized segment
//
n = (unsigned int)__section_end(“.data_init”) – (unsigned int)__section_begin(“.data_init”);
pdst = (unsigned char *)__section_begin(“.data”);
psrc = (unsigned char *)__section_begin(“.data_init”);
for(k=0; k {
*(pdst + k) = *(psrc + k);
}//
// initialize segment for ram-function
//
n = (unsigned int)__section_end(“.textrw_init”) – (unsignedint)__section_begin(“.textrw_init”);
pdst = (unsigned char *)__section_begin(“.textrw”);
psrc = (unsigned char *)__section_begin(“.textrw_init”);
for(k=0; k {
*(pdst + k) = *(psrc + k);
}return;
}

(9) main 함수로 이동

EXTERN main
ldr pc, =main

드디어 모든 Stack초기화와 Segment 초기화 과정을 끝내고 C 함수를 호출할 수 있게 되었습니다. 이제부터는 C 코드를 이용해서 각 디바이스들을 테스트할 수 있게 되었네요.

5.2 GPIO Output(LED On/Off)

LED를 컨트롤 하기 위해서는 포트를 Output으로 설정한 후에 GPIO(General Purpose Input Output) 포트에 Low or High를 출력하면 됩니다. 아래 회로도는 우리가 실습에 사용하고 있는 Mini2440의 LED 회로도입니다. 4개의 LED가 있는데 각 LED는 GPB5 ~ 8 에 연결이 되어 있습니다. 그렇다면 LED1을 켜기 위해서 GPB5 포트에 Low(0)로 해야 할까요? 아니면 High(1)로 해야 할까요? 정답은 LED의 한쪽 끝이 VDD33V에 연결이 되어 있기 때문에 Low로 설정해야 전류의 흐름이 발생하여 LED가 켜지게 됩니다.

실험예제
LED1, LED2는 On을 하고, LED3, LED4는 Off 시켜 봅니다.
(1) GPBCON 레지스터에 GPB5 ~ GPB8을 Output으로 설정합니다.

// GPB5 Output
(*(volatile unsigned *)0×56000010) = (*(volatile unsigned *)0×56000010) & ~(0×3 << 10);
(*(volatile unsigned *)0×56000010) = (*(volatile unsigned *)0×56000010) | (0×1 << 10);// GPB6 Output
rGPBCON = rGPBCON & ~(0×3 << 12);
rGPBCON = rGPBCON | (0×1 << 12);// GPB7 Output
rGPBCON = rGPBCON & ~(0×3 << 14);
rGPBCON = rGPBCON | (0×1 << 14);// GPB8 Output
rGPBCON = rGPBCON & ~(0×3 << 16);
rGPBCON = rGPBCON | (0×1 << 16);

(2) GPBDAT 레지스터의 GPB5, GPB6을 Low로, GPB7, GPB8을 High로 세팅합니다.

// LED1 On
rGPBDAT = rGPBDAT & ~(0×1 << 5);
// LED2 On
rGPBDAT = rGPBDAT & ~(0×1 << 6);
//rGPBDAT = rGPBDAT | (0×1 << 6);
// LED3 Off
rGPBDAT = rGPBDAT | (0×1 << 7);
// LED4 Off
rGPBDAT = rGPBDAT | (0×1 << 8);

diag.c – led_test()

소스코드 분석

(*(volatile unsigned *)0×56000010) = (*(volatile unsigned *)0×56000010) & ~(0×3 << 10);
GPBCON 레지스터의 주소가 0×50000010입니다. 0×3(b11)을 왼쪽으로 10번 쉬프트를 하면 b110000000000이고 이것을 “~” (Bit clear) 시키면 GPB5[11:10] 부분이 “00″ 으로 Clear 됩니다.

(*(volatile unsigned *)0×56000010) = (*(volatile unsigned *)0×56000010) | (0×1 << 10);
0×1(b01)을 왼쪽으로 10번 쉬프트를 하면 b010000000000 이고 이것을 “|” (OR) 시키면 GPB5[11:10] 부분이 “01″ 으로 Output 설정됩니다.

소스 코드중에 volatile 이라는 것을 사용하고 있습니다. 이것은 컴파일러 최적화에서 제외되는 효과가 있습니다.

컴파일러 최적화 전	컴파일러 최적화 전
int a = 0; // 전역 변수 int b = 0; // 전역 변수 int i; // 로컬 변수for(i=0;i<100;i++) b = b + a * 100;	int a = 0; // 전역 변수 int b = 0; // 전역 변수 int i; // 로컬 변수for(i=0;i<100;i++) b = b + 0; // a * 100;

위의 코드에서 오른쪽 코드처럼 개발자가 의도하지 않게 컴파일러에 의해 최적화가 되어 “a*100″ 부분을 최적화하여 b 변수에 항상 0으로 저장이 되도록 할 수도 있습니다. 물론 일반적인 상황에서는 아무 문제가 되지 않지만 for 루프 수행중에 외부 인터럽트가 발생하여 인터럽트 서비스 루틴에서 a의 값을 0이 아닌 다른 값으로 변하게 한 후 다시 for 루프를 수행하면 개발자는 b에 0이 아닌 다른값이 저장되기를 기대하고 있겠지만 최적화된 코드에서는 b에 항상 0 이 저장이 되어 있을 것입니다. 이것은 개발자가 의도한 결과가 아닙니다. 이런 현상을 방지하기 위해서는 변수 a 를 volatile로 선언을 하면 됩니다. 특히나 SFR 레지스터 등에 값을 세팅하는 작업을 한다면 항상 volatile 로 선언을 해서 사용하는 것이 좋습니다.

5.3 GPIO Input( KEY Input) – Polling

LED를 켰을 때와 반대로 이번에는 GPIO포트를 이용해서 입력을 받아 보도록 하겠습니다. 포트에서 입력을 받기 위해서는 포트를 Input으로 설정한 후에 GPIO(General Purpose Input Output) 포트를 읽으면 됩니다. 6개의 KEY가 있는데 우리는 INT11, INT13에 연결되어 있는 K2, K3에 대해서 폴링 방식으로 입력을 감지해 보도록 하겠습니다. 참고로 폴링 방식이란 코드에서 무한 루프를 돌면서 특정 행위를 하는 것을 말합니다. 이번 경우에는 Key가 눌러졌는지를 감시하는 것이겠지요. 폴링과 다른 방식으로는 인터럽트 방식이 있습니다. 다음 절에서 공부하게 될 내용입니다.

실험예제
K2, K3 를 읽어서 KEY가 눌러져 있으면 LED2, LED3 를 On으로 하고, 눌러져 있지 않으면 Off로 설정해봅시다.

(1) GPGCON 레지스터에 GPG3, GPG5를 Input으로 설정합니다.

// KEY3, GPG5 Input
rGPGCON = rGPGCON & ~(0×3 << 10);
// KEY2, GPG3 Input
rGPGCON = rGPGCON & ~(0×3 << 6);

(2) GPGDAT 레지스터의 GPG3, GPG5를 읽어서 “0″ 이면 KEY가 눌린 상태이고, “1″ 이면 KEY가 눌러지지 않은 상태입니다.

diag.c – key_test()

// KEY3, GPG5 Input
rGPGCON = rGPGCON & ~(0×3 << 10);
// KEY2, GPG3 Input
rGPGCON = rGPGCON & ~(0×3 << 6);while(1)
{
if( (rGPGDAT & (0×1 << 3)) == 0 ) // KEY2 pressed
// LED2 On
rGPBDAT = rGPBDAT & ~(0×1 << 6);
else
// LED2 Off
rGPBDAT = rGPBDAT | (0×1 << 6);
if( (rGPGDAT & (0×1 << 5)) == 0 ) // KEY3 pressed
// LED3 On
rGPBDAT = rGPBDAT & ~(0×1 << 7);
else
// LED3 Off
rGPBDAT = rGPBDAT | (0×1 << 7);Delay(80);
};

5.4 GPIO Input( KEY Input) – Interrupt

이번에는 인터럽트 방식으로 K2, K3 입력을 감지해보도록 하겠습니다. 인터럽트 방식은 폴링방식보다 효율적이기는 하지만 좀 더 복잡합니다. 여기서 효율적이라고 하는 것은 CPU사용을 효과적으로 한다는 것이지 폴링방식보다 빠르다는 말은 아닙니다. 인터럽트 방식은 인터럽트 요청이 왔을때 인터럽트 서비스 루틴으로 분기할 때까지 지연시간이 있어 폴링 방식보다 느릴 수 있습니다. 하지만 폴링방식처럼 계속 루프를 돌면서 대기하지 않아도 되기 때문에 CPU활용면에서는 효율적입니다.

실험예제
K2, K3를 읽어서 KEY가 눌러져 있으면 LED2, LED3를 On으로 하고 눌러져 있지 않으면 Off로 설정해봅시다.

(1) GPGCON 레지스터에 GPG3, GPG5를 EINT(0×2)으로 설정합니다.

// KEY3, GPG5 EINT13
rGPGCON = rGPGCON & ~(0×3 << 10);
rGPGCON = rGPGCON | (0×2 << 10);// KEY2, GPG3 EINT11
rGPGCON = rGPGCON & ~(0×3 << 6);
rGPGCON = rGPGCON | (0×2 << 6);

(2) EXTINT1 레지스터에 EINT11, EINT13을 Falling Edge로 설정합니다.

Extintn(External Interrupt Control Register n)

The 8 external interrupts can be requested by various signaling methods. The EXTINT register configures configures the signaling method between the level trigger and edge trigger for the extemal interrupt request, and also configuress the signal polarity.
To recognize the level interrupt, the valid logic level on EXTINTn pin must be retained for 40ns at least because of the noise filter.

// set eint13 falling edge trigger
rEXTINT1 &= ~(0×7 << 20);
rEXTINT1 |= (0×2 << 20);// set eint11 falling edge trigger
rEXTINT1 &= ~(0×7 << 12);
rEXTINT1 |= (0×2 << 12);

(3) EINTPEND 레지스터의 Pending bit를 Clear 합니다.

// clear eint 11,13
rEINTPEND |= (1 << 11)|(1 << 13);

“It is cleard by writing 1″ 이라는 문구가 보이는데요. 무슨 의미 일까요? 일반적으로 우리가 SFR 레지스터를 설정할 때에 아래와 같이 먼저 Bit를 Clear 시키고 Set 하는 2단계 과정을 거치게 됩니다.

rEXTINT1 &= ~(0×7 << 20);
rEXTINT1 |= (0×2 << 20);

하지만 인터럽트 서비스 루틴 안에서는 이것 조차도 비효율적일수 있고 Atmoic Operation이 아니기 때문에 Pending Clear를 하는 과정에서 새로운 인터럽트가 발생할 경우에 새로운 인터럽트가 지연될 수도 있습니다.

rEINTPEND |= (1 << 11)|(1 << 13);

이러한 이유로 위와 같이 “1″ 을 써넣어서 바로 Pending을 Clear 할 수 있도록 한 것입니다.

(4) EINTMASK 레지스터에서 Interrupt를 Enable 합니다.

// enable eint 11,13
rEINTMASK &= ~((1 << 11)|(1 << 13));

(5) SRCPND 레지스터의 Pending bit를 Clear 합니다.

rSRCPND = (0×1<<5); // Clear pending bit

(6) INTPND 레지스터의 Pending bit를 Clear 합니다.

rINTPND = (0×1<<5); // Clear pending bit

(7) EINT 인터럽트 서비스 루틴의 함수 포인터를 설정합니다.

pISR_EINT8_23 = (U32)isr_eint_8_23;

(8) INTMSK에서 EINT8_23 의 인터럽트를 Enable 합니다.
INTERRUPT MASK(INTMSK) REGISTER
This register also has 32 bits each of which is related to an interrupt source. If a specific bit is set to 1, the CPU does not service the interrupt request from the corresponding interrupt source(note that even in such a case, the corresponding bit of SRCPND register is set to 1). If the mask bit is 0, the interrupt request can be serviced.

rINTMSK &= ~((0×1<<5));

(9) Startup코드의 IRQ Exception에서 인터럽트 번호를 확인하고 인터럽트 서비스 루틴으로 분기합니다.

IsrIRQ
sub sp,sp,#4 ;reserved for PC –> 1
stmfd sp!,{r8-r9} ; –> 2
ldr r9,=INTOFFSET ; –> 3
ldr r9,[r9] ; –> 4
ldr r8,=HandleEINT0 ; –> 5
add r8,r8,r9,lsl #2 ; –> 6
ldr r8,[r8] ; –> 7
str r8,[sp,#8] ; –> 8
ldmfd sp!,{r8-r9,pc} ; –> 9

▶ 1 : 스택포인터를 1 감소하여 빈 공간을 만듭니다. 인터럽트 핸들러 함수의 주소값이 저장될 공간입니다.
▶ 2 : r8, r9를 사용하고 복원해야 하므로 stack에 저장합니다. stmfd는 먼저 어드레스를 감소하고 저장하므로 1에서 만들어진 빈공간은 그대로 남아 있습니다.
▶ 3, 4 : INTOFFSET을 r9에 로드합니다.
▶ 5 : HandleEINT0를 r8에 로드합니다. HandleEINT0는 Startup 코드의 아래 부분에 정의되어 있습니다.
▶ 6,7 : HandleEINT0 + INTOFFSET*4의 수식이 됩니다. INTOFFSET 레지스터에는 발생한 인터럽트 소스의 Offset 값이 들어있는 레지스터입니다.

우리는 EINT8_23을 이용할 것이기 때문에 INTOFFSET 레지스터에는 5가 저장되어 있을 것입니다. 그러므로 HandleEINT0 + 5*4 즉 HandleEINT8_23의 주소가 됩니다.
소스코드에서 key_test_eint() 함수에서 pISR_EINT8_23 = (U32)isr_eint_8_23; 의 코드를 삽입하면 EINT8_23 인터럽트가 발생하면 isr_eint_8_23 함수로 분기를 하게 됩니다.

▶ 8 : str r8,[sp,#8] 에 의해서 맨 처음에 Stack의 빈공간을 만들어 두었던 곳으로 인터럽트 핸들러 함수의 포인터 주소값을 저장합니다.
▶ 9 : r8, r9 를 Stack에서 복원하고 pc 에 인터럽트 핸들러 함수의 주소가 저장이 되어 실제로 인터럽트 핸들러 함수가 실행이 됩니다.

(10) 인터럽트 서비스 루틴에서 GPGDAT 레지스터의 GPG3, GPG5를 읽어서 “0″ 이면 KEY가 눌린 상태이고, “1″ 이면 KEY 눌러지지 않은 상태입니다.

지금까지 설명한 인터럽트 관련 설정들을 S3C2440 인터럽트 컨트롤러 블럭도와 비교해서 보시기 바랍니다.

Interrupt MODE도 IRQ/FIQ 설정을 해야 하지만 S3C2440의 기본 인터럽트 설정 값이 IRQ 이기 때문에 생략하였습니다.
외부 인터럽트 1개를 서비스 받기 위해서 정말 많은 과정이 필요 하네요. ARM Applications 이후에 하게될 Cortex-M3 Architecture 부분에서도 인터럽트 서비스에 대해서 설명을 할텐데, 그때 Cortex-M3가 얼마나 간결하고 효율적인지 비교해 보시기 바랍니다.

diag.c – key_test_eint()

__irq __arm void isr_eint_8_23(void)
{
if(rINTPND==BIT_EINT8_23)
{
ClearPending(BIT_EINT8_23);
if(rEINTPEND&(1<<11))
{
rEINTPEND |= 1 << 11;
rGPBDAT = rGPBDAT ^ (0×1 << 6); // toggle
}
if(rEINTPEND&(1<<13))
{
rEINTPEND |= 1 << 13;
rGPBDAT = rGPBDAT ^ (0×1 << 7); // toggle
}
}
}
void key_test_eint(void)
{// KEY3, GPG5 EINT13
rGPGCON = rGPGCON & ~(0×3 << 10);
rGPGCON = rGPGCON | (0×2 << 10);
// KEY2, GPG3 EINT11
rGPGCON = rGPGCON & ~(0×3 << 6);
rGPGCON = rGPGCON | (0×2 << 6);// set eint13 falling edge trigger
rEXTINT1 &= ~(0×7 << 20);
rEXTINT1 |= (0×2 << 20);// set eint11 falling edge trigger
rEXTINT1 &= ~(0×7 << 12);
rEXTINT1 |= (0×2 << 12);// clear eint 11,13 –> clear by writing “1″ test
rEINTPEND |= (1 << 11)|(1 << 13);// enable eint 11,13
rEINTMASK &= ~((1 << 11)|(1 << 13));
rSRCPND = (0×1<<5); // Clear pending bit –> clear by writing “1″ test
rINTPND = (0×1<<5); // Clear pending bit –> clear by writing “1″ testpISR_EINT8_23 = (U32)isr_eint_8_23;
// Enable EINT8_23 Interrupt
rINTMSK &= ~((0×1<<5));}

5.5 Timer

임베디드 시스템에서 Timer는 가장 중요하고 필수적인 요소중의 하나로 OS에서 Task 스케줄링을 위해서 사용되기도 합니다. 전자액자, 차량용 블랙박스 등의 응용 어플리케이션에서도 특정 시간 이후에 인터럽트를 발생시켜 정해진 일을 수행하는 경우등 응용분야는 무수히 많습니다.
시간 이야기가 나와서 이야기 하는데 CPU의 클럭 속도가 1Hz 라는 것은 무엇을 의미하는 것일까요? 이것은 1초에 1번의 Tick이 발생한다는 것입니다. 아주 정확한 것은 아니지만 캐시가 있는 시스템에서 캐시 Hit(캐시에서 데이터 혹은 명령어를 가지고 올 경우)일 경우에 1초에 1개의 명령어를 수행한다는 것과 같습니다. S3C2440이 400MHz 로 동작한다면 1초에 4억번의 Tick이 발생하는 것입니다. 정말 어마어마 하지요. 상상해 보세요. 요즘 최신 스마트폰들은 2GHz CPU이면서 그것도 듀얼 코어입니다. 아래는 시간과 주파수 사이의 관계입니다. Timer 설정하는데 이정도는 알고 있어야 합니다. 잘 기억하시기 바랍니다.

- 1sec = 1,000ms = 1,000,000us = 1,000,000,000ns
- 1Hz = 1KHz = 1MHz = 1GHz

실험예제
S3C2440 CPU의 내장된 Timer4를 이용해서 1초에 한번씩 Timer 인터럽트를 발생시켜 LDE2를 Blink(On/Off) 하는 실험을 해보도록 하겠습니다.

(1) TCFG0 레지스터의 Timer4 Prescaler를 15로 설정합니다.

Timer CONFIGURATION REGISTER0 (TCFG0)
Timer input clock Frequency = PCLK/{prescaler value+1}/{divider value}
{prescaler value} = 0~255
{divider value} = 2,4,8,16

// Timer4 Prescaler = 15
rTCFG0 = 0×0;
rTCFG0 = (15 << 8);

(2) TCFG1 레지스터의 Timer4 Divider를 1/2 로 설정합니다.

// Timer4 Divider = 2
rTCFG1 = 0×0;
rTCFG1 = (0×0 << 16);

위와 같이 설정하면 Datasheet 에 있는 아래 공식에 의해서

Timer input clock Frequency = PCLK / {prescaler value+1} / {divider value}
Timer input clock Frequency = 50000000/(15+1)/2 = 1562500

위의 계산식의 의미는 Timer4의 클럭이 1초에 1562500번 발생 한다는 의미입니다. 그러므로 Timer4 buffer count(TCNTB4)를 15625 로 설정해 주면 10ms마다 Auto Reload(Timer Overflow)가 되어 인터럽트가 발생하게 됩니다. 물론 간단하게 TCNTB4를 1562500로 설정해 주면 1초에 한번 발생하는 인터럽트를 만들 수 있겠지만, 안타깝게도 S3C2440의 타이머는 16비트 타이머이므로 최대 값으로 0xFFFF(65535) 이상을 사용할 수가 없습니다.

(3) TCNTB4 레지스터에 Timer4 buffer count를 15625로 설정합니다.

// buffer count
rTCNTB4 = 15625; // interrupt resolution 10msec

(4) TCON 레지스터에 Update TCNTB4와 Auto Reload를 설정합니다.

(5) TCON 레지스터를 설정하여 Timer를 Start 시킵니다.

// Start Timer 4
rTCON |= (1<<20);

(6) TCON에서 Manual Update를 해제하고 INTMSK에서 인터럽트 마스크를 Clear 시킵니다.

// clean manual update
rTCON &= ~(1<<21);// Enable interrupt
rINTMSK &= ~(0×1<<14);

이렇게 하면 Timer4 인터럽트가 10msec마다 한번씩 발생하게 됩니다.

diag.c – timer4_test()

__irq __arm void isr_timer4(void)
{
rSRCPND = BIT_TIMER4; //Clear pending bit
rINTPND = BIT_TIMER4;// Timer가 10msec 마다 발생하므로 1초에 한번씩 toggle 시키기 위해서
if( ++one_seconds_var == 100 )
{
rGPBDAT = rGPBDAT ^ (0×1 << 6); // toggle LED2
one_seconds_var = 0;
}void timer4_test(void)
{/*
Timer input clock Frequency = PCLK / {prescaler value+1} / {divider value}
{prescaler value} = 0~255
{divider value} = 2, 4, 8, 16
period = (prescaler value + 1) * (divider value) * buffer count / PCLK = 10 ms
e.g.; PCLK = 50 Mhz
10 ms = (15 + 1) * 2 * 15625 / (50000 * 1000)
15626 = 10 ms * (50000 * 1000) / 2 / (15 + 1)
*/// Timer4 Prescaler = 15
rTCFG0 = 0×0;
rTCFG0 = (15 << 8);// Timer4 Divider = 2
rTCFG1 = 0×0;
rTCFG1 = (0×0 << 16); // Timer input clock Frequency = PCLK / {prescaler value+1} / {divider value} // 50000000/(15+1)/2 = 1562500 –> 1초에 발생하는 Timer Tick// buffer count
rTCNTB4 = 15625; // interrupt resolution 10msecrTCON = rTCON & ~(0xffffff) | 0×1< rTCON = rTCON | (1 << 22); // Auto reloadpISR_TIMER4 = (int)isr_timer4;// Start Timer 4
rTCON |= (1<<20);// clean manual update
rTCON &= ~(1<<21);// Enable interrupt
rINTMSK &= ~(0×1<<14);

}

여기서 잠깐! 일반함수와 “__irq __arm” 가 있는 함수의 차이점은 무엇일까요?

일반 함수의 Return 부분

ISR 함수의 Return 부분

ISR 함수는 ARM Architecture에서 배운대로 Return을 SUBS PC,LR,#4로 하고 있습니다. 잘 기억이 나지 않으시면 ARM Architecture 자료에서 Pipeline과 Interrupt 부분을 다시 보시기 바랍니다.

5.6 PWM Buzzer

Buzzer, LED 등의 밝기 조정 등에 응용할 수 있습니다.

실험예제
Buzzer을 울리도록 하고 외부 인터럽트 방식으로 Key K2를 누르면 주파수를 10Hz 올리고 K3를 누르면 10Hz 주파수가 내려가도록 해봅시다.

(1) GPBCON 레지스터에서 GPB0를 TOUT0(Timer0 Output)으로 설정합니다.

rGPBCON &= ~0×3; // set GPB0 as tout0, pwm output
rGPBCON |= 0×2;

(2) TCFG0 레지스터의 Timer0 Prescaler를 15로 설정합니다.

PWM TIMER CONTROL REGISTERS
TIMER CONFIGURATION REGISTER0 (TCFG0)
Timer input clock Frequency = PCLK /{prescaler value+1} / {divider value}
{prescaler value} = 0~255
{divider value} = 2, 4, 8, 16

rTCFG0 &= ~0xff;
rTCFG0 |= 15; // prescaler = 15+1

(3) Timer0의 Divider 를 1/8 로 설정합니다.

rTCFG1 &= ~0xf;
rTCFG1 |= 2; // mux = 1/8

(4) Timer0의 Count buffer register, compare buffer register를 설정합니다.

rTCNTB0 = (Pclk>>7)/buzzer_freq;
rTCMPB0 = rTCNTB0>>1; // rTCNTB0/2

여기까지 설정을 하면 아래와 같이 1KHz의 주파수가 만들어집니다.

Timer input clock Frequency = PCLK / {prescaler value+1} / {divider value}
Timer input clock Frequency = 50000000/(15+1)/8 = 390625 → 1초에 발생하는 Timer Tick

50000000Hz(PCLK) >> 7 = 390625 → 결국은 1초에 1번 1Hz값, buzzer_freq(1000)으로 나누어 주면 TCNTBn은 1KHz가 됩니다.

추가로 TCMPBn은 TCNTBn/2로 하면 최종적으로 1KHz인 Timer0(TOUT0)으로 1KHz인 PWM 파형이 출력됩니다.

(5) Timer0를 Start 시킵니다.

rTCON &= ~0x1f;
rTCON |= 0xb; //disable deadzone, auto-reload, inv-off, update TCNTB0&TCMPB0, start timer 0
rTCON &= ~2; //clear manual update bit

diag.c – pwm_buzzer_test()

__irq __arm void isr_eint_8_23(void)
{if(rINTPND==BIT_EINT8_23)
{
ClearPending(BIT_EINT8_23);if(rEINTPEND&(1<<11)) // KEY2
{
rEINTPEND |= 1 << 11;
rGPBDAT = rGPBDAT ^ (0×1 << 6); // LED2 togglebuzzer_freq += 100;
pwm_buzzer_test();
}
if(rEINTPEND&(1<<13)) // KEY3
{
rEINTPEND |= 1 << 13;
rGPBDAT = rGPBDAT ^ (0×1 << 7); // LED3 togglebuzzer_freq -= 100;
pwm_buzzer_test();
}
}
}void pwm_buzzer_test(void)
{
rGPBCON &= ~0×3; // set GPB0 as tout0, pwm output
rGPBCON |= 0×2;rTCFG0 &= ~0xff;
rTCFG0 |= 15; // prescaler = 15+1rTCFG1 &= ~0xf;
rTCFG1 |= 2; // mux = 1/8// Timer input clock Frequency = PCLK / {prescaler value+1} / {divider value}
// 50000000/(15+1)/8 = 390625 –> 1초에 발생하는 Timer Tick// PCLK = 50000000Hz >> 7 = 390625 –> 결국은 1초에 1번 1Hz 값이다.
// buzzer_freq(1000) 으로 나누어 주면 1KHz가 된다.
rTCNTB0 = (PCLK>>7)/buzzer_freq;rTCMPB0 = rTCNTB0>>1; // rTCNTB0/2

rTCON &= ~0x1f;
rTCON |= 0xb; //disable deadzone, auto-reload, inv-off, update TCNTB0&TCMPB0, start timer 0
rTCON &= ~2; //clear manual update bit
}

5.7 UART

임베디드 프로그램에서 Timer와 함께 UART도 필수적인 인터페이스입니다. 개발초기에 디버그 모니터용으로 활용하기도 하고 개발이 완료된 이후에는 제품의 Setting, Firmware 업그레이드 등에도 활용합니다.

실험예제
UART0를 PC와 115200bps Baudrate로 통신(RX, TX)을 하는 Echo server로 만들어 봅시다.

(1) GPH2를 TXD로 GPH3을 RXD로 설정하고, GPH의 Pullup을 Disable 합니다.

rGPHCON &= ~( (0×3 << 6) | (0×3 << 4) );
rGPHCON |= ( (0×2 << 6) | (0×2 << 4) );
rGPHUP = 0x7ff; // The pull up function is disabled GPH[10:0]

(2) UART0의 FIFO Buffer를 Disable 합니다.

rUFCON0 = 0×0; //UART channel 0 FIFO control register, FIFO disable

(3) UART0의 Auto Flow Control을 Disable 합니다.

rUMCON0 = 0×0; //UART chaneel 0 MODEM control register, AFC disable

(4) UART Line Control Regier 설정 (Normal Mode, No Parity, One Stop Bit, Word Length = 8)

rULCON0 = 0×3; //Line control register : Normal,No parity,1 stop,8 bits

(5) UART Control Regier 설정

rUCON0 = (0×0 << 10) | (0×1 << 6) | (0×0 << 5) | (0×0 << 4) | (0×1 << 2) | (0×1 << 0);

(6) UART Baudrate Divisor Register 설정

rUBRDIV0 = ( (int)(Pclk/16./baud+0.5) -1 ); //Baud rate divisior register 0 value = 26

UBRDIV = (int)( UART clock / ( buad rate x 16) ) -1
( UART clock : PCLK, FCLK/n or UEXTCLK )

우리는 UART Clock으로 PCLK 50MHz(50000000)을 사용하고 있으므로 계산식은 다음과 같습니다.

UBRDIV = ( PCLK / (115200*16) ) – 1 = 26

diag.c – uart0_test()

void uart0_send_byte(int data)
{
while(!(rUTRSTAT0 & 0×2)); //Wait until THR is empty.
Delay(10);
WrUTXH0(data);}void uart0_test(unsigned int baud)
{
rGPHCON &= ~( (0×3 << 6) | (0×3 << 4) );
rGPHCON |= ( (0×2 << 6) | (0×2 << 4) );rGPHUP = 0x7ff; // The pull up function is disabled GPH[10:0]rUFCON0 = 0×0; //UART channel 0 FIFO control register, FIFO disable
rUMCON0 = 0×0; //UART chaneel 0 MODEM control register, AFC disable//UART0
rULCON0 = 0×3; //Line control register : Normal,No parity,1 stop,8 bitsrUCON0 = (0×0 << 10) | (0×1 << 6) | (0×0 << 5) | (0×0 << 4) | (0×1 << 2) | (0×1 << 0);rUBRDIV0 = ( (int)(Pclk/16./baud+0.5) -1 ); //Baud rate divisior register 0 value = 26while(!(rUTRSTAT0 & 0×4)); //Wait until tx shifter is empty.uart0_send_byte(‘E’);
uart0_send_byte(‘c’);
uart0_send_byte(‘h’);
uart0_send_byte(‘o’);
uart0_send_byte(‘\r’);
uart0_send_byte(‘\n’);while(1)
{
Delay(10);
while(!(rUTRSTAT0 & 0×1)); //Receive data ready
uart0_send_byte((*(volatile unsigned char *)0×50000024));
}

}

위의 코드는 터미널창에 “Echo” 를 Display 하고 터미널에서 입력한 문자를 바로 Echo 하여 다시 터미널 창에 표시하게 됩니다.

이것으로 ARM Applications 4부를 마치며,
다음호에서는 III. Cortex-M3 Architecture에 대하여 살펴보도록 하겠습니다.

[17호]JK전자와 함께하는 ARM 완전정복(3)-3

디바이스마트 매거진 — Sun, 10 Mar 2013 06:20:23 +0000

JK전자와 함/께/하/는 ARM 완전 정복Ⅱ.ARM Applications – 1부글 | JK전자

4. 개발환경 설정

4.1 IAR Workbench 개발환경 설정

ARM Simulator 기반의 실습 프로젝트와 유사하지만 디버거 설정 부분과 Pre-include directory 설정 등이 추가됩니다.
(1) Create New Project

(2) Empty project 생성

(3) 프로젝트 파일이름 입력 – “mini2440_test”

(4) 그룹생성 – “base”, “testcode”그룹 생성

(5) 소스 파일추가

- “base”그룹 : base 폴더 안의 *.s, *.c 파일들 추가
- “testcode”그룹 : testcode 폴더 안의 *.c 파일들 추가

(6) 프로젝트 옵션 설정

(6.1) Target Device 설정 : Samsung S3C2440A로 설정합니다.

(7) Processor Mode 설정 : “ARM”모드로 설정합니다.

(8) C/C++ Compiler Pre-include 디렉토리 설정

(9) Assembler Pre-include 디렉토리 설정

(10) Scattor Loading 파일 설정 : 프로젝트 디렉토리에 “mini2440_lnk.icf”파일을 선택합니다.

(11) Program Start Entry 설정 : “ __program_start”라고 입력합니다.

(12) 디버깅 정보를 포함하도록 설정합니다.

(13) Map 파일을 생성하도록 합니다.

(14) Debugger 정보 설정 : Dirver – Simulator, Run to main은 반드시 설정 해제합니다.

4.2 JTAG 을 이용한 프로그램 다운로드

4.2.1 ARM-JTAG을 이용한 프로그램 다운로드

(1) ARM-JTAG Standard 버젼 이상을 사용해야 합니다.

(2) IAR 개발환경에서 Debugger를 설정합니다.

RDI Driver를 JICE.dll 로 설정합니다.

(3) Windows7 사용자일 경우 IAR IDE 프로그램과, JICE Server의 실행 환경을 관리자 권한으로 설정합니다.

(4) JICE Server 를 실행한 후 Target Detect 를 합니다.

(5) IAR Workbench 에서 “Download and Debugging”을 실행합니다.

위와 같은 화면이 나왔으면 정상적으로 실행이 완료된 상태입니다. 참고로 “mini2440_lnk.icf”파일은 S3C2440의 RAM(0×30000000)영역에서 실행이 되도록 되어 있습니다. NOR 플래시에 다운로드해서 실행을 할 수도 있지만 NOR 플래시도 10만번 이상 Erase하게 되면 수명이 다하기 때문에 테스트용으로는 주로 RAM에서 실행되도록 합니다.

(6) NOR 플래시에 프로그램을 다운로드 하는 방법
- “mini2440_lnk.icf”파일에서 “define symbol EXECUTE_IN_SDRAM=1;”부분을 “define symbol EXECUTE_IN_SDRAM=0;”으로 수정합니다.
- IAR 프로젝트를 Rebuild 합니다.
- jcs 스크립트 파일에서 “mini2440_test.bin”파일의 이름과 경로를 수정합니다.
- JICE Commander를 실행 -> Script Run -> “S3C2440_NOR(SST39VF1601)_PROGRAM_WITH_FLASHAGENT.jcs”를 실행합니다.

■ 이것으로 ARM Applications 1부를 마치며, 다음호에는 아래 내용에 대하여 살펴보도록 하겠습니다.

[17호]JK전자와 함께하는 ARM 완전정복(3)-2

디바이스마트 매거진 — Sun, 10 Mar 2013 05:43:18 +0000

JK전자와 함/께/하/는 ARM 완전 정복
Ⅱ.ARM Applications – 1부글 | JK전자

2. 어셈블리어 실습

2.1 ARM Simulator 환경 설정

IAR ARM용 컴파일러는 가격이 그렇게 싸지는 않습니다. 다행히도 www.iar.com 에서 시간 제한(30일), 사이즈 제한(32Kbyte) 버젼을 다운 받아서 사용해 볼 수 있습니다.

2.1.1 IAR Evaluation 버젼 다운로드
- 다운로드 사이트 방문
http://supp.iar.com/Download/SW/?item=EWARM-EVAL

패키지 사이즈가 약 830MB정도 입니다. 다운 받아서 설치하시기 바랍니다.

다음은 Evaluation 버젼을 다운로드 받기 위한 절차대로 화면을 캡쳐해 놓은 것입니다. 참조하시기 바랍니다.

반드시 “Code size limited”를 선택하시기 바랍니다. 그렇지 않으면 30일 이후에 더이상 IAR 컴파일러를 사용할 수 없게 됩니다.

(2) IAR Evaluation 버젼 설치

설치가 완료되면 마지막에 License 를 입력하는 화면이 나옵니다. 여기에서 “Register with IAR System to get an evaluation license”를 선택하시기 바랍니다.

현재 설치된 제품 중에 라이센스가 없는 제품의 리스트가 나옵니다. 선택을 하고 “다음”으로 진행합니다.

IAR Evaluation 버젼을 다운받기 위해서 입력했던 Email 주소로 Registeration Confirm 메일이 와있을 것입니다.
Confirm 메일에 있는 Confirm 링크를 클릭하면 “Registration Complete”와 함께 Evaluation License 번호를 알 수가 있습니다. 그 번호를 위의 화면의 빈 칸에 입력하고 나서 “Regiser”버튼을 누르면 잠시 후에 네트워크를 통해서 Evaluation 라이센스 번호를 받게 됩니다. 경우에 따라서 Fail 이라는 메세지가 나올 수도 있습니다. 그때는 “Register”버튼을 다시 한번 클릭해서 재시도해 보시기 바랍니다.

모든 설치가 완료된 화면입니다.

2.1.2 ARM Simulator 프로젝트 생성
아래 화면대로 따라서 ARM Simulator 기반의 실습 프로젝트를 생성해 보시기 바랍니다.

(1) Create New Project

(2) Empty project 생성

(3) 프로젝트 파일이름 입력 – “arm_simulator”

(4) 그룹생성 – “base”, “testcode”그룹 생성

- “base”그룹 : 2440init_ewarm.s 추가
- “testcode”그룹 : main.c, SegInit.c 추가

(6) 프로젝트 옵션 설정

(6.1) Target Device 설정

Samsung S3C2440A 로 설정합니다.

(7) Processor Mode 설정

“ARM”모드로 설정합니다.

(8) Scattor Loading 파일 설정

프로젝트 디렉토리에 “arm_simulator.icf”파일을 선택합니다.

(9) Program Start Entry 설정

“ __program_start”라고 입력합니다.

(10) 디버깅 정보를 포함하도록 설정합니다.

(11) Map 파일을 생성하도록 합니다.

(12) Debugger 정보 설정 : Dirver – Simulator, Run to main은 반드시 설정 해제합니다.

2.2 Data Processing Instructions

2장에서는 ARM Simulator를 활용한 어셈블리어 실습을 해보도록 하겠습니다. 이 내용들은 ARM Architecture Instruction의 이론 부분을 설명할 때 한번씩 나왔던 내용입니다. 여기서는 이론으로 공부했던 내용들을 실제로 ARM Simulator에서 코드를 작성한 후 컴파일하고 실행해서 결과 값을 직접 확인해 보는데 의미가 있습니다.

R0 = 0×00
R1 = 0×22
R2 = 0×02
R3 = 0×00
R4 = 0×00

레지스터 값이 위와 같을 때 아래 예제들을 차례대로 수행해 보세요.

(1) AND R0, R0, #0xFF
2440init_ewarm.s 파일에 다음과 같이 입력을 합니다.

SECTION IMAGE_STARTUP:CODE (2)
PUBLIC __program_start
CODE32
__program_start
b ResetHandler
b HandlerUndef ;handler for Undefined mode
b HandlerSWI ;handler for SWI interrupt
b HandlerPabort ;handler for PAbort
b HandlerDabort ;handler for DAbort
b . ;reserved
b HandlerIRQ ;handler for IRQ interrupt
b HandlerFIQ ;handler for FIQ interrupt
ResetHandler
MOV R0, #0×00
MOV R1, #0×22
MOV R2, #0×02
MOV R3, #0×00
MOV R4, #0x00AND R0, R0, #0xFF
ADD R0, R0, #1
ADD R0, R0, R1
LSL R1, R0, #2
SUB R3, R2, R1, LSR R2HandlerFIQ
b .HandlerIRQ
b .HandlerUndef
b .HandlerSWI
b .HandlerDabort
b .HandlerPabort
b .END

- 실행 결과

(2) ADD R0, R0, #1 ; R0 = R0 + 1 = 0×1
- 실행 결과

(3) ADD R0, R0, R1 ; R0 = R0 + R1 = 0×01 + 0×22 = 0×23
- 실행 결과

(4) LSL R1, R0, #2 ; 0×23(100011) LSL #2 = 0x8C(10001100) -> 참고로 왼쪽으로 2번 쉬프트 하면 *4 를 한 것과 같습니다.
- 실행 결과

(5) SUB R3, R2, R1, LSR R2
- 실행 결과

R3의 값이 0xFFFFFFDF 로 복잡한 값이 나왔습니다. 왜 이런 결과가 나왔을까요? 우선 R1을 오른쪽으로 2번 쉬프트시키면 0×23이 되고 R2(0×02)에서 R1(0×23)을 빼면 결과 값이 -0×21가 되고 이 값을 2의 보수로 표시하면 0xFFFFFFDF가 됩니다.

0×21 = 00000000000000000000000000100001
-0×21 = 11111111111111111111111111011111 –> 0×21의 2의 보수
참고로 2의 보수를 취하는 방법은 원래의 2진수에서 0->1, 1->0 으로 바꾼 후에 1을 더하면 되겠지요.

2.3 Multiply Instructions

R0 = 0×01
R1 = 0×02
R2 = 0×03
R3 = 0×04

레지스터 값이 위와 같을 때 아래 예제들을 차례대로 수행해보세요.

(1) MUL R2, R0, R1 ; R2 = R0*R1 = 0×02
2440init_ewarm.s 파일에 다음과 같이 입력을 합니다.

ResetHandler
MOV R0, 0×01
MOV R1, 0×02
MOV R2, 0×03
MOV R3, 0x04MUL R2, R0, R1
MULS R2, R0, R1
MLA R3, R2, R1, R0

- 실행 결과

(2) MULS R2, R0, R1 ; R2 = R0*R1 = 0×02
MUL 명령과 같은 명령입니다. 하지만 MUL뒤에 “S”가 붙으면 명령어 처리가 끝난 이후에 CPSR의 Flag Field가 연산 결과에 따라서 업데이트가 됩니다.
- 실행 결과

(3) MLA R3, R2, R1, R0 ; R3 = R2*R1 + R0
참 효율적이네요. 명령어 하나로 곱하기 연산과 더하기 연산을 같이 할 수 있습니다.
- 실행 결과

2.4 Load/Store Instructions

2.4.1 Pre-index
R0 = 0×31000000
R1 = 0×00
R2 = 0×00

(1) LDR R1, [R0] ; R1 2440init_ewarm.s 파일에 다음과 같이 입력을 합니다.

ResetHandler
MOV R0, 0×31000000
MOV R1, 0×0
MOV R2, 0x0LDR R1, [R0] STR R1, [R0, #4] STR R1, [R0, #4]!

- 실행 결과

(2) STR R1, [R0, #4] ; R1

(3) STR R1, [R0, #4]! ; R1
- 실행 결과

2.4.2 Post-index
R0 = 0×31000000
R1 = 0×00
R2 = 0×04

(1) LDR R1, [R0], R2 ; R1

ResetHandler
MOV R0, 0×31000000
MOV R1, 0×0
MOV R2, 0x4LDR R1, [R0], R2
STR R1, [R0], #4

- 실행 결과

(2) STR R1, [R0], #4 ; R1
- 실행 결과

2.5 Load/Store Multiple Instructions

R0 = 0x000A
R4 = 0x000B
R5 = 0x000C
R13 = 0xFFF0

(1) STMIA R13!, {R0,R4-R5}

ResetHandler
MOV R0, #0x000A
MOV R4, #0X000B
MOV R5, #0x000C
LDR R13, =0xFFF0STMIA R13!, {R0,R4-R5}

- 실행 결과

(2) STMIB R13!, {R0,R4-R5}

ResetHandler
MOV R0, #0x000A
MOV R4, #0X000B
MOV R5, #0x000C
LDR R13, =0xFFF0STMIB R13!, {R0,R4-R5}

- 실행 결과

(3) STMDA R13!, {R0,R4-R5}

ResetHandler
MOV R0, #0x000A
MOV R4, #0X000B
MOV R5, #0x000C
LDR R13, =0xFFF0STMDA R13!, {R0,R4-R5}

- 실행 결과

(4) STMDB R13!, {R0,R4-R5}

ResetHandler
MOV R0, #0x000A
MOV R4, #0X000B
MOV R5, #0x000C
LDR R13, =0xFFF0STMDB R13!, {R0,R4-R5}

- 실행 결과

2.6 Branch Instructions

ResetHandlersubsequent
MOV R0, #1
MOV R1, #2
BL func1
ADD R2, R0, R1func1
MOV R0, #3
MOV R1, #4
BL func2
ADD R2, R0, R1
MOV PC, LRfunc2
MOV R0, #5
MOV R1, #6
ADD R2, R0, R1
MOV PC, LR

위의 예제를 실행하면 R2 레지스터에 “3”이 저장이 되지 않습니다. R2 레지스터에 “3”이 저장이 될 수 있도록 예제를 수정해 보시기 바랍니다. 수정한 예제 코드는 아래와 같습니다.

서브 함수를 호출 할 경우에는 서브 함수에서 사용하는 레지스터와 LR 레지스터를 반드시 저장한 이후에 사용해야 한다는 것을 알 수 있습니다.

2.7 Status Register Access Instructions

ResetHandler
MRS R0, CPSR
BIC R0, R0, #0×80 ; 7번 비트를 clear 하면 인터럽트가 활성화 됩니다.
MSR CPSR, R0

- 실행 결과

2.8 Conditional Execution

지금까지 배운 모든 어셈블리어들을 활용해서 최종적으로 몇가지 예제를 풀어 보도록 하겠습니다. 예제를 구현하는데에는 여러가지 방법들이 많이 있겠지만 가장 최적화된 어셈블리 명령어를 사용하시기 바랍니다.

(1) 1 ~ 10을 더하는 최적화된 어셈블리어로 작성해 보세요.

ResetHandler
MOV R5, #10
MOV R6, #0
loop_sum
ADD R6, R6, R5
SUBS R5, R5, #1
BNE loop_sum ; Not Equal(Z=1)

루프를 사용할 경우에는 거꾸로 도는 것이 효율적입니다.

(2) 2개 변수 사이의 절대값을 구하세요.
- [-2 - 3] 사이의 절대값

ResetHandler
MOV R0, #-2
MOV R1, #3SUBS R0, R0, R1V
RSBMI R0, R0, #0

“SUBS R0, R0, R1”명령을 실행했을 때의 그림입니다. R0, CPSR의 “N”Flag를 잘 살펴보시기 바랍니다. 참고로 RSBMI 명령어는 CPSR의 “N”Flag가 Set되어 있을 때 뺄셈을 하는데 SUB 명령과는 연산의 방향이 반대로 수행이 되는 명령어입니다. 그러니까 이번 예제에서는 “#0”에서 “R0”를 빼는 것입니다.

- [3 - 1] 사이의 절대값

ResetHandler
MOV R0, #3
MOV R1, #1SUBS R0, R0, R1
RSBMI R0, R0, #0

“SUBS R0, R0, R1”명령을 실행했을 때의 그림입니다. R0, CPSR의 “N”Flag를 잘 살펴 보시기 바랍니다.

3장에서는 우리가 실제로 실습에 사용할 S3C2440 ARM9 개발보드에 대해서 소개하도록 하겠습니다. ARM Simulator에서는 별다른 설정없이도 어셈블리어 실습을 할 수 있었으나 실제 타겟을 사용할 경우에는 개발보드의 메모리 컨트롤러, 부팅과정 등을 제대로 이해하고 있어야 코드 작성이 가능합니다. 실제 개발보드에서 실습을 하기 전에 S3C2440에 대해서 이론적으로 공부해보도록 하겠습니다.

JK전자와 함께하는 ARM 완전정복(3)-2 에서 계속 됩니다.

[17호]JK전자와 함께하는 ARM 완전정복(3)-1

디바이스마트 매거진 — Sun, 10 Mar 2013 00:42:26 +0000

JK전자와 함/께/하/는 ARM 완전 정복Ⅱ.ARM Applications – 1부글 | JK전자

자료는 ARM을 처음 접하는 입문자로서 S/W 엔지니어 혹은 H/W 엔지니어를 대상으로 하였습니다. 처음에는 Cortex-M3 구조를 목표로 하였으나 전통적인 ARM(주로 ARM7, ARM9)의 구조에 대해서 먼저 이야기한 다음 Cortex-M3 구조에 대해서 하기로 마음을 고쳐 먹었습니다. Cortex-M3도 ARM 이기 때문에 전통적인 ARM의 구조에 대해서 잘 이해하고 Cortex-M3 구조와 비교해 보면서 공부한다면 큰 도움이 될 것입니다.

ARM Architecture 강의에서는 특정 CPU(S3C2440, STM32Fxx) 에 대한 내용 보다는 ARM Core의 이론적인 구조 자체에 대해서 많은 설명을 하였습니다. 이번 강의에서는 Samsung의 ARM9 CPU S3C2440 개발보드를 이용해서 실제 실습을 통해서 ARM에 대해서 공부해 보도록 하겠습니다.
I. ARM Architecture ~ IV. Cortex-M3 Applications 까지 분명 쉽지 않은 지루하고도 먼 여행이 되겠지만 ARM을 공부하는 임베디드 관련 엔지니어라면 언젠가는 한 번은 넘어야 하는 산이라 생각됩니다. 부디 이 자료가 ARM을 정복하는데 조금이라도 도움이 되시길 바랍니다.

강의 전체 로드맵

I. ARM Architecture | 임베디드 시스템 개론에 대한 설명과 ARM7, ARM9 의 구조에 대해서 설명합니다.
II. ARM Applications | 삼성의 S3C2440(ARM9) 개발보드(S3C2440 Mini 개발보드)를 이용해서 어셈블리어와 UART, GPIO 등을 실습합니다.
III. Cortex-M3 Architecture | Cortex-M3의 특징과 구조에 대해서 설명합니다.
IV. Cortex-M3 Applications | STM32F103VCT6 Dragon 개발보드를 이용해서 GPIO, LCD, SPI, UART, MP3, SDIO, I2C 등을 실습합니다.

이 강의 자료에 대한 모든 질의사항은 http://cafe.naver.com/avrstudio의 ARM Architecture Q&A게시판에 글을 남겨 주시거나 jk@deviceshop.net로 메일을 보내주시기 바랍니다. 가급적이면 여러 사람이 질문에 대한 답변을 공유할 수 있도록 네이버 카페 게시판을 이용해주셨으면 합니다. 감사합니다.

Ⅱ. ARM Applications 1부 목차

1. Base of Software Engineering
1.1 Memory Endian Formats
1.2 보수 표현
1.3 논리연산
1.4 진수변환
1.5 Data Types
1.6 Aligned & Un-Aligned Data
2. 어셈블리어 실습
2.1 ARM Simulator 환경 설정

2.2 Data Processing Instructions
2.3 Multiply Instructions
2.4 Load/Store Instructions
2.5 Branch Instructions
2.6 Status Register Access Instructions
2.7 Conditional Execution
3.1 S3C2440 CPU
3.2 S3C2440 Features

3. S3C2440 개발보드 소개
3.3 S3C2440 HW IPs
3.4 Memory Controller
3.5 Timer
3.6 UART
3.7 NAND Booting
4. 개발환경 설정
4.1 IAR Workbench 개발환경 설정
4.2 ARM-JTAG 을 이용한 프로그램 다운로드

1장의 내용은 컴퓨터를 전공한 사람이라면 누구나 다 아는 내용이지만 어셈블리어 실습을 하기위해서는 반드시 알아야 하는 내용입니다. 다 아는 내용이겠지만 기억을 되살리는 차원에서 간단하게만 설명 하도록 하겠습니다.

1. Base of Software Engineering

1.1 Memory Endian Formats

워드 데이터 안에서의 바이트 순서로 크게 빅 엔디언과 리틀 엔디언으로 나눌 수 있습니다. 빅 엔디언은 사람이 숫자를 쓰는 방법과 같이 큰 단위의 바이트가 앞에 오는 방법이고, 리틀 엔디언은 반대로 작은 단위의 바이트가 앞에 오는 방법입니다. 다시 한번 강조하지만 이것은 워드 범위 내에서의 바이트 단위의 순서입니다.
또한 ARM 레지스터에 저장이 될 경우에는 엔디안의 구분이 없고 메모리 접근 측면에서만 구분이 필요합니다.

엔디안 종류	0×1234	0×12345678	아키텍쳐
Big-endian	12 34	12 34 56 78	모토로라 등
Little-endian	34 12	78 56 34 12	x86

* 몇몇 아키텍처는 빅 엔디언과 리틀 엔디언 중 하나를 선택할 수 있도록 설계되어있고, 이를 바이 엔디언(Bi-endian)이라 부릅니다. PowerPC, DEC 알파, MIPS, PA-RISC, IA-64 등은 바이 엔디언을 사용하는 대표적인 아키텍처입니다. 우리가 공부하고 있는 ARM도 엔디언을 선택해서 사용할 수 있도록 설계되어 있습니다.
x86 아키텍처가 리틀 엔디언을 쓰기 때문에, 오늘날 x86 아키텍처를 사용하는 대부분의 데스크톱 컴퓨터는 리틀 엔디언을 쓰며 이를 “인텔 포맷” 이라고 합니다

Example)
32비트 숫자인 0x2A를 Little-endian으로 표시 하면?
0×00 00 00 2A = 2A 00 00 00

1.2 보수 표현
컴퓨터에서 보수를 사용하는 이유는 무엇일까요? 모든 것이 0과 1로 표현되는 컴퓨터에서 음수를 표현하는데 편리하기 때문에 사용합니다. 물론 이를 이용해서 뺄셈도 합니다. 예를 들면 12-3의 수식을 컴퓨터(ALU)에서 계산을 하면 실제로는 12에서 3을 빼는 것이 아니라 12와 3의 2의 보수(3의 음수표현)를 더해서 계산을 하게 됩니다.

1.2.1 “1″ 의 보수
주어진 이진수의 모든 자리 숫자를 반전(0을 1로, 1을 0으로)시키면 1의 보수를 얻을 수 있습니다.

8자리의 이진수 01001011(십진수로 75)의 1의 보수를 구하면 아래와 같습니다.
01001011 의 모든 자리의 수를 반전시킨다.
10110100 –> 1의 보수

1.2.2 “2″ 의 보수
1의 보수를 구한 다음 2진수 “1″ 을 더하면 됩니다.
8자리의 이진수 01001011(십진수로 75)의 2의 보수를 구하면 아래와 같습니다.

01001011 의 모든 자리의 수를 반전시킨다.
10110100 –> 1의 보수

10110100
+) 00000001 –> 1의 보수에서 1을 더합니다.
—————
10110101 –> 2의 보수

보수를 구할 때 한 자리가 더 길어질 경우에는 가장 높은 자리의 숫자는 버립니다.

1.2.3 “2″ 의 보수를 이용한 뺄셈

예제) 100-75를 2의 보수를 이용해서 연산하시요.
100-75는 100+(-75)와 같으므로

01100100 (10진수 100)
+) 10110101 (10진수 75의 2의 보수)
—————
100011001

새로 생긴 가장 높은 자리의 숫자를 빼고 남은 00011001은 십진수로 25와 같으며 이는 계산하려던 식의 결과입니다.

예제) 10-75를 2의 보수를 이용해서 연산하시요.
10-75는 10+(-75)와 같으므로

00001010 (10진수 10)
+) 10110101 (10진수 75의 2의 보수)
—————
10111111 (이 결과는 음수 : MSB가 1 이므로 다시 2의 보수를 취하면 65 즉 -65)

10111111 결과는 MSB가 1(음수)이므로 다시 2의 보수를 취해보면 01000001은 십진수로 65와 같으며 이는 계산하려던 식의 결과 -65가 됩니다.

1.3 논리 연산

1.3.1 NOT
2진수 각 자리의 값을 반대로 바꾸는 연산입니다. 이 연산은 어떤 값의 보수를 구할 때 효과적으로 사용할 수 있습니다.

NOT 0111
= 1000

C나 C++에는 “~” 연산을 통해 이 값을 구할 수 있습니다.

x = ~y;

1.3.2 OR
두 값의 각 자릿수를 비교해, 둘 중 하나라도 1이 있다면 1을, 아니면 0을 계산합니다.

0101
OR 0011
= 0111

C/C++에는 “ | ” 연산자가 이 기능을 제공합니다.

x = y | z;

1.3.3 XOR
두 값의 각 자릿수를 비교해, 값이 같으면 0, 다르면 1을 계산합니다.

0101
XOR 0011
= 0110

C/C++에는 “ ^ ” 연산자가 이 기능을 제공한다.

x = y ^ z;

1.3.4 AND
두 값의 각 자릿수를 비교해, 두 값 모두에 1이 있을 때에만 1을, 나머지 경우에는 0을 계산합니다.

0101
AND 0011
= 0001

C/C++에는 “ & ” 연산자가 이 기능을 제공한다.

x = y & z;

1.4. Shift 연산

1.4.1 왼쪽으로 쉬프트(<<)
“ << ” 키워드는 데이터를 왼쪽으로 비트 수만큼 이동시키기 때문에 2의 “이동할 비트수”를 제곱한 값과 데이터가 곱해진 값이 결과 값으로 도출됩니다. 5(b00000101)를 왼쪽으로 3비트 이동시키면 5 << 3 = 40(b00101000) 즉 5 * 8 한 것과 같은 효과가 나타납니다.

가중치	128	64	32	16	8	4	2	1
연산전	0	0	0	0	0	1	0	0
연산후	0	0	1	0	1	0	0	0

1.4.2 오른쪽으로 쉬프트(>>)
“>>” 키워드는 데이터를 오른쪽으로 비트 수만큼 이동시키기 때문에 2의 “이동한 비트수”를 제곱한 값으로 데이터를 나눗셈 한 값이 도출됩니다.
40(b00101000)를 오른쪽으로 1비트 이동시키면 40 >> 1 = 20(b00101000) 즉 40/2 한 것과 같은 효과가 있습니다.

가중치	128	64	32	16	8	4	2	1
연산전	0	0	1	0	2	0	0	0
연산후	0	0	0	1	0	1	0	0

1.4.3 부호가 있는 왼쪽 쉬프트 연산(<<)
79(b01001111) << 1 = -98(b10011110)
부호 비트(“1”)와 그 다음 비트(“0”)가 서로 다른 값인 경우 부호가 바뀌고 Overflow가 발생하게 됩니다. 위의 예제에서는 양수에서 음수로 바뀌면서 Overflow가 발생하였습니다.

가중치	부호	64	32	16	8	4	2	1
연산전	0	1	0	0	1	1	1	1
연산후	1	0	0	1	1	1	1	0

1.4.4 부호가 있는 오른쪽 쉬프트 연산(>>)
여기서 65의 2의 보수를 이용해서 -65를 표현했습니다. -65(b10111111) >> 1 = -33(b11011111)
예를 들어 위의 그림과 같이 “1011 1111” 값을 오른쪽으로 한번 이동하면 왼쪽에 생긴 빈 공간은 최상위 비트인 1 값으로 채워지는 것입니다. 만약 “-160 >> 4v 를 연산하면 -160 의 이진수 값인“1010 0000”가 오른쪽으로 4비트만큼 이동하고, 왼쪽에 생긴 네개의 빈 공간은 최상위 비트인 1 로 채워지므로 연산 결과는 “1111 1010”가 됩니다.

1.5 Rotate 연산

데이터의 모든 비트들을 각각 서로 이웃한 비트의 자리로 옮기고 한 쪽 끝에서 밀려 나가는 비트가 다시 반대편 끝으로 들어오게 되는 연산입니다.

1.5.1 부호 없는(Rotate no carry) 왼쪽 Rotate
23(b00010111) ROL 1 = 46(b00101110)

Left circular shift or rotate

1.5.2 부호 없는(Rotate no carry) 오른쪽 Rotate
23(b00010111) ROR 1 = 139(b10001011)

Right circular shift or rotate

1.5.3 부호 있는(Rotate through carry) 왼쪽 Rotate
ROL과 동일하지만 Carry Flag가 최하위 비트로 이동하고, 최상의 비트의 값이 Carry Flag 로 이동됩니다.
23(b00010111) RCL 1 = 47(b00101111)

Left rotate through carry

1.5.4 부호 있는(Rotate through carry) 오른쪽 Rotate
23(b00010111) RCR 1 = 267(b100001011)

Right rotate through carry
아주 기본적인 내용들이지만 기본적인 것부터 정확하게 알고 있어야 합니다. 주로 데이터 암호화나, 고속의 그래픽 처리 작업 등에서 Shift, Rotate 연산을 많이 사용합니다.

1.6 진수변환

2진수를 16진수로 변환할 때 4자리씩 끊어서 계산하면 편리합니다. 자주 쓰이는 수들의 2진수와 16진수들의 예제들입니다.

2^4 = 16B = b0001 0000 = 0×10
2^5 = 32B = b0010 0000 = 0×20
2^6 = 64B = b0100 0000 = 0×40
2^7 = 128B = 0×80
2^8 = 256B = b0001 0000 0000 = 0×100
2^10 = 1KB = b0100 0000 0000 = 0×400
2^20 = 1MB = b0001 0000 0000 0000 0000 0000 = 0×100000
2^30 = 1GB = 0×40000000
2^40 = 1TB = 0X10000000000
4KB = 0×1000, 64KB = 0×10000, 1MB = 0×100000

Ex)
4GB = 4*1GB = 4 * 2^30 = 2^2 * 2^30 = 2^32 = 0×100000000
256KB = 256*1KB = 2^8 * 2^10 = 2^18 = 0×40000
96KB = 64KB + 32KB = 2^6*2^10 + 2^5*2^10 = 0×10000 + 0×3000 = 0×13000
135KB = 128KB + 4KB + 2KB + 1KB = 2^17 + 2^12 + 2^11 + 2^10 = 0×20000 + 0×1000 + 0×800 + 0×400 = 0x21c00

1.7 Data Types

Byte(8 bits)
Halfword(16 bits)
Word (32 bits)
Long Word (64 bits)

- Value ranges

unsigned char val;
0 <= val <= 2^8(255)
signed char val;
-128(0×80) <= val <= 127(0x7F)
int(signed 32bit integer) val;
0×8000 0000 <= val <= 7FFFF FFFF

1.8 Aligned & Un-Aligned Data Access

1.8.1 Aligned Access

(1) Halfword Data Access : 데이터의 주소 값이 짝수이어야 합니다.
(2) Word Data Access : 데이터의 주소 값이 4의 배수이어야 합니다.

Aligned Data Access

char buf[100];int *p;
int gVar;p = (int *)&buf[0];
gVar = *p –> Data Abort 가능성 1p = (int *)&buf[1];
gVar = *p –> Data Abort 가능성 2

- Data Abort 가능성 2 : buf의 데이터형이 char(8 bit) 이기 때문에 0번째 이후 부터는 4의 배수가 아니기 때문에 Data Abort 가능성이 있습니다.
- Data Abort 가능성 1 : 0번째 인덱스인데 어떻게 보면 Data Abort 가능성이 없는 것처럼 보입니다. 보통은 Linker가 알아서 buf 변수의 할당 주소를 4의 배수에 맞추어 주지만 그렇지 않을 가능성도 있기 때문에 링커에 따라서는 Data Abort 가능성이 있는 것입니다. 그렇다면 Data Abort가 발생하지 않도록 char 배열 buf를 선언하려면 어떻게 해야 할까요? 컴파일러 지시자를 사용해서 char 배열 buf를 강제로 4의 배수로 맞추어 주는 것입니다.

Aligned Data Access

#pragma data_alignment = 2 –> 강제로 4의 배수가 되도록 지시
char buf[100];int *p;
int gVar;p = (int *)&buf[0];
gVar = *p –> 정상동작p = (int *)&buf[1];
gVar = *p –> 1번째 배열에서는 여전히 Data Abort 가능성 2

여기서 또 한가지 ARM C언어에서 구조체 선언을 할 때 어떻게 선언하는 것이 효율적인지를 알아 봅시다.

비 효율적인 구조체 데이터 선언
struct { char a; int b; short c; int d; } gVar;	메모리 배치

위의 그림을 보면 총 5byte의 메모리 공간을 낭비하였습니다. 그렇다면 선언 순서를 short c, int b 의 순서를 바꾸면 어떻게 될까요?

비 효율적인 구조체 데이터 선언
struct { char a; short c; int b; int d; }gVar;	메모리 배치

단지 선언 순서만 바꾸어도 메모리 낭비가 5-byte에서 1-byte로 줄었습니다.

1.8.2 Un-Aligned Data Access

(1) ARM Architecture v6 부터 지원됨
(2) ARM Architecture v4T, v5T(E) 등에서 Un-aligned data를 접근하려고 하면 Data Abort가 발생합니다.

JK전자와 함께하는 ARM 완전정복(3)-2 에서 계속 됩니다.