화면에 그리기위해

vram에 뭔가 써야함.

naskfunc.nas에 write_mem8 함수 추가

;naskfunc
;TAB=4

[FORMAT "WCOFF"]        ;오브젝트 파일 만드는 모드
[INSTRSET "i486p"]       ;486명령사용하고싶다 작성
[BITS 32]               ;32비트모드용 기계어 만듬

;오브젝트 파일 위한 정보
[FILE "naskfunc.nas"]   ;소스파일명 정보
    GLOBAL  _io_hlt,_write_mem8     ;이프로그램에 포함된 함수명

; 실제 함수

[SECTION .text]         ;오브젝트 파일에서는 이것을 쓴후에 프로그램을 쓴다.
_io_hlt:        ;void io_hlt(void);
    HLT
    RET

_write_mem8:    ; void write_mem8(int addr, int data);
    MOV ECX, [ESP+4]    ; [esp+4]에 addr이 들어있으니 ecx에 읽어들임
    MOV AL, [ESP+8]     ; [ESP+8]에 data가 있으니 al에 읽어들임
    MOV [ECX], AL
    RET

 

 

 

nask에 instrset으로 486용임을 알림

cpu를 32비트 모드로 사용중이라 32비트 레지스터 사용 ecx

vram 구간 전체에 15를 써서 하얗게 됨

 

bootpack.c

void io_hlt(void);
void write_mem8(int addr, int data);

void HariMain(void)
{
    int i;
    
    for (i = 0xa0000; i<= 0xaffff; i++)
    {
        write_mem8(i, 15);  //move byte [i], 15
    }

fin:
    io_hlt();     //naskfunc.nas의 _io_hlt가 실행됨.
    goto fin;
}

 

* vram이 0xa0000에서 시작하는 이유

haribote.nas에서 vram에 0x000a0000으로 지정

 

 

 

 

줄무늬 만들기

i와 0x0f and 연산으로 줄무늬 만들기

void io_hlt(void);
void write_mem8(int addr, int data);

void HariMain(void)
{
    int i;
    
    for (i = 0xa0000; i<= 0xaffff; i++)
    {
        write_mem8(i, i & 0x0f);  //move byte [i], 15
    }

fin:
    io_hlt();     //naskfunc.nas의 _io_hlt가 실행됨.
    goto fin;
}

 

 

 

포인터 사용하기

write_mem8대신 포인터사용해줘도 지정가능

void io_hlt(void);
void write_mem8(int addr, int data);

void HariMain(void)
{
    int i;
    char *p;

    
    for (i = 0xa0000; i<= 0xaffff; i++)
    {
        p = i;
        *p = i & 0x0f;
        //write_mem8(i, i & 0x0f);  //move byte [i], 15
    }

fin:
    io_hlt();     //naskfunc.nas의 _io_hlt가 실행됨.
    goto fin;
}

 

 

 

색상 사용하기

색상 쓰기위해 rgb table 준비해서 팔레트 설정하는 내용

어셈블리 함수가 여러개 추가됨.

void io_hlt(void);
void io_cli(void);
void io_out8(int prot, int data);
int io_load_eflags(void);
void io_store_eflags(int eflags);

void init_palette(void);
void set_palette(int start, int end, unsigned char *rgb);

void HariMain(void)
{
    int i;
    char *p; //p라는 변수는 byte[]용 번지
    
    init_palette();

    p = (char *)0xa0000;

    for (i=0; i <= 0xffff; i++)
    {
        p[i] = i & 0x0f;
    }

    for(;;)
    {
        io_hlt();
    }
}

void init_palette(void)
{
    static unsigned char table_rgb[16 * 3] = {
        0x00, 0x00, 0x00,
        0xff, 0x00, 0x00,
        0x00, 0xff, 0x00,
        0xff, 0xff, 0x00,
        0x00, 0x00, 0xff,
        0xff, 0x00, 0xff,
        0x00, 0xff, 0xff,
        0xff, 0xff, 0xff,
        0xc6, 0xc6, 0xc6,
        0x84, 0x00, 0x00,
        0x00, 0x84, 0x00,
        0x84, 0x84, 0x00,
        0x00, 0x00, 0x84,
        0x84, 0x00, 0x84,
        0x00, 0x84, 0x84,
        0x84, 0x84, 0x84
    };

    set_palette(0, 15, table_rgb);
    return;
}

void set_palette(int start, int end, unsigned char *rgb)
{
    int i, eflags;
    eflags = io_load_eflags();  // 인터럽트 허가 플래그 값 가져옴
    io_cli();                   // 허가 플래그를 0으로 하여 인터럽트 금지
    io_out8(0x03c8, start);
    for (i=start;i<=end;i++)
    {
        io_out8(0x03c9, rgb[0] / 4);
        io_out8(0x03c9, rgb[1] / 4);
        io_out8(0x03c9, rgb[2] / 4);
        rgb += 3;
    }
    io_store_eflags(eflags);    // 인터럽트 허가 플래그를 본래 값으로 되돌림.
    return;
}

 

 

 

추가된 함수들

; naskfunc
; TAB=4

[FORMAT "WCOFF"]				; 오브젝트 파일을 만드는 모드	
[INSTRSET "i486p"]				; 486명령까지 사용하고 싶다고 하는 기술
[BITS 32]					; 32비트 모드용의 기계어를 만든다
[FILE "naskfunc.nas"]				; 원시 파일명 정보

		GLOBAL	_io_hlt, _io_cli, _io_sti, io_stihlt
		GLOBAL	_io_in8,  _io_in16,  _io_in32
		GLOBAL	_io_out8, _io_out16, _io_out32
		GLOBAL	_io_load_eflags, _io_store_eflags

[SECTION .text]

_io_hlt:	; void io_hlt(void);
		HLT
		RET

_io_cli:	; void io_cli(void);
		CLI
		RET

_io_sti:	; void io_sti(void);
		STI
		RET

_io_stihlt:	; void io_stihlt(void);
		STI
		HLT
		RET

_io_in8:	; int io_in8(int port);
		MOV		EDX,[ESP+4]		; port
		MOV		EAX,0
		IN		AL,DX
		RET

_io_in16:	; int io_in16(int port);
		MOV		EDX,[ESP+4]		; port
		MOV		EAX,0
		IN		AX,DX
		RET

_io_in32:	; int io_in32(int port);
		MOV		EDX,[ESP+4]		; port
		IN		EAX,DX
		RET

_io_out8:	; void io_out8(int port, int data);
		MOV		EDX,[ESP+4]		; port
		MOV		AL,[ESP+8]		; data
		OUT		DX,AL
		RET

_io_out16:	; void io_out16(int port, int data);
		MOV		EDX,[ESP+4]		; port
		MOV		EAX,[ESP+8]		; data
		OUT		DX,AX
		RET

_io_out32:	; void io_out32(int port, int data);
		MOV		EDX,[ESP+4]		; port
		MOV		EAX,[ESP+8]		; data
		OUT		DX,EAX
		RET

_io_load_eflags:	; int io_load_eflags(void);
		PUSHFD		; PUSH EFLAGS의 의미
		POP		EAX
		RET

_io_store_eflags:	; void io_store_eflags(int eflags);
		MOV		EAX,[ESP+4]
		PUSH	EAX
		POPFD		; POP EFLAGS의 의미
		RET

 

 

 

이전보다 더 다양한 색상으로 줄무늬가 그려짐.

 

 

박스 그리기

boxfill8 함수 만들어 박스 띄움

void io_hlt(void);
void io_cli(void);
void io_out8(int prot, int data);
int io_load_eflags(void);
void io_store_eflags(int eflags);

void init_palette(void);
void set_palette(int start, int end, unsigned char *rgb);
void boxfill8(unsigned char *vram, int xsize, unsigned char c, int x0, int y0, int x1, int y1);

#define COL8_000000     0
#define COL8_FF0000     1
#define COL8_00FF00     2
#define COL8_FFFF00     3
#define COL8_0000FF     4
#define COL8_FF00FF     5
#define COL8_00FFFF     6
#define COL8_FFFFFF     7
#define COL8_C6C6C6     8
#define COL8_840000     9
#define COL8_008400     10
#define COL8_848400     11
#define COL8_000084     12
#define COL8_840084     13
#define COL8_008484     14
#define COL8_848484     15

void HariMain(void)
{
    int i;
    char *p; //p라는 변수는 byte[]용 번지
    
    init_palette();

    p = (char *)0xa0000;

    boxfill8(p, 320, COL8_FF0000, 20, 20, 120, 120);
    boxfill8(p, 320, COL8_00FF00, 70, 50, 170, 150);
    boxfill8(p, 320, COL8_0000FF, 120, 80, 220, 180);

    for(;;)
    {
        io_hlt();
    }
}

void init_palette(void)
{
    static unsigned char table_rgb[16 * 3] = {
        0x00, 0x00, 0x00,
        0xff, 0x00, 0x00,
        0x00, 0xff, 0x00,
        0xff, 0xff, 0x00,
        0x00, 0x00, 0xff,
        0xff, 0x00, 0xff,
        0x00, 0xff, 0xff,
        0xff, 0xff, 0xff,
        0xc6, 0xc6, 0xc6,
        0x84, 0x00, 0x00,
        0x00, 0x84, 0x00,
        0x84, 0x84, 0x00,
        0x00, 0x00, 0x84,
        0x84, 0x00, 0x84,
        0x00, 0x84, 0x84,
        0x84, 0x84, 0x84
    };

    set_palette(0, 15, table_rgb);
    return;
}

void set_palette(int start, int end, unsigned char *rgb)
{
    int i, eflags;
    eflags = io_load_eflags();  // 인터럽트 허가 플래그 값 가져옴
    io_cli();                   // 허가 플래그를 0으로 하여 인터럽트 금지
    io_out8(0x03c8, start);
    for (i=start;i<=end;i++)
    {
        io_out8(0x03c9, rgb[0] / 4);
        io_out8(0x03c9, rgb[1] / 4);
        io_out8(0x03c9, rgb[2] / 4);
        rgb += 3;
    }
    io_store_eflags(eflags);    // 인터럽트 허가 플래그를 본래 값으로 되돌림.
    return;
}

void boxfill8(unsigned char *vram, int xsize, unsigned char c, int x0, int y0, int x1, int y1)
{
    int x, y;
    for(y = y0; y <= y1; y++)
    {
        for (x=x0; x<=x1; x++)
            vram[y *xsize + x] = c;
    }
    return;
}

 

 

 

바탕화면 만들기

 

일단 박스필 4개만하면 이런식으로 화면이 만들어진다.

 

void HariMain(void)
{
    char *vram;
    int xsize, ysize;
    init_palette();
    vram = (char *) 0xa0000;
    xsize = 320;
    ysize = 200;

    boxfill8(vram, xsize, COL8_008484, 0, 0, xsize-1, ysize-29);    //녹하늘색 화면
    boxfill8(vram, xsize, COL8_C6C6C6, 0, ysize-28, xsize-1, ysize-28); // 바닥 표시줄구분선
    boxfill8(vram, xsize, COL8_FFFFFF, 0, ysize-27, xsize-1, ysize-27); //바닥 표시줄 구분선
    boxfill8(vram, xsize, COL8_C6C6C6, 0, ysize-26, xsize-1, ysize-1); //바닥 표시줄


    for(;;)
    {
        io_hlt();
    }
}

 

 

 

 

 

박스필 몇개 더 추가하면

옛날 윈도우 화면 느낌으로 만들어진다.

void HariMain(void)
{
    char *vram;
    int xsize, ysize;
    init_palette();
    vram = (char *) 0xa0000;
    xsize = 320;
    ysize = 200;

    boxfill8(vram, xsize, COL8_008484, 0, 0, xsize-1, ysize-29);    //녹하늘색 화면
    boxfill8(vram, xsize, COL8_C6C6C6, 0, ysize-28, xsize-1, ysize-28); // 바닥 작업표시줄구분선
    boxfill8(vram, xsize, COL8_FFFFFF, 0, ysize-27, xsize-1, ysize-27); //바닥 작업표시줄 구분선
    boxfill8(vram, xsize, COL8_C6C6C6, 0, ysize-26, xsize-1, ysize-1); //작업 표시줄


	boxfill8(vram, xsize, COL8_FFFFFF,  3,         ysize - 24, 59,         ysize - 24);
	boxfill8(vram, xsize, COL8_FFFFFF,  2,         ysize - 24,  2,         ysize -  4);
	boxfill8(vram, xsize, COL8_848484,  3,         ysize -  4, 59,         ysize -  4);
	boxfill8(vram, xsize, COL8_848484, 59,         ysize - 23, 59,         ysize -  5);
	boxfill8(vram, xsize, COL8_000000,  2,         ysize -  3, 59,         ysize -  3);
	boxfill8(vram, xsize, COL8_000000, 60,         ysize - 24, 60,         ysize -  3);

	boxfill8(vram, xsize, COL8_848484, xsize - 47, ysize - 24, xsize -  4, ysize - 24);
	boxfill8(vram, xsize, COL8_848484, xsize - 47, ysize - 23, xsize - 47, ysize -  4);
	boxfill8(vram, xsize, COL8_FFFFFF, xsize - 47, ysize -  3, xsize -  4, ysize -  3);
	boxfill8(vram, xsize, COL8_FFFFFF, xsize -  3, ysize - 24, xsize -  3, ysize -  3);

    for(;;)
    {
        io_hlt();
    }
}

 

 

 

day04.zip
0.01MB

이전 글에서 ipl 초기 프로그램 로더 만들면서

부트섹터 외 부분은 로드 하지 않음

 

이번에 플로피 디스크 읽도록 수정

 

수정된 ipl.nas 이전 ipl.nas
; hello-os
; TAB=4

ORG 0x7c00 ; 이 프로그램이 어디에 read되는가

; 이하는 표준적인 FAT12 포맷 플로피 디스크를 위한 기술

JMP entry
DB 0x90
DB "HELLOIPL" ; boot sector이름을 자유롭게 써도 좋다(8바이트)
DW 512 ; 1섹터 크기(512로 해야 함)
DB 1 ; 클러스터 크기(1섹터로 해야 함)
DW 1 ; FAT가 어디에서 시작될까(보통은 1섹터째부터)
DB 2 ; FAT 개수(2로 해야 함)
DW 224 ; 루트 디렉토리 영역의 크기(보통은 224엔트리로 한다)
DW 2880 ; 드라이브 크기(2880섹터로 해야 함)
DB 0xf0 ; 미디어 타입(0xf0로 해야 함)
DW 9 ; FAT영역의 길이(9섹터로 해야 함)
DW 18 ; 1트럭에 몇 개의 섹터가 있을까(18로 해야 함)
DW 2 ; 헤드 수(2로 해야 함)
DD 0 ; 파티션을 사용하지 않기 때문에 여기는 반드시 0
DD 2880 ; 드라이브 크기를 한번 더 write
DB 0,0,0x29 ; 잘 모르지만 이 값으로 해 두면 좋은 것 같다
DD 0xffffffff ; 아마, 볼륨 시리얼 번호
DB "HELLO-OS   " ; 디스크 이름(11바이트)
DB "FAT12   " ; 포맷 이름(8바이트)
RESB 18 ; 우선 18바이트를 비어 둔다

; 프로그램 본체

entry:
MOV AX, 0 ; 레지스터 초기화
MOV SS,AX
MOV SP,0x7c00
MOV DS,AX

;디스크 읽기

MOV AX,0x820
MOV ES,AX
MOV CH,0 ; 실린더0
MOV DH,0 ; 헤드 0
MOV CL,2 ; 섹터 2

MOV AH, 0x02 ;AH=0x02; 디스크read
MOV AL, 1 ;1섹터
MOV BX,0
MOV DL,0x00로 ;A드라이브
INT 0x13 ;디스크BIOS 호출
JC error

putloop:
MOV AL,[SI]
ADD SI, 1 ; SI에 1을 더한다
CMP AL,0
JE fin
MOV AH, 0x0e ; 한 글자 표시 Function
MOV BX, 15 ; 칼라 코드
INT 0x10 ; 비디오 BIOS 호출
JMP putloop
fin:
HLT ; 무엇인가 있을 때까지 CPU를 정지시킨다
JMP fin ; Endless Loop

msg:
DB 0x0a, 0x0a ; 개행을 2개
DB "hello, world"
DB 0x0a ; 개행
DB 0

RESB 0x7dfe-$ ; 0x7dfe까지를 0x00로 채우는 명령

DB 0x55, 0xaa
; hello-os
; TAB=4

ORG 0x7c00 ; 이 프로그램이 어디에 read되는가

; 이하는 표준적인 FAT12 포맷 플로피 디스크를 위한 기술

JMP entry
DB 0x90
DB "HELLOIPL" ; boot sector이름을 자유롭게 써도 좋다(8바이트)
DW 512 ; 1섹터 크기(512로 해야 함)
DB 1 ; 클러스터 크기(1섹터로 해야 함)
DW 1 ; FAT가 어디에서 시작될까(보통은 1섹터째부터)
DB 2 ; FAT 개수(2로 해야 함)
DW 224 ; 루트 디렉토리 영역의 크기(보통은 224엔트리로 한다)
DW 2880 ; 드라이브 크기(2880섹터로 해야 함)
DB 0xf0 ; 미디어 타입(0xf0로 해야 함)
DW 9 ; FAT영역의 길이(9섹터로 해야 함)
DW 18 ; 1트럭에 몇 개의 섹터가 있을까(18로 해야 함)
DW 2 ; 헤드 수(2로 해야 함)
DD 0 ; 파티션을 사용하지 않기 때문에 여기는 반드시 0
DD 2880 ; 드라이브 크기를 한번 더 write
DB 0,0,0x29 ; 잘 모르지만 이 값으로 해 두면 좋은 것 같다
DD 0xffffffff ; 아마, 볼륨 시리얼 번호
DB "HELLO-OS   " ; 디스크 이름(11바이트)
DB "FAT12   " ; 포맷 이름(8바이트)
RESB 18 ; 우선 18바이트를 비어 둔다

; 프로그램 본체

entry:
MOV AX, 0 ; 레지스터 초기화
MOV SS,AX
MOV SP,0x7c00
MOV DS,AX
MOV ES,AX

MOV SI,msg
putloop:
MOV AL,[SI]
ADD SI, 1 ; SI에 1을 더한다
CMP AL,0
JE fin
MOV AH, 0x0e ; 한 글자 표시 Function
MOV BX, 15 ; 칼라 코드
INT 0x10 ; 비디오 BIOS 호출
JMP putloop
fin:
HLT ; 무엇인가 있을 때까지 CPU를 정지시킨다
JMP fin ; Endless Loop

msg:
DB 0x0a, 0x0a ; 개행을 2개
DB "hello, world"
DB 0x0a ; 개행
DB 0

RESB 0x7dfe-$ ; 0x7dfe까지를 0x00로 채우는 명령

DB 0x55, 0xaa

 

 

디스크 읽기 설정

- 읽기 : AH=0x02

- 쓰기 : AH=0x03

- DH = 헤드 번호

- DL = 드라이브 번호

- CH = 실린더 번호 & 0xFF

- CL = 섹터번호

 

 

 

일단 책에서 시킨데로 에러는 나오진 않는데 S가 나온다.

S가나오면 안될텐데

 

 

 

 

 

 

책에 설명안된 부분을 안적어서 그랬다.

 

; hello-os
; TAB=4

		ORG		0x7c00			; 이 프로그램이 어디에 read되는가

; 이하는 표준적인 FAT12 포맷 플로피 디스크를 위한 기술

		JMP		entry
		DB		0x90
		DB		"HELLOIPL"		; boot sector이름을 자유롭게 써도 좋다(8바이트)
		DW		512			; 1섹터 크기(512로 해야 함)
		DB		1			; 클러스터 크기(1섹터로 해야 함)
		DW		1			; FAT가 어디에서 시작될까(보통은 1섹터째부터)
		DB		2			; FAT 개수(2로 해야 함)
		DW		224			; 루트 디렉토리 영역의 크기(보통은 224엔트리로 한다)
		DW		2880			; 드라이브 크기(2880섹터로 해야 함)
		DB		0xf0			; 미디어 타입(0xf0로 해야 함)
		DW		9			; FAT영역의 길이(9섹터로 해야 함)
		DW		18			; 1트럭에 몇 개의 섹터가 있을까(18로 해야 함)
		DW		2			; 헤드 수(2로 해야 함)
		DD		0			; 파티션을 사용하지 않기 때문에 여기는 반드시 0
		DD		2880			; 드라이브 크기를 한번 더 write
		DB		0,0,0x29		; 잘 모르지만 이 값으로 해 두면 좋은 것 같다
		DD		0xffffffff		; 아마, 볼륨 시리얼 번호
		DB		"HELLO-OS   "		; 디스크 이름(11바이트)
		DB		"FAT12   "		; 포맷 이름(8바이트)
		RESB	18				; 우선 18바이트를 비어 둔다

; 프로그램 본체

entry:
		MOV		AX, 0			; 레지스터 초기화
		MOV		SS,AX
		MOV		SP,0x7c00
		MOV		DS,AX

;디스크 읽기

		MOV		AX,0x820
		MOV		ES,AX
		MOV		CH,0			; 실린더0
		MOV		DH,0			; 헤드 0
		MOV		CL,2			; 섹터 2

		MOV		AH, 0x02		;AH=0x02; 디스크read
		MOV		AL, 1			;1섹터
		MOV		BX,0
		MOV		DL,0x00로		;A드라이브
		INT		0x13			;디스크BIOS 호출
		JC error
fin:
		HLT					; 무엇인가 있을 때까지 CPU를 정지시킨다
		JMP		fin			; Endless Loop
error:
		MOV		AX,0
		MOV		ES,AX
		MOV		SI,msg
putloop:
		MOV		AL,[SI]
		ADD		SI, 1			; SI에 1을 더한다
		CMP		AL,0
		JE		fin
		MOV		AH, 0x0e		; 한 글자 표시 Function
		MOV		BX, 15			; 칼라 코드
		INT		0x10			; 비디오 BIOS 호출
		JMP		putloop
msg:
		DB		0x0a, 0x0a		; 개행을 2개
		DB		"load error"
		DB		0x0a			; 개행
		DB		0

		RESB	0x7dfe-$		; 0x7dfe까지를 0x00로 채우는 명령

		DB		0x55, 0xaa

 

수정 결과 정상 동작 확인

 

 

 

 

오류시 retry 추가

; hello-os
; TAB=4

		ORG		0x7c00			; 이 프로그램이 어디에 read되는가

; 이하는 표준적인 FAT12 포맷 플로피 디스크를 위한 기술

		JMP		entry
		DB		0x90
		DB		"HELLOIPL"		; boot sector이름을 자유롭게 써도 좋다(8바이트)
		DW		512			; 1섹터 크기(512로 해야 함)
		DB		1			; 클러스터 크기(1섹터로 해야 함)
		DW		1			; FAT가 어디에서 시작될까(보통은 1섹터째부터)
		DB		2			; FAT 개수(2로 해야 함)
		DW		224			; 루트 디렉토리 영역의 크기(보통은 224엔트리로 한다)
		DW		2880			; 드라이브 크기(2880섹터로 해야 함)
		DB		0xf0			; 미디어 타입(0xf0로 해야 함)
		DW		9			; FAT영역의 길이(9섹터로 해야 함)
		DW		18			; 1트럭에 몇 개의 섹터가 있을까(18로 해야 함)
		DW		2			; 헤드 수(2로 해야 함)
		DD		0			; 파티션을 사용하지 않기 때문에 여기는 반드시 0
		DD		2880			; 드라이브 크기를 한번 더 write
		DB		0,0,0x29		; 잘 모르지만 이 값으로 해 두면 좋은 것 같다
		DD		0xffffffff		; 아마, 볼륨 시리얼 번호
		DB		"HELLO-OS   "		; 디스크 이름(11바이트)
		DB		"FAT12   "		; 포맷 이름(8바이트)
		RESB	18				; 우선 18바이트를 비어 둔다

; 프로그램 본체

entry:
		MOV		AX, 0			; 레지스터 초기화
		MOV		SS,AX
		MOV		SP,0x7c00
		MOV		DS,AX

;디스크 읽기

		MOV		AX,0x820
		MOV		ES,AX
		MOV		CH,0			; 실린더0
		MOV		DH,0			; 헤드 0
		MOV		CL,2			; 섹터 2

		MOV		SI,0			;실패 횟수 세는 레지스터

retry:
		MOV		AH, 0x02		;AH=0x02; 디스크read
		MOV		AL, 1			;1섹터
		MOV		BX,0
		MOV		DL,0x00로		;A드라이브
		INT		0x13			;디스크BIOS 호출
		JNC		fin				;에러 없으면 fin으로
		ADD		SI,1			;SI에 1더함
		CMP		SI,5			;SI와 5비교
		JAE		error			; SI>=5 면 error
		MOV		AH,0x00
		MOV		DL,0x00			;A드라이브
		INT		0x13			;드라이브리셋
		JMP		retry

fin:
		HLT					; 무엇인가 있을 때까지 CPU를 정지시킨다
		JMP		fin			; Endless Loop
error:
		MOV		AX,0
		MOV		ES,AX
		MOV		SI,msg
putloop:
		MOV		AL,[SI]
		ADD		SI, 1			; SI에 1을 더한다
		CMP		AL,0
		JE		fin
		MOV		AH, 0x0e		; 한 글자 표시 Function
		MOV		BX, 15			; 칼라 코드
		INT		0x10			; 비디오 BIOS 호출
		JMP		putloop
msg:
		DB		0x0a, 0x0a		; 개행을 2개
		DB		"load error"
		DB		0x0a			; 개행
		DB		0

		RESB	0x7dfe-$		; 0x7dfe까지를 0x00로 채우는 명령

		DB		0x55, 0xaa

 

 

 

 

 

18섹터까지 읽기

 

1장의 디스크

- 80 실린더

- 2 헤드

- 1실린더 = 18섹터

- 1섹터 = 512바이트

- 80 x 2 x 18 x 512 = 1,440kb

 

CL로 섹터 번호 지정. 2 ~ 18섹터까지 반복 읽기수행

; hello-os
; TAB=4

		ORG		0x7c00			; 이 프로그램이 어디에 read되는가

; 이하는 표준적인 FAT12 포맷 플로피 디스크를 위한 기술

		JMP		entry
		DB		0x90
		DB		"HELLOIPL"		; boot sector이름을 자유롭게 써도 좋다(8바이트)
		DW		512			; 1섹터 크기(512로 해야 함)
		DB		1			; 클러스터 크기(1섹터로 해야 함)
		DW		1			; FAT가 어디에서 시작될까(보통은 1섹터째부터)
		DB		2			; FAT 개수(2로 해야 함)
		DW		224			; 루트 디렉토리 영역의 크기(보통은 224엔트리로 한다)
		DW		2880			; 드라이브 크기(2880섹터로 해야 함)
		DB		0xf0			; 미디어 타입(0xf0로 해야 함)
		DW		9			; FAT영역의 길이(9섹터로 해야 함)
		DW		18			; 1트럭에 몇 개의 섹터가 있을까(18로 해야 함)
		DW		2			; 헤드 수(2로 해야 함)
		DD		0			; 파티션을 사용하지 않기 때문에 여기는 반드시 0
		DD		2880			; 드라이브 크기를 한번 더 write
		DB		0,0,0x29		; 잘 모르지만 이 값으로 해 두면 좋은 것 같다
		DD		0xffffffff		; 아마, 볼륨 시리얼 번호
		DB		"HELLO-OS   "		; 디스크 이름(11바이트)
		DB		"FAT12   "		; 포맷 이름(8바이트)
		RESB	18				; 우선 18바이트를 비어 둔다

; 프로그램 본체

entry:
		MOV		AX, 0			; 레지스터 초기화
		MOV		SS,AX
		MOV		SP,0x7c00
		MOV		DS,AX

;디스크 읽기

		MOV		AX,0x820
		MOV		ES,AX
		MOV		CH,0			; 실린더0
		MOV		DH,0			; 헤드 0
		MOV		CL,2			; 섹터 2

readloop:
		MOV		SI,0			;실패 횟수 세는 레지스터
retry:
		MOV		AH, 0x02		;AH=0x02; 디스크read
		MOV		AL, 1			;1섹터
		MOV		BX,0
		MOV		DL,0x00로		;A드라이브
		INT		0x13			;디스크BIOS 호출
		JNC		next			;에러 없으면 fin으로
		ADD		SI,1			;SI에 1더함
		CMP		SI,5			;SI와 5비교
		JAE		error			; SI>=5 면 error
		MOV		AH,0x00
		MOV		DL,0x00			;A드라이브
		INT		0x13			;드라이브리셋
		JMP		retry
next:
		MOV		AX,ES		;어드레스를 0x200 더한다.
		ADD		AX,0x0020	
		MOV		ES,AX		;ADD ES, 0x020이 없어서 이렇게함
		ADD		CL,1		;CL +=1
		CMP		CL,18		;CL과 18비교
		JBE		readloop	; CL <= 18 이면 readloop로

fin:
		HLT					; 무엇인가 있을 때까지 CPU를 정지시킨다
		JMP		fin			; Endless Loop
error:
		MOV		AX,0
		MOV		ES,AX
		MOV		SI,msg
putloop:
		MOV		AL,[SI]
		ADD		SI, 1			; SI에 1을 더한다
		CMP		AL,0
		JE		fin
		MOV		AH, 0x0e		; 한 글자 표시 Function
		MOV		BX, 15			; 칼라 코드
		INT		0x10			; 비디오 BIOS 호출
		JMP		putloop
msg:
		DB		0x0a, 0x0a		; 개행을 2개
		DB		"load error"
		DB		0x0a			; 개행
		DB		0

		RESB	0x7dfe-$		; 0x7dfe까지를 0x00로 채우는 명령

		DB		0x55, 0xaa

 

 

10 실린더 읽기

이전에는 C0-H0-S2 ~ C0-H0-S18까지 읽었는데 이번에는

C9-H1-S18까지 읽어보려고함.

 

맨 위에

CYLS EQU 10으로

CYLS(실린더)=10 설정

; hello-os
; TAB=4


CYLS	EQU		10				; 어디까지 read할지

		ORG		0x7c00			; 이 프로그램이 어디에 read되는가

; 이하는 표준적인 FAT12 포맷 플로피 디스크를 위한 기술

		JMP		entry
		DB		0x90
		DB		"HELLOIPL"		; boot sector이름을 자유롭게 써도 좋다(8바이트)
		DW		512			; 1섹터 크기(512로 해야 함)
		DB		1			; 클러스터 크기(1섹터로 해야 함)
		DW		1			; FAT가 어디에서 시작될까(보통은 1섹터째부터)
		DB		2			; FAT 개수(2로 해야 함)
		DW		224			; 루트 디렉토리 영역의 크기(보통은 224엔트리로 한다)
		DW		2880			; 드라이브 크기(2880섹터로 해야 함)
		DB		0xf0			; 미디어 타입(0xf0로 해야 함)
		DW		9			; FAT영역의 길이(9섹터로 해야 함)
		DW		18			; 1트럭에 몇 개의 섹터가 있을까(18로 해야 함)
		DW		2			; 헤드 수(2로 해야 함)
		DD		0			; 파티션을 사용하지 않기 때문에 여기는 반드시 0
		DD		2880			; 드라이브 크기를 한번 더 write
		DB		0,0,0x29		; 잘 모르지만 이 값으로 해 두면 좋은 것 같다
		DD		0xffffffff		; 아마, 볼륨 시리얼 번호
		DB		"HELLO-OS   "		; 디스크 이름(11바이트)
		DB		"FAT12   "		; 포맷 이름(8바이트)
		RESB	18				; 우선 18바이트를 비어 둔다

; 프로그램 본체

entry:
		MOV		AX, 0			; 레지스터 초기화
		MOV		SS,AX
		MOV		SP,0x7c00
		MOV		DS,AX

;디스크 읽기

		MOV		AX,0x820
		MOV		ES,AX
		MOV		CH,0			; 실린더0
		MOV		DH,0			; 헤드 0
		MOV		CL,2			; 섹터 2

readloop:
		MOV		SI,0			;실패 횟수 세는 레지스터
retry:
		MOV		AH, 0x02		;AH=0x02; 디스크read
		MOV		AL, 1			;1섹터
		MOV		BX,0
		MOV		DL,0x00			;A드라이브
		INT		0x13			;디스크BIOS 호출
		JNC		next			;에러 없으면 fin으로
		ADD		SI,1			;SI에 1더함
		CMP		SI,5			;SI와 5비교
		JAE		error			; SI>=5 면 error
		MOV		AH,0x00
		MOV		DL,0x00			;A드라이브
		INT		0x13			;드라이브리셋
		JMP		retry
next:
		MOV		AX,ES		;어드레스를 0x200 더한다.
		ADD		AX,0x0020	
		MOV		ES,AX		;ADD ES, 0x020이 없어서 이렇게함
		ADD		CL,1		;CL +=1
		CMP		CL,18		;CL과 18비교
		JBE		readloop	; CL <= 18 이면 readloop로
		MOV		CL,1
		ADD		DH,1
		CMP		DH,2
		JB		readloop	;DH<2라면 readloop로
		MOV		DH,0
		ADD		CH,1
		CMP		CH,CYLS
		JB		readloop	;CH<CYLS면 readloop로

fin:
		HLT					; 무엇인가 있을 때까지 CPU를 정지시킨다
		JMP		fin			; Endless Loop
error:
		MOV		AX,0
		MOV		ES,AX
		MOV		SI,msg
putloop:
		MOV		AL,[SI]
		ADD		SI, 1			; SI에 1을 더한다
		CMP		AL,0
		JE		fin
		MOV		AH, 0x0e		; 한 글자 표시 Function
		MOV		BX, 15			; 칼라 코드
		INT		0x10			; 비디오 BIOS 호출
		JMP		putloop
msg:
		DB		0x0a, 0x0a		; 개행을 2개
		DB		"load error"
		DB		0x0a			; 개행
		DB		0

		RESB	0x7dfe-$		; 0x7dfe까지를 0x00로 채우는 명령

		DB		0x55, 0xaa

 

 

중간에 next 부분을 보면

섹터(CL) +1해서 18까지 보내고 

18넘기면 다시 실린더 1 설정

DH 1로 헤더 반대편 확인

DH2가 넘으면 DH = 0으로 다시 헤드 윗면 설정

실린더 CH+1해서 CYLS(10)이 될때까지 루프하도록 동작 

 

next:
		MOV		AX,ES		;어드레스를 0x200 더한다.
		ADD		AX,0x0020	
		MOV		ES,AX		;ADD ES, 0x020이 없어서 이렇게함
		ADD		CL,1		;CL +=1
		CMP		CL,18		;CL과 18비교
		JBE		readloop	; CL <= 18 이면 readloop로
		MOV		CL,1
		ADD		DH,1
		CMP		DH,2
		JB		readloop	;DH<2라면 readloop로
		MOV		DH,0
		ADD		CH,1
		CMP		CH,CYLS
		JB		readloop	;CH<CYLS면 readloop로

 

 

Makefile 수정하기

지금 왜하는건지 설명해주지 않는데

haribote.sys 파일을 만들어서 haribote.img에다가 집어넣는다고 한다. 왜하는진 모르겠는데

 

make file 수정하다보니 알겟는게

초기 프로그램 로더 ipl과 os 본체 haribote.sys를 분리시켜 어셈블한다음 

하나의 img에 합치려고하는듯하다.

 

수정된 makefile

TOOLPATH = ../z_tools/
MAKE     = $(TOOLPATH)make.exe -r
NASK     = $(TOOLPATH)nask.exe
EDIMG    = $(TOOLPATH)edimg.exe
IMGTOL   = $(TOOLPATH)imgtol.com
COPY     = copy
DEL      = del

# 디폴트 동작

default :
	$(MAKE) img

# 파일 생성 규칙

ipl.bin : ipl.nas Makefile
	$(NASK) ipl.nas ipl.bin ipl.lst

haribote.sys : haribote.nas Makefile
	$(NASK) haribote.nas haribote.sys haribote.lst

haribote.img : ipl.bin haribote.sys Makefile
	$(EDIMG)   imgin:../z_tools/fdimg0at.tek \
		wbinimg src:ipl.bin len:512 from:0 to:0 \
		copy from:haribote.sys to:@: \
		imgout:haribote.img

# 커맨드

asm :
	$(MAKE) ipl.bin

img :
	$(MAKE) haribote.img

run :
	$(MAKE) img
	$(COPY) haribote.img ..\z_tools\qemu\fdimage0.bin
	$(MAKE) -C ../z_tools/qemu

install :
	$(MAKE) img
	$(IMGTOL) w a: haribote.img

clean :
	-$(DEL) ipl.bin
	-$(DEL) ipl.lst
	-$(DEL) haribote.sys
	-$(DEL) haribote.lst

src_only :
	$(MAKE) clean
	-$(DEL) haribote.img

 

 

 

작성한 os 본체

기존에 ipl.nas 에도 fin이 있던데 문제되지 않나 싶은데

잘은 모르겟지만 ipl.nas 에선 fin앞에까지만 읽어서 문제없는듯하다.

생각해보니 makefile에서 512바이트만 읽도록 하기도 했엇고.

fin:
        HLT
        JMP     fin

 

 

정상동작 확인

 

 

 

 

헥스에디터로보면 0x01ff에 55aa가 들어가있어서 부트섹터가 제대로 들어가있는것같고

 

 

 

 

os본체 파일명은 0x002600에

파일 내용은 0x004200이후에 있다는데 뭘 잘못햇는지 보이질않는다.

 

 

 

 

아무튼 지나가서

OS 본체 동작 확인

320x200x8bit 컬러 모드로 띄우는데 기존 그대로 나온다.

; haribote-os
; TAB=4

        ORG     0xc200      ;프로그램 로딩될곳

        MOV     AL,0x13     ;VGA 그래픽스, 320x200x8bit컬러
        MOV     AH,0x00
        INT     0x10

fin:
        HLT
        JMP     fin

 

 

기존의 ipl.nas next 레이블 끝에

haribote.sys로 넘어가기위한 코드를 안넣어둿기 때문

 

next:
		MOV		AX,ES		;어드레스를 0x200 더한다.
		ADD		AX,0x0020	
		MOV		ES,AX		;ADD ES, 0x020이 없어서 이렇게함
		ADD		CL,1		;CL +=1
		CMP		CL,18		;CL과 18비교
		JBE		readloop	; CL <= 18 이면 readloop로
		MOV		CL,1
		ADD		DH,1
		CMP		DH,2
		JB		readloop	;DH<2라면 readloop로
		MOV		DH,0
		ADD		CH,1
		CMP		CH,CYLS
		JB		readloop	;CH<CYLS면 readloop로


		MOV		[0x0ff0],CH	;IPL이 어디까지 읽엇는지 메모
		JMP		0xc200

 

0xc200으로 넘어가서 동작하면 QEMU가 검은 스크린이 정상적으로 나온다.

 

 

 

 

0xc200인 이유

- 파일 내용이 0x4200 번지부터 시작됨

- 부트섹터 맨앞이 0x8000에 오도록 지정됨

- 0x8000 + 0x4200 = 0xc200의 메모리를 읽어들이기 때문이라는데 0x8000이 어느 부분에서 그렇게 된건지 못찾겟다.

 

 

 

바이오스 다뤄보기

- 바이오스가 16비트 기계어로 되어있어 32비트 모드에선 사용 불가. 32비트 컴파일러(c언어) 쓰기전에 BIOS 설정부터 해보자.

haribote.nas에 부트 정보랑 키보드 LED 상태 저장하도록 수정

; haribote-os
; TAB=4

;BOOT_INFO
CYLS    EQU     0x0ff0      ;부트섹터가 설정
LEDS    EQU     0x0ff1
VMODE   EQU     0x0ff2      ;색수에 관한 정보
SCRNX   EQU     0x0ff4      ;screen x resolution
SCRNY   EQU     0x0ff6      ;screen y resolution
VRAM    EQU     0x0ff8      ;그래픽버퍼의 개시번지


        ORG     0xc200      ;프로그램 로딩될곳

        MOV     AL,0x13     ;VGA 그래픽스, 320x200x8bit컬러
        MOV     AH,0x00
        INT     0x10

        MOV     BYTE [VMODE],8;화면 모드 메모
        MOV     WORD [SCRNX], 320
        MOV     WORD [SCRNY], 200
        MOV     DWORD [VRAM], 0x000a0000

; 키보드 LED 상태를 BIOS가 알려줌
        MOV     AH,0x020
        INT     0x16        ;keyboard BIOS
        MOV     [LEDS],AL
fin:
        HLT
        JMP     fin

 

 

 

c언어 진입하기 부분이 문제다.

기존에 haribote.nas를 수정한 asmhead.nas가 복잡한것도 그런데

bootpack.c를 기계어로 만드는부분 설명이 요란하다.

내가 전에 어떻게 이걸했지?

일단 asmhead.nas

; haribote-os boot asm
; TAB=4

BOTPAK	EQU		0x00280000		; bootpack의 로드 장소
DSKCAC	EQU		0x00100000		; 디스크 캐쉬 프로그램의 장소
DSKCAC0	EQU		0x00008000		; 디스크 캐쉬 프로그램의 장소(리얼모드)

; BOOT_INFO 관계
CYLS	EQU		0x0ff0			; boot sector가 설정한다
LEDS	EQU		0x0ff1
VMODE	EQU		0x0ff2			; 색 가지수에 관한 정보.어떤 비트 칼라인가?
SCRNX	EQU		0x0ff4			; 해상도의 X
SCRNY	EQU		0x0ff6			; 해상도의 Y
VRAM	EQU		0x0ff8			; 그래픽 버퍼의 개시 번지

		ORG		0xc200		; 이 프로그램이 어디에 Read되는가

; 화면 모드를 설정

		MOV		AL, 0x13	; VGA 그래픽스, 320 x200x8bit 칼라
		MOV		AH,0x00
		INT		0x10
		MOV		BYTE [VMODE], 8	; 화면 모드를 메모 한다(C언어가 참조한다)
		MOV		WORD [SCRNX],320
		MOV		WORD [SCRNY],200
		MOV		DWORD [VRAM],0x000a0000

; 키보드의 LED 상태를 BIOS가 가르쳐 준다

		MOV		AH,0x02
		INT		0x16 		; keyboard BIOS
		MOV		[LEDS],AL

; PIC가 일절의 세치기를 받아들이지 않게 한다
;	AT호환기의 사양에서는, PIC의 초기화를 한다면,
;	진한 개를 CLI앞에 해 두지 않으면 이따금 행업 한다
;	PIC의 초기화는 나중에 한다

		MOV		AL,0xff
		OUT		0x21,AL
		NOP				; OUT 명령을 연속하면 잘 되지 않는 기종이 있는 것 같기 때문에
		OUT		0xa1,AL

		CLI				; CPU 레벨에서도 인터럽트 금지

; CPU로부터 1MB이상의 메모리에 액세스 할 수 있도록, A20GATE를 설정

		CALL	waitkbdout
		MOV		AL,0xd1
		OUT		0x64,AL
		CALL	waitkbdout
		MOV		AL, 0xdf	; enable A20
		OUT		0x60,AL
		CALL	waitkbdout

; 프로텍트 모드 이행

[INSTRSET "i486p"]				; 486명령까지 사용하고 싶다고 하는 기술

		LGDT	[GDTR0]			; 잠정 GDT를 설정
		MOV		EAX,CR0
		AND		EAX, 0x7fffffff	; bit31를 0으로 한다(페이징 금지를 위해)
		OR		EAX, 0x00000001	; bit0를 1로 한다(프로텍트 모드 이행이므로)
		MOV		CR0,EAX
		JMP		pipelineflush
pipelineflush:
		MOV		AX,1*8		; read, write 가능 세그먼트(segment) 32bit
		MOV		DS,AX
		MOV		ES,AX
		MOV		FS,AX
		MOV		GS,AX
		MOV		SS,AX

; bootpack의 전송

		MOV		ESI, bootpack	; 전송원
		MOV		EDI, BOTPAK	; 전송처
		MOV		ECX,512*1024/4
		CALL	memcpy

; 하는 김에 디스크 데이터도 본래의 위치에 전송

; 우선은 boot sector로부터

		MOV		ESI, 0x7c00	; 전송원
		MOV		EDI, DSKCAC	; 전송처
		MOV		ECX,512/4
		CALL	memcpy

; 나머지 전부

		MOV		ESI, DSKCAC0+512; 전송원
		MOV		EDI, DSKCAC+512	; 전송처
		MOV		ECX,0
		MOV		CL,BYTE [CYLS]
		IMUL	ECX,512*18*2/4		; 실린더수로부터 바이트수/4에 변환
		SUB		ECX,512/4	; IPL분만큼 공제한다
		CALL	memcpy

; asmhead에서 해야 하는 것은 전부 다 했으므로,
;	나머지는 bootpack에 맡긴다

; bootpack의 기동

		MOV		EBX,BOTPAK
		MOV		ECX,[EBX+16]
		ADD		ECX, 3		; ECX += 3;
		SHR		ECX, 2		; ECX /= 4;
		JZ		skip		; 전송 해야 할 것이 없다
		MOV		ESI,[EBX+20]	; 전송원
		ADD		ESI,EBX
		MOV		EDI,[EBX+12]	; 전송처
		CALL	memcpy
skip:
		MOV		ESP,[EBX+12]	; 스택 초기치
		JMP		DWORD 2*8:0x0000001b

waitkbdout:
		IN		 AL,0x64
		AND		 AL,0x02
		IN		 AL, 0x60	; 빈 데이터 READ(수신 버퍼가 나쁜짓을 못하게)
		JNZ		waitkbdout	; AND결과가 0이 아니면 waitkbdout에
		RET

memcpy:
		MOV		EAX,[ESI]
		ADD		ESI,4
		MOV		[EDI],EAX
		ADD		EDI,4
		SUB		ECX,1
		JNZ		memcpy		; 뺄셈 한 결과가 0이 아니면 memcpy에
		RET
; memcpy는 주소 사이즈 prefix 넣는 것을 잊지 않으면, string 명령에서도 쓸 수 있다

		ALIGNB	16
GDT0:
		RESB	8			; null selector
		DW		0xffff, 0x0000, 0x9200, 0x00cf	; read/write 가능 세그먼트(segment) 32bit
		DW		0xffff, 0x0000, 0x9a28, 0x0047	; 실행 가능 세그먼트(segment) 32 bit(bootpack용)

		DW		0
GDTR0:
		DW		8*3-1
		DD		GDT0

		ALIGNB	16
bootpack:

 

 

 

그래도 길이가 작은 부분은 직접 쳐보자

먼저 bootpack.c

void io_hlt(void);

void HariMain(void)
{

fin:
    io_hlt();
    goto fin;
}

 

naskfunc.nas

;naskfunc
;TAB=4

[FORMAT "WCOFF"]        ;오브젝트 파일 만드는 모드
[BITS 32]               ;32비트모드용 기계어 만듬

;오브젝트 파일ㅇ 위한 정보
[FILE "naskfunc.nas"]   ;소스파일명 정보
    GLOBAL  _io_hlt     ;이프로그램에 포함된 함수명

; 실제 함수

[SECTION .text]         ;오브젝트 파일에서는 이것을 쓴후에 프로그램을 쓴다.
_io_hlt:   ;void io_hlt(void);
    HLT
    RET

 

 

 

 

makefile도 너무 길어졋으므로 그냥 복붙해서 사용

TOOLPATH = ../z_tools/
INCPATH  = ../z_tools/haribote/

MAKE     = $(TOOLPATH)make.exe -r
NASK     = $(TOOLPATH)nask.exe
CC1      = $(TOOLPATH)cc1.exe -I$(INCPATH) -Os -Wall -quiet
GAS2NASK = $(TOOLPATH)gas2nask.exe -a
OBJ2BIM  = $(TOOLPATH)obj2bim.exe
BIM2HRB  = $(TOOLPATH)bim2hrb.exe
RULEFILE = $(TOOLPATH)haribote/haribote.rul
EDIMG    = $(TOOLPATH)edimg.exe
IMGTOL   = $(TOOLPATH)imgtol.com
COPY     = copy
DEL      = del

# 디폴트 동작

default :
	$(MAKE) img

# 파일 생성 규칙

ipl10.bin : ipl10.nas Makefile
	$(NASK) ipl10.nas ipl10.bin ipl10.lst

asmhead.bin : asmhead.nas Makefile
	$(NASK) asmhead.nas asmhead.bin asmhead.lst

bootpack.gas : bootpack.c Makefile
	$(CC1) -o bootpack.gas bootpack.c

bootpack.nas : bootpack.gas Makefile
	$(GAS2NASK) bootpack.gas bootpack.nas

bootpack.obj : bootpack.nas Makefile
	$(NASK) bootpack.nas bootpack.obj bootpack.lst

naskfunc.obj : naskfunc.nas Makefile
	$(NASK) naskfunc.nas naskfunc.obj naskfunc.lst

bootpack.bim : bootpack.obj naskfunc.obj Makefile
	$(OBJ2BIM) @$(RULEFILE) out:bootpack.bim stack:3136k map:bootpack.map \
		bootpack.obj naskfunc.obj
# 3MB+64KB=3136KB

bootpack.hrb : bootpack.bim Makefile
	$(BIM2HRB) bootpack.bim bootpack.hrb 0

haribote.sys : asmhead.bin bootpack.hrb Makefile
	copy /B asmhead.bin+bootpack.hrb haribote.sys

haribote.img : ipl10.bin haribote.sys Makefile
	$(EDIMG)   imgin:../z_tools/fdimg0at.tek \
		wbinimg src:ipl10.bin len:512 from:0 to:0 \
		copy from:haribote.sys to:@: \
		imgout:haribote.img

# 커맨드

img :
	$(MAKE) haribote.img

run :
	$(MAKE) img
	$(COPY) haribote.img ..\z_tools\qemu\fdimage0.bin
	$(MAKE) -C ../z_tools/qemu

install :
	$(MAKE) img
	$(IMGTOL) w a: haribote.img

clean :
	-$(DEL) *.bin
	-$(DEL) *.lst
	-$(DEL) *.gas
	-$(DEL) *.obj
	-$(DEL) bootpack.nas
	-$(DEL) bootpack.map
	-$(DEL) bootpack.bim
	-$(DEL) bootpack.hrb
	-$(DEL) haribote.sys

src_only :
	$(MAKE) clean
	-$(DEL) haribote.img

 

 

 

검정화면만 나와서 모르겟지만 정상동작하는듯하다.

 

 

 

 

 

day03.zip
0.02MB

플로피 디스크에서 512바이트까지가 부트섹터였는데

nask로 부트섹터 만들고, 나머지는 이미지 툴로 만듬

 

 

기존에 어셈블 코드

asm.bat

..\z_tools\nask.exe helloos.nas helloos.img

 

을 bin과 lst (기계어로 번역되는 명령 목록) 출력되도록 수정

..\z_tools\nask.exe ipl.nas ipl.bin ipl.lst

 

making.bat

ipl.bin으로 helloos.img 만듬

edimg.exe로 ipl.bin 먼저 놓고 helloos.img 이미지 출력

..\z_tools\edimg.exe   imgin:../z_tools/fdimg0at.tek   wbinimg src:ipl.bin len:512 from:0 to:0   imgout:helloos.img

 

 

 

ipl.bin에는 부트섹터내용만 들어가므로

helloos3의 맨 끝에 부트섹터외는 제외되어있음.

 

기존 helloos3 ipl.nas
;hello-os
;TAB

ORG 0x7c00      ;메모리내 어디에 로딩되는지

JMP entry
DB  0x90

DB "HELLOIPL" ; boot sector이름을 자유롭게 써도 좋다(8바이트)
DW 512 ; 1섹터 크기(512로 해야 함)
DB 1 ; 클러스터 크기(1섹터로 해야 함)
DW 1 ; FAT가 어디에서 시작될까(보통 1섹터째부터)
DB 2 ; FAT 개수(2로 해야 함)
DW 224 ; 루트 디렉토리 영역의 크기(보통 224엔트리로 해야 한다)
DW 2880 ; 드라이브 크기(2880섹터로 해야 함)
DB 0xf0 ; 미디어 타입(0xf0로 해야 함)
DW 9 ; FAT영역 길이(9섹터로 해야 함)
DW 18 ; 1트럭에 몇 개의 섹터가 있을까(18로 해야 함)
DW 2 ; 헤드 수(2로 해야 함)
DD 0 ; 파티션을 사용하지 않기 때문에 여기는 반드시 0
DD 2880 ; 드라이브 크기를 한번 더 write
DB 0,0,0x29 ; 잘 모르지만 이 값으로 해 두면 좋은 것 같다
DD 0xffffffff ; 아마, 볼륨 시리얼 번호
DB "HELLO-OS   " ; 디스크 이름(11바이트)
DB "FAT12   " ; 포맷 이름(8바이트)
RESB 18 ; 우선 18바이트를 비어 둔다

;프로그램 본체

entry:
    MOV AX, 0      ;레지스터 초기화
    MOV SS,AX
    MOV SP,0x7c00
    MOV DS,AX
    MOV ES,AX

    MOV SI,msg

putloop:
    MOV AL,[SI]
    ADD SI,1        ;si에 1더함
    CMP AL,0
    JE  fin
    MOV AH,0x0e     ;한문자 표시기능
    MOV BX,15       ;컬러코드
    INT 0x10        ;비디오BIOS호출
    JMP putloop

fin:
    HLT             ;cpu정지
    JMP fin         ;무한루프

msg:
    DB  0x0a, 0x0a  ;줄바꿈문자2개
    DB  "hello, world"
    DB  0x0a        ;줄바꿈문자2개
    DB  0

    RESB 0x7dfe-$   ;0x7dfe까지 0x00으로 채우기
    DB  0x55, 0xaa

; boot sector 이외부분 기술

DB      0xf0, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00
RESB    4600
DB      0xf0, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00
RESB    1469432
; hello-os
; TAB=4

ORG 0x7c00 ; 이 프로그램이 어디에 read되는가

; 이하는 표준적인 FAT12 포맷 플로피 디스크를 위한 기술

JMP entry
DB 0x90
DB "HELLOIPL" ; boot sector이름을 자유롭게 써도 좋다(8바이트)
DW 512 ; 1섹터 크기(512로 해야 함)
DB 1 ; 클러스터 크기(1섹터로 해야 함)
DW 1 ; FAT가 어디에서 시작될까(보통은 1섹터째부터)
DB 2 ; FAT 개수(2로 해야 함)
DW 224 ; 루트 디렉토리 영역의 크기(보통은 224엔트리로 한다)
DW 2880 ; 드라이브 크기(2880섹터로 해야 함)
DB 0xf0 ; 미디어 타입(0xf0로 해야 함)
DW 9 ; FAT영역의 길이(9섹터로 해야 함)
DW 18 ; 1트럭에 몇 개의 섹터가 있을까(18로 해야 함)
DW 2 ; 헤드 수(2로 해야 함)
DD 0 ; 파티션을 사용하지 않기 때문에 여기는 반드시 0
DD 2880 ; 드라이브 크기를 한번 더 write
DB 0,0,0x29 ; 잘 모르지만 이 값으로 해 두면 좋은 것 같다
DD 0xffffffff ; 아마, 볼륨 시리얼 번호
DB "HELLO-OS   " ; 디스크 이름(11바이트)
DB "FAT12   " ; 포맷 이름(8바이트)
RESB 18 ; 우선 18바이트를 비어 둔다

; 프로그램 본체

entry:
MOV AX, 0 ; 레지스터 초기화
MOV SS,AX
MOV SP,0x7c00
MOV DS,AX
MOV ES,AX

MOV SI,msg
putloop:
MOV AL,[SI]
ADD SI, 1 ; SI에 1을 더한다
CMP AL,0
JE fin
MOV AH, 0x0e ; 한 글자 표시 Function
MOV BX, 15 ; 칼라 코드
INT 0x10 ; 비디오 BIOS 호출
JMP putloop
fin:
HLT ; 무엇인가 있을 때까지 CPU를 정지시킨다
JMP fin ; Endless Loop

msg:
DB 0x0a, 0x0a ; 개행을 2개
DB "hello, world"
DB 0x0a ; 개행
DB 0

RESB 0x7dfe-$ ; 0x7dfe까지를 0x00로 채우는 명령

DB 0x55, 0xaa 

 

 

 

 

부트섹터 이외부분이 제거되어있는데 왜 정상동작하는지는 모르겠다.

거의 0으로 채우는거긴했는데

생각해보니 msg 맨 뒷부분에 0x7fde까지 0으로 채우고 마지막에 0x55,0xaa를 넣어놧구나

512바이트 맨 마지막에 0x55,0xaa가 있으면 부팅가능 디스크로 판단했다고 정리했었다.

 

 

 

메이크파일 만들기

Makefile

# 파일 생성 규칙
ipl.bin : ipl.nas Makefile
	..\z_tools\nask.exe ipl.nas ipl.bin ipl.lst

helloos.img : ipl.bin Makefile
	..\z_tools\edimg.exe	imgin:..\z_tools\fdimg0at.tek \
	wbinimg src:ipl.bin len:512 from:0 to:0 imgout:helloos.img

 

make -r helloos.img 로 

bin과 lst 생성 후 img까지 생성

 

 

 

 

 

make file 개선

make run만 해주면

img 만들고 실행

소스만 남기도록 비우는 코드도 추가

# 파일 생성 규칙
ipl.bin : ipl.nas Makefile
	..\z_tools\nask.exe ipl.nas ipl.bin ipl.lst

helloos.img : ipl.bin Makefile
	..\z_tools\edimg.exe	imgin:..\z_tools\fdimg0at.tek \
	wbinimg src:ipl.bin len:512 from:0 to:0 imgout:helloos.img


img :
	..\z_tools\make.exe -r helloos.img


asm:
	..\z_tools\make.exe -r ipl.bin

run :
	..\z_tools/make.exe img
	copy helloos.img ..\z_tools\qemu\fdimage0.bin
	..\z_tools\make.exe -C ..\z_tools\qemu

install :
	..\z_tools\make.exe img
	..\z_tools\imgtol.com w a: helloos.img

clean :
	-del ipl.bin
	-del ipl.lst

src_only :
	..\z_tools\make.exe clean
	-del helloos.img

 

 

 

day02.zip
0.00MB

 

 

이번에 사용할 helloos3 이미지 어셈블리파일

 

;hello-os
;TAB

ORG 0x7c00      ;메모리내 어디에 로딩되는지

JMP entry
DB  0x90

DB		"HELLOIPL"		; boot sector이름을 자유롭게 써도 좋다(8바이트)
DW		512			; 1섹터 크기(512로 해야 함)
DB		1			; 클러스터 크기(1섹터로 해야 함)
DW		1			; FAT가 어디에서 시작될까(보통 1섹터째부터)
DB		2			; FAT 개수(2로 해야 함)
DW		224			; 루트 디렉토리 영역의 크기(보통 224엔트리로 해야 한다)
DW		2880			; 드라이브 크기(2880섹터로 해야 함)
DB		0xf0			; 미디어 타입(0xf0로 해야 함)
DW		9			; FAT영역 길이(9섹터로 해야 함)
DW		18			; 1트럭에 몇 개의 섹터가 있을까(18로 해야 함)
DW		2			; 헤드 수(2로 해야 함)
DD		0			; 파티션을 사용하지 않기 때문에 여기는 반드시 0
DD		2880			; 드라이브 크기를 한번 더 write
DB		0,0,0x29		; 잘 모르지만 이 값으로 해 두면 좋은 것 같다
DD		0xffffffff		; 아마, 볼륨 시리얼 번호
DB		"HELLO-OS   "		; 디스크 이름(11바이트)
DB		"FAT12   "		; 포맷 이름(8바이트)
RESB	18				; 우선 18바이트를 비어 둔다

;프로그램 본체

entry:
    MOV AX, 0      ;레지스터 초기화
    MOV SS,AX
    MOV SP,0x7c00
    MOV DS,AX
    MOV ES,AX

    MOV SI,msg

putloop:
    MOV AL,[SI]
    ADD SI,1        ;si에 1더함
    CMP AL,0
    JE  fin
    MOV AH,0x0e     ;한문자 표시기능
    MOV BX,15       ;컬러코드
    INT 0x10        ;비디오BIOS호출
    JMP putloop

fin:
    HLT             ;cpu정지
    JMP fin         ;무한루프

msg:
    DB  0x0a, 0x0a  ;줄바꿈문자2개
    DB  "hello, world"
    DB  0x0a        ;줄바꿈문자2개
    DB  0

    RESB 0x7dfe-$   ;0x7dfe까지 0x00으로 채우기
    DB  0x55, 0xaa

; boot sector 이외부분 기술

DB      0xf0, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00
RESB    4600
DB      0xf0, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00
RESB    1469432

 

 

실행결과

 

 

 

어셈블리 정리

ORG : 여기부터 프로그램 시작점, 여기 기준으로 로드됨

JMP : goto

entry : 레이블 선언

MOV AX,0 : AX에 0 대입

 

16비트 레지스터들

AX(누산기), CX(카운터), DX(데이터), BX(베이스), SP(스텍포인터), BP(베이스 포인터), SI(소스인덱스), DI(목적인덱스)

 

세그먼트 레지스터들

ES 엑스트라 세그먼트, CS 코드 세그먼트, SS 스택세그먼트, DS 데이터세그먼트

 

 

ORG와 레이블 이해

ORG로 0x7c00에서 시작

entry는 0x7c50

msg는 0x7c74

MOV SI, msg => SI 소스인덱스 레지스터에 0x7c74 대입

 

 

[]이해하기

MOV WORD [678], 123 : 678, 679번지에 123 입력(리틀엔디언식)

데이터크기 [번지]

ex : BYTE [SI], WORD[BX], SI에 987이 있을떄 : BYTE[987] == BYTE[SI]

 

MOV AL, [SI] 이해하기

MOV AL, BYTE[SI]에서 데이터크기 BYTE 생략(AL은 8비트 레지스터이므로 크기 생략가능)

MOV AL, [SI] : SI번지의 1바이트를 AL로 대입하라

 

ADD 연산

ADD SI, 1 : SI = SI + 1

 

CMP 비교 연산

CMP AL, 0

JE fin 

AL == 0 이면 fin으로 가라

 

INT

- 인터럽트

- INT 주소 : 주소 함수 호출

- INT 0x10 : 16번 비디오제어 함수 호출

 

BIOS 문자 표시 적기

- AH = 0x0e;

- AL = 캐릭터 코드

- BH = 컬러코드

- 리턴 : 없음

 

putloop 파트와 같이 보기

- AL 누산기LOW에 SI 소스인덱스 레지스터 번지 값 대입

- SI = SI +1

- 누산기 LOW가 0이면 fin으로

- MOV AH, 0x0e로 문자 표 시설정

- MOV BX,15로 컬러 설정

putloop:
    MOV AL,[SI]
    ADD SI,1        ;si에 1더함
    CMP AL,0
    JE  fin
    MOV AH,0x0e     ;한문자 표시기능
    MOV BX,15       ;컬러코드
    INT 0x10        ;비디오BIOS호출
    JMP putloop

 

 

 

helloos2에서 DB로 작성한 어셈블리 코드가

좌측과 같이 고쳐졌는데

putloop 부분이 잘 이해되지 않는다.

 

SI 소스 인덱스 레지스터에다가 msg 레이블 넣고

SI주소값을 AL에다 대입

SI 다음 주소값을 AL에다 대입

계속반복

msg 마지막엔 db 0가 있으므로

putloop CMP AL,0이 true가 되는 때가 온다.

 

 

아 JMP msg가 아니라

MOV SI, msg라 

entry: 레이블 다음에 그대로 putloop에 진행한듯보인다.

 

helloos3 helloos2

 

 

 

 

 

 

이전 글에서 내가 무엇을 했느냐,,,

전에 쓴 글을보면서 

헥스에디터로 이미지파일 만들고 qemu로 돌리기까지 했었다.

 

책 설명이 제대로 안되있는데 내가 어떻게 이걸했을까 생각하다보니 한빛미디어 자료실에 

올라와있는 자료를 보고 했었던것같다

책 링크 걸어둔다.

 

https://m.hanbit.co.kr/store/books/book_view.html?p_code=B9833754652

 

OS 구조와 원리: OS 개발 30일 프로젝트

저자가 수년 동안 개발하여 완성한 OS를 독자와 함께 30일 프로젝트로 함께 만들어가는 내용이다. OS는 플로피디스크로도 구동할 수 있고 우리가 사용하고 있는 윈도우 XP와 같은 OS에서 에뮬레이

m.hanbit.co.kr

https://dw.hanbit.co.kr/exam/1482/

 

Index of /exam/1482

 

dw.hanbit.co.kr

 

 

아무튼 다음으로 할일은 어셈블리를 쓰려고한다.

헥스에디터대신 텍스트에디터로 만들고

nasm 대신 저자가 만든 nask로 어셈블하면 이전처럼 쓸수있다고한다.

 

오랜만에 인성훈련을 위해 어셈블리 그대로 쓰고

(이전 글 헥스 에디터 사진과 같이 보면 내용 동일함)

 

이미지 파일로 빌드

 

 

 

 

방금 nask로 빌드한 이미지가 정상적으로 실행된걸 확인했다!

 

 

뜻정리하면

DB : data byte 1바이트 쓰기

RESB : reserve byte 숫자만큼 0x00으로 채우기

 

 

 

어셈블리 코드 개선 결과

; 는 주석

DW : data word 워드로 18비트, 2바이트

DD : data double word 더블 워드로 4바이트

 

 

 

 

 

추가 용어 정리

FAT12 포맷 : 플로피 디스크 포멧 형식

부트섹터 

 - 플로피디스크 처음섹터, 플로피는 512바이트씩 읽음

 - 플로피는 1,440kb로 512바이트로 나누면 2880섹터로 구성

 * 부팅가능한지 보기위해 첫 섹터의 맨뒤 2바이트를 봄. 마지막이 55 AA가 아니면 부팅할수 없다고 판단.

 =>이게 무슨소린가 싶어서 헥스에디터로보니 첫 섹터 512바이트 맨 끝부분에 55 AA가 들어가있음

IPL : initial program loader 초기 프로그램 읽기 장치, 보통 OS 로드하기위한 프로그램 위치

부트 : 부트스트랩의 약어, 자신의 힘으로 이룬다는 의미

예전에 OS개발30일프로젝트 책보고 어느정도 진행하다가 커서띄우기?까지인가 하다가 말았던적이 있다.

os만들길할까 언어만들기해볼까 고민하다가 

가장 생각없이 할수있을것같은 책이어서 이 책을 진행해보려고함.

 

근데 이 책이 15년도 전에 나온 책이라 자료들링크가 안된다.

 

이 링크에 들어가도 안나오는데

http://www.zob.ne.jp/~c.mos/soft/bz.html

 

다행이 우리나라분이 따로블로그에 파일올려둠

https://m.blog.naver.com/websearch/70029495287

 

바이너리 에디터 (2진수 편집기)

"OS구조와 원리" 란 책을 읽다가 알게된 프로그램인데 바이너리 파일 작성 및 수정에 좋은 프로그램인 것...

blog.naver.com

 

나도 백업삼아서 여기다 추가로도올림

Bz162.zip
0.05MB

 

 

바이너리 헥스 에디터인데

키보드입력하면 좌측에는 헥스값이 우측에는 실제값이 나온다.

숫자 1 하면 31

0은 30

a는 61

b는 62식으로 찍힘

 

다시 돌아와서 책이 시키느데로 다시찍어보자

 

일단 000037까지 적긴했는데

90이후부터 168000까지 0누르면된다고한다.

그러면 37~90까진 뭘까?

 

별 내용이없으니 그냥 복붙으로 168000까지내려왓다.

 

 

중간에 0001F0과 001400에 00을하면안된다고해서 그부분들좀 고쳐주자

 

 

뭔진모르겟지만 디스크이미지를 만들었다!

설명대로 크기는 1,474,560 바이트(1440 x1024)

이름은 helloos.img로 저장

 

원래같으면 플로피디스크에다가 이걸 넣어서 부팅시켜 확인해야하는데 플로피디스켓이 없다.

예전에 내가 어떻게 했나 다시보면

 

https://throwexception.tistory.com/628

 

os만들기 - 2. 에뮬레이터에서 돌리기 삽질기 feat.msys

자료에서보면 boshs에 방금 만든 이미지를 돌리더라 바로 돌릴수 있는줄 알고 해봤지만 - 부팅가능한 이미지가 아니라고 아무것도 뜨지 않는다. 다시 잘보니 toolset으로 부팅 가능 이미지로 만들

throwexception.tistory.com

 

 

대충 이 사람이 만든걸 썻던것같다.

 

https://github.com/fakefish/OSASK/tree/master

 

GitHub - fakefish/OSASK: 30天自制操作系统的学习

30天自制操作系统的学习. Contribute to fakefish/OSASK development by creating an account on GitHub.

github.com

 

 

 

위 깃헙 파일 tolset 폴더에

helloos0 폴더만들고 내가 만든 이미지 복사

z_new_w에 있는 cons_9x와 cons_nt.bat 가져오고

 

install.bat과 run.bat 작성

 

 

 

 

 

cons_nt.bat 실행후 run 명령을 주면

qemu가 돌아가는데 이미지를 잘못 만들었는지 not a bootable disk가 뜬다. 

 

 

 

 

내가 뭘 잘못했는가 이해가안갓는데

위에서 아까 안쓴부분이 문제인것같았다.

다행이 이전에 내가 뭘보고 만든건진 모르겟지만 전체 작성한 기록이 있어서 참고해서 따라만듬

 

https://throwexception.tistory.com/629

 

os만들기 - 3. 글자찍히는 부팅가능한 바이너리 이미지 만들기

os만들기 - 2에서 한 모든 일들은 다 쓸모없는 짓이었다. 나중에 다시보니 지금 하는 바이너리 파일 만드는건 모든 바이너리 코드들을 내 마음대로가 아니라 똑같이 만들어야 부팅가능한 이미지

throwexception.tistory.com

 

 

 

 

 

 

 

다행이 이전 링크에 내가 처음 만든 이미지파일도 올려놔서 따라서 보고 뭐가 문젠지 찾아 고ㅕ쳤다.

바이너리 에디터로 부팅하는 이미지 만듦

helloos.img
1.41MB

 

 

 

 

시리얼 통신 책 읽은 다음에 본 책은

임베디드 하드웨어 이해와 설계

2006년도에나온 대충 20년전 책이다.

 

이 책을 왜 봤느냐

임베디드 보드를 어떻게 만드는지 궁금해서 봤다

 

기본적인 컴퓨터 개념부터 어셈블리어, 전기전자, 주변장치를 다룬 후

마이크로컨트롤러로 간단한 컴퓨터 만드는 내용을 다룬다.

 

사실 내가 바란건 ARM 코어 A 시리즈로 어떻게 임베디드 리눅스 보드 만드는지 궁금하기도 했지만

그것보다 낮은 레벨(이 책 내용도 제대로 이해못하고 대충 넘어갔으나) 의 내용이지만 보게되었음

 

앞에 컴퓨터 구조나 전기전자 내용은 잘 이해하는건 아니지만 이전에 공부하면서 여러번 봤던 개념이라 대충 넘어갈수 있어고

주변장치 시리얼, USB, 네트워크 부분은 꽤 유익하게 볼수 있엇다

마이크로 컨트롤러에 주변장치를 어떻게 연결해서 사용하는지를 대강 파악하는데 도움은 되었음

 

뒷부분에 실제 컴퓨터 만드는 내용들이 있는데 내가 이해하기 힘들어서 AVR 파트만 대충 보고 말았다.

ATTINY15 는 내장 오실레이터가 있으니 따로 진동자 안달고 어떻게 프로그래밍하는지 

이 책의 전체 내용중 10~20% 정도 이해한것같긴하지만 처음 이만큼 읽은게 어딘가싶다.

 

 

다음에 볼 책은

보안에 미쳐라에서 소개했던 운영체제만들기 보려고하는데 걱정이다.

 

https://www.yes24.com/Product/Goods/2143795

 

임베디드 하드웨어 이해와 설계 - 예스24

이 책의 가장 큰 특징은 소프트웨어 개발자가 임베디드 하드웨어를 공부할 때 저자의 도움으로 쉽고 재미있게 하드웨어를 학습할 수 있다. 한마디로 임베디드 분야로 영역을 넓히는 소프트웨어

www.yes24.com

오랜만에 본 책은 시리얼 통신 핸드북

 

볼 책은 많이 찾아두긴 했는데 영 읽히지가 않아서 뒤적뒤적하다가

데이터 통신하는쪽이 그나마 덜 부담스러워서 본 책이다.

 

시리얼 통신이라 함믄

uart, spi, i2c가 어떻게 생겨있는지 정도만 이해하고 있었지

 

ttl 레벨을 증폭시켜서 쓴다느니 하는 내용은 잘 감이 잡히지 않은 상태였다.

그리고 컴퓨터는 병렬로 처리하는대 어떻게 직렬통신을 한다는것인가 잘 이해안가는 부분이 많았는데

 

이런 궁금했던 부분들을 해소해준 책이다.

 

직렬 통신은

데이터 처리부 - UART - 라인트렌시버 - 케이블 - 라인트렌시버 - uart - 데이터 처리부 

같은 식으로 구성되어있는데

 

데이터 처리부에서 병렬 데이터를 uart 가밭아 직렬로 만들고

라인트렌시버를통해 ttl, cmos 전압 레벨을 띄워서 통신해주는 거더라 

 

그리고 각 기기간 통신 속도를 맞춰줘도 속도가 안맞으면 어떻게 처리하는건가 싶엇느ㅡㄴ데

이걸 오버런 에러라 부르며 별도의 핀을통해 하드웨어적인 방법이나 소프트웨어 적인 방법으로 조절하는걸 알았다.

 

그리고 rs-232에 사용하는 db-9 커넥터의 경우 핀이 9개인데 아두이노 에서 쓰는 직렬통신은 핀을 3개만 써서 왜 이런건가 싶엇는데 핀 3개 쓰는경우 5개 쓰는경우 9개쓰는 경우 등 다 에러 조절을 위해서 이렇게 늘려서쓸수있는거더라

 

rs-232, rs-422, rs-485도 구분이 좀됬다.

232의 경우 언발랜스드 신호로 그라운드 기준으로 했다면

422, 485는 차동 신호로 거리를 늘린점

422는 1:N이지만 485는 N:N 차이 정도

 

중간에 회로 구성에 대한 부분은 대충 넘어가기도 했고

마지막에 커넥터나 무선 통신 부분도 

와이파이, 블루투스, 지그비, 로라 등 표로 간략하게 정리된게 좋았음.

 

국내에 직렬통신에 이만큼 진심인 책은 없을듯싶다

 

 

https://www.yes24.com/Product/Goods/102907829

 

[전자책]시리얼통신 핸드북 - 예스24

시리얼통신 반도체 ASIC 및 하드웨어 개발자가 쓴 상세 표준 내용과 현장 실무 노하우를 담은 시리얼통신 핸드북비동기 시리얼통신 RS-232, RS-422, RS-485 통신방식과 종단저항, 아이솔레이션, 접지

www.yes24.com

 

 

import sys
import math
import random
import pygame
from pygame.locals import QUIT, KEYDOWN, K_LEFT, K_RIGHT, Rect

class Block:
    def __init__(self, col, rect, speed = 0):
        self.col = col
        self.rect = rect
        self.speed = speed
        self.dir = random.randint(-45, 45) + 270
    
    def move(self):
        self.rect.centerx += math.cos(math.radians(self.dir)) * self.speed
        self.rect.centery -= math.sin(math.radians(self.dir)) * self.speed
    
    def draw(self):
        if self.speed == 0:
            pygame.draw.rect(SURFACE, self.col, self.rect)
        else:
            pygame.draw.ellipse(SURFACE, self.col, self.rect)

def tick():
    global BLOCKS
    for event in pygame.event.get():
        if event.type == QUIT:
            pygame.quit()
            sys.exit()
        elif event.type == KEYDOWN:
            if event.key == K_LEFT:
                PADDLE.rect.centerx -= 10
            elif event.key == K_RIGHT:
                PADDLE.rect.centerx += 10
    if BALL.rect.centery < 1000:
        BALL.move()

    prev_len = len(BLOCKS)
    BLOCKS = [
        x for x in BLOCKS
        if not x.rect.colliderect(BALL.rect)
    ]
    if len(BLOCKS) != prev_len:
        BALL.dir *= -1
    
    if PADDLE.rect.colliderect(BALL.rect):
        BALL.dir = 90 + (PADDLE.rect.centerx - BALL.rect.centerx) / PADDLE.rect.width * 80
    
    if BALL.rect.centerx < 0 or BALL.rect.centerx > 600:
        BALL.dir = 180 - BALL.dir
    if BALL.rect.centery < 0:
        BALL.dir = -BALL.dir
        BALL.speed = 15



pygame.init()
pygame.key.set_repeat(5, 5)
SURFACE = pygame.display.set_mode((600, 800))
FPSCLOCK = pygame.time.Clock()
BLOCKS = []
PADDLE = Block((242, 242, 0), Rect(300, 700, 100, 30))
BALL = Block((242, 242, 0), Rect(300, 400, 20, 20), 10)

def main():
    myfont = pygame.font.SysFont(None, 80)
    msg_clear = myfont.render("Cleared!", True, (255, 255, 0))
    msg_over = myfont.render("Game over!", True, (255, 255, 0))
    fps = 30
    colors = [(255, 0, 0), (255, 165, 0), (242, 242, 0),
              (0, 128,0), (128, 0, 128), (0, 0, 255)]
    for y_pos, color in enumerate(colors, start = 0):
        for x_pos in  range(0, 5):
            BLOCKS.append(Block(color, Rect(x_pos * 100 + 60, y_pos * 50 + 40, 80, 30)))
    
    while True:
        tick()
        SURFACE.fill((0, 0, 0))
        BALL.draw()
        PADDLE.draw()
        for block in BLOCKS:
            block.draw()
        if len(BLOCKS) == 0:
            SURFACE.blit(msg_clear, (200, 400))
        if BALL.rect.centery > 800 and len(BLOCKS) > 0:
            SURFACE.blit(msg_over, (150, 400))
        
        pygame.display.update()
        FPSCLOCK.tick(fps)

if __name__ == "__main__":
    main()

 

 

 

 

import sys
import random
import pygame
from pygame.locals import QUIT, KEYDOWN, K_LEFT, K_RIGHT, K_UP, K_DOWN, Rect

pygame.init()
pygame.key.set_repeat(5, 5) # control how held keys are repeated
SURFACE = pygame.display.set_mode([600, 600])
FPSCLOCK = pygame.time.Clock()

class Snake:
    def __init__(self, pos):
        self.bodies = [pos]
    
    def move(self, key):
        x_pos, y_pos = self.bodies[0]

        if key == K_LEFT:
            x_pos -= 1
        elif key == K_RIGHT:
            x_pos += 1
        elif key == K_UP:
            y_pos -= 1
        elif key == K_DOWN:
            y_pos += 1
        head = (x_pos, y_pos)

        is_game_over = head in self.bodies or \
            head[0] < 0 or head[0] >= W or \
            head[1] < 0 or head[1] >= H

        self.bodies.insert(0, head)
        if head in FOODS:
            i = FOODS.index(head)
            del FOODS[i]
            add_food(self)
        else:
            self.bodies.pop()
        return is_game_over
    
    def draw(self):
        for body in self.bodies:
            pygame.draw.rect(SURFACE, (0, 255, 255),
                             Rect(body[0] * 30, body[1] * 30, 30, 30))

FOODS = []
(W, H) = (20, 20)

def add_food(snake):
    while True:
        pos = (random.randint(0, W-1), random.randint(0, H - 1))
        if pos in FOODS or pos in snake.bodies:
            continue
        FOODS.append(pos)
        break

def paint(snake, msg):
    SURFACE.fill((0, 0, 0))
    snake.draw()

    for food in FOODS:
        pygame.draw.ellipse(SURFACE, (0, 255, 0),
                            Rect(food[0] * 30, food[1] * 30, 30, 30))
    for index in range(20):
        pygame.draw.line(SURFACE, (64, 64, 64),
                         (index*30, 0), (index*30, 600))
        pygame.draw.line(SURFACE, (64, 64, 64),
                         (0, index*30), (600, index* 30))
    
    if msg != None:
        SURFACE.blit(msg, (150, 300))
    pygame.display.update()

def main():
    myfont = pygame.font.SysFont(None, 80)
    key = K_DOWN
    msg = None
    game_over = False
    snake = Snake((int(W/2), int(H/2)))
    for _ in range(10):
        add_food(snake)
    
    while True:
        for event in pygame.event.get():
            if event.type == QUIT:
                pygame.quit()
                sys.exit()
            elif event.type == KEYDOWN:
                key = event.key
        
        if game_over:
            msg = myfont.render("Game Over!", True, (255, 255, 0))
        else:
            game_over = snake.move(key)
        
        paint(snake, msg)
        FPSCLOCK.tick(10)

if __name__ == "__main__":
    main()

 

+ Recent posts