참고. 롬 파일에 데이터(사운드, 이미지 등등) 파일 포함 방법

원문 : http://kkamagui.springnote.com/pages/428590

들어가기 전에...

0.시작하면서...

 사운드를 출력하거나 이미지를 출력하기위해서는 데이터가 필요하다. libfat를 이용해서 직접 디스크에 접근하는 방법도 있지만, 작은 크기의 파일이라면 롬 파일에 포함하는 것이 빠르고 편리하다.

 devkitPro에는 bin2s.exe라는 프로그램을 가지고 있다. bin2s는 binary 파일을 그대로 덤프하여 .s 확장자를 가진 어셈블리어 파일을 만들어 주는데 이것을 이용하면 .s 파일을 같이 링크하여 프로그램에 포함 시킬 수 있다.

1.bin2s.exe

 아래는 콘솔창에서 bell.bin 파일의 내용을 bell.s 파일로 덤프한 화면이다.

 아래는 bell.s 파일의 내용이다. 단순하게 섹션을 나누고 global 키워드로 레이블을 export 한 것임을 알 수 있다.

1. /* Generated by BIN2S - please don't edit directly */
    .section .rodata
    .balign 4
    .global bell_bin_size
   bell_bin_size: .int 27842
    .global bell_bin
   bell_bin:
    .byte   2,  0,  9,  0,  7,  0,  5,  0,  3,  0,  1,  0,255,255,  4,  0
    .byte   5,  0,  5,  0,  5,  0,  4,  0,  3,  0,  8,  0,  2,  0,  0,  0
    .byte   2,  0,  1,  0,  2,  0,  3,  0,  6,  0,  6,  0,  7,  0,  7,  0
2. ......생략......
3.  .byte   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
    .byte   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
    .byte   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0
    .byte   0,  0
4.  .global bell_bin_end
   bell_bin_end:

2.프로젝트에 추가 방법

 위에서 binary 파일을 어셈블리어 파일로 바꾸는 것에 대해서 알아보았다. 만약 프로젝트에 포함할 파일이 100개라면 100개를 다 일일이 바꿔주고 처리해야 할까?

 답은 "그렇지 않다" 이다. 프로젝트가 있는 makefile을 열어보면 맨 아래쪽에 아래와 같은 bin 파일에 대한 처리 부분이 나와있다.

1. #---------------------------------------------------------------------------------
   %.bin.o : %.bin
   #---------------------------------------------------------------------------------
    @echo $(notdir $<)
    @$(bin2o)

 bin2o를 사용해서 bin 파일로 바꾼다는 것이다. bin2o? 우리가 알고있는 것은 bin2s.exe 인데??? bin2o는 bin2s.exe를 사용하는 쉘 매크로이고 devkitPro 폴더에 있는 base_rules 파일에 아래와 같이 정의되어있다.

1. #---------------------------------------------------------------------------------
   # canned command sequence for binary data
   #---------------------------------------------------------------------------------
   define bin2o
    bin2s $< | $(AS) $(ARCH) -o $(@)
2.  echo "extern const u8" `(echo $(<F) | sed -e 's/^\([0-9]\)/_\1/' | tr . _)`"_end[];" > `(echo $(<F) | tr . _)`.h
    echo "extern const u8" `(echo $(<F) | sed -e 's/^\([0-9]\)/_\1/' | tr . _)`"[];" >> `(echo $(<F) | tr . _)`.h
    echo "extern const u32" `(echo $(<F) | sed -e 's/^\([0-9]\)/_\1/' | tr . _)`_size";" >> `(echo $(<F) | tr . _)`.h
   endef

 위에서 보는 것과 같이 바로 어셈블리어 컴파일러(AS)에 넣어서 .o 파일을 생성한다. 그 아래에 있는 부분은 헤더파일을 생성하는 부분으로 파일명으로 .h파일을 생성하고 그 안에 아래와 같은 내용을 추가해 준다.

1. extern const u8 bell_bin_end[];
   extern const u8 bell_bin[];
   extern const u32 bell_bin_size;

 즉 소스에서 a = bell_bin[ 3 ]와 같이 사용할 수 있도록 헤더를 구성해 주는 것이다.

3.makefile 확인 및 수정 방법

 이제 편리한 사용을 위해 프로젝트의 makefile을 손볼 차례다. makefile을 조금만 수정하면 특정 폴더에 bin 파일을 넣는 것 만으로도 롬파일에 데이터를 포함하고 또 사용할 수 있다.

 보통 데이터는 data 폴더를 사용하므로 bin 파일도 data 폴더에 넣는 걸로 하자.

1. #---------------------------------------------------------------------------------
   # BUILD is the directory where object files & intermediate files will be placed
   # SOURCES is a list of directories containing source code
   # INCLUDES is a list of directories containing extra header files
   # DATA is a list of directories containing binary files
   # all directories are relative to this makefile
   #---------------------------------------------------------------------------------
   BUILD  := build
   SOURCES  := source MyLibrary 
   INCLUDES := include build
   DATA  :=  data
2. ...... 생략 ......
3. 
   #---------------------------------------------------------------------------------
   # you need a rule like this for each extension you use as binary data
   #---------------------------------------------------------------------------------
   %.bin.o : %.bin
   #---------------------------------------------------------------------------------
    @echo $(notdir $<)
    @$(bin2o) 

 위에서 조금 의아한 부분이 INCLUDES에 있는 build 일 것이다. 왜 build 폴더를 Include에 넣느냐 하면, bin2o에 의해 생성된 .o 파일과 .h 파일이 build 폴더에서 생성되기 때문이다. 일단 한번 돌려보면 알 수 있다.

4.Wave or MP3 파일을 Raw 파일로 바꾸는 방법

 Wave나 MP3 파일을 NDS에서 출력할 수 있는 Sound 파일로 바꾸려면 일단 Raw Data로 변경한 후, libnds의 PlaySound() 옵션에 적절하게 파라메터를 넘겨서 Play 해주면 된다.

 Raw Data로 바꾸는 방법은 공개 소프트웨어인 Switch(http://www.nch.com.au/switch/plus.html)를 이용하면 쉽게 Raw Data로 변경가능하다. 아래는 Wave 파일을 넣어서 Raw 파일로 변경하는 화면이다.

<Switch 인코딩(Encoding) 화면>

 위의 붉은 색 사각형이 주의깊게 봐야 할 부분이다. 순서는 아래와 같다.

1. .raw 파일로 output 형식을 설정한다.
2. Encoder Options 버튼을 누른다.
3. Codec Settings에서 옵션을 잘 조정하고 주의 깊게 봐둔다.(PlaySound() 함수에서 사용되는 옵션들이다. NDS 배경음악으로는 저정도도 괜찮다. 더 높으면 좋지만 낭비라고 생각한다.)
4. Convert 버튼을 누른다.

결과 파일은 .raw 파일이 나오는데 이것을 data 폴더에 .bin으로 고치고 사용하면 된다. 자세한 사용법은 04 NDS 커널(Kernel) 만들기 소스를 참고하면 된다.

5.마치면서...

 지금까지 데이터 파일을 삽입하는 방법에 대해서 알아보았다. 간단한 wave 파일 같은 경우는 쉽게 포함할 수 있으니 한번 테스트 해보도록 하자.

이 글은 스프링노트에서 작성되었습니다.

참고. 디버그 영역을 이용한 가상 IPC 통신

원문 : http://kkamagui.springnote.com/pages/423568

들어가기 전에...

0.시작하면서...

 NDS는 ARM9과 ARM7 간의 통신을 위해 IPC 통신 기능을 가지고 있다. 하지만 IPC 설정을 해줘야 하고 보낼 수 있는 데이터의 양도 최대 64byte까지로 한정되어있기 때문에 무엇인가 부족한 면이 있다.

 그렇기에 libnds에서는 ARM7과 ARM9이 공유하는 메모리를 이용해서 가상의 IPC 기능을 구현했는데, \devkitPro\libnds\source\include\nds 폴더에 ipc.h 파일에 나와있다.

1. 
   //---------------------------------------------------------------------------------
   typedef struct sTransferSoundData {
   //---------------------------------------------------------------------------------
     const void *data;
     u32 len;
     u32 rate;
     u8 vol;
     u8 pan;
     u8 format;
     u8 PADDING;
   } TransferSoundData, * pTransferSoundData;
2. 
   //---------------------------------------------------------------------------------
   typedef struct sTransferSound {
   //---------------------------------------------------------------------------------
     TransferSoundData data[16];
     u8 count;
     u8 PADDING[3];
   } TransferSound, * pTransferSound;
3. 
   //---------------------------------------------------------------------------------
   typedef struct sTransferRegion {
   //---------------------------------------------------------------------------------
    vint16 touchX,   touchY;  // TSC X, Y
    vint16 touchXpx, touchYpx; // TSC X, Y pixel values
    vint16 touchZ1,  touchZ2; // TSC x-panel measurements
    vuint16 tdiode1,  tdiode2;  // TSC temperature diodes
    vuint32 temperature;   // TSC computed temperature
4.  uint16 buttons;    // X, Y, /PENIRQ buttons
5.  union {
     vuint8 curtime[8];  // current time response from RTC
6.   struct {
      vu8 command;
      vu8 year;  //add 2000 to get 4 digit year
      vu8 month;  //1 to 12
      vu8 day;   //1 to (days in month)
7.    vu8 weekday;   // day of week
      vu8 hours;  //0 to 11 for AM, 52 to 63 for PM
      vu8 minutes;  //0 to 59
      vu8 seconds;  //0 to 59
     } rtc;
    } time;
8.  uint16 battery;   // battery life ??  hopefully.  :)
    uint16 aux;    // i have no idea...
9.  // Don't rely on these below, will change or be removed in the future
    pTransferSound soundData;
10.  vuint32 mailAddr;
     vuint32 mailData;
     vuint8 mailRead;
     vuint8 mailBusy;
     vuint32 mailSize;
    } TransferRegion, * pTransferRegion;
11. 
    static inline
    TransferRegion volatile * getIPC(); // __attribute__ ((deprecated));
12. static inline
    TransferRegion volatile * getIPC() {
     return (TransferRegion volatile *)(0x027FF000);
    } 

 TransferRegion 이라는 구조체를 정의해서 사용하는데, 터치 스크린의 좌표 및 RTC, 그리고 Sound 데이터 모두가 위의 구조체에 들어있다. 그리고 구조체가 존재하는 영역은 0x027FF000 으로 이 영역은 메인 메모리 영역이다. 일반적으로는 사용할 수 없고 Debug 모드일때 8Mbyte로 메모리가 확장되는데 그때 사용할 수 있는 영역이다. NDS 홈브루 실행 시에 디버그 모드로 진입하는지는 확실치 않으나 저 영역은 디버그 모드가 아니라도 접근할 수 있는 영역이 아닐까 조심스럽게 추측해 본다.

2.마치며...

 위의 구조체를 조금 바꾸면 우리가 원하는 데이터를 끼워 넣는 것도 가능하다. 혹시 추가로 기능이 필요하면 넣어서 사용하도록 하자.

이 글은 스프링노트에서 작성되었습니다.

참고. THUMB 코드와 ARM 코드 및 상호 호출(Interworking)

원문 : http://kkamagui.springnote.com/pages/437975

들어가기 전에...

0.시작하면서...

 NDS 개발 툴킷인 devkitPro를 보면 C 코드 같은 경우 THUMB 코드를 사용하도록 되어있다. 하지만 인터럽트가 발생하면 ARM 모드로 전환되고, 기타 ARM 코드로 생성된 라이브러리나 어셈블리로 짜여진 ARM 코드 등등 같은 것을 같이 호출하여 사용하기위해 interwork 옵션으로 중간에 proxy 함수(베니어 함수-veneer)를 사용하여 이를 처리한다.

 Proxy 코드는 어떤식으로 생기는 것일까? NDS 커널에 간단한 테스트를 추가하여 이를 확인해 보기로 했다.  NDS에서 C 코드는 기본적으로 Thumb 모드로 컴파일 된다. 하지만 어셈블리어 코드는 ARM 모드로 컴파일한다. 이 두 언어의 코드를 함께 빌드한 후, 역어셈블리(Disassembly)해보면 어떤 식으로 호출되는지 알 수 있다.

NDS 커널에 대한 내용은 21 NDS 커널(Kernel) 만들기를 참고하도록 하자.

1.THUMB 코드와 ARM 코드 작성

NDS 커널에 간단하게 아래의 루틴을 추가하였다.

1. <main.cpp 파일>
2. ...... 생략 ......
3. extern "C" void Test3( void ); <== assem.s 파일애서 만든 ARM 코드 함수
4. ...... 생략 ......
5. int main()
6. {
7. ...... 생략 ......
8.     Test3();
9. ...... 생략 ......
10. }

1. <assem.s 파일>
2.     .global Test3 
3. 
   
4. ...... 생략 ......
5. Test3:
       bx lr 

 위의 코드를 보면 알 수 있듯이 C에서 간단히 함수를 호출하고 어셈블리어에서는 그냥 리턴하도록 구현되어있다.

2.결과 파일 디스어셈블리(Disassembly)

2.1 테스트 함수 디스어셈블리(THUMB->ARM 호출)

이것을 컴파일 및 링크하여 나온 결과를 objdump.exe로 디스어셈블리 해보면 아래와 같은 결과를 볼 수 있다.

1. 0200128c <main>:

   ...... 생략 ......

    20012d6: f014 fdb3  bl 2015e40 <__Test3_from_thumb>

   ...... 생략 ......

    

   02015e40 <__Test3_from_thumb>:
    2015e40: 4778       bx pc 2015e42: 46c0       nop   (mov r8, r8)

    

2. 02015e44 <__Test3_change_to_arm>: 2015e44: eaffafbd  b 2001d40 <Test3>

    

   02001d40 <Test3>: 2001d40: e12fff1e  bx lr 2001d44: e1a00000  nop   (mov r0,r0)
    2001d48: e1a00000  nop   (mov r0,r0)
    2001d4c: e1a00000  nop   (mov r0,r0)

 ARM 코드를 바로 호출하는게 중간에 THUMB 모드에서 ARM 모드로 전환하는 코드를 통해 호출하고 있는 것을 볼 수 있다. BX 명령은 오퍼런드(Operand)의 0bit 값을 CPSR의 THUMB 모드 비트로 설정해 주는 역할을 하는 명령어이다. 즉 오퍼런드의 0bit가 1이면 Thumb 모드가 되고 0이면 ARM 모드가 된다. 명령어에 대한 자세한 내용은 참고. ARM 어셈블리(Assembly)를 참고하도록 하자.

 이제 main 함수부터 순차적으로 따라가보자. 맨 위에 <main>에서 bl 2014e40을 실행하면 __Test3_from_thumb() 함수가 호출되고, bx pc를 호출하면 PC는 항상 현재 실행하는 명령 + ( 2 * 명령어 크기 )의 위치에 있으므로(즉 짝수 이므로), bx pc를 하는 순간 ARM 모드로 전환된다. 그리고 PC는 현재 실행 중인 주소(2015e40) + 4byte( 2 * Thumb 모드 명령어 크기(2) ) 다음에 있는 b 2001d40을 실행하게 된다. 이렇게 하여 무사히 Thumb -> ARM으로 호출되었다.

 그런데 뭔가 좀 이상한 느낌이 들지 않는가? BL 명령으로 __Test3_from_thumb 을 호출하고 나면 BX PC 명령에 의해 코드가 4Byte 또는 2Byte로 정렬되어있기 때문에 ARM 모드로 전환된다. 이러한 상태에서 ARM 코드를 정상적으로 실행한 뒤에 BX LR 명령으로 원래 루틴으로 돌아가는데... 정상적으로 다시 실행이 되려면 lr에 들어있는 0번째 bit가 1로 설정되어있어야 한다는 말이 된다.

 실제로 그럴까? ARM 문서에 보면 그냥 LR에 들어가는 값은 현재 코드 위치 + 4라고만 되어있었다. 이 설명 만으로는 BX LR 을 수행했을 때 THUMB 모드로 정상적으로 돌아갈 수 없다. 그래서 테스트 코드에서 LR값을 받아 찍어보았다.

 아래는 ARM Architecture Manual에서 찾은 THUMB 모드에서 BL, BLX에 대한 내용이다.

2.2 타이머 함수 디스어셈블리(ARM->THUMB)

 그럼 이번에는 반대의 경우를 보자. 인터럽트 핸들러 함수인 타이머 함수 핸들러 같은 경우 ARM 코드로 되어있다. 하지만 스케줄러를 호출하는 함수 같은 경우는 C로 된 함수를 호출하여 그 안에서 처리한다. 이 부분에 대한 코드는 아래와 같다.

1. 2001c40 <isrTimerInAsm>: 2001c40: e92d4000  stmdb sp!, {lr}
    2001c44: eb00507a  bl 2015e34 <__isrTimerInC_from_arm> 2001c48: e59f00bc  ldr r0, [pc, #188] ; 2001d0c <g_dwCurTask>
    2001c4c: e59f10c0  ldr r1, [pc, #192] ; 2001d14 <g_dwNextTask>
    2001c50: e3510000  cmp r1, #0 ; 0x0
    2001c54: 0a000001  beq 2001c60 <TIMEREND>
    2001c58: e28d2004  add r2, sp, #4 ; 0x4
    2001c5c: eb000001  bl 2001c68 <SwitchTask2>
2. 02015e34 <__isrTimerInC_from_arm>:
    2015e34: e59fc000  ldr ip, [pc, #0] ; 2015e3c <__isrTimerInC_from_arm+0x8>
    2015e38: e12fff1c  bx ip
    2015e3c: 020013fd  andeq r1, r0, #-201326589 ; 0xf4000003
3. 020013fc <isrTimerInC>: 20013fc: b510       push {r4, lr}
    20013fe: b084       sub sp, #16
4. ...... 생략 ......
5.  2001466: b004       add sp, #16
    2001468: bd10       pop {r4, pc}

 위의 코드에서 보면 역시나 BX IP에서 IP 레지스터가 가리키는 값이 0x20013FD로 isrTimerInC의 주소 + 1로 설정되어있음을 알 수 있다. isrTimerInC 함수에서 lr 레지스터를 꺼내어 PC에 넣는 순간 역시 BX와 마찬가지로 레지스터의 0 bit가 CPSR의 Thumb 비트에 설정된다.

3.마치며...

 ARM 코드와 THUMB 코드를 서로 호출할 때 어떠한 일이 일어나는지 확인해 보았다. 모드가 여러종류가 존재하다보니 이러한 복잡한 부분이 생기는 것 같은데... 한번 봐두는 것도 나쁘지 않은 것 같다. THUMB 모드의 명령어와 ARM 모드의 명령어의 동작이 약간씩 다르므로 익혀두는 것도 나쁘지 않은 것 같다.

 ARM을 열심히 하도록 하자 @0@)/~

이 글은 스프링노트에서 작성되었습니다.

참고. Software Reset 방법

원문 :  http://kkamagui.springnote.com/pages/498134

들어가기 전에...

0.업데이트 

• 2007/10/24 03:39:39 : 특정 기기 지원에 대한 추가 부분은 23 Soft Reset 분석 의 첨부파일을 참고하자.

   

   

0.시작하면서...

 홈브루를 실행하면 가장 큰 문제가 다시 부트메뉴로 돌아갈려면 전원을 껐다 켜야한다는 것이다. 이것이 불편하여 Software Reset을 지원하는 라이브러리를 구상하게 되었다.

1.rebootlib

 세상에 내가 생각하는 모든 것은 이미 구현되었다고 누가 말했던듯... rebootlib라는 라이브러리가 이미 나와있었다. http://lickr.org/files/rebootlib/rebootlib_1.1r.zip에서 다운 받을 수 있으며 개발자 사이트는 http://licklick.wordpress.com/category/rebootlib/ 이다. 상당히 재미있는 것을 많이 하고 있으므로 사이트에 들려서 한번 둘러보는 것도 나쁘지 않은 듯 하다.

 소스를 다운받아 열어보면 알겠지만, 특정 기기는 지원하지 않는다는... ㅜ_ㅜ... 그게 하필 내가 쓰고 있는 거라는... ㅜ_ㅜ

<개발자 사이트>

2.Moonshell Plug-in

 NDS를 사용한다면 모르면 간첩인 문쉘(Moonshell)의 Plug-in 중에 mse10_reset 디렉토리를 보면 Software Reset에 대한 내용이 나와있다. 문쉘은 http://mdxonline.dyndns.org/archives/2007/03/moonshell_ver171_dl.shtml에서 받을 수 있으며 Source와 Plug-in SDK를 모두 받을 수 있다.

 하지만 역시 특정 기기는 지원하지 않는다는... ㅜ_ㅜ...

<문쉘(Moonshell) 개발자 사이트>

3.마치면서...

 좋은 라이브러리도 있고 레퍼런스도 있지만... 좀더 기다려야 할듯하다. 빨리 버전업이 되었으면.... ㅜ_ㅜ

이 글은 스프링노트에서 작성되었습니다.

참고. NDS 속도에 대한 몇가지 테스트

 원문 : http://kkamagui.springnote.com/pages/503175

들어가기 전에...

0.시작하면서...

 NDS의 실제 속도는 얼마나 될까? 클럭으로 따지자면 둘다 100MHz가 안되니 그리 빠르다고는 할 수 없다. 하지만 이 수치만 가지고는 뭔가 와닿지가 않는다.

 우리가 쉽게 느낄 수 있는 것? 화면 그리는데 몇 ms 걸리고, 얼마의 크기의 메모리를 복사하는데 몇 ms가 걸리고 하는 말이 더 와닿지 않는가? 지금부터 프로파일러를 사용해서 NDS의 속도에 대한 몇가지를 테스트 해보자. 프로파일러에 대한 내용은 22 타이머(Timer)를 이용한 프로파일러(Profiler) 만들기 에서 찾을 수 있다.

1.메모리 복사 속도

 메모리 속도 테스트는 RGB555 포맷을 사용하는 프레임 버퍼(Frame Buffer)모드의 화면 전체를 복사하는 것을 테스트 했다. 참고로 스크린의 크기는 256 * 192 이므로 총 메모리양은 256 * 192 * 2 = 98304 Byte이다.

 여기서 사용된 코드는 모두 GCC의 최적화 옵션 중 최고인 -O2 옵션으로 컴파일 되고 링크되었다.

1.1 메인 메모리(Main Memory) -> 메인 메모리(Main Memory)

1.1.1 memcpy 사용

 아래는 프로파일링 테스트에 사용된 함수이다.

1. /**
       FrameBuffer의 내용을 LCD에 덤프한다.
   */
   void CWindowManager::DumpFrameBufferToScreen( void )
   {
       memcpy( SUB_FRAMEBUFFER, MAIN_FRAMEBUFFER, SCREEN_HEIGHT * SCREEN_WIDTH * 2 );
2.     memcpy( MAIN_FRAMEBUFFER, SUB_FRAMEBUFFER, SCREEN_HEIGHT * SCREEN_WIDTH *  2 );
   }

  테스트 결과는 아래와 같다.

• NDS : 17 ~ 18 ms,한 화면을 복사하는데 8.5 ~ 9 ms
• NDS Emulator(iDeaS) : 23 ~ 24 ms,한 화면을 복사하는데 11.5 ~ 12 ms

1.1.2 for 루프 사용

 아래는 프로파일링 테스트에 사용된 함수이다.

1. /**
       FrameBuffer의 내용을 LCD에 덤프한다.
   */
   void CWindowManager::DumpFrameBufferToScreen( void )
   {
    int i;
    
    DWORD* pdwDst;
    DWORD* pdwSrc;
    
    pdwDst = ( DWORD* ) SUB_FRAMEBUFFER;
    pdwSrc = ( DWORD* ) MAIN_FRAMEBUFFER;
    
    for( i = SCREEN_HEIGHT * SCREEN_WIDTH / 2 ; i > 0 ; i-- )
    {
     *pdwDst = *pdwSrc;
     pdwDst++;
     pdwSrc++;
    }
        
    pdwDst = ( DWORD* ) MAIN_FRAMEBUFFER;
    pdwSrc = ( DWORD* ) SUB_FRAMEBUFFER;
    
    for( i = SCREEN_HEIGHT * SCREEN_WIDTH / 2 ; i > 0 ; i-- )
    {
     *pdwDst = *pdwSrc;
     pdwDst++;
     pdwSrc++;
    }
   }

  테스트 결과는 아래와 같다.

• NDS : 17 ~ 18 ms,한 화면을 복사하는데 8.5 ~ 9 ms
• NDS Emulator(iDeaS) : 29 ~ 30 ms,한 화면을 복사하는데 14.5 ~ 15 ms

1.1.3 고속 메모리 전송 함수 사용(자작)

 ARM 모드의 12개 레지스터를 사용해서 블럭 전송을 하는 소스코드인데, 자세한 것은 02 NDS 홈브루(Homebrew) - NDS 윈도우 시스템(Windows System)의 내용을 참고하자. 시간은 4 ~ 5 ms 정도(앞서 테스트의 반) 나온다.

1.2 메인 메모리(Main Memory) -> 비디오 메모리(Video Memory)

1.2.1 memcpy 사용

 아래는 프로파일링 테스트에 사용된 함수이다.

1. /**
       FrameBuffer의 내용을 LCD에 덤프한다.
   */
   void CWindowManager::DumpFrameBufferToScreen( void )
   {
       memcpy( LCD_MAIN_ADDR, MAIN_FRAMEBUFFER, SCREEN_HEIGHT * SCREEN_WIDTH *
               2 );
      
       memcpy( LCD_SUB_ADDR, SUB_FRAMEBUFFER, SCREEN_HEIGHT * SCREEN_WIDTH *
               2 );
   }

 테스트 결과는 아래와 같다.

• NDS : 14 ~ 15 ms,한 화면을 복사하는데 7 ~ 7.5 ms
• NDS Emulator(iDeaS) : 23 ~ 24 ms,한 화면을 복사하는데 11.5 ~ 12 ms

1.2.2 For 루프 사용

 아래는 프로파일링 테스트에 사용된 함수이다.

1. /**
       FrameBuffer의 내용을 LCD에 덤프한다.
   */
   void CWindowManager::DumpFrameBufferToScreen( void )
   {
    int i;
    
    DWORD* pdwDst;
    DWORD* pdwSrc;
    
    pdwDst = ( DWORD* ) LCD_MAIN_ADDR;
    pdwSrc = ( DWORD* ) MAIN_FRAMEBUFFER;
    
    for( i = SCREEN_HEIGHT * SCREEN_WIDTH / 2 ; i > 0 ; i-- )
    {
     *pdwDst = *pdwSrc;
     pdwDst++;
     pdwSrc++;
    }     
      
    pdwDst = ( DWORD* ) LCD_SUB_ADDR;
    pdwSrc = ( DWORD* ) SUB_FRAMEBUFFER;
    
    for( i = SCREEN_HEIGHT * SCREEN_WIDTH / 2 ; i > 0 ; i-- )
    {
     *pdwDst = *pdwSrc;
     pdwDst++;
     pdwSrc++;
    }
   }
   

 테스트 결과는 아래와 같다.

• NDS : 16 ~ 17 ms,한 화면을 복사하는데 8 ~ 8.5 ms
• NDS Emulator(iDeaS) : 29 ~ 30 ms,한 화면을 복사하는데 14.5 ~ 15 ms

1.2.3 고속 메모리 함수 사용(자작)

 여기 추가하기...

1.3 비디오 메모리(Video Memory) -> 메인 메모리(Main Memory)

1.3.1 memcpy 사용

 아래는 프로파일링 테스트에 사용된 함수이다.

1. /**
       FrameBuffer의 내용을 LCD에 덤프한다.
   */
   void CWindowManager::DumpFrameBufferToScreen( void )
   {
       memcpy( MAIN_FRAMEBUFFER, LCD_MAIN_ADDR, SCREEN_HEIGHT * SCREEN_WIDTH *
               2 );
      
       memcpy( SUB_FRAMEBUFFER, LCD_SUB_ADDR, SCREEN_HEIGHT * SCREEN_WIDTH *
               2 );
   } 

 테스트 결과는 아래와 같다.

• NDS : 13 ~ 14 ms,한 화면을 복사하는데 6.5 ~ 7 ms
• NDS Emulator(iDeaS) : 23 ~ 24 ms,한 화면을 복사하는데 11.5 ~ 12 ms

1.3.2 For 루프 사용

 아래는 프로파일링 테스트에 사용된 함수이다.

1. /**
       FrameBuffer의 내용을 LCD에 덤프한다.
   */
   void CWindowManager::DumpFrameBufferToScreen( void )
   {
    int i;
    
    DWORD* pdwDst;
    DWORD* pdwSrc;
    
    pdwDst = ( DWORD* ) MAIN_FRAMEBUFFER;
    pdwSrc = ( DWORD* ) LCD_MAIN_ADDR;
    
    for( i = SCREEN_HEIGHT * SCREEN_WIDTH / 2 ; i > 0 ; i-- )
    {
     *pdwDst = *pdwSrc;
     pdwDst++;
     pdwSrc++;
    }     
      
    pdwDst = ( DWORD* ) SUB_FRAMEBUFFER;
    pdwSrc = ( DWORD* ) LCD_SUB_ADDR;
    
    for( i = SCREEN_HEIGHT * SCREEN_WIDTH / 2 ; i > 0 ; i-- )
    {
     *pdwDst = *pdwSrc;
     pdwDst++;
     pdwSrc++;
    }
   }
   

 테스트 결과는 아래와 같다.

• NDS : 16 ~ 17 ms,한 화면을 복사하는데 8 ~ 8.5 ms
• NDS Emulator(iDeaS) : 29 ~ 30 ms,한 화면을 복사하는데 14.5 ~ 15 ms

1.3.3 고속 메모리 전송 함수(자작)

 여기 추가하기...

1.4 비디오 메모리(Video Memory) -> 비디오 메모리(Video Memory)

1.4.1 memcpy 사용

 아래는 프로파일링 테스트에 사용된 함수이다.

1. /**
       FrameBuffer의 내용을 LCD에 덤프한다.
   */
   void CWindowManager::DumpFrameBufferToScreen( void )
   {
       memcpy( LCD_SUB_ADDR, LCD_MAIN_ADDR, SCREEN_HEIGHT * SCREEN_WIDTH *
               2 );
      
       memcpy( LCD_MAIN_ADDR, LCD_SUB_ADDR, SCREEN_HEIGHT * SCREEN_WIDTH *
               2 );
   }

 테스트 결과는 아래와 같다.

• NDS : 16 ~ 17 ms,한 화면을 복사하는데 8 ~ 8.5 ms
• NDS Emulator(iDeaS) : 23 ~ 24 ms,한 화면을 복사하는데 11.5 ~ 12 ms

1.4.2 For 루프 사용

 아래는 프로파일링 테스트에 사용된 함수이다.

1. /**
       FrameBuffer의 내용을 LCD에 덤프한다.
   */
   void CWindowManager::DumpFrameBufferToScreen( void )
   {
    int i;
    
    DWORD* pdwDst;
    DWORD* pdwSrc;
    
    pdwDst = ( DWORD* ) LCD_SUB_ADDR;
    pdwSrc = ( DWORD* ) LCD_MAIN_ADDR;
    
    for( i = SCREEN_HEIGHT * SCREEN_WIDTH / 2 ; i > 0 ; i-- )
    {
     *pdwDst = *pdwSrc;
     pdwDst++;
     pdwSrc++;
    }     
      
    pdwDst = ( DWORD* ) LCD_MAIN_ADDR;
    pdwSrc = ( DWORD* ) LCD_SUB_ADDR;
    
    for( i = SCREEN_HEIGHT * SCREEN_WIDTH / 2 ; i > 0 ; i-- )
    {
     *pdwDst = *pdwSrc;
     pdwDst++;
     pdwSrc++;
    }
   }
   

 테스트 결과는 아래와 같다.

• NDS : 19 ~ 20 ms,한 화면을 복사하는데 9.5 ~ 10 ms
• NDS Emulator(iDeaS) : 39 ~ 40 ms,한 화면을 복사하는데 19.5 ~ 20 ms

1.4.3 고속 메모리 전송 함수(자작)

 ARM 모드의 12개 레지스터를 사용해서 블럭 전송을 하는 소스코드인데, 자세한 것은 02 NDS 홈브루(Homebrew) - NDS 윈도우 시스템(Windows System)의 내용을 참고하자. 시간은 4 ~ 5 ms 정도(앞서 테스트의 반) 나온다.

1.5 메모리 복사에 대한 결론

• 비디오 메모리 -> 비디오 메모리를 제외하고는 모두 거의 비슷
• 블럭 전송 시간 < memcpy 시간 <= for 루프 시간
• 에뮬레이터의 속도는 믿을 것이 못됨
• 블럭 전송이 가장 빠름

이 글은 스프링노트에서 작성되었습니다.

참고. DPG 파일 포맷

원문 :  http://kkamagui.springnote.com/pages/492957

들어가기 전에...

0.시작하면서...

 문쉘(MoonShell)의 동영상 포맷인 DPG에 대해서 알아보자.

1.파일 포맷(File Format)

 아래는 Wikipedia에 등록된 내용이다.

File Format

[edit] General Outline

The DPG file specification is simple. All DPG files contain a 36 byte header, followed by audio, and then a standard mpeg-1 video stream. The audio format can differ; older DPG files used a special WAV format audio, but newer versions of moonshell have phased that out in favor of MP2 audio.

[edit] File Structure

The file begins with a 36 byte header (Note: all of the numbers below are hexadecimal.):

• 44 50 47 30 (this stands for DPG0 in ASCII)
• Four bytes for the number of frames in the video
• Two bytes for the frames per second that the video runs
• 00 00
• Four bytes for the audio sample rate
• 00 00 00 00 (this was the number of audio channels, now deprecated in favor of MP2 audio)
• 24 00 00 00 (this is the start of the audio file, i.e. right after the header)
• Four bytes for the length, in bytes, of the audio
• Four bytes for the above length + 36 bytes (i.e. the start of the video file)
• Four bytes for the length, in bytes, of the video

(A C program and source is included in the BatchDPG source code to simplify the header generation)

After a header has been made, concatenate everything together:

• Linux & Mac (OS X Terminal): cat header.head audio.mp2 video.raw.mpg > ndsmpeg.dpg
• Windows: copy /b header.head + audio.mp2 + video.raw.mpg ndsmpeg.dpg

[edit] Audio Encoding

The audio is encoded in standard MP2 format. For example, using ffmpeg to encode in.avi into out.mp2 at a 22050 sample rate and a bitrate of 64 kb/s:

ffmpeg -i in.avi -vn -ab 64k -ar 22050 out.mp2

[edit] Video Encoding

MoonShell can be very particular about the types of MPEG video it will decode correctly. Videos made with ffmpeg do not work very well; MEncoder seems to be a better option. The FPS and bitrate rely on personal preference, but the DS does not have much processing power - lower bitrates and framerates seem to work better. Finally, since the DS screen is so small, rescaling to 256 by 192 is the most space-efficient.

Here is an example command using MEncoder (this should be on one line):

mencoder in.avi -o out.mpg -nosound -ovc lavc -lavcopts vcodec=mpeg1video:vrc_buf_size=327:vrc_maxrate=512:vbitrate=256:vstrict=-1 -ofps 18 -vf scale=256:192

This produces an AVI with a working MPEG video stream, but it should be extracted into a raw format with ffmpeg, however, this is not required:

ffmpeg -i out.mpg -an -vcodec copy -f mpeg1video out.raw.mpg

Or, in more recent versions of mencoder you can just add the following option:

-of rawvideo

This makes MEncoder output raw video with no need to extract it later with ffmpeg.

2.DPG 파일 생성 소스

1. #include "stdio.h"
   #include "stdlib.h"
2. void putint(unsigned int i, FILE* outfile) {
      fputc(i & 0xff, outfile);
      i >>= 8;
      fputc(i & 0xff, outfile);
      i >>= 8;
      fputc(i & 0xff, outfile);
      i >>= 8;
      fputc(i & 0xff, outfile);
   }
3. int main(int argc, char* argv[]) {
      int frames;
      int fps;
      int samplerate;
      int audiosize;
      int videosize;
     
      //char* filename = "header",0;
      FILE* outfile;
     
      if (argc != 7) {
         printf("usage: headermaker <frames> <fps> <samplerate> <audiosize> <videosize> <filename>\n");
         return -1;
      }
     
      // read our parameters
      frames  = atoi(argv[1]);
      fps   = atoi(argv[2]);
      samplerate = atoi(argv[3]);
      audiosize = atoi(argv[4]);
      videosize = atoi(argv[5]);
     
      outfile = fopen(argv[6], "wb");
     
      // magic number:
      fputc(0x44, outfile);
      fputc(0x50, outfile);
      fputc(0x47, outfile);
      fputc(0x30, outfile);
     
      // frames
      putint(frames, outfile);
     
      // fps
      fputc(0x00, outfile);
      fputc(fps%256, outfile);
     
      fputc(0x00, outfile);
      fputc(0x00, outfile);
     
      // samplerate
      putint(samplerate, outfile);
     
      // channels
      putint(0, outfile);
     
      // begin and size audio
      putint(36, outfile);
      putint(audiosize, outfile);
     
      // begin and size video
      putint(36+audiosize, outfile);
      putint(videosize, outfile);
     
      fclose(outfile);
     
      return 0;
   }

3.마치면서...

 아주 간단한 파일 포맷이다. 시간나면 인코딩 라이브러리를 이용해서 직접 생성해봐야겠다.

이 글은 스프링노트에서 작성되었습니다.

참고. ARM 어셈블리(Assembly)

원문 : http://kkamagui.springnote.com/pages/432792

들어가기 전에...

1.ARM/THUMB Common Part

1.1 Condition Code

 ARM의 어셈블리 명령어들은 뒤에 post fix가 붙는데, 그 post fix의 의미는 아래와 같다. 일반적으로 아무것도 붙지 않으면 AL이라고 가정한다. Branch 명령인 B와 같은 경우 그냥 사용하면 BAL이 되고 BEQ와 같은 조합으로 CPSR에 있는 Condition flag를 이용하여 조건 분기와 같은 역할을 할 수 있는 것이다.

1.2 Addressing Mode

1.3 Shifter operand Mode

12. <Rm>, =XXX => XXX의 Address를 Rm에 넣는다.

1.4 Post-Fix

• S : 계산 후 CPSR에 SPSR을 넣어 복구
• ! : 계산 결과를 Base Register에 적용
• ^ : PC가 포함된 경우는 연산 후 CPSR에 SPSR을 넣어 복구 or SYSTEM/USER 모드가 아닌 경우이고 PC가 없는 경우는 SYSTEM/USER 모드 레지스터에 값을 로드/스토어

2.ARM/THUMB 명령어 리스트

2.1 필수 참고 사항

• <Rd> : 목적지 레지스터를 의미, 일반적으로 결과값을 저장하거나 전송할 레지스터의 값
• <post fix : 'S'>
  • <Rd>에 PC가 있을 경우 계산 후 CPSR에  SPSR의 값을 대입. SPSR이 존재하지 않는 모드(SYSTEM/USER) 모드일 경우는 동작을 보장할 수 없음
  • <Rd> PC가 없을 경우 계산 결과 플래그를 CPSR에 업데이트
• <post fix : '!'> : 계산 후 Base Register의 값을 갱신. Multiple Load/Store Instruction 시에 유용히 쓰임
• <shifter_operand> : #1와 같이 값 자체로도 쓰일 수 있으며 LSL #2와 같이 배럴 쉬프터(Shifter)를 사용해서 할 수도 있다.

2.2 ARM 모드 Instruction List

• ADC : Add with carry 
  • ADC{<cond>}{S} <Rd>, <Rn>, <shifter_operand>
  • <Rd> = <Rn> + <sifter_operand>

• ADD : 
  • ADD{<cond>}{S} <Rd>, <Rn>, <shifter_operand>

• AND : 
  • AND{<cond>}{S} <Rd>, <Rn>, <shifter_operand>

• B, BL : Branch
  • B{L}{<cond>} <target_address>
  • BL의 경우 LR 레지스터에 PC + 4의 값을 대입

• BIC : Bit Clear
  
  • BIC{<cond>}{S} <Rd>, <Rn>, <shifter_operand>

• BKPT : Breakpoint
  • BKPT <immediat>

• BLX : Branch with Link and Exchange
  • BLX{<cond>} <target_addr>
  • Target_Addr의 값의 bit 0의 값으로 CPSR의 THUMB 모드를 설정한다.
  • ARM 모드와 THUMB 모드를 변환하는데 사용된다.

• BX : Branch And Exchange
  • BLX{<cond>} <Rm>
  • Rm의 bit 0의 값으로 CPSR의 THUMB 모드를 설정한다.
  • ARM 모드와 THUMB 모드를 변화하는데 사용된다.

• CDP : Coprocessor Data Processing 
  • CDP{<cond>} <coproc>, <opcode_1>, <CRd>, <CRn>, <CRm>, <opcode_2>
  • CDP2{<cond>} <coproc>, <opcode_1>, <CRd>, <CRn>, <CRm>, <opcode_2>

• CLZ : Count Leading Zeros 
  • CLZ{<cond>} <Rd>, <Rm>
  • MSB부터 LSB로 가면서 1로 설정된 첫번째 bit까지 0이 몇개인가 헤아린다.

• CMN : Compare Negative(음수)
  • CMN{<cond>} <Rd>, <Shifter_operand> 
  • Add를 기반으로 비교
  • 두개가 같으면(결과가 0이면) CPSR의 Z 비트가 1로 설정
  • Shifter_operand의 nagative 값과 <Rd>를 비교한 후 결과를 CPSR에 저장

• CMP : Compare
  • CMP{<cond>} <Rd>, <Shifter_operand>
  • Substract를 기반으로 비교
  • 두개가 같으면(결과가 0이면) CPSR의 Z 비트가 1로 설정
  • Shifter_operand의 값과 <Rd>를 비교한 후 결과를 CPSR에 저장

• EOR : Exclusive OR
  • EOR{<cond>}{S} <Rd>, <Rn>, <Shifter_operand>

• LDC : Load Coprocessor
  • LDC{<cond>}{L} <coproc>, <CRd>, <addressing_mode>
  • LDC2{<cond>}{L} <coproc>, <CRd>, <addressing_mode>

• LDM : Load Multiple Instruction
  • LDM{<cond>}<addressing_mode> <Rn>{!}, <registers>
  • PC가 <registers>에 포함되어있으면 BX 명령과 같은 동작을 한다. (0 bit에 따라서 THUMB 모드와 ARM 모드가 바뀐다.)
  • registers는 낮은 번호의 레지스터부터 높은 번호의 레지스터 순서로 정렬되어야 한다.
  • '!'가 붙으면 Load가 끝난 Rn 레지스터의 값이 Registers의 갯수 * 4 만큼 증가된다.
  • 레지스터의 낮은 번호는 메모리의 낮은 주소(Rn의 시작주소)에 로드되고 레지스터의 높은 주소는 메모리의 높은 주소(Rn + ( regiser 개수 - 1 ) * 4)에 로드된다.
  • LDM{<cond>}<addressing_mode> <Rn>{!}, <registers_without_pc>^
    • resisters 에 포함된 레지스터는 User Mode의 레지스터를 의미한다.
  • LDM{<cond>}<addressing_mode> <Rn>{!}, <registers_pc>^  
    • 레지스터를 로드한 후에 SPSR의 값을 CPSR에 넣는다.

• LDR : Load Register
  • LDR{<cond>} <Rd>, <addressing_mode>
  • <Rd>가 PC인 경우는 BX와 같이 동작한다.

• LDRB : Load Register Byte
  • LDR<cond>}B <Rd>, <addressing_mode>
  • <Rd>에는 하위 8bit는 값이 설정되고 나머지는 0으로 체워진다.

• LDRBT : Load Register Byte Width Translation 
  • LDR{<cond>}BT <Rd>, <post_indexed_addressing_mode>

• LDRH : Load Register Halfword
  • LDR{<cond>}H <Rd>, <addressing_mode>

• LDRSB : Load Register Signed Byte
  • LDR{<cond>}SB <Rd>, <addressing_mode>

• LDRSH : Load Register Signed Halfword 
  • LDR{<cond>}SH <Rd>, <addressing_mode>

• LDRT : Load Register with Translation
  • LDR{<cond>}T <Rd>, <post_indexed_addressing_mode>

• MCR : Move to Coprocessor from ARM Register
  • MCR{<cond>} <coproc>, <opcode_1>, <Rd>, <CRn>, <CRm>, {, <opcode_2>}
  • MCR2{<cond>} <coproc>, <opcode_1>, <Rd>, <CRn>, <CRm>, {, <opcode_2>}

• MLA : Multiply Accumlator 
  • MLA{<cond>}{S} <Rd>, <Rm>, <Rs>, <Rn>
  • Rd = ( Rm * Rs + Rn )

• MOV : Move
  • MOV{<cond>}{S} <Rd>, <shifter_operand> 

• MRC : Move To ARM Register from Coprocessor
  • MRC{<cond>} <coproc>, <opcode_1>, <Rd>, <CRn>, <CRm>, {, <opcode_2>}
  • MRC2{<cond>} <coproc>, <opcode_1>, <Rd>, <CRn>, <CRm>, {, <opcode_2>}

• MRS : Move PSR to General-purpose register
  • MRS{<cond>} <Rd>, CPSR
  • MRS{<cond>} <Rd>, SPSR 

• MSR : Move To Status Register From ARM
  • MSR{<cond>} CPSR_<fields>, #<Immediate> 
  • MSR{<cond>} CPSR_<fields>, <Rm> 
  • MSR{<cond>} SPSR_<fields>, #<Immediate> 
  • MSR{<cond>} SPSR_<fields>, <Rm> 
  • PSR의 특정 비트 플래그만 조작할 수 있다. 
    • fields : c or x or s or f

• MUL : Multiply
  • MUL{<cond>}{S} <Rd>, <Rm>, <Rs>
  • <Rd> = <Rm> + <Rs>

• MVN : Move Negative
  • MVN{<cond>}{S} <Rd>, <shifter_operand> 

• ORR : Logical OR
  • ORR{<cond>}{S} <Rd>, <Rn>, <shifter_operand> 

• RSB : Reverse Subtract
  • RSB{<cond>}{S} <Rd>, <Rn>, <shifter_operand> 
  • <Rd> = <shifter_operand> - <Rn>

• RSC : Reverse Substract Width Carry
  • RSC{<cond>}{S} <Rd>, <Rn>, <shifter_operand> 
  • <Rd> = <shifter_operand> - <Rn> - NOT(C Flag)

• SBC : Substract with Carry
  • SBC{<cond>}{S} <Rd>, <Rn>, <shifter_operand> 
  • <Rd> = <Rn> - <shifter_operand> - NOT(C Flag)

• SMLAL : Signed Multiply Accumulate Long
  • SMLAL{<cond>}{S} <RdLo>, <RdHi>, <Rm>, <Rs> 
  •  

• SMULL : Signed Multiply Long
  • SMULL{<cond>}{S} <RdLo>, <RdHi>, <Rm>, <Rs> 
  • 

• STC : Store Coprocessor
  • STC{<cond>}{L} <coproc>, <CRd>, <addressing_mode>
  • STC2{L} <coproc>, <CRd>, <addressing_mode>
  • coprocessor의 레지스터 <CRd>로 부터 <addressing_mode>로 값을 저장

• STM : Store Multiple
  
  • STM{<cond>}<addressing_mode> <Rn>{!}, <registers>
  • STM{<cond>}<addressing_mode> <Rn>{!}, <registers>^
  • <Rn>의 메모리주소부터 시작하여 <registers>의 값을 저장
  • 레지스터의 낮은 번호는 메모리의 낮은 주소(Rn의 시작주소)에 저장되고 레지스터의 높은 주소는 메모리의 높은 주소(Rn + ( regiser 개수 - 1 ) * 4)에 저장된다.
  • '^'가 포함되면 User 모드의 레지스터가 저장됨

• STR : Store Register
  • STR{<cond>} <Rd>, <addressing_mode>
  • <addressing_mode> = <Rd>

• STRB : Store Register Byte
  • STR{<cond>}B <Rd>, <addressing_mode>
  • <addressing_mode> = Rd[7:0]

• STRBT : Store Register Byte width Translation
  • STR{<cond>}BT <Rd>, <post_indexed_addressing_mode>

• STRH : Store Register Halfword
  • STR{<cond>}H <Rd>, <addressing_mode>

• STRT : Store Register with Translation
  • STR{<cond>}T <Rd>, <post_indexed_addressing_mode>

• SUB : Substract
  • SUB{<cond>}{S} <Rd>, <Rn>, <shifter_operand>
  • <Rd> = <Rn> - <shifter_operand>

• SWI : Software Interrupt
  • SWI{<cond>} <immed_24> 

• SWP : Swap
  • SWP{<cond>} <Rd>, <Rm>, [<Rn>]
  • <Rd> = [<Rn>],  [<Rn>] = <Rm>

• SWPB : Swap Byte
  • SWP{<cond>}B <Rd>, <Rm>, [<Rn>]
  • <Rd> = [<Rn>],  [<Rn>] = <Rm>

• TEQ : Test Equivalence
  • TEQ{<cond>} <Rd>, <shifter_operand>
  • Logical Exclusive OR를 이용해서 비교
  • 두 값이 같으면 CPSR의 Z 플래그가 1로 세팅

• TST : Test
  • TST{<cond>} <Rn>, <shift_operand>
  • AND 이용해서 비교
  • 결과가 0이면 CPSR의 Z 비트가 1로 셋팅

• UMLAL : Unsigned Multiply Accumulate Long
  • UMLAL{<cond>}{S} <RdLo>, <RdHi>, <Rm>, <Rs>
  • 

• UMULL : Unsigned Multiply Long
  • UMULL{<cond>}{S} <RdLo>, <RdHi>, <Rm>, <Rs>
  • 

2.3 THUMB 모드 Instruction List

• BL, BLX : Branch with Link, Branch with Link Exchange
  • BL <target_addr>
  • BLX <target_addr>
  • 
  • 
  • THUMB 모드의 BL은 LR 레지스터에 0bit를 1로 셋팅하여 BX LR과 같은 명령 사용 시 THUMB 모드로 다시 돌아올 수 있도록 하고 있다.

3.ARM C Calling Convention

 ARM의 경우 레지스터가 많기 때문에 Intel과는 달리 4개의 파라메터까지는 Register 0 ~ Register 3에 저장하게 된다. R0 같은 경우는 일반적으로 리턴 값으로 사용되기도 하며, Register 4 ~ Register 8은 Callee에서 사용하는 레지스터이다.

 Caller는 R0 ~ R3 까지를 저장하고 복원할 책임을 가지며 Callee는 R4 ~ R8 까지를 저장하고 복원하는 책임을 가진다.

<APCS(Arm Procedure Call Standard)에서 각 레지스터의 역할>

 ARM에서 Branch를 하면 LR 레지스터에 Return Address가 저장되므로, 다시 다른 함수를 Call 하게 되면 LR 레지스터를 저장하고 다시 복구해야 한다.

4.마치며...

 ARM 어셈블리에 대해서 간략하게나마 정리했다. 시간 날때 틈틈히 찾아보도록 하자.

이 글은 스프링노트에서 작성되었습니다.

참고. ARM Processor Overview

원문 : http://kkamagui.springnote.com/pages/430849

들어가기 전에...

0.시작하면서...

 예전에 한번 StrongARM(ARM7)을 이용해서 간단한 OS를 만들어 본적이 있었다. 물론 아주 오래전 일이라 기억이 잘 안나지만 ARM 메뉴얼과 어셈블리어를 가지고 시름하여 결국 태스트 스위칭 기능까지 구현할 수 있었다.

 시간이 흘러... 이제 NDS에 커널을 올려볼까 하고 있는데... 다시 어셈블리어를 보고 프로세서에 대해서 볼려니 아주 눈물이 난다. ㅜ_ㅜ.... 그래도 일단 봐야지... 어찌하겠는가... 크윽.. ㅜ_ㅜ

 간단하게 프로그래밍하기위한 기능적인 부분만 보자.

1.ARM Architecture 소개

 ARM은 RISC 구조의 CPU로써 매우 간단한 명령에들로 구성되어있다. ARM이 하버드 아키텍쳐를 사용했으며 어쩌구 저쩌구 하는 내용은 일단 생략하고... 나의 입장에서 보는 ARM의 구조는 그냥 단순한 블랙박스인데... 레지스터가 굉장히 많고 여러가지 모드를 가진 32bit CPU라는 정도이다. ARM에 대한 자세한 내용은 첨부에 올린 ARM Architecture Manual을 참고하도록 하자.

1.1 ARM Register

1.1.1 Register Overview And General Register

 ARM은 여러모드를 가지고 있는데, 한 모드에서는 32bit R0 ~ R15까지 16개의 범용 레지스터 및 CPSR/SPSR의 상태 레지스터를 가진다.

 몇개의 레지스터는 특수한 이름과 의미를 가지고 있는데 아래와 같다.

• R13 : Stack의 Top을 가리키는 sp 레지스터
• R14 : 함수 호출 시 리턴 주소를 저장하는 용도의 Link Register(lr) 레지스터
• R15 : 경우는 현재 수행중인 명령 위치를 가리키는 pc 레지스터

  몇개의 레지스터는 모드에 따라서 각 모드 전용의 레지스터를 가지는데, 일단 아래를 보자.

<ARM의 Register들>

 위에서 보면 좌측 하단의 작은 삼각형이 있는 레지스터들이 있다. 이 레지스터들이 해당 모드의 전용 레지스터로써 R13(sp)와 R14(lr)의 경우는 거의 모든 모드에서 개별 모드의 레지스터를 사용한 다는 것을 알 수 있다. 그리고 User 모드와 System 모드는 레지스터를 그대로 공유한다. 일단 이 정도만 알아두자.

1.1.2 PSR(Program Status Registers)

 PSR(Program Status Register) 레지스터는 현재 프로그램이 실행되는 모드를 나타내는 레지스터로써 현재 상태를 나타내는 CPSR과 이전의 상태를 나타내는 SPSR 레지스터가 존재한다. SPSR의 경우는 User 모드나 System 모드에서 실행중인 프로그램이 특정 Exception 모드로 변경되었을 때, User/System 모드의 CPSR을 저장하는 용도로 사용된다.

<PSR 레지스터의 구조>

 ARM Architecture Manual을 보면 각 플래그에 대해서 아래와 같이 설명해 놓았다.

 

<PSR 레지스터 설명>

  PSR의 아래 5bit는 Mode를 바꾸는데 사용된다. 직접 값을 CPSR이나 SPSR에 넣어서 모드를 바꾸는 것 또한 가능하므로 특정 모드로 전환할 수 있다. THUMB 모드의 경우 T Bit가 1로 설정된다는 정도만 알아두자.

2.ARM CPU Mode

 ARM은 총 7개의 Processor Mode를 가지고 있다.

<ARM Processor Mode>

 앞서 살펴봤듯이 User 모드를 제외한 모든 모드는 특권(Priviledge) 모드이고  User/System을 제외한 다른 모드는 Exception 모드이다.

 재미있는 사용법을 가진 모드를 몇가지 살펴보면 아래와 같다.

• FIQ : ISR 중에 특별히 빨리 처리가 되어야 하는 인터럽트 처리 모드
• IRQ : 일반적인 인터럽트 처리 모드
• Undefined : 명령이나 코프로세서가 존재하지 않아서 발생한 Exception 모드. 여기서 특수한 처리를 해주면 명령을 Emulation 하는 것도 가능

3.ARM Exception Vector And Handling

3.1 Exception Vector

 Exception이 발생하면 당연히 Exception에 대한 처리를 해줘야 하는데 Exception에 따른 처리가 들어있는 곳이 바로 Exception Vector이다.

 Exceptoin Vector의 경우 0x000000000 의 주소에 위치하거나 설정에 따라서 0xFFFF0000 위치에 위치할 수 있다.

<ARM Exception Vector Table>

 위에서 보면 0x14가 빠져있는데 이것은 Reserved 된 Vector 이기 때문에 사용되지 않는다. Exception Vector의 경우 단순히 4Byte의 크기를 가지므로 해당 Exception을 처리하는 루틴으로 jmp하는 명령이 일반적으로 들어있다.

3.2 Exception Handling

 Exception이 발생하면 어떤 일이 생길까? 단순히 모드만 변화되는 것일까? 실제로 Exception이 발생했을 때 일어나는 일은 아래와 같다.

1. // R14(lr) 레지스터에는 Exception 처리를 끝내고 돌아갈 주소가 저장된다.
2. R14_<exception_mode> = return link 
3. SPSR_<exception_mode> = CPSR 
4. CPSR[4:0] = excpetion mode number 
5. // ARM 모드로 강제 전환
6. CPSR[ 5 ] = 0 
7. // 만약 reset 이나 FIQ 같은 경우이면 FIQ를 Disable 시킨다.
8. if <exception_mode> == Reset or FIQ then 
9.     CPSR[ 6 ] = 1
10. // 인터럽트는 무조건 발생 불가
11. CPSR[ 7 ] = 1 
12. // PC에 exception vector의 주소가 입력 됨으로써 해당 주소의 코드가 실행되게 된다.
13. PC = exception vector address 
14. ...... Exception 처리 ......
15. // 처리가 완전히 끝난 후 되돌아 간다.
16. CPSR = SPSR
17. PC = R14_<exception_mode>

 위의 굵은 부분이 처리 흐름 부분인데, 인터럽트를 불가하고 Exception을 처리한다음 다시 복구하는 것을 알 수 있다. CPSR의 값을 SPSR의 값으로 복원하고 PC를 변경하는 것은 이것을 자동으로 해주는 명령어를 통해 할 수 있는데 접미사로 "S'가 붙은 MOVS와 LDMS와 같은 명령으로 가능하다.

 아래는 Exception Handler의 Return 부분을 보여주는 예제이다.

1. SUB R14, R14, #4 
2. STMFD SP!, { XXXXX, R14 } 
3. ...... 처리 ...... 
4. LDMFD SP!, { XXXXX, PC }^ 
5. or MOVS PC, R14
6. or SUBS PC, R14, #4

 ARM 어셈블리에어 대해서는 참고. ARM 어셈블리(Assembly) 를 참고하도록 하고 접미사 S와 ^만 봐두고 넘어가자.

 Exception 처리에 대한 자세한 내용은 ARM Manual의 A2-14에 잘 나와있으므로 참고하자.

3.3 Exception Priority

 Exception이라도 우선 순위가 다른 데, 아래같은 순서를 가진다.

• 1 (Highest) : Reset
• 2 : Data Abort 
• 3 : FIQ 
• 4 : IRQ 
• 5 : Prefetch Abort 
• 6 (Lowest) : Undefined instruction SWI 

4.Memory Mapped I/O

 Memory Mapped I/O는 Port I/O 방식과 달리 메모리 주소에 IO와 통신하는 라인을 연결하여 Memory에 값을 쓰면 버스를 통해 컨트롤러에게 전달되는 방식이다. 따라서 메모리 주소를 공유해서 사용하므로 프로그래밍 시에 접근이 용이하다는 장점이 있으나 실제 사용가능한 메모리 공간이 줄어든다는 단점도 있다.

 Port I/O 같은 경우는 Intel CPU가 대표적으로써 I/O를 위한 별도의 주소공간이 존재하고 I/O를 위해 별도의 명령( IN/OUT )을 통해 데이터를 주고 받는 방식이다.

 == 여기 나중에 내용 더 체우기 ==

4.마치면서...

 ARM에서 프로그래밍을 하기위한 배경지식을 쌓기위해 ARM CPU에 대해서 간략하게 알아보았다. 이제 본격적으로 프로그래밍을 한번 해보자. @0@)/~

5.첨부

• 14128_ArchitectureManaual.pdf : ARM  메뉴얼
• DUI0041C_SoftwareDevelopment.pdf : ARM C Calling Convention에 대한 메뉴얼

이 글은 스프링노트에서 작성되었습니다.

24 WIFI 라이브러리 설치 및 사용방법(작성중)

원문 :  http://kkamagui.springnote.com/pages/551155

들어가기 전에...

0.시작하면서...

 NDS에서 WIFI를 사용할 수 있도록 하는 libwifi가 2007년 9월 일자로 업데이트 되었다. 자세한 내용은 http://www.devkitpro.org 를 참고하면 되고 다운로드는 https://sourceforge.net/project/showfiles.php?group_id=114505&package_id=199021&release_id=541526 에서 직접 내려받을 수 있다

 이제 소스 컴파일부터 실제 사용까지 과정을 알아보자. 

1.소스 컴파일 및 설치

 위의 링크에서 dswifi-src-XXX.XXX 로 표시되어있는 source가 포함된 버전을 받는다. 라이브러리를 받지 않고 굳이 소스를 받는 이유는 현재 사용중인 데브킷 프로의 버전과 라이브러리가 맞지 않을 수도 있고 기타 다른 라이브러리(PALib 등등)를 사용하고 있다면 데브킷 프로의 라이브러리들이 교체되었을 가능성도 있으므로 이런 일련의 문제를 한방에 해결하기위해 소스를 컴파일 하는 것이다.

 소스를 다운받아 적당한 폴더에 압축을 풀고 해당 디렉토리로 이동하여 콘솔창에서 make를 입력하면 라이브러리를 빌드할 수 있다.

 빌드가 끝나면 아래와 같은 화면이 나온다. 

<빌드완료>

 이제 빌드가 완료되었으므로 dswifi의 include와 lib 폴더를 devkitpro가 설치된 libnds 폴더 아래에 복사한다. 같은 이름의 파일들이 있다고 덮어쓸지를 물어보는 데, 전부 다 덮어쓰도록 하자. 이상으로 소스 컴파일 및 설치가 끝났다.

2.라이브러리 사용 

 dswifi를 사용하기위해서는 ARM9과 ARM7 양쪽 코어에서 작업을 해줘야 한다. 조금 까다로운 절차가 필요한데, 다행이 예제 셈플을 제공하고 있다. 예제 셈플은
http://www.akkit.org/dswifi/ 에서 받을 수 있다(라이브러리를 만든 저작자 같다). 비록 0.3 버전의 테스트 소스이지만 정상적으로 동작한다. 물론 손을 좀 봐야하는 것은 당연한 이야기!!!

TODO 

• WIFI 사용 예제 넣기. 아래의 소스를 정리해서 편리하게 쓸 수 있도록 정리하기
• Ad-hoc 소스 정리해서 넣기 

3.마치면서... 

4.첨부 

• dswifi-src-0.3.3.zip : WIFI 소스
• wifi_example.zip : WIFI Test 소스
• wifi_lib_test.zip : dswifi 0.3 버전때 사용하던 테스트 소스. 0.3.3 버전으로 링크하면 동작 안함.. ㅜ_ㅜ. 나중에 손을 좀 봐야겠음.
• wifi_lib_test.nds : dswifi 0.3.3 버전으로 컴파일한 테스트 실행파일

• ad-hoc 구성 관련

  • WMB_Host-lastest.zip
    
  • WMB_Host_0.1.zip
    
  • DownloadPlayHost.zip

이 글은 스프링노트에서 작성되었습니다.

23 Soft Reset 분석

원문 :  http://kkamagui.springnote.com/pages/547779

들어가기 전에...

0.시작하면서...

 홈브루 개발자라면 한번쯤은 자신이 개발한 홈브루도 소프트 리셋(전원 버튼을 누르지 않고 재부팅 시키는 방법)에 대해서 고민해 봤을 것이다. 문쉘(MoonShell)을 보면 플러그인 기능으로 Reset.mse를 통해 소프트 리셋(Soft Reset) 기능을 지원한다. 하지만 사실 문쉘 소스에 있는 Reset.mse는 모든 카드를 지원하지 않는다. 아무래도 제작자가 다 테스트 해보기엔 무리였을지도...

 그런데 얼마전에 3 in 1 Expansion Pack 을 쓰면서 우연히 Rudolph(루돌프인가.. ㅡ_ㅡa..)라는 분이 이 문제를 해결했다는 것을 알았다. 이분 덕택에 문쉘 소프트 리셋 기능이 잘 동작하게 된듯....

 이제 본격적으로 한번 분석해 보자. 

1.ARM9 코드 분석

1. //---------------------------------------------------------------------------------
   int main(void) {
   //---------------------------------------------------------------------------------
     MSEINFO_Readed=MSE_GetMSEINFO(&MSEINFO);
    
     REG_IME=0;
    
     POWER_CR = POWER_ALL_2D;
   //  POWER_CR &= ~POWER_SWAP_LCDS;
     POWER_CR |= POWER_SWAP_LCDS;
    
     SetARM9_REG_WaitCR();
    
     irqInit();
    
     {
       void InitVRAM(void);
       InitVRAM();
       void ShowMSEINFO(void);
       ShowMSEINFO();
       void SoftReset(void);
       SoftReset();
     }
    
     while(1);
   } 

 Soft Reset 함수를 부르는거 말고는 별로 하는 것이 없는 듯 하다.

1. void SoftReset(void)

   {

   const char *pname=MSEINFO.AdapterName;

    

   _consolePrintf("go to farmware menu. [%s]\n",pname);

    

   ERESET RESET=RESET_NULL;

    

   if(strcmp(pname,"M3CF")==0){

   cartSetMenuMode_M3CFSD();

   RESET=RESET_MENU_M3CF;

   }

   if(strcmp(pname,"M3SD")==0){

   cartSetMenuMode_M3CFSD();

   RESET=RESET_MENU_M3SD;

   }

   if(strcmp(pname,"MPCF")==0){

   cartSetMenuMode_MPCF();

   RESET=RESET_MENU_MPCF;

   }

   if(strcmp(pname,"SCCF")==0){

   cartSetMenuMode_SCCFSD();

   RESET=RESET_MENU_SCCF;

   }

   if(strcmp(pname,"SCSD")==0){

   cartSetMenuMode_SCCFSD();

   RESET=RESET_MENU_SCSD;

   }

   if(strcmp(pname,"SCLT")==0){

   cartSetMenuMode_SCCFSD();

   RESET=RESET_MENU_SCSD;

   }

   if(strcmp(pname,"EZSD")==0){

   cartSetMenuMode_EZSD();

   RESET=RESET_MENU_EZSD;

   }

   if(strcmp(pname,"DLMS")==0){

   RESET=RESET_MENU_DSLink;

   IPCEX->RESET=RESET;

   LinkReset_ARM9();

   while(1);

   }

    

   //====== R4TF was added.

   if(strcmp(pname,"R4TF")==0){

   if(FAT_InitFiles() == false) {

   _consolePrintf("Can not initialized FAT.\n");

   while(1);

   }

   FAT_FILE *r4 = FAT_fopen("/_DS_MENU.DAT", "rb");

   (*(vu32*)0x027FFE18) = r4->dirEntSector*512+r4->dirEntOffset*32; <== 이부분 주의

   FAT_fclose(r4);

   _consolePrintf("_DS_MENU.DAT = %08X\n", *(vu32*)0x027FFE18);

    

   _boot_VRAM_clear();

    

   RESET=RESET_MENU_R4TF;

   IPCEX->RESET=RESET;

    

   REG_IME = 0;

   REG_IE = 0;

   REG_IF = REG_IF;

    

   WAIT_CR = 0xE880;

   REG_IPC_SYNC = 0;

   DMA0_CR = 0;

   DMA1_CR = 0;

   DMA2_CR = 0;

    

   ret_menu9_R4();

   while(1);

   }

    

   //====== EZ5S was added.

   if(strcmp(pname,"EZ5S")==0){

   RESET=RESET_MENU_EZ5S;

   IPCEX->RESET=RESET;

   ret_menu9_EZ5();

   while(1);

   }

   //====== by Rudolph (2007/05/25)

    

    

   if(RESET==RESET_NULL){

   _consolePrintf("not support adapter type.\n");

   while(1);

   }

    

   *(vu16*)(0x04000208) = 0; //REG_IME = IME_DISABLE;

   *(vu16*)(0x04000204) |= 0x0880; //sysSetBusOwners(false, false);

   *((vu32*)0x027FFFFC) = 0;

   *((vu32*)0x027FFE04) = (u32)0xE59FF018;

   *((vu32*)0x027FFE24) = (u32)0x027FFE04;

    

   IPCEX->RESET=RESET;

    

   asm("swi 0x00"); //swiSoftReset();

   asm("bx lr");

    

   while(1);

   }

 (*(vu32*)0x027FFE18) = r4->dirEntSector*512+r4->dirEntOffset*32; 코드에서 실제로 카드 내에 FAT 영역의 주소를 ARM7에 넘겨줘서 ARM7이 카드 명령을 통해 데이터를 읽게 만드는 부분이 중요한 부분인것 같다. ARM7에서도 카드에 접근해서 데이터를 읽을 수 있음을 보여주는 예이다.

 이부분에 대한 자세한 내용은 아래의 1.1 참고 부분을 참조하자. 

 아래는 위에서 호출하는 _boot_VRAM_clear() 함수와 ret_menu9_R4() 함수이다.

1. //====== R4TF was added.
   static void _boot_VRAM_clear()
   {
   /*********
    u16 _VRAM_C_CR=VRAM_C_CR;
    u16 _VRAM_D_CR=VRAM_D_CR;
2.  VRAM_C_CR = VRAM_ENABLE | (1 | 0);
    VRAM_D_CR = VRAM_ENABLE | (1 | (1<<3));
3.  memset((char*)0x06000000, 0x00, 0x40000);
4.  VRAM_C_CR=_VRAM_C_CR;
    VRAM_D_CR=_VRAM_D_CR;
   *********/
5. /* 덇렄밒궸?렑궠귢귡궴궞귣궻귒긏깏귺 */
    u16 *vr;
    int i;
6.  u16 _VRAM_C_CR=VRAM_C_CR;
7.  VRAM_C_CR = VRAM_ENABLE | VRAM_C_MAIN_BG_0x6000000;
8.  vr = (u16*)0x06010000;
    for(i = 0; i < 0x10000/2; i++) {
     *vr = 0x0000;
     vr++;
    }
9.  VRAM_C_CR=_VRAM_C_CR;
10. }
    //====== by Rudolph (2007/05/25) 

1.  .ALIGN
    .GLOBAL ret_menu9_R4
    .CODE 32
    .ARM
2. ret_menu9_R4:
3.  mov r0, #0x2000
    orr r0, r0, #0x78
    mov r1, #0x00
    mcr 15, 0, r0, cr1, cr0, 0
    mcr 15, 0, r1, cr7, cr5, 0
    mcr 15, 0, r1, cr7, cr6, 0
    mcr 15, 0, r1, cr7, cr10, 4
    orr r0, r0, #0x50000
    mcr 15, 0, r0, cr1, cr0, 0
4.       ldr r0, =0x027FFDF8
         ldr r1, =0xE51FF004
         str r1, [r0, #0x0]   @ (027ffdf8)=E51FF004:ldr r15,[r15, #-0x4]
         str r0, [r0, #0x4]   @ (027ffdfC)=027FFDF8
5.  bx r0    @ JUMP 027FFDF8
6.  .END 

 위의 ret_menu9_R4까지 호출하면 ARM9은 처리가 완전히 끝난다. 

1.1 참고 (*(vu32*)0x027FFE18) = r4->dirEntSector*512+r4->dirEntOffset*32 코드 분석

 2007/07/26 테스트 결과  r4->dirEntSector 값은 실제 _DS_MENU.DAT가 존재하는 Directory Entry의 물리 섹터 번호를 의미하고 r4->dirEntOffset*32 값은 Directory Entry 내의 Offset을 의미했다. 위의 코드를 아래와 같이 고쳐서 테스트 해본 결과 0x2E0 섹터의 2번째 Offset에 _DS_MENU.DAT 파일이 존재하는 것으로 나왔는데, 실제 확인 결과 그러했다.

1. //====== R4TF was added.
     if(strcmp(pname,"R4TF")==0){
    if(FAT_InitFiles() == false) {
     _consolePrintf("Can not initialized FAT.\n");
     while(1);
    }
    FAT_FILE *r4 = FAT_fopen("/_DS_MENU.DAT", "rb");
    (*(vu32*)0x027FFE18) = r4->dirEntSector*512+r4->dirEntOffset*32;
    _consolePrintf("_DS_MENU.DAT = %08X\n", *(vu32*)0x027FFE18);
    _consolePrintf("Entry Sector = %08X, Entry Offset = %08X\n", r4->dirEntSector, r4->dirEntOffset );
    FAT_fclose(r4);
    while( 1 );
    _boot_VRAM_clear();
2.  RESET=RESET_MENU_R4TF;
    IPCEX->RESET=RESET;
3.  REG_IME = 0;
    REG_IE = 0;
    REG_IF = REG_IF;
4.  WAIT_CR = 0xE880;
    REG_IPC_SYNC = 0;
    DMA0_CR = 0;
    DMA1_CR = 0;
    DMA2_CR = 0;
5.  ret_menu9_R4();
    while(1);
     } 

<실제 분석한 화면>

 이것으로 보아 R4에는 디렉토리 엔트리 정보를 이용해서 실제 파일을 읽어들일 수 있음을 알 수 있었다. 

 또한 rebootlib 소스를 분석하면서 저 _DS_MENU.DAT 파일이 특수한 형태로 암호화된 nds 파일이라는 것을 알 수 있었고, ARM7 소스에서 왜 카드 명령을 통해 다시 읽어오는가도 짐작할 수 있었다. 리버싱을 통해 R4에게 명령을 내리고 R4 카드가 디코딩을 하면 그것을 다시 메모리에 복사하면 굳이 압축 해제 알고리즘을 몰라도 처리 가능하기 때문이었다.

2.ARM7 코드 분석

 아래는 ARM7에서 사용하는 함수 메인이다.

1. __attribute__((noinline)) static void main_Proc_Reset(ERESET RESET)
   {
     switch(RESET){
       case RESET_NULL: return; break;
       case RESET_VRAM: {
         REG_IME = IME_DISABLE; // Disable interrupts
         REG_IF = REG_IF; // Acknowledge interrupt
         *((vu32*)0x027FFE34) = (u32)0x06000000; // Bootloader start address for VRAM
         swiSoftReset(); // Jump to boot loader
       } break;
       case RESET_GBAMP: boot_GBAMP(); break;
       case RESET_GBAROM: boot_GBAROM(); break;
       case RESET_MENU_DSLink: LinkReset_ARM7(); break;
       case RESET_MENU_MPCF: break;
       case RESET_MENU_M3CF: break;
       case RESET_MENU_M3SD: break;
       case RESET_MENU_SCCF: break;
       case RESET_MENU_SCSD: break;
       case RESET_MENU_EZSD: break;
   //====== R4TF was added.
       case RESET_MENU_R4TF: ret_menu7_R4(); break;
   //====== EZ5S was added.
       case RESET_MENU_EZ5S: ret_menu7_EZ5(); break;
   //====== by Rudolph (2007/05/25)
     }
2.   *(vu16*)(0x04000208) = 0;       //REG_IME = IME_DISABLE;
     *((vu32*)0x027FFE34) = *((vu32*)0x027FFFF8);
     asm("swi 0x00");                //swiSoftReset();
     asm("bx lr");
   } 

1. void ret_menu7_R4()
   {
    char *adr;
    u32 blk, siz;
    u32 i;
    u32 *mem;
2.  REG_IME = 0;
    REG_IE = 0;
    REG_IF = REG_IF;
3.  REG_IPC_SYNC = 0;
    DMA0_CR = 0;
    DMA1_CR = 0;
    DMA2_CR = 0;
    DMA3_CR = 0;
4.  while((*(vu32*)0x027FFDFC) != 0x027FFDF8); // Timing adjustment with ARM9
5.  mem = (u32*)0x02000000;
    for(i = 0; i < 0x3FF800/4; i++) {
     *mem = 0x00000000;
     mem++;
    }
   // memset((u8*)0x2000000, 0x00, 0x3FF800);
6.  while(_set_r4menu());
7.  adr = (char*)0x027FFE00;
    _read_r4menu(adr, 0);   // Header
8. 
    blk = (*(vu32*)0x027FFE20) / 512;
    adr = (char*)(*(vu32*)0x027FFE28);
    siz = (*(vu32*)0x027FFE2C);
    for(i = 0; i < siz; i += 512) {  // ARM9
     _read_r4menu(adr, blk);
     blk++;
     adr += 512;
    }
9.  blk = (*(vu32*)0x027FFE30) / 512;
    adr = (char*)(*(vu32*)0x027FFE38);
    siz = (*(vu32*)0x027FFE3C);
    for(i = 0; i < siz; i += 512) {  // ARM7
     _read_r4menu(adr, blk);
     blk++;
     adr += 512;
    }
10.  *(vu32*)0x027FFDFC = *(vu32*)0x027FFE24;
     asm("swi 0x00");   // JUMP 0x027FFE34
11.  while(1);
12. } 

1. static int _set_r4menu()
   {
    u32 add;
2.  add = (*(vu32*)0x027FFE18); <== 이 부분이 _DS_MENU.DAT에 대한 FAT 정보를 읽는 부분이다.
3.  while(CARD_CR2 & CARD_BUSY);
4.  CARD_CR1H = 0xC0;
    CARD_COMMAND[0] = 0xB4;
    CARD_COMMAND[1] = (add >> 24) & 0xFF;
    CARD_COMMAND[2] = (add >> 16) & 0xFF;
    CARD_COMMAND[3] = (add >> 8) & 0xFF;
    CARD_COMMAND[4] = add & 0xFF;
   // CARD_COMMAND[5] = 0x00;
   // CARD_COMMAND[6] = 0x00;
   // CARD_COMMAND[7] = 0x00;
5.  CARD_CR2 = 0xA7586000;
    while(!(CARD_CR2 & CARD_DATA_READY));
6.  return(CARD_DATA_RD);
   } 

1. static int _read_r4menu(char *buf, u32 blk)
   {
    int s = 0;
    u32 *buf32;
2.  buf32 = (u32*)buf;
    blk *= 2;
3. 
    do {
     while(CARD_CR2 & CARD_BUSY);
     CARD_CR1H = 0xC0;
     CARD_COMMAND[0] = 0xB6;
     CARD_COMMAND[1] = (blk >> 16) & 0xFF;
     CARD_COMMAND[2] = (blk >> 8) & 0xFF;
     CARD_COMMAND[3] = blk & 0xFF;
     CARD_COMMAND[4] = 0x00;
   //  CARD_COMMAND[5] = 0x00;
   //  CARD_COMMAND[6] = 0x00;
   //  CARD_COMMAND[7] = 0x00;
     CARD_CR2 = 0xA7586000;
     while(!(CARD_CR2 & CARD_DATA_READY));
    } while(CARD_DATA_RD);
4.  while(CARD_CR2 & CARD_BUSY);
5. 
    CARD_CR1H = 0xC0;
    CARD_COMMAND[0] = 0xBF;
    CARD_COMMAND[1] = (blk >> 16) & 0xFF;
    CARD_COMMAND[2] = (blk >> 8) & 0xFF;
    CARD_COMMAND[3] = blk & 0xFF;
    CARD_COMMAND[4] = 0x00;
   // CARD_COMMAND[5] = 0x00;
   // CARD_COMMAND[6] = 0x00;
   // CARD_COMMAND[7] = 0x00;
    CARD_CR2 = 0xA1586000;
6.  do {
     while(!(CARD_CR2 & CARD_DATA_READY));
     *buf32 = CARD_DATA_RD;
     buf32++;
     s += 4;
    } while(CARD_CR2 & CARD_BUSY);
7.  return(s);
   }

 위에서 사용된 CARD 관련 명령들은 libnds.h에 정의되어있으며 아래와 같다. 

1. // Card bus
   #define CARD_CR1       (*(vuint16*)0x040001A0)
   #define CARD_CR1H      (*(vuint8*)0x040001A1)
   #define CARD_EEPDATA   (*(vuint8*)0x040001A2)
   #define CARD_CR2       (*(vuint32*)0x040001A4)
   #define CARD_COMMAND   ((vuint8*)0x040001A8)
2. #define CARD_DATA_RD   (*(vuint32*)0x04100010)
3. #define CARD_1B0       (*(vuint32*)0x040001B0)
   #define CARD_1B4       (*(vuint32*)0x040001B4)
   #define CARD_1B8       (*(vuint16*)0x040001B8)
   #define CARD_1BA       (*(vuint16*)0x040001BA)
4. 
   #define CARD_CR1_ENABLE  0x80  // in byte 1, i.e. 0x8000
   #define CARD_CR1_IRQ     0x40  // in byte 1, i.e. 0x4000
5. 
   // CARD_CR2 register:
6. #define CARD_ACTIVATE   (1<<31)  // when writing, get the ball rolling
   // 1<<30
   #define CARD_nRESET     (1<<29)  // value on the /reset pin (1 = high out, not a reset state, 0 = low out = in reset)
   #define CARD_28         (1<<28)  // when writing
   #define CARD_27         (1<<27)  // when writing
   #define CARD_26         (1<<26)
   #define CARD_22         (1<<22)
   #define CARD_19         (1<<19)
   #define CARD_ENCRYPTED  (1<<14)  // when writing, this command should be encrypted
   #define CARD_13         (1<<13)  // when writing
   #define CARD_4          (1<<4)   // when writing
7. // 3 bits in b10..b8 indicate something
   // read bits
   #define CARD_BUSY       (1<<31)  // when reading, still expecting incomming data?
   #define CARD_DATA_READY (1<<23)  // when reading, CARD_DATA_RD or CARD_DATA has another word of data and is good to go

 CARD에 직접 명령을 내려서 이것을 처리할려면 R4에 대해서 자세히 안다는 전제가 필요한데... 정말 대단한 사람들이 아닐 수 없다. 이걸 다 어떻게 분석한거지... ㅡ_ㅡ;;;

 Card에 대한 내용은 GBATEK(http://nocash.emubase.de/gbatek.htm#dsmemorycontrolcartridgesandmainram)에서 찾을 수 있다.

3.libfat 코드 분석 

 구버전의 GBA FS는 File ID에 FILE_STRUCTURE 포인터를 그대로 넘기도록 되어있어서 File ID를 이용하면 FAT 관련 정보를 모두 얻어낼 수 있었다. 하지만 libfat로 업그레이드 되면서 POSIX 표준 함수(fopen, fwrite, fread, fclose 등)을 지원하게 되었고 구조가 조금 달라지게 되었다. 물론 FILE* 값을 이용해서 fileno() 함수로 File ID를 얻어올 수 있지만 테스트 결과 GBA FS 처럼 FILE_STRUCTURE로 캐스팅해서 값을 정상적으로 얻을 수 없었다(물론 잠결에 테스트 했기때문에, 좀더 테스트를 진행해 봐야 한다.. ㅡ_ㅡa..)

 다행이도 libfat의 Partition 관련 변수가 export 되어있으므로 그 변수를 이용해서 FAT 관련 기본정보를 얻을 수 있고, diropen() 과 같은 함수를 사용하면 Directry 구조체를 얻을 수 있는데 이것을 이용하면 Directory Entry에 대한 정보를 얻을 수 있으므로 GBA FS 수준의 정보를 얻을 수 있다. 

3.1 dir.h 분석

1. /* Directory iterator for mantaining state between dir* calls */
   typedef struct {
       int device;
       void *dirStruct;
   } DIR_ITER;
2. DIR_ITER* diropen (const char *path);
   int dirreset (DIR_ITER *dirState);
   int dirnext (DIR_ITER *dirState, char *filename, struct stat *filestat);
   int dirclose (DIR_ITER *dirState); 

 위의 코드를 보면 diropen() 함수는 DIR_ITER* 를 리턴한다. 구조체의 dirStruct 필드가 심상치 않은데, 예상대로 아래에서 보듯 DIR_STATE_STRUCT 구조체를 얻을 수 있다. 

3.2 fatdir.c 

1. int _FAT_dirnext_r (struct _reent *r, DIR_ITER *dirState, char *filename, struct stat *filestat) {
    DIR_STATE_STRUCT* state = (DIR_STATE_STRUCT*) (dirState->dirStruct);
2.  // Make sure we are still using this entry
    if (!state->inUse) {
     r->_errno = EBADF;
     return -1;
    } 

 DIR_STATE_STRUCT는 아래에서 볼 수 있다.

3.3 fatdir.h 

1. typedef struct {
    PARTITION* partition;
    DIR_ENTRY currentEntry;
    u32 startCluster;
    bool inUse;
    bool validEntry;
   } DIR_STATE_STRUCT;

 만세, PARTITION 정보와 DIR_ENTRY 구조체 정보를 얻을 수 있다.

3.4 patition.h 

1. #ifdef NDS
   typedef enum {PI_DEFAULT, PI_SLOT_1, PI_SLOT_2, PI_CUSTOM} PARTITION_INTERFACE;
   #else
   typedef enum {PI_CART_SLOT} PARTITION_INTERFACE;
   #endif
2. typedef struct {
    u32 fatStart;
    u32 sectorsPerFat;
    u32 lastCluster;
    u32 firstFree;
   } FAT;
3. typedef struct {
    const IO_INTERFACE* disc;
    CACHE* cache;
    // Info about the partition
    bool readOnly;  // If this is set, then do not try writing to the disc
    FS_TYPE filesysType;
    u32 totalSize;
    u32 rootDirStart; <== 실제 Root Directory가 시작되는 물리 섹터 번호. 이것으로 접근하면 바로 Root Directory를 찾을 수 있다.
    u32 rootDirCluster;
    u32 numberOfSectors;
    u32 dataStart;
    u32 bytesPerSector;
    u32 sectorsPerCluster;
    u32 bytesPerCluster;
    FAT fat;
    // Values that may change after construction
    u32 cwdCluster;   // Current working directory cluser
    u32 openFileCount;
   } PARTITION;

 FAT에 관련된 거의 대부분의 정보는 PARTITION 구조체에서 얻을 수 있다. IO_INTERFACE 구조체를 이용하면 현재 사용중인 Device의 타입을 알 수 있다.

1. extern PARTITION* _FAT_partitions[];

 위와 같이 사용하면 실제 libfat에 있는 파티션 정보를 얻어올 수 있고, 인덱스로 PI_DEFAULT( 0 ), PI_SLOT_1( 1 ), PI_SLOT_2( 2 ), PI_CUSTOM( 3 )과 같은 값을 넘겨주면 해당 Partition 정보에 접근할 수 있다. 보통 Default로 설정하여 libfat를 사용하므로 PI_DEFAULT or 0을 넣으면 Partition 정보를 얻을 수 있다.

3.5 disc_io.h

1. #define FEATURE_MEDIUM_CANREAD  0x00000001
   #define FEATURE_MEDIUM_CANWRITE  0x00000002
   #define FEATURE_SLOT_GBA   0x00000010
   #define FEATURE_SLOT_NDS   0x00000020
2. typedef bool (* FN_MEDIUM_STARTUP)(void) ;
   typedef bool (* FN_MEDIUM_ISINSERTED)(void) ;
   typedef bool (* FN_MEDIUM_READSECTORS)(u32 sector, u8 numSecs, void* buffer) ;
   typedef bool (* FN_MEDIUM_WRITESECTORS)(u32 sector, u8 numSecs, void* buffer) ;
   typedef bool (* FN_MEDIUM_CLEARSTATUS)(void) ;
   typedef bool (* FN_MEDIUM_SHUTDOWN)(void) ;
3. 
   typedef struct {
    unsigned long   ul_ioType ;
    unsigned long   ul_Features ;
    FN_MEDIUM_STARTUP  fn_StartUp ;
    FN_MEDIUM_ISINSERTED fn_IsInserted ;
    FN_MEDIUM_READSECTORS fn_ReadSectors ;
    FN_MEDIUM_WRITESECTORS fn_WriteSectors ;
    FN_MEDIUM_CLEARSTATUS fn_ClearStatus ;
    FN_MEDIUM_SHUTDOWN  fn_Shutdown ;
   } IO_INTERFACE, *LPIO_INTERFACE ;

 ul_ioType을 자세히 보면 4Byte의 Charactor ASCII 값으로 되어있고 0Byte ~ 3Byte의 순서로 "M3SD", "M3CF", "R4TF" 와 같은 문자들이 들어있다. 이것을 이용하면 현재 사용중인 Device의 정보도 알 수 있다.

3.6 Directory Navigation으로 정보 뽑기 예제

 첨부에 있는 msev10_reset_R4EZ5_kkamagui.zip의 ARM9 코드를 조금 수정하여 GBA FS를 사용하지 않고 libfat를 이용해서 정보를 뽑아낸 예제이다.

1. //====== R4TF was added.
     if(strcmp(pname,"R4TF")==0)
     {
       PARTITION* pstPartition;
       DIR_ITER* pstCur;
       DIR_STATE_STRUCT* pstDirState;
       int iOffset;
       int iRootDirSector;
      
       char vcBuffer[ 256 ];
      
       fatInitDefault();
      
       iOffset = -1;
       pstCur = diropen( "/" );
       if( pstCur == NULL )
       {
     _consolePrintf("Can Not Open /_DS_MENU.DAT File.\n");
           while( 1 );
       }
       while( dirnext( pstCur, vcBuffer, NULL ) == 0 )
       {
           pstDirState = ( DIR_STATE_STRUCT* ) pstCur->dirStruct; <== 여기가 포인트~ pstDirState를 이용하면 FAT 관련 섹터정보를 얻을 수 있음 자세한건 위의 구조체 참조
           _consolePrintf( "%s %08X\n",
               vcBuffer, pstDirState->currentEntry.dataStart.offset );
           if( strcmp( vcBuffer, "_DS_MENU.DAT" ) == 0 )
           {
               // Offset 자체가 1부터 카운팅 되기 때문에 실제 인덱스를 알려면
               // 1을 빼야한다.
               iOffset = pstDirState->currentEntry.dataStart.offset - 1;
              
               _consolePrintf( "DirEntry = %08X\n", pstDirState->currentEntry.dataStart.offset );
               break;
           }
       }
       dirclose( pstCur );
      
       pstPartition = _FAT_partitions[ 0 ];
       _consolePrintf("partition = %08X %08X\n", 
           pstPartition->rootDirStart, pstPartition->bytesPerSector );
       iRootDirSector = pstPartition->rootDirStart;
2.     // R4 CART에 넘겨줄 _DS_MENU.DAT의 정보가 담긴 Directory Offset 값
       (*(vu32*)0x027FFE18) = iRootDirSector * 512 + iOffset * 32;
       
       while( 1 ); 

<실행 결과>

4.마치면서... 

 간단히 NDS를 소프트웨어적으로 리셋하는 코드에 대해서 살펴보았다. 조금씩 Device 마다 차이는 있지만 결국 NDS의 상태를 초기상태와 비슷하게 만들거나 또는 Firmware를 강제로 메모리에 올린다음 그것을 실행하게 방식으로 처리하는 것을 알 수 있었다.

 더 궁금한 점은 첨부에 올려놓은 소스를 보면 될 것 같고, 다음에는 이것을 이용하여 만든 Reset Library를 소개하고 사용법에 대해서 알아보겠다.

5.첨부 

• reset_mse05.zip
• reset_mse05kr2.zip
• msev10_reset_R4EZ5_kkamagui.zip : devkitPro 20 버전에서 돌아갈 수 있도록 수정한 버전. _BOOT_MP.nds를 실행하면 됨.

이 글은 스프링노트에서 작성되었습니다.

22 타이머(Timer)를 이용한 프로파일러(Profiler) 만들기

원문 : http://kkamagui.springnote.com/pages/503123

들어가기 전에...

0.시작하면서...

 프로그램을 만들다 보면 이상하게 느린 경우가 있다. 대부분이 알고리즘을 잘못 선택했거나, 아니면 쓸데없는 루프를 돈다거나, 극히 드문 경우지만 버퍼 오버플로우가 나서 다른 함수를 실컷 수행하다가 운좋게 다시 돌아오는 경우도 있다(실제로 겪어봤다... ㅡ_ㅡ;;;)

 이런 경우 GetTickCount()나 혹은 다른 카운팅 함수를 이용해서 실행 시간을 측정해서 원인을 분석하는게 일반적이다. 시간을 측정하기 위해서는 어느정도 만족할만한 시간 분해능을 가진 타이머가 필요한데, 마침 NDS에서는 4개의 Timer를 가지고 있으므로 이것을 이용하여 프로파일러를 만들어보자.

1.타이머(Timer) 설정

 타이머는 3번 타이머를 사용한다고 했다. 그럼 이제 남은건 분해능 설정인데, 1/1000초 정도면 괜찮을 것 같다. 아래는 Timer를 1/1000초로 설정한는 소스이다.

1. /**
    프로파일러 초기화
     1/1000 마다 한번씩 튀게 만든다.
   */
   void CProfiler::Initialize( void )
   {
       TIMER3_DATA = TIMER_FREQ_256( 1000 ); 
       TIMER3_CR = TIMER_ENABLE | TIMER_IRQ_REQ | TIMER_DIV_256;
    
       irqSet( IRQ_TIMER3, isrProfilerTimer );
       irqEnable( IRQ_TIMER3 );
   } 

2.최대 프로파일러(Profiler) 개수

 여러군데 값을 저장하여 테스트 할 수 있으므로 어느정도의 개수를 가지도록 해야 할텐데... 일단 지금은 10개로 해놨다.

3.구현

 프로파일러를 구현하는 방법은 의외로 간단하다. 프로파일링을 시작하는 부분에서 현재 Timer의 값을 저장하고, 후에 결과를 출력할 부분에서 현재 값과 저장한 값의 차이를 리턴하여 걸린 시간을 리턴하면 된다.  시간을 계속 갱신하여 인터벌을 계산하고 싶으면 업데이트를 수행하면 된다(윈도우에서 간단하게나마 GetTickCount()를 이용해서 테스트 해본 사람은 금방 알 것이다.)

아래는 Profiler.h의 내용이다.

1. #ifndef __PROFILER_H__
   #define __PROFILER_H__
2. 
   #define MAX_PROFILERCOUNT 10
   #define DWORD unsigned int
3. class CProfiler
   {
   protected:
    static DWORD ms_vdwTime[ MAX_PROFILERCOUNT ];
    
   public:
    CProfiler();
    ~CProfiler();
4.  static void Initialize( void );
    static void Finalize( void );
    
    static void Update( int iIndex );
    static DWORD GetInterval( int iIndex );
    static bool IsValidIndex( int iIndex );
   };
5. #endif /*PROFILER_H_*/
   

 아래는 Profiler.cpp의 내용이다.

1. #include "Profiler.h"
   #include <nds.h>
2. // Static 변수
   DWORD CProfiler::ms_vdwTime[ MAX_PROFILERCOUNT ];
3. static DWORD gs_dwTimerTick = 0;
4. /**
    Profiler Timer의 핸들러 루틴
   */
   void isrProfilerTimer( void )
   {
    gs_dwTimerTick++;
   }
5. 
   /**
    Constructor
   */
   CProfiler::CProfiler()
   {
6. }
7. /**
    Destructor
   */
   CProfiler::~CProfiler()
   {
8. }
9. /**
    프로파일러 초기화
     1/1000 마다 한번씩 튀게 만든다.
   */
   void CProfiler::Initialize( void )
   {
    TIMER3_DATA = TIMER_FREQ_256( 1000 );
    TIMER3_CR = TIMER_ENABLE | TIMER_IRQ_REQ | TIMER_DIV_256;
    
       irqSet( IRQ_TIMER3, isrProfilerTimer );
       irqEnable( IRQ_TIMER3 );
   }
10. /**
     프로파일러 종료
    */
    void CProfiler::Finalize( void )
    {
     TIMER3_CR &= ~TIMER_ENABLE;
     
        irqSet( IRQ_TIMER3, 0 );
        irqDisable( IRQ_TIMER3 );
    }
11. 
    /**
     현재 Timer 값을 Update 한다.
    */
    void CProfiler::Update( int iIndex )
    {
     if( IsValidIndex( iIndex ) == false )
     {
      return ;
     }
     ms_vdwTime[ iIndex ] = gs_dwTimerTick;
    }
12. /**
      걸린 시간을 얻는다.
    */
    DWORD CProfiler::GetInterval( int iIndex )
    {
     if( IsValidIndex( iIndex ) == false )
     {
      return 0xFFFFFFFF;
     }
     return ( gs_dwTimerTick - ms_vdwTime[ iIndex ] );
    }
13. /**
     인덱스가 유효한가 리턴한다.
    */
    bool CProfiler::IsValidIndex( int iIndex )
    {
     if( ( iIndex < 0 ) || ( iIndex >= MAX_PROFILERCOUNT ) )
     {
      return false;
     }
     return true;
    } 

4.사용법

 프로파일러는 Static 함수들을 가지고 있으므로 굳이 객체를 만들 필요 없다. 아래는 사용방법을 나타낸 것이다.

1. // 초기화 
2. CProfiler::Initialize();
3. ...... 생략 ......
4. // 프로파일링 시작 시점
5. // 0번 프로파일러의 값을 갱신한다. 
6. CProfiler::Update( 0 );
7. DoSomething();
8. printf( "실행하는데 걸린 시간 = %d", CProfiler::GetInterval( 0 ) );
9. // 다시 0번 프로파일러 값 갱신
10. CProfiler::Update( 0 );

 아주 간단하다. Update() 및 GetInterval() 함수에 사용된 인덱스는 현재 0 ~ 9번까지 사용할 수 있다.

5.마치면서...

 NDS의 타이머를 이용해서 간단한 프로파일러를 만드는 방법에 대해 알아보았다. NDS의 열악한 디버깅 환경으로 인해 속도 측정에 어려운 부분이 있었다. 이제 프로파일러도 생겼으니 열심히 효율을 높여보자. @0@)/~!!!

6.첨부

• Profiler.h
• Profiler.cpp
  

이 글은 스프링노트에서 작성되었습니다.

20 ARM7/ARM9 커스텀 프로젝트(Custom Project) 만들기

원문 : http://kkamagui.springnote.com/pages/425564

들어가기 전에...

0.시작하면서

 ARM9만 사용해도 어느정도 기능을 갖춘 홈브루를 만들 수 있다. 왠만한 컨트롤은 ARM9에서 할 수 있으며, ARM7에서만 가능한 기능도 IPC를 통해서 libnds가 어느정도 구현해 놓았기 때문이다.

 하지만 여기서 안주할 수 없다. ARM7에 특별한 기능을 추가하기 위해서는 당연히 ARM7 작성하는 것이 필수이다. 그럼 어떻게 ARM7 코드를 작성하여 ARM9 코드와 같이 NDS 파일을 만들 수 있는지 알아보자.

1.Root의 makefile

 \devkitPro\examples\nds\templates 폴더에 가면 Combine 폴더가 있다. Combine 폴더는 ARM7과 ARM9의 elf 파일을 생성하고 그것을 하나로 뭉쳐 nds 파일을 생성하도록 make 파일이 구성되어있다. 일단 Root 폴더에 있는 makefile을 보자.

1. #---------------------------------------------------------------------------------
   .SUFFIXES:
   #---------------------------------------------------------------------------------
   ifeq ($(strip $(DEVKITARM)),)
   $(error "Please set DEVKITARM in your environment. export DEVKITARM=<path to>devkitARM)
   endif
2. include $(DEVKITARM)/ds_rules
3. export TARGET  := $(shell basename $(CURDIR))
   export TOPDIR  := $(CURDIR)
4. 
   .PHONY: $(TARGET).arm7 $(TARGET).arm9
5. #---------------------------------------------------------------------------------
   # main targets
   #---------------------------------------------------------------------------------
   all: $(TARGET).ds.gba
6. $(TARGET).ds.gba : $(TARGET).nds
7. #---------------------------------------------------------------------------------
   $(TARGET).nds : $(TARGET).arm7 $(TARGET).arm9
    ndstool -c $(TARGET).nds -7 $(TARGET).arm7 -9 $(TARGET).arm9
8. #---------------------------------------------------------------------------------
   $(TARGET).arm7 : arm7/$(TARGET).elf
   $(TARGET).arm9 : arm9/$(TARGET).elf
9. #---------------------------------------------------------------------------------
   arm7/$(TARGET).elf:
    $(MAKE) -C arm7
    
   #---------------------------------------------------------------------------------
   arm9/$(TARGET).elf:
    $(MAKE) -C arm9
10. #---------------------------------------------------------------------------------
    clean:
     $(MAKE) -C arm9 clean
     $(MAKE) -C arm7 clean
     rm -f $(TARGET).ds.gba $(TARGET).nds $(TARGET).arm7 $(TARGET).arm9

  위에서 보는 것과 같이 ARM7과 ARM9 폴더 각각의 make를 실행하여 .arm7, .arm9 파일을 생성하고 그것을 ndstool로 합쳐서 nds 파일을 만든다.

2.arm9 및 arm7의 makefile

 arm9의 makefile에 대한 설명은 00 NDS makefile 및 NDS 파일 생성 과정 분석에서 이미 했으니 찾아보도록 하자. ARM7 또한 ARM9의 makefile과 다른 것이 거의 없으니 위 문서를 참조하면 된다.

3.makefile의 수정

 templete 폴더에 있는 makefile은 arm7과 arm9이 거의 비슷하지만 약간 다르다. 아래는 ARM7의 INCLUDES 값이다.

1. INCLUDES := include build

 arm9 및 arm7에 build 폴더를 추가하자. bin2s.exe 파일을 통해 binary 데이터를 롬파일에 추가하면 build 폴더에 .h 파일이 생성된다. 따라서 편리하게 쓰기위해서 build 폴더를 include에 추가하자.

 자작한 Custom Library를 위한 폴더를 추가해서 Custom 폴더에 자주쓰고 거의 변하지 않는 파일들을 넣어서 나중에 다시 사용할 수 있도록 하자.  arm7/arm9 makefile의 SOURCES 부분에 MyLibrary 폴더를 추가하고 arm7/arm9 각각의 폴더에 MyLibrary 폴더를 추가한다. 앞으로 이 폴더에는 자체 제작한 라이브러리 파일을 넣을 것이다.

 DATA 부분에는 롬파일에 메모리 배열형태로 추가할 데이터가 있는 폴더를 넣는다. data 폴더로 설정하고 .bin 파일의 이름으로 파일을 생성하면 bin2s.exe 실행파일에 의해 .o 파일이 생성되어 같이 링크되게 된다.

1. SOURCES  := source MyLibrary
2. DATA     := data

 이 프로젝트를 빌드하면 .arm9 및 .arm7 파일이 생성되고 .nds 파일이 만들어 진다.

4.실행 결과

 생성된 .nds 파일을 실행하면 터치 스크린의 좌표를 찍어주는 아래와 같은 화면이 보인다.

<실행화면>

5.마치며...

 지금까지 ARM7 및 ARM9 모두를 사용하는 Templete 파일을 이용해서 나만의 Custom Project를 생성하는 방법을 알아보았다. 이로써 우리는 ARM7 및 ARM9 코드를 모두 작성할 수 있게 되었다. 폴더가 접혔을 때 백그라운드 처리 또는 끄기, 리부팅과 같은 ARM7에서만 접근 가능한 작업들을 할 수 있게 된 것이다.

 이제 마구마구 기능을 추가해서 멋진 홈브루를 만들어 보자. @0@)/~

6.첨부

• MyTemplete.zip : 사용할 Templete 파일

이 글은 스프링노트에서 작성되었습니다.

10 타이머(Timer) 제어

원문 : http://kkamagui.springnote.com/pages/428819

들어가기 전에...

0.시작하면서...

 타이머는 일정 시간이 지나면 그것을 알려주는 역할을 하는 아주 간단한 장치이다. 아주 간단하지만 OS에서, 특히 시분할 스케줄링을 하는 OS에서는 스케줄링의 시작점이자 프로세스 퍼포먼스 분석의 기초자료가 되는 아주 중요한 역할을 한다. 또한 주기적으로 해야하는 작업의 경우 타이머를 사용해서 하면 편리하게 할 수 있다.

NDS의 타이머에 대해서 자세히 알아보자.

1.타이머 레지스터(Timer Register)

 NDS의 타이머에 대한 내용은 http://nocash.emubase.de/gbatek.htm#dstimers에서 자세히 볼 수 있다. NDS에서는 ARM9 4개, ARM7 4개 총 8개의 타이머를 가지고 있으며 타이머의 클럭은 F = 33.514 MHz 이다.

 GBA와 클럭만 다르고 나머지는 동일하므로 GBA의 타이머에 대한 설명을 보도록 하자.

The GBA includes four incrementing 16bit timers.
Timer 0 and 1 can be used to supply the sample rate for DMA sound channel A and/or B.

4000100h - TM0CNT_L - Timer 0 Counter/Reload (R/W)
4000104h - TM1CNT_L - Timer 1 Counter/Reload (R/W)
4000108h - TM2CNT_L - Timer 2 Counter/Reload (R/W)
400010Ch - TM3CNT_L - Timer 3 Counter/Reload (R/W)
Writing to these registers initializes the <reload> value (but does not directly affect the current counter value). Reading returns the current <counter> value (or the recent/frozen counter value if the timer has been stopped).
The reload value is copied into the counter only upon following two situations: Automatically upon timer overflows, or when the timer start bit becomes changed from 0 to 1.
Note: When simultaneously changing the start bit from 0 to 1, and setting the reload value at the same time (by a single 32bit I/O operation), then the newly written reload value is recognized as new counter value.

 Counter/Reload 레지스터는 16bit 크기를 가지는 레지스터로써, 읽을 때는 현재 카운터의 값을 리턴하고 쓸 때는 타이머 만료 카운트를 설정하는데 사용된다. 주의할 점은 쓸 때(Reload) 만료 카운트의 값이 바로 적용되는 것이 아니라 아래의 타이머 컨트롤(Timer Control) 레지스터의 7Bit의 값이 0 -> 1로 바뀌거나 타이머가 만료되었을 때 내부적으로 복사되어서 사용되는 점이다. 만료 카운트를 즉시 적용시키려면 값을 쓴 다음 타이머를 중지했다가 다시 시작하면 된다.

 만료 카운터를 설정할때 값을 양수로 넣으면 안되고 음수로 넣어야 한다. 즉 타이머 카운팅이 100회되면 만료된다는 것을 설정하고 싶다면 -100을 넣어야 한다. 이 점을 특히 주의해야 한다.

 만약 직접 값을 설정하고 싶다면 매크로를 사용하지 않고 직접 쓸 수 있다. 만약 타이머가 10회 카운트 되면 인터럽트가 발생하도록 설정하려면, 타이머의 값이 16bit이므로 Max 값은 0xFFFF가 된다. 이 값이 0x10000으로 되는 순간 overflow가 발생해서 인터럽트가 발생하므로 따라서 0x10000 - 10의 값을 설정하면 차례로 카운팅 되어 10회 카운트 된 다음 인터럽트가 발생하게 된다. 

4000102h - TM0CNT_H - Timer 0 Control (R/W)
4000106h - TM1CNT_H - Timer 1 Control (R/W)
400010Ah - TM2CNT_H - Timer 2 Control (R/W)
400010Eh - TM3CNT_H - Timer 3 Control (R/W)

Bit Expl. 0-1 Prescaler Selection (0=F/1, 1=F/64, 2=F/256, 3=F/1024) 2 Count-up Timing (0=Normal, 1=See below) 3-5 Not used 6 Timer IRQ Enable (0=Disable, 1=IRQ on Timer overflow) 7 Timer Start/Stop (0=Stop, 1=Operate) 8-15 Not used

When Count-up Timing is enabled, the prescaler value is ignored, instead the time is incremented each time when the previous counter overflows. This function cannot be used for Timer 0 (as it is the first timer).
F = System Clock (16.78MHz). <== GBA의 클럭

 위의 타이머 컨트롤러의 플래그를 보면 만료가 되었을 때 인터럽트를 발생하게 하여 알려주는 옵션이 있다. 이것을 이용하여 인터럽트 발생 시 즉시 어떤 일을 수행하게 하면 타이밍에 민감한 프로그램도 작성할 수 있다.

 프리스케일러(Prescaler)의 경우 타이머 클럭을 특정 값으로 나누어 타이머의 분해능을 선택하는 역할을 한다. 0을 선택한 경우는 1초에 33.514M 번 타이머가 증가하지만 1을 선택한 경우는 1초에 33.514/64번 발생하는 것이다. 자신의 용도에 맞게 잘 사용하면 된다.

 Count-up Timing 옵션이 있는데 이 옵션을 사용하면 프리스케일러 값은 무시되고 바로 이전의 카운터(타이머 1의 경우는 타이머 0, 타이머 2의 경우는 타이머 1...)의 overflow가 발생할 때마다 카운트가 증가하게 된다. 단 타이머 0의 경우는 이전 타이머가 없기 때문에 해당되지 않는다.

2.구현

 타이머에 대한 구현은 devkitPro\libnds\source\include\nds 폴더에 timers.h 파일에서 찾을 수 있다.

1. // Max frequency is: 33554432Hz\n
   // Min frequency is: 512Hz\n
2. // 0x2000000는 33554432와 같다.
3. #define TIMER_FREQ(n)    (-0x2000000/(n)) 
   
4. #define TIMER_FREQ_64(n)  (-(0x2000000>>6)/(n))
   
5. #define TIMER_FREQ_256(n) (-(0x2000000>>8)/(n))
   
6. #define TIMER_FREQ_1024(n) (-(0x2000000>>10)/(n))
7. 
   //! Same as %TIMER_DATA(0).
   #define TIMER0_DATA    (*(vuint16*)0x04000100)
   #define TIMER1_DATA    (*(vuint16*)0x04000104)
   #define TIMER2_DATA    (*(vuint16*)0x04000108)
   #define TIMER3_DATA    (*(vuint16*)0x0400010C)
8. #define TIMER_DATA(n)  (*(vuint16*)(0x04000100+((n)<<2)))
9. // Timer control registers
   //! Same as %TIMER_CR(0).
   #define TIMER0_CR   (*(vuint16*)0x04000102)
   #define TIMER1_CR   (*(vuint16*)0x04000106)
   #define TIMER2_CR   (*(vuint16*)0x0400010A)
   #define TIMER3_CR   (*(vuint16*)0x0400010E)
10. #define TIMER_CR(n) (*(vuint16*)(0x04000102+((n)<<2)))
    
11. #define TIMER_ENABLE    (1<<7)
12. //! Causes the timer to request an Interupt on overflow.
    #define TIMER_IRQ_REQ   (1<<6)
13. //! When set will cause the timer to count when the timer below overflows (unavailable for timer 0).
    #define TIMER_CASCADE   (1<<2)
14. //! Causes the timer to count at 33.514Mhz.
    #define TIMER_DIV_1     (0)
    //! Causes the timer to count at (33.514 / 64) Mhz.
    #define TIMER_DIV_64    (1)
    //! Causes the timer to count at (33.514 / 256) Mhz.
    #define TIMER_DIV_256   (2)
    //! Causes the timer to count at (33.514 / 1024)Mhz.
    #define TIMER_DIV_1024  (3)

 타이머의 주소와 비트 값에 대한 간단한 매크로로 되어있는 것을 알 수 있다.

 그럼 이제 실제로 사용하는 예제를 보자. 아주 간단한데 타이머를 1/1000초 즉 ms 단위로 튀게 하려면 아래와 같이 하면된다. ㅡ,.ㅡ;;;

1. TIMER0_DATA = TIMER_FREQ( 1000 );
2. // 타이머의 시작
3. TIMER0_CR = TIMER_ENABLE | TIMER_IRQ_REQ | TIMER_DIV_1;
4. ...... 생략 ......
5. // 타이머의 종료
6. TIMER0_CR &= ~TIMER_ENABLE;

3.마치면서...

 이상으로 타이머에 대해 알아보았다. 워낙 간단해서 따로 설명할 것도 없었는데... 사용법 정도만 알아놓자.

이 글은 스프링노트에서 작성되었습니다.

09 NDS 홈브루(Homebrew) - KKAMAGUI Defence Tower

원문 : http://kkamagui.springnote.com/pages/575344

들어가기 전에...

0.버전관리

0.시작하면서...

 Defence Tower 스타일의 게임은 인터넷에서 흔히 구할 수 있다. 특히 플레쉬 게임으로 많이 나와있는데, http://www.xgenstudios.com/game.php?keyword=xenotactic 와 같은 게임이 대표적인 Defence Tower 스타일의 게임이라 할 수 있다.

 NDS의 홈브루 게임 중에서도 Defence Tower 류의 게임을 몇개 구할 수 있는데, 게임을 하다 흥미가 생겨서 하나 만들어 보기로 했다.

1.지도(Map) 디자인

 NDS의 화면은 256 * 192 Pixel의 듀얼로 구성되어있다. 위쪽 화면은 상태를 표시하는 화면으로 사용하고, 아래쪽 화면은 게임 진행 및 타워 설치 등등으로 사용하도록 하자. 그럼 이제 화면을 적절히 나누어서 최소 타일로 설정해야 하는데, 하나의 타일 크기가 적의 크기가 되도록 하자.

 일단 최소 단위 블럭은 12 pixel * 12 pixel로 정했고 이것을 NDS의 한 화면으로 나누면 대충 아래와 같은 21 개 * 16 개의 Block이 나온다. 아래는 최외각을 블럭으로 쌓고 그 외의 공간을 중립 공간으로 설정한 맵의 구성이다.

<Map Design>

 이제 최소 블럭 하나씩을 할당해서 적(Enemy)와 타워(Tower)를 할당한 후, 각 타워의 공격 범위(Sight)를 표시하면 아래와 같다.

<적과 타워 설치>

 위의 그림은 공격범위가 3인 타워와 공격범위가 2인 타워를 나타낸다. 각 타워는 해당 범위내에 있는 적을 검색해서 적절한 타이밍에 총을 발사하면 될 것이다.

2.전체 디자인

 게임의 전체적인 구성은 아래와 같이 되어있다.

<클래스 다이어그램>

 게임의 주체는 Tower, Bullet, Enemy의 3가지로 구성되어있다.

• Tower : 타워. 유저가 설치하여 적(Enemy)를 막도록 하는 구조물
• Bullet : 타워가 적을 향해 발사하는 총알
• Enemy : 유저를 괴롭히는 적

 매 Tick 마다 각각의 주체는 적을 검색하고 총알을 쏘고 타워를 피하는 등등의 각자 맡은 일을 한다. 전략의 경우는 여러가지가 있을 수 있기 때문에 Strategy 패턴을 이용하여 쉽게 교체가 가능하도록 했다(전략부분에 대해서는 아래의 알고리즘 항목을 참고하도록 하자).

 MapUtil 클래스를 통해서 Map에 접근함으로써 여기저기 중복될 수 있는 맵 관련 함수를 한 곳에 모았다. 게임의 전체적인 진행은 GameMain 클래스가 맡고 있으며 외부에서 GameMain 클래스를 통해서 게임을 진행하고 현재 진행 상태를 판단하게 된다.

3.알고리즘(Algorithm)

3.1 타워 알고리즘(Tower Algorithm)

 타워의 알고리즘은 아주 간단하다. 타워의 발사 속도 및 범위를 이용해서 주변의 적을 검색하고 주변에 적이 있을 경우 총을 발사하면 된다. 발사 한 후에는 일정시간 이상 대기한 후 다시 발사하면 된다.

 타워의 종류 또한 여러가지 있을 수 있으나, 일단 지금은 단발식 타워만 고려하고 업그레이드가 가능하도록 구현하였다.

3.2 적 알고리즘(Enemy Algorithm)

 적의 알고리즘은 약간 까다롭다. 적의 레벨에 따라서 여러 알고리즘이 존재할 수 있는데, 아래와 같은 요건을 고려하였다.

• 무조건 시작점에서 출구점 방향(왼쪽에서 오른쪽)으로 이동해야 한다.
• 벽 및 타워는 통과할 수 없다.

• 적은 타워의 영향권을 가끔 벗어날 수 있다.

  • 저 레벨의 적은 타워의 발사 범위 영향을 거의 고려하지 않는다.
  • 고 레벨의 적은 타워의 발사 범위 영향을 많이 고려한다.

 글로 쓸려니 약간 추상적인데, 코드로 보면 간단하다. 테스트 방법 및 코드는 아래를 참고하자.

3.3 적 알고리즘 테스트

 MFC를 이용해서 간단히 알고리즘을 테스트하는 프로그램을 제작했다. 직접 눈으로 보면서 프로그래밍하면 더 나을 것 같아서 테스트 프로그램을 만들었다.

<알고리즘 테스트 화면>

 각 ASCII 값이 나타내는 의미는 아래와 같다.

• "1" : 타워. 실제 NDS로 포팅된 후에는 "T"로 바뀜
• "X" : 적
• "@" : 벽
• 붉은색 점 : 타워에서 발사된 총알

 프로그램의 흰 바탕 위에 클릭을 하면 적절히 타워("1")이 설치되고 시작을 누르면 시뮬레이션이 시작된다. 더블 버퍼링을 하지 않았기 때문에 눈이 아프다는 큰 문제가... ㅜ_ㅜ

 테스트 프로그램은 알고리즘을 테스트하기 위한 프로그램이고, 추후 알고리즘을 추가하고 싶을 때 먼저 테스트 한 후 NDS로 포팅하면 된다. 테스트 프로그램은 아래 첨부 파일에 올려 놓았다.

3.4 알고리즘 구성 방법

 적(Enemy)는 다양한 알고리즘으로 구성되어야 하므로 Strategy 패턴을 이용하여 구성하였다. 아래는 전체 클래스 다이어그램에서 전략 알고리즘 부분을 표시한 부분이다.

<클래스다이어그램-Strategy 패턴>

 현재 3가지 타입의 전략이 있는데, 목표를 향해 직선으로 이동하고 중간에 장애물이 있을 때, 아래 위로 살짝 피하는 MoveStraightStrategy를 필두로 하여, 그것을 상속받아서 조금 수정한 AvoidTowerStrategy, 그리고 멍청하게 행동하는 FoolishStrategy가 있다.

 전략은 적이 생성될 때 랜덤하게 선택된다.

3.5 알고리즘 추가 및 테스트

 알고리즘은 아래의 CStrategy를 상속받아서 DeterminDirection() 함수를 구현해 주기만 하면 끝난다.

1. #define DIRECTION_UP    1
   #define DIRECTION_DOWN  2
   #define DIRECTION_LEFT  3
   #define DIRECTION_RIGHT 4

2.  

3. /**
       움직임을 결정하는 전략
   */
   class CStrategy
   {
   protected:
       bool IsCanGo( int iX, int iY );
4. public:
       CStrategy( void );
       virtual ~CStrategy( void );
      
       virtual int DetermineDirection( int iX, int iY, int iLastDirection ) = 0;
   };
   

 리턴값으로 DIRECTION_UP 과 같은 방향 매크로를 넘겨주면 그 방향으로 이동한다. iLastDirection에 이전에 움직였던 방향값이 넘어옴으로 이를 잘 활용하면 여러가지 패턴을 만들 수 있다. 실제 구현 예제는 위를 상속받은 구체 Strategy 클래스를 참고하도록 하자.

3.NDS 포팅

3.1 NDS 개발 환경 및 포팅

 NDS에 윈도우 라이브러리가 구현되어있으므로(물론 내가 만들었다. 자세한 내용은 02 NDS 윈도우 시스템(Windows System)을 참고하자) 위에서 설명한 알고리즘 테스트 프로그램의 소스를 크게 수정없이 사용할 수 있다. 차이라면 개인적인 취향 때문에 함수 몇개가 덜 구현되거나 스타일이 조금 다르다는 정도...?

 아무것도 없는 허허벌판(??)에서 윈도우 라이브러리를 사용하기가 쉽지 않은데, 그래서 템플릿으로 사용할 수 있는 프로젝트를 올려놓았다. 26 윈도우 라이브러리(Window Library) 사용을 위한 프로젝트(Project) 만들기에서 프로젝트 파일을 찾을 수 있다. libfat도 같이 사용하도록 되어있으니 필요없는 사람은 makefile을 수정해서 빼도록하자(libfat를 빼니 홈브루 크기가 120K 정도 줄어든것 같다. @0@ 이럴수가!!! ).

 포팅에 대한 내용은 크게 다루지 않을 것이며 궁금한 사람은 Diff 프로그램으로 위의 테스트 프로그램과 NDS로 포팅된 소스의 내용을 비교해 보면 알 수 있을 것이다. 메인 소스는 거의 바뀌지 않았음을 알 수 있다. 이 얼마나 행복한 일인가... ㅜ_ㅜ

3.2 실행 화면 및 게임 방법

 게임 방법은 아주 간단하다. 타워를 클릭하면 설치하는 데, 일단 설치된 타워에 인접해서 설치는 불가능하다는 조건만 명심하면 된다(이 조건으로 인해 게임 난이도가 살짝 올라갔다. ㅜ_ㅜ). 즉 대충 놓으면 결과적으로 화면에 놓을 수 있는 타워의 개수도 적어지고 게임이 일찍 끝날 확률이 높다.

<게임을 실행한 화면>

4.마치면서...

 디펜스 타워에 빠져서 개발하게 된 홈브루 치고는 좀 허술한데... 실제로 플레이 해보니 나름 할만해서 만족하고 있다. 추후 업그레이드는 별로 고려하지 않고 있지만, 적의 알고리즘이나 타워 설치 부분은 아쉬운 부분이 많아서 업그레이드 할지도...

 매번 프로그램을 작성하면서 느끼는 것이지만 정말 UI에 소질이 없는 것 같다. 프로그램 작성하는 시간보다 그림 그리는데 시간이 더 많이드니... ㅡ_ㅡa... 이거 원 산출이 안맞아서... ㅜ_ㅜ..

 심심하다면 한번쯤 다운 받아서 해보자~ @0@)/~

5.첨부

• SmileWar.zip : NDS 용 프로젝트 파일
• DefenceTest.zip : 윈도우용 테스트 프로젝트 파일
• Defence_Tower.ppt : PPT 파일

이 글은 스프링노트에서 작성되었습니다.

08 사운드(Sound) 제어

원문 : http://kkamagui.springnote.com/pages/423523

들어가기 전에...

1.채널 컨트롤 레지스터(Channel Control Register)

 NDS에는 16개의 사운드 채널이 존재하며 각 채널들은 독립적인 소리를 낼 수 있다. 스피커로 출력되는 소리는 각 채널에서 나는 소리의 합이다.

 IO 블럭은 첫번째 사운드 레지스터들이 0x4000400에서 0x400040F까지 존재하며 16번째 블럭은 0x40004F0에서 0x40004FF까지 존재한다. 사운드 레지스터에 대해서는 http://nocash.emubase.de/gbatek.htm#dssound 에서 자세히 볼 수 있다.

 위의 링크에 문서를 읽어보면 스피커가 2개이기 때문에 스테레오 사운드를 제공할 수 있다고 되어있다. 그런데 아래에 레지스터를 보면 스테레오 모드라는 것이 없다. 어떻게 스테레오를 구현하는 걸까? 곰곰히 생각해보니 스테레오로 Play 하려면 2개의 좌/우 스피커용 파일을 만들고 Panning을 이용해서 각각 넣는게 아닌가 하는 생각이 들었다. 실제로 그렇게 하는지는 의문이지만 가능은 하다는거 @0@)/~!!

40004x0h - ARM7 - SOUNDxCNT - Sound Channel X Control Register (R/W)

Bit0-6 Volume (0..127=silent..loud) Bit7 Not used (always zero) Bit8-9 Data Shift (0=Normal, 1=Div2, 2=Div4, 3=Div16) Bit10-14 Not used (always zero) Bit15 Hold (0=Nothing, 1=Hold) (?) Bit16-22 Panning (0..127=left..right) (64=half volume on both speakers) Bit23 Not used (always zero) Bit24-26 Wave Duty (0..7) ;HIGH=(N+1)*12.5%, LOW=(7-N)*12.5% (PSG only) Bit27-28 Repeat Mode (0=Manual, 1=Loop Infinite, 2=One-Shot, 3=Prohibited) Bit29-30 Format (0=PCM8, 1=PCM16, 2=IMA-ADPCM, 3=PSG/Noise) Bit31 Start/Status (0=Stop, 1=Start/Busy)

All channels support ADPCM/PCM formats, PSG rectangular wave can be used only on channels 8..13, and white noise only on channels 14..15.

 위에서 보면 몇가지 재미있는 옵션들을 볼 수 있다. Panning 모드를 사용하면 스피커 한쪽에서 소리를 내는 것이 가능하며, Repeat 모드를 사용하면 계속해서 소리를 출력할 수 있다. Format 같은 경우 좀 특이하게 PCM/ADPCM/PGS-Noise 모드를 지원한다. 소리를 출력하기위한 포맷이 굳이 PCM이 아니어도 가능하다는 말이다.

 PSG라는 말이 나오는데, 아무래도 Pulse Sound Generator의 의미인것 같고 사인파 같은 파형을 출력하는 것 같다.

40004x4h - ARM7 - SOUNDxSAD - Sound Channel X Data Source Register (W)

Bit0-26 Source Address Bit27-31 Not used

 사운드 소스 레지스터로써 출력할 사운드가 어디에 위치하는지 주소를 넣어준다.

40004x8h - ARM7 - SOUNDxTMR - Sound Channel X Timer Register (W)

Bit0-15 Timer Value, Sample frequency, timerval=-(16777216 / freq)

 The PSG Duty Cycles are composed of eight "samples", and so, the frequency for Rectangular Wave is 1/8th of the selected sample frequency.
For PSG Noise, the noise frequency is equal to the sample frequency.

 16777216의 값은 0x1000000와 같고 타이머 레지스터에 설정되어야 하는 값은 저 값을 -0x1000000의 값을 Frequency로 나눈 값으로 설정해야 한다. Frequency의 값은 11025와 같은 실제 Hz의 값을 넣어줘야 한다.

40004xAh - ARM7 - SOUNDxPNT - Sound Channel X Loopstart Register (W)

Bit0-15 Loop Start, Sample loop start position

 Loop로 반복할 때 시작 위치를 정해줄 수 있는 것 같은데... 자세한 건 테스트를 해봐야 겠다.

40004xCh - ARM7 - SOUNDxLEN - Sound Channel X Length Register (W)
The number of samples for N words is 4*N PCM8 samples, 2*N PCM16 samples, or 8*(N-1) ADPCM samples (the first word containing the ADPCM header). The Sound Length is not used in PSG mode.

Bit0-21 Sound length (counted in words, ie. N*4 bytes) Bit22-31 Not used

Minimum length is 4 words (16 bytes), smaller values (0..3 words) are interpreted as zero length (no sound output).

 Sound Length 레지스터에 입력되는 값은 Word 단위이다. ARM에서 Word 단위는 4Byte이므로 8bit Sample 같은 경우는 전체 길이를 4로 나누어줘야 하고 16bit의 Sample 같은 경우는 2로 나누어줘야 한다.

2.사운드 컨트롤 레지스터(Sound Control Register)

 각 채널별 설정이 아닌 전체에 적용되는 마스터의 성격을 가지는 레지스터이다.

4000500h - SOUNDCNT - ARM7 - Sound Control Register (R/W)

Bit0-6 Master Volume (0..127=silent..loud) Bit7 Not used (always zero) Bit8-9 Left Out (probably selects Mixer or "Bypassed" channels?) Bit10-11 Right Out (probably selects Mixer or "Bypassed" channels?) Bit12 Output Sound Channel 1 (0=To Mixer, 1=Bypass Mixer) Bit13 Output Sound Channel 3 (0=To Mixer, 1=Bypass Mixer) Bit14 Not used (always zero) Bit15 Master Enable (0=Disable, 1=Enable)

4000504h - SOUNDBIAS - ARM7 - Sound Bias Register (R/W)

Bit0-9 Sound Bias (0..3FFh, usually 200h) Bit10-31 Not used (always zero)

After applying the master volume, the signed left/right audio signals are in range -200h..+1FFh (with medium level zero), the Bias value is then added to convert the signed numbers into unsigned values (with medium level 200h).

The sampling frequency of the mixer is 1.04876 MHz with an amplitude resolution of 24 bits, but the sampling frequency after mixing with PWM modulation is 32.768 kHz with an amplitude resolution of 10 bits.

  그냥 살짝 볼 부분은 Master Enable과 Master Volume 부분인 것 같다. 나머지 부분은 그리 중요하지 않은 듯 하므로 패스~

3.구현

 사운드 부분은 ARM7에만 연결되어있으므로, 테스트를 위해 ARM7 코드를 손보거나 아니면 라이브러리를 통해 간접적으로 테스트 해야 한다. 소스가 간단하니 굳이 만들 필요는 없을 것 같고 libnds의 소스를 보도록 하자. 사운드 레지스터 관련 헤더파일은 \devkitPro\libnds\source\include\nds\arm7 폴더에 audio.h 파일을 보면 된다.

1. 
   #define SOUND_VOL(n) (n)
   #define SOUND_FREQ(n) ((-0x1000000 / (n)))
   #define SOUND_ENABLE BIT(15)
   #define SOUND_REPEAT    BIT(27)
   #define SOUND_ONE_SHOT  BIT(28)
   #define SOUND_FORMAT_16BIT (1<<29)
   #define SOUND_FORMAT_8BIT (0<<29)
   #define SOUND_FORMAT_PSG    (3<<29)
   #define SOUND_FORMAT_ADPCM  (2<<29)
   #define SOUND_16BIT      (1<<29)
   #define SOUND_8BIT       (0)
2. #define SOUND_PAN(n) ((n) << 16)
3. #define SCHANNEL_ENABLE BIT(31)
4. //---------------------------------------------------------------------------------
   // registers
   //---------------------------------------------------------------------------------
   #define SCHANNEL_CR(n)    (*(vuint32*)(0x04000400 + ((n)<<4)))
   #define SCHANNEL_VOL(n)    (*(vuint8*)(0x04000400 + ((n)<<4)))
   #define SCHANNEL_PAN(n)    (*(vuint8*)(0x04000402 + ((n)<<4)))
   #define SCHANNEL_SOURCE(n)   (*(vuint32*)(0x04000404 + ((n)<<4)))
   #define SCHANNEL_TIMER(n)   (*(vint16*)(0x04000408 + ((n)<<4)))
   #define SCHANNEL_REPEAT_POINT(n) (*(vuint16*)(0x0400040A + ((n)<<4)))
   #define SCHANNEL_LENGTH(n)   (*(vuint32*)(0x0400040C + ((n)<<4)))
5. #define SOUND_CR          (*(vuint16*)0x04000500)
   #define SOUND_MASTER_VOL  (*(vuint8*)0x04000500)
6. //---------------------------------------------------------------------------------
   // not sure on the following
   //---------------------------------------------------------------------------------
   #define SOUND_BIAS        (*(vuint16*)0x04000504)
   #define SOUND508          (*(vuint16*)0x04000508)
   #define SOUND510          (*(vuint16*)0x04000510)
   #define SOUND514    (*(vuint16*)0x04000514)
   #define SOUND518          (*(vuint16*)0x04000518)
   #define SOUND51C          (*(vuint16*)0x0400051C)

 앞부분에서 설명했던 레지스터의 주소를 매크로로 정의해 놓은 것을 알 수 있다.

 실제 사용된 코드 부분은 \devkitPro\libnds\source\basicARM7\source 폴더의 defaultARM7.c 파일에서 볼 수 있다.

1. //---------------------------------------------------------------------------------
   void startSound(int sampleRate, const void* data, u32 bytes, u8 channel, u8 vol,  u8 pan, u8 format) {
   //---------------------------------------------------------------------------------
    SCHANNEL_TIMER(channel)  = SOUND_FREQ(sampleRate);
    SCHANNEL_SOURCE(channel) = (u32)data;
    SCHANNEL_LENGTH(channel) = bytes >> 2 ; <== 4byte 즉 word 단위 값으로 넣기위해 4로 나누는 부분
    SCHANNEL_CR(channel)     = SCHANNEL_ENABLE | SOUND_ONE_SHOT | SOUND_VOL(vol) | SOUND_PAN(pan) | (format==1?SOUND_8BIT:SOUND_16BIT);
   }
2. 
   //---------------------------------------------------------------------------------
   s32 getFreeSoundChannel() {
   //---------------------------------------------------------------------------------
    int i;
    for (i=0; i<16; i++) {
     if ( (SCHANNEL_CR(i) & SCHANNEL_ENABLE) == 0 ) return i;
    }
    return -1;
   }
3. //---------------------------------------------------------------------------------
   void VblankHandler(void) {
   //---------------------------------------------------------------------------------
4.  u32 i;
5. 
    //sound code  :)
    TransferSound *snd = IPC->soundData;
    IPC->soundData = 0;
6.  if (0 != snd) {
7.   for (i=0; i<snd->count; i++) {
      s32 chan = getFreeSoundChannel();
8.    if (chan >= 0) {
       startSound(snd->data[i].rate, snd->data[i].data, snd->data[i].len, chan, snd->data[i].vol, snd->data[i].pan, snd->data[i].format);
      }
     }
    }
9. }

 위에서 보면 채널 레지스터 설정 시에 타이밍, 소스, 길이 모두 설정한 뒤에 채널 설정 레지스터를 설정하는 것을 볼 수 있다. 타이밍, 소스, 길이 레지스터를 설정하는 순서는 별 의미 없어보이나 채널 설정 레지스터를 설정하는 것은 가장 마지막에 해야 한다.

4.마치며...

 이제 사운드도 출력할 수 있게 되었다. 사운드 정보를 PCM으로 바꾸면 간단히 Play할 수 있으므로 examples 폴더에 있는 사운드 예제를 한번 돌려보자.

이 글은 스프링노트에서 작성되었습니다.

07 문쉘(Moon shell)의 터치스크린(Touch Screen) 소스

원문 :  http://kkamagui.springnote.com/pages/423448

들어가기 전에...

0.시작하면서...

 libnds의 터치스크린 소스는 값이 튀는 문제가 있다. 물론 소프트웨어 적으로 처리하는 방법이 있지만 완전하지 못해서 가장 널리 쓰이는 문쉘(Moon shell)의 소스를 받아서 터치스크린쪽 소스를 봤다. http://mdxonline.dyndns.org/archives/nds/에 가면 NDS의 문쉘소스를 받을 수 있다.

1.libnds의 touch.c

 \devkitPro\libnds\source\source\arm7 폴더의 touch.c 파일을 열어보면 굉장히 복잡한 소스들이 널려있다. 그중에서 터치 스크린에서 값을 읽는 핵심적인 소스만 추리면 아래와 같다.

1. static bool touchInit = false;
   static s32 xscale, yscale;
   static s32 xoffset, yoffset;
2. //---------------------------------------------------------------------------------
   int16 readTouchValue(uint32 command, int16 *dist_max, u8 *err){
   //---------------------------------------------------------------------------------
    int16 values[5];
    int32 aux1, aux2, aux3, dist, dist2, result = 0;
    u8 i, j, k;
3.  *err = 1;
4.  SerialWaitBusy();
5.  REG_SPICNT = SPI_ENABLE | SPI_BAUD_2MHz | SPI_DEVICE_TOUCH | SPI_CONTINUOUS;
    REG_SPIDATA = command;
6.  SerialWaitBusy();
7.  for(i=0; i<5; i++){
     REG_SPIDATA = 0;
     SerialWaitBusy();
8.   aux1 = REG_SPIDATA;
     aux1 = aux1 & 0xFF;
     aux1 = aux1 << 16;
     aux1 = aux1 >> 8;
9.   values[4-i] = aux1;
10.   REG_SPIDATA = command;
      SerialWaitBusy();
11.   aux1 = REG_SPIDATA;
      aux1 = aux1 & 0xFF;
      aux1 = aux1 << 16;
12.   aux1 = values[4-i] | (aux1 >> 16);
      values[4-i] = ((aux1 & 0x7FF8) >> 3);
     }
13.  REG_SPICNT = SPI_ENABLE | SPI_BAUD_2MHz | SPI_DEVICE_TOUCH;
     REG_SPIDATA = 0;
     SerialWaitBusy();
14.  dist = 0;
     for(i=0; i<4; i++){
      aux1 = values[i];
15.   for(j=i+1; j<5; j++){
       aux2 = values[j];
       aux2 = abs(aux1 - aux2);
       if(aux2>dist) dist = aux2;
      }
     }
16.  *dist_max = dist;
17.  for(i=0; i<3; i++){
      aux1 = values[i];
18.   for(j=i+1; j<4; j++){
       aux2 = values[j];
       dist = abs(aux1 - aux2);
19.    if( dist <= range ){
        for(k=j+1; k<5; k++){
         aux3 = values[k];
         dist2 = abs(aux1 - aux3);
20.      if( dist2 <= range ){
          result = aux2 + (aux1 << 1);
          result = result + aux3;
          result = result >> 2;
          result = result & (~7);
21.       *err = 0;
22.       break;
         }
        }
       }
      }
     }
23.  if((*err) == 1){
      result = values[0] + values[4];
      result = result >> 1;
      result = result & (~7);
     }
24.  return (result & 0xFFF);
    }
25. //---------------------------------------------------------------------------------
    // reading pixel position:
    //---------------------------------------------------------------------------------
    touchPosition touchReadXY() {
    //---------------------------------------------------------------------------------
26.  int16 dist_max_y, dist_max_x, dist_max;
     u8 error, error_where, first_check, i;
27.  touchPosition touchPos = { 0, 0, 0, 0, 0, 0 };
28.  if ( !touchInit ) {
29.   xscale = ((PersonalData->calX2px - PersonalData->calX1px) << 19) / ((PersonalData->calX2) - (PersonalData->calX1));
      yscale = ((PersonalData->calY2px - PersonalData->calY1px) << 19) / ((PersonalData->calY2) - (PersonalData->calY1));
30.   xoffset = ((PersonalData->calX1 + PersonalData->calX2) * xscale  - ((PersonalData->calX1px + PersonalData->calX2px) << 19) ) / 2;
      yoffset = ((PersonalData->calY1 + PersonalData->calY2) * yscale  - ((PersonalData->calY1px + PersonalData->calY2px) << 19) ) / 2;
      touchInit = true;
     }
31.  uint32 oldIME = REG_IME;
32.  REG_IME = 0;
33.  first_check = CheckStylus();
     if(first_check != 0){
      error_where = 0;
34.   touchPos.z1 =  readTouchValue(TSC_MEASURE_Z1 | 1, &dist_max, &error);
      touchPos.z2 =  readTouchValue(TSC_MEASURE_Z2 | 1, &dist_max, &error);
35.   touchPos.x = readTouchValue(TSC_MEASURE_X | 1, &dist_max_x, &error);
      if(error==1) error_where += 1;
36.   touchPos.y = readTouchValue(TSC_MEASURE_Y | 1, &dist_max_y, &error);
      if(error==1) error_where += 2;
37.   REG_SPICNT = SPI_ENABLE | SPI_BAUD_2MHz | SPI_DEVICE_TOUCH | SPI_CONTINUOUS;
      for(i=0; i<12; i++){
       REG_SPIDATA = 0;
38.    SerialWaitBusy();
      }
39.   REG_SPICNT = SPI_ENABLE | SPI_BAUD_2MHz | SPI_DEVICE_TOUCH;
      REG_SPIDATA = 0;
40.   SerialWaitBusy();
41.   if(first_check == 2) error_where = 3;
42.   switch( CheckStylus() ){
      case 0:
       last_time_touched = 0;
       break;
      case 1:
       last_time_touched = 1;
43.    if(dist_max_x > dist_max_y)
        dist_max = dist_max_x;
       else
        dist_max = dist_max_y;
44.    break;
      case 2:
       last_time_touched = 0;
       error_where = 3;
45.    break;
      }
46.   s16 px = ( touchPos.x * xscale - xoffset + xscale/2 ) >>19;
      s16 py = ( touchPos.y * yscale - yoffset + yscale/2 ) >>19;
47.   if ( px < 0) px = 0;
      if ( py < 0) py = 0;
      if ( px > (SCREEN_WIDTH -1)) px = SCREEN_WIDTH -1;
      if ( py > (SCREEN_HEIGHT -1)) py = SCREEN_HEIGHT -1;
48.   touchPos.px = px;
      touchPos.py = py;
49. 
     }else{
      error_where = 3;
      touchPos.x = 0;
      touchPos.y = 0;
      last_time_touched = 0;
     }
50.  UpdateRange(&range, dist_max, error_where, last_time_touched);
51.  REG_IME = oldIME;
52. 
     return touchPos;
53. }

 음.. 일단 소스가 좀 복잡하고 뭔가 잘하려고 노력한것 같은데, 문제가 좀 있어보인다. readTouchValue() 소스를 일단 보면 값을 여러번 읽어서 그 값을 평균내는 것 비슷하게 동작하는 것 같은데...  더 문제는 값을 다 읽고 난 다시 CheckStylus() 함수를 이용해서 터치스크린의 상태를 얻어온다는 점이다.

 만약 위에서 값을 읽었을 때 정상적인 터치스크린의 값이 들어왔는데, 뒤에 CheckStylus() 함수에서 체크할 때는 터치가 떨어진 상태라면...? 약간의 시간차가 있는데 이 시간차 때문에 문제가 있어 보인다(실제로도 문제가 있다. ㅡ,.ㅡ;;;)

2.문쉘(Moon Shell)의 _touch.c

 문쉘의 터치스크린 소스는 의외로 간단하다. 전체 소스는 아래와 같다.

1. #include <nds.h>
   #include <nds/jtypes.h>
   #include <nds/system.h>
   #include <nds/arm7/touch.h>
   #include <nds/registers_alt.h>
2. #include <stdlib.h>
3. #include "_touch.h"
4. //---------------------------------------------------------------------------------
   __attribute__((noinline)) static uint16 _touchRead(uint32 command) {
   //---------------------------------------------------------------------------------
    uint16 result;
    SerialWaitBusy();
5.  // Write the command and wait for it to complete
    REG_SPICNT = SPI_ENABLE | SPI_BAUD_2MHz | SPI_DEVICE_TOUCH | SPI_CONTINUOUS; //0x0A01;
    REG_SPIDATA = command;
    SerialWaitBusy();
6.  // Write the second command and clock in part of the data
    REG_SPIDATA = 0;
    SerialWaitBusy();
    result = REG_SPIDATA;
7.  // Clock in the rest of the data (last transfer)
    REG_SPICNT = SPI_ENABLE | 0x201;
    REG_SPIDATA = 0;
    SerialWaitBusy();
8.  // Return the result
    return ((result & 0x7F) << 5) | (REG_SPIDATA >> 3);
   }
9. 
   //---------------------------------------------------------------------------------
   uint32 _touchReadTemperature(int * t1, int * t2) {
   //---------------------------------------------------------------------------------
    *t1 = _touchRead(TSC_MEASURE_TEMP1);
    *t2 = _touchRead(TSC_MEASURE_TEMP2);
    return 8490 * (*t2 - *t1) - 273*4096;
   }
10. 
    static bool touchInit = false;
    static s32 xscale, yscale;
    static s32 xoffset, yoffset;
11. 
    //---------------------------------------------------------------------------------
    __attribute__((noinline)) static s32 readTouchValue(int measure, int retry , int range) {
    //---------------------------------------------------------------------------------
     int i;
     s32 this_value=0, this_range;
12.  s32 last_value = _touchRead(measure | 1);
13.  for ( i=0; i < retry; i++) {
      this_value = _touchRead(measure | 1);
      this_range = abs(last_value - this_value);
      if (this_range <= range) break;
     }
     
     if ( i == range) this_value = 0;
     return this_value;
14. }
15. static int _MaxRetry = 5;
    static int _MaxRange = 30;
16. void _touchReadXY_AutoDetect(void)
    {
      xscale = ((PersonalData->calX2px - PersonalData->calX1px) << 19) / ((PersonalData->calX2) - (PersonalData->calX1));
      yscale = ((PersonalData->calY2px - PersonalData->calY1px) << 19) / ((PersonalData->calY2) - (PersonalData->calY1));
     
      xoffset = ((PersonalData->calX1 + PersonalData->calX2) * xscale  - ((PersonalData->calX1px + PersonalData->calX2px) << 19) ) / 2;
      yoffset = ((PersonalData->calY1 + PersonalData->calY2) * yscale  - ((PersonalData->calY1px + PersonalData->calY2px) << 19) ) / 2;
     
      touchInit = true;
    }
17. // reading pixel position:
    //---------------------------------------------------------------------------------
    touchPosition _touchReadXY() {
    //---------------------------------------------------------------------------------
18.  if(touchInit==false){
       REG_IME=0;
       while(1);
     }
19.  touchPosition touchPos;
20. /*
      if((xscale<128)||(yscale<128)||(xoffset<128)||(yoffset<128)){
     touchPos.px = 0;
     touchPos.py = 0;
21.  return touchPos;
      }
    */
     
     touchPos.x = readTouchValue(TSC_MEASURE_X, _MaxRetry, _MaxRange);
     touchPos.y = readTouchValue(TSC_MEASURE_Y, _MaxRetry, _MaxRange);
22.  s16 px = ( touchPos.x * xscale - xoffset + xscale/2 ) >>19;
     s16 py = ( touchPos.y * yscale - yoffset + yscale/2 ) >>19;
23.  if ( px < 0) px = 0;
     if ( py < 0) py = 0;
     if ( px > (SCREEN_WIDTH -1)) px = SCREEN_WIDTH -1;
     if ( py > (SCREEN_HEIGHT -1)) py = SCREEN_HEIGHT -1;
24.  touchPos.px = px;
     touchPos.py = py;
25.  return touchPos;
26. }

 libnds에서 봤던 평균을 낸다던지 하는 소스는 여기서 보이지 않는다. 아주 간단하게 처음 터치 스크린의 값을 읽고 그값과 다음 읽은 값과 비교하여 차이가 적당한 범위 내이면 읽은 값이 정확하다고 판단하여 리턴하는 형식이다. 참으로 간단하면서도 명확한 방법이 아닐 수 없다. 만약 첫번째 읽은 값이 잘못된 값이면 touchPos.x와 touchPos.y의 값이 문제가 있을 것이므로 이것을 이용해서 판단하면 될 듯 하다.

 실제 libnds를 이용해서 touch.x, touch.y의 값을 같이 사용해서 판단하고 있으나 제대로 동작하지 않는데, 문쉘의 방법은 괜찮을 듯 하다(실제로도 문쉘은 잘 동작한다.)

3.마치며...

 간단한 방법이 제일 좋은 듯하다. libnds의 경우 여러가지 경우를 너무 생각해서 소스가 복잡하고 제대로 동작하지 않는 것 같다. 나중에 소스를 손봐서 새로 테스트 해봐야 겠다.

이 글은 스프링노트에서 작성되었습니다.

07 Serial Peripheral Interface(SPI)

원문 : http://kkamagui.springnote.com/pages/422905

들어가기 전에...

 Serial Pheripheral Interface(SPI)는 FULL Duplex로 동작하는 Mototola에서 개발된 버스이다. 자세한 내용은 wikipedia http://en.wikipedia.org/wiki/Serial_peripheral_interface에서 찾을 수 있으며 하나의 Master와 하나 이상의 Slave의 컨트롤러로 이루어진다.

1.구성 및 설명

<Master-Slave SPI>

  좌측과 같이 Master/Slave가 1:1로 연결될 수 있고, 우측과 같이 1:n으로 연결하는 것도 가능하다. NDS의 SPI 컨트롤에서 Chip Select가 있는 것을 보아 다수의 컨트롤러가 묶여있는 것 같다.

Interface

The SPI bus specifies four logic signals.

• SCLK — Serial Clock (output from master)
• MOSI/SIMO — Master Output, Slave Input (output from master)
• MISO/SOMI — Master Input, Slave Output (output from slave)
• SS — Slave Select (active low; output from master)

Alternative naming conventions are also widely used:

• SCK — Serial Clock (output from master)
• SDI, DI, SI — Serial Data In
• SDO, DO, SO — Serial Data Out
• nCS, CS, nSS, STE — Chip Select, Slave Transmit Enable (active low; output from master)

The SDI/SDO (DI/DO, SI/SO) convention requires that SDO on the master be connected to SDI on the slave, and vice-versa. That's confusing, so the MOSI/MISO convention is preferred.

SPI port pin names for particular IC products may differ from those depicted in these illustrations.

2.동작방법

The SPI bus can operate with a single master device and with one or more slave devices.

If a single slave device is used, the SS pin may be fixed to logic low if the slave permits it. Some slaves require the falling edge (high->low transition) of the slave select to initiate an action such as the MAX1242 by Maxim IC, an ADC, that starts conversion on said transition. With multiple slave devices, an independent SS signal is required from the master for each slave device.

Most devices have tri-state outputs that become high impedance ("disconnected") when the device is not selected. Devices without tristate outputs can't share SPI bus segments with other devices; only one such slave may talk to the master, and only its chipselect may be activated.

Data Transmission

A typical hardware setup using two shift registers to form an inter-chip circular buffer

To begin a communication, the master first configures the clock, using a frequency less than or equal to the maximum frequency the slave device supports. Such frequencies are commonly in the range of 1-70 MHz.

The master then pulls the slave select low for the desired chip. If a waiting period is required (such as for analog-to-digital conversion) then the master must wait for at least that period of time before starting to issue clock cycles.

During each SPI clock cycle, a full duplex data transmission occurs:

• the master sends a bit on the MOSI line; the slave reads it from that same line
• the slave sends a bit on the MISO line; the master reads it from that same line

Not all transmissions require all four of these operations to be meaningful but they do happen.

The transmissions normally involve two shift registers of some given word size, such as eight bits, one in the master and one in the slave; they are connected in a ring. Data is usually shifted out with the most significant bit first, while shifting a new least significant bit into the same register. After that register has been shifted out, the master and slave have exchanged register values. Then each device takes that value and does something with it, such as writing it to memory. If there is more data to exchange, the shift registers are loaded with new data and the process repeats.

Transmissions may involve any number of clock cycles. When there are no more data to be transmitted, the master stops toggling its clock. Normally, it then deselects the slave.

Transmissions often use single 8-bit bytes, and a master can initiate multiple such transmissions if it wishes/needs. However, other word sizes are also common, such as 16-bit words for touchscreen controllers or audio codecs, like the TSC2101 from Texas Instruments; or 12-bit words for many digital-to-analog or analog-to-digital converters.

Every slave on the bus that hasn't been activated using its slave select line must disregard the input clock and MOSI signals, and may not drive MISO. The master selects only one slave at a time.

 

3.인터럽트(Interrupt)

Interrupts

SPI devices sometimes use another signal line to send an interrupt signal to a host CPU. Examples include pen-down interrupts from touchscreen sensors, thermal limit alerts from temperature sensors, alarms issued by real time clock chips, and headset jack insertions from the sound codec in a cell phone.

 위에서 NDS의 Pen Down 예제를 들어서 설명해 놓은 것이 있다.

4.NDS의 SPI

4.1 SPI 레지스터

 NDS에 연결되어있는 SPI의 구성은 http://nocash.emubase.de/gbatek.htm#dsserialperipheralinterfacebusspi 에서 찾아볼 수 있다.

Serial Peripheral Interface Bus
SPI Bus is a 4-wire (Data In, Data Out, Clock, and Chipselect) serial bus.
The NDS supports the following SPI devices (each with its own chipselect).
DS Firmware Serial Flash Memory
DS Touch Screen Controller (TSC)
DS Power Management

40001C0h - SPICNT - NDS7 - SPI Bus Control/Status Register

0-1 Baudrate (0=4MHz/Firmware, 1=2MHz/Touchscr, 2=1MHz/Powerman., 3=512KHz) 2-6 Not used (Zero) 7 Busy Flag (0=Ready, 1=Busy) (presumably Read-only) 8-9 Device Select (0=Powerman., 1=Firmware, 2=Touchscr, 3=Reserved) 10 Transfer Size (0=8bit/Normal, 1=16bit/Bugged) 11 Chipselect Hold (0=Deselect after transfer, 1=Keep selected) 12-13 Not used (Zero) 14 Interrupt Request (0=Disable, 1=Enable) 15 SPI Bus Enable (0=Disable, 1=Enable)

The "Hold" flag should be cleared BEFORE transferring the LAST data unit, the chipselect will be then automatically cleared after the transfer, the program should issue a WaitByLoop(3) manually AFTER the LAST transfer.

 SPI Control 레지스터를 설정할 때 주의할 점은 마지막 Command or Data를 송신할때는 Chipselect Hold를 미리 0으로 설정해 놓아야 한다는 것이다. 이것을 하지 않으면 Chipselect가 자동으로 해제되지 않으므로 해당 칩을 계속 물고 있게 된다.

• 1Byte의 명령만 송신할 때 : chipselect를 0으로 설정해서 명령을 송신한 다음 데이터를 수신받음
• 2Byte 이상의 명령 + 데이터의 형태를 송신할 때 : chipselect를 1로 설정하여 데이터를 송신한 다음 마지막 바이트에서는 chipselect를 0으로 한다음 송신

40001C2h - SPIDATA - NDS7 - SPI Bus Data/Strobe Register (R/W)

The SPI transfer is started on writing to this register, so one must <write> a dummy value (should be zero) even when intending to <read> from SPI bus.

0-7 Data 8-15 Not used (always zero, even in bugged-16bit mode)

During transfer, the Busy flag in SPICNT is set, and the written SPIDATA value is transferred to the device (via output line), simultaneously data is received (via input line). Upon transfer completion, the Busy flag goes off (with optional IRQ), and the received value can be then read from SPIDATA, if desired.

 데이터를 송/수신 할때 주의할 점은 SPI Control 레지스터의 Busy bit가 0일때 보내야 한다는 것이다. Busy bit가 1일때는 데이터를 송신 중이거나 수신중이기 때문에 보내거나 받으면 안된다. 

Notes/Glitches
SPICNT Bits 12,13 appear to be unused (always zero), although the BIOS (attempts to) set Bit13=1, and Bit12=Bit11 when accessing the firmware.
The SPIDATA register is restricted to 8bit, so that only each second byte will appear in the register when attemting to use the bugged 16bit mode.

Cartridge Backup Auxiliar SPI Bus
The NDS Cartridge Slot uses a separate SPI bus (with other I/O Ports), see
DS Cartridge Backup

 위는 참고적인 사항이니 그냥 넘어가자.

4.2 SPI 사용 순서

4.2.1 명령 송신

 SPI를 통해 해당 Device로 명령과 데이터를 송신할때 아래와 같은 순서로 하면 된다.

4.2.2 데이터 수신

 SPI를 통한 데이터 수신의 경우에는 명령을 보내고 수신 요청(0x00을 SPI Data 레지스터에 씀)을 함으로써 바로 받을 수 있다.

5.구현

 SPI는 ARM7에만 있으므로 \devkitPro\libnds\srouce\include\nds\arm7 폴더에서 serial.h 파일을 찾아야 한다.

// SPI chain registers
#define REG_SPICNT      (*(vuint16*)0x040001C0)
#define REG_SPIDATA     (*(vuint16*)0x040001C2)

#define SPI_ENABLE  BIT(15)
#define SPI_IRQ     BIT(14)
#define SPI_BUSY    BIT(7)

 

// Pick the SPI clock speed
#define SPI_BAUD_4MHZ    0
#define SPI_BAUD_2MHZ    1
#define SPI_BAUD_1MHZ    2
#define SPI_BAUD_512KHZ  3

 

// meh
#define SPI_BAUD_4MHz    0
#define SPI_BAUD_2MHz    1
#define SPI_BAUD_1MHz    2
#define SPI_BAUD_512KHz  3

 

// Pick the SPI transfer length
#define SPI_BYTE_MODE   (0<<10)
#define SPI_HWORD_MODE  (1<<10)

 

// Pick the SPI device
#define SPI_DEVICE_POWER      (0 << 8)
#define SPI_DEVICE_FIRMWARE   (1 << 8)
#define SPI_DEVICE_NVRAM      (1 << 8)
#define SPI_DEVICE_TOUCH      (2 << 8)
#define SPI_DEVICE_MICROPHONE (2 << 8)

 

// When used, the /CS line will stay low after the transfer ends
// i.e. when we're part of a continuous transfer
#define SPI_CONTINUOUS       BIT(11)

 위에서 설명했던 각 Register의 값과 비트를 설정해 놓았다는 것을 알 수 있다.

 이 헤더 파일을 사용해서 직접 Power Control을 한 예제를 보자. \devkitPro\libnds\source\source\arm7 폴더에서 spi.c 파일을 찾으면 된다.

1. //---------------------------------------------------------------------------------
   int writePowerManagement(int reg, int command) {
   //---------------------------------------------------------------------------------
     // Write the register / access mode (bit 7 sets access mode)
2.   while (REG_SPICNT & SPI_BUSY);
     REG_SPICNT = SPI_ENABLE | SPI_BAUD_1MHZ | SPI_BYTE_MODE | SPI_CONTINUOUS | SPI_DEVICE_POWER;
     REG_SPIDATA = reg;
3.   // Write the command / start a read
     while (REG_SPICNT & SPI_BUSY);
     REG_SPICNT = SPI_ENABLE | SPI_BAUD_1MHZ | SPI_BYTE_MODE | SPI_DEVICE_POWER;
     REG_SPIDATA = command;
4.   // Read the result
     while (REG_SPICNT & SPI_BUSY);
     return REG_SPIDATA & 0xFF;
   }

 위에서 보면 2Byte의 Command를 날려야 하는데, 첫번째 송신때는 SPI_CONTINUOUS를 사용했지만 두번째는 SPI_CONTINOUS를 사용하지 않은 것을 알 수 있다.

6.마치면서...

 SPI의 동작 및 NDS에 적용된 부분을 살펴보았다. 이제 ARM7 코드만 손보면 우리가 원하는 작업을 할 수 있게 되었다. Power Control 같은 경우도 Memory Map Register를 사용해서 할 수 없었던 부분을 할 수 있다.

 이것 저것 많이 테스트 해보도록 하자 >ㅁ<)/~

이 글은 스프링노트에서 작성되었습니다.

07 NDS 홈브루(Homebrew) - KNG(KKAMAGUI NDS Graphic) File 변환 툴

원문 :  http://kkamagui.springnote.com/pages/566442

들어가기 전에...

0.버전관리

0.시작하면서...

 NDS에서 그림을 출력하려면 어떻게 해야할까? 방법은 크게 2가지가 있다.

 어느 방법을 사용하던지 중요한 점은 NDS에서 편하게 불러쓰고 화면에 뿌릴 수 있어야 한다는 점이다. 그래서 KNG(KKAMAGUI NDS Graphic) 포맷을 개발하게 되었고, RGB555 포맷으로 그대로 변환하여 저장하게 하여 별도의 처리없이 화면에 표시가능하도록 구성했다.

 이제 KNG에 대해서 하나하나 알아보자.

1.KNG 구성

 KNG는 RGB555 포맷을 기본으로 사용하도록 만들어졌고 크게 헤더 부분과 데이터 부분, 두부분으로 구성되어있다. 헤더를 굳이 만들 필요가 있는가 하는 사람도 있겠지만, PSP와 같은 기기로 확장을 생각하고 있기 때문에 나름 범용으로 쓰기위해 헤더와 데이터로 구분했다.

 아래는 헤더의 구성이다.

1. // 매크로 정의
   #define VERSION_NDS_0_0 0x00
2. #pragma pack( push, 1 )
3. // 헤더 구조체
   typedef struct kkamaguiNdsGraphicStruct
   {
       char vcSignature[ 3 ]; // KNG 설정
       BYTE bVersion;         // 이미지 포맷 버전, 0x00 설정
       int iWidth;            // 이미지 넓이
       int iHeight;           // 이미지 높이
   } KNG, * PKNG;
4. #pragma pack( pop )

 각 부분의 역할은 아래와 같다.

• vcSignature : 파일 포맷의 유효성을 검증하기위한 방편
• bVersion : 다양한 데이터 양식을 지원하기위해 넣은 버전 번호. 매크로에 정의되어있듯 NDS RGB555 포맷은 0x00으로 정의되어있음
• iWidth : 이미지의 가로 넓이
• iHeight : 이미지의 세로 넓이

 데이터는 헤더의 바로 뒤에 연달아서 나오게 되어있으므로 헤더를 뛰어넘고 데이터를 접근하면 Raw Data에 바로 접근할 수 있다. 데이터 양을 줄이기 위해서는 Run-Length Encoding과 같은 방법을 사용해서 처리하면 사이즈를 줄일 수 있지만, 현재 버전에서는 굳이 넣지 않았다.

 NDS Firmware 문서를 뒤져보면 Firmware에서 Run-Length Decoding과 Huffman Decoding 루틴을 제공하는 것을 알 수 있는데, 사이즈가 부담스러우면 두가지 방법을 사용하는 것도 괜찮은듯 하다.

2.KNG 파일 포맷으로 변환

 KNG로 변환하는 것은 아주 간단하다. 헤더를 생성한 다음, RGB 포맷을 RGB555 포맷으로 수정하여 저장하면 끝이다. 첨부에 포함된 변환 프로그램 소스를 보면 쉽게 알 수 있는데, 핵심 부분은 CMyImage 클래스 이다. FreeImage 라이브러리를 사용해서 이미지를 읽고 헤더를 생성한후 RGB555 포맷으로 저장한다. 학교 수업때 사용한 프로젝트를 약간 변경한 소스여서 지저분한데, 마음에 안들면 새로 만들도록 하자.

 아래는 CMyImage 클래스의 간단한 사용법이다.

1. CMyImage clImage;
2. ... 생략 ...
3. clImage.LoadImage( "a.jpg" );
4. clImage.SaveImageWithConvert();
5. clImage.UnloadImage();

 위를 실행하고 나면 a.jpg.kng 라는 파일이 a.jpg 파일이 있는 같은 폴더에 생성된다.

 변환하는 과정을 좀더 상세히 살펴보자. 어떻게 변경하는 것일까? 아래는 실제 변환하는 소스이다.

1. /**
       이미지를 변환과 함께 저장한다.
   */
   BOOL CMyImage::SaveImageWithConvert( void )
   {
       CSize clSize;
       int i;
       int j;
       RGBQUAD stRgb;
       char vcNewFileName[ 256 ];
       KNG stHeader;
       int iFd;
       WORD wValue;
       WORD wR;
       WORD wG;
       WORD wB;
      
       // 파일 이름을 설정한다.
       vcNewFileName[ 0 ] = '\0';
       _snprintf( vcNewFileName, sizeof( vcNewFileName ), "%s.kng", m_vcFileName );
2.     iFd = _open( vcNewFileName, _O_CREAT | _O_WRONLY | _O_TRUNC | _O_BINARY,
           _S_IREAD | _S_IWRITE );
       if( iFd == -1 )
       {
           return FALSE;
       }
3.     // 헤더를 설정하여 파일에 쓴다.
       SetHeaderInfo( &stHeader );
       _write( iFd, &stHeader, sizeof( stHeader ) );
4.     // 이미지를 변환해서 파일에 쓴다.
       clSize = GetImageSize();
5. 
       // 위 아래가 바뀌어 있어서 뒤집는다.
       for( j = clSize.cy - 1 ; j >= 0 ; j-- )
       {
           for( i = 0 ; i < clSize.cx ; i++ )
           {
               // RGB 값을 얻어서 555 Format으로 맞춘다.
               stRgb = GetPixel( i, j );
              
               wR = ( WORD )( stRgb.rgbRed * ( ( double ) 31 / 255 ) );
               wG = ( WORD )( stRgb.rgbGreen * ( ( double ) 31 / 255 ) );
               wB = ( WORD )( stRgb.rgbBlue * ( ( double ) 31 / 255 ) );
              
               // MSB는 Alpha Bit이다. 이것을 0으로 설정하면 NDS에서 그려지지 않는다.
               wValue = 0x8000 | ( wB << 10 ) | ( wG << 5 ) | ( wR );
               _write( iFd, &wValue, 2 );
               //TRACE( "[%d %d] [%d %d %d] %X\n", i, j, wR, wG, wB, wValue );
           }
       }
       _close( iFd );
6.     return TRUE;
   }
   

 파일을 관리하는 부분을 다 제외하고 파란색 부분만 보면, 헤더를 생성하고 이미지의 각 부분의 Pixel 값을 읽은 후 RGB555 포맷에 맞게 곱셈/나눗셈을 해서 처리하는 것을 알 수 있다. 간단한 소스니 별다른 부연 설명은 필요 없을 듯...

 한가지 유의할 점은 원 이미지는 위아래가 뒤집혀서 저장되므로 그것을 바로잡기위해 루프의 인덱스를 조작한 부분이다. 혹시나 특정 파일 포맷을 변환했는데, 위아래가 뒤집혀서 NDS에 출력될 경우는 저 부분을 손보면 된다.

3.KNG 이미지 출력

 KNG 이미지를 출력하는 방법은 아주 간단하다. 일단 헤더에서 이미지에 대한 정보를 추출한 다음 루프를 돌면서 화면에 뿌려주면 된다. RGB555 모드로 NDS를 설정하는 방법이 궁금하면 02 NDS 윈도우 시스템(Windows System) 문서를 참고하도록 하자.

 아래는 KNG 파일을 출력하는 소스의 일부분이다.

1.     // 복사한다.
    for( i = 0 ; i < iHeight; i++ )
    {
        iTemp1 = ( i + iDstY ) * iDstWidth + iDstX;
        iTemp2 = ( i + iSrcY ) * iSrcWidth + iSrcX;
       
        memcpy( pwDstAddr + iTemp1, pwSrcAddr + iTemp2, iWidth * 2 );
    }

 pwDstAddr이 RGB555로 설정된 비디오 메모리의 주소이고, pwSrcAddr이 KNG 파일 내의 Raw Data의 주소이다. 간단히 메모리간의 복사로 해결할 수 있다.

4.변환 툴 사용법

 이미지 변환툴은 jpg, png, bmp와 같은 그래픽 파일 포맷을 지원한다. 단 사이즈 조작 기능은 없으니 사이즈를 조작하려면 그림판이나 포토샵을 이용해서 이미 조작해야 할 것이다. 원활한 사용을 위해서는 이미지 크기가 256 X 192 이하로 하는게 좋다. 이 이상된다면 출력 루틴을 수정하고 그래픽 모드 또한 수정해야 할 것이므로, 정신 건강에 매우 해롭다. ㅡ_ㅡa...

 아래는 변환툴을 실행한 화면이다.

<실행화면>

 메뉴의 파일->이미지 파일 선택을 클릭하여 변환할 파일을 선택하거나, 툴바의 열기 버튼을 클릭하여(위의 붉은색) 변환할 파일을 선택하면 이미지 변환이 수행되고 아래와 같은 화면이 표시되면 정상적으로 변환 된 것이다.

<이미지 변환 성공>

 해당 이미지가 있는 폴더에 보면 .kng 확장자가 붙은 파일이 추가로 생성되었음을 알 수 있다. 이 파일을 롬파일에 추가하거나 libfat를 이용해서 불러 사용하면 된다. 롬파일에 이미지 또는 파일을 추가하는 방법은 참고. 롬 파일에 데이터(사운드, 이미지 등등) 파일 포함 방법 문서를 참고하도록 하자.

5.마치면서...

 NDS용 파일 포맷을 생성하고 변환하는 방법에 대해서 간단히 알아보았다. 이것으로 홈브루를 더욱 예쁘게 만들 수 있게 되었다. 더욱 홈브루 개발에 정진하자. @0@)/~!!!

6.첨부

• 03_이미지_변환.zip

이 글은 스프링노트에서 작성되었습니다.

06 NDS 홈브루(Homebrew) - 소프트웨어 리셋 라이브러리(Software Reset Library)

원문 :  http://kkamagui.springnote.com/pages/558349

들어가기 전에...

0.수정사항

0.시작하면서...

 소프트웨어 리셋 라이브러리의 모체는 23 Soft Reset 분석 에 나와있는 문쉘(moonshell)의 Reset.mse 플러그인 프로그램이다. 문쉘 플러그인으로 동작하게 만든 것을 소스를 변경하여 libfat만 있으면 동작 가능하도록 수정했다.

 모든 소스에 대한 권리는 문쉘의 권리를 따르며 이 소스를 사용하거나 임의 수정하여 얻는 불이익에 대해서는 책임지지 않는다. ^^;;;

 뭐 원래 오픈 소스이기 때문에 큰일이야 나겠냐 만은... ㅡ_ㅡa... 그래도 혹시나 모르니까 미리 알려둔다.

1.주된 변경 사항

1.1 GBA FS -> libfat 

 앞서 말했듯이 모체는 문쉘의 소스이다. 문쉘 소스는 과거의 FAT 라이브러리인 GBA FS를 사용하기 때문에 일반적으로 사용하는 libfat와는 맞지 않다. 그렇다고 리셋 기능 때문에 GBA FS를 그대로 사용하기에는 쓸모없는 코드가 너무 많이 들어가므로 이 부분을 libfat를 사용하도록 수정했다. 이 부분에 대한 자세한 내용은 23 Soft Reset 분석 문서를 참고하면 자세하게 알 수 있다.

1.2 IPCEX -> IPC 

 소프트웨어적인 리셋을 위해서는 ARM9과 ARM7 모두 리셋해야 하는데, ARM7의 리셋 신호를 위해 문쉘은 IPCEX라는 별도의 구조체를 사용하고 있다. 이것을 수정하여 libnds의 기본 정보는 IPC 구조체를 그대로 사용하도록 하고, mail 관련 정보를 사용하도록 했다. 자세한 내용은 아래의 사용 예제를 보면 쉽게 알 수 있다. 

2.라이브러리 설치 

2.1 소스 및 라이브러리 다운로드 

 resetlib를 사용하기위해서는 헤더파일과 라이브러리 파일만 libnds 폴더에 복사해 주면 된다. 아래 첨부에 있는 resetlib.zip을 다운받아서 압축을 해제하면 아래와 같이 소스파일과 헤더파일 그리고 라이브러리 파일이 생긴다.

<헤더 및 라이브러리>

2.2 라이브러리 파일 복사 

 lib 아래에 있는 라이브러리 파일을 devkitPro가 설치된 폴더에 있는 libnds\lib 폴더 아래로 복사한다.

<라이브러리 파일 복사>

2.3 헤더 파일 복사 

  resetlib.h 파일을  devkitPro가 설치된 폴더에 있는 libnds\include 폴더 아래로 복사한다.

<헤더 파일 복사>

 이로써 라이브러리 설치가 완료되었다. 정말 간단하지 않은가? @0@)/~!!!

3.사용 예제 

 resetlib를 사용하기 위해서는 makefile을 수정해서 resetlib를 추가해주는 과정과 ARM9과 ARM7 소스에서 각각 Sync를 맞춰서 SoftReset() 함수를 호출해 주는 과정이 필요하다. 즉 ARM9만 사용하게 되어있는 프로젝트는 소프트웨어 리셋을 사용할 수 없다는 말이다. 

 ARM9 프로젝트를 ARM7과 ARM9을 사용하는 프로젝트로 변경하는 것은 그렇게 어려운 일이 아니니 devkitPro 예제에 templete 폴더에 있는 combined 템플릿을 이용하여 수정하도록 하자. 

 이제 makefile 수정방법부터 하나하나 알아보자. 

3.1 makefile 수정 

 resetlib는 ARM9용과 ARM7 용이 따로 제작되어있다. 따라서 각각에 맞게 수정해 줘야 한다. 

3.1.1 ARM9 수정 

 LIBS 부분을 아래와 같이 수정하여 libfat와 libreset9을 사용하도록 한다.

1. #---------------------------------------------------------------------------------
   # any extra libraries we wish to link with the project
   #---------------------------------------------------------------------------------
   LIBS := -lfat -lnds9 -lreset9 

3.1.2 ARM7 수정 

 LIBS 부분을 아래와 같이 수정하여 libfat와 libreset7을 사용하도록 한다. 

1. LIBS := -lnds7 -lreset7

3.2 ARM9 및 ARM7 코드 

3.2.1 ARM9 코드 

 간단히 헤더를 추가하고 libfat의  fatInitDefault() 함수를 호출해서 초기화를 수행한 다음 SoftReset() 함수를 호출해 주면 된다. 아주 간단하다.

1. // 추가해야 하는 부분
   #include <fat.h>
   
2. #include <resetlib.h>
   
3. //---------------------------------------------------------------------------------
   int main(void) {
   //---------------------------------------------------------------------------------
       REG_IME=0;
      
       POWER_CR = POWER_ALL_2D;
       POWER_CR |= POWER_SWAP_LCDS;
      
       irqInit();
       {
           InitVRAM();
              
           // reset library는 libfat를 사용하므로 반드시 해줘야 한다.
           fatInitDefault();
           
           // Soft Reset 실행
           SoftReset();
       }
      
       while(1);
   } 

3.2.2 ARM7 코드 

 아래의 코드처럼 IPC의 mailData 부분을 통해서 RESET 관련 메시지를 ARM9이 보내도록 되어있는데, 그 값을 이용해서 Sync를 맞추어 SoftReset() 을 호출하면 된다. 

1. #include <resetlib.h>
2. ... 생략 ... 
3. //---------------------------------------------------------------------------------
   int main(int argc, char ** argv) {
   //---------------------------------------------------------------------------------
       irqInit();
      
       // 반드시 초기화 해야 한다.
       IPC->mailData = RESET_NULL; //====== IPC RESET Clear by Rudolph (2007/06/13)
       irqSet(IRQ_VBLANK, VblankHandler);
      
       irqEnable(IRQ_VBLANK);
      
       while (1)
       {
           swiIntrWait(1,IRQ_VBLANK); // vblank
          
           // mail IPC를 감시하면서 값이 NULL 이 아니면 리셋 하도록 한다.
           if( IPC->mailData != RESET_NULL )
           {
               SoftReset( IPC->mailData );
               while(1);
           }
       }
   } 

 좀 더 상세한 내용은 첨부에 있는 resetlibTest.zip 를 보면 된다(사실 봐도 별 소용 없다. 위의 코드가 전부이다. ㅡ_ㅡa..)

4.마치면서... 

 이것으로 홈브루에도 리셋 기능을 넣을 수 있게 되었다. 홈브루 실행 후 파워 버튼을 만질 일도 이젠 없다. ㅜ_ㅜ... 이 얼마나 좋은 일인가.. ㅜ_ㅜ... 라이브러리 사용법 또한 간단하니 이 얼마나 감동인가... ㅜ_ㅜ

 이제 다시 홈브루 개발의 세계로 빠져보자. @0@)/~!!! 

5.첨부

• resetlib.zip : 리셋 라이브러리 소스 및 바이너리
• resetlibTest.zip : 라이브러리 테스트 소스

이 글은 스프링노트에서 작성되었습니다.

05 파워 컨트롤(Power Control)

원문 : http://kkamagui.springnote.com/pages/411216

들어가기 전에...

0. 시작하면서...

 NDS는 LCD, 사운드, Graphic 엔진 등 여러가지 장비를 가지고 있다. 이 장비는 파워 컨트롤 레지스터에 특정 값을 입력함으로써 조절할 수 있으며 ARM9과 ARM7 별로 컨트롤 할 수 있는 장비가 다르다.

http://nocash.emubase.de/gbatek.htm#dspowermanagement 를 참조하면 Power Control에 대한 자세한 정보를 얻을 수 있는데, 아래와 같다.

1. Port I/O

1.1 Port And Bit

 먼저 살펴볼 부분은 Port I/O를 통해서 접근할 수 있는 장비에 대한 부분이다.

The DS contains several Power Managment functions, some accessed via I/O ports, some accessed via SPI bus (described later on below).

4000304h - POWCNT1 - NDS9 - Graphics Power Control Register (R/W)

0 Enable Flag for both LCDs (0=Disable) (Prohibited, see notes) 1 2D Graphics Engine A (0=Disable) (Ports 008h-05Fh, Pal 5000000h) 2 3D Rendering Engine (0=Disable) (Ports 320h-3FFh) 3 3D Geometry Engine (0=Disable) (Ports 400h-6FFh) 4-8 Not used 9 2D Graphics Engine B (0=Disable) (Ports 1008h-105Fh, Pal 5000400h) 10-14 Not used 15 Display Swap (0=Send Display A to Lower Screen, 1=To Upper Screen)

Use SwapBuffers command once after enabling Rendering/Geometry Engine.
Improper use of Bit0 may damage the hardware?
When disabled, corresponding Ports become Read-only, corresponding (palette-) memory becomes read-only-zero-filled.

4000304h - POWCNT2 - NDS7 - Sound/Wifi Power Control Register (R/W)

Bit Expl. 0 Sound Speakers (0=Disable, 1=Enable) (Initial setting = 1) 1 Wifi (0=Disable, 1=Enable) (Initial setting = 0) 2-31 Not used

Note: Bit0 disables the internal Speaker only, headphones are not disabled.
Bit1 disables Port 4000206h, and Ports 4800000h-480FFFFh.

4000206h - NDS7 - WIFIWAITCNT - Wifi Waitstate Control

Bit Expl. 0-2 Wifi WS0 Control (0-7) (Ports 4800000h-4807FFFh) 3-5 Wifi WS1 Control (0-7) (Ports 4808000h-480FFFFh) 4-15 Not used (zero)

This register is initialized by firmware on power-up, don't change.
Note: WIFIWAITCNT can be accessed only when enabled in POWCNT2.

4000301h - NDS7 - HALTCNT - Low Power Mode Control (R/W)
In Halt mode, the CPU is paused as long as (IE AND IF)=0.
In Sleep mode, most of the hardware including sound and video are paused, this very-low-power mode could be used much like a screensaver.

Bit Expl. 0-5 Not used (zero) 6-7 Power Down Mode (0=No function, 1=Enter GBA Mode, 2=Halt, 3=Sleep)

The HALTCNT register should not be accessed directly. Instead, the BIOS Halt, Sleep, CustomHalt, IntrWait, or VBlankIntrWait SWI functions should be used.
BIOS Halt Functions
ARM CP15 System Control Coprocessor
The NDS9 does not have a HALTCNT register, instead, the Halt function uses the co-processor opcode "mcr p15,0,r0,c7,c0,4" - this opcode locks up if interrupts are disabled via IME=0 (unlike NDS7 HALTCNT method which doesn't check IME).

4000300h - NDS7/NDS9 - POSTFLG - BYTE - Post Boot Flag (R/W)
The NDS7 and NDS9 post boot flags are usually set upon BIOS/Firmware boot completion, once when set the reset vector is redirected to the debug handler of Nintendo's hardware debugger. That allows the NDS7 debugger to capture accidental jumps to address 0, that appears to be a common problem with HLL-programmers, asm-coders know that (and why) they should not jump to 0.

Bit Expl. 0 Post Boot Flag (0=Boot in progress, 1=Boot completed) 1 NDS7: Not used (always zero), NDS9: Bit1 is read-writeable 2-7 Not used (always zero)

There are some write-restrictions: The NDS7 register can be written to only from code executed in BIOS. Bit0 of both NDS7 and NDS9 registers cannot be cleared (except by Reset) once when it is set.

 ARM9과 ARM7에서 접근할 수 있는 부분이 위와 같이 다르고 해당 비트만 0/1을 바꿔주면 간단히 제어할 수 있다는 것을 알 수 있다.

1.2 libnds 분석

 Devkit Pro의 libnds 및의 Source 폴더에 가면 실제 구현한 소스와 헤더를 볼 수 있다. Port I/O 관련 파워 관리 부분은 system.h 파일에 있으므로  한번 살펴보자.

 Port I/O 이므로 파워를 컨트롤 할 수 있는 포트 번호를 알아야 하는데 system.h 파일에 아래와 같이 정의 되어있고 02 NDS Spec 에서도 찾아볼 수 있다.

1. #define REG_POWERCNT *(vu16*)0x4000304

  위의 정의를 보니 16bit의 크기를 가지는 것 같다. ARM9과 ARM7에 대해서 정의해 놓은 값도 같이 보자.

1. #define POWER_LCD   BIT(0)
   #define POWER_2D_A   BIT(1)
   #define POWER_MATRIX  BIT(2)
   #define POWER_3D_CORE  BIT(3)
   #define POWER_2D_B   BIT(9)
   #define POWER_SWAP_LCDS  BIT(15)
2. //! Enables power to all hardware required for 2D video.
   #define POWER_ALL_2D     (POWER_LCD |POWER_2D_A |POWER_2D_B)
3. //! Enables power to all hardware required for 3D video.
   #define POWER_ALL   (POWER_ALL_2D | POWER_3D_CORE | POWER_MATRIX)

 위에서 파워 조작 레지스터의 비트값을 그대로 매크로로 만들었음을 알 수 있다. BIT()는 해당 비트를 1로 설정해 주는 역할을 하는 간단한 매크로이다.

1.3 사용 예제

 매크로를 사용하여 LCD를 키고 그래픽을 표시하려면 아래와 같이 사용하면 된다.

1. REG_POWERCNT |= POWER_ALL_2D;
2. powerON( POWER_ALL_2D ); <== 위의 코드와 비슷한 역할을 하는 매크로다.

 만약 위처럼 Engine을 Enable 하지 않고 그냥 LCD만 ON(bit0)만 하면 어떻게 될까? 실제로 해보면 상단 LCD에는 흰색이, 하단 LCD에는 검은색만 표시되고 화면에 아무것도 그려지지 않는다.

 엔진 A를 Enable 시키면? 하단 LCD에 그림이 표시되며, 엔진 B를 Enable 시키면? 상단 LCD가 표시된다. 이때 Swap을 Enable 시키면 상/하단이 바뀌어서 나오게 된다.

  I/O 포트를 이용해서 제어하는 방식은 위와 같이 하면 끝이다.

2. SPI

2.1 Index And Registers

 아래는 SPI를 사용해서 접근해야 하는 부분이다.

Power Management Device
The Power Management Device is accessed via SPI bus,
DS Serial Peripheral Interface Bus (SPI)
To access the device, write the Index Register, then read or write the data register, and release the chipselect line when finished.

Index Register

Bit0-1 Register Select (0..3) Bit2-6 Not used Bit7 Register Direction (0=Write, 1=Read)

Register 0 - Powermanagement Control (R/W)

Bit0 Sound Amplifier (0=Disable, 1=Enable) (When disabled, sound becomes very silent, but it is still audible) Bit1 Sound related? (0=Disable, 1=Enable) Bit2 Lower Backlight (0=Disable, 1=Enable) Bit3 Upper Backlight (0=Disable, 1=Enable) Bit4 Power LED Blink Enable (0=Always ON, 1=Blinking OFF/ON) Bit5 Power LED Blink Speed (0=Slow, 1=Fast) (only if Blink enabled) Bit6 DS System Power (0=Normal, 1=Shut Down) Bit7 Not used

Register 1 - Battery Status (R)

Bit0 Battery Power LED Status (0=Power Good/Green, 1=Power Low/Red) Bit1-7 Not used

Register 2 - Microphone Amplifier Control (R/W)

Bit0 Amplifier (0=Disable, 1=Enable) Bit1-7 Not used

Register 3 - Microphone Amplifier Gain Control (R/W)

Bit0-1 Gain (0..3=Gain 20, 40, 80, 160) Bit2-7 Not used

Backlight Dimming / Backlight caused Shut-Down(s)
The above bits are essentially used to switch Backlights on or off. However, there a number of strange effects. Backlight dimming is possible by pulse width modulation, ie. by using a timer interrupt to issue pulse widths of N% ON, and 100-N% OFF. Too long pulses are certainly resulting in flickering. Too short pulses are ignored, the backlights will remain OFF, even if the ON and OFF pulses are having the same length. Much too short pulses cause the power supply to shut-down; after changing the backlight state, further changes must not occur within the next (circa) 2500 clock cycles. The mainboard can be operated without screens & backlights connected, however, if so, the power supply will shut-down as soon as backlights are enabled.

Memory Power Down Functions
DS Main Memory Control
DS Firmware Serial Flash Memory

2.2 SPI(Serial Peripheral Interface Bus)

 SPI는 아래의 I/O 포트로 제어해야 한다.

Serial Peripheral Interface Bus
SPI Bus is a 4-wire (Data In, Data Out, Clock, and Chipselect) serial bus.
The NDS supports the following SPI devices (each with its own chipselect).
DS Firmware Serial Flash Memory
DS Touch Screen Controller (TSC)
DS Power Management

40001C0h - SPICNT - NDS7 - SPI Bus Control/Status Register

0-1 Baudrate (0=4MHz/Firmware, 1=2MHz/Touchscr, 2=1MHz/Powerman., 3=512KHz) 2-6 Not used (Zero) 7 Busy Flag (0=Ready, 1=Busy) (presumably Read-only) 8-9 Device Select (0=Powerman., 1=Firmware, 2=Touchscr, 3=Reserved) 10 Transfer Size (0=8bit/Normal, 1=16bit/Bugged) 11 Chipselect Hold (0=Deselect after transfer, 1=Keep selected) 12-13 Not used (Zero) 14 Interrupt Request (0=Disable, 1=Enable) 15 SPI Bus Enable (0=Disable, 1=Enable)

The "Hold" flag should be cleared BEFORE transferring the LAST data unit, the chipselect will be then automatically cleared after the transfer, the program should issue a WaitByLoop(3) manually AFTER the LAST transfer.

40001C2h - SPIDATA - NDS7 - SPI Bus Data/Strobe Register (R/W)
The SPI transfer is started on writing to this register, so one must <write> a dummy value (should be zero) even when intending to <read> from SPI bus.

0-7 Data 8-15 Not used (always zero, even in bugged-16bit mode)

During transfer, the Busy flag in SPICNT is set, and the written SPIDATA value is transferred to the device (via output line), simultaneously data is received (via input line). Upon transfer completion, the Busy flag goes off (with optional IRQ), and the received value can be then read from SPIDATA, if desired.

Notes/Glitches
SPICNT Bits 12,13 appear to be unused (always zero), although the BIOS (attempts to) set Bit13=1, and Bit12=Bit11 when accessing the firmware.
The SPIDATA register is restricted to 8bit, so that only each second byte will appear in the register when attemting to use the bugged 16bit mode.

Cartridge Backup Auxiliar SPI Bus
The NDS Cartridge Slot uses a separate SPI bus (with other I/O Ports), see
DS Cartridge Backup

 Port I/O를 쓰지않고 SPI를 통해서 접근해야하는 부분들은 위와 같다. SPI는 ARM7에만 연결되어있으므로 ARM7을 통해서 접근해야 한다.

Power Management Device
The Power Management Device is accessed via SPI bus,
DS Serial Peripheral Interface Bus (SPI)
To access the device, write the Index Register, then read or write the data register, and release the chipselect line when finished.

Index Register

Bit0-1 Register Select (0..3) Bit2-6 Not used Bit7 Register Direction (0=Write, 1=Read)

Register 0 - Powermanagement Control (R/W)

Bit0 Sound Amplifier (0=Disable, 1=Enable) (When disabled, sound becomes very silent, but it is still audible) Bit1 Sound related? (0=Disable, 1=Enable) Bit2 Lower Backlight (0=Disable, 1=Enable) Bit3 Upper Backlight (0=Disable, 1=Enable) Bit4 Power LED Blink Enable (0=Always ON, 1=Blinking OFF/ON) Bit5 Power LED Blink Speed (0=Slow, 1=Fast) (only if Blink enabled) Bit6 DS System Power (0=Normal, 1=Shut Down) Bit7 Not used

Register 1 - Battery Status (R)

Bit0 Battery Power LED Status (0=Power Good/Green, 1=Power Low/Red) Bit1-7 Not used

Register 2 - Microphone Amplifier Control (R/W)

Bit0 Amplifier (0=Disable, 1=Enable) Bit1-7 Not used

Register 3 - Microphone Amplifier Gain Control (R/W)

Bit0-1 Gain (0..3=Gain 20, 40, 80, 160) Bit2-7 Not used

Backlight Dimming / Backlight caused Shut-Down(s)
The above bits are essentially used to switch Backlights on or off. However, there a number of strange effects. Backlight dimming is possible by pulse width modulation, ie. by using a timer interrupt to issue pulse widths of N% ON, and 100-N% OFF. Too long pulses are certainly resulting in flickering. Too short pulses are ignored, the backlights will remain OFF, even if the ON and OFF pulses are having the same length. Much too short pulses cause the power supply to shut-down; after changing the backlight state, further changes must not occur within the next (circa) 2500 clock cycles. The mainboard can be operated without screens & backlights connected, however, if so, the power supply will shut-down as soon as backlights are enabled.

 Power Management Register는 재미있는 항목들을 가지고 있다. DS를 닫았을 때, 파워 LED가 깜빡이게 하는 기능을 포함해서 전체 파워를 끄는기능, 깜빡이는 속도를 조절하는 기능 등등을 가지고 있다. 잘 활용하면 쉽게 사용할 수 있을 것 같다. SPI를 통해 사용해야 하므로 07 Serial Peripheral Interface(SPI) 부분을 참고하도록 하자.

2.3 libnds 분석

 여기다 분석해서 글 적기

2.4 사용 예제

 아래의 예제는 SPI를 사용하는 예제로써 Register 0의 값을 읽어 전원 관련 부분 LED를 Blink하는 소스이다.

1. #include <nds.h>
2. /**
       LED를 Slow or Fast로 깜빡이게 하거나 계속 켜져있도록 한다.
           SPI를 통해 보낸다.
   */
   void SetLEDBlinkMode( bool bBlinkEnable, bool bSlow )
   {
       unsigned char ucData;
      
       ucData = 0;
      
       SerialWaitBusy();
       // SPI를 설정한다.
       REG_SPICNT = SPI_ENABLE | SPI_BAUD_1MHz | SPI_DEVICE_POWER | SPI_CONTINUOUS;
       // Read Mode로 설정하고 Register 0을 선택한다.
       REG_SPIDATA = 0x80;
3.     SerialWaitBusy();
       // 마지막 더미 데이터를 보내서 데이터를 바로 읽도록 한다.
       REG_SPICNT = SPI_ENABLE | SPI_BAUD_1MHz | SPI_DEVICE_POWER;
       REG_SPIDATA = 0x00;
      
       // Register 0에서 데이터를 읽는다.
       SerialWaitBusy();
       ucData = REG_SPIDATA;
4.     // 만약 깜빡임 모드가 아니면 계속 켜져있도록 설정한다.
       if( bBlinkEnable == false )
       {
           ucData &= ~( BIT( 4 ) );
       }
       // 깜빡임 모드이면 Slow/Fast에 따라서
       else
       {
           ucData |= BIT( 4 );
           if( bSlow == true )
           {
               ucData &= ~( BIT( 5 ) );
           }
           else
           {
               ucData |= BIT( 5 );
           }
       }
5.     SerialWaitBusy();
       // SPI를 설정한다.
       REG_SPICNT = SPI_ENABLE | SPI_BAUD_1MHz | SPI_DEVICE_POWER | SPI_CONTINUOUS;
      // Write Mode로 설정하고 Register 0을 선택한다.
       REG_SPIDATA = 0x00;
      
       // Register 0에 데이터를 보낸다.
       SerialWaitBusy();
       REG_SPICNT = SPI_ENABLE | SPI_BAUD_1MHz | SPI_DEVICE_POWER;
       REG_SPIDATA = ucData;
   }

 위의 소스를 보면 상단의 파란색 블럭은 Register 0에서 값을 읽는 부분이고 하단의 파란색 블럭은 Register 0에 값을 쓰는 부분임을 알 수 있다. 소스에서 나타난 흐름 같은 부분은 07 Serial Peripheral Interface(SPI) 문서를 보면 된다.

3. 마치며...

 여기다 마무리 하기.

이 글은 스프링노트에서 작성되었습니다.

05 NDS 홈브루(Homebrew) - MP3 Player 만들기

원문 :  http://kkamagui.springnote.com/pages/525438

들어가기 전에...

0.시작하면서...

 NDS를 사용하는 사람이라면 문쉘에 대해서 모르는 사람이 없을 것이다. MP3 Player는 물론 Text Viewer, Binary Viewer, 동영상 재생까지 모든 기능을 갖추고 있는 만능 쉘이다.  뭔지 모르는 사람들은... 끄응... 구글링이라도 한번... ㅡ_ㅡa...

 나도 간단한 쉘을 만들고 있기에, MP3 Player에 과감히 도전해 보았다. 

1.MP3 Decoder Library 선택 

 문쉘이 쓰고 있는 MP3 Decoder는 libmad로써 나름 괜찮은 성능을 자랑한다. 하지만 단점이라면 큰 크기랄까... ㅡ_ㅡ;;; 실제 libmad를 다운받아서 ARM7에 올렸는데, Huffman 테이블의 크기도 크고 코드 량이 많아서 NDS의 ARM7쪽 코드 및 데이터 영역을 넘어서 버렸다. 컴파일 다 하고 링크할 때 오류가 나서 빌드가 안되는 말도안되는 상황이... ㅡ_ㅡ;;;; 

 문쉘은 필요없는 부분을 추려내서 사이즈를 줄인 것 같은데, 자세하게 분석해 보지 않아서 정확하게는 모르겠다. 

 마구 추려내기 꺼림직하여 좀더 작은 크기의 library를 찾아보니 Helix library가 있었다. https://helixcommunity.org/ 에서 다운로드 받을 수 있는데, 절차가 아주 까다롭고 불편했다. 뭐 여러가지 검색을 하다보니 겨우 소스를 구할 수 있었는데, helix.zip 를 클릭하면 된다(첨부에도 넣어놨다).