def step_function(x):
    y = x > 0
    return y.astype(np.int32)

 

import matplotlib.pyplot as plt
import numpy as np

x = np.arange(-5.0, 5.0, 0.1)
y = step_function(x)
plt.plot(x, y)
plt.ylim(-0.1, 1.1)
plt.show()

 

 

 

def sigmoid(x):
    return 1 / (1+np.exp(-x))

 

x = np.arange(-5.0, 5.0, 0.1)
y = sigmoid(x)
plt.plot(x, y)
plt.ylim(-0.1, 1.1)
plt.show()

def relu(x):
    return np.maximum(0, x)

 

 

 

X = np.array([1, 0.5])
W1 = np.array([
    [0.1, 0.3, 0.5],
    [0.2, 0.4, 0.6]
])
B1 = np.array([0.1, 0.2, 0.3])

print(W1.shape)
print(X.shape)
print(B1.shape)

A1 = np.dot(X, W1) + B1
print(A1.shape)

 

Z1 = sigmoid(A1)
print(A1)
print(Z1)

 

 

def identity_function(x):
    return x

def init_network():
    network = {}
    network['W1'] = np.array([
        [0.1, 0.3, 0.5],
        [0.2, 0.4, 0.6]
    ])
    network['b1'] = np.array([0.1, 0.2, 0.3])
    network['W2'] = np.array([
        [0.1, 0.4], [0.2, 0.5], [0.3, 0.6]
    ])
    network['b2'] = np.array([0.1, 0.2])
    network['W3'] = np.array([
        [0.1, 0.3], [0.2, 0.4]
    ])
    network['b3'] = np.array([0.1, 0.2])
    return network

def forward(network, x):
    W1, W2, W3 = network['W1'], network['W2'], network['W3']
    b1, b2, b3 = network['b1'], network['b2'], network['b3']
    
    a1 = np.dot(x, W1) + b1
    z1 = sigmoid(a1)
    a2 = np.dot(z1,W2) + b2
    z2 = sigmoid(a2)
    a3 = np.dot(z2,W3) + b3
    y = identity_function(a3)
    return y

network = init_network()
x = np.array([1.0, 0.5])
y = forward(network, x)
print(y)

 

 

def softmax(a):
    C = np.max(a)
    exp_a = np.exp( a - C)
    sum_exp_a = np.sum(exp_a)
    y = exp_a / sum_exp_a
    return y

 

'딥러닝' 카테고리의 다른 글

밑딥1 - 1. 단순게이트  (0) 2024.06.17
def AND(x1, x2):
    w1, w2, theta = 0.5, 0.5, 0.7
    tmp = x1*w1 + x2*w2
    if tmp <= theta:
        return 0
    elif tmp > theta:
        return 1

print(AND(0,0))
print(AND(1,0))
print(AND(0,1))
print(AND(1,1))

 

 

import numpy as np
x = np.array([0, 1])
w = np.array([0.5, 0.5])
b = -0.8
print(w*x)
print(np.sum(w*x))
print(np.sum(w*x)+b)

 

 

def NAND(x1, x2):
    x = np.array([x1, x2])
    w = np.array([-0.5, -0.5])
    b = 0.7
    tmp = np.sum(w*x) + b
    if tmp <= 0:
        return 0
    else:
        return 1

def OR(x1, x2):
    x = np.array([x1, x2])
    w = np.array([0.5, 0.5])
    b = -0.2
    tmp = np.sum(w*x) + b
    if tmp <= 0:
        return 0
    else:
        return 1

 

 

def XOR(x1, x2):
    s1 = NAND(x1, x2)
    s2 = OR(x1, x2)
    y = AND(s1, s2)
    return y

print(XOR(0,0))
print(XOR(1,0))
print(XOR(0,1))
print(XOR(1,1))

 

'딥러닝' 카테고리의 다른 글

밑딥1 - 2.신경망  (0) 2024.06.17

오랜만에 본 책인 그림으로배우는 http & network

 

이거 보기전에 다른것도 짧게 몇개 보긴했지만

책 리뷰글 쓰기 귀찬아서 게으름피우다가

간만에 쓴다.

 

그래봣자 리뷰 글이라고 할만큼 

책을 열심히 본것도 아니고 중간에 대충 넘어간 부분이 대부분이라 쓸내용이 없긴한데

 

일단 책 제목에 베이직이라는 단어가 있지만

생각보다 깊이 있는 내용들을 그림으로 가능한 쉽게 표현하려고 노력한 책으로 보이는데

 

HTTP 프로토콜에 대한 왠만한 대부분 내용들이 들어가 있다.

 

물론 지금은 HTTP만 쓰는게 아니라 보안을 위한 HTTPS 프로토콜에 대한 내용도

보안쪽을 내가 잘아는건아니지만 빈틈없이 포함되어 있다.

 

내가 이 책을 보기전에 생각한건

간단하게 그림으로 배우는 서버, 웹서버 통신 책 같이 얕고 넓은 내용인줄 알았는데

 

생각보다 깊이있는 내용들을 그림으로 표현해서 알려주려고한게 

이 책의 특징이 아닌가 싶다.

 

오라일리에서 나온 HTTP 책 두꺼운거?에 비하면

정말 친절한 책이라 생각된다.

 

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

 

그림으로 배우는 HTTP & Network - 예스24

이 책은 웹의 근간을 이루는 HTTP를 중심으로 하여 웹, 인터넷 데이터 통신 분야의 기초가 되는 내용들을 다루고 있다. 관련 분야를 배우고자 하는 독자들을 위해 만화 캐릭터와 일러스트를 활용

www.yes24.com

 

오랜만에 쓰는 책 리뷰글이다.

 

이번에 본 책은 효율적 개발로 이끄는 파이썬 실천 기술

 

 

 

평소 개발 서적을 보면서 초급서는 엄청많은데에 비해 

읽기 좋은 중급서가 너무 없다 생각이 들때가 많았는데

 

이 책은 파이썬 기초 문법에서 패키징, 병렬처리 등 중급 내용까지 아우른다.

 

진지한 파이썬같이 다른 파이썬 중급서보다

가장 간단한 예시로 읽기 좋았던건 이책인듯하다.

 

이 책을 통해

그동안 이해가 잘 안되던 파이썬 패키지 __init__.py나

sdist, venv 구조가 조금은 감이 잡히더라

 

 

 

중고급서에 병렬처리니 단위테스트니 하는 내용들은 많은데

쓸일이 없으니 눈에 잘안들어오는데

그래도 오픈소스 쓰면서 자주 마주치는 위 내용들은 좀 이해하는데 도움되었음.

 

 

 

 

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

 

효율적 개발로 이끄는 파이썬 실천 기술 - 예스24

프로그래밍에 대한 지식은 어느 정도 있지만,파이썬은 잘 모르는 분들을 위한 실천적 입문서!『효율적 개발로 이끄는 파이썬 실천 기술』은 이런 분들을 위한 읽기 쉬우면서도 얕지 않은 입문

www.yes24.com

 

 

 

 

 

신호

- 시간 흐름에 따라 변화하는 정보를 가진 질량

- 시간의 연속 유무에 따른 분류 : 연속시간 신호(아날로그), 이산시간 신호(디지털)

 

시스템

- 신호를 변형,저장 등 가공하는 과정

 

시스템 예시

1. 잡음 제거 시스템

2. 흐려짐 제거 시스템

 

 

신호의 예시

음성신호

영상신호

 

 

신호의 변환

- AD 변환 : 아날로그 신호 -> 디지털 신호

- DA 변환 : 디지털 신호 -> 아날로그 신호

 

 

원랜 오늘 사칙연산까지만 하려했는데

잠깐 시간도 남아서 논리연산 조금 해보려고한다.

 

시프트연산

- SHR para1, para2

 para1 : 작업 장소

 para2 : 오른쪽(왼쪽)로 이동할 비트수 주로 4배수

- SHL para1, para2

%include "io64.inc"

section .text
global main
main:
    ;write your code here
    mov ax,0x1234
    
    PRINT_HEX 2,ax
    NEWLINE
    
    shl ax,4
    
    PRINT_HEX 2,ax
    NEWLINE
    
    mov [a], word 0x1234
    PRINT_HEX 2,a
    NEWLINE
    
    shr word [a], 4
    PRINT_HEX 2,a
    NEWLINE
    
    xor rax, rax
    ret

section .bss
    a resw 1

 

 

 

 

AND, OR, XOR, NOT 연산

- AND, OR, XOR para1, para2(para1 = para1연산para2)

- NOT para(para = not para)

%include "io64.inc"

section .text
global main
main:
    ;write your code here
    mov al, 0b10110110
    mov bl, 0b01010101
    PRINT_HEX 1,al
    NEWLINE
    PRINT_HEX 1,bl
    NEWLINE
    
    and al, bl
    PRINT_HEX 1,al
    NEWLINE
    
    mov al, 0b10110110
    mov bl, 0b01010101
    or al,bl
    PRINT_HEX 1,al
    NEWLINE
    
    mov al, 0b10110110
    mov bl, 0b01010101
    xor al,bl
    PRINT_HEX 1,al
    NEWLINE
    
    mov al, 0b10110110
    not al
    PRINT_HEX 1,al
    NEWLINE
    
    xor rax, rax
    ret

 

 

문자열 출력하기

- PRINT_STRING : SASM에서 제공하는 문자열 출력 매크로 함수

- ssection .data에 바이트 연속으로 선언

PRINT_STRING param(출력할곳 주소)

* 문자열 종료시 0x00으로 표기

* NASM에선 ''나 ""둘다 문자열로 허용

%include "io64.inc"

section .text
global main
main:
    ;write your code here
    PRINT_STRING msg1
    NEWLINE
    PRINT_STRING msg2
    NEWLINE
    PRINT_STRING msg3
    
    xor rax, rax
    ret
    
section .data
    msg1 db 'haha ',0x00
    msg2 db 'hellow !',0x00
    msg3 db "mnsg3 ok",0x00

 

 

입력받기

- SASM에서는 아래 두함수로 받을수 있음

- GET_DEC para1, para2 입력된 문자열 10진수로 인식

 para1 입력할 바이트 수 para2 입력받을 곳 레지스터나 메모리주소

- GET_HEX para1, para2 입력된 문자열 16진수로 인식

 para1 입력할 바이트 수 para2 입력받을 곳 레지스터나 메모리주소

%include "io64.inc"

section .text
global main
main:
    ;write your code here
    GET_DEC 1,al    ;1바이트 입력
    GET_DEC 2,a     ;2바이트 입력
    
    PRINT_DEC 1,al
    NEWLINE
    PRINT_DEC 2,a
    xor rax, rax
    ret
    
section .bss
    a resw 1    ;2바이트 초기화되지않은 변수 a1개 선언

 

 

 

 

 

덧셈연산

- ADD para1, para2(para1 = para 1 + para2)

 para 1 : 레지스터나 메모리에있는값

 para2 : 레지스터, 메모리, 값

 *para1,2둘다 메모리인 경우는 안됨

 

%include "io64.inc"

section .text
global main
main:
    ;write your code here
    mov ax,1    ;2바이트 레지스터에 1대입
    mov bx,3    ;2바이트레지스터 bx에 3대입
    
    add ax, bx
    PRINT_DEC 2,ax
    NEWLINE
    
    mov [a], word 7 ;2바이트 변수 a에 7대입
    add ax, [a]
    PRINT_DEC 2,ax
    NEWLINE
    
    mov bx, 2
    add [a], bx
    PRINT_DEC 2,a
    NEWLINE
    
    mov [b], byte 2
    ;add [a], [b] <= error!

    xor rax, rax
    ret
    
section .bss
    a resw 1
    b resw 1

 

 

 

뺄셈연산

- SUB para1, para2(para1 = para1 - para2)

 para1 : 레지스터 나 메모리 값

 para2 : 레지스터, 메모리, 값

%include "io64.inc"

section .text
global main
main:
    ;write your code here
    mov ax,1
    mov bx,3
    
    sub ax, bx
    PRINT_DEC 2, ax
    NEWLINE
    
    mov [a], word 7
    sub ax, [a]
    PRINT_DEC 2,ax
    NEWLINE
    
    mov bx,2
    sub [a],bx
    PRINT_DEC 2,a
    NEWLINE
    
    mov [b], byte 2
    PRINT_DEC 2,b
    ;sub [a], [b] <= 에러
    
    xor rax, rax
    ret
    
section .bss
    a resw 1
    b resw 1

 

 

 

1바이트 곱샘연산

- MUL para(1바이트)

* para가 1바이트일때 AX = AL * para

* para는 레지스터만 허용

*곱되는값은 무조건 AL레지스터에

*결과는 AX레지스터에 반환

 

아래 코드에서 ax레지스터를 0으로 초기화안하면 ah 레지스터값에 따라 영향받기 때문

%include "io64.inc"

section .text
global main
main:
    ;write your code here
    PRINT_DEC 2,ax
    NEWLINE
    
    ;2*3
    mov ax,0
    mov al, 2
    mov bl, 3
    mul bx
    
    PRINT_DEC 1,ax
    NEWLINE

    xor rax, rax
    ret

 

 

 

1바이트 나누기 연산

- DIV para(1바이트)

* para가 1바이트일때 : AX / para : AL(몫), AH(나머지)

* 나눠지는값은 AX에

* 연산결과는 AL, AH로 리턴됨

%include "io64.inc"

section .text
global main
main:
    ;write your code here
    ; 7(AX) / 2 = 3(AL, 몫), 1(AH, 나머지)
    
    mov ax, 7
    mov bl, 2
    div bl
    
    mov bl, ah
    
    PRINT_DEC 1,al
    NEWLINE
    PRINT_DEC 1,bl
    NEWLINE

    xor rax, rax
    ret

 

 

 

실행파일만들고 콘솔에서 실행해보기

코드작성 -> file에서 .exe 로 저장하기 -> 콘솔로 실행

%include "io64.inc"

section .text
global main
main:
    ;write your code here
    PRINT_STRING msg1
    NEWLINE
    
    mov ax,3
    
    PRINT_DEC 2,ax
    NEWLINE

    xor rax, rax
    ret

section .data
    msg1 db "hello",0x00

 

 

 

 

 

사칙연산 계산기 만들기

- 2개의 변수를 1바이트 단위로 받아 메모리에 저장

- 사칙연산 한 값을 1바이트 단위 메모리에 각각 저장

- 나누기 결과는 몫과 나머지를 나누어 저장

- 곱의 경우 결과를 2바이트 변수로 선언하고 사용

- 이후 결과 모두 출력

%include "io64.inc"

section .text
global main
main:
    ;write your code here
    ;input
    PRINT_STRING msg1
    GET_DEC 1,mya
    PRINT_DEC 1,mya
    NEWLINE
    
    PRINT_STRING msg1
    GET_DEC 1,myb
    PRINT_DEC 1,myb
    NEWLINE
    
    
    ;calc
    ;+
    mov al, [mya]
    mov bl, [myb]
    add al, bl
    mov [a], al
    
    ;-
    mov al, [mya]
    mov bl, [myb]
    sub al, bl
    mov [b], al
    
    ;*
    mov al, [mya]
    mov bl, [myb]
    mul bl
    mov [c], ax
    
    ;/
    mov ax,0
    mov al,[mya]
    mov bl,[myb]
    div bl;
    mov [d],al
    mov [e],ah
    
    
    
    
    ;output
    PRINT_STRING msg2
    PRINT_DEC 1,a
    NEWLINE
    
    PRINT_STRING msg3
    PRINT_DEC 1,b
    NEWLINE
    
    PRINT_STRING msg4
    PRINT_DEC 2,c
    NEWLINE
    
    PRINT_STRING msg5
    PRINT_DEC 1,d
    NEWLINE
    
    PRINT_STRING msg6
    PRINT_DEC 1,e
    NEWLINE
    

    xor rax, rax
    ret

section .data
    msg1 db 'input data:',0x00
    msg2 db '+:',0x00
    msg3 db '-:',0x00
    msg4 db '*:',0x00
    msg5 db '/(q):',0x00
    msg6 db '/(r):',0x00

section .bss
    mya resb 1; input 1
    myb resb 1; input 2
    a resb 1 ; +
    b resb 1 ; -
    c resw 1 ; *
    d resb 1 ; /(몫)
    e resb 1 ; /(나머지)

 

콘솔로 돌리기

 

 

워드

- CPU에서 처리하는 단위

- 16비트 CPU의 경우

- 16bit = 2byte = 1word

 

16진수 표기

- 10진수 10 = 16진수 0x0A

 

레지스터 크기

- 64bit OS는 64비트, 32bit os는 32비트 크기 레지스터 사용

- RAX :  64bit

- EAX : 32bit

- AX : 16bit

- AH, AL : 8bit

 

 

SASM 어셈블리 구조

- %include "io64.inc" : OS에 무관한 입출력 매크로 함수 지원

- section .text

  * section : 데이터나 명령을 모은 블록

- global main : 프로그램 시작점

 

 

 

레지스터 데이터 입력하기

- 주로 ABCD 레지스터 사용 (eax, ax, bx)

%include "io64.inc"

section .text
global main
main:
    ;write your code here
    mov eax, 0x1234 ;A레지스터 32bit 크기에 0x1234저장
    mov ax, 0x1234  ;A레지스터 16bit 크기에 0x1234 저장
    mov ax, bx      ;bx의 값을 ax로 복사
    mov ax,ebx      ;[에러발생] ebx(32bit)값을 ax(16bit)에 저장시
    xor rax, rax도
    ret

 

 

 

 

 

어셈블리 메모리

- 메모리 사용 필요한것 : 메모리 크기, 메모리 위치

- 개발자는 메모리 크기 결정은 가능하나 주소는 모르므로 심벌(변수)로 설정하여 사용함.

아래의 경우

변수 명 : a

크기 : 2바이트

시작 주소 : 1

저장 값 : 0x1234

 

 

리틀엔디언 빅엔디언

- 메모리에 값(바이트) 저장하는 순서

- 위에서 0x1234가 1에 0x34, 2에 0x12가 들어가는것은 리틀엔디언방식

https://ko.wikipedia.org/wiki/%EC%97%94%EB%94%94%EC%96%B8

 

 

어셈블리 변수선언 (초기화 x)

- 초기화 하지 않은 변수는 .bss 블록에 언해야함

section .bss

    변수명    크기지시자    개수

 

크기지시자

resb 1바이트  byte?

resw 2바이트 word?

resd 4바이트 double word?

resq  8바이트 qaurd word?

 

 

 

어셈블리 변수선언 (초기화 o)

- 초기값이 있는 경우 section .data 블록에서 선언함

변수명    크기지시자    초기값

 

크기지시자

db 1바이트 바이트

dw 2바이트 워드

dd 4바이트 더블워드?

dq 8바이트 쿼드워드?

 

 

 

메모리 이용하기, 

- mov : 메모리에 데이터 보내기

 ex) 변수 a에 저장된 값을 ax 레지스터로 가져오라

  -> mov ax, [a]

변수명 = 주소, [변수명] = 주소에 있는값

* []는 c언어의 포인터 느낌으로 생각하면 될듯 []가 없는 변수는 주소 []가 있는 변수는 가리키는 곳

 

(주의) 어셈블리에서 변수 선언시 크기 지정해줘도 데이터는 크기를 명시해야함.

 

10번라인에서 데이터 크기 명시하지 않아 빌드 에러
바이트 명시시 빌드 성공

 

 

레지스터와 메모리 값 출력하기

- 레지스터, 메모리에 있는 값을 CPU 어셈블리만으로 출력은 힘듬. OS에 포함되어있기 때문.

- 운영체제와 무관하게 SASM에서 제공해주는 매크로 함수 사용하여 출력해보기

PRINT_HEX 바이트수, 레지스터혹은변수명 : 레지스터혹은변수명을 16진수로 출력

PRINT_DEC 바이트수, 레지스터혹은변수명 : 레지스터혹은변수명을 10진수로 출력

NEWLINE : 화면에 줄변경

 

* 0x12는 10진수로 16 + 2 = 18이 되므로 PRINT_DEC 2, ax(0x12)는 18이 맞음

 

 

데이터 옮기기 예제

1. 초기값 있는 메모리 변수 4개 선언 크기는 1,2,4,8바이트로 값은 16진수로 초기화

2. 초기값없는 메모리 변수 1, 2,4,8바이트 1개씩 선언하고 앞에서 선언한 값을 아래 선언한 변수로 이동

3. 변수 8개 모두 16진수로 출력

%include "io64.inc"

section .text
global main
main:
    ;write your code here
    mov al,[a]      ;1바이트 크기 변수 a를 1바이트 레지스터 al에 저장
    mov [mya],al    ;1바이트 레지스터 al값을 mya에 저장
    
    mov ax,[b]      ;2바이트 크기 변수 b를 2바이트 레지스터 ax에 저장
    mov [myb],ax    ;2바이트 레지스터 ax값을 myb에 저장
    
    mov eax,[c]     ;4바이트 크기 변수 c를 4바이트 레지스터 eax에 저장
    mov [myc],eax
    
    mov rax,[d]
    mov [myd],rax
    
    
    PRINT_HEX 1,a   ;1바이트 단위로 변수 a값 16진수로 출력
    NEWLINE
    
    PRINT_HEX 2,b   ;2바이트 단위로 변수 b값 16진수로 출력
    NEWLINE
    
    PRINT_HEX 4,c   ;4바이트 단위로 변수 c값 16진수로 출력
    NEWLINE
    
    PRINT_HEX 8,d   ;8바이트 단위로 변수 d값 16진수로 출력
    NEWLINE
    
    PRINT_HEX 1,mya
    NEWLINE
    
    PRINT_HEX 2,myb
    NEWLINE
    
    PRINT_HEX 4,myc
    NEWLINE
    
    PRINT_HEX 8,myd
    
    xor rax, rax
    ret

section .data
    a db 0x12                   ;1바이트 변수 0x12
    b dw 0x1234                 ;2바이트 변수 0x1234
    c dd 0x12345678             ;4바이트 변수 c
    d dq 0x1234567812345678     ;8바이트 변수 d
  
section .bss
    mya resb 1  ;1바이트 초기화안된변수 선언
    myb resw 1  ;2바이트 초기화안된변수 myb선언
    myc resd 1  ;4바이트 초기화안된변수 myc선언
    myd resq 1  ;8바이트 초기화안된변수 myq선

 

주로 쓰는 어셈블러

- 윈도우 : MASM

- 리눅스/유닉스 : GAS

- 둘다 가능 : NSAM

 

 

사용할 어셈블러 ide

https://dman95.github.io/SASM/english.html

 

SASM - Simple crossplatform IDE for NASM, MASM, GAS, FASM assembly languages

SASM SASM (SimpleASM) - simple Open Source crossplatform IDE for NASM, MASM, GAS, FASM assembly languages. SASM has syntax highlighting and debugger. The program works out of the box and is great for beginners to learn assembly language. SASM is translated

dman95.github.io

 

 

 

 

 

보다보니

맨위에 

include io64.inc를 안해준게 문제더라

%include "io64.inc"

section .text
global main
main:
    ;write your code here
    mov eax,10
    PRINT_DEC 1, eax
    
    xor eax, eax
    ret

'컴퓨터과학 > os' 카테고리의 다른 글

어셈블리 - 3. 사칙연산  (0) 2024.04.14
어셈블리 - 2. 기초 개념들  (0) 2024.04.14
OS30 - 7. 글자쓰기  (0) 2024.04.08
OS30 - 6. c언어 사용, 화면 만들기  (0) 2024.04.05
OS30 - 5. ipl 만들기, c언어 진입  (0) 2024.04.05

먼저  어셈블리코드에서 부팅정보 가져오기

 

이전에 어샘해드.nas에 부트정보 표기했었는데 이걸 c에 가져와서 사용

 


void HariMain(void)
{
    char *vram;
    int xsize, ysize;
    short *binfo_scrnx, *binfo_scrny;
    int *binfo_vram;

    init_palette();
    binfo_scrnx = (short *)0x0ff4;
    binfo_scrny = (short *)0x0ff6;
    binfo_vram = (int *)0x0ff8;
    vram = (char *) *binfo_vram;
    xsize = *binfo_scrnx;
    ysize = *binfo_scrny;

 

 

구조체 사용해서 부트인포 정리

struct BOOTINFO {
    char cyls, leds, vmode, reserve;
    short scrnx, scrny;
    char *vram;
};

void HariMain(void)
{
    char *vram;
    int xsize, ysize;
    struct BOOTINFO *binfo;
 
 
    init_palette();
    binfo = (struct BOOTINFO *) 0x0ff0;
    xsize = (*binfo).scrnx;
    ysize = (*binfo).scrny;
    vram = (*binfo).vram;

 

 

화살표 연산자로 수정

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);
void init_screen(char *vram, int x, int y);

#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

struct BOOTINFO {
    char cyls, leds, vmode, reserve;
    short scrnx, scrny;
    char *vram;
};

void HariMain(void)
{
    struct BOOTINFO *binfo = (struct BOOTINFO *) 0x0ff0;
 
    init_palette();
    init_screen(binfo->vram, binfo->scrnx, binfo->scrny);

    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;
}

void init_screen(char *vram, int x, int y)
{
	boxfill8(vram, x, COL8_008484,  0,     0,      x -  1, y - 29);
	boxfill8(vram, x, COL8_C6C6C6,  0,     y - 28, x -  1, y - 28);
	boxfill8(vram, x, COL8_FFFFFF,  0,     y - 27, x -  1, y - 27);
	boxfill8(vram, x, COL8_C6C6C6,  0,     y - 26, x -  1, y -  1);

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

	boxfill8(vram, x, COL8_848484, x - 47, y - 24, x -  4, y - 24);
	boxfill8(vram, x, COL8_848484, x - 47, y - 23, x - 47, y -  4);
	boxfill8(vram, x, COL8_FFFFFF, x - 47, y -  3, x -  4, y -  3);
	boxfill8(vram, x, COL8_FFFFFF, x -  3, y - 24, x -  3, y -  3);
    return;
}

 

 

 

글자 쓰기

putchar8로 폰트데이터 드로잉 구현

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);
void init_screen(char *vram, int x, int y);
void putfont8(char *vram, int xsize, int x, int y, char c, char *font);

#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

struct BOOTINFO {
    char cyls, leds, vmode, reserve;
    short scrnx, scrny;
    char *vram;
};

void HariMain(void)
{
    struct BOOTINFO *binfo = (struct BOOTINFO *) 0x0ff0;
    static char font_A[16] = {
        0x00, 0x18, 0x18, 0x18, 0x18, 0x24, 0x24, 0x24,
        0x24, 0x7e, 0x42, 0x42, 0x42, 0xe7, 0x00, 0x00
    };

    init_palette();
    init_screen(binfo->vram, binfo->scrnx, binfo->scrny);
    putfont8(binfo->vram, binfo->scrnx, 10, 10, COL8_FFFFFF, font_A);

    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;
}

void init_screen(char *vram, int x, int y)
{
	boxfill8(vram, x, COL8_008484,  0,     0,      x -  1, y - 29);
	boxfill8(vram, x, COL8_C6C6C6,  0,     y - 28, x -  1, y - 28);
	boxfill8(vram, x, COL8_FFFFFF,  0,     y - 27, x -  1, y - 27);
	boxfill8(vram, x, COL8_C6C6C6,  0,     y - 26, x -  1, y -  1);

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

	boxfill8(vram, x, COL8_848484, x - 47, y - 24, x -  4, y - 24);
	boxfill8(vram, x, COL8_848484, x - 47, y - 23, x - 47, y -  4);
	boxfill8(vram, x, COL8_FFFFFF, x - 47, y -  3, x -  4, y -  3);
	boxfill8(vram, x, COL8_FFFFFF, x -  3, y - 24, x -  3, y -  3);
    return;
}

void putfont8(char *vram, int xsize, int x, int y, char c, char *font)
{
    int i;
    char *p, d;
    for (i = 0; i < 16; i++)
    {
        p = vram + (y + i) * xsize + x;
        d = font[i];
        if ((d&0x80) != 0) {p[0]=c;}
        if ((d&0x40) != 0) {p[1]=c;}
        if ((d&0x20) != 0) {p[2]=c;}
        if ((d&0x10) != 0) {p[3]=c;}
        if ((d&0x08) != 0) {p[4]=c;}
        if ((d&0x04) != 0) {p[5]=c;}
        if ((d&0x02) != 0) {p[6]=c;}
        if ((d&0x01) != 0) {p[7]=c;}
    }

}

 

 

 

 

폰트 데이터 가져와 사용하기

위 예제에선 폰트 A 데이터를 직접 그려서 썻으나

아래 택스트 파일을 바이너리 이미지로 만들어 bootpack.obj와 합쳐서 사용함.

hankaku.txt
0.04MB

 

 

 

void HariMain(void)
{
    struct BOOTINFO *binfo = (struct BOOTINFO *) 0x0ff0;
    extern char hankaku[4096];

    init_palette();
    init_screen(binfo->vram, binfo->scrnx, binfo->scrny);
    putfont8(binfo->vram, binfo->scrnx, 8, 8, COL8_FFFFFF, hankaku + 'A' * 16);
    putfont8(binfo->vram, binfo->scrnx, 16, 8, COL8_FFFFFF, hankaku + 'B' * 16);
    putfont8(binfo->vram, binfo->scrnx, 24, 8, COL8_FFFFFF, hankaku + 'C' * 16);
    putfont8(binfo->vram, binfo->scrnx, 40, 8, COL8_FFFFFF, hankaku + '1' * 16);
    putfont8(binfo->vram, binfo->scrnx, 48, 8, COL8_FFFFFF, hankaku + '2' * 16);
    putfont8(binfo->vram, binfo->scrnx, 56, 8, COL8_FFFFFF, hankaku + '3' * 16);
    

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

 

 

 

 

+ Recent posts