printf("ho_tari\n");

19일차

호타리 — Wed, 30 Jul 2025 09:43:40 +0900

2025.07.29

디바이스 드라이버 개발 환경 구축

https://www.notion.so/rotary_encoder-23f27600c1fd80f68259ec875849c89d?source=copy_link

디바이스 드라이버 rotary_encoder 작성

Makefile

obj-m += rotary_encoder.o

KDIR := /lib/modules/$(shell uname -r)/build
PWD  := $(shell pwd)

all:
	$(MAKE) -C $(KDIR) M=$(PWD) modules

clean:
	$(MAKE) -C $(KDIR) M=$(PWD) clean

rotary_encoder.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#include <linux/device.h>
#include <linux/timer.h> // 커널 타이머 헤더 추가

// --- 장치 이름 및 주 번호 설정 ---
#define DEVICE_NAME "rotary_dev"

// --- GPIO 핀 설정 (BCM GPIO 번호 기준) ---
#define LED0_GPIO   538
#define LED1_GPIO   531
#define LED2_GPIO   525
#define LED3_GPIO   518
#define LED5_GPIO   533
#define LED6_GPIO   532
#define LED7_GPIO   528

#define ROTARY_CLK_GPIO 529
#define ROTARY_DT_GPIO  539
#define KEY_SWITCH_GPIO 534

#define DEBOUNCE_TIME_MS 50 // 디바운싱 시간 (50ms)

// --- 전역 변수 ---
static int rotary_count = 0;
static int led5_state = 0;
static dev_t dev_num;
static struct cdev rotary_cdev;
static struct class *rotary_class;
static struct device *rotary_device;

// 인터럽트 관련
static int rotary_irq_clk;
static int key_switch_irq;
static int last_rotary_clk_state;
static unsigned long last_rotary_irq_time = 0;

// 디바운싱을 위한 커널 타이머
static struct timer_list debounce_timer;

// ... (이전 코드의 함수 선언, 파일 연산 구조체, LED 업데이트 함수 등은 동일) ...
static int rotary_open(struct inode *, struct file *);
static int rotary_release(struct inode *, struct file *);
static ssize_t rotary_read(struct file *, char __user *, size_t, loff_t *);
static ssize_t rotary_write(struct file *, const char __user *, size_t, loff_t *);
static long rotary_ioctl(struct file *, unsigned int, unsigned long);

static const struct file_operations rotary_fops = {
    .owner   = THIS_MODULE,
    .open    = rotary_open,
    .release = rotary_release,
    .read    = rotary_read,
    .write   = rotary_write,
    .unlocked_ioctl = rotary_ioctl,
};

static void update_led_display(int value) {
    value = value % 16;
    if (value < 0) value += 16;
    gpio_set_value(LED0_GPIO, (value & 0x01) ? 1 : 0);
    gpio_set_value(LED1_GPIO, (value & 0x02) ? 1 : 0);
    gpio_set_value(LED2_GPIO, (value & 0x04) ? 1 : 0);
    gpio_set_value(LED3_GPIO, (value & 0x08) ? 1 : 0);
}


// --- Rotary Encoder 인터럽트 핸들러 (이전과 동일) ---
static irqreturn_t rotary_encoder_isr(int irq, void *dev_id) {
    unsigned long current_time = jiffies;
    if (time_after(current_time, last_rotary_irq_time + msecs_to_jiffies(2))) {
        int current_clk_state = gpio_get_value(ROTARY_CLK_GPIO);
        if (current_clk_state != last_rotary_clk_state) {
            int dt_state = gpio_get_value(ROTARY_DT_GPIO);
            if (current_clk_state == 0) {
                if (dt_state == 1) { rotary_count++; gpio_set_value(LED7_GPIO, 1); gpio_set_value(LED6_GPIO, 0); }
                else { rotary_count--; gpio_set_value(LED7_GPIO, 0); gpio_set_value(LED6_GPIO, 1); }
                update_led_display(rotary_count);
            }
        }
        last_rotary_clk_state = current_clk_state;
        last_rotary_irq_time = current_time;
    }
    return IRQ_HANDLED;
}

// --- 디바운싱 타이머 콜백 함수 (NEW) ---
static void debounce_timer_callback(struct timer_list *t) {
    // 타이머가 만료된 시점의 버튼 상태를 다시 확인
    int current_state = gpio_get_value(KEY_SWITCH_GPIO);

    // 여전히 눌려있다면(LOW), 유효한 누름으로 간주하고 토글 실행
    if (current_state == 0) {
        led5_state = !led5_state;
        gpio_set_value(LED5_GPIO, led5_state);
        printk(KERN_INFO "Key Switch: Valid press detected, LED5 toggled to %s\n", led5_state ? "ON" : "OFF");
    }

    // 다음 입력을 받을 수 있도록 인터럽트를 다시 활성화
    enable_irq(key_switch_irq);
}

// --- Key Switch 인터럽트 핸들러 (MODIFIED) ---
static irqreturn_t key_switch_isr(int irq, void *dev_id) {
    // 인터럽트가 발생하면, 추가적인 바운싱을 막기 위해 인터럽트를 즉시 비활성화
    disable_irq_nosync(key_switch_irq);

    // 디바운싱 타이머를 현재로부터 DEBOUNCE_TIME_MS 이후로 설정
    mod_timer(&debounce_timer, jiffies + msecs_to_jiffies(DEBOUNCE_TIME_MS));

    return IRQ_HANDLED;
}


// ... (장치 파일 연산 함수들은 이전과 동일) ...
static int rotary_open(struct inode *inode, struct file *file) { return 0; }
static int rotary_release(struct inode *inode, struct file *file) { return 0; }
static ssize_t rotary_read(struct file *file, char __user *buf, size_t count, loff_t *pos) {
    int len; char kbuf[20];
    if (*pos > 0) return 0;
    len = scnprintf(kbuf, sizeof(kbuf), "%d\n", rotary_count);
    if (copy_to_user(buf, kbuf, len)) return -EFAULT;
    *pos += len; return len;
}
static ssize_t rotary_write(struct file *file, const char __user *buf, size_t count, loff_t *pos) {
    long new_count; int ret; char kbuf[20];
    if (count >= sizeof(kbuf)) return -EINVAL;
    if (copy_from_user(kbuf, buf, count)) return -EFAULT;
    kbuf[count] = '\0';
    ret = kstrtol(kbuf, 10, &new_count);
    if (ret != 0) return ret;
    rotary_count = new_count; update_led_display(rotary_count);
    return count;
}
#define IOCTL_ROTARY_GET_COUNT _IOR('R', 1, int)
#define IOCTL_ROTARY_SET_COUNT _IOW('R', 2, int)
#define IOCTL_ROTARY_TOGGLE_LED5 _IO('R', 3)
#define IOCTL_ROTARY_GET_LED5_STATE _IOR('R', 4, int)
static long rotary_ioctl(struct file *file, unsigned int cmd, unsigned long arg) {
    int ret = 0; int val;
    switch (cmd) {
        case IOCTL_ROTARY_GET_COUNT:
            val = rotary_count; if (copy_to_user((int __user *)arg, &val, sizeof(val))) ret = -EFAULT; break;
        case IOCTL_ROTARY_SET_COUNT:
            if (copy_from_user(&val, (int __user *)arg, sizeof(val))) { ret = -EFAULT; }
            else { rotary_count = val; update_led_display(rotary_count); } break;
        case IOCTL_ROTARY_TOGGLE_LED5: led5_state = !led5_state; gpio_set_value(LED5_GPIO, led5_state); break;
        case IOCTL_ROTARY_GET_LED5_STATE:
            val = led5_state; if (copy_to_user((int __user *)arg, &val, sizeof(val))) ret = -EFAULT; break;
        default: ret = -ENOTTY; break;
    }
    return ret;
}

// --- 모듈 초기화 함수 (MODIFIED) ---
static int __init rotary_init(void) {
    // ... (이전의 장치 등록, GPIO 요청 부분은 동일) ...
    int ret = 0;
    static const struct gpio leds[] = {
        { LED0_GPIO, GPIOF_OUT_INIT_LOW, "led0" }, { LED1_GPIO, GPIOF_OUT_INIT_LOW, "led1" },
        { LED2_GPIO, GPIOF_OUT_INIT_LOW, "led2" }, { LED3_GPIO, GPIOF_OUT_INIT_LOW, "led3" },
        { LED5_GPIO, GPIOF_OUT_INIT_LOW, "led5" }, { LED6_GPIO, GPIOF_OUT_INIT_LOW, "led6" },
        { LED7_GPIO, GPIOF_OUT_INIT_LOW, "led7" },
    };
    static const struct gpio inputs[] = {
        { ROTARY_CLK_GPIO, GPIOF_IN, "r_clk" }, { ROTARY_DT_GPIO,  GPIOF_IN, "r_dt"  },
        { KEY_SWITCH_GPIO, GPIOF_IN, "r_sw"  },
    };
    int i;

    ret = alloc_chrdev_region(&dev_num, 0, 1, DEVICE_NAME);
    if (ret < 0) return ret;
    cdev_init(&rotary_cdev, &rotary_fops);
    ret = cdev_add(&rotary_cdev, dev_num, 1);
    if (ret < 0) goto unregister_chrdev;
    rotary_class = class_create(DEVICE_NAME);
    if (IS_ERR(rotary_class)) { ret = PTR_ERR(rotary_class); goto cdev_del; }
    rotary_device = device_create(rotary_class, NULL, dev_num, NULL, DEVICE_NAME);
    if (IS_ERR(rotary_device)) { ret = PTR_ERR(rotary_device); goto class_destroy; }

    for (i = 0; i < ARRAY_SIZE(leds); i++) {
        ret = gpio_request_one(leds[i].gpio, leds[i].flags, leds[i].label);
        if (ret) { for (i--; i >= 0; i--) gpio_free(leds[i].gpio); goto device_destroy; }
    }
    for (i = 0; i < ARRAY_SIZE(inputs); i++) {
        ret = gpio_request_one(inputs[i].gpio, inputs[i].flags, inputs[i].label);
        if (ret) { for (i--; i >= 0; i--) gpio_free(inputs[i].gpio); goto free_led_gpios; }
    }
    update_led_display(0); last_rotary_clk_state = gpio_get_value(ROTARY_CLK_GPIO);

    // 디바운싱 타이머 초기화 (NEW)
    timer_setup(&debounce_timer, debounce_timer_callback, 0);

    // 인터럽트 등록 (이전과 동일)
    rotary_irq_clk = gpio_to_irq(ROTARY_CLK_GPIO);
    ret = request_irq(rotary_irq_clk, rotary_encoder_isr, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "rotary_clk_irq", NULL);
    if (ret) goto free_input_gpios;

    key_switch_irq = gpio_to_irq(KEY_SWITCH_GPIO);
    ret = request_irq(key_switch_irq, key_switch_isr, IRQF_TRIGGER_FALLING, "key_switch_irq", NULL);
    if (ret) goto free_rotary_irq;

    printk(KERN_INFO "rotary_dev: Driver loaded with debounce timer. Major: %d\n", MAJOR(dev_num));
    return 0;

free_rotary_irq:
    free_irq(rotary_irq_clk, NULL);
free_input_gpios:
    for (i = 0; i < ARRAY_SIZE(inputs); i++) gpio_free(inputs[i].gpio);
free_led_gpios:
    for (i = 0; i < ARRAY_SIZE(leds); i++) gpio_free(leds[i].gpio);
device_destroy:
    device_destroy(rotary_class, dev_num);
class_destroy:
    class_destroy(rotary_class);
cdev_del:
    cdev_del(&rotary_cdev);
unregister_chrdev:
    unregister_chrdev_region(dev_num, 1);
    return ret;
}

// --- 모듈 종료 함수 (MODIFIED) ---
static void __exit rotary_exit(void) {
    int i;
    // 모듈이 제거될 때 타이머가 실행 중일 수 있으므로 안전하게 삭제
    del_timer_sync(&debounce_timer);

    free_irq(key_switch_irq, NULL);
    free_irq(rotary_irq_clk, NULL);

    static const struct gpio leds[] = { { LED0_GPIO }, { LED1_GPIO }, { LED2_GPIO }, { LED3_GPIO }, { LED5_GPIO }, { LED6_GPIO }, { LED7_GPIO }, };
    static const struct gpio inputs[] = { { ROTARY_CLK_GPIO }, { ROTARY_DT_GPIO }, { KEY_SWITCH_GPIO }, };
    for (i = 0; i < ARRAY_SIZE(inputs); i++) gpio_free(inputs[i].gpio);
    for (i = 0; i < ARRAY_SIZE(leds); i++) { gpio_set_value(leds[i].gpio, 0); gpio_free(leds[i].gpio); }

    device_destroy(rotary_class, dev_num);
    class_destroy(rotary_class);
    cdev_del(&rotary_cdev);
    unregister_chrdev_region(dev_num, 1);
    printk(KERN_INFO "rotary_dev: Driver unloaded.\n");
}

module_init(rotary_init);
module_exit(rotary_exit);
MODULE_LICENSE("GPL");

실행결과

https://youtube.com/shorts/GIZFrVPDJYc

github에 push하는 법

git add .

git commit -m "new"

git push origin main

혹시 push에서 pull을 해야하는 error가 발생한다면
git pull origin main --rebase

18일차

호타리 — Mon, 28 Jul 2025 17:00:49 +0900

2025.07.28

rotary sw 디지털 회로 설계

로터리 엔코더는 가전제품의 메뉴 선택이나 시간설정 등에 많이 사용되는 부품.

건조기나 냉장고에서도 많이 사용.

엔코더란 기계적인 위치의 변화나 방향·각도 등을 검출하여 전기적인 신호로 출력하는 센서.

엔코더의 명칭은 「encode= 코드화 한다」가 유래이며, 각도나 위치 변위의 코드화, 즉 펄스 신호로 부호화 하는것을 말한다.

엔코더 종류에는 회전의 각도나 방향을 검출하는 로터리 엔코더와 직선의 위치나 이동량을 검출하는 리니어 엔코더 등이 있다

회전할 때 정해진 패턴의 신호를 출력하기 때문에 이 신호를 바탕으로 회전부가 얼마나 회전했는지를 파악할 수 있다.

회전입력 하나로 다양한 입력을 받음으로써 부품의 수를 줄일 수 있기 때문에 로터리엔코더는 여러 제품의 입력장치로

광범위하게 활용되고 있음.

로터리 엔코더: 회전속도 회전량 및 회전 방향을 검출 하는 센서 장치

사용자가 스위치를 돌리면, 스위치 내부의 접점들이 회전하며 특정 패턴으로 연결되고, 이 패턴 변화를 통해 각도 변화를 감지

즉, 회전 방향과 각도 변화량을 펄스 형태로 출력하여 디지털 신호로 처리할 수 있게 함.

출력 펄스는 회전 위치의 절대치가 아닌 회전한 각도에 의해 비례하는 펄스 출력

2비트 상태 {A, B}의 이전 상태 → 현재 상태 변화에 따라 방향을 판단

동작 원리

(1) 회전 감지:

EC11 로터리 스위치는 회전축에 연결된 원판(디스크)에 규칙적인 패턴(구멍 또는 틈)이 있다

이 원판은 두 개의 광학 센서 또는 기계식 접점과 함께 작동

(2) 신호 생성:

회전축이 회전하면, 원판의 패턴이 광학 센서 또는 기계식 접점을 통과하면서 빛을 차단하거나 연결
이 차단/연결 변화가 디지털 펄스 신호로 변환

(3)펄스 신호 처리:

생성된 펄스 신호는 컨트롤러와 같은 장치에서 입력으로 받아 처리

• EC11은 증분형(Incremental) 로터리 엔코더의 한 종류.
일반적인 가변 저항처럼 특정 각도 범위가 있는 것이 아니라,
360도 계속 회전할 수 있으며 회전 방향과 회전량을 감지하여 디지털 펄스 신호로 출력.
또한, EC11 엔코더는 푸시 버튼 스위치가 내장되어 있어, 노브를 누르는 동작도 감지할 수 있다.

• 증분형 엔코더: 회전 변위를 일련의 디지털 펄스 신호로 변환.

절대적인 위치를 알려주는 것이 아니라, 얼마나 움직였고 어느 방향으로 움직였는지 알려줌.

전원이 꺼지면 마지막 위치 정보는 유지되지 않음.

• A상(s1)(Phase A) 및 B(s2)상(Phase B) 출력: EC11 엔코더는 두 개의 출력(A상, B상)을 가짐.

이 두 신호는 서로 약 ¼ 주기(90도)의 위상차를 가짐.

• 시계 방향(CW) 회전 시: A상이 B상보다 먼저 HIGH로 변함.

• 반시계 방향(CCW) 회전 시: B상이 A상보다 먼저 HIGH로 변함.

이 위상차를 분석하여 엔코더의 회전 방향을 감지할 수 있다.

• 펄스 수: EC11은 보통 20펄스/회전 또는 24펄스/회전. 이 펄스 수를 세어 회전량을 알 수 있다.

• 내장 푸시 버튼 (선택 사항): 많은 EC11 엔코더는 축을 누르면 작동하는 스위치가 내장되어 있다.

이는 메뉴 선택, 음소거 등의 기능을 구현하는 데 유용하다.

block diagram

rotary.v

`timescale 1ns / 1ps

module rotary(
    input clk,
    input reset,
    input clean_s1,
    input clean_s2,
    input clean_key,
    output [15:0] led
    );

    reg [1:0] r_prev_state = 2'b00;
    reg [1:0] r_curr_state = 2'b00;
    reg [1:0] r_direction = 2'b00;
    reg [7:0] r_count = 8'h00;

    reg [15:0] r_led = 16'b0;

    always @(posedge clk or posedge reset) begin
        if (reset) begin
            r_prev_state <= 2'b00;
            r_curr_state <= 2'b00;
            r_direction <= 2'b00;
            r_count <= 8'h00;
            r_led <= 16'b0;
        end else begin
            r_prev_state <= r_curr_state;
            r_curr_state <= {clean_s1, clean_s2};

            case ({r_prev_state, r_curr_state})

            4'b0010, 4'b1011, 4'b1101, 4'b0100: begin // CW 00 -> 10 -> 11 -> 01 -> 00
                if (r_count < 8'hFF) // overflow 방지
                    r_count <= r_count + 1;
                r_direction <= 2'b01;
            end

            4'b0001, 4'b0111, 4'b1110, 4'b1000: begin // CCW 00 -> 01 -> 11 -> 10 -> 00
                if (r_count > 8'h00) // underflow 방지
                    r_count <= r_count - 1;
                r_direction <= 2'b10;
            end

            endcase

            // clean_key ON/OFF 제어
            r_led[13] <= ~clean_key;

            // LED 출력 구성
            r_led[15:14] <= r_direction;
            r_led[12:8]  <= 5'b0;
            r_led[7:0]   <= r_count;

        end
    end

    assign led = r_led;

endmodule

top.v

`timescale 1ns / 1ps

module top(
    input clk,
    input reset,  // btnU
    input [2:0] btn,
    input [7:0] sw,
    input RsRx,
    input s1, // JC1
    input s2, // JC2
    input key, // JC3
    output RsTx,
    output [7:0] seg,
    output [3:0] an,
    output [15:0] led
    );

    wire [2:0] w_btn_debounce;
    wire [13:0] w_seg_data;
    wire w_tick;
    wire [7:0] w_rx_data;
    wire w_rx_done;

    // 디바운싱 된 입력
    wire w_clean_s1, w_clean_s2, w_clean_key;

    button_debounce u_button_debounce(
        .i_clk(clk),
        .i_reset(reset),
        .i_btn(btn[0]),
        .o_btn_clean(w_btn_debounce)
    );

    button_debounce #(.DEBOUNCE_LIMIT(200_000))u_s1_debounce( // debounce 2ms
        .i_clk(clk),
        .i_reset(reset),
        .i_btn(s1),
        .o_btn_clean(w_clean_s1)
    );

    button_debounce #(.DEBOUNCE_LIMIT(200_000))u_s2_debounce( // debounce 2ms
        .i_clk(clk),
        .i_reset(reset),
        .i_btn(s2),
        .o_btn_clean(w_clean_s2)
    );

    button_debounce #(.DEBOUNCE_LIMIT(200_000))u_key_debounce( // debounce 2ms
        .i_clk(clk),
        .i_reset(reset),
        .i_btn(key),
        .o_btn_clean(w_clean_key)
    );

    rotary u_rotary(
        .clk(clk),
        .reset(reset),
        .clean_s1(w_clean_s1),
        .clean_s2(w_clean_s2),
        .clean_key(w_clean_key),
        .led(led)
    );

endmodule

Basys3-Master_original.xdc

## This file is a general .xdc for the Basys3 rev B board
## To use it in a project:
## - uncomment the lines corresponding to used pins
## - rename the used ports (in each line, after get_ports) according to the top level signal names in the project

## Clock signal
set_property -dict { PACKAGE_PIN W5   IOSTANDARD LVCMOS33 } [get_ports clk]
create_clock -add -name sys_clk_pin -period 10.00 -waveform {0 5} [get_ports clk]


## Switches
set_property -dict { PACKAGE_PIN V17   IOSTANDARD LVCMOS33 } [get_ports {sw[0]}]
set_property -dict { PACKAGE_PIN V16   IOSTANDARD LVCMOS33 } [get_ports {sw[1]}]
set_property -dict { PACKAGE_PIN W16   IOSTANDARD LVCMOS33 } [get_ports {sw[2]}]
set_property -dict { PACKAGE_PIN W17   IOSTANDARD LVCMOS33 } [get_ports {sw[3]}]
set_property -dict { PACKAGE_PIN W15   IOSTANDARD LVCMOS33 } [get_ports {sw[4]}]
set_property -dict { PACKAGE_PIN V15   IOSTANDARD LVCMOS33 } [get_ports {sw[5]}]
set_property -dict { PACKAGE_PIN W14   IOSTANDARD LVCMOS33 } [get_ports {sw[6]}]
set_property -dict { PACKAGE_PIN W13   IOSTANDARD LVCMOS33 } [get_ports {sw[7]}]
#set_property -dict { PACKAGE_PIN V2    IOSTANDARD LVCMOS33 } [get_ports {sw[8]}]
#set_property -dict { PACKAGE_PIN T3    IOSTANDARD LVCMOS33 } [get_ports {sw[9]}]
#set_property -dict { PACKAGE_PIN T2    IOSTANDARD LVCMOS33 } [get_ports {sw[10]}]
#set_property -dict { PACKAGE_PIN R3    IOSTANDARD LVCMOS33 } [get_ports {sw[11]}]
#set_property -dict { PACKAGE_PIN W2    IOSTANDARD LVCMOS33 } [get_ports {sw[12]}]
#set_property -dict { PACKAGE_PIN U1    IOSTANDARD LVCMOS33 } [get_ports {sw[13]}]
#set_property -dict { PACKAGE_PIN T1    IOSTANDARD LVCMOS33 } [get_ports {sw[14]}]
#set_property -dict { PACKAGE_PIN R2    IOSTANDARD LVCMOS33 } [get_ports { cin }]


## LEDs
set_property -dict { PACKAGE_PIN U16   IOSTANDARD LVCMOS33 } [get_ports {led[0]}]
set_property -dict { PACKAGE_PIN E19   IOSTANDARD LVCMOS33 } [get_ports {led[1]}]
set_property -dict { PACKAGE_PIN U19   IOSTANDARD LVCMOS33 } [get_ports {led[2]}]
set_property -dict { PACKAGE_PIN V19   IOSTANDARD LVCMOS33 } [get_ports {led[3]}]
set_property -dict { PACKAGE_PIN W18   IOSTANDARD LVCMOS33 } [get_ports {led[4]}]
set_property -dict { PACKAGE_PIN U15   IOSTANDARD LVCMOS33 } [get_ports {led[5]}]
set_property -dict { PACKAGE_PIN U14   IOSTANDARD LVCMOS33 } [get_ports {led[6]}]
set_property -dict { PACKAGE_PIN V14   IOSTANDARD LVCMOS33 } [get_ports {led[7]}]
set_property -dict { PACKAGE_PIN V13   IOSTANDARD LVCMOS33 } [get_ports {led[8]}]
set_property -dict { PACKAGE_PIN V3    IOSTANDARD LVCMOS33 } [get_ports {led[9]}]
set_property -dict { PACKAGE_PIN W3    IOSTANDARD LVCMOS33 } [get_ports {led[10]}]
set_property -dict { PACKAGE_PIN U3    IOSTANDARD LVCMOS33 } [get_ports {led[11]}]
set_property -dict { PACKAGE_PIN P3    IOSTANDARD LVCMOS33 } [get_ports {led[12]}]
set_property -dict { PACKAGE_PIN N3    IOSTANDARD LVCMOS33 } [get_ports {led[13]}]
set_property -dict { PACKAGE_PIN P1    IOSTANDARD LVCMOS33 } [get_ports {led[14]}]
set_property -dict { PACKAGE_PIN L1    IOSTANDARD LVCMOS33 } [get_ports {led[15]}]


##7 Segment Display
set_property -dict { PACKAGE_PIN W7   IOSTANDARD LVCMOS33 } [get_ports {seg[0]}]
set_property -dict { PACKAGE_PIN W6   IOSTANDARD LVCMOS33 } [get_ports {seg[1]}]
set_property -dict { PACKAGE_PIN U8   IOSTANDARD LVCMOS33 } [get_ports {seg[2]}]
set_property -dict { PACKAGE_PIN V8   IOSTANDARD LVCMOS33 } [get_ports {seg[3]}]
set_property -dict { PACKAGE_PIN U5   IOSTANDARD LVCMOS33 } [get_ports {seg[4]}]
set_property -dict { PACKAGE_PIN V5   IOSTANDARD LVCMOS33 } [get_ports {seg[5]}]
set_property -dict { PACKAGE_PIN U7   IOSTANDARD LVCMOS33 } [get_ports {seg[6]}]
set_property -dict { PACKAGE_PIN V7   IOSTANDARD LVCMOS33 } [get_ports {seg[7]}]  
# seg[7] : dp 
set_property -dict { PACKAGE_PIN U2   IOSTANDARD LVCMOS33 } [get_ports {an[0]}]
set_property -dict { PACKAGE_PIN U4   IOSTANDARD LVCMOS33 } [get_ports {an[1]}]
set_property -dict { PACKAGE_PIN V4   IOSTANDARD LVCMOS33 } [get_ports {an[2]}]
set_property -dict { PACKAGE_PIN W4   IOSTANDARD LVCMOS33 } [get_ports {an[3]}]


##Buttons
set_property -dict { PACKAGE_PIN T18   IOSTANDARD LVCMOS33 } [get_ports reset]
set_property -dict { PACKAGE_PIN W19   IOSTANDARD LVCMOS33 } [get_ports {btn[0]}]
set_property -dict { PACKAGE_PIN U18   IOSTANDARD LVCMOS33 } [get_ports {btn[1]}]
set_property -dict { PACKAGE_PIN T17   IOSTANDARD LVCMOS33 } [get_ports {btn[2]}]
#set_property -dict { PACKAGE_PIN U17   IOSTANDARD LVCMOS33 } [get_ports btnD]


##Pmod Header JA
#set_property -dict { PACKAGE_PIN J1   IOSTANDARD LVCMOS33 } [get_ports {JA[0]}];#Sch name = JA1
#set_property -dict { PACKAGE_PIN L2   IOSTANDARD LVCMOS33 } [get_ports {JA[1]}];#Sch name = JA2
#set_property -dict { PACKAGE_PIN J2   IOSTANDARD LVCMOS33 } [get_ports {JA[2]}];#Sch name = JA3
#set_property -dict { PACKAGE_PIN G2   IOSTANDARD LVCMOS33 } [get_ports {JA[3]}];#Sch name = JA4
#set_property -dict { PACKAGE_PIN H1   IOSTANDARD LVCMOS33 } [get_ports {JA[4]}];#Sch name = JA7
#set_property -dict { PACKAGE_PIN K2   IOSTANDARD LVCMOS33 } [get_ports {JA[5]}];#Sch name = JA8
#set_property -dict { PACKAGE_PIN H2   IOSTANDARD LVCMOS33 } [get_ports {JA[6]}];#Sch name = JA9
#set_property -dict { PACKAGE_PIN G3   IOSTANDARD LVCMOS33 } [get_ports {JA[7]}];#Sch name = JA10

##Pmod Header JB
#set_property -dict { PACKAGE_PIN A14   IOSTANDARD LVCMOS33 } [get_ports {JB[0]}];#Sch name = JB1
#set_property -dict { PACKAGE_PIN A16   IOSTANDARD LVCMOS33 } [get_ports {JB[1]}];#Sch name = JB2
#set_property -dict { PACKAGE_PIN B15   IOSTANDARD LVCMOS33 } [get_ports {JB[2]}];#Sch name = JB3
#set_property -dict { PACKAGE_PIN B16   IOSTANDARD LVCMOS33 } [get_ports {JB[3]}];#Sch name = JB4
#set_property -dict { PACKAGE_PIN A15   IOSTANDARD LVCMOS33 } [get_ports {JB[4]}];#Sch name = JB7
#set_property -dict { PACKAGE_PIN A17   IOSTANDARD LVCMOS33 } [get_ports {JB[5]}];#Sch name = JB8
#set_property -dict { PACKAGE_PIN C15   IOSTANDARD LVCMOS33 } [get_ports {JB[6]}];#Sch name = JB9
#set_property -dict { PACKAGE_PIN C16   IOSTANDARD LVCMOS33 } [get_ports {JB[7]}];#Sch name = JB10

##Pmod Header JC
set_property -dict { PACKAGE_PIN K17   IOSTANDARD LVCMOS33 } [get_ports { s1 }];#Sch name = JC1
set_property -dict { PACKAGE_PIN M18   IOSTANDARD LVCMOS33 } [get_ports { s2 }];#Sch name = JC2
set_property -dict { PACKAGE_PIN N17   IOSTANDARD LVCMOS33 } [get_ports { key }];#Sch name = JC3
#set_property -dict { PACKAGE_PIN P18   IOSTANDARD LVCMOS33 } [get_ports {JC[3]}];#Sch name = JC4
#set_property -dict { PACKAGE_PIN L17   IOSTANDARD LVCMOS33 } [get_ports {JC[4]}];#Sch name = JC7
#set_property -dict { PACKAGE_PIN M19   IOSTANDARD LVCMOS33 } [get_ports {JC[5]}];#Sch name = JC8
#set_property -dict { PACKAGE_PIN P17   IOSTANDARD LVCMOS33 } [get_ports {JC[6]}];#Sch name = JC9
#set_property -dict { PACKAGE_PIN R18   IOSTANDARD LVCMOS33 } [get_ports {JC[7]}];#Sch name = JC10

##Pmod Header JXADC
#set_property -dict { PACKAGE_PIN J3   IOSTANDARD LVCMOS33 } [get_ports {JXADC[0]}];#Sch name = XA1_P
#set_property -dict { PACKAGE_PIN L3   IOSTANDARD LVCMOS33 } [get_ports {JXADC[1]}];#Sch name = XA2_P
#set_property -dict { PACKAGE_PIN M2   IOSTANDARD LVCMOS33 } [get_ports {JXADC[2]}];#Sch name = XA3_P
#set_property -dict { PACKAGE_PIN N2   IOSTANDARD LVCMOS33 } [get_ports {JXADC[3]}];#Sch name = XA4_P
#set_property -dict { PACKAGE_PIN K3   IOSTANDARD LVCMOS33 } [get_ports {JXADC[4]}];#Sch name = XA1_N
#set_property -dict { PACKAGE_PIN M3   IOSTANDARD LVCMOS33 } [get_ports {JXADC[5]}];#Sch name = XA2_N
#set_property -dict { PACKAGE_PIN M1   IOSTANDARD LVCMOS33 } [get_ports {JXADC[6]}];#Sch name = XA3_N
#set_property -dict { PACKAGE_PIN N1   IOSTANDARD LVCMOS33 } [get_ports {JXADC[7]}];#Sch name = XA4_N


##VGA Connector
#set_property -dict { PACKAGE_PIN G19   IOSTANDARD LVCMOS33 } [get_ports {vgaRed[0]}]
#set_property -dict { PACKAGE_PIN H19   IOSTANDARD LVCMOS33 } [get_ports {vgaRed[1]}]
#set_property -dict { PACKAGE_PIN J19   IOSTANDARD LVCMOS33 } [get_ports {vgaRed[2]}]
#set_property -dict { PACKAGE_PIN N19   IOSTANDARD LVCMOS33 } [get_ports {vgaRed[3]}]
#set_property -dict { PACKAGE_PIN N18   IOSTANDARD LVCMOS33 } [get_ports {vgaBlue[0]}]
#set_property -dict { PACKAGE_PIN L18   IOSTANDARD LVCMOS33 } [get_ports {vgaBlue[1]}]
#set_property -dict { PACKAGE_PIN K18   IOSTANDARD LVCMOS33 } [get_ports {vgaBlue[2]}]
#set_property -dict { PACKAGE_PIN J18   IOSTANDARD LVCMOS33 } [get_ports {vgaBlue[3]}]
#set_property -dict { PACKAGE_PIN J17   IOSTANDARD LVCMOS33 } [get_ports {vgaGreen[0]}]
#set_property -dict { PACKAGE_PIN H17   IOSTANDARD LVCMOS33 } [get_ports {vgaGreen[1]}]
#set_property -dict { PACKAGE_PIN G17   IOSTANDARD LVCMOS33 } [get_ports {vgaGreen[2]}]
#set_property -dict { PACKAGE_PIN D17   IOSTANDARD LVCMOS33 } [get_ports {vgaGreen[3]}]
#set_property -dict { PACKAGE_PIN P19   IOSTANDARD LVCMOS33 } [get_ports Hsync]
#set_property -dict { PACKAGE_PIN R19   IOSTANDARD LVCMOS33 } [get_ports Vsync]


##USB-RS232 Interface
set_property -dict { PACKAGE_PIN B18   IOSTANDARD LVCMOS33 } [get_ports RsRx]
set_property -dict { PACKAGE_PIN A18   IOSTANDARD LVCMOS33 } [get_ports RsTx]


##USB HID (PS/2)
#set_property -dict { PACKAGE_PIN C17   IOSTANDARD LVCMOS33   PULLUP true } [get_ports PS2Clk]
#set_property -dict { PACKAGE_PIN B17   IOSTANDARD LVCMOS33   PULLUP true } [get_ports PS2Data]


##Quad SPI Flash
##Note that CCLK_0 cannot be placed in 7 series devices. You can access it using the
##STARTUPE2 primitive.
#set_property -dict { PACKAGE_PIN D18   IOSTANDARD LVCMOS33 } [get_ports {QspiDB[0]}]
#set_property -dict { PACKAGE_PIN D19   IOSTANDARD LVCMOS33 } [get_ports {QspiDB[1]}]
#set_property -dict { PACKAGE_PIN G18   IOSTANDARD LVCMOS33 } [get_ports {QspiDB[2]}]
#set_property -dict { PACKAGE_PIN F18   IOSTANDARD LVCMOS33 } [get_ports {QspiDB[3]}]
#set_property -dict { PACKAGE_PIN K19   IOSTANDARD LVCMOS33 } [get_ports QspiCSn]


## Configuration options, can be used for all designs
set_property CONFIG_VOLTAGE 3.3 [current_design]
set_property CFGBVS VCCO [current_design]

## SPI configuration mode options for QSPI boot, can be used for all designs
set_property BITSTREAM.GENERAL.COMPRESS TRUE [current_design]
set_property BITSTREAM.CONFIG.CONFIGRATE 33 [current_design]
set_property CONFIG_MODE SPIx4 [current_design]

14 ~ 17일차 mini Project4 - 공기 조화 설비 HVAC_System

호타리 — Tue, 22 Jul 2025 11:10:07 +0900

2025.07.17 ~ 2025.07.22

BESPOKE 스마트 가전 FPGA 시스템

다양한 센서 및 액추에이터를 통합하여 구현한 스마트 가전 시뮬레이션 FPGA 프로젝트

프로젝트 개요

이 프로젝트는 Vivado 기반 Basys3 보드에서 다음과 같은 스마트 가전 기능을 통합적으로 구현합니다:

초음파 거리 측정
DHT11 온습도 센서 기반 HVAC 제어
전자레인지 기능 (타이머, 서보 제어, 부저 알림)
UART 통신을 통한 측정값 전송 및 외부 명령 수신
스톱워치 / IDLE 애니메이션

주요 기능

모드 설명

MODE 0 (Idle)	FND 순환 애니메이션 표시 (대기 상태)
MODE 1 (공조기 자동)	온습도 + 초음파 거리 측정 → 자동 모터 제어 (측정 온도 기준 PWM) + UART 전송
MODE 2 (공조기 수동)	온습도 측정 + 스위치·버튼으로 설정한 희망 온도에 따라 DC 모터 제어 + UART 전송
MODE 3 (전자레인지)	시간 설정 + 조리 동작 FSM + 서보모터 제어 + 종료시 부저 알림
MODE 4 (스톱워치)	실시간 스톱워치 카운트 FND 표시

UART 포맷 명세

데이터 종류 포맷 예시 설명

초음파 거리	Dist:0123cm	거리 측정 결과 (cm)
온도/습도	Temp:27.06C Humi:64.00%	정수 2자리 + 소수 2자리로 전송
오류 메시지	Error: DHT fail	DHT11 측정 실패 시 전송 (예정 기능)

⚙️ 사용한 주요 모듈

센서 및 제어

hcsr04.v: 초음파 거리 측정
dht11_controller.v: 온습도 센서 제어 FSM
manual_temp_controller.v: 수동 온도 설정 FSM
hvac_pwm_dcmotor.v: 온도 기반 DC 모터 제어
mw_controller.v, mw_servo_motor.v: 전자레인지 FSM

디스플레이 및 출력

fnd_controller.v: 7-segment 표시 제어
idle_fnd.v: IDLE 모드 애니메이션
buzzer_controller.v: 부저 제어
uart_tx.v, data_sender.v: UART 통신

공통 모듈

button_debounce.v: 버튼 디바운싱
tick_generator.v: 1Hz / 1us 등 클럭 분주기

FSM 다이어그램 요약 (Mermaid)

DHT11 FSM

stateDiagram-v2
    [*] --> IDLE
    IDLE --> SEND_REQUEST: after 3s
    SEND_REQUEST --> WAIT_RESPONSE_LOW: after 18ms
    WAIT_RESPONSE_LOW --> WAIT_RESPONSE_HIGH: falling edge detected
    WAIT_RESPONSE_HIGH --> READ_DATA: rising edge detected
    READ_DATA --> VERIFY_CHECKSUM: 40bit done
    VERIFY_CHECKSUM --> IDLE

‍♂️ 초음파 FSM

stateDiagram-v2
    [*] --> WAIT
    WAIT --> TRIGGER: tick_1Hz
    TRIGGER --> WAIT_ECHO: 10us pulse sent
    WAIT_ECHO --> MEASURE: echo rising edge
    MEASURE --> DONE: echo falling edge
    DONE --> WAIT: latch value, wait for next tick

️ 공조기 FSM (HVAC 제어)

stateDiagram-v2
    [*] --> IDLE
    IDLE --> AUTO_CONTROL: btnL (mode change)
    AUTO_CONTROL --> READ_DISTANCE: tick_1Hz
    AUTO_CONTROL --> READ_TEMPERATURE: tick_1Hz
    READ_DISTANCE --> DISABLE_MOTOR: distance <= 5cm
    READ_DISTANCE --> SET_PWM: distance > 5cm
    READ_TEMPERATURE --> EVALUATE_TEMP
    EVALUATE_TEMP --> MANUAL_CONTROL: btnL (mode change)
    MANUAL_CONTROL --> APPLY_TARGET_TEMP: sw[1] == 1 / btnU(Temp↑), btnD(Temp↓)
    APPLY_TARGET_TEMP --> SET_PWM: 희망 온도 기준 제어
    EVALUATE_TEMP --> SET_PWM: 측정된 온도 기준 자동 제어
    DISABLE_MOTOR --> SET_PWM

전자레인지 FSM

stateDiagram-v2
    [*] --> IDLE
    IDLE --> SET_TIME: btn_inc/dec
    SET_TIME --> COOKING: btn_start
    COOKING --> COMPLETE: time = 0
    COMPLETE --> DOOR_OPEN: btn_open
    DOOR_OPEN --> DOOR_CLOSE: btn_close
    DOOR_CLOSE --> IDLE

⏱ 분초시계 / 스톱워치 FSM

stateDiagram-v2
    [*] --> IDLE
    IDLE --> IDLE: btnD (circle speed control)
    IDLE --> MINSEC_WATCH: btnR
    MINSEC_WATCH --> STOPWATCH: btnR
    STOPWATCH --> IDLE: btnR
    STOPWATCH --> STOPWATCH: btnC (pause / resume)
    STOPWATCH --> STOPWATCH: tick_1Hz (count up)
    STOPWATCH --> STOPWATCH: btnU (reset time)

상세 구현 기능 정리

압축파일 내 Verilog 소스 기준으로 구현된 각 기능은 다음과 같습니다:

✅ 센서 및 입력 처리

파일명 기능 설명

hcsr04.v	HC-SR04 초음파 센서 구동 및 거리 측정
dht11.v / dht11_controller.v	DHT11 온습도 센서 통신 FSM
manual_temp_controller.v	스위치 기반 수동 온도 설정 FSM
button_debounce.v	버튼 디바운싱 회로 구현 (노이즈 방지)

✅ DC 모터 / HVAC 제어

파일명 기능 설명

hvac_pwm_dcmotor.v	자동/수동 온도에 따라 DC 모터 PWM 제어
pwm_dcmotor.v, pwm_duty_cycle_control.v	일반 DC 모터 제어용 PWM 회로

✅ 전자레인지 시스템

파일명 기능 설명

microwave.v	전체 전자레인지 시스템 통합
mw_controller.v, mw_fsm_controller.v	조리 상태 FSM 제어
mw_servo_motor.v	서보 모터로 문 여닫기
mw_time_controller.v	조리 시간 설정 및 카운트

✅ 디스플레이 및 시각 출력

파일명 기능 설명

fnd_controller.v, fnd_controller_2.v	7-세그먼트 디스플레이 제어
idle_fnd.v	IDLE 모드 애니메이션 출력
sw_fnd_controller.v, dht11_fnd_controller.v	스톱워치 및 온습도 값 디스플레이

✅ 스톱워치 / 타이머

파일명 기능 설명

minsec_stopwatch.v	분/초 단위 스톱워치 카운트 FSM
sw_controller.v	스톱워치 모드 전환 및 동작 FSM

✅ 부저 제어

파일명 기능 설명

buzzer_top.v	전체 부저 시스템 통합
power_on_buzzer.v, open_buzzer.v	버튼 기반 부저 제어
ultra_buzzer_controller.v	거리 경보용 부저 제어 FSM

✅ UART 통신

파일명 기능 설명

uart_tx.v, uart_rx.v	송수신 회로
uart_controller.v	전체 UART 통신 제어
data_sender.v, dht11_data_sender.v	UART 전송 포맷 관리

️ 시연 영상

영상 종류 링크

전체 동작 영상	동작 영상 보러가기
UART 통신 영상	comportmaster 출력 영상

사용법

Vivado로 프로젝트 열기 (15.BESPOKE.xpr)
Top Module: top
bitstream 생성 후 Basys3에 다운로드
스위치/버튼 조작 및 comportmaster로 UART 결과 확인

배선 및 Basys3 핀 할당 요약

기능 핀 이름 연결 포트명

메인 클럭	W5	clk
리셋 버튼	R2	reset
스위치	V17 \~ R2	sw[0] ~ sw[14]
버튼	W19, U18, T17, T18, U17	btn[0] ~ btn[4]
LED	U16 \~ L1	led[0] ~ led[15]
7세그먼트	W7 \~ V7	seg[0] ~ seg[7]
Anode	U2, U4, V4, W4	an[0] ~ an[3]
초음파 센서	B15, B16	echo, trig
DHT11 데이터	R18	dht11_data (pull-up 적용)
부저	K17	buzzer
DC 모터 제어	JA1\~JA3	PWM_OUT, in1_in2[0], in1_in2[1]
서보모터	JA4	PWM_SERVO
HVAC DC 모터 제어	J3, L3, M2	PWM_OUT_HVAC, in1_in2_HVAC[0], in1_in2_HVAC[1]
UART 통신	A18, B18	RsTx, RsRx

개발 환경

Vivado 2021.1
Basys3 FPGA 보드
comportmaster 또는 Tera Term
100MHz 시스템 클럭 기준

✍️ 참고 및 기여

이 프로젝트는 임베디드 시스템, 센서 통합, 하드웨어 제어, UART 통신 등 실전 회로 설계 능력을 종합적으로 훈련하기 위해 설계되었습니다.

13일차

호타리 — Wed, 16 Jul 2025 17:06:22 +0900

2025.07.16

UART 통신

ASCII '0' ~ '9' 1초 단위로 출력

'PSH' 이름 1초 단위로 출력

UART_RX

https://github.com/SE0NGH0/AI_Verilog_HDL/tree/main/77.uart

12일차

호타리 — Wed, 16 Jul 2025 09:08:10 +0900

2025.07.15

UART(Universal Asynchronous Receiver/Transmitter)
비동기 직렬 통신 방식으로, 마이크로컨트롤러(MCU), FPGA, 센서 등에서 널리 사용되는 통신 방법

■ UART 통신의 특징
  - 비동기식(Asynchronous): 클럭 신호를 별도로 사용하지 않음
  - 직렬 통신: 데이터를 한 비트씩 순차적으로 전송
  - Full-Duplex 가능: 송신(TX)과 수신(RX)을 동시에 처리 가능

■ UART 데이터 통신 규격

시작 (START) 비트: 통신의 시작을 의미하며 한 비트 시간 길이만큼 0을 유지한다.
데이터 비트: 5~8비트의 데이터 전송을 한다.
패리티 (PARITY) 비트: 오류 검증을 하기 위한 패리티 값을 생성하여 송신하고 수신쪽에서 오류 판단한다.
끝 (STOP) 비트: 통신 종료를 알린다.
보드레이트 (Baud Rate): Baud Rate는 통신에서 1초에 전송하는 심볼의 수이다.
비동기 통신에서는 별도의 데이터의 시작과 끝을 위한 별도의 클럭을 사용하지 않고 1bit의 데이터를 확인 하기 위하여 여러 개의 샘플(16개)를 취하여 비트의 시작과 끝을 판단 한다. 2배속 모드는 비트 데이터 확인을 위해서 샘플의 수를 절반(8개)로 줄여 전송속도를 2배로 증가 시키는 방법이다.

송신 (TX)
   보낼 데이터(byte)를 프레임 구조로 구성
    각 비트를 일정한 속도로 순차적으로 전송

수신 (RX)
   Start Bit의 Falling Edge를 감지 → 샘플링 시작
   정해진 시간 간격으로 Data/Parity/Stop Bit 수신

UART의 장점 / 단점

UART Transmit

1. 비동기 통신 방식으로, 송신(TX)과 수신(RX)이 독립적으로 처리됨.
송신과 수신은 각각 다른 타이밍에 발생할 수 있으며, 별도의 클럭 신호 없이 데이터를 송 · 수신함

2. 비동기이기 때문에 데이터를 받을 때, Start bit를 0으로 고정 후 데이터를 송 · 수신하고 마지막 끝 비트를 1로 고정시키는 인코딩 작업이 필요

3. 또한 송 · 수신시 Baud Rate를 고려해야 하기 때문에, 타이밍에 맞춰 인코딩 해야함

Step1 : START 신호로 low signal을 10416 ns 동안 전송(9600 BPS 기준)

Step2 : 이어서 8bit의 DATA를 LSB부터 MSB까지 0 이면 low, 1이면 high 로 10416 ns 주기로 전송

Step3 : DATA 전송을 마치고 high 로 유지

1. System clock 100MHz에서 9600Hz의 주파수를 만들고자 하면

1.1. 100MHz(100,000,000Hz) 의 1주기(1/100,000,000)는 0.000,000,01 sec(10ns)

1.2. System clock 100MHz를 입력으로 해서 9600Hz의 주파수를 만들고자 하면
  1) 1주기는 100MHz / 9600Hz  10416.666ns(104.16us)
  2)  결국 1주기가 10416.666ns 짜리 가 9600번 반복하면 100MHz(100,000,000Hz)가 생성 된다.
      - system clock의 100MHz의 1주기가 10ns로써 10416.666ns를 count하기 위해서는 10416번 count 한다.
3) 여기서 50% Duty cycle을 유지 하고자 한다면 10416.666ns의 절반인  5208.333 ns

2. System clock이 100MHz에서 115200(bps)Hz의 주파수를 만들고자 하면

- 100,000,000Hz/115200bps = 868 (CLOCK PER BIT)

100MHz system clock의 115200bps 전송을 하기 위해서는 868clock당 1 bit를 송.수신 하면 됨

UART top module block diagram

UART controller module block diagram

UART 송신 module uart_tx

11일차 mini Project3 - Microwave_System

호타리 — Mon, 14 Jul 2025 12:42:22 +0900

2025.07.14

# Verilog Microwave Oven System

Basys3 FPGA 기반의 Verilog HDL 프로젝트로, 실생활 전자레인지의 핵심 기능을 디지털 회로로 구현하였습니다.

---

## 프로젝트 개요

이 프로젝트는 전자레인지의 주요 기능을 FPGA 보드에서 구현한 것입니다.
사용자는 버튼을 통해 시간을 설정하고, 조리 과정을 시작하며, 모터 및 서보, 부저를 통한 피드백을 제공합니다.

> 타이머 설정 → 모터 회전 및 동작 → 종료 시 알림음 및 서보 제어

---

## ️ 주요 기능 요약

| 기능                  | 설명 |
|-----------------------|------|
| ⏱ 타이머 설정         | 버튼으로 초 단위 시간 설정 (`btn_U`, `btn_D`) |
| ▶ 조리 시작/취소      | `btn_run`으로 시작, `btn_D`로 취소 가능 |
| DC 모터 회전        | 조리 시간 동안 자동 PWM 회전 |
| 부저 출력          | 버튼 입력 시 BEEP, 종료 시 알림음 |
| 서보모터 문 제어   | `btn_L`로 열기, `btn_R`로 닫기 |
| FND 디스플레이     | 남은 시간 출력 |
| 방향 제어          | SW14, SW15를 통해 DC 모터 방향 설정 가능 (`in1_in2`) |

---

## 프로젝트 구조

```
├── top_module.v               # 전체 시스템 통합 FSM
├── btn_controller.v           # 버튼 디바운싱 + 펄스 생성
├── fnd_controller.v           # FND로 남은 시간 표시 및 타이머 FSM
├── buzzer_controller.v        # 부저 제어
├── dc_controller.v            # DC 모터 PWM 제어 (타이머 연동)
├── servo_motor_controller.v   # 서보모터 PWM 제어 (수동 버튼)
```

---

## 시스템 동작 흐름

```mermaid
stateDiagram-v2
    [*] --> CIRCLE
    CIRCLE --> IDLE: sw0 == 1
    IDLE --> SET_TIME: btn_U or btn_D
    SET_TIME --> RUNNING: btn_run
    RUNNING --> DONE: timer done
    RUNNING --> IDLE: btn_D (cancel)
    DONE --> IDLE
```

---

## 입출력 핀 구성

| 핀/스위치    | 설명 |
|--------------|------|
| `btn_U`      | 시간 증가 |
| `btn_D`      | 시간 감소 / 취소 |
| `btn_L`      | 서보모터 문 열기 (0도) |
| `btn_R`      | 서보모터 문 닫기 (180도) |
| `btn_run`    | 조리 시작 |
| `sw`         | 모드 선택 |
| `sw14~15`    | DC 모터 방향 제어 |
| `in1_in2`    | DC 모터 제어 핀 |
| `PWM_OUT`    | DC 모터 PWM 출력 |
| `servo_out`  | 서보모터 PWM 출력 |
| `buzzer`     | 부저 신호 출력 |
| `seg_data`   | 7-segment 데이터 |
| `an`         | FND 자리 선택 |

---

## 시연 영상

[YouTube 시연 영상 바로 보기](https://youtube.com/shorts/ziCvCQJrvrs)

> 영상에서는 버튼을 이용한 시간 설정, 조리 시작, DC 모터 회전, FND 출력, 서보모터 문 제어, 부저 반응 등의 전체 동작 흐름을 확인할 수 있습니다.

---

## ⚙️ 구현 상세

- **DC 모터는 타이머 동작 중 자동 회전**, 종료되면 PWM 출력이 0으로 꺼짐
- **서보모터는 버튼 입력(`btn_L`, `btn_R`)으로 직접 열고 닫음**
- **부저는 타이머 종료 시 알림음 출력**
- **FND는 남은 시간 출력 또는 0점멸 애니메이션**
- **모터 방향은 SW14, SW15에 따라 `in1_in2`로 전달**

---

## 테스트 및 시뮬레이션

- FPGA 실제 배치 후 하드웨어 디버깅 완료
- PWM 파형, FND 타이밍, 서보 제어 파형 모두 확인
- Simulation 없이 실제 동작 중심으로 검증

---

## Vivado 프로젝트 설정

- **Board**: Digilent Basys3 (Artix-7 xc7a35tcpg236-1)
- **Clock**: 100 MHz
- **Constraints**: Basys3-Master.xdc 사용

---

## 참고

- 서보모터 PWM: 50Hz 기준 (1ms~2ms = 0도~180도)
- DC 모터 PWM: 10단계 듀티 설정 가능 (0~9)
- FND: 4-digit multiplexing 방식, timer 카운트와 blink 상태 병행 출력

---

https://github.com/SE0NGH0/AI_Verilog_HDL/tree/main/microwave

10일차

호타리 — Mon, 14 Jul 2025 12:41:02 +0900

2025.07.11

휴가

9일차

호타리 — Thu, 10 Jul 2025 16:53:53 +0900

2025.07.10

buzzer

buzzer_top.v

`timescale 1ns / 1ps

module top(
    input clk,
    input reset,
    input btnL,
    input btnR,
    output buzzer
);

    wire clean_btnL, clean_btnR;
    wire buzzer_L, buzzer_R;

    // 버튼 디바운스
    button_debounce dbL (
        .i_clk(clk),
        .i_reset(reset),
        .i_btn(btnL),
        .o_btn_clean(clean_btnL)
    );

    button_debounce dbR (
        .i_clk(clk),
        .i_reset(reset),
        .i_btn(btnR),
        .o_btn_clean(clean_btnR)
    );

    // 파워 온 시퀀스 (btnL)
    power_on_buzzer u_power (
        .clk(clk),
        .reset(reset),
        .btnL(clean_btnL),
        .buzzer_L(buzzer_L)
    );

    // 오픈 시퀀스 (btnR)
    open_buzzer u_open (
        .clk(clk),
        .reset(reset),
        .btnR(clean_btnR),
        .buzzer_R(buzzer_R)
    );

    assign buzzer = buzzer_L | buzzer_R;

endmodule

power_on_buzzer.v

`timescale 1ns / 1ps

module power_on_buzzer(
    input clk,
    input reset,
    input btnL,
    output reg buzzer_L
);

    parameter CNT_70MS = 23'd7000000;
    parameter CNT_3S   = 29'd300000000;

    parameter HALF_1K = 17'd50000;
    parameter HALF_2K = 17'd25000;
    parameter HALF_3K = 17'd16667;
    parameter HALF_4K = 17'd12500;

    reg btnL_d1, btnL_d2;
    wire btnL_edge = btnL_d1 & ~btnL_d2;

    always @(posedge clk) begin
        btnL_d1 <= btnL;
        btnL_d2 <= btnL_d1;
    end

    reg run = 0;
    reg [2:0] step = 0;
    reg [28:0] dur_cnt = 0;
    reg [17:0] wave_cnt = 0;
    reg [17:0] half_cycle = 0;

    always @(*) begin
        case (step)
            0: half_cycle = HALF_1K;
            1: half_cycle = HALF_2K;
            2: half_cycle = HALF_3K;
            3: half_cycle = HALF_4K;
            default: half_cycle = 0;
        endcase
    end

    always @(posedge clk or posedge reset) begin
        if (reset) begin
            run <= 0; step <= 0; dur_cnt <= 0; wave_cnt <= 0; buzzer_L <= 0;
        end else begin
            if (btnL_edge) run <= ~run;
            if (!run) begin
                step <= 0; dur_cnt <= 0; wave_cnt <= 0; buzzer_L <= 0;
            end else begin
                if ((step < 4 && dur_cnt >= CNT_70MS) || (step == 4 && dur_cnt >= CNT_3S)) begin
                    dur_cnt <= 0;
                    step <= (step == 4) ? 0 : step + 1;
                end else begin
                    dur_cnt <= dur_cnt + 1;
                end

                if (half_cycle != 0) begin
                    if (wave_cnt >= half_cycle) begin
                        wave_cnt <= 0;
                        buzzer_L <= ~buzzer_L;
                    end else wave_cnt <= wave_cnt + 1;
                end else begin
                    buzzer_L <= 0;
                    wave_cnt <= 0;
                end
            end
        end
    end

endmodule

open_buzzer.v

`timescale 1ns / 1ps

module open_buzzer(
    input clk,
    input reset,
    input btnR,
    output reg buzzer_R
);

    parameter CNT_70MS = 23'd7000000;
    parameter CNT_3S   = 29'd300000000;

    parameter HALF_261 = 18'd192000;
    parameter HALF_329 = 18'd152000;
    parameter HALF_392 = 18'd128000;
    parameter HALF_554 = 18'd90000;

    reg btnR_d1, btnR_d2;
    wire btnR_edge = btnR_d1 & ~btnR_d2;

    always @(posedge clk) begin
        btnR_d1 <= btnR;
        btnR_d2 <= btnR_d1;
    end

    reg run = 0;
    reg [2:0] step = 0;
    reg [28:0] dur_cnt = 0;
    reg [17:0] wave_cnt = 0;
    reg [17:0] half_cycle = 0;

    always @(*) begin
        case (step)
            0: half_cycle = HALF_261;
            1: half_cycle = HALF_329;
            2: half_cycle = HALF_392;
            3: half_cycle = HALF_554;
            default: half_cycle = 0;
        endcase
    end

    always @(posedge clk or posedge reset) begin
        if (reset) begin
            run <= 0; step <= 0; dur_cnt <= 0; wave_cnt <= 0; buzzer_R <= 0;
        end else begin
            if (btnR_edge) run <= ~run;
            if (!run) begin
                step <= 0; dur_cnt <= 0; wave_cnt <= 0; buzzer_R <= 0;
            end else begin
                if ((step < 4 && dur_cnt >= CNT_70MS) || (step == 4 && dur_cnt >= CNT_3S)) begin
                    dur_cnt <= 0;
                    step <= (step == 4) ? 0 : step + 1;
                end else begin
                    dur_cnt <= dur_cnt + 1;
                end

                if (half_cycle != 0) begin
                    if (wave_cnt >= half_cycle) begin
                        wave_cnt <= 0;
                        buzzer_R <= ~buzzer_R;
                    end else wave_cnt <= wave_cnt + 1;
                end else begin
                    buzzer_R <= 0;
                    wave_cnt <= 0;
                end
            end
        end
    end

endmodule

button_debounce.v

`timescale 1ns / 1ps

module button_debounce #(parameter DEBOUNCE_LIMIT = 20'd999_999) (
    input      i_clk,
    input      i_reset,
    input      i_btn,
    output    reg  o_btn_clean  
);
    reg [19:0] count;
    reg btn_state;
    reg btn_clean;

    always @(posedge i_clk, posedge i_reset) begin
        if (i_reset) begin
            count <= 0;
            btn_state <= 0;
            o_btn_clean <= 0;
        end else if (i_btn == btn_state) begin
            count <= 0;
        end else begin
            if (count < DEBOUNCE_LIMIT)
                count <= count + 1;
            else begin
                btn_state <= i_btn;
                o_btn_clean <= i_btn;
                count <= 0;  // 리셋하면 다음 변경을 다시 감지할 수 있음
            end
        end
    end
    
endmodule

8일차

호타리 — Wed, 9 Jul 2025 16:50:12 +0900

2025.07.09

shift_register & FSM

btnU 를 누르면 1이 btnD를 누르면 0이 입력 되도록 구현
입력 되는 상황은 led6~led0로 left shift표시 되도록 하고 동일한 입력 2개(00 또는 11) 발견 시00이면 led15 on 11이면 led14를 on
그렇지 않은 경우는 led15 led14를 off로 처리

top.v

`timescale 1ns / 1ps

module pattern_detector_top (
    input  wire clk,
    input  wire rst,      // 동기 리셋
    input  wire btnU,     // 1 입력 버튼
    input  wire btnD,     // 0 입력 버튼
    output wire [15:0] led // led[6:0] = 입력 표시, led[7] = 패턴 감지
);

    wire clean_btnU, clean_btnD;
    wire pulse_btnU, pulse_btnD;

    // 디바운싱
    button_debouncer db_u (
        .clk(clk),
        .btn(btnU),
        .debounced(clean_btnU)
    );

    button_debouncer db_d (
        .clk(clk),
        .btn(btnD),
        .debounced(clean_btnD)
    );

    // 원샷
    one_pulse op_u (
        .clk(clk),
        .btn_in(clean_btnU),
        .pulse_out(pulse_btnU)
    );

    one_pulse op_d (
        .clk(clk),
        .btn_in(clean_btnD),
        .pulse_out(pulse_btnD)
    );

    // FSM 동작
    pattern_detector_fsm fsm (
        .clk(clk),
        .rst(rst),
        .in1(pulse_btnU),
        .in0(pulse_btnD),
        .led(led)
    );

endmodule

pattern_detector_fsm.v

`timescale 1ns / 1ps


module pattern_detector_fsm (
    input wire clk,
    input wire rst,
    input wire in1,             // btnU → 1
    input wire in0,             // btnD → 0
    output reg [15:0] led       // led[6:0]: 입력 표시, led[14]: 11 감지, led[15]: 00 감지
);

    // 상태 정의
    parameter S_IDLE = 2'b00;
    parameter S_1ST  = 2'b01;

    reg [1:0] current_state, next_state;

    reg prev_bit;
    reg din_bit;
    reg input_valid;

    // 입력 디코딩
    always @(*) begin
        if (in1) begin
            din_bit = 1'b1;
            input_valid = 1'b1;
        end else if (in0) begin
            din_bit = 1'b0;
            input_valid = 1'b1;
        end else begin
            input_valid = 1'b0;
        end
    end

    // 입력 시프트 저장 레지스터 (입력값 자체 shift)
    reg [6:0] input_shift;

    // 상태 전이 및 출력 동작
    always @(posedge clk or posedge rst) begin
        if (rst) begin
            current_state <= S_IDLE;
            prev_bit <= 1'b0;
            input_shift <= 7'b0000000;
            led[15:14] <= 2'b00;
        end else begin
            current_state <= next_state;

            if (input_valid) begin
                // ⬅ 왼쪽으로 입력값 shift (0 또는 1 입력 반영)
                input_shift <= {input_shift[5:0], din_bit};

                // 이전 입력과 비교하여 패턴 감지
                if (din_bit == 1'b0 && prev_bit == 1'b0) begin
                    led[15] <= 1'b1;  // 00
                    led[14] <= 1'b0;
                end else if (din_bit == 1'b1 && prev_bit == 1'b1) begin
                    led[15] <= 1'b0;
                    led[14] <= 1'b1;  // 11
                end else begin
                    led[15] <= 1'b0;
                    led[14] <= 1'b0;  // 01 or 10
                end

                prev_bit <= din_bit;
            end
        end
    end

    // 상태 천이 및 출력 결합
    always @(*) begin
        next_state = current_state;

        case (current_state)
            S_IDLE: begin
                if (input_valid)
                    next_state = S_1ST;
            end

            S_1ST: begin
                next_state = S_1ST;
            end
        endcase

        // 입력 시프트값 출력 연결
        led[6:0] = input_shift;
        // 나머지 led[13:7]는 0으로 유지
    end

endmodule

one_pulse.v

`timescale 1ns / 1ps

module one_pulse (
    input  wire clk,
    input  wire btn_in,
    output reg  pulse_out
);

    reg btn_delay;

    always @(posedge clk) begin
        btn_delay <= btn_in;
        pulse_out <= btn_in & ~btn_delay;
    end

endmodule

button_debouncer.v

`timescale 1ns / 1ps

module button_debouncer (
    input  wire clk,
    input  wire btn,
    output reg  debounced
);

    reg [15:0] cnt;
    reg btn_sync, btn_prev;

    always @(posedge clk) begin
        btn_sync <= btn;
        if (btn_sync == btn_prev)
            cnt <= cnt + 1;
        else
            cnt <= 0;

        if (cnt == 16'hFFFF)
            debounced <= btn_sync;

        btn_prev <= btn_sync;
    end

endmodule

결과 영상

https://youtu.be/zFXQ9qYePkk

7일차 mini Project2 - Vending_Machine

호타리 — Wed, 9 Jul 2025 09:48:24 +0900

2025.07.08

shift register

shift_top.v

`timescale 1ns / 1ps

module shift_top (
    input  wire       clk,      // 100 MHz 클럭
    input  wire       reset,    // Active-High 리셋
    input  wire       btnU,     // ‘1’ 입력 버튼 (Active-High)
    input  wire       btnD,     // ‘0’ 입력 버튼 (Active-High)
    output reg  [7:0] led       // [7]=패턴 플래그, [6:0]=시프트 레지스터
);

    //--------------------------------------------------------------------------
    // 1) 버튼 동기화 & 원샷 펄스 생성
    //--------------------------------------------------------------------------
    reg btnU_d, btnD_d;
    always @(posedge clk or posedge reset) begin
        if (reset) begin
            btnU_d <= 1'b0;
            btnD_d <= 1'b0;
        end else begin
            btnU_d <= btnU;
            btnD_d <= btnD;
        end
    end

    // 눌림 에지(0→1)에서 한 사이클만 1이 되는 펄스
    wire pulse1 = btnU & ~btnU_d;
    wire pulse0 = btnD & ~btnD_d;

    //--------------------------------------------------------------------------
    // 2) din 생성: pulse1→‘1’, pulse0→‘0’
    //--------------------------------------------------------------------------
    reg din;
    always @(posedge clk or posedge reset) begin
        if (reset)
            din <= 1'b0;
        else if (pulse1)
            din <= 1'b1;
        else if (pulse0)
            din <= 1'b0;
        // else din 유지
    end

    //--------------------------------------------------------------------------
    // 3) 7비트 Shift Register: pulse1 또는 pulse0일 때만 시프트
    //--------------------------------------------------------------------------
    reg [6:0] shift_reg;
    always @(posedge clk or posedge reset) begin
        if (reset)
            shift_reg <= 7'b0;
        else if (pulse1)
            shift_reg <= { shift_reg[5:0], 1'b1 };
        else if (pulse0)
            shift_reg <= { shift_reg[5:0], 1'b0 };
        // else shift_reg 유지
    end

    //--------------------------------------------------------------------------
    // 4) 패턴 검출: shift_reg == 7'b1010111
    //--------------------------------------------------------------------------
    wire pattern_hit = (shift_reg == 7'b1010111) ? 1'b1 : 1'b0;

    //--------------------------------------------------------------------------
    // 5) LED 갱신
    //--------------------------------------------------------------------------
    always @(posedge clk or posedge reset) begin
        if (reset)
            led <= 8'b0;
        else
            led <= { pattern_hit, shift_reg };
    end

endmodule

결과

https://youtube.com/shorts/jmxTMGEkNf0

Vending_Machine Project

https://github.com/SE0NGH0/AI_Verilog_HDL/tree/main/vending_machine

6일차

호타리 — Mon, 7 Jul 2025 17:49:29 +0900

2025.07.07

순차회로와 FSM

조합회로 (Combinational Logic)
- 값을 저장하지 못함
- 클럭을 사용하지 않음
- 입력의 변화가 출력에 바로 반영됨
- 예 : adders, multiplexers, decoders, encoders, gates

순차회로 (Sequential Logic)
- 값을 저장하는 래치, 플립플롭, 레지스터, 메모리 등의 소자가 있어 상태를 저장
- 클럭을 사용하여 값을 저장
- 입력이 변화해도 주로 클럭의 에지에서 값이 반영됨
- 예 : counter, register, clock divider, FSM (Finite State Machine)

순차 회로의 종류

FSM (한정된 상태를 갖는 머신)
- Counter (계수기)
- Clock divider (클럭 분주기)
- FSM

Register (레지스터)
- Shift register
- Parallel register

조합회로

FSM 타입의 회로

TV channel 버튼
- 0, 1, 2, …, 9 채널이 있는 TV가 있다고 가정하고 채널 UP과 DN 버튼으로 채널을 선택한다면
- 채널 UP 버튼을 눌렀을 때
현재 상태가 3이면 다음 상태는 4
현재 상태가 9라면 다음 상태는 10
- 채널 DN 버튼을 눌렀을 때
현재 상태가 3이면 다음 상태는 2
현재 상태가 9라면 다음 상태는 8
- 다음 상태는 입력과 현재상태에 의해 결정
- 출력은 현재상태를 바로 출력으로 사용

현재상태를 저장하는 순차회로로만 가능하며 조합회로로는 불가능

FSM의 세부 블록 구분

FSM (Finite State Machine), 유한 상태 머신의 개념
- 유한한 개수의 상태를 가지고 있으며
- 입력과 현재상태에 따라 다음상태가 결정되고
- (입력과) 현재상태에 따라 출력이 결정되는 머신

FSM 세부 블록
- Next state logic (조합회로)
입력(input) + 현재상태(present state) → 조합회로 → 다음상태(next state)

- State register (순차회로, F/F)
다음상태(next state) → clock edge에서 저장 → 현재상태(present state)

- Output logic (조합회로)
Moore machine의 경우 : 현재상태(present state) → 조합회로 → 다음상태(next state)
Mealy machine의 경우 : 입력(input) + 현재상태(present state) → 조합회로 → 다음상태

- 상태 다이어그램의 일반적인 표기법
- 현재상태가 st0일 경우
출력 done = 1
만약 in=1 이면 출력은 out = 0, 다음 상태는 st1

상태표 (State Table)

TV Channel 버튼 Verilog code

tv_channel.v

`timescale 1ns / 1ps

module tv_channel(
    input wire clk,
    input wire rstn,
    input wire up,
    input wire dn,
    output [3:0] ch
    );

    reg [3:0] state, next_state;

    always @(up or dn or state) begin
        if (up & ~dn) begin
            if (state == 9) 
                next_state = 0;
            else 
                next_state = state + 1;
        end
        else if (~up & dn) begin
            if (state == 0) 
                next_state = 9;
            else 
                next_state = state - 1;
        end else begin
            next_state = state;
        end
    end

    always @(posedge clk or negedge rstn) begin
        if (!rstn) 
            state <= 4'h0;
        else 
            state <= next_state;
    end

    assign ch = state;

endmodule

tb_tv_channel.v

`timescale 1ns / 1ps

module tb_ch();


    reg clk, rstn;
    reg up, dn;
    wire [3:0] ch;


    tv_channel dut_tv(
    .clk(clk),
    .rstn(rstn),
    .up(up), .dn(dn),
    .ch(ch)
    );


    initial clk = 0;
    always #5 clk = ~ clk;

    initial begin
        #0 rstn = 1; up = 1'b1; dn = 1'b0;
        #90 up = 1'b0; dn = 1'b1;
        #50 up = 1'b1;
        #20 up = 1'b0; dn = 1'b0;
        #30 up = 1'b0; dn = 1'b0;
        #120 $finish;
    end
endmodule

TV Channel 버튼 Simulation 결과

레지스터 회로

파이프라인(Pipeline) 형태의 회로

Blocking과 Nonblocking 할당문

코딩 가이드라인
- 가이드라인-1：순차회로 또는 래치를 모델링하는 always 블록에서는 nonblocking 할당문을 사용한다.
- 가이드라인-2：조합논리회로를 모델링하는 always 블록에서는 blocking 할당문을 사용한다.

- 가이드라인-3：동일한 always 블록에서 순차회로와 조합논리회로를 함께 표현하는 경우에는 nonblocking 할당문을 사용한다.

- 가이드라인-4：동일한 always 블록 내에서 blocking 할당문과 nonblocking 할당문을 혼합해서 사용하지 않는다.

- 가이드라인-5：다수의 always 블록에서 동일한 reg 변수에 값을 할당하지 않는다.

원하지 않는 래치의 합성
일반적으로, case 문에 모든 가능한 case 항목들이 포함되지 않거나 if 조건문에서
else 블록이 생략되는 경우가 있을 수 있다. case 문과 if 조건문에 모든 가능한 조건들이 포함되지 않은 경우를 ‘불완전한 조건 지정’이라고 한다.
조합논리회로의 HDL 모델링에서는 입력의 모든 경우에 대해 출력값이 지정되어야 한다. case 문에서 입력의 모든 가능한 경우에 대하여 명시적으로 출력값이 지정되지 않으면,
출력값이 지정되지 않은 입력 조건에 대해서는 이전에 지정된 출력값을 계속 유지하는 것으로 해석될 수 있으므로 논리 합성 툴은 암시적으로 래치를 생성하게 된다. 래치가 포함된 회로는
순차논리회로가 되므로 합성된 회로는 원래 의도했던 조합논리회로로 동작하지 않게 된다.
따라서 case 문 또는 if 조건문으로 조합논리회로를 모델링하는 경우에는 모든 가능한 입력 조건들에 대해 출력값을 명시적으로 지정하거나, 또는 default 값을 지정해야 한다.

1. 원하지 않는 래치의 합성

case 문에 모든 가능한 case 항목들이 포함되지 않는 경우
if 조건문에서 else 블록이 생략되는 경우

= 순수한 조합논리회로의 합성

모든 가능한 입력 조건들에 대해 출력값을 명시적으로 지정
default 값을 지정

순차회로
현재의 입력과 현재 상태에 의해 다음 상태와 출력이 결정되는 회로
기억소자(래치, 플립플롭, SRAM)와 조합논리회로로 구성
레지스터, 주파수 분주기, 계수기(counter), 유한상태머신(Finite State Machine; FSM)

래치와 플립플롭
래치(latch) : 클록의 레벨(즉, 0 또는 1)에 따라 동작하는 저장소자 => 사용안함
플립플롭(Flip/flop) : 클록의 상승 또는 하강에지에 동기되어 동작하는 저장소자

순차회로의 모델링
always 구문만을 사용
이벤트 리스트에는 edge-sensitive이므로 posedge 또는 negedge가 있는 clock이나 reset, preset만을 사용
변수는 reg로 선언
할당문은 nonblocking(<=) 을 사용

래치(latch)
값을 저장할 수 있는 소자
가장 간단한 래치는 NOR 게이트 2개 또는 NAND 게이트 2개로 만들 수 있음
NAND 게이트가 NOR 게이트보다 레이아웃 크기가 작기 때문에 NAND 게이트로 만든 래치를 주로 설명

SR래치의 동작

SR래치의 파형

- S와 R신호는 active-low 신호로 생각한다.

S=0, R=0으로 모두 active 된 경우

→ 다시 S=0, R=0이 되었을 때 set이 될 지 reset이 될 지 모름
→ 이러한 값이 입력되지 않도록 해야 함

SR래치의 상태표(state table)

D Latch

- 일반적으로 가장 많이 사용되는 Latch

D Latch의 상태표

D Latch의 파형

- EN = 1일 때 Q는 입력 D를 그대로 출력하므로 transparent latch라고도 함

Cross-coupled inverter
- Cross-coupled inverter는 bi-stable 회로로 2가지의 값을 안정적으로 저장
- SR latch도 cross-coupled inverter를 기본으로 하고 있음

Cross-coupled inverter
- Vi1=Vo2=1, Vi2=Vo1=0 또는 Vi1=Vo2=0, Vi2=Vo1=1 일 때 안정된 상태

D latch
- Cross-coupled inverter와 transmission gate 2개를 사용하여 만들 수 있음

D Latch의 동작

래치(latch)의 사용
- 래치를 사용하여 회로를 꾸밀 때에는 주로 two phase non-overlapping clock 등을 사용
- 그러나 클럭 스큐 등의 문제가 있어 회로가 복잡해지면 사용이 쉽지 않음
- 오히려 래치는 만들지 말아야 할 것으로 인식됨
- Verilog 사용자가 조합회로를 만들었으나 실수를 하여 래치가 만들어지는 경우가 발생
→ 이를 방지하기 위해서는 모든 입력의 경우의 수에 대하여 출력을 명시하면 됨
→ 모든 경우에 대하여 명시가 어렵다면 상황에 따라 default 문장, else 문장, 출력 초기화를 사용
→ 기타 방법으로 “full_case parallel_case”를 사용하는 방법이 있으나 권장되지는 않음

Clock 신호
- Clock 신호는 주기적인 square wave 임
- Clock 신호는 의미있는 정보를 보낸다기 보다는 타이밍을 맞추기 위해 사용
- Clock에 맞추어 Latch 또는 플립플롭들이 동시에 정보를 저장

플립플롭 개요
- 플립플롭(F/F)은 Clock 신호가 변화(transition)하는 시점인 edge(에지)에 맞추어 동작 (Edge-sensitive) (Latch는 Clock 신호 값의 수준에 맞추어 동작 (Level-sensitive))
- Rising edge에 맞추어 동작하는 F/F을 rising edge triggered F/F 이라 함
- Falling edge에 맞추어 동작하는 F/F을 falling edge triggered F/F 이라 함

Classical D F/F
- 전통적인 구조의 rising edge-triggered D F/F
- C=0 이면 S=1와 R=1이므로 Q와 Q는 값을 유지
- C=0 에서 C=1이 되고 이 때 D=0이라면 오른쪽 SR래치에 S=1, R=0이 입력되어 Q=0이 됨
- 따라서 C=0에서 C=1이 되는 순간(rising edge)에 D=0의 값을 받아 Q=0이 됨

Classical D F/F
- C=0 이면 S=1와 R=1이므로 Q와 Q는 값을 유지
- C=0 에서 C=1이 되고 이 때 D=1이라면 오른쪽 SR래치에 S=0, R=1이 입력되어 Q=1이 됨
- 따라서 C=0에서 C=1이 되는 순간(rising edge)에 D=1의 값을 받아 Q=1이 됨

D F/F 상태표

Edge-triggered D F/F
- Edge-triggered D F/F = Pulse transition detector + D Latch
- Pulse transition detector가 아주 짧은 시간만 D latch의 EN=1로 하므로 마치 edge에 값을 받아들이는 동작의 효과를 냄

Pulse transition detector 회로
- 신호가 inverter를 통과할 때의 지연시간을 이용하여 짧은 시간 동안만 1이 되는 일종의 glitch(spike)를 발생시킴

Master-slave D F/F
- 앞의 2가지 D F/F과 동작이 같음
- 2개의 D latch를 사용하여 구성

Master-slave D F/F (회로의 다른 표현)

Mater-slave D F/F의 동작 매커니즘

비동기 리셋 D F/F
- 동기(Synchronous) : 클럭 신호에 맞추어 값이 변할 경우
- 비동기(Asynchronous) : 클럭 신호와 상관없이 값이 변할 경우

비동기 리셋 D F/F의 상태표

D Latch와 D F/F의 파형

Propagation delay time, 전달(전파) 지연 시간
- Tclk-q : Clock의 edge로부터 값이 출력되기까지의 시간

D Latch와 D F/F의 차이점

F/F 타이밍 고찰
- 실제로는 tclk-to-q 지연시간 때문에 q1, q0가 clock edge 보다 늦게 변하므로 clock edge 기준 앞의 값을 받아들이는 것으로 생각한다

레지스터 회로

파이프라인(Pipeline) 형태의 회로

F/F의 셋업(setup)과 홀드(hold) 시간
- Setup time : Clock의 edge 전 미리 입력 데이터가 안정되어야 하는 최소 시간
- Hold time : Clock의 edge 후 입력 데이터가 유지되고 있어야 하는 최소 시간

유한상태 머신(Finite State Machine; FSM)
- 지정된 수의 상태를 가지고 상태의 천이에 의해 출력을 생성하는 회로
- 디지털 시스템의 제어회로 구성에 사용
- Moore 머신 : 출력이 현재상태에 의해서만 결정
- Mealy 머신 : 출력이 현재상태와 입력에 의해 결정

Mealy FSM

fsm.v

`timescale 1ns / 1ps

module fsm (
    input  wire clk,
    input  wire rstn,
    input  wire done,
    output ack,
    output reg [1:0] current_state  // 상태를 외부에서도 관찰 가능하게
);

    // 상태 인코딩 정의
    parameter READY = 2'b00;
    parameter TRANS = 2'b01;
    parameter WRITE = 2'b10;
    parameter READ  = 2'b11;

    reg [1:0] next_state;

    // 순차 논리: 상태 전이
    always @(posedge clk or negedge rstn) begin
        if (!rstn)
            current_state <= READY;
        else
            current_state <= next_state;
    end

    // 조합 논리: next state 계산
    always @(current_state or done) begin
        case (current_state)
            READY:  next_state = (done == 1) ? TRANS : READY;
            TRANS:  next_state = (done == 0) ? TRANS : WRITE;
            WRITE:  next_state = (done == 1) ? READ  : WRITE;
            READ:   next_state = (done == 0) ? READ  : READY;
            default: next_state = READY;
        endcase
    end

    assign ack = 1;

endmodule

tb_fsm.v

`timescale 1ns / 1ps

module tb_fsm();

    reg clk, rstn;
    reg done;
    wire ack;
    wire [1:0] current_state;

    // ✅ 모듈 이름 일치시키기 (fsm)
    fsm dut_fsm (
        .clk(clk), 
        .rstn(rstn), 
        .done(done), 
        .ack(ack),
        .current_state(current_state)
    );

    // 클럭 생성
    initial clk = 0;
    always #5 clk = ~clk;  // 10ns 주기

    // 테스트 시나리오
    initial begin
        // 파형 출력
        $dumpfile("fsm_tb.vcd");
        $dumpvars(0, tb_fsm);

        // 초기 조건
        rstn = 0; done = 0;

        // 리셋 → READY
        #20 rstn = 1;

        // 상태 전이 시퀀스
        #10 done = 0; // READY, ack = 1
        #10 done = 1; // TRANS, ack = 1
        #10 done = 1; // TRANS 유지
        #10 done = 0; // WRITE
        #10 done = 0; // WRITE 유지
        #10 done = 1; // READ
        #10 done = 0; // READ 유지
        #10 done = 1; // READY
        #10 done = 0; // READY
        #10 done = 1; // TRANS
        #10 rstn = 0; // 다시 RESET
        #10 rstn = 1; // RESET OFF

        #20 $finish;
    end

endmodule

Moore FSM

moore_fsm.v

`timescale 1ns / 1ps

module fsm_moore (
    input  wire clk,
    input  wire rstn,
    input  wire done,
    output reg ack,                      // reg로 변경 (Moore는 상태 기반 출력)
    output reg [1:0] current_state       // 상태 관찰용 출력
);

    // 상태 인코딩
    parameter READY = 2'b00;
    parameter TRANS = 2'b01;
    parameter WRITE = 2'b10;
    parameter READ  = 2'b11;

    reg [1:0] next_state;

    // 상태 전이 (순차 논리)
    always @(posedge clk or negedge rstn) begin
        if (!rstn)
            current_state <= READY;
        else
            current_state <= next_state;
    end

    // 다음 상태 결정 (조합 논리)
    always @(*) begin
        case (current_state)
            READY:  next_state = (done) ? TRANS : READY;
            TRANS:  next_state = (done) ? WRITE : TRANS;
            WRITE:  next_state = (done) ? READ  : WRITE;
            READ:   next_state = (done) ? READY : READ;
            default: next_state = READY;
        endcase
    end

    // Moore 출력 로직: 상태에 따라 출력 결정
    always @(*) begin
        case (current_state)
            READY:  ack = 1'b0;
            TRANS:  ack = 1'b0;
            WRITE:  ack = 1'b0;
            READ:   ack = 1'b1;   // 예: READ 상태일 때만 ack=1
            default: ack = 1'b0;
        endcase
    end

endmodule

tb_moore_fsm.v

`timescale 1ns / 1ps

module tb_fsm_moore();

    reg clk, rstn;
    reg done;
    wire ack;
    wire [1:0] current_state;

    // ✅ Moore FSM DUT 인스턴스
    fsm_moore dut (
        .clk(clk),
        .rstn(rstn),
        .done(done),
        .ack(ack),
        .current_state(current_state)
    );

    // ✅ 클럭 생성: 10ns 주기 (100MHz)
    initial clk = 0;
    always #5 clk = ~clk;

    // ✅ 시뮬레이션 시나리오
    initial begin
        $dumpfile("fsm_moore_tb.vcd");  // 파형 저장 파일
        $dumpvars(0, tb_fsm_moore);

        // 초기값
        rstn = 0;
        done = 0;

        // 리셋 해제
        #20 rstn = 1;

        // 상태 전이 순서 (Moore FSM 기준)
        #10 done = 0; // READY 유지
        #10 done = 1; // TRANS로 전이
        #10 done = 1; // WRITE로 전이
        #10 done = 1; // READ로 전이
        #10 done = 1; // READY로 전이
        #10 done = 1; // TRANS로 전이
        #10 done = 0; // TRANS 유지
        #10 done = 1; // WRITE로 전이
        #10 done = 1; // READ로 전이
        #10 done = 0; // READ 유지
        #10 done = 1; // READY로 전이

        // 리셋 테스트
        #10 rstn = 0;
        #10 rstn = 1;
        #20 done = 0;

        #20 $finish;
    end

endmodule

5일차 mini Project1 - MINSEC_WATCH/STOPWATCH

호타리 — Mon, 7 Jul 2025 12:15:47 +0900

목적
Basys3 (100 MHz) FPGA 보드 위에 4자리 7-세그먼트(FND)를 장착한 디지털 인터페이스 구현

사용자 버튼 조작으로 3가지 동작 모드 전환

IDLE (CIRCLE 회전)
MINSEC_WATCH (분·초 시계)
STOPWATCH (스톱워치)

입력 BTN[3:0]
BTN[0]: 모드 전환(IDLE → WATCH → STOPWATCH → IDLE)
BTN[1]: 스톱워치 시작/정지 토글
BTN[2]: 스톱워치 초기화
BTN[3]: IDLE 모드 시 회전 속도 변경
RESET: 모든 모드에서 IDLE로 복귀

출력 FND[3:0] + SEG[6:0]
4자리 7-세그먼트 디스플레이

btn_command_controller.v

0.01MB

fnd_controller.v

0.01MB

minsec_stopwatch_top.v

0.00MB

https://github.com/SE0NGH0/AI_Verilog_HDL/tree/main/05.minsec_stopwatch_project

결과 영상

https://youtu.be/3Lz6mxAgbA8

4일차

호타리 — Fri, 4 Jul 2025 09:06:18 +0900

2025.07.03

fnd_controller.v

`timescale 1ns / 1ps

module fnd_controller(
    input clk,
    input [13:0] input_data,
    input reset,
    output [3:0] an, // 자릿수 선택
    output [7:0] seg_data
    );

    wire [1:0] w_sel;

    fnd_digit_select u_fnd_digit_select(
        .clk(clk),
        .reset(reset),
        .sel(w_sel) // 00 01 10 11
    );

    wire [3:0] w_d1, w_d10, w_d100, w_d1000;

    bin2bcd u_bin2bcd(
        .in_data(input_data),
        .d1(w_d1),
        .d10(w_d10),
        .d100(w_d100),
        .d1000(w_d1000)
    );

    fnd_display u_fnd_display(
        .digit_sel(w_sel),
        .d1(w_d1),
        .d10(w_d10),
        .d100(w_d100),
        .d1000(w_d1000),
        .an(an),
        .seg(seg_data)
    );
endmodule


// 1ms마다 fnd를 display하기 위해 digit 1자리씩 선택
// 4ms까지는 잔상효과가 있다 그 이상이면 깜빡임 현상이 발생
module fnd_digit_select(
    input clk,
    input reset,
    output reg [1:0] sel // 00 01 10 11
);

    reg [16:0] r_1ms_counter = 0;
    reg [1:0] r_digit_sel = 0;

    always @(posedge clk or posedge reset) begin
        if (reset) begin
            r_1ms_counter <= 0;
            r_digit_sel <= 0;
            sel <= 0;
        end else begin
            if (r_1ms_counter == 100_000-1) begin // 1ms
                r_1ms_counter <= 0;
                r_digit_sel <= r_digit_sel + 1;
                sel <= r_digit_sel;
            end else begin
                r_1ms_counter <= r_1ms_counter + 1;
            end
        end
    end
    
endmodule

// bin2bcd
// 입력 : bin 14bit인 이유 최대 9999까지 표현 값이 들어있기 때문
// 0 ~ 9999 
// 출력 : bcd
module bin2bcd (
    input [13:0] in_data,
    output [3:0] d1,
    output [3:0] d10,
    output [3:0] d100,
    output [3:0] d1000
);

    assign d1 = in_data % 10;
    assign d10 = (in_data / 10) % 10;
    assign d100 = (in_data / 100) % 10;
    assign d1000 = (in_data / 1000) % 10;
    
endmodule

module fnd_display (
    input [1:0] digit_sel,
    input [3:0] d1,
    input [3:0] d10,
    input [3:0] d100,
    input [3:0] d1000,
    output reg [3:0] an,
    output reg [7:0] seg
);

    reg [3:0] bcd_data;

    always @(digit_sel) begin
        case (digit_sel)
            2'b00: begin bcd_data = d1; an = 4'b1110; end
            2'b01: begin bcd_data = d10; an = 4'b1101; end
            2'b10: begin bcd_data = d100; an = 4'b1011; end
            2'b11: begin bcd_data = d1000; an = 4'b0011; end
            default: begin bcd_data = 4'b0000; an = 4'b1111; end
        endcase
    end

    always @(bcd_data) begin
        case (bcd_data)
            4'd0: seg <= 8'hC0; // 8'b11000000 : 0
            4'd1: seg <= 8'hF9; // 8'b11111001 : 1
            4'd2: seg <= 8'hA4; // 8'b10100100 : 2
            4'd3: seg <= 8'hB0; // 8'b10110000 : 3
            4'd4: seg <= 8'h99; // 8'b10011001 : 4
            4'd5: seg <= 8'h92; // 8'b10010010 : 5
            4'd6: seg <= 8'h82; // 8'b10000010 : 6
            4'd7: seg <= 8'hF8; // 8'b11111000 : 7
            4'd8: seg <= 8'h80; // 8'b10000000 : 8
            4'd9: seg <= 8'h90; // 8'b10010000 : 9
            default: seg = 8'hFF; // 8'b11111111 : all off
        endcase
    end
    
endmodule

top.v

`timescale 1ns / 1ps

module top(
    input clk,
    input reset, // btnU
    input [2:0] btn,
    input [7:0] sw,
    output [7:0] seg,
    output [3:0] an,
    output [15:0] led
    );

    fnd_controller u_fnd_controller(
        .clk(clk),
        .input_data(15'd9999),
        .reset(reset),
        .an(an),
        .seg_data(seg)
    );

endmodule

3일차

호타리 — Wed, 2 Jul 2025 18:47:23 +0900

2025.07.02

button debounce

FPGA의 버튼을 누를 때 단일 펄스만 생성하도록 Verilog에 간단한 디바운싱 회로를 구현

FPGA의 버튼에 대한 디바운싱 회로

100Mhz → 8Hz

100M / 8 = 12,500,000 cycles

12,500,000 / 2 = 6,250,000 (10us * 62500개)

FPGA의 버튼을 눌렀다 놓으면 푸시 버튼 신호에서 예기치 않은 위아래 바운스가 많이 발생

디바운싱 회로는 예상대로 바운싱 없이 CLOCK 기간을 가진 단일 pulse만 생성

디바운싱 회로의 예상 파형

btnC를 1번 눌렀다 떼면 led가 on ↔ off toggle

Debouncer

버튼 등의 스위치를 누르면 노이즈가 있는 신호가 발생

Debouncer : 기계적 진동 때문에 1이나 0으로 안정된 값을 바로 갖지 못하므로 이러한 채터(chatter) 또는 바운스(bounce)를 제거

- 값이 바뀔 때 여러 번 진동하므로 일정 시간 동안 값이 바뀌지 않는 경우 안정된 값으로 출력

- 스위치에 따라서 다르지만 보통은 10ms 정도 값이 바뀌지 않으면 값이 안정

- 신호 in이 0에서 1로 바뀔 때 1의 값이 10ms 동안 바뀌지 않으면 out을 1로 출력

- 반대의 경우도 마찬가지로 1에서 0으로 바뀔 때 in이 10ms동안 0을 유지한다면 out을 0으로 출력

https://github.com/SE0NGH0/AI_Verilog_HDL/tree/main/03.btn_debounce

0702 verilog 과제 박성호.pptx

6.13MB

2일차

호타리 — Wed, 2 Jul 2025 08:51:16 +0900

2025.07.01

면접으로 인한 수업 미참여

1일차

호타리 — Mon, 30 Jun 2025 16:51:11 +0900

2025.06.30

Vivado와 Vitis에 대해서

Vivado와 Vitis는 모두 Xilinx가 FPGA(Fiel-Programmable Gate Array) 개발을 위해 제공하는 도구. 각 도구의 주요 사용 용도와 차이는 다음과 같다.

Vivado: Xilinx의 FPGA 디자인 및 논리 합성 도구. 이 도구를 사용하면 디자인을 직접 FPGA에 구현하고, 논리를 합성하며, 타이밍 분석을 수행하고, FPGA의 물리적 배치를 정의할 수 있다. 또한, RTL(RTL, Register Transfer Level) 설계를 위한 하드웨어 설명 언어, 예를 들어 VHDL이나 Verilog를 사용하여 사용자가 직접 하드웨어 로직을 설계 할 수 있다.

Vitis : Xilinx의 소프트웨어 설계 스택으로, FPGA에서 실행되는 애플리케이션을 개발하는 데 사용. Vitis는 다양한 종류의 처리 요소(예: CPUs, GPUs, FPGAs)에 대해 단일 개발 환경을 제공. 소프트웨어 개발자가 C, C++, OpenCL, Python 등의 고수준 언어를 사용하여 FPGA에 애플리케이션을 개발하고 최적화할 수 있다. Vitis는 또한 라이브러리 세트를 제공하여 알고리즘을 빠르게 구현하고, 기계 학습, 이미지 처리, 데이터 분석 등의 고수준 도메인에 대한 최적화를 제공.

요약하면, Vivado는 FPGA의 하드웨어 설계 및 구현을 위한 도구이고, Vitis는 FPGA에서 실행되는 소프트웨어 애플리케이션을 개발하는 도구이다. 따라서 이 두 도구는 FPGA 개발의 다른 측면을 각각 다루며, 종종 함께 사용되어 하드웨어와 소프트웨어를 모두 개발하는 통합 개발 환경을 제공합니다.

Xilinx Zynq FPGA에서는 Programmable Logic (PL)과 Processing System (PS)이라는 두 가지 주요 구성 요소가 있다.

(1)Programmable Logic (PL): FPGA의 주요 기능 중 하나로, 사용자가 특정 로직 기능을 구현하기 위해 프로그래밍할 수 있는

영역이다. 이 PL 영역은 VHDL, Verilog 등의 하드웨어 설명 언어를 사용하여 구현되며, 이는 Vivado와 같은 도구를 통해 수행된다.

(2) Processing System (PS): Zynq FPGA에 내장된 고정된 하드웨어 구성 요소로서, 일반적으로 ARM 기반의 프로세서 시스템이다. PS는 운영 체제를 실행하고, 소프트웨어 애플리케이션을 실행하며, PL과 상호 작용하는 데 사용된다. 이 부분은 주로 고수준 언어(C, C++, Python 등)를 사용하여 개발하며, 이는 Vitis와 같은 도구를 통해 수행된다.

- Vivado는 주로 PL을 설계하고 구현하는 데 사용되며,

- Vitis는 PS에서 실행되는 소프트웨어를 개발하는 데 사용.

그러나 두 시스템은 서로 밀접하게 연결되어 있으며, 종종 Vivado를 사용하여 PS와 PL 사이의 인터페이스를 설정하고, Vitis를 사용하여 PS에서 실행되는 소프트웨어와 PL에서 실행되는 하드웨어 로직 간의 상호 작용을 관리한다.

HDL : Hardware Description Language

디지털 논리 회로의 문자 표현

- schematic보다 만들거나 고치기 쉬움

- HDL 설계시에는 항상 schematic을 생각해야 함

HDL은 programming languages가 아님

- 매우 비슷하게 보이지만 프로그램처럼 작성하면 안됨

- Verilog 문법은 C와 상당히 유사함

- 뛰어넘어야 할 가장 중요하고 어려운 개념

- C : 순차적 실행

- HDL : 병렬적 실행

- 컴파일 방법은 비슷함

- C : Source → 컴파일 → 실행파일

- HDL : Source → 컴파일 → 시뮬레이션 → 합성(synthesis) → Hardware

Verilog의 특징

- C언어와 유사하다

- 코딩량이 10~30% 적다

- 회사에서는 Verilog가 우세하다

- 많은 IP들이 Verilog로 되어 있다

- VHDL은 표현이 너무 엄격

System IC 설계과정

설계사양 결정

- 회로의 기능, 동작성능, 동작 주파수, 칩 면적 및 전력 소모 목표치, 시험 범주(test coverage), 설계 기간, NRE(Non-Recurring Engineering) 비용, 칩 단가 등이 포함된 설계 목표

- 설계될 시스템의 분할, 적용될 알고리즘과 아키텍처, 데이터 입/출력 및 제어 신호들의 타이밍, 입력/출력 신호의 이름과 비트 폭, 리셋 및 enable 신호, 클록 신호에 대한 정의 등을 포함

행위수준(Behavioral level) 모델링 및 검증

- 상세 설계 이전에 설계사양을 확인할 수 있도록 시스템의 전체기능을 모델링하고 검증하는 과정

- 설계사양에서 정의된 기능의 만족 여부, 입/출력 인터페이스의 호환성, 국제표준규격의 만족 여부 등을 검증

- C언어, Verilog, SystemVerilog, SystemC 등을 사용

HDL 코딩 (RTL 설계)

- RTL (Register Transfer Level) 모델링을 통한 상세 설계

- 논리합성 툴에서 합성 가능한 코드로 개발

- 합성 가능한 RTL 설계

- 모듈을 이용한 구조적 모델링

- 합성이 지원되지 않는 구문이나 파일 입/출력 구문은 사용 금지

- 최적의 하드웨어가 합성되도록 모델링

- 검증을 위한 테스트 벤치 (test bench) 작성

HDL 시뮬레이션 (기능 검증)

- RTL 모델이 설계사양을 만족하는지 확인하기 위한 검증

- 회로 내부의 지연이 고려되지 않은 기능 수준의 검증

- 회로의 기능을 정확하게 검증할 수 있는 테스트 벤치의 작성이 중요

- 테스트벤치 작성은 설계자의 능력과 숙련도가 요구됨

- 최근 시스템 복잡도가 급격히 증가함에 따라 검증 작업이 설계 과정의 병목이 됨

논리합성 (synthesis)

- RTL 수준의 HDL 코드를 게이트 수준의 논리회로로 변환하는 과정

- 합성 조건들이 명시된 제한조건과 target library가 사용됨

- Constraint

- 합성되는 회로의 목표 동작 주파수, 면적, 클록신호 사양, 입/출력 신호 사양, 환경 변수 및 설계 규칙 등 논리합성에 사용될 조건들

- Target library

- 합성에 사용되는 라이브러리

- 특정 회사의 FPGA 디바이스 또는 특정 회사의 셀 라이브러리

논리합성

논리합성 단계

- HDL 코드를 읽어 문법적인 오류를 분석하고 구문을 해석하여 논리 게이트로 변환하는 단계

- 최적화 알고리즘을 적용하여 회로를 간소화시키는 최적화 단계

- 셀 라이브러리로 매핑하는 단계

게이트 수준 검증

- 합성이 완려되면 게이트 수준의 netlist가 얻어지며 합성에 사용된 라이브러리의 특성이 합성된 회로에 반영됨

- RTL 수준 검증에서 사용되었던 테스트 벤치를 동일하게 적용하여 논리 및 타이밍을 검증

- 정적 타이밍 분석 (Static Timing Analysis; STA)

- 합성된 회로의 신호경로를 중심으로 타이밍을 분석

- 시뮬레이션 벡터가 사용되지 않음

- 레지스터의 setup time과 hold time의 위반 여부를 분석함

레이아웃 설계

- 논리합성을 통해 생성된 게이트 수중netlist를 마스크 제작에 사용될 레이아웃 도면으로 변환하는 과정

- 자동 배치/배선 툴

- 칩 제작 공정에 맞게 미리 설계된 표준 셀 라이브러리, RAM, ROM 등의 매크로 셀, I/O 패드 셀과 설계자가 지정한 타이밍 조건을 적용하여 최적화된 레이아웃 도면을 생성

Post-layout 검증

- 레이아웃으로부터 셀과 배선에 의한 지연 특성을 추출하여 타이밍 특성이 고려된 post-layout 검증

- 게이트 수준 타이밍 시뮬레이션, 레이아웃의 기생 효과를 고려한 STA, 각종 설계 규칙검사 등을 통해 설계의 정확성을 검증

RTL 수준과 Gate 수준 Verilog

HDL 기반 설계의 장점

- 설계 시간의 단축

- 초기 설계과정에서의 설계오류 수정이 용이

- 합성에 의한 회로 생성과 설계 변경이 용이

- 설계의 질 향상

- 우수하고 광범위한 하드웨어 기술 능력, 상위 수준의 설계 가능

- 다양한 설계기법의 검색에 의한 최적화 도달

- 선택적 최적화 기법을 이용한 합성 설계

- 특정 설계기술이나 공정과 무관한 설계

- 특정 ASIC 제조업체 및 구현기술과 무관한 설계 가능

- 동일한 HDL 설계의 다른 라이브러리 이용한 합성

- 신속한 하드웨어 원형화(prototyping) 가능

- 낮은 설계 비용

- 상위레벨 설계도구의 사용에 따른 설계 생산성 향상

- 설계기간의 단축에 따른 설계비용의 감소

- 설계자산의 재사용에 의한 설계비용의 감소

- 표준 HDL 및 사용자의 확대

- IEEE 표준인 동시에 미국 정부의 공인 HDL

- 전세계적으로 설계 및 설계정보 교환의 수단으로 사용이 확대

- 효율적인 설계관리

- HDL 언어의 구조적 설계 기능을 이용한 전체 설계의 기능별 분할 설계 및 설계관리 및 문서화 용이

CMOS (Complementary Metal Oxide Semiconductor)

- NMOS (N-Type Metal Oxide Semiconductor) transistors

- PMOS (P-Type Metal Oxide Semiconductor) transistors

NMOS Transistor

- Logic '1'을 gate에 가하면 'on'

- Logic '0'을 gate에 가하면 'off'

PMOS Transistor

- Logic '1'을 gate에 가하면 'off'

- Logic '0'을 gate에 가하면 'on'

CMOS 인버터

CMOS NAND 게이트

CMOS NOR 게이트

gate_test.v (and)

`timescale 1ns / 1ps // 10.222

module gate_test(
    input wire a,
    input b, // 생략하면 wire 아무런 언급 안하면 1bit
    output out
    );

    assign out = a & b;

endmodule

gate_test.v (or)

`timescale 1ns / 1ps // 10.222

module gate_test(
    input wire a,
    input b, // 생략하면 wire 아무런 언급 안하면 1bit
    output out
    );

    assign out = a | b;

endmodule

`timescale 1ns / 1ps // 10.222

module gate_test(
    input wire a,
    input wire b, // 생략하면 wire 아무런 언급 안하면 1bit
    output led0,
    output led1,
    output led2,
    output led3,
    output led4,
    output led5
    );

    assign led0 = a & b;
    assign led1 = a | b;
    assign led2 = ~(a & b);
    assign led3 = ~(a | b);
    assign led4 = a ^ b;
    assign led5 = ~a;

endmodule

gate_test.v (배열)

`timescale 1ns / 1ps // 10.222

module gate_test(
    input wire a,
    input wire b, // 생략하면 wire 아무런 언급 안하면 1bit
    output [5:0] led
    // output led0,
    // output led1,
    // output led2,
    // output led3,
    // output led4,
    // output led5
    );

    assign led[0] = a & b; // and
    assign led[1] = a | b; // or
    assign led[2] = ~(a & b); // nand
    assign led[3] = ~(a | b); // nor
    assign led[4] = a ^ b; // xor
    assign led[5] = ~a; // not a

endmodule

2일차

호타리 — Fri, 27 Jun 2025 09:18:27 +0900

2025.06.11

리눅스의 파일
- 파일은 리눅스에서 가장 근본적이고 기본적인 추상화-"Every thing is a file"
- 상호작용은 상당부분은 파일 읽기와 파일 쓰기로 발생
- 파일에 접근하려면 먼저 파일을 열어야한다 - 읽기와 쓰기 목적으로 파일열기가 가능
- 열린 파일은 고유한 fd(file descriptor)설명자를 통해 참조되며, 열린 파일과 연관된 메타 데이터와 특정 파일 자체로 다시 매핑
- Linux 커널 내에서 해당 설명자는 file descriptor(fd)로 불리는 정수(C 유형int)에 의해 처리
- fd는 사용자 공간과 공유되며 사용자 프로그램이 파일에 액세스하기 위해 직접 사용함
- Linux 시스템 프로그래밍의 대부분은 파일을 열어서 fd를 할당받고 fd를 이용하여 파일을 조작하고, 닫고 사용하는 것으로 실행된다.
- 리눅스의 표준 file descriptors(fd)

Regular 파일
- 리눅스에서 일반적으로 파일이라고 하면regular 파일을 말함
- Regular 파일은 바이트 스트림이라 부르는 선형 배열로 구성된 데이터 바이트를 담고 있음-Linux에서는 파일에 대한 추가구성 또는 형식이 지정되지 않음
- 바이트는임의의값을가질수있으며, 파일내에서어떤방식으로든구성될수있고, Linux는시스템수준에서 바이트스트림외에는파일에구조를적용하지않음
- 파일내의모든바이트를읽을수있고, 쓸수있으며, 파일내의특정바이트에서시작할수있으며, 이시작하는위치를 파일position 또는파일offset 이라고한다-파일을처음열면file offset은0 이며바이트단위로읽거나쓸때offset 값이증가함
- 파일중간에바이트를쓰면해당오프셋에있던이전바이트를덮어쓰기때문에파일중간에서부터 파일을확장할수 없으며대부분의파일쓰기는파일끝에서발생
- 파일의크기는바이트단위로측정되며 파일의크기를나타내는길이는단순히파일을구성하는선형배열의바이트수를 말함
- 동일한프로세스또는다른프로세스에서단일파일을여러번open 할수있고, 열린파일의인스턴스에고유한file descriptor(fd)가 부여됨
- 프로세는file descriptor(fd)를 공유할수있고, file descriptor는 하나이상의프로세스에서 사용될수있다
  - 커널에서제약이없기때문에사용자공간에서동기화에대한조정이필요함
- 파일은파일이름으로접근하지만 실제로는파일시스템에서 할당된고유한정수값,inode에의해참조된다
  - 할당된inode 정수값을inode number, i-number, ino 등으로부름

리눅스 파일 제어
- 리눅스파일 제어와 관련된 system call과 libraryclose / fcloseread / freadstat, lstatlink / unlink / symlinkumaskmkdir, rmdiropendir, readdir, closedir
- rename
- getcwd, chdir
- chmod, chown
- utime
- dup, dup2
- access
- write / fwrite
- open / fopen / creat
- 파일 열기(open)
  - 커널은 프로세스 별로 열린 파일을 관리-file table
  - 열린 파일은 file descriptor(fd)로 색인화됨

05.access_fixed_all.c

Mini Proejct1 - Socket Driver Arcade

호타리 — Fri, 27 Jun 2025 09:07:23 +0900

Socket Driver Arcade Project

SOCKET_DRIVER_ARCADE.pdf

0.73MB

# Socket_Driver_Arcade

실행 방법

Ubuntu 환경
1. vim lcd1602.c
2. vim Makefile
3. make -j12 ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu-
4. scp lcd1602.ko pi@ip주소:/home/pi

Raspi 환경
1. sudo insmod lcd1602.ko
2. sudo chmod 666 /dev/lcd1602
3. dmesg | tail로 lcd1602 register 확인
4. sudo mknod /dev/lcd1602 c $MAJOR $MINOR (dmesg | tail로 확인)
5. vim server_final.c
6. gcc server_final.c -o server_final
7. vim client_final.c
8. gcc client_final.c -o client_final
9. ./server_final
10. ./client_final ip주소 - 플레이어 2명 접속
11. 게임 실행

# 멀티플레이어 터미널 미니 게임, LCD1602 & LED 하드웨어 피드백

이 프로젝트는 C로 구현한 간단한 멀티플레이어 미니게임 서버·클라이언트 프로그램과, Raspberry Pi의 하드웨어(LED 및 I2C LCD1602 디스플레이)를 이용해 플레이어 점수 및 라운드 승자를 시각적으로 출력하는 예제입니다.

## 목차

* [주요 기능](#주요-기능)
* [하드웨어 구성](#하드웨어-구성)
* [소프트웨어 요구사항](#소프트웨어-요구사항)
* [프로젝트 구조](#프로젝트-구조)
* [빌드 방법](#빌드-방법)
* [사용법](#사용법)
* [코드 개요](#코드-개요)

## 주요 기능

* **3가지 미니게임**: 가위바위보, 연산 대결, 반응 속도 게임
* **두 명 동시 플레이**: TCP 클라이언트 2명이 각 라운드에 참여
* **자동 점수 집계**: 3라운드 종료 후 승/패 결과 요약
* **하드웨어 피드백**:

  * **LED**: 각 라운드별 승리 시 해당 라운드 LED(총 3개) 점등
  * **LCD1602**: 최종 점수 요약을 I2C LCD1602에 표시

## 하드웨어 구성

* **LED (GPIO 제어)**

  * 라운드1→GPIO17 (LED0)
  * 라운드2→GPIO27 (LED1)
  * 라운드3→GPIO22 (LED2)
  * 각 LED는 330Ω 저항과 함께 Raspberry Pi GND에 연결
* **I2C LCD1602 디스플레이**

  * SDA → GPIO2
  * SCL → GPIO3
  * 모듈 주소: 0x27
  * 4.7kΩ 풀업 저항 (보드 내장 또는 외부)

## 소프트웨어 요구사항

* Raspberry Pi OS (Raspbian 등)
* `gcc`, `make`, `pthread` 라이브러리
* `i2c-tools` (I2C 버스 확인 및 디버깅)
* `raspi-gpio` 유틸리티 (GPIO 제어)
* I2C 활성화:

  ```bash
  sudo raspi-config nonint do_i2c 0
  ```

## 프로젝트 구조

```
project/
├── server_final.c   # 게임 서버 및 LCD/LED 제어 (라운드별 LED + LCD)
├── client_final.c        # 게임 클라이언트 (터미널 인터페이스)
├── lcd1602.c           # I2C LCD1602 커널 모듈
└── Makefile            # 빌드 스크립트
```

## 빌드 방법

1. 프로젝트 디렉터리를 Raspberry Pi로 복사
2. 의존성 설치:

   ```bash
   sudo apt update
   sudo apt install build-essential i2c-tools raspi-gpio
   ```
3. 빌드:

   ```bash
   make -j12 ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu-
   ```

   → `server_final`, `client_final`, `lcd1602.ko` 생성

## 사용법

### 1. LCD 커널 모듈 로드

```bash
sudo insmod lcd1602.ko
sudo chmod 666 /dev/lcd1602
sudo mknod /dev/lcd1602 c $MAJOR $MINOR (dmesg | tail에서 번호 확인)
ls -l /dev/lcd1602
```

### 2. 서버 실행

```bash
sudo ./server_final
```

* 포트 10000에서 두 명의 클라이언트 연결을 대기

### 3. 클라이언트 접속

두 개의 터미널에서:

```bash
./client_final <서버_IP>
```

### 4. 하드웨어 피드백 확인

* **라운드별 LED**: 각 라운드 종료 시 플레이어1이 이긴 라운드 LED만 점등
* **LCD1602**: 3라운드 종료 후 다음 내용 표시:

  ```
  P1: X win Y lose
  P2: A win B lose
  ```

## 코드 개요

### `server_final.c`

1. **네트워크**: TCP 소켓 생성, 포트 10000 바인딩, 최대 2명 접속
2. **미니게임 로직**

   * `play_rps()`, `play_math()`, `play_react()` 함수
3. **라운드별 LED 제어**

   * `round_winners[3]`에 각 라운드 승자(0 또는 1) 저장
   * `led_per_round()` 함수에서 승자 배열 참조, `raspi-gpio`로 GPIO17/27/22 제어
4. **LCD 제어**

   * `/dev/lcd1602`에 write하여 I2C LCD1602 출력
5. **결과 전송 및 정리**

### `client_final.c`

* 서버 연결 및 게임 입력/출력 처리

### `lcd1602.c`

* I2C LCD1602 커널 모듈 (dynamic char device)

---

## 데모 동영상

아래 링크에서 프로젝트 실행 모습을 확인할 수 있습니다:

* [https://youtu.be/a2IlBgpWruA](https://youtu.be/a2IlBgpWruA)
* [https://youtube.com/shorts/zeM5-n1U8Fc](https://youtube.com/shorts/zeM5-n1U8Fc)
* [https://youtube.com/shorts/pw4d3U6k4-s](https://youtube.com/shorts/pw4d3U6k4-s)

---

핵심코드
server.c
  1. TCP 서버 초기화 및 클라이언트 연결 대기
int sock = socket(AF_INET, SOCK_STREAM, 0);
setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

struct sockaddr_in addr = { AF_INET, htons(PORT), INADDR_ANY };
bind(sock, (struct sockaddr*)&addr, sizeof(addr));
listen(sock, MAX_CLIENTS);

while (cnt < MAX_CLIENTS) {
    int cfd = accept(sock, NULL, NULL);
    client_info_t *ci = malloc(sizeof(*ci));
    ci->sockfd = cfd; ci->player_id = cnt;
    clients[cnt++] = ci;
    pthread_create(&tid, NULL, client_thread, ci);
    pthread_detach(tid);
}

 ️ 설명:
TCP 소켓 생성 후 바인딩 → 최대 2명 클라이언트 접속 대기
접속마다 개별 스레드 할당
pthread로 병렬 처리
  2. 클라이언트 스레드 진입 처리: client_thread()
void *client_thread(void *arg) {
    client_info_t *ci = arg;
    char buf[BUF_SIZE];
    snprintf(buf, sizeof(buf), "[서버] Player %d 입장\n", ci->player_id+1);
    send(ci->sockfd, buf, strlen(buf), 0);

    while (1) {
        pthread_mutex_lock(&game.lock);
        if (clients[0] && clients[1]) {
            pthread_mutex_unlock(&game.lock);
            break;
        }
        pthread_mutex_unlock(&game.lock);
        usleep(100000);
    }
    return NULL;
}

구성 요소
설명
client_info_t
각 클라이언트의 소켓 FD와 플레이어 ID 정보 저장
send()
접속 확인 메시지 전송 (Player 1 입장, Player 2 입장)
pthread_mutex
두 클라이언트 모두 연결될 때까지 락을 걸고 조건 확인
usleep(100000)
바쁜 대기를 피하기 위한 0.1초 sleep, CPU 낭비 최소화
비동기 입장 처리
→ 각 클라이언트 입장 후 별도 스레드에서 대기
Race condition 방지
→ pthread_mutex_lock()을 이용해 clients[] 접근 시 동기화
게임 진행 제어점
→ 두 명 모두 입장해야 게임 진행 가능 (main thread에서 round 시작)
클라이언트 스레드는 입장 알림 및 진입 동기화 역할만 수행
이후 게임 로직은 main thread가 직접 관리
멀티플레이 환경에서 정확한 입장 타이밍 제어를 위한 핵심 함수
  3. 게임 제어 및 통신 루프 (핵심 로직)
int (*games[3])(client_info_t*, client_info_t*) = { play_rps, play_math, play_react };
while (game.current_round < 3) {
    int r = game.current_round;
    int w = games[r](clients[0], clients[1]);
    round_winners[r] = w;
    game.scores[w]++;
    game.current_round++;
    for (int i = 0; i < MAX_CLIENTS; i++) {
        send(clients[i]->sockfd,
             i == w ? "WIN\n" : "LOSE\n",
             i == w ? 4 : 5, 0);
    }
}

 ️ 설명:
가위바위보, 연산, 반응 속도 게임을 차례로 진행
각 라운드마다 승자를 판단하고 점수 반영
클라이언트에게 WIN/LOSE 결과 전송
  4. 디바이스 연동: LCD + LED 제어
// LCD 출력용 메시지 생성
snprintf(line1, sizeof(line1), "P1:%d win %d lose", p1, 3-p1);
snprintf(line2, sizeof(line2), "P2:%d win %d lose", p2, 3-p2);
memcpy(out, line1, 16);
memcpy(out + 16, line2, 16);
lcd_write(out);  // /dev/lcd1602에 결과 출력

// LED 피드백
for (int i = 0; i < 3; i++) {
    snprintf(cmd, sizeof(cmd), "raspi-gpio set %d op %s",
             led_pins[i], round_winners[i] == 0 ? "dh" : "dl");
    system(cmd);
}


 ️ 설명:
/dev/lcd1602를 통해 LCD에 최종 점수 출력
각 라운드 결과를 GPIO LED로 표시 (승자에 따라 High/Low 제어)
raspi-gpio 명령어로 핀 출력 설정
client.c
   1. 서버 연결 초기화
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in serv = {AF_INET, htons(PORT)};
inet_pton(AF_INET, argv[1], &serv.sin_addr);
if(connect(sockfd, (struct sockaddr*)&serv, sizeof(serv)) < 0) {
    perror("connect"); exit(1);
}

 ️ 설명:
TCP 소켓 생성 (SOCK_STREAM)
서버 주소 설정 및 connect()로 연결
IP는 사용자 인자(argv[1])로 입력
  2. 게임 루프 구조 및 메시지 처리
while(fgets(buf, BUF_SIZE, fp)) {
    if(strncmp(buf, "WIN\n", 4)==0) { printf("[결과] 승리!\n"); continue; }
    if(strncmp(buf, "LOSE\n", 5)==0) { printf("[결과] 패배.\n"); continue; }
    if(strncmp(buf, "TIE\n", 4)==0) { printf("[결과] 무승부!\n"); continue; }
    ...

 ️ 설명:
서버에서 오는 문자열 메시지를 기준으로 분기 처리
결과 메시지 (WIN, LOSE, TIE)는 단순 출력
  3. 미니게임 입력 처리 (예: 가위바위보)
if(strncmp(buf, "RPS", 3)==0) {
    printf("[게임: 가위바위보] rock/paper/scissors 입력: ");
    char in[BUF_SIZE];
    fgets(in, BUF_SIZE, stdin);
    in[strcspn(in,"\n")] = '\0';
    fprintf(fp, "%s\n", in);
    fflush(fp);
}

 ️ 설명:
서버의 지시에 따라 입력 요청
사용자 입력을 줄바꿈 제거 후 서버로 전송
구조는 MATH, REACT도 유사
i2c_lcd.c
  1. 프로젝트 내 LCD 드라이버의 역할
  목적: 게임 서버 결과를 하드웨어 LCD에 출력

  위치: server 에서 write("/dev/lcd1602") 호출
→ LCD 디바이스 드라이버가 이를 처리하여 실제 I2C 전송 수행

✅ 주요 기술요소
- 문자 디바이스 드라이버
- I2C client 장치 생성
- 데이터시트 기반 LCD 제어 (4bit 모드)

  2. 드라이버 구조 개요
[사용자 공간] → echo "P1:1 P2:2" > /dev/lcd1602
                   ↓ write() 호출

[커널 공간]   → lcd_write() 함수 진입
                   ↓
                I2C 통신 (i2c_master_send)
                   ↓
[실제 하드웨어] LCD1602 

  구조 설명:
문자 디바이스 등록
유저 write() → 문자 → 커맨드 변환 → LCD로 전송
  3. 문자 디바이스 등록 과정
alloc_chrdev_region(&lcd_dev, 0, 1, "lcd1602");
cdev_init(&lcd_cdev, &lcd_fops);
cdev_add(&lcd_cdev, lcd_dev, 1);

  설명:
alloc_chrdev_region()으로 major/minor 동적 할당
cdev_add()로 write 시스템콜 연결
결과: /dev/lcd1602 자동 생성됨
  4. I2C 클라이언트 장치 등록
struct i2c_board_info info = {
    .type = "lcd1602",
    .addr = 0x27,
};
adap = i2c_get_adapter(1);
lcd_client = i2c_new_client_device(adap, &info);

  설명:
Raspberry Pi의 I2C-1 버스에서 주소 0x27의 장치 등록
이후 i2c_master_send()로 해당 장치에 데이터 전송 가능
lcd_client가 하드웨어 포인터 역할(I2C 디바이스를 나타내는 커널 구조체 포인터)
  5. LCD 초기화 시퀀스 (HD44780, 4bit)
lcd_cmd(0x33);  // 초기화
lcd_cmd(0x32);  // 4bit 모드 설정
lcd_cmd(0x28);  // 2줄, 5x8도트
lcd_cmd(0x0C);  // 화면 ON, 커서 OFF
lcd_cmd(0x06);  // 자동 커서 이동
lcd_cmd(0x01);  // 화면 clear

  설명:
HD44780의 초기화 순서를 정확히 따름
LCD1602는 실제로 4bit만 사용되므로 두 번에 나눠 전송
  6. 명령/데이터 전송 구조
void lcd_send(u8 val, u8 rs) {
    write4(val, 0);         // 상위 4비트
    write4(val << 4, rs);   // 하위 4비트
}

void write4(u8 nibble, u8 ctrl) {
    u8 data = (nibble & 0xF0) | ctrl | LCD_BACKLIGHT;
    i2c_master_send(lcd_client, &data, 1);
    pulse_enable(data);
}

  설명:
한 글자를 4bit 단위로 나눠 두 번 전송
RS=0: 커맨드, RS=1: 데이터
LCD Enable 펄스는 latch 역할
  7. write() 시스템콜 구현
char kbuf[33];
copy_from_user(kbuf, buf, len);  // 사용자 버퍼 복사

lcd_cmd(0x01); // 화면 clear
for (i = 0; i < len && i < 16; i++)
    lcd_data(kbuf[i]);
if (len > 16) {
    lcd_cmd(0xC0); // 둘째 줄로 이동
    for (i = 16; i < len && i < 32; i++)
        lcd_data(kbuf[i]);
}

  설명:
한 줄 16글자 기준
2줄(32자)까지 출력 가능
write() → 커널 복사 → i2c 전송
  8. insmod → 동작 예시 흐름
# 드라이버 삽입
$ sudo insmod lcd1602.ko

# 장치 생성 확인
$ ls /dev/lcd1602

# dmesg 로그 확인
lcd1602: char device registered (major=245, minor=0)
lcd1602: LCD initialized

  설명:
실제 리눅스 환경에서 사용자가 어떻게 접근하는지 명확히 제시
  9. 커널 모듈 exit 및 정리
void __exit lcd_exit_module(void) {
    i2c_unregister_device(lcd_client);
    cdev_del(&lcd_cdev);
    unregister_chrdev_region(lcd_dev, 1);
}

  설명:
rmmod lcd1602 시 안전하게 I2C 장치 제거
문자 디바이스 및 major 번호 반납
  10. 요약: LCD 드라이버 설계의 핵심
✅ 문자 디바이스와 I2C 통신을 커널 모듈에서 직접 구현
✅ 사용자 공간 ↔ 커널 ↔ 하드웨어 구조 완전 이해
✅ 게임 서버 결과 → 실시간 LCD 출력으로 시각화
✅ 시스템 콜 / 하드웨어 통신 / 커맨드 제어 모두 아우른 종합 설계

10일차

호타리 — Tue, 24 Jun 2025 16:57:19 +0900

2025.06.24

BMP180

i2c라이브러리를 이용해서 기압 측정

bmp180_i2c.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/i2c-dev.h>
#include <math.h>
#include <string.h>
#include <errno.h>

// BMP180 I2C 주소 및 레지스터
#define BMP180_ADDRESS           0x77
#define BMP180_REG_CAL_AC1       0xAA
#define BMP180_REG_CONTROL       0xF4
#define BMP180_REG_RESULT        0xF6
#define BMP180_CMD_READ_TEMP     0x2E
#define BMP180_CMD_READ_PRESSURE 0x34

// 보정 계수 전역 저장
static short ac1, ac2, ac3, b1, b2, mb, mc, md;
static unsigned short ac4, ac5, ac6;

static int i2c_fd;

// 함수 프로토타입
static void  read_calibration_data(void);
static unsigned int read_ut(void);
static unsigned int read_up(int oss);

// 보정 데이터 읽기
static void read_calibration_data(void) {
    unsigned char buf[22];
    if (read(i2c_fd, buf, 22) != 22) {
        perror("Failed to read calibration data");
        exit(1);
    }
    ac1 = (buf[0] << 8) | buf[1];
    ac2 = (buf[2] << 8) | buf[3];
    ac3 = (buf[4] << 8) | buf[5];
    ac4 = (buf[6] << 8) | buf[7];
    ac5 = (buf[8] << 8) | buf[9];
    ac6 = (buf[10] << 8) | buf[11];
    b1  = (buf[12] << 8) | buf[13];
    b2  = (buf[14] << 8) | buf[15];
    mb  = (buf[16] << 8) | buf[17];
    mc  = (buf[18] << 8) | buf[19];
    md  = (buf[20] << 8) | buf[21];
}

// 원시 온도 읽기
static unsigned int read_ut(void) {
    unsigned char cmd[2] = { BMP180_REG_CONTROL, BMP180_CMD_READ_TEMP };
    if (write(i2c_fd, cmd, 2) != 2) {
        perror("Failed to write temp cmd");
        exit(1);
    }
    usleep(5000);

    unsigned char reg = BMP180_REG_RESULT;
    if (write(i2c_fd, &reg, 1) != 1) {
        perror("Failed to set temp read ptr");
        exit(1);
    }

    unsigned char buf[2];
    if (read(i2c_fd, buf, 2) != 2) {
        perror("Failed to read uncomp temp");
        exit(1);
    }
    return (buf[0] << 8) | buf[1];
}

// 원시 압력 읽기
static unsigned int read_up(int oss) {
    unsigned char cmd[2] = { BMP180_REG_CONTROL,
        (unsigned char)(BMP180_CMD_READ_PRESSURE + (oss << 6)) };
    if (write(i2c_fd, cmd, 2) != 2) {
        perror("Failed to write press cmd");
        exit(1);
    }
    // OSS에 따른 대기
    switch (oss) {
        case 0: usleep(5000);  break;
        case 1: usleep(8000);  break;
        case 2: usleep(14000); break;
        case 3: usleep(26000); break;
    }

    unsigned char reg = BMP180_REG_RESULT;
    if (write(i2c_fd, &reg, 1) != 1) {
        perror("Failed to set press read ptr");
        exit(1);
    }

    unsigned char buf[3];
    if (read(i2c_fd, buf, 3) != 3) {
        perror("Failed to read uncomp press");
        exit(1);
    }
    return (((buf[0] << 16) | (buf[1] << 8) | buf[2]) >> (8 - oss));
}

int main(void) {
    const char *i2c_dev = "/dev/i2c-1";

    // I2C 버스 오픈
    if ((i2c_fd = open(i2c_dev, O_RDWR)) < 0) {
        perror("Open i2c bus");
        return 1;
    }
    if (ioctl(i2c_fd, I2C_SLAVE, BMP180_ADDRESS) < 0) {
        perror("ioctl I2C_SLAVE");
        return 1;
    }

    // 보정 데이터 읽기 위치 설정
    unsigned char start = BMP180_REG_CAL_AC1;
    if (write(i2c_fd, &start, 1) != 1) {
        perror("Set cal data ptr");
        return 1;
    }
    read_calibration_data();

    printf("BMP180 실시간 측정 시작 (Ctrl+C 또는 Ctrl+Z 로 종료)\n\n");

    while (1) {
        // 원시값 읽기
        unsigned int ut = read_ut();
        unsigned int up = read_up(3);  // 최고 해상도 OSS=3

        // 온도 계산
        long x1 = ((long)ut - ac6) * ac5 >> 15;
        long x2 = ((long)mc << 11) / (x1 + md);
        long b5 = x1 + x2;
        double temperature = ((b5 + 8) >> 4) / 10.0;  // °C

        // 압력 계산
        long b6 = b5 - 4000;
        x1 = (b2 * (b6 * b6 >> 12)) >> 11;
        x2 = (ac2 * b6) >> 11;
        long x3 = x1 + x2;
        long b3 = ((((long)ac1 * 4 + x3) << 3) + 2) >> 2;
        x1 = (ac3 * b6) >> 13;
        x2 = (b1 * (b6 * b6 >> 12)) >> 16;
        x3 = ((x1 + x2) + 2) >> 2;
        unsigned long b4 = (ac4 * (unsigned long)(x3 + 32768)) >> 15;
        unsigned long b7 = ((unsigned long)up - b3) * (50000 >> 3);
        long p;
        if (b7 < 0x80000000)
            p = (b7 * 2) / b4;
        else
            p = (b7 / b4) * 2;
        x1 = (p >> 8) * (p >> 8);
        x1 = (x1 * 3038) >> 16;
        x2 = (-7357 * p) >> 16;
        p = p + ((x1 + x2 + 3791) >> 4);

        double pressure_hpa = p / 100.0;

        printf("온도: %.2f °C    압력: %.2f hPa\n",
               temperature, pressure_hpa);

        sleep(1);
    }

    close(i2c_fd);
    return 0;
}

디바이스 드라이버 개발

bmp180.c

// SPDX-License-Identifier: GPL-2.0
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/i2c.h>
#include <linux/delay.h>
#include <linux/mutex.h>
#include <linux/sysfs.h>
#include <linux/of.h>
#include <linux/of_device.h>

#define BMP180_REG_CALIB   0xAA
#define BMP180_REG_CTRL    0xF4
#define BMP180_REG_DATA    0xF6
#define BMP180_CMD_TEMP    0x2E
#define BMP180_CMD_PRESS   0x34

struct bmp180_data {
    struct i2c_client *client;
    struct mutex      lock;
    /* Calibration coefficients */
    s16  ac1, ac2, ac3, b1, b2, mb, mc, md;
    u16  ac4, ac5, ac6;
    int  oss;
};

static int bmp180_read_calib(struct bmp180_data *d)
{
    u8 buf[22];
    int ret;

    ret = i2c_smbus_read_i2c_block_data(d->client,
                                        BMP180_REG_CALIB,
                                        sizeof(buf), buf);
    if (ret < 0)
        return ret;

    d->ac1 = (buf[0] << 8) | buf[1];
    d->ac2 = (buf[2] << 8) | buf[3];
    d->ac3 = (buf[4] << 8) | buf[5];
    d->ac4 = (buf[6] << 8) | buf[7];
    d->ac5 = (buf[8] << 8) | buf[9];
    d->ac6 = (buf[10] << 8) | buf[11];
    d->b1  = (buf[12] << 8) | buf[13];
    d->b2  = (buf[14] << 8) | buf[15];
    d->mb  = (buf[16] << 8) | buf[17];
    d->mc  = (buf[18] << 8) | buf[19];
    d->md  = (buf[20] << 8) | buf[21];
    return 0;
}

static int bmp180_read_raw_temp(struct bmp180_data *d, int *ut)
{
    int ret;
    u8 msb, lsb;

    /* Send temperature measurement command */
    ret = i2c_smbus_write_byte_data(d->client,
                                    BMP180_REG_CTRL,
                                    BMP180_CMD_TEMP);
    if (ret < 0)
        return ret;
    msleep(5);

    /* Read MSB and LSB directly from DATA registers */
    msb = i2c_smbus_read_byte_data(d->client, BMP180_REG_DATA);
    lsb = i2c_smbus_read_byte_data(d->client, BMP180_REG_DATA + 1);
    if ((int)msb < 0 || (int)lsb < 0)
        return -EIO;

    *ut = (msb << 8) | lsb;
    return 0;
}

static int bmp180_read_raw_press(struct bmp180_data *d, int *up)
{
    int ret;
    u8 msb, lsb, xlsb;

    ret = i2c_smbus_write_byte_data(d->client,
                                    BMP180_REG_CTRL,
                                    BMP180_CMD_PRESS + (d->oss << 6));
    if (ret < 0)
        return ret;
    msleep(5 + (3 << d->oss));

    msb  = i2c_smbus_read_byte_data(d->client, BMP180_REG_DATA);
    lsb  = i2c_smbus_read_byte_data(d->client, BMP180_REG_DATA + 1);
    xlsb = i2c_smbus_read_byte_data(d->client, BMP180_REG_DATA + 2);
    if ((int)msb < 0 || (int)lsb < 0 || (int)xlsb < 0)
        return -EIO;

    *up = ((msb << 16) | (lsb << 8) | xlsb) >> (8 - d->oss);
    return 0;
}

static long bmp180_calc_temp(struct bmp180_data *d, int ut, int *t)
{
    long x1 = ((long)ut - d->ac6) * d->ac5 >> 15;
    long x2 = ((long)d->mc << 11) / (x1 + d->md);
    long b5 = x1 + x2;

    *t = (b5 + 8) >> 4;  /* 0.1°C unit */
    return b5;
}

static int bmp180_calc_press(struct bmp180_data *d, int up,
                             long b5, int *p)
{
    long b6 = b5 - 4000;
    long x1 = (d->b2 * (b6 * b6 >> 12)) >> 11;
    long x2 = (d->ac2 * b6) >> 11;
    long x3 = x1 + x2;
    long b3 = ((((long)d->ac1 * 4 + x3) << d->oss) + 2) >> 2;
    x1 = (d->ac3 * b6) >> 13;
    x2 = (d->b1 * (b6 * b6 >> 12)) >> 16;
    x3 = ((x1 + x2) + 2) >> 2;
    long b4 = (d->ac4 * (unsigned long)(x3 + 32768)) >> 15;
    long b7 = ((unsigned long)up - b3) * (50000 >> d->oss);
    long p_raw = (b7 < 0x80000000 ?
                  (b7 << 1) / b4 :
                  (b7 / b4) << 1);
    x1 = (p_raw >> 8) * (p_raw >> 8);
    x1 = (x1 * 3038) >> 16;
    x2 = (-7357 * p_raw) >> 16;
    *p = p_raw + ((x1 + x2 + 3791) >> 4);

    return 0;
}

/* sysfs show functions */
static ssize_t show_temp(struct device *dev,
                         struct device_attribute *attr,
                         char *buf)
{
    struct bmp180_data *d = dev_get_drvdata(dev);
    int ut, t, ret;
    long b5;

    mutex_lock(&d->lock);
    ret = bmp180_read_raw_temp(d, &ut);
    if (ret < 0)
        goto out;
    b5 = bmp180_calc_temp(d, ut, &t);
out:
    mutex_unlock(&d->lock);

    if (ret < 0)
        return ret;
    return sprintf(buf, "%d\n", t);
}
static DEVICE_ATTR(temp, 0444, show_temp, NULL);

static ssize_t show_press(struct device *dev,
                          struct device_attribute *attr,
                          char *buf)
{
    struct bmp180_data *d = dev_get_drvdata(dev);
    int ut, up, p, ret;
    long b5;

    mutex_lock(&d->lock);
    ret = bmp180_read_raw_temp(d, &ut);
    if (ret < 0)
        goto out;
    b5 = bmp180_calc_temp(d, ut, &p);
    ret = bmp180_read_raw_press(d, &up);
    if (ret < 0)
        goto out;
    ret = bmp180_calc_press(d, up, b5, &p);
out:
    mutex_unlock(&d->lock);

    if (ret < 0)
        return ret;
    return sprintf(buf, "%d\n", p);
}
static DEVICE_ATTR(pressure, 0444, show_press, NULL);

static struct attribute *bmp180_attrs[] = {
    &dev_attr_temp.attr,
    &dev_attr_pressure.attr,
    NULL,
};
static const struct attribute_group bmp180_group = {
    .attrs = bmp180_attrs,
};

static const struct of_device_id bmp180_of_match[] = {
    { .compatible = "bosch,bmp180" },
    { /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, bmp180_of_match);

static const struct i2c_device_id bmp180_id[] = {
    { "bmp180", 0 },
    { }
};
MODULE_DEVICE_TABLE(i2c, bmp180_id);

static int bmp180_probe(struct i2c_client *client)
{
    struct bmp180_data *d;
    int ret;

    d = devm_kzalloc(&client->dev,
                     sizeof(*d), GFP_KERNEL);
    if (!d)
        return -ENOMEM;

    mutex_init(&d->lock);
    d->client = client;
    d->oss    = 0;
    i2c_set_clientdata(client, d);

    ret = bmp180_read_calib(d);
    if (ret < 0) {
        dev_err(&client->dev,
                "calibration read failed: %d\n", ret);
        return ret;
    }

    ret = sysfs_create_group(&client->dev.kobj,
                             &bmp180_group);
    if (ret)
        dev_err(&client->dev,
                "sysfs group create failed: %d\n", ret);

    dev_info(&client->dev, "BMP180 sensor probed\n");
    return ret;
}

static void bmp180_remove(struct i2c_client *client)
{
    sysfs_remove_group(&client->dev.kobj,
                       &bmp180_group);
}

static struct i2c_driver bmp180_driver = {
    .driver = {
        .name           = "bmp180",
        .of_match_table = of_match_ptr(bmp180_of_match),
    },
    .probe    = bmp180_probe,
    .remove   = bmp180_remove,
    .id_table = bmp180_id,
};
module_i2c_driver(bmp180_driver);

MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("BMP180 pressure/temperature sensor driver");
MODULE_LICENSE("GPL v2");

응용프로그램 개발

bmp180_read.c

// bmp180_read.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <dirent.h>
#include <string.h>
#include <errno.h>
#include <sys/stat.h>

#define I2C_DEV_DIR   "/sys/bus/i2c/devices"
#define TEMP_FILE     "temp"
#define PRESS_FILE    "pressure"

// 디렉토리 안에 temp와 pressure 파일이 모두 있는 첫 번째 디렉토리 검색
static int find_bmp180_dir(char *out, size_t len) {
    DIR *d = opendir(I2C_DEV_DIR);
    struct dirent *ent;
    if (!d) return -1;

    while ((ent = readdir(d)) != NULL) {
        // 디렉토리 이름이 "버스-주소" 형태인지 간단히 체크
        if (strchr(ent->d_name, '-') == NULL) 
            continue;

        char path_temp[256], path_press[256];
        snprintf(path_temp,  sizeof(path_temp),
                 I2C_DEV_DIR "/%s/" TEMP_FILE, ent->d_name);
        snprintf(path_press, sizeof(path_press),
                 I2C_DEV_DIR "/%s/" PRESS_FILE, ent->d_name);

        if (access(path_temp, R_OK) == 0 && access(path_press, R_OK) == 0) {
            snprintf(out, len, I2C_DEV_DIR "/%s", ent->d_name);
            closedir(d);
            return 0;
        }
    }

    closedir(d);
    return -1;
}

// sysfs에서 정수 읽기
static int read_int(const char *path, int *out) {
    char buf[32];
    int fd = open(path, O_RDONLY);
    if (fd < 0) return -1;
    ssize_t n = read(fd, buf, sizeof(buf)-1);
    close(fd);
    if (n <= 0) return -1;
    buf[n] = '\0';
    *out = atoi(buf);
    return 0;
}

int main(void) {
    char devdir[128];
    if (find_bmp180_dir(devdir, sizeof(devdir)) < 0) {
        fprintf(stderr, "ERROR: bmp180 모듈 디렉토리를 찾을 수 없습니다.\n");
        return 1;
    }

    char temp_path[256], press_path[256];
    snprintf(temp_path,  sizeof(temp_path),
             "%s/" TEMP_FILE,  devdir);
    snprintf(press_path, sizeof(press_path),
             "%s/" PRESS_FILE, devdir);

    printf("BMP180 기압·온도 측정 (Ctrl+C로 종료)\n\n");
    while (1) {
        int t_raw, p_raw;
        if (read_int(temp_path,  &t_raw) < 0 ||
            read_int(press_path, &p_raw) < 0) {
            fprintf(stderr,
                "센서 값 읽기 실패: %s\n",
                strerror(errno));
            return 1;
        }

        // 모듈에서 temp는 0.1°C 단위로, pressure는 Pa 단위로 리턴됩니다.
        double temp_c = t_raw / 10.0;
        double press_hpa = p_raw / 100.0;

        printf("온도: %.1f °C    압력: %.2f hPa\n",
               temp_c, press_hpa);
        sleep(1);
    }
    return 0;
}

9일차

호타리 — Mon, 23 Jun 2025 16:57:52 +0900

2025.06.23

ctags

$ sudo apt-get install universal-ctags
$ sudo apt-get install cscope

#linux 폴더에서 실행

ctags -R
cscope -R

$ vi ~/.vimrc   로 .vimrc 파일을 연다.

set hlsearch
set autoindent
set cindent
set nu
set tabstop=4 
set shiftwidth=4
set title
if has("syntax")
    syntax on
endif


if filereadable("./tags")
    set tags=./tags
elseif filereadable("../tags")
    set tags=../tags
elseif filereadable("../../tags")
    set tags=../../tags
elseif filereadable("../../../tags")
    set tags=../../../tags
elseif filereadable("../../../../tags")
    set tags=../../../../tags
else
    set tags=/home/ubuntu/project/linux/tags
endif

set tags=/home/ubuntu/project/linux/tags

set csprg=/usr/bin/cscope
"set csto=0
"set cst
set nocsverb
if filereadable("./cscope.out")
    cs add ./cscope.out
elseif filereadable("../cscope.out")
    cs add ../cscope.out
elseif filereadable("../../cscope.out")
    cs add ../../cscope.out
elseif filereadable("../../../cscope.out")
    cs add ../../../cscope.out
elseif filereadable("../../../../cscope.out")
    cs add ../../../../cscope.out
else
    cs add /home/pi/project/linux/cscope.out
endif
set csverb

정의로 가기

Ctrl-] 

Ctrl-t

gd => go definition

Ctrl+o to go back; Ctrl+i to go forward

search 현재 커서있는 단어

g + *

n : next 찾기
shift + n : previous
Ctrl+o to go back; Ctrl+i to go forward

line number로 이동

50 + shift + g

word로 이동

7 + w

[cscope 사용법]
1. 소스 디렉토리에서 ctags 생성
분석하려는 소스들의 루트 디렉토리에서 생성
```
$ ctags -R
```
- -R 이라는 옵션이 하위디렉토리까지 생각해서 만든다는거다.
- 만약에 ctags * 라고 명령어를 실행하면, 현재 디렉토리 기준으로만 ctag가 생성된다.
1. 소스 디렉토리에서 cscope.out 과 cscope.files 를 생성
즉, 내가 분석하려는 소스들의 루트 디렉토리에서 생성
```
$ cscope -R
```
ctrl + d 눌러서 빠져 나온다.
ex) 만약에 test/ 즉, test라는 폴더 안의 소스를 전부 분석하고 싶으면 cd test 로 test 폴더 들어가서 만들면 되겠지.
ex) 만약에 test/ 즉, test라는 폴더 안의 소스를 전부 분석하고 싶으면 cd test 로 test 폴더 들어가서 만들면 되겠지.

핸들러 함수 VS 콜백 함수

구분	핸들러 함수 (Handler Function)	콜백 함수 (Callback Function)
정의	특정 이벤트나 신호, 인터럽트 등이 발생했을 때 이를 처리하기 위해 등록된 함수	다른 함수에 인자로 전달되어, 특정 조건이나 이벤트 발생 시 호출되는 함수
주요 용도	주로 이벤트, 인터럽트, 신호, 사용자 입력 등을 처리하는 데 사용	비동기 처리, 이벤트 처리, 작업 완료 시 추가 동작 등 다양한 상황에서 사용
등록 방식	시스템이나 프레임워크에 핸들러로 명시적으로 등록됨 (예: 인터럽트 핸들러, 이벤트 핸들러)	함수의 인자로 직접 전달되거나, 내부적으로 등록되어 호출됨
실행 시점	해당 이벤트나 신호가 발생할 때 시스템이 자동으로 호출	해당 함수(예: 비동기 함수)의 작업이 끝나거나, 특정 조건이 만족될 때 호출
예시	인터럽트 핸들러, 이벤트 핸들러, 신호 핸들러	setTimeout, 비동기 파일 읽기, Promise.then, 이벤트 리스너 등

추가 설명

핸들러 함수는 “어떤 이벤트나 신호가 발생했을 때 그에 대응해 처리하는 역할”을 하며, 운영체제나 프레임워크에 명시적으로 등록되어 동작합니다. 예를 들어, 인터럽트 핸들러는 하드웨어 인터럽트가 발생할 때 운영체제가 호출하는 함수입니다
콜백 함수는 “다른 함수에 인자로 전달되어, 그 함수의 작업이 끝난 후에 호출되는 함수”입니다. 콜백은 비동기 처리, 이벤트 처리 등에서 널리 사용되며, 함수의 제어 흐름을 유연하게 만들 수 있습니다
관계: 콜백 함수가 핸들러로 등록되어 사용될 수도 있습니다. 예를 들어, 이벤트 핸들러를 콜백 함수로 등록하는 경우가 많습니다

요약

핸들러 함수: 이벤트나 신호가 발생할 때 시스템이 자동으로 호출하도록 등록된 함수
콜백 함수: 다른 함수에 인자로 전달되어, 특정 조건이나 이벤트가 발생할 때 호출되는 함수

둘은 비슷해 보이지만, 핸들러는 “등록”과 “자동 호출”에 초점이 있고, 콜백은 “함수 전달”과 “유연한 실행”에 초점이 있습니다.

1. list_add() / list_add_tail()

void list_add(struct list_head *new, struct list_head *head);

void list_add_tail(struct list_head *new, struct list_head *head);

• 첫 번째 인자: new → 새로 리스트에 넣을 노드

• 두 번째 인자: head → 어디 근처에 넣을지를 결정하는 기준

즉, 이 함수는 new를 어디에 “넣을지” 결정하기 때문에, new가 주체입니다.

2. list_del() / list_move()

void list_del(struct list_head *entry);

void list_move(struct list_head *entry, struct list_head *head);

• 첫 번째 인자: entry → 이미 리스트 안에 존재하는 노드 (작업의 대상)

• list_del(entry) → entry를 삭제

• list_move(entry, head) → entry를 head 바로 뒤로 이동

이 함수들은 리스트에 이미 들어 있는 노드를 조작하는 것이기 때문에, 그 노드가 첫 번째 인자로 오는 것이 자연스럽습니다.

요약 표

함수 이름 첫 번째 인자 의미 동작 주체

list_add() new 새로 추가할 노드 추가 대상 노드

list_add_tail() new 새로 추가할 노드 추가 대상 노드

list_del() entry 삭제할 노드 조작 대상 노드

list_move() entry 이동시킬 노드 조작 대상 노드

list_move_tail() entry 리스트의 끝으로 이동시킬 노드 조작 대상 노드

비유로 이해하기

• list_add(new, head)는 “new야, 너 head 뒤에 가 있어” → new가 중심

• list_del(entry)는 “entry야, 너 삭제당해” → entry가 중심

보통 이런 설계는 왜 하나요?

• 일관성 유지와 가독성 때문입니다.

• 보통 어떤 함수가 무엇을 조작할지에 따라 그 “주체”를 첫 번째 인자로 넣는 것이 일반적입니다.

bh1750.c

/* bh1750_chrdrv.c */

#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>

#define BH1750_ADDR      0x23
#define CMD_POWER_ON     0x01
#define CMD_RESET        0x07
#define CMD_CONT_HIGHRES 0x10

#define DEVICE_NAME      "bh1750"
#define CLASS_NAME       "sensor"

struct bh1750_data {
    struct i2c_client *client;
    struct cdev cdev;
};

static dev_t dev_number;
static struct class *bh1750_class;

static int bh1750_read_lux(struct i2c_client *client, char *buf)
{
    u8 data[2];
    int ret;
    u16 raw;
    u32 lux_x100;

    /* 전원 ON, 리셋, 연속 고해상도 모드 */
    i2c_smbus_write_byte(client, CMD_POWER_ON);
    i2c_smbus_write_byte(client, CMD_RESET);
    i2c_smbus_write_byte(client, CMD_CONT_HIGHRES);
    msleep(180);

    ret = i2c_smbus_read_i2c_block_data(client,
                                        CMD_CONT_HIGHRES,
                                        2, data);
    if (ret < 0)
        return ret;

    raw = (data[0] << 8) | data[1];
    lux_x100 = (raw * 1000U + 6) / 12;

    return sprintf(buf, "%u.%02u\n",
                   lux_x100 / 100,
                   lux_x100 % 100);
}

static ssize_t bh1750_char_read(struct file *filp,
                                char __user *user_buf,
                                size_t count,
                                loff_t *ppos)
{
    struct bh1750_data *d = filp->private_data;
    char tmp[16];
    int len;

    if (*ppos > 0)
        return 0; /* EOF */

    len = bh1750_read_lux(d->client, tmp);
    if (len < 0)
        return len;

    if (copy_to_user(user_buf, tmp, len))
        return -EFAULT;

    *ppos += len;
    return len;
}

static int bh1750_char_open(struct inode *inode, struct file *filp)
{
    struct bh1750_data *d = container_of(inode->i_cdev,
                                         struct bh1750_data, cdev);
    filp->private_data = d;
    return 0;
}

static const struct file_operations bh1750_fops = {
    .owner   = THIS_MODULE,
    .open    = bh1750_char_open,
    .read    = bh1750_char_read,
};

static int bh1750_probe(struct i2c_client *client)
{
    struct bh1750_data *d;
    int ret;

    /* 드라이버 데이터 할당 */
    d = devm_kzalloc(&client->dev, sizeof(*d), GFP_KERNEL);
    if (!d)
        return -ENOMEM;
    d->client = client;

    /* 캐릭터 디바이스 번호 및 클래스 생성 */
    if (!bh1750_class) {
        ret = alloc_chrdev_region(&dev_number, 0, 1, DEVICE_NAME);
        if (ret < 0)
            return ret;

        bh1750_class = class_create(CLASS_NAME);
        if (IS_ERR(bh1750_class)) {
            unregister_chrdev_region(dev_number, 1);
            return PTR_ERR(bh1750_class);
        }
    }

    /* cdev 초기화 및 등록 */
    cdev_init(&d->cdev, &bh1750_fops);
    d->cdev.owner = THIS_MODULE;
    ret = cdev_add(&d->cdev, dev_number, 1);
    if (ret) {
        class_destroy(bh1750_class);
        unregister_chrdev_region(dev_number, 1);
        return ret;
    }

    /* /dev 노드 생성 */
    device_create(bh1750_class, NULL, dev_number, NULL, DEVICE_NAME);

    i2c_set_clientdata(client, d);
    dev_info(&client->dev, "%s: registered char device /dev/%s\n",
             DEVICE_NAME, DEVICE_NAME);
    return 0;
}

static void bh1750_remove(struct i2c_client *client)
{
    struct bh1750_data *d = i2c_get_clientdata(client);

    device_destroy(bh1750_class, dev_number);
    cdev_del(&d->cdev);
    class_destroy(bh1750_class);
    unregister_chrdev_region(dev_number, 1);
}

static const struct i2c_device_id bh1750_id[] = {
    { "bh1750", 0 },
    { }
};
MODULE_DEVICE_TABLE(i2c, bh1750_id);

static struct i2c_driver bh1750_driver = {
    .driver   = { .name = "bh1750" },
    .probe    = bh1750_probe,
    .remove   = bh1750_remove,
    .id_table = bh1750_id,
};

module_i2c_driver(bh1750_driver);

MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("BH1750 I2C Light Sensor with /dev Interface");
MODULE_LICENSE("GPL");

bh1750_read.c

// bh1750_read.c (using sysfs interface, continuous measurement)
// 유저스페이스에서 sysfs로 BH1750 조도 센서 값을 계속 읽어 출력

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

int main(void) {
    const char *sysfs_path = "/dev/bh1750";
    char buf[32];

    while (1) {
        FILE *fp = fopen(sysfs_path, "r");
        if (!fp) {
            perror("fopen sysfs lux");
            return EXIT_FAILURE;
        }

        if (fgets(buf, sizeof(buf), fp) != NULL) {
            size_t len = strlen(buf);
            if (len > 0 && buf[len-1] == '\n')
                buf[len-1] = '\0';
            printf("Ambient Light: %s lux\n", buf);
        } else {
            fprintf(stderr, "Failed to read lux value from %s\n", sysfs_path);
            fclose(fp);
            return EXIT_FAILURE;
        }

        fclose(fp);
        sleep(1); // 1초 간격으로 측정
    }

    return EXIT_SUCCESS;
}

1. 모듈 등록 및 메타 정보

module_i2c_driver(bh1750_driver);

MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("BH1750 I2C Light Sensor with /dev Interface");
MODULE_LICENSE("GPL");

일반 원리
- module_init/module_exit 대신 버스 전용 매크로(module_i2c_driver) 사용
- MODULE_LICENSE("GPL") 등으로 라이선스·저자·설명 기입
bh1750_chrdrv.c
- I²C 버스에 붙는 bh1750_driver를 등록
- 모듈이 로드될 때 bh1750_probe 호출, 언로드될 때 자동으로 bh1750_remove

2. I²C 드라이버 구조체

static const struct i2c_device_id bh1750_id[] = {
    { "bh1750", 0 },
    { }
};

static struct i2c_driver bh1750_driver = {
    .driver   = { .name = "bh1750" },
    .probe    = bh1750_probe,
    .remove   = bh1750_remove,
    .id_table = bh1750_id,
};

일반 원리
- .name / .id_table로 디바이스 매칭
- .probe() / .remove() 콜백 등록
적용 예
- 디바이스 트리나 i2c_board_info에서 "bh1750"가 있으면 bh1750_probe 실행

3. 드라이버 데이터 저장

struct bh1750_data {
    struct i2c_client *client;
    struct cdev       cdev;
};

일반 원리
- 디바이스별 컨텍스트(struct)에 상태·핸들 저장
- devm_kzalloc() / i2c_set_clientdata() 로 관리
코드 내역
- client 포인터 → I²C 전송에 사용
- cdev 구조체 → 캐릭터 디바이스 등록에 사용

4. 캐릭터 디바이스 등록

/* 1) dev 번호 할당 & class 생성 */
ret = alloc_chrdev_region(&dev_number, 0, 1, DEVICE_NAME);
bh1750_class = class_create(CLASS_NAME);

/* 2) cdev 초기화 & 등록 */
cdev_init(&d->cdev, &bh1750_fops);
cdev_add(&d->cdev, dev_number, 1);

/* 3) /dev 노드 생성 */
device_create(bh1750_class, NULL, dev_number, NULL, DEVICE_NAME);

일반 원리
1. alloc_chrdev_region()
2. cdev_init() + cdev_add()
3. class_create() + device_create() → /dev/... 자동 생성
주의 사항
- class_create() 시점에 THIS_MODULE 인자는 최신 API에서 제거됨
- 성공 시 major/minor 번호가 dev_number에 채워짐

5. 파일 연산자(File Operations)

static const struct file_operations bh1750_fops = {
    .owner = THIS_MODULE,
    .open  = bh1750_char_open,
    .read  = bh1750_char_read,
};

일반 원리
- open, read, write, ioctl 등 함수 포인터 테이블
- 사용자 공간의 open("/dev/bh1750") → bh1750_char_open 호출
bh1750_chrdrv.c
- open에서 private_data에 bh1750_data 구조체 연결
- read에서 I²C 센서값을 읽어 버퍼에 복사

6. I²C 통신: SMBus API 사용

i2c_smbus_write_byte(client, CMD_POWER_ON);
i2c_smbus_write_byte(client, CMD_RESET);
i2c_smbus_write_byte(client, CMD_CONT_HIGHRES);
msleep(180);
i2c_smbus_read_i2c_block_data(client, CMD_CONT_HIGHRES, 2, data);

일반 원리
- SMBus API로 간단한 바이트 송수신 또는 블록 전송
포인트
- 센서에 명령 전송 → 측정 모드 설정
- msleep() 사용으로 커널 스케줄러에 제어 양보

7. Probe & Remove

static int bh1750_probe(struct i2c_client *client) { … }
static void bh1750_remove(struct i2c_client *client) { … }

probe() 주요 작업
1. devm_kzalloc()으로 driver data 할당
2. char device 등록 (위 4번)
3. i2c_set_clientdata() 연결
remove() 주요 작업
1. device_destroy(), cdev_del()
2. class_destroy(), unregister_chrdev_region()

8. 데이터 흐름 요약

모듈 로드 → I²C driver 등록
디바이스 바인딩 → bh1750_probe()
유저 공간: open("/dev/bh1750") → read()
커널: SMBus 통해 센서 읽고, 포맷팅 후 user buffer에 복사
모듈 언로드 → bh1750_remove()

9. 확장 학습 포인트

동기 vs 비동기 I/O: read()가 블로킹/논블로킹 지원해 보기
IOCTL 추가: 측정 모드 변경, 타이밍 조절 기능 구현
Device Tree: .of_match_table 추가하여 DT 바인딩
전력 관리: pm_runtime_* API로 센서 전원 관리

I²C 주소 스캔 결과에서

23: 0x23 주소의 디바이스가 응답했다는 의미입니다.
- i2cdetect가 “ping” 방식으로 해당 주소에 읽기 시도를 해서 ACK(응답)를 받으면 16진수 주소를 표시합니다.
UU: 그 주소(예: 0x23)에 이미 커널 드라이버가 바인딩(bind)되어 있어서, 유저 공간에서 직접 probing(읽기/쓰기)하지 않는다는 뜻입니다.
- 이미 /sys/bus/i2c/devices/…/driver 아래에 해당 디바이스가 등록되어 있으면, 안전을 위해 i2cdetect는 “사용 중(Used)” 표시로 바꿔버립니다.

요약

23	장치가 응답함	아직 커널 드라이버 미등록 상태
UU	드라이버가 바인딩됨	드라이버에서 이미 사용 중이므로 스캔하지 않음

8일차

호타리 — Mon, 23 Jun 2025 09:10:03 +0900

2025.06.20

리눅스 디바이스 드라이버 ⇒ 임베디드에서 관심 영역

역할
- 디바이스 드라이버는 하드웨어를 사용 가능하게 만들어 줄 뿐 하드웨어를 어떻게 사용 할지에 대한 결정은 응용 프로그램에게 넘겨야 한다.
고려사항
- 최대한 유연하고 많은 기능을 사용자에게 제공하려고 할 수록 디바이스 드라이버 제작자는 많은 부분을 구현 해야한다.
- 동기식, 비동기식 모두 지원할 것인가?
- 장치를 여러 번 열 것 인가?
- 정책 독립성을 제공할 것인가?
제공되는 디바이스 드라이버 유틸리티
- 디바이스 제어와 구성을 도울 목적으로 간단한 유틸리티와 디바이스 드라이버를 같이 출시하는 경우가 있다.
모놀리식 방식
- 초기 리눅스 커널은 모놀로딕 방식으로 커널에 모든 디바이스 드라이버를 포함 시켜야 했다.
- 이런 방식은 디바이스가 바뀔때마다 커널 컴파일을 다시 해야 한다.
모듈구동 방식
- 커널이 동작중인 상태에서 디바이스 드라이버를 동적으로 추가하거나 제거할 수 있는 개념으로 개발 시간을 효과적으로 단축할 수 있다.
- PCI, USB, PCMCIA에 관련된 디바이스의 PNP기능을 지원하려면 모듈 방식이 필요하다.
- 모듈 방식은 MMU가 있는 프로세서에서만 지원되며, 커널 버전이 동일해야 하는 문제가 있다.

hello_module.c

#include <linux/module.h>
#include <linux/init.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("Simple Hello World module");

static int __init hello_init(void) {
    printk(KERN_INFO "Hello World from kernel module!\n");
    return 0;
}

static void __exit hello_exit(void) {
    printk(KERN_INFO "Goodbye from kernel module!\n");
}

module_init(hello_init);
module_exit(hello_exit);

Makefile

obj-m := hello_module.o
KDIR := $(HOME)/project/linux
PWD  := $(shell pwd)

all:
	make -C $(KDIR) M=$(PWD) modules

clean:
	make -C $(KDIR) M=$(PWD) clean

make -j12 ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu-

문자 디바이스 드라이버 예제 (하드웨어 불필요)

char_dev.c

#include <linux/module.h>
#include <linux/fs.h>

#define DEV_NAME "mychardev"
static int major_num;

static ssize_t dev_read(struct file *file, char __user *buf, size_t len, loff_t *offset)
{
    const char *msg = "Hello from kernel!\n";
    return simple_read_from_buffer(buf, len, offset, msg, strlen(msg));
}

static struct file_operations fops = {
    .owner = THIS_MODULE,
    .read = dev_read,
};

static int __init char_dev_init(void)
{
    major_num = register_chrdev(0, DEV_NAME, &fops);
    if (major_num < 0) {
        pr_err("Device registration failed\n");
        return major_num;
    }
    pr_info("Major number: %d\n", major_num);
    return 0;
}

static void __exit char_dev_exit(void)
{
    unregister_chrdev(major_num, DEV_NAME);
    pr_info("char_dev removed\n");
}

module_init(char_dev_init);
module_exit(char_dev_exit);

MODULE_LICENSE("GPL");

leddrv.c

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>

#define DEV_NAME "led-driver"
#define BCM_BASE 0xFE000000
#define GPIO_BASE (BCM_BASE + 0x200000)

#define GPIO_PIN 18

static void __iomem *gpio_base;
#define INP_GPIO(g)   (*(volatile unsigned int *)(gpio_base + ((g)/10)*4) &= ~(7 << (((g)%10)*3)))
#define OUT_GPIO(g)   (*(volatile unsigned int *)(gpio_base + ((g)/10)*4) |=  (1 << (((g)%10)*3)))
#define GPIO_SET(g)   (*(volatile unsigned int *)(gpio_base + 0x1C) = (1 << g))
#define GPIO_CLR(g)   (*(volatile unsigned int *)(gpio_base + 0x28) = (1 << g))

static int major;

static ssize_t myled_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
    char kbuf[2] = {0};

    if (copy_from_user(kbuf, buf, 1)) return -EFAULT;

    if (kbuf[0] == '1') {
           GPIO_SET(GPIO_PIN);  // 켜기
           pr_info("LED ON\n");
        }
    else if (kbuf[0] == '0') {
         GPIO_CLR(GPIO_PIN);  // 끄기
        pr_info("LED OFF\n");
}

    return count;
}

static struct file_operations fops = {
    .owner = THIS_MODULE,
    .write = myled_write,
};

static int __init myled_init(void)
{
    major = register_chrdev(0, DEV_NAME, &fops);
    if (major < 0) return major;

    gpio_base = ioremap(GPIO_BASE, 0x100);
    INP_GPIO(GPIO_PIN);
    OUT_GPIO(GPIO_PIN);

    pr_info("myled loaded: /dev/%s (major %d)\n", DEV_NAME, major);
    return 0;
}

static void __exit myled_exit(void)
{
    unregister_chrdev(major, DEV_NAME);
    if (gpio_base) iounmap(gpio_base);
    pr_info("myled unloaded\n");
}

module_init(myled_init);
module_exit(myled_exit);
MODULE_LICENSE("GPL");

myled.c

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>

int main(int argc, char *argv[])
{
    int fd;
    if (argc != 2 || (argv[1][0] != '0' && argv[1][0] != '1')) {
        printf("사용법: %s 0|1\n", argv[0]);
        return 1;
    }

    fd = open("/dev/led-driver", O_WRONLY);
    if (fd < 0) {
        perror("디바이스 열기 실패");
        return 1;
    }

    write(fd, argv[1], 1);
    close(fd);
    return 0;
}

sudo mknod /dev/led-driver c $(grep led-driver /proc/devices | awk '{print $1}') 0

7일차

호타리 — Fri, 20 Jun 2025 09:41:30 +0900

2025.06.19

개발 환경 구축

리눅스에서 사용하는 컴파일러는 GCC를 주로 사용하며 디버거로 는 GDB를 사용하고 있다. 타깃 보드가 ARM 계열 프로세서를 사용하고 있으면 ARM용 GCC 컴파일러를 설치하고, 타깃 보드가 x86 계열 프로세서를 사용하고 있으면 x86용 GCC 컴파일러를 설치하여 사용하면 된다.

브이엠웨어(VMWare), 버추얼 박스(VirtualBox), Xen 하이버 바이저

크로스 개발환경 구축

개발 시스템 구축

Download Linux ISO Image - 로그인 필요 없음.

https://ubuntu.com/download/desktop

Window + VM + Linux 개발 시스템 구축

VM - memory 4GB이상, HD 30GB 이상

Download VMPlayer - 로그인 필요

https://www.vmware.com/products/desktop-hypervisor/workstation-and-fusion

VMWare Tools 설치

설치중 사용자 생성

크로스 툴 체인 설치

sudo apt update

sudo apt upgrade -y

sudo apt install git

sudo apt install crossbuild-essential-arm64 <= 64bit

sudo apt install crossbuild-essential-armhf <= 32bit

RaspberryPi 커널 컴파일

https://www.raspberrypi.com/documentation/computers/linux_kernel.html

cd project/
git clone --depth=1 --branch rpi-6.12.y  https://github.com/raspberrypi/linux

sudo apt install bc bison flex libssl-dev make libc6-dev libncurses5-dev

sudo apt install crossbuild-essential-arm64

cd linux
# .bashrc에 등록
vim .bashrc
KERNEL=kernel8  
#확인
echo $KERNEL

make ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- bcm2711_defconfig

#
vim .config
CONFIG_LOCALVERSION="-v8-MY_CUSTOM_KERNEL"

make -j12 ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- Image modules dtbs

#sudo env PATH=$PATH make -j12 ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- INSTALL_MOD_PATH=/home/ubuntu/rpi_modules modules_install
#scp -r /home/andrew/rpi_modules/lib/modules/6.12.33-v8-MY_CUSTOM_KERNEL+ pi@192.168.55.40:/lib/modules/

# rpi에 /home/kernel폴더 생성 -> 밑에 modules, root, boot폴더 생성
#오래 걸림 => tar로 압축해서 복사하는거는?
#scp -r /home/andrew/rpi_modules/lib/modules/6.12.33-v8-MY_CUSTOM_KERNEL+ pi@192.168.55.40:/home/kernel/modules/
sudo make -j12 ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- INSTALL_MOD_PATH=/home/ubuntu/kernel/modules modules_install

sudo tar cf rpi_modules.tar rpi_module/
scp -r /home/andrew/rpi_modules.tar pi@192.168.55.40:/home/pi/kernel/modules/


#sudo cp mnt/boot/$KERNEL.img mnt/boot/$KERNEL-backup.img
#sudo cp arch/arm64/boot/Image mnt/boot/$KERNEL.img
#sudo cp arch/arm64/boot/dts/broadcom/*.dtb mnt/boot/
#sudo cp arch/arm64/boot/dts/overlays/*.dtb* mnt/boot/overlays/
#sudo cp arch/arm64/boot/dts/overlays/README mnt/boot/overlays/

#linux 폴더에서 


scp -r /home/ubuntu/project/linux/arch/arm64/boot/Image pi@10.10.16.221:/home/pi/kernel/boot/$KERNEL.img
scp -r /home/ubuntu/project/linux/arch/arm64/boot/dts/broadcom/*.dtb pi@10.10.16.221:/home/pi/kernel/boot/
scp -r /home/ubuntu/project/linux/arch/arm64/boot/dts/overlays/*.dtb* pi@10.10.16.221:/home/pi/kernel/boot/overlays/
scp -r /home/ubuntu/project/linux/arch/arm64/boot/dts/overlays/README pi@10.10.16.221:/home/pi/kernel/boot/overlays/


#라즈베리파이 /home/pi/kernel/modules에서
sudo mv 6.12.33-v8-MY_CUSTOM_KERNEL+/ /lib/modules/

#라즈베리파이 
sudo cp /home/pi/kernel/boot/kernel8.img /boot/firmware/6.12.33-v8-MY_CUSTOM_KERNEL+.img

sudo cp /home/pi/kernel/boot/* /boot/
sudo cp /home/pi/kernel/boot/overlays/* /boot/overlays

# 라즈베리파이 에서 부팅시 이미지 참조위치 변경
#config.txt => /boot/firmware  in the boot partition to select your kernel:
sudo vim /boot/firmware/config.txt

[all]
kernel=6.12.33-v8-MY_CUSTOM_KERNEL+.img

sudo reboot

6일차

호타리 — Wed, 18 Jun 2025 16:19:54 +0900

2025.06.18

01.thread_create.c

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>

#define _GNU_SOURCE         /* See feature_test_macros(7) */
#include <unistd.h>
#include <sys/syscall.h>

void *thread_function(void *arg);

int main() {
	int status;
	pthread_t tid;
	pthread_attr_t attr;
	void *thread_result;
	int i;
	

	pthread_attr_init(&attr);
	status = pthread_create(&tid, &attr, thread_function, "hello thread");
	// status = pthread_create(&tid, NULL, thread_function,(void *) NULL);
	if(status !=0){
		perror("pthread_create");
		exit(1);
	}
	printf("Created Thread ID = %u\n", (unsigned int)tid);
	
	for(i=1; i<=5; i++){
		printf("Parent thread %d!!\n", i);
		sleep(1);
	}
	return 0;
}

void *thread_function(void *arg){
	int i;
	pid_t tpid, pid;
	
	pthread_t thread_id;
	thread_id = pthread_self();
	printf("Thread ID: %u\n", (unsigned int)thread_id);

	for(i=1; i<=10; i++){
		printf("\t\tChild thread[%d] - %s\n", i, (char *)arg);
		sleep(1);
	}
	return NULL;
}

02.thread_join.c

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
#include <stdint.h>

//#define _GNU_SOURCE         /* See feature_test_macros(7) */
#include <unistd.h>
#include <sys/syscall.h>

void *thread_function(void *arg);

int main() {
	int status;
	pthread_t tid;
	void *return_value;
	int i;

	
	status = pthread_create(&tid, NULL, thread_function, "hello thread\n");
	if(status !=0){
		perror("pthread_create");
		exit(1);
	}
	
	for(i=1; i<=5; i++){
		printf("Parent thread %d!!\n", i);
		sleep(1);
	}

	//
	status = pthread_join(tid, &return_value);
	if(status != 0){
		perror("pthread_join");
		exit(1);
	}
	printf("Thread joined, it returned %s\n", (char *)return_value); 
	// printf("Thread joined, it returned %ld\n", (uintptr_t)return_value); 
	
	return 0;
}

void *thread_function(void *arg){
	int i;
	pid_t * tpid;
	pthread_t * thread_id;
	
	tpid=malloc(sizeof(pid_t));
	thread_id=malloc(sizeof(pthread_t));

	*tpid = syscall(SYS_gettid);
	printf("Thread LWP: %d, Thread PID: %d\n", *tpid, getpid());
	
	*thread_id = pthread_self();
	printf("Thread ID: %lu\n", *thread_id);
	
	for(i=1; i<=10; i++){
		printf("\t\tChild thread %d\n", i);
		sleep(1);
	}
	// pthread_exit("Good Bye");
	// return (void *)1;
	pthread_exit((void *)0);
}

03.thread_exit.c

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>

//#define _GNU_SOURCE         /* See feature_test_macros(7) */
#include <unistd.h>
#include <string.h>
#include <sys/syscall.h>

void *thread_function(void *arg);

int main() {
	int status, i;
	pthread_t tid;
	void *thread_result;
	void * ret;

	status = pthread_create(&tid, NULL, thread_function, "hello thread");
	if(status !=0){
		perror("pthread_create");
		exit(1);
	}
	
	sleep(1);
	pthread_cancel(tid);
	pthread_join(tid, &ret);
	printf("RET = %ld\n", (intptr_t)ret);
	return 0;
}

void *thread_function(void *arg){
	int i;
	pid_t tpid, pid;
	int ret, unused;
#if 0
	ret = pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, &unused);
#else
	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
#endif

	for(int i=1; i<=10; i++){
		printf("\tChild thread %d\n", i);
		for(int k=0; k<300000000; k++) {}
		if(i==7){
			pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, &unused);
		}
	}
	return (void *) 5;
}

01.multi-thread.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>

void *isprime(void *arg);
void *progress(void *arg);

int main(int argc, char *argv[]){
  long long num1;
  long long num2;
  pthread_t tid1, tid2, tid3;
  pthread_attr_t attr;
  if (argc != 3) {
    fprintf(stderr, "Please supply two numbers.\n" "Example: %s 9 7\n", argv[0]);
    return 1;
  }
  num1 = atoll(argv[1]);
  num2 = atoll(argv[2]);
  
  pthread_attr_init(&attr);
  
  pthread_create(&tid3, &attr, progress, NULL);
  pthread_detach(tid3);
  
  pthread_create(&tid1, &attr, isprime, &num1);
  pthread_create(&tid2, &attr, isprime, &num2);
  
  pthread_join(tid1, NULL);
  pthread_join(tid2, NULL);
  
  pthread_attr_destroy(&attr);
  if (pthread_cancel(tid3) != 0)
     fprintf(stderr, "Couldn't cancel progress thread\n");
  printf("Done!\n");
	sleep(3);
  return 0;
}

void *isprime(void *arg){
   long long int number = *((long long*)arg);
   long long int j;
   int prime = 1;
    
   for(j=2; j<number; j++) {
      if(number%j == 0){
         prime = 0;
      }
   }
   if(prime == 1){
      printf("\n%lld is a prime number\n", number);
      return NULL;
   }else{
      printf("\n%lld is not a prime number\n", number);
      return NULL;
   }
}

void *progress(void *arg){
   while(1) {
      sleep(1);
      printf(".");
      fflush(stdout);
   }
   return NULL;
}

02.thread-return.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <stdint.h>

void *isprime(void *arg);
void *progress(void *arg);

int main(int argc, char *argv[]){
   long long num1;
   long long num2;
   pthread_t tid1;
   pthread_t tid2;
   pthread_t tid3;
   void *result1;
   void *result2;
   if (argc != 3){
      fprintf(stderr, "Please supply two numbers.\n" "Example: %s 9 7\n", argv[0]);
      return 1;
   }
   num1 = atoll(argv[1]);
   num2 = atoll(argv[2]);
   
   pthread_create(&tid3, NULL, progress, NULL);  
   pthread_detach(tid3);
   pthread_create(&tid1, NULL, isprime, &num1);
   pthread_create(&tid2, NULL, isprime, &num2);

   pthread_join(tid1, &result1);
   if ((uintptr_t)result1 == 1)
      printf("\n%lld is a prime number\n", num1);
   else
      printf("\n%lld is not a prime number\n", num1);
         
   pthread_join(tid2, &result2);   
   if ((uintptr_t)result2 == 1)
      printf("\n%lld is a prime number\n", num2);
   else
      printf("\n%lld is not a prime number\n", num2);
   
   if ( pthread_cancel(tid3) != 0 )
      fprintf(stderr, "Couldn't cancel progress thread\n");
   return 0;
}

void *isprime(void *arg) {
   long long int number = *((long long*)arg);
   long long int j;
   int prime = 1;
    
   for(j=2; j<number; j++){
      if(number%j == 0)
         prime = 0;
   }
   if(prime == 1)
      return (void*)1;
   else
      return (void*)0;
}

void *progress(void *arg){
   while(1){
      sleep(1);
      printf(".");
      fflush(stdout);
   }
   return NULL;
}

01.endian_conv.c

#include <stdio.h>
#include <arpa/inet.h>
#include <stdlib.h>

int main(int argc, char *argv[]){
	unsigned char *addr;
	unsigned int host_addr;
	unsigned int net_addr;
	
	struct sockaddr_in sock_addr;

	host_addr=0xc0a83865;
	printf("LIEELE ENDIAN = %#x\n", host_addr);
	addr = (unsigned char *)&host_addr;
	printf("MEM-ADDR = %p \t\t%#x\n", addr, *addr++);
	printf("MEM-ADDR = %p \t\t%#x\n", addr, *addr++);
	printf("MEM-ADDR = %p \t\t%#x\n", addr, *addr++);
	printf("MEM-ADDR = %p \t\t%#x\n", addr, *addr++);
	
	sock_addr.sin_addr.s_addr=host_addr;
	printf("LITTLE ENDIAN IP_ADDR = %s\n\n", inet_ntoa(sock_addr.sin_addr));
	
	net_addr=htonl(host_addr);
	printf("BIG ENDIAN = %#x\n", net_addr);
	addr = (unsigned char *)&net_addr;
	printf("MEM-ADDR = %p \t\t%#x\n", addr, *addr++);
	printf("MEM-ADDR = %p \t\t%#x\n", addr, *addr++);
	printf("MEM-ADDR = %p \t\t%#x\n", addr, *addr++);
	printf("MEM-ADDR = %p \t\t%#x\n", addr, *addr++);
	
	sock_addr.sin_addr.s_addr=net_addr;	
	printf("BIG ENDIAN IP_ADDR = %s\n", inet_ntoa(sock_addr.sin_addr));
	return 0;
}

02.ip-address.c

#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdlib.h>

int main(int argc, char * argv[]){
	in_addr_t ipaddr;
	struct sockaddr_in sock_addr; 
	struct in_addr sip_addr;
	unsigned char *addr;
	
	ipaddr=inet_network(argv[1]); 	// host_addr=inet_network("192.168.60.100");
	printf("inet_network() = %#x\n", ipaddr);
	addr = (unsigned char *)&ipaddr;
	printf("MEM-ADDR = %p ", addr);
	printf(" --> %#x ", *addr);
	printf("\t%#x %#x %#x %#x\n", *addr, *addr++, *addr++, *addr++);
	
	sock_addr.sin_addr.s_addr=inet_addr(argv[1]);
	ipaddr=sock_addr.sin_addr.s_addr;
	printf("inet_addr() = %#x\n", ipaddr);
	addr = (unsigned char *)&ipaddr;
	printf("MEM-ADDR = %p ", addr);
	printf(" --> %#x ", *addr);
	printf("\t%#x %#x %#x %#x\n", *addr, *addr++, *addr++, *addr++);
	
	inet_aton(argv[1], &sip_addr);
	printf("inet_aton() = %#x\n", sip_addr.s_addr);
	ipaddr=sip_addr.s_addr;
	addr = (unsigned char *)&ipaddr;
	printf("MEM-ADDR = %p ", addr);
	printf(" --> %#x ", *addr);
	printf("\t%#x %#x %#x %#x\n", *addr, *addr++, *addr++, *addr++);
	
	
	inet_pton(AF_INET, argv[1], &(sock_addr.sin_addr));
	printf("inet_pton() = %#x \n", sock_addr.sin_addr.s_addr);
	
	addr=inet_ntoa(sock_addr.sin_addr);
	printf("inet_ntoa() = %s\n", addr);
	return 0;
}

01.tcp_client.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netdb.h>

int main(int argc, char* argv[]){
	int sockfd;
	struct sockaddr_in sockaddr;
	char message[500];
	int bytes_recv;
	socklen_t len;
	
	if(argc!=3){
		printf("Usage : %s <IP> <port>\n", argv[0]);
		exit(1);
	}
	
	sockfd=socket(PF_INET, SOCK_STREAM, 0);
	if(sockfd == -1){
		perror("sockfdet() error!!");
		exit(1);
	}
	
	memset(&sockaddr, 0, sizeof(sockaddr));
	sockaddr.sin_family=AF_INET;
	sockaddr.sin_addr.s_addr=inet_addr(argv[1]);
	sockaddr.sin_port=htons(atoi(argv[2]));
		
	if(connect(sockfd, (struct sockaddr*)&sockaddr, sizeof(sockaddr))==-1){
		perror("connect() error!!");
		exit(1);
	}

#if 1			//It is to see the peer information in terms of name and port #
	len = sizeof(sockaddr);
	getpeername(sockfd, (struct sockaddr*)&sockaddr, &len);
	printf("Peer IP address: %s\n", inet_ntoa(sockaddr.sin_addr));
	printf("Peer port      : %d\n", ntohs(sockaddr.sin_port));
#endif
	bzero(&message, sizeof(message));
	bytes_recv=recv(sockfd, message, sizeof(message), 0);
	//bytes_recv=read(sockfd, message, sizeof(message));
	if(bytes_recv==-1){
		perror("recv() error!!");
		exit(1);
	}
	printf("Message from server: %s (%d)\n", message, bytes_recv); 
	
	printf("Press Enter to close the socket!!!");
	getchar();

	close(sockfd);
	return 0;
}

02.tcp_server.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>

int main(int argc, char *argv[]){
	int server_sfd;
	int client_sfd;

	struct sockaddr_in server_addr;
	struct sockaddr_in client_addr;
	socklen_t sock_size;
	
	int bytes_sent;
	char message[]="Welcome to Linux Network Programming!";
	int yes = 1;
	
	if(argc!=2){
		printf("Usage : %s <port>\n", argv[0]);
		exit(1);
	}
	
	server_sfd=socket(PF_INET, SOCK_STREAM, 0);
	if(server_sfd == -1){
		perror("socket() error!!");
		exit(1);
	}

#if 1
	if(setsockopt(server_sfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1){
		perror("setsockopt() error!!");
		exit(1);
	}
#endif
	
	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family=AF_INET;
	server_addr.sin_addr.s_addr=htonl(INADDR_ANY);
	server_addr.sin_port=htons(atoi(argv[1]));

	if(bind(server_sfd, (struct sockaddr*) &server_addr, sizeof(server_addr))==-1 ){
		perror("bind() error!!");
		exit(1);
	}
	
	if(listen(server_sfd, 10)==-1){
		perror("listen() error!!");
		exit(1);
	}
	
	sock_size=sizeof(client_addr);  
	client_sfd=accept(server_sfd, (struct sockaddr*)&client_addr,&sock_size);
	printf("Connected to the client port --> %d\n", htons(client_addr.sin_port));
	if(client_sfd==-1){
		perror("accept() error!!");
		exit(1);
	}
	
	bytes_sent = send(client_sfd, message, strlen(message), 0);
	//bytes_sent=write(client_sfd, message, sizeof(message));
	printf("bytes_sent : %d\n", bytes_sent);

	printf("Press Enter to close the socket!!!");
	getchar();

	close(client_sfd);	
	close(server_sfd);
	return 0;
}

01-1.tcp_client_close.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netdb.h>

/*
	This example requites to work with 02-1.tcp_server_close.c to see if what happens
	when server close the socket while waiting for recv().
	To test it, server keeps hiting the "Enter" until the socket is closed
*/

int main(int argc, char* argv[]) {
	int sockfd;
	struct sockaddr_in sockaddr;
	char message[500];
	int bytes_recv;
	
	if(argc!=3) {
		printf("Usage : %s <IP> <port>\n", argv[0]);
		exit(1);
	}
	
	sockfd=socket(PF_INET, SOCK_STREAM, 0);
	if(sockfd == -1) {
		perror("socket() error!!");
		exit(1);
	}
	
	memset(&sockaddr, 0, sizeof(sockaddr));
	sockaddr.sin_family=AF_INET;
	sockaddr.sin_addr.s_addr=inet_addr(argv[1]);
	sockaddr.sin_port=htons(atoi(argv[2]));
		
	if(connect(sockfd, (struct sockaddr*)&sockaddr, sizeof(sockaddr))==-1) {
		perror("connect() error!!");
		exit(1);
	}
	for(int i=0; i<5; i++) {
		bzero(&message, sizeof(message));
		bytes_recv=recv(sockfd, message, sizeof(message), 0);
	//bytes_recv=read(sockfd, message, sizeof(message));
		if(bytes_recv==-1)	{
			perror("recv() error!!");
			exit(1);
	}
	if(bytes_recv == 0){
		printf("socket is closed by the other end!!!\n");
		break;
	}
		printf("Message from server: %s \n", message); 
	}
	
	close(sockfd);
	return 0;
}

/*
* while waiting for new message using recv, client may be able to detect 
* the lost of connection when a server close the socket.
*/

02-1.tcp_server_close.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>

/*
	This example may work together with 01.tcp_client.c 
	and the client is waiting for server to close the socket fibytes_sent
*/

int main(int argc, char *argv[]) {
	int server_sfd;
	int client_sfd;

	struct sockaddr_in server_addr;
	struct sockaddr_in client_addr;
	socklen_t client_addr_size;
	
	int bytes_sent;

	char message[]="Welcome to Linux Network Programming!";

	int yes = 1;
	
	if(argc!=2) {
		printf("Usage : %s <port>\n", argv[0]);
		exit(1);
	}
	
	server_sfd=socket(PF_INET, SOCK_STREAM, 0);
	if(server_sfd == -1) {
		perror("socket() error!!");
		exit(1);
	}

#if 1
	if(setsockopt(server_sfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) {
		perror("setsockopt() error!!");
		exit(1);
	}
#endif
	
	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family=AF_INET;
	server_addr.sin_addr.s_addr=htonl(INADDR_ANY);
	server_addr.sin_port=htons(atoi(argv[1]));

	if(bind(server_sfd, (struct sockaddr*) &server_addr, sizeof(server_addr))==-1 )	{
		perror("bind() error!!");
		exit(1);
	}
	
	if(listen(server_sfd, 5)==-1)	{
		perror("listen() error!!");
		exit(1);
	}
	
	client_addr_size=sizeof(client_addr);  
	client_sfd=accept(server_sfd, (struct sockaddr*)&client_addr,&client_addr_size);
	printf("Connected to the client port --> %d\n", htons(client_addr.sin_port));
	if(client_sfd==-1) {
		perror("accept() error!!");
		exit(1);
	}
	
	bytes_sent = send(client_sfd, message, strlen(message), 0);
	printf("bytes_sent : %d\n", bytes_sent);
	//write(client_sfd, message, sizeof(message));
	if(bytes_sent == -1){
		printf("Socket is closed by the other end!!!\n");
		close(client_sfd);	
		close(server_sfd);
	}
	
	printf("Enter to send...");
	getchar();
	
	bytes_sent = send(client_sfd, message, sizeof(message), 0);
	printf("bytes_sent1 : %d\n", bytes_sent);
	//write(client_sfd, message, sizeof(message));
	if(bytes_sent == 0){
		printf("Socket1 is closed by the other end!!!\n");
		close(client_sfd);	
		close(server_sfd);
	}

	printf("Enter to send...");
	getchar();

	bytes_sent = send(client_sfd, message, sizeof(message), 0);
	printf("bytes_sent2 : %d\n", bytes_sent);
	//send() doesn't return 0 when the socket is not available due to close
	if(bytes_sent == -1){
		printf("Socket2 is closed by the other end!!!\n");
		close(client_sfd);	
		close(server_sfd);
	}
	
#if 1
	printf("Enter to close the socket!!!");
	getchar();
#endif
	close(client_sfd);	
	close(server_sfd);
	
	return 0;
}

02-1.tcp_server_sigpipe.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/wait.h>

/*
	This example is to demonstrate how to detect lost of the socket connection 
	by using signal SIGPIPE which will be sent to the application when send() is failed 
	when socket is closed by the client
*/

int server_sfd;
int client_sfd;

void handler(int signo) {
	int ret;
	int status;
	
	printf("Server detected the connection lost by receiving signal(%d)\n", signo);
	close(client_sfd);	
	close(server_sfd);	
	printf("Sockets closed -----\n");
	
}

int main(int argc, char *argv[]) {
	struct sockaddr_in server_addr;
	struct sockaddr_in client_addr;
	socklen_t sock_size;

	char message[]="Welcome to Linux Network Programming!";

	int yes = 1;
	
	if(argc!=2) {
		printf("Usage : %s <port>\n", argv[0]);
		exit(1);
	}
	
	signal(SIGPIPE, handler);
	
	server_sfd=socket(PF_INET, SOCK_STREAM, 0);
	if(server_sfd == -1){
		perror("socket() error!!");
		exit(1);
	}

	if(setsockopt(server_sfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1){
		perror("setsockopt() error!!");
		exit(1);
	}
	
	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family=AF_INET;
	server_addr.sin_addr.s_addr=htonl(INADDR_ANY);
	server_addr.sin_port=htons(atoi(argv[1]));

	if(bind(server_sfd, (struct sockaddr*) &server_addr, sizeof(server_addr))==-1 ) {
		perror("bind() error!!");
		exit(1);
	}
	
	if(listen(server_sfd, 5)==-1) {
		perror("listen() error!!");
		exit(1);
	}
	
	sock_size=sizeof(client_addr);  
	client_sfd=accept(server_sfd, (struct sockaddr*)&client_addr,&sock_size);
	printf("Connected to the client port --> %d\n", htons(client_addr.sin_port));
	if(client_sfd==-1){
		perror("accept() error!!");
		exit(1);
	}
	
	for(int i=0; i<10; i++){
		send(client_sfd, message, sizeof(message), 0);
		//write(client_sfd, message, sizeof(message));
		sleep(1);
	}
	
	return 0;
}

/*
* When server is tring to send a packet and the connection is closed by client,
* the kernel may detect it and deliver a signal of SIGPIPE to the server process. 
*/

01.hello_client.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>

int main(int argc, char *argv[]){
	int sockfd;
	struct sockaddr_in sockaddr;
	socklen_t sock_size;
	int bytes_sent;

	char message1[]="Hello world ";
	char message2[]="Good morning ";
	char message3[]="I am a few good man";

	if(argc!=3) {
		printf("Usage : %s <IP> <port>\n", argv[0]);
		exit(1);
	}
	
	sockfd=socket(PF_INET, SOCK_STREAM, 0);
	if(sockfd == -1) {
		perror("socket() error!!");
		exit(1);
	}

	memset(&sockaddr, 0, sizeof(sockaddr));
	sockaddr.sin_family=AF_INET;
	sockaddr.sin_addr.s_addr=inet_addr(argv[1]);
	sockaddr.sin_port=htons(atoi(argv[2]));

	if(connect(sockfd, (struct sockaddr*)&sockaddr, sizeof(sockaddr))==-1) {
		perror("connect() error!!");
		exit(1);
	}
	
	bytes_sent = send(sockfd, message1, strlen(message1), 0);
	printf("bytes_sent1 = %d\n", bytes_sent);
	bytes_sent = send(sockfd, message2, strlen(message2), 0);
	printf("bytes_sent2 = %d\n", bytes_sent);
	bytes_sent = send(sockfd, message3, strlen(message3), 0);
	printf("bytes_sent3 = %d\n", bytes_sent);

	close(sockfd);
	return 0;
}

02.hello_server.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>

int main(int argc, char* argv[]){
	int server_sfd, client_sfd;
	struct sockaddr_in server_addr, client_addr;
	socklen_t sock_size;
	char message[128];					//should be big enough to place the entire tcp_rx_buf
	int bytes_recv=0, idx=0;
	char t_rxbuf[20];					//should be enough to place the receive() size
	int yes = 1;
	
	if(argc!=2){
		printf("Usage : %s <port>\n", argv[0]);
		exit(1);
	}
	
	server_sfd=socket(PF_INET, SOCK_STREAM, 0);
	if(server_sfd == -1)	{
		perror("socket() error!!");
		exit(1);
	}

	if(setsockopt(server_sfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1){
		perror("setsockopt() error!!");
		exit(1);
	}

	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family=AF_INET;
	server_addr.sin_addr.s_addr=htonl(INADDR_ANY);
	server_addr.sin_port=htons(atoi(argv[1]));
	
	if(bind(server_sfd, (struct sockaddr*) &server_addr, sizeof(server_addr))==-1 ) { 
		perror("bind() error!!");
		exit(1);
	}
	
	if(listen(server_sfd, 5)==-1) {
		perror("listen() error!!");
		exit(1);
	}
	
	sock_size=sizeof(client_addr);  
	client_sfd=accept(server_sfd, (struct sockaddr*)&client_addr,&sock_size);
	if(client_sfd==-1) {
		perror("accept() error!!");
		exit(1);
	}

	bzero(&message, sizeof(message));
#if 0
	bytes_recv=recv(client_sfd, message, sizeof(message), 0);
#else
	while( bytes_recv=recv(client_sfd, &message[idx], 8, 0) ) {
		printf("Receiving index %d(%d)\n", idx, bytes_recv);
		if(bytes_recv == 0) {
			break;
		} else {
			memset(t_rxbuf, 0, sizeof(t_rxbuf));
			strncpy(t_rxbuf, &message[idx], bytes_recv);			
			printf("recv ok(%d:%s)\n", idx, t_rxbuf);
			idx += bytes_recv;
		}
		bytes_recv += bytes_recv;
	}
#endif
	
	printf("Message from %s: %s\n", inet_ntoa(client_addr.sin_addr), message);  
	close(client_sfd);
	close(server_sfd);
	return 0;
}

01.mytcpclient.c

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>

int main(int argc, char *argv[]){
	int sockfd, bytes_recv; 
	struct sockaddr_in sockaddr;
	char tx_buf[128], rx_buf[128];
	int i;

	if(argc != 2){
		fprintf(stderr, "usage : client serverip \n");
		exit(1);
	}

	//socket open
	if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
		perror("socket() error");
		exit(1);
	}

	sockaddr.sin_family = AF_INET;
	sockaddr.sin_port = htons(10000);
	sockaddr.sin_addr.s_addr = inet_addr(argv[1]);    
	/*  sockaddr.sin_addr.s_addr = inet_addr("70.12.117.90");  */
	memset(&(sockaddr.sin_zero), '\0',8);

	printf("[ %s ]\n", inet_ntoa(sockaddr.sin_addr));

	//connection request to server
	if(connect(sockfd, (struct sockaddr *)&sockaddr, sizeof(struct sockaddr)) == -1){
		perror("connect() error");
		exit(1);
	}
	
	for(i=1; i<=10; i++) {
		memset(tx_buf, 0, sizeof(tx_buf));
		memset(rx_buf, 0, sizeof(rx_buf));
		sprintf(tx_buf, "Hello_%d server(from %d)!!\n", i, getpid());
		//messge send to server
		if(send(sockfd, tx_buf, strlen(tx_buf)+1, 0) == -1) 
			perror("send");
		//message rx wait from server
		if((bytes_recv = recv(sockfd, rx_buf, sizeof(rx_buf), 0)) == -1){
			perror("recv");
			exit(1);
		}
		printf("----->Client Received : %s", rx_buf);
		sleep((getpid()+i)%5);
	}
	//close socket
	close(sockfd);
	return 0;
}

02.mytcpserver_fork_wrong.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>   
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>   
#include <sys/wait.h>

int main(void) {
	int server_sfd, client_sfd, bytes_recv;
	struct sockaddr_in server_addr;
	struct sockaddr_in client_addr;
	int sock_size;
	int yes = 1;
	char tx_buf[128], rx_buf[128];
	int i;

	if((server_sfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
		perror("socket() error");
		exit(1);
	}

	if(setsockopt(server_sfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) {
		perror("setsockopt() error");
		exit(1);
	}
	
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(10000); //server port number setting
	server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	memset(&(server_addr.sin_zero), '\0', 8);

	//server ip & port number setting
	if(bind(server_sfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1) {
		perror("bind() error");
		exit(1);
	}

	//client backlog setting
	if(listen(server_sfd, 5) == -1) {
		perror("listen() error");
		exit(1);
	}

	while(1) {
		sock_size = sizeof(struct sockaddr_in);

		//wait for client request
		if((client_sfd = accept(server_sfd, (struct sockaddr *)&client_addr, &sock_size)) == -1) {
			perror("accept() error");
			continue;
		}

		printf("server : got connection from %s \n", inet_ntoa(client_addr.sin_addr));

		if(!fork()){
			close(server_sfd);
			for(i=1; ; i++) {
				memset(tx_buf, 0, sizeof(tx_buf));
				memset(rx_buf, 0, sizeof(rx_buf));
				//wait for rx data from client	
				if((bytes_recv = recv(client_sfd, rx_buf, sizeof(rx_buf), 0)) == -1){
					perror("recv");
					exit(1);
				}
				if(bytes_recv == 0) 
					break;	
				printf("Server Rx(%d) : %s", getpid(), rx_buf);
				sprintf(tx_buf, "Hi_%d, client(from %s)~~\n", i, inet_ntoa(server_addr.sin_addr));
				//send data to client
				if(send(client_sfd, tx_buf, strlen(tx_buf)+1, 0) == -1) perror("send");	
			}
			printf("Server(%d): Client Connection Socket Closed!!\n", getpid());
			//close client socket connection		
			close(client_sfd);
			exit(0);
		}
		close(client_sfd);	//parent close the client socket as they are being servered by child
		waitpid(-1, NULL, WNOHANG);
	}
	return 0;
}

02-1.mytcpserver_fork_well.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>   
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>   
#include <sys/wait.h>

/* 
	Original example code has Zombie process left behind.
	In order to get rid of those Zombie process, it is mandatory, in this example, 
	to hand signal SIGCHLD which would be received when a child process is dead.
*/

void handler(int signo) {
	int ret;
	int status;
	
	printf("Signal Handler starts -----\n");
	ret = waitpid(-1, &status, WNOHANG);
	if(ret == 0) {
		printf("PID %d child process is dead\n", ret);
		// break;
	}
	if(ret == -1 && errno == ECHILD) {
		printf("No Child --\n");
		// break;
	}
	if(ret == -1) {
		perror("child waitpid");
		abort();
	}
	printf("PID %d child process is dead\n", ret);
	printf("Signal Handler ends -----\n");
}

int main(void) {
	int server_sfd, client_sfd, bytes_recv;
	struct sockaddr_in server_addr;
	struct sockaddr_in client_addr;
	int sock_size;
	int yes = 1;
	char tx_buf[128], rx_buf[128];
	int i;
	
	signal(SIGCHLD, handler);

	if((server_sfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
		perror("socket() error");
		exit(1);
	}

	if(setsockopt(server_sfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) {
		perror("setsockopt() error");
		exit(1);
	}
	
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(10000); //server port number setting
	server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	memset(&(server_addr.sin_zero), '\0', 8);

	//server ip & port number setting
	if(bind(server_sfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1) {
		perror("bind() error");
		exit(1);
	}

	//client backlog setting
	if(listen(server_sfd, 5) == -1) {
		perror("listen() error");
		exit(1);
	}

	while(1) {
		
		sock_size = sizeof(struct sockaddr_in);

		//wait for client request
		if((client_sfd = accept(server_sfd, (struct sockaddr *)&client_addr, &sock_size)) == -1) {
			perror("accept() error");
			continue;
		}

		printf("server : got connection from %s \n", inet_ntoa(client_addr.sin_addr));

		if(!fork())	{
			close(server_sfd);
			for(i=1; ; i++){
				memset(tx_buf, 0, sizeof(tx_buf));
				memset(rx_buf, 0, sizeof(rx_buf));
				//wait for rx data from client	
				if((bytes_recv = recv(client_sfd, rx_buf, sizeof(rx_buf), 0)) == -1) {
					perror("recv");
					exit(1);
				}
				if(bytes_recv == 0) 
					break;	
				printf("Server Rx(%d) : %s", getpid(), rx_buf);
				sprintf(tx_buf, "Hi_%d, client(from %s)~~\n", i, inet_ntoa(server_addr.sin_addr));
				//send data to client
				if(send(client_sfd, tx_buf, strlen(tx_buf)+1, 0) == -1) 
					perror("send");	
			}
			printf("Server(%d): Client Connection Socket Closed!!\n", getpid());
			//close client socket connection		
			close(client_sfd);
			exit(0);
		}
	}
	return 0;
}

02-2.mytcpserver_nonblock.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>   
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>   
#include <sys/wait.h>
#include <pthread.h>

void * server_function (void * args) {
	int bytes_recv;
	int sockfd = *((int*)args);
	char tx_buf[128], rx_buf[128];
	
	for(int i=1; ; i++) {
		memset(tx_buf, 0, sizeof(tx_buf));
		memset(rx_buf, 0, sizeof(rx_buf));
		if((bytes_recv = recv(sockfd, rx_buf, sizeof(rx_buf), 0)) == -1){
			perror("recv");
			exit(1);
		}
		if(bytes_recv == 0) break;	
		printf("Server Rx(%d) : %s", getpid(), rx_buf);
		sprintf(tx_buf, "Hi_%d, client(from %d)~~\n", i, getpid());
		if(send(sockfd, tx_buf, strlen(tx_buf)+1, 0) == -1) perror("send");	
	}
	printf("Server(%d): Client Connection Socket Closed!!\n", getpid());
	close(sockfd);
	return NULL;
}

int main(void){
	int server_sfd, client_sfd;
	struct sockaddr_in server_addr;
	struct sockaddr_in client_addr;
	int sock_size;
	int yes = 1;
	int i;
	pthread_t tid;

	if((server_sfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
		perror("socket() error");
		exit(1);
	}

	if(setsockopt(server_sfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1){
		perror("setsockopt() error");
		exit(1);
	}
	
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(10000); //server port number setting
	server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	memset(&(server_addr.sin_zero), '\0', 8);

	//server ip & port number setting
	if(bind(server_sfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1){
		perror("bind() error");
		exit(1);
	}

	//client backlog setting
	if(listen(server_sfd, 5) == -1){
		perror("listen() error");
		exit(1);
	}

	while(1){
		sock_size = sizeof(struct sockaddr_in);

		//wait for client request
		if((client_sfd = accept(server_sfd, (struct sockaddr *) &client_addr, &sock_size)) == -1){
			perror("accept() error");
			continue;
		}

		printf("server : got connection from %s \n", inet_ntoa(client_addr.sin_addr));
		pthread_create(&tid, NULL, server_function, &client_sfd);
	}
	return 0;
}

02-2.mytcpserver_thread.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>   
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>   
#include <sys/wait.h>
#include <pthread.h>

void * server_function (void * args) {
	int bytes_recv;
	int sockfd = *((int*)args);
	char tx_buf[128], rx_buf[128];
	
	for(int i=1; ; i++) {
		memset(tx_buf, 0, sizeof(tx_buf));
		memset(rx_buf, 0, sizeof(rx_buf));
		if((bytes_recv = recv(sockfd, rx_buf, sizeof(rx_buf), 0)) == -1){
			perror("recv");
			exit(1);
		}
		if(bytes_recv == 0) break;	
		printf("Server Rx(%d) : %s", getpid(), rx_buf);
		sprintf(tx_buf, "Hi_%d, client(from %d)~~\n", i, getpid());
		if(send(sockfd, tx_buf, strlen(tx_buf)+1, 0) == -1) perror("send");	
	}
	printf("Server(%d): Client Connection Socket Closed!!\n", getpid());
	close(sockfd);
	return NULL;
}

int main(void){
	int server_sfd, client_sfd;
	struct sockaddr_in server_addr;
	struct sockaddr_in client_addr;
	int sock_size;
	int yes = 1;
	int i;
	pthread_t tid;

	if((server_sfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
		perror("socket() error");
		exit(1);
	}

	if(setsockopt(server_sfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1){
		perror("setsockopt() error");
		exit(1);
	}
	
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = htons(10000); //server port number setting
	server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	memset(&(server_addr.sin_zero), '\0', 8);

	//server ip & port number setting
	if(bind(server_sfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1){
		perror("bind() error");
		exit(1);
	}

	//client backlog setting
	if(listen(server_sfd, 5) == -1){
		perror("listen() error");
		exit(1);
	}

	while(1){
		sock_size = sizeof(struct sockaddr_in);

		//wait for client request
		if((client_sfd = accept(server_sfd, (struct sockaddr *) &client_addr, &sock_size)) == -1){
			perror("accept() error");
			continue;
		}

		printf("server : got connection from %s \n", inet_ntoa(client_addr.sin_addr));
		pthread_create(&tid, NULL, server_function, &client_sfd);
	}
	return 0;
}

5일차

호타리 — Tue, 17 Jun 2025 16:51:29 +0900

2025.06.17

07.myexecl.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <wait.h>

int main(void) {
	pid_t pid;
	int status;
	switch (pid=fork()) {
		case -1:
			perror("fork failed");
			break;
		case 0:				// child process
			printf("CHILD PROCESS : %d\n", getpid());
			if(execl("./01.mytask", "01.mytask", "10", (char *) 0) == -1)
				perror("execl");
		default:
			sleep(1);
			system("ps -lf");
			pid = wait(&status);
			printf("parent : waited (%d) and completed!\n", pid);
			exit(0);
	}
	return 0;
}

07-1.myexecl.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <wait.h>

void handler(int signo) {
	pid_t exit_pid;
	printf("\nhandler_pid [%d], handler_ppid [%d]\n", getpid(), getppid());
	exit_pid = waitpid(-1, NULL, WNOHANG);
	if(exit_pid == -1)
		perror("waitpid");
	else
		printf("Terminated child PID = %d\n", exit_pid);
}

int main(void) {
	pid_t pid;
	
	signal(SIGCHLD, handler);
	switch (pid=fork()) {
		case 0:				// child process
			printf("CHILD PROCESS : %d\n", getpid());
			char *args[] = {"01.mytask", "10", NULL};
			if(execv("./01.mytask", args) == -1)
				perror("execv");
			exit(100);
		default:
			getchar();
	}
	return 0;
}

08.mydaemon.c

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <syslog.h>
#include <fcntl.h>
#include <stdlib.h>
#include <time.h>
#include <syslog.h>

int main(void) {
	pid_t pid, sid;
	int fd, fd0, fd1, fd2;
	time_t now;
	
	if((pid = fork()) != 0) {
		exit(0);																							//parent exit
	}
	sid=setsid();
	umask(0022); 			
	chdir("/");
	close(STDIN_FILENO); close(STDOUT_FILENO); close(STDERR_FILENO);
	fd = open("/tmp/mydaemon.log", O_WRONLY | O_CREAT | O_TRUNC, 0666);
	dup2(fd, 1); dup2(fd, 2);
	while(1){
		time(&now);
		fprintf(stdout, "Mydaemon alive at %s", ctime(&now));
		fflush(stdout); 																			/* flush the stream */
		sleep(5);
	}
	return 0;
}

09.mydaemon.service

[Unit]
Description=Mydaemon testing via by systemd
[Service]
ExecStart=/usr/local/bin/09.mydaemon-systemd
Restart=on-failure
Type=forking
PIDFile=/run/mydaemon.pid
[Install]
WantedBy=multi-user.target

09.mydaemon-systemd.c

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <syslog.h>
#include <fcntl.h>
#include <stdlib.h>
#include <time.h>
#include <signal.h>

void sigHandler(int sig);

int fd;
const char pidfile[] = "/run/mydaemon.pid";
const char daemonlog[]="/tmp/mydaemon.log";

int main(int argc, char * argv[]) {
	pid_t pid, sid;
	time_t now;
	struct sigaction action;
		
	if((pid = fork()) != 0) { 
		exit(0);									//parent exit and child continues
	}
	
	if((pid = fork()) !=0 ) {		//double forking
		exit(0);					
	}
	
	sid=setsid();
	if ((fd = open(pidfile, O_RDWR | O_CREAT)) == -1){
			perror("Can't open file for writing");
			return 1;
	}
	dprintf(fd, "%d\n", getpid());
	
	umask(0); 			
	if(chdir("/") !=0 ) {
		perror("chdir");
		exit(1);
	}
	
	close(STDIN_FILENO); close(STDOUT_FILENO); close(STDERR_FILENO);
	
	/* prepare for sigaction */
	action.sa_handler = sigHandler;
	sigfillset(&action.sa_mask);
	action.sa_flags = SA_RESTART;
	/* register the signals we want to handle */
	sigaction(SIGTERM, &action, NULL);
	sigaction(SIGINT, &action, NULL);
	sigaction(SIGQUIT, &action, NULL);
	sigaction(SIGABRT, &action, NULL);
	
	if((access(daemonlog, F_OK)) == 0){
	   unlink(daemonlog);
   }
	
	if ((fd = open(daemonlog, O_CREAT | O_RDWR | O_TRUNC, 0644)) == -1){
		perror("Can't open daemonlog");
		return 1;
	}
	while(1){
		time(&now);
		dprintf(fd, "Mydaemon alive at %s", ctime(&now));
		sleep(5);
	}
	return 0;
}

void sigHandler(int sig){
    int status = 0;
    if ( sig == SIGTERM || sig == SIGINT || sig == SIGQUIT || sig == SIGABRT ){
        if ((unlink(pidfile)) == -1)			/* remove the pid-file */
            status = 1;
        if ((close(fd)) == -1)
            status = 1;
		if ((unlink(daemonlog)) == -1)			/* remove the daemonlog */
            status = 1;
        exit(status); 							/* exit with the status set*/
    }else{										/* some other signal */
        exit(1);
    }
}

01.mypipe1.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <time.h>

int main(void) {
	int pd[2], read_fd, write_fd;
	pid_t pid;
	time_t timer1, timer2;
	char tx_buf[100], rx_buf[100];
	
	if ( pipe(pd) == -1 ) {
		perror("pipe");    
		exit(1);    
	}
	
	read_fd = pd[0];    
	write_fd = pd[1];
  
	switch(pid=fork()) {
		case 0: 
			close(read_fd);
			for(int i=0; i<11; i++){
				// for(timer1=time(NULL); time(NULL)<timer1 + 1;)
				// continue;
				// strcpy(tx_buf, "\e[31mHello Parent. I am child.");
				sprintf(tx_buf, "\e[31mHello Parent. I am child ---%d\n", i);
				write(write_fd, tx_buf, strlen(tx_buf)+1);
				for(timer1=time(NULL); time(NULL)<timer1 + 1;)
				continue;
				// read(read_fd, rx_buf, sizeof(rx_buf));
				// printf("\e[00m--------> CHILD: %s\n", rx_buf);
			}
			exit(0);
		default:   
#if 1
			close(write_fd);
			for(int i=0; i<10; i++){
				// for(timer2=time(NULL); time(NULL)<timer2 + 2;)
					// continue;
				// memset(&rx_buf[0], 0, sizeof(rx_buf));
				read(read_fd, rx_buf, sizeof(rx_buf));
				printf("\e[00mPARENT: %s\n", rx_buf);
				// for(timer2=time(NULL); time(NULL)<timer2 + 2;)
					// continue;
				// strcpy(tx_buf, "\e[00mHello Child. I am Parent");
				// sprintf(tx_buf, "\e[00mWeleome Child. I am Parent--%d\n", i);
				// write(write_fd, tx_buf, strlen(tx_buf)+1);
			}
#else
			for(int i=0; i<10; i++){
				for(timer2=time(NULL); time(NULL)<timer2 + 2;)
					continue;
				strcpy(tx_buf, "\e[00mHello Child. I am Parent");
				write(write_fd, tx_buf, strlen(tx_buf)+1);
				read(read_fd, rx_buf, sizeof(rx_buf));
				printf("\e[00mPARENT: %s\n", rx_buf);
			}
#endif
			exit(0);
	}
}

02.mypipe2.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <time.h>

#define MSGSIZE	64

int main(void){
	int pd1[2], pd2[3];
	pid_t ret;
	time_t timer1;
	char sbuf[MSGSIZE];
	char rbuf[MSGSIZE];
	int i, len;
	
	if(pipe(pd1) == -1){
		perror("pipe1");
		exit(1);
	}
	
	if(pipe(pd2) == -1){
		perror("pipe2");
		exit(1);
	}
	
	
	switch(fork()){
		case 0:					//child
			close(pd1[0]);
			close(pd2[1]);
			for(i=0; i<5; i++) {
				sprintf(&sbuf[0], "Hello, Parent #%d", i+1);
				write(pd1[1], sbuf, strlen(sbuf));
				
				memset(&rbuf[0], 0, MSGSIZE);
				len = read(pd2[0], rbuf, MSGSIZE);
				if(len == 0){
					break;
				}
				printf("CHILD: %s\n", rbuf);
				for(timer1=time(NULL); time(NULL)<timer1 + 1;)
					continue;
			}
			exit(0);
		default:				//parent
			close(pd1[1]);
			close(pd2[0]);
			for(i=0; ; i++) {
				memset(&rbuf[0], 0, MSGSIZE);
				len = read(pd1[0], rbuf, MSGSIZE);
				if(len == 0){
					break;
				}
				printf("PARENT: %s\n", rbuf);
				for(timer1=time(NULL); time(NULL)<timer1 + 1;)
					continue;
				sprintf(&sbuf[0], "Welcome, Child #%d", i+1);
				write(pd2[1], sbuf, strlen(sbuf));
			}
	}
	return 0;
}

03.myfifo_recv.c

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(){
	int fd;
	char buf[128];
	int count = 0;
	
	if((access ("/tmp/myfifo", F_OK)) != 0){
		if(mkfifo("/tmp/myfifo", S_IRUSR | S_IWUSR) == -1){
			perror("mkfifo");
			exit(1);
		}
	}
	
	if((fd = open("/tmp/myfifo", O_RDONLY)) == -1){
		perror("open");
		exit(1);
	}
	
	while(1){
		memset(buf, 0, sizeof(buf));
		read(fd, buf, sizeof(buf));
		printf("Rx - %s\n", buf);
		if(strstr(buf, "end")){
			break;
		}
	}
	close(fd);
	unlink("/tmp/myfifo");
	return 0;
}

04.myfifo_send.c

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

int main(){
	int fd, i;
	char buf[128];
	time_t timer1;
	
	if((fd = open("/tmp/myfifo", O_WRONLY)) == -1){
		perror("open");
		exit(2);
	}
	
	for(i=0; i<5; i++){
		memset(buf, 0, sizeof(buf));
		sprintf(&buf[0], "Hello(%d)", i);
		write(fd, &buf[0], strlen(buf)+1);
		printf("Tx: %s\n", buf);
		for(timer1=time(NULL); time(NULL)<timer1 + 2;)
			continue;
	}
	memset(buf, 0, sizeof(buf));
	sprintf(buf, "end");
	write(fd, buf, strlen(buf)+1);
	close(fd);
	/* unlink("/tmp/mkfifo"); */
	return 0;
}

03.posix_shm_write.c

#include <stdio.h>
#include <unistd.h>  
#include <sys/mman.h>
#include <sys/stat.h>       
#include <fcntl.h>
#include <string.h>

#define  MEM_SIZE    128

int main() {
	int fd;
	void *shm_addr;
	const char *message0= "Welcome to ";
	const char *message1= "Linux Systems ";
	const char *message2= "Programming!";
	
	
	fd = shm_open("/mydata", O_RDWR | O_CREAT, 0666);
	
	
	ftruncate(fd, MEM_SIZE);
		
	
	shm_addr = mmap(0, MEM_SIZE, PROT_WRITE, MAP_SHARED, fd, 0);
	printf( "Map addr is %p\n", shm_addr );
#if 1	
	write(fd, message0, strlen(message0));
	write(fd, message1, strlen(message1));
	write(fd, message2, strlen(message2));
#else
	memcpy(shm_addr, message0, strlen(message0));
	shm_addr += strlen(message0);
	sprintf(shm_addr, message1, strlen(message1));
	shm_addr += strlen(message1);
	memcpy(shm_addr, message2, strlen(message2));
	shm_addr += strlen(message2);
#endif
	printf("Press enter to munmap.... ");
	getchar();
	munmap(shm_addr, MEM_SIZE);
	return 0;
}

04.posix_shm_read.c

#include <stdio.h>
#include <unistd.h>  
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>

#define  MEM_SIZE    128

int main() {
	int fd;
	void *shm_addr;
	char buf[MEM_SIZE];

	fd = shm_open("/mydata", O_RDONLY, 0666);
	if(fd == -1){
		perror("shm_open");
		exit(1);
	}
	
	
	shm_addr = mmap(0, MEM_SIZE, PROT_READ, MAP_SHARED, fd, 0);
	if(shm_addr == (void *)-1){
		perror("mmap error");
		return EXIT_FAILURE;
	}
#if 1	
	memset(buf, 0, MEM_SIZE);
	read(fd, buf, MEM_SIZE);
	printf("%s\n", buf);
#else
	memcpy(buf, shm_addr, sizeof(buf));
	printf("Map addr is %p\n", shm_addr);
	printf("Read message: %s\n", buf);
#endif
	printf("Press enter to munmap .....");
	getchar();
	munmap(shm_addr, MEM_SIZE);
	printf("Press enter to remove shared memory file");
	getchar();
	shm_unlink("/mydata");
	// close(fd);
	return 0;
}

03.posix-mqsend.c

#include <stdio.h>
#include <mqueue.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <string.h>
#include <unistd.h>
#define MAX_MSG_SIZE 2048

int main(int argc, char *argv[]){
	int mqd; /* msg queue descriptor */
	/* attributes for the message queue */
	struct mq_attr msgattr;
	msgattr.mq_maxmsg = 10;
	msgattr.mq_msgsize = MAX_MSG_SIZE;
	char msg[128];

	mqd = mq_open("/myqueue", O_CREAT|O_RDWR, 0644, &msgattr); 
	if(mqd == -1){
	  perror("Creating message queue");
	  return 1;
	}
	for(int i=0; i<10; i++){
		sprintf(&msg[0], "Hello, message queue #%d", i+1);
		if((mq_send(mqd, msg, strlen(msg), 1)) == -1){
			perror("Message queue send");
			return 1;
		}
	}
	printf("Press Enter to remove message queue....");
	getchar();
	
	mq_close(mqd);
	mq_unlink("/myqueue");
	return 0;
}

03.posix-mqrecv.c

#include <stdio.h>
#include <mqueue.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>

int main(void){
   int mqd; 								/* msg queue descriptor */
   char *buffer;
   struct mq_attr msgattr;
   mqd = mq_open("/myqueue", O_RDONLY);
   if(mqd == -1){
      perror("Open message queue");
      return 1;
   }
   if((mq_getattr(mqd, &msgattr)) == -1){
      perror("Get message attribute");
      return 1;
   }
   buffer = calloc(msgattr.mq_msgsize, sizeof(char));
   if(buffer == NULL){
      fprintf(stderr, "Couldn't allocate memory");
      return 1;
   }
   printf("%ld messages in queue\n", msgattr.mq_curmsgs);
   for(int i = 0; i<msgattr.mq_curmsgs; i++){
      if((mq_receive(mqd, buffer, msgattr.mq_msgsize, NULL)) == -1){
         perror("Message receive");
         return 1;
      }
      printf("%s\n", buffer);
   }
   memset(buffer, '\0', msgattr.mq_msgsize);
   free(buffer);
   mq_close(mqd);
   //mq_unlink("/myqueue");
   return 0;
}

03.shm_posix_named_sem1.c

#include <semaphore.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/shm.h>
#include <sys/mman.h>

#include <stdlib.h>
#include <stdio.h>

#define KEY_NUM     0x2222
#define	MEM_SIZE		1024

int main(int argc, char **argv) {
  sem_t *mysem;
	int shm_id;
	void *shm_addr;

	printf("Started --------------------\n");
	if((shm_id = shmget((key_t)KEY_NUM,MEM_SIZE,IPC_CREAT|0666)) == -1) {
		perror("shmget");
		exit(1);
	}

	if((shm_addr = shmat(shm_id, NULL, 0)) == (void *)-1) {
		perror("shmat");
		exit(1);
	}
	
	printf("Named semaphore ---------------\n");
  if((mysem = sem_open("/mysemaphore", O_CREAT, 0777, 1)) == NULL) {
    perror("Sem Open Error");
    return 1;
  }

  for(int i=0; i<500; i++){
#ifdef SEM
    sem_wait(mysem);
#endif
		sprintf((char *)shm_addr, "%d", getpid());
		for(int j=0; j<5000000; j++){}
		if(getpid() == atoi(shm_addr))
			putchar('0');
		else
			putchar('X');
		fflush(stdout);
#ifdef SEM
		sem_post(mysem);
#endif
    }
	if(shmdt(shm_addr) !=0){
		perror("shmdt");
		exit(2);
	}
	sem_close(mysem);
	sem_unlink("/mysemaphore");
	if(shmctl(shm_id, IPC_RMID, NULL) == -1){
		perror("shmctl");
		exit(2);
	}
}

// sem.mysem file for mysem semaphore is located in /dev/shm
// To compile the program, -lrt & -lpthread is required

04.shm_posix_named_sem2.c

#include <semaphore.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/shm.h>
#include <sys/mman.h>

#include <stdlib.h> 
#include <stdio.h>

#define KEY_NUM     0x2222
#define	MEM_SIZE	1024
        
int main(int argc, char **argv){       
	sem_t *mysem;
	int shm_id;
	void *shm_addr;
	
	printf("Started --------------------\n");
	if((shm_id = shmget((key_t)KEY_NUM,MEM_SIZE,IPC_CREAT|0666)) == -1) {
		perror("shmget");
		exit(1);
	}

	if((shm_addr = shmat(shm_id, NULL, 0)) == (void *)-1) {
		perror("shmat");
		exit(1);
	}
	
	printf("Named semaphore ---------------\n");
	if((mysem = sem_open("/mysemaphore", O_CREAT, 0777, 1)) == SEM_FAILED) {
			perror("Sem Open Error");
			return 1;
	}

	for(int i=0; i<500; i++){  
#ifdef SEM	
		sem_wait(mysem);
#endif
		sprintf((char *)shm_addr, "%d", getpid());
		for(int j=0; j<3000000; j++){}
		if(getpid() == atoi(shm_addr))
			putchar('0');
		else
			putchar('X');
		fflush(stdout);
#ifdef SEM
		sem_post(mysem);
#endif
                
	}  
	if(shmdt(shm_addr) !=0){
		perror("shmdt");
		exit(2);
	}
	sem_close(mysem);
	sem_unlink("/mysemaphore");
}

4일차

호타리 — Mon, 16 Jun 2025 16:52:06 +0900

2025.06.16

00.process.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

int a=10, a2=20;
int b, b2;

int f1(int x){
	return ++x;
}

int f2(int x){
	return --x;
}

int main(){
	int c=100, c2;
	char *d = "\e[31mThis is virtual memory layout of the process\e[00m";
	// char *d; 
	char *name;
	
	name = malloc(40);
	name = "cafe";
	
	printf("addr(TEXT)=> \tmain:%p, f1:%p, f2:%p\n", main, f1, f2);
	printf("addr(CONST)=> \td:%p : %s\n", *(&d), d);
	printf("addr(DATA)=> \ta:%p, a2:%p, a_value:%d, a2_value:%d\n", &a, &a2,*(&a), *(&a2));
	printf("addr(BSS)=> \tb:%p, b2:%p, b_value:%d, b2_value:%d\n", &b, &b2, *(&b), *(&b2));
	printf("addr(HEAP)=> \tname_var:%p, name_addr:%p, name:%s\n", &name, name, name );
	printf("addr(STACK)=> \tc:%p, c_value:%d\n", &c, *(&c));
	printf("addr(STACK)=> \td:%p, d_value:%p\n", &d, *(&d));
	// c=200; c2=300;
	// printf("addr(STACK)=> c:%p, c_value:%d, c2:%p, c2_value:%d\n", &c, *(&c), &c2, *(&c2));
	sleep(1);
	strcpy(d, "hello world");
	printf("addr(CONST)=> \td:%p : %s\n", d, d);
	return 0;
}

cli_args.c

#include<stdio.h>

int main(int argc, char * argv[]){
   
    printf("Number of Arguments Passed: %d\n", argc);
    // This loop prints the all the command line values that are passed through the program
    for(int i=0; i<argc; i++){
        printf("%s\n", argv[i]);
    }

    return 0;
}

env_list.c

#include<stdio.h>

int main(){

    extern char **environ;

    char **environment_list = environ;

    /* This code Helps us to prints the all the Environments available 
	 * in the operating system.
    */
	
    while(*environment_list != NULL){
        printf("%s\n", *environment_list);
        environment_list++;
    }
	
	// for(int i=0; i<10; i++){
        // printf("%s\n", *environment_list);
        // environment_list++;
    // }

    return 0;
}

env_set_get_del.c

#include<stdio.h>
#include<stdlib.h>

int main(){

    char env_name[15];
    char env_value[255];
    int overwrite=1;
    printf("Enter your Variable name:");
    scanf("%s", env_name);
    printf("Enter the Variable Value: ");
    scanf("%s", env_value);
    
    int status = setenv(env_name, env_value, overwrite);

    if(status == 0){
        printf("Environment variable Created Successfully.!\n");
    }else if(status == -1){
        printf("Environment variable creation failed.!\n");
    }
	printf("%s=%s\n",env_name,  getenv(env_name));
	status = unsetenv(env_name);
	printf("%s=%s\n",env_name,  getenv(env_name));
    return 0;
}

01.mytask.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <wait.h>

int main(int argc, char *argv[]) {
	int i, fd;
	
	printf("%s's PID[%d], PPID[%d]\n", argv[0], getpid(), getppid());
	
	if((fd = open("/dev/null", O_WRONLY|O_CREAT|O_TRUNC, 0644)) == -1){
		perror("open");
		exit(1);
	}
	
#if 1
	dup2(fd, 1);
#endif
	
	for(i=1; i<=atoi(argv[1]); i++) {
		printf("MyTask_%d!!\n", i);
		sleep(1);
	}
	return 0;
}

02.mysystem.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[]){
	char cmd_buf[256];
	int ret;
	
	printf("--------------system start--------------\n");
#if 1
	strcpy(cmd_buf, "./01.mytask 10");
#else
	strcpy(cmd_buf, "ps -f");
#endif
	ret = system(cmd_buf);
	printf("--------------system end-----------%d-----\n", ret);
	 
	return 0;
}

02-1.mysystem.c

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>
#include <string.h>

void handler(int signo) {
	pid_t exit_pid;
	printf("handler_pid [%d], handler_ppid [%d]\n", getpid(), getppid());
	exit_pid = waitpid(-1, NULL, WNOHANG);
	if(exit_pid == -1)
		printf("waitpid error with ERRNO=%d meaning %s\n", errno,  strerror(errno));
	else
		printf("Terminated child PID = %d\n", exit_pid);
}

int main() {
	signal(SIGCHLD, handler);
	system("echo Hello World");
	system("ps -lf");
}

03.myfork

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

int main(void){
	pid_t pid;
	printf("My PID is %d\n", getpid());
   
	pid = fork();
	if(pid == -1){
		perror("fork failed");
		return 1;
	}
	printf("Hello World from PID = %d\n", getpid());
	sleep(120);
	return 0;
}

03-1.myfork_vm.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

int a=10, b;
int main() {
	int c=100, c2;
	char *d = "I am parent";
	char *name;
	name = malloc(50);
	name = "cafe";
	pid_t pid=fork();
	if(pid == 0){
		a=200; b=400; c=600; d="I am child"; name="ubuntu";
	}
	printf("\e[00m%s[%d] of ppid[%d]\n", d, getpid(), getppid());
	printf("paddr(TEXT)=> main:%p\n", main);
	printf("paddr(CONST)=> d:%p, d_value:%s\n", d, d);
	printf("paddr(DATA)=> a:%p, a_value:%d\n", &a, *(&a));
	printf("paddr(BSS)=> b:%p, b_value:%d\n", &b, *(&b));
	printf("paddr(STACK)=> c:%p, c_value:%d, d:%p, d_value:%p\n", &c, *(&c), &d, *(&d));
	printf("paddr(HEAP)=> name:%p, name_value:%s\n", &name, name);
	sleep(1);
}

03-2.myfork_zombie.c

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <time.h>

int main(int argc, char *argv[]){
	pid_t pid;
	time_t startTimec, startTimep;
	
	if((pid = fork()) < 0){
		perror("fork");
		exit(1);
	}else if(pid == 0){		//Child process
		printf("\e[31mCHILD PROCESS---- (%d)\e[00m\n", getpid());
		for (startTimec = time(NULL); time(NULL) < startTimec + 8;){
				for(int i=0; i<100000000; i++);
				write(1, "+", 1);
		}
		sleep(10);
		exit(0);
	}else{					//Parent process
		printf("\e[00mPARENT PROCESS ---(%d)\n", getpid());
		for (startTimep = time(NULL); time(NULL) < startTimep + 10;){
				for(int i=0; i<100000000; i++);
				write(1, "*", 1);
		}
		sleep(100);
	}
	return 0;
}

03-3.myfork_fd_share.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>

#define BUF_SIZE	128

int main() {
	int fd;
	pid_t pid;
	char buf[BUF_SIZE];
	char *data="Good Morning";
	
	fd=open("file01", O_RDWR | O_APPEND, 0666);
	pid=fork();
	if(pid == 0){
		printf("Child FD = %d\n",fd);
		write(fd, data, strlen(data));
		sleep(1);
		lseek(fd, 0, SEEK_SET);
		read(fd, buf, sizeof(buf));
		printf("Child : %s\n", buf);
	}else{
		getchar();
		printf("Parent FD = %d\n",fd);
		lseek(fd, 12, SEEK_SET);
		read(fd, buf, sizeof(buf));
		printf("Parent : %s\n", buf);
	}
	return 0;
}

/*
* Initially, file01 assumes to contain "hello world" by echoing "hello world > file01"
* then, the output of both parent and chile would be "good morning"
*
* Above example shows that both write and read system call move file offset 
* to the point of ending of writing or reading.
* To see offset, check the return value of lseek.
*
* Any files opened after fork would not be shared between a child and a parent
*/

04.mywait.c

#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>

int main (void) {
	int status;
	pid_t pid;
	
	if((pid=fork()) == 0){
		system("ps -l");
		printf("Child (%d) waiting for either a signal or timeout\n", getpid());
#if 0
		pause();
#else
		sleep(3);
#endif
		exit(10);
	} else {
		printf("Parent (%d) waiting for termination of child\n", getpid());
		pid = wait(&status);
		if (pid == -1)
			perror ("wait");
		printf("PID of Child terminated = %d\n", pid);
		if (WIFEXITED(status))
			printf ("Normal termination with exit status=%d\n", WEXITSTATUS(status));
		if (WIFSIGNALED(status))
			printf ("terminated by signal=%d%s\n", WTERMSIG(status), WCOREDUMP(status) ? \
																	" (dumped core)" : "");
		system("ps -l");
	}
	return 0;
}

05.mywaitpid.c

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <time.h>

int main(void) {
	int status=0;
	pid_t pid, exit_pid;
	time_t startTimec, startTimep;
	
	switch(pid = fork()){
		case -1:		// fork error
			perror("fork"); 
			exit(1);
		case 0:						//Child 
			for (startTimec = time(NULL); time(NULL) < startTimec + 8;){
				for(int i=0; i<100000000; i++);
				write(1, "+", 1);
			}
			printf("\n");
			system("ps -lf");
			exit(0);
		default:					//Parent
			for (startTimep = time(NULL); time(NULL) < startTimep + 10;){
				for(int i=0; i<100000000; i++);
				write(1, "*", 1);
				exit_pid = waitpid(-1, &status, WNOHANG);
			}
			printf("\n");
			system("ps -lf");
	}
	return 0;
}

05-1.mywaitpid.c

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>
#include <string.h>
#include <time.h>

void handler(int signo) {
	pid_t exit_pid;
	printf("\nhandler_pid [%d], handler_ppid [%d]\n", getpid(), getppid());
	exit_pid = waitpid(-1, NULL, WNOHANG);
	if(exit_pid == -1)
		// printf("waitpid error with ERRNO=%d meaning %s\n", errno,  strerror(errno));
		perror("waitpid");
	else
		printf("Terminated child PID = %d\n", exit_pid);
}

int main() {
	pid_t pid1, pid2;
	time_t startTimec, startTimes, startTimep;
	signal(SIGCHLD, handler);
	switch(pid1 = fork()){
		case 0: 
			switch(pid2=fork()){
				case 0:
					printf("grand-child pid [%d] of ppid [%d] started\n", getpid(), getppid());
					// for (startTimec = time(NULL); time(NULL) < startTimec + 8;){
						// for(int i=0; i<100000000; i++);
						// write(1, "+", 1);
					// }
					sleep(5);
					exit(0);
				default:
					printf("child pid [%d] of ppid [%d] started\n", getpid(), getppid());
					// for (startTimes = time(NULL); time(NULL) < startTimes + 6;){
						// for(int i=0; i<100000000; i++);
						// write(1, "#", 1);
					// }
					sleep(10);
					exit(0);
			}
		default: 
			printf("main pid [%d] of ppid [%d] started\n", getpid(), getppid());
			for (startTimep = time(NULL); time(NULL) < startTimep + 13;){
					for(int i=0; i<100000000; i++);
					write(1, "*", 1);
			}
			printf("\n");
	} 
	return 0;
}

05-2.mywatipid.c

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>
#include <time.h>

void handler(int signo) {
	pid_t exit_pid;
	printf("\nhandler_pid [%d], handler_ppid [%d]\n", getpid(), getppid());
	exit_pid = waitpid(-1, NULL, WNOHANG);
	if(exit_pid == -1)
		// printf("waitpid error with ERRNO=%d meaning %s\n", errno,  strerror(errno));
		perror("waitpid");
	else
		printf("Terminated child PID = %d\n", exit_pid);
}

int main(void){
	pid_t pid1, pid2;
	time_t startTimec, startTimes, startTimep;
	signal(SIGCHLD, handler);
	switch(pid1 = fork()){
		case 0:						//Child 1
			for (startTimec = time(NULL); time(NULL) < startTimec + 13;){
				for(int i=0; i<100000000; i++);
				write(1, "+", 1);
			}
			exit(10);
		default:					//Parent
			switch(pid2 = fork()){
				case 0:				//Child 2
					for (startTimes = time(NULL); time(NULL) < startTimes + 6;){
						for(int i=0; i<100000000; i++);
						write(1, "#", 1);
					}
					exit(11);
				default:			//Parent
					for (startTimep = time(NULL); time(NULL) < startTimep + 15;){
						for(int i=0; i<100000000; i++);
						write(1, "*", 1);
					}
					printf("\n");
			}
	}
	return 0;
}

06.myexit.c

#include <sys/wait.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

static int status;
void handler(int signo) {
	printf ("Signal[%d]='%s' is caughted in handler\n", signo, strsignal(signo));
	if((waitpid(-1, &status, WUNTRACED | WCONTINUED)) == -1){
        perror("waitpid");
    }
	if (WIFEXITED(status)) {
        printf("exited, status=%d\n", WEXITSTATUS(status));
    } else if (WIFSIGNALED(status)) {
		if(WTERMSIG(status) && WCOREDUMP(status))
			printf("terminated and coredumped by signal[%d]\n" , WTERMSIG(status));
		else 
			printf("terminated by signal[%d]\n", WTERMSIG(status));
    } else if (WIFSTOPPED(status)) {
        printf("stopped by signal[%d]\n", WSTOPSIG(status));
    } else if (WIFCONTINUED(status)) {
        printf("continued\n");
    }
}

void handler2(int signo) {
	extern const char * const sys_siglist[];
	printf ("Signal[%d]='%s' is caughted in handler2\n", signo, strsignal(signo));
}

int main(int argc, char *argv[]) {
	pid_t pid;
	signal(SIGCHLD, handler);
	
  if ((pid=fork()) == -1) {
    perror("fork");
    _exit(EXIT_FAILURE);
  }
	if(pid == 0){            /* Code executed by child */
    printf("Child PID is %ld\n", (long) getpid());
    if (argc == 2) {
			signal(SIGINT, handler2);
			pause();  
			sleep(1);
			exit(atoi(argv[1]));
		}
      _exit(10);
	}else{                    /* Code executed by parent */
		getchar();
  }
}

06-1.myexit.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

void hello() {
   printf("Hello\n");
}
void world(int exit_code, void *arg) {
   printf("world with CODE=%d and MSG=%s\n", exit_code, (char *)arg);
}

int main() {
   /* register the termination function */
   atexit(hello);
   on_exit(world, "Good Bye");
	 atexit(hello);
   
   printf("Starting  main program...\n");

   printf("Exiting main program...\n");
   
   // exit(10);
   _exit(20);
   // return 100;
}

06-1.myexit.c (exit(10);)

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

void hello() {
   printf("Hello\n");
}
void world(int exit_code, void *arg) {
   printf("world with CODE=%d and MSG=%s\n", exit_code, (char *)arg);
}

int main() {
   /* register the termination function */
   atexit(hello);
   on_exit(world, "Good Bye");
	 atexit(hello);
   
   printf("Starting  main program...\n");

   printf("Exiting main program...\n");
   
   exit(10);
   // _exit(20);
   // return 100;
}

06-2.myexit.c

#include <sys/wait.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

void handler(int signo) {
	printf ("signal[%d]='%s' is caughted\n", signo, strsignal(signo));
	// exit(20);
}

void exit_handler(int exit_code, void *arg){
	printf("PID=%d is exited with CODE=%d and MSG=%s\n", getpid(), exit_code, (char *)arg);
}

int main(int argc, char *argv[]) {
	signal(SIGCHLD, handler);
	on_exit(exit_handler, "exit function ended");
	switch (fork()){
		case -1:
			perror("fork");
			exit(30);
		case 0:
			printf("Child PID = %ld, Parend PID = %d \n", (long) getpid(), getppid());
			if (argc == 2) {
				exit(atoi(argv[1]));
			}
			_exit(10);
		default:
			getchar();
			exit(150);
	}
}

08.mydaemon.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <time.h>

void daemonize(void) {
    pid_t pid = fork();
    if (pid < 0) {
        perror("fork failed");
        exit(EXIT_FAILURE);
    }
    if (pid > 0) {
        /* Parent exits, child continues */
        exit(EXIT_SUCCESS);
    }

    /* Become session leader to detach from terminal */
    if (setsid() < 0) {
        perror("setsid failed");
        exit(EXIT_FAILURE);
    }

    /* Clear file creation mask */
    umask(0);

    /* Change working directory to root */
    if (chdir("/") < 0) {
        perror("chdir failed");
        exit(EXIT_FAILURE);
    }

    /* Close inherited file descriptors */
    long max_fd = sysconf(_SC_OPEN_MAX);
    if (max_fd == -1) {
        max_fd = 1024;
    }
    for (long fd = 0; fd < max_fd; fd++) {
        close(fd);
    }

    /* Redirect stdin, stdout, stderr to /dev/null */
    open("/dev/null", O_RDONLY);
    open("/dev/null", O_RDWR);
    open("/dev/null", O_RDWR);
}

int main(void) {
    FILE *logfp;

    daemonize();

    /* Open log file after daemonization */
    logfp = fopen("/tmp/mydaemon.log", "a+");
    if (!logfp) {
        exit(EXIT_FAILURE);
    }

    /* Periodically write to log */
    while (1) {
        time_t now = time(NULL);
        struct tm *tm_info = localtime(&now);
        char time_str[64];
        strftime(time_str, sizeof(time_str), "%a %b %d %T %Y", tm_info);
        fprintf(logfp, "Mydaemon alive at %s\n", time_str);
        fflush(logfp);
        sleep(5);
    }

    /* Clean up */
    fclose(logfp);
    return EXIT_SUCCESS;
}

현재 process에서 ppid를 찾아 올라가서 1,2프로세스까지 ppid를 찾아 올라가는 프로그램 작성

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

// Read PPid from /proc/[pid]/status
long get_ppid(long pid) {
    char path[64], line[128];
    FILE *f;
    snprintf(path, sizeof(path), "/proc/%ld/status", pid);
    if ((f = fopen(path, "r")) == NULL) return -1;
    while (fgets(line, sizeof(line), f)) {
        long p;
        if (sscanf(line, "PPid:\t%ld", &p) == 1) {
            fclose(f);
            return p;
        }
    }
    fclose(f);
    return -1;
}

int main(void) {
    long pid = getpid(), ppid;
    printf("01.current : %ld", pid);

    while ((ppid = get_ppid(pid)) > 2) {
        printf(" → %ld", ppid);
        pid = ppid;
    }
    if (ppid > 0)
        printf(" → %ld", ppid);

    printf("\n");
    return 0;
}

powershell 관리자권한으로 실행

VSCode 연동

3일차

호타리 — Fri, 13 Jun 2025 17:05:21 +0900

2025.06.13

00.signalprint.c

#include <stdio.h>
#include <signal.h>
#include <unistd.h>

const char *binary[16] = {
    [ 0] = "0000", [ 1] = "0001", [ 2] = "0010", [ 3] = "0011",
    [ 4] = "0100", [ 5] = "0101", [ 6] = "0110", [ 7] = "0111",
    [ 8] = "1000", [ 9] = "1001", [10] = "1010", [11] = "1011",
    [12] = "1100", [13] = "1101", [14] = "1110", [15] = "1111",
};

void print_byte(int byte){
    // printf("%s%s", bit_rep[byte >> 4], bit_rep[byte & 0x0F]);
	printf("%s", binary[byte & 0x0F]);
}

void print_sigset_t(sigset_t *set){
	int i;

	i = SIGRTMAX;
	// i = 32;
	do {
		int x = 0;
		i -= 4;
		if (sigismember(set, i+1)) x |= 1;
		if (sigismember(set, i+2)) x |= 2;
		if (sigismember(set, i+3)) x |= 4;
		if (sigismember(set, i+4)) x |= 8;
		// printf("%x", x);
		print_byte(x);
	} while (i >= 4); 
	printf("\n");
}

int main(int argc, char **argv)
{
	sigset_t set;
	sigemptyset(&set);
	/* add signals to set */
	sigaddset(&set, SIGINT); 		//sig # 2
	sigaddset(&set, SIGHUP);		//sig # 1
	sigaddset(&set, SIGALRM);		//sig # 14
	sigaddset(&set, SIGFPE);		//sig # 8
	sigaddset(&set, SIGABRT);		//sig # 6
	/* dump signals from set*/	
	print_sigset_t(&set);
}

01.signal.c

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>

int repeat = 0;

void handler(int signo){
	fprintf(stderr, "Signal handler triggered %d times (signum=%d)\n", repeat++, signo);
	if(repeat >= 5)
		signal(SIGINT, SIG_DFL);
	if(signo == 15){
	
		sleep(3);
		exit(0);
	}
}

int main(int argc, char *argv[]){
	signal(SIGINT, handler);
	signal(SIGQUIT, handler);
	signal(SIGTERM, handler);
	signal(SIGTSTP, handler);
	while(1){
		printf("signal interrupt test --- %d\n", repeat);
		sleep(1);
	}
	return 0;
}

02.mypause.c

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <signal.h>

static void handler (int signo){
	printf ("[%d] signal is caughted\n", signo);
}

int main (void){
	signal(SIGRTMIN, handler);
	signal(SIGRTMIN+1, handler);
	for (;;){
		for(int i=0; i<5; i++){
			printf("I am running  --- %d\n", i);
			sleep(1);
		}
		printf("Now I am waiting for a signal --- ");
		pause();
	}
	return 0;
}

01.mysignal_handler.c

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>

static int cnt_int = 0;
static int cnt_quit = 0;
static int cnt_term = 0;
static int cnt_tstp = 0;

void handler_sigint(int signo){
	fprintf(stderr, "Signal handler triggered %d times (signum=%d)\n", cnt_int++, signo);
	if(cnt_int >= 5)
		signal(SIGINT, SIG_DFL);
	if(signo == 15){
	
		sleep(3);
		exit(0);
	}
}

void handler_sigquit(int signo){
	fprintf(stderr, "Signal handler triggered %d times (signum=%d)\n", cnt_quit++, signo);
	if(cnt_quit >= 5)
		signal(SIGQUIT, SIG_DFL);
	if(signo == 15){

		sleep(3);
		exit(0);
	}
}

void handler_sigterm(int signo) {

    cnt_term++;

    fprintf(stderr, "[SIGTERM] count=%d, signo=%d\n", cnt_term, signo);

    if (cnt_term >= 5) {
	    signal(SIGTERM, SIG_DFL);
    }
}

void handler_sigtstp(int signo){
	fprintf(stderr, "Signal handler triggered %d times (signum=%d)\n", cnt_tstp++, signo);
	if(cnt_tstp >= 5)
		signal(SIGTSTP, SIG_DFL);
	if(signo == 15){

		sleep(3);
		exit(0);
	}
}

int main(int argc, char *argv[]){
	signal(SIGINT, handler_sigint);
	signal(SIGQUIT, handler_sigquit);
	signal(SIGTERM, handler_sigterm);
	signal(SIGTSTP, handler_sigtstp);
	while(1){
		printf("signal interrupt test --- INT:%d, QUIT:%d, TERM:%d, TSTP:%d\n", cnt_int, cnt_quit, cnt_term, cnt_tstp);
		sleep(1);
	}
	return 0;
}

ctrl+c : int

ctrl+\ : tstp

ctrl+z : quit

kill : tstp

03.mykill.c

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <errno.h>
#include <unistd.h>

int main(int argc, char *argv[]){
	
#if 1
	if(argc < 3){
		fprintf(stderr, "Usage: %s <pid_#> <sig_#>\n", argv[0]);
		exit(1);
	}
	if(kill(atoi(argv[1]), atoi(argv[2])) == -1){
		if(errno == EINVAL){
			printf("Invalid signal\n");
		}else if(errno == EPERM){
			printf("No Permission\n");
		}else if(errno == ESRCH){
			printf("No such process\n");
		}
	}
#else
	if(argc < 2){
		fprintf(stderr, "Usage: %s <pid_#>\n", argv[0]);
		exit(1);
	}
	for (int i=34; i<64; i++){
		kill(atoi(argv[1]), i);
		sleep(3);
	}
#endif
	return 0;
}

04.myraise.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>

void handler(int signo){
	printf("Received Signal no - %d\n", signo);
}

int main(int argc, char *argv[]){
	int a,b;
	
	for(int i=1; i<64; i++){
		if(signal(i, handler) == SIG_ERR){
			fprintf (stderr, "Cannot handle signal=%d\n", i);
		} 
	}
	for(int i=0; i<64; i++){
		if(i!=9 && i!=32 && i!=33){
			// kill(getpid(), i);
			raise(i);
			sleep(1);
		}
	}
	return 0;
}

04.myraise_kill.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>

int count = 0;

void handler(int signo){
	printf("Received Signal no - %d\n", signo);
    if(signo == 34){
        count++;
        fprintf (stderr, "signo34, count up, count : %d\n", count);
    }else if(signo == 35){
        count--;
        fprintf (stderr, "signo35, count down, count : %d\n", count);
    }
}

void handler34(int signo){
	count++;
        fprintf (stderr, "signo34, count up, count : %d\n", count);
}

void handler35(int signo){
	count--;
        fprintf (stderr, "signo35, count down, count : %d\n", count);
}

int main(int argc, char *argv[]){
	int a,b;

    printf("pid : %d\n", getpid());

    signal(34, handler34);
    signal(35, handler35);
	

    while(1){
        sleep(1);
    }

	return 0;
}

05.setprocmask.c

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include "signalprint.h"

void handler(int signo){
	printf ("[%d] signal is caughted\n", signo);
}

int main(void) {
	sigset_t set1, set2, set3, set4, oldset;
	
	signal(SIGQUIT, handler);  // ctrl + \
	sleep(2);
	sigemptyset(&set1);	
	sigaddset(&set1, 2);
	printf("signals in set1 are blocked\n");
	printf("set1 : ");
	print_sigset_t(&set1);	
	sigprocmask(SIG_BLOCK, &set1, &oldset);
	printf("oldset: ");
	print_sigset_t(&oldset);
	
	sleep(5);
	sigemptyset(&set2);							
	sigaddset(&set2, SIGQUIT);  
	printf("\nSignals in set2 are blocked\n");	
	printf("set2 : ");
	print_sigset_t(&set2);	
	sigprocmask(SIG_BLOCK, &set2, &oldset);
	printf("oldset: ");
	print_sigset_t(&oldset);
	
	sleep(5);
	sigemptyset(&set4);							
	sigaddset(&set4, SIGRTMIN);  
	printf("\nSignals in set4 are now blocked\n");	
	printf("set4 : ");
	print_sigset_t(&set4);	
	sigprocmask(SIG_BLOCK, &set4, &oldset);
	printf("oldset: ");
	print_sigset_t(&oldset);

	sleep(5);
	sigfillset(&set3);							
	printf("\nThe set of blocked signal is replaced by set3\n");
	printf("set3 : ");
	print_sigset_t(&set3);
	sigprocmask(SIG_SETMASK, &set3,  &oldset);	
	printf("oldset : ");
	print_sigset_t(&oldset);
	
	sleep(5);
	printf("\nSignals in oldset are now unblocked\n");
	sigprocmask(SIG_UNBLOCK, &oldset, NULL);			
		
	for(int i=0; ; i++){    
		printf("Hello Signal --- %d\n", i);    
		sleep(1);  
	}
	return 0;
}

signalprint.h

void print_sigset_t(sigset_t*set);

00.signalprint.c

#include <stdio.h>
#include <signal.h>
#include <unistd.h>

const char *binary[16] = {
    [ 0] = "0000", [ 1] = "0001", [ 2] = "0010", [ 3] = "0011",
    [ 4] = "0100", [ 5] = "0101", [ 6] = "0110", [ 7] = "0111",
    [ 8] = "1000", [ 9] = "1001", [10] = "1010", [11] = "1011",
    [12] = "1100", [13] = "1101", [14] = "1110", [15] = "1111",
};

void print_byte(int byte){
    // printf("%s%s", bit_rep[byte >> 4], bit_rep[byte & 0x0F]);
	printf("%s", binary[byte & 0x0F]);
}

void print_sigset_t(sigset_t *set){
	int i;

	i = SIGRTMAX;
	// i = 32;
	do {
		int x = 0;
		i -= 4;
		if (sigismember(set, i+1)) x |= 1;
		if (sigismember(set, i+2)) x |= 2;
		if (sigismember(set, i+3)) x |= 4;
		if (sigismember(set, i+4)) x |= 8;
		// printf("%x", x);
		print_byte(x);
	} while (i >= 4); 
	printf("\n");
}

/*
int main(int argc, char **argv)
{
	sigset_t set;
	sigemptyset(&set);
	/* add signals to set
	sigaddset(&set, SIGINT); 		//sig # 2
	sigaddset(&set, SIGHUP);		//sig # 1
	sigaddset(&set, SIGALRM);		//sig # 14
	sigaddset(&set, SIGFPE);		//sig # 8
	sigaddset(&set, SIGABRT);		//sig # 6
	/* dump signals from set	
	print_sigset_t(&set);
}
*/

06.mysigsuspend.c

#include <stdio.h> 
#include <signal.h> 
#include <unistd.h>
#include <stdlib.h>
#include "signalprint.h"

static void handler(int signo) { 
	printf ("[%d] signal is caughted\n", signo);
} 

int main() { 
	sigset_t set1,set2; 
	signal(SIGINT, handler); 
	signal(SIGRTMAX-1, handler);
	
	sigemptyset(&set1); 
	sigaddset(&set1,SIGINT); 
	sigaddset(&set1,SIGRTMAX-1); 
	
	sigfillset(&set2); 
	sigdelset(&set2, SIGINT);
	sigdelset(&set2, SIGRTMAX-1);
	
	sigprocmask(SIG_BLOCK,&set1,NULL); 
	print_sigset_t(&set1);
	print_sigset_t(&set2);
	
	for(int i=0; i<5; i++){
		printf("Critical Region 1 is running --- %d\n", i);
		sleep(1);
	}
#if 1
	printf("Waiting for a signal  ----------------- \n");
	sigsuspend(&set2);
#else
	sigprocmask(SIG_SETMASK, &set2, NULL);
	printf("Waiting for a signal  ----------------- \n");
	pause();
#endif
	for(int i=0; i<5; i++){
		printf("Critical Region 2 is running --- %d\n", i);
		sleep(1);
	}
	exit(0); 
}

07.mysigaction.c

#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include "signalprint.h"

void handler(int sig){ㅐ 
	sigset_t sigset;
    sigprocmask(SIG_SETMASK, NULL, &sigset);
	printf("blocked signal set : ");
	print_sigset_t(&sigset);
	for(int i=1; i<=3; i++) {
		printf("handler_%d!!\n", i);
		sleep(1);
	}
}
	
int main(void){
	struct sigaction act, oldact;
	
	act.sa_handler = handler;
	sigemptyset(&act.sa_mask);
	sigaddset(&act.sa_mask,SIGQUIT);
	
	// act.sa_flags=SA_NODEFER;
	act.sa_flags=SA_RESTART;
	// act.sa_flags=SA_RESETHAND;
	sigaction(SIGINT, &act, &oldact);
	
	for(int i=1; ; i++){
		printf("signal test --- %d\n", i);
		sleep(2);
	}
	return 0;
}

08.mysigalarm.c

#include <stdio.h> 
#include <stdlib.h> 
#include <unistd.h> 
#include <signal.h> 
#include <string.h>

void alarm_handler(int signo){
	printf("Time over, try again later---\n");
	exit(0);
}

int main(int argc, char *argv[]){
	char buf[512];
	char *passwd = "hello";
	struct sigaction act;
	if(argc <2){
		fprintf(stderr, "Usage: %s <timelimit>\n", argv[0]);
		exit(1);
	}
	act.sa_handler = alarm_handler;
	sigaction(SIGALRM, &act, NULL);
	alarm(atoi(argv[1]));
	while(1){
		printf("Input password: ");
		scanf("%s", buf);
		if(!strcmp(buf, passwd)){
			printf("Success\n");
			break;
		}else{
			printf("Fail\n");
		}
	}
	printf("Main function -----\n");
	return 0;
}

10.mysigpending.c

#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include "signalprint.h"

static void handler(int signo) { 
	printf("Signal #(%d) is caught\n", signo); 
}

int main( void){
	sigset_t sigset, oldset, pendingset;
	for(int i=1; i<=64; i++){
		signal(i, handler);
	}
	sigfillset(&sigset);
	sigprocmask(SIG_SETMASK, &sigset, &oldset);
	print_sigset_t(&oldset);
	int i=0;
	while(1){
		printf( "I am running --- %d\n", i++);
		sleep(1);
		if (sigpending(&pendingset) == 0){
			print_sigset_t(&pendingset);
			if (sigismember(&pendingset, SIGINT)){
				printf( "SIGINT was pended --- end of loop.\n");
				break;
			}
			if(sigismember(&pendingset, SIGTSTP)){
				printf( "SIGTSTP was pended --- end of loop.\n");
				break;
			}
		}
   }
	 sigprocmask(SIG_SETMASK, &oldset, NULL);
	 sleep(3);
   return 0;
}

07.mysigaction_intquit.c

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include "signalprint.h"   // print_sigset_t()

void handler(int sig) {
    sigset_t sigset;
    // 현재 블록된 시그널 집합을 조회
    sigprocmask(SIG_SETMASK, NULL, &sigset);
    printf("blocked signal set: ");
    print_sigset_t(&sigset);

    for (int i = 1; i <= 3; i++) {
        printf("handler_%d for SIGINT\n", i);
        sleep(1);
    }
}

int main(void) {
    struct sigaction act;
    sigset_t block_set;

    // 1) SIGINT 에만 handler 등록
    sigemptyset(&act.sa_mask);      // handler 중 추가 차단 안 함
    act.sa_handler = handler;
    act.sa_flags   = SA_RESTART;    // 시스템 호출 자동 재시작
    if (sigaction(SIGINT, &act, NULL) < 0) {
        perror("sigaction(SIGINT)");
        exit(1);
    }

    // 2) SIGQUIT 은 아무 설정도 하지 않아 기본 동작 유지

    // 3) 그 외 모든 시그널을 block_set 에 추가
    sigfillset(&block_set);         // 집합을 모두 1로
    sigdelset(&block_set, SIGINT);  // SIGINT 만 언블록
    sigdelset(&block_set, SIGQUIT); // SIGQUIT 만 언블록

    // 4) 프로세스 시그널 마스크로 적용 → 언블록된 시그널만 전달됨
    if (sigprocmask(SIG_SETMASK, &block_set, NULL) < 0) {
        perror("sigprocmask");
        exit(1);
    }

    // 5) 메인 루프
    for (int i = 1; ; i++) {
        printf("signal test --- %d\n", i);
        sleep(2);
    }

    return 0;
}

Mini Project1 - No Smoking Area

호타리 — Tue, 10 Jun 2025 16:45:08 +0900

SE0NGH0/No_Smoking_Area_Project

Smoking Detection System Project

프로젝트 개요

본 프로젝트는 YOLOv5 기반의 흡연자 탐지 시스템으로,
Flask 서버와 웹캠 스트리밍을 활용하여 금연 구역 내 실시간 흡연 여부를 감지하고,
로그 및 통계를 자동으로 저장 및 시각화하는 AI 비전 시스템입니다.

1. 프로젝트 클론

1.1 Git 설치

Windows:
Git 공식 사이트에서 설치

Mac/Linux:

sudo apt install git    # Ubuntu
brew install git        # Mac

1.2 GitHub에서 프로젝트 클론

git clone https://github.com/yourusername/smoking-detection-system.git
cd smoking-detection-system

2. 라이브러리 설치

2.1 가상환경 설정 (선택사항)

# 가상환경 생성 (Windows)
python -m venv venv

# 가상환경 활성화
venv\Scripts\activate        # Windows
source venv/bin/activate      # Mac/Linux

2.2 필요 라이브러리 설치

pip install -r requirements.txt

3. YOLOv5 모델 다운로드

3.1 모델 파일 준비

이미 best.pt 모델이 있다면 /models 폴더에 복사
필요 시 YOLOv5 GitHub에서 다운로드 가능

4. 웹캠 설정

4.1 연결 확인

Windows: 장치 관리자에서 웹캠 확인
Linux: lsusb 명령어로 연결 확인

4.2 브라우저 접근 허용

브라우저에서 카메라 접근 허용 팝업을 수락해야 스트리밍 가능

5. 서버 실행

5.1 Flask 서버 실행

python app.py

웹 브라우저에서 http://127.0.0.1:5000 접속

6. 흡연 감지 및 통계

6.1 감지 기능

실시간 스트리밍 중 흡연자 감지 시 "Stop Smoking Please." 문구 표시
감지된 이미지 /smoker 폴더에 자동 저장

6.2 통계 시각화

메인 웹페이지에 흡연 감지 횟수 및 통계 표시
흡연 발생 시마다 수치 자동 갱신

7. 서버 종료

Ctrl + C  # 서버 종료

8. 추가 설정 (선택)

카메라 인덱스 조정: cv2.VideoCapture(0)의 인덱스 값을 1 또는 2로 변경해보세요
YOLOv5 모델 재학습: 더 나은 성능을 위해 사용자 정의 데이터셋으로 추가 학습 가능

프로젝트 폴더 구조

/smoking-detection-system
├── app.py
├── requirements.txt
├── /static
│   ├── /images
│   │   └── police_logo.png
│   └── /css
│       └── style.css
├── /templates
│   └── index.html
└── /models
    └── best.pt (YOLO 모델)

본 프로젝트는 금연 구역에서의 비흡연 환경을 조성하기 위해
실시간 비전 기술을 적용한 사회적 가치 기반 AI 응용 프로젝트입니다.

1일차

호타리 — Tue, 10 Jun 2025 16:44:59 +0900

2025.06.10

리눅스 운영

U : Router가 Up 인 상태임을 나타냄

G : 경로가 Gateway 임을 나타냄

H : 목적지가 호스트 주소임을 나타냄 D : 경로가 리디렉션에 의해 생성되었음을 나타냄 M : 경로가 리디렉션에 의해 수정되었음을 나타냄

리눅스 운영체제 구성과 커널

운영체제 (Operating System)

windows(← DOS에서부터 시작)

Microsoft u 초기에는 cooperative multitasking

Unix

AT&T Bell Labs

preemptive multitasking

Linux

저수준의 terminal emulator 개발을 위해서 시작 (Torvalds)

Unix와 호환되는 kernel을 만드는 것

GNU/Linux

리눅스 커널

하드웨어 장치 접속 / 연결 (네트워크 장치-어뎁터, 하드디스크, 문자 장치 등)

개별 프로그램에 메모리 할당

개별 프로그램에 CPU

할당 프로그램간 정보(데이터) 교환

리눅스 유틸리티 프로그램, 라이브러리와 어플리케이션

유틸리티 프로그램의 종류

계산기, 달력, 문서편집기, 디스크 관리 등

라이브러리

개발자가 아니더라도, 프로그램 실행시 반드시 필요한 서비스를 제공해주는 것 (libc)

어플리케이션 (생산성 프로그램)

Web 브라우저 워드 프로세서

리눅스 사용자 인터페이스

Text-mode User Interface (Command Lineinterface - CLI)

시스템은 단순히 텍스트 기반의 로그인 프롬프트만 출력

일반사용자 ($), 루트 사용자 (#) - 부팅 시 설치 프로그램마다 다름

텍스트 기반 문서 편집기 사용 (vi, nano)

Graphical User Interface (GUI)

X window 사용 (Xorg-X11)

GNOME (Desktop)

KDE

리눅스 파일시스템 표준 계층구조 (Filesystem Hierarchy Standard, FHS)

Root Filesystem Tree (rootfs)

Linux 배포판 (Linux Distributions)

리눅스(커널) 기반의 완전한 운영체제를 만든 것

리눅스 커널 Linux 핵심 툴 세트 (GNU Utilities, X window, disk 관리, 기타 운영에 필요한 기능들)

보조 프로그램 (Desktop 환경, 생산성 프로그램, 어플리케이션 등)

시동 스크립트 (Startup script) (네트워크 프로그램, 로그인 프로그램..)

설치 프로그램 (Installer)

Types of Linux Distributions

Pro Developers

Market Share

ubuntu 배포 주기

어떤 Linux 배포판을 선택할 것인가?

배포판	선택 기준 (제안)
RedHat Enterprise Linux (RHEL)	기술지원 계약이 필요한 경우
CentOS	기술지원 계약 없이 기업용 RHEL을 사용하고 싶을 때
Fedora	랩탑이나 데스크탑에 RHEL 개발 환경을 설치하고자 할 때
Linux Mint	영화보기, 음악듣기, 게임 용으로 그래픽 환경에서의 개인적 데스크 탑을 원할 때
Debian	서버, 랩탑 또는 주로 디바이스에서 사용하고자 할 때 (RaspberryPi)
Ubuntu	Debian 기반의 Desktop 버전을 사용하고자 할 때
Kali Linux	한번의 클릭으로 해킹을 하기를 원할 때
기타	고급 사용자들은 Arch, Gentoo. OpenSUSE,,, 등을 사용할 수도

쉘과 파일시스템 기본 이해

쉘(shell)이란?

Shell은 사용자가 입력한 모든 명령어를 읽어서 해석한 후 운영체제에 전달하여 실행을 요청하는 응용 프로그램

쉘 스크립트에서는 명령어 해석기(Command Interpreter) 라고 함

터미널(키보드와 모니터)을 연결하고 터미널을 통하여 입출력을 제어

리눅스 시스템과 사용자를 연결하는 통로

리눅스 운영체제와 리눅스 사용자 간의 저수준 인터페이스

쉘(Shell)의 주요 기능

운영체제와 키보드 인터페이스로서의 기능

사용자 편의에 맞게 명령어를 만들고 변경 및 추가하는 기능

새 명령어 개발을 위한 컴퓨터 언어로서의 기능 - 쉘 스크립트

쉡의 종류

쉘(shell)의 종류	특징	프롬프트
bash Bourne Again shell	Bourne again shell은 최초로 개발된 쉘인 Bourne shell의 변종임. 리눅스에서 가장 많이 사용되는 IEEE POSIX 호환이며 Borune shell과 호환되는 쉘로서 GNU 프로젝트에 의해 만들어지고 배포되고 있음.	$
sh Bourne shell	Bourne 쉘은 C쉘이나 Korn 쉘과 기능적인 면을 비교해 보면 미흡한 점이 있는데, 그 중 가장 큰 단점은 상호 대화형(Interactive) 방식을 취하고 있지 않다는 점임. Steven Bourne의 Bourne shell, sh	$
csh C-Program Style shell	버클리 캘리포니아 대학에서 개발된 프로그래머들에게 적합한 shell임. 대화형 사용법에서는 Bourne shell과 대부분 호환되지만 전혀 다른 프로그래밍 인터페이스를 가지고 있음. Bill Joy의 C shell, csh C언어와 유사한 언어를 사용, 상호 대화형 방식으로 구성	%
ksh Korn shell	일반적으로 유닉스에서 가장 많이 사용되고 있는 shell이며 Bourne shell에 처음으로 현대적인 shell 기능(C shell로부터 차용한 것임)을 도입한 shell임. Bourne shell과 호환됨.	$
zsh	Korn shell과 매우 유사한 셸이지만 Korn shell보다 더 많고 유용한 기능 등을 추가하여 개선시킨 것임.	%

파일 시스템 표준 계층 (FHS)

파일 시스템(file system)

컴퓨터에서 파일이나 자료를 쉽게 발견 및 접근할 수 있도록 보관 또는 조직하는 체제

어플리케이션이 사용하는 파일과 미디어에 저장된 데이터 사이를 연결

파일 시스템 관리

저장된 데이터에 접근하는 것을 관리

데이터를 보관하고 접근하는 시간을 개선하기 위하여 파일시스템을 튜닝하고, 모니터링하며, 복구하는 기능

파일 시스템 탐험하기

현재 작업 디렉터리

pwd : Print current working directory

사용자가 처음 로그인을 하면 항상 사용자의 home 디렉토리가 기본 working directory가 됨

사용자의 기본 working directory는 사용자가 생성될 때 결정되며 /etc/passwd 파일에 해당 정보가 기록되어 있음

디렉토리 이동

Home Directory로 이동

cd , cd ~, pushd, popd

Parent Directory로 이동 : cd ..

이전 디렉토리로 이동 : cd -

절대 경로(absolute path)와 상대 경로(relative path)

절대경로 : "/"로 시작하는 경로 이름

상대경로 : "/"로 시작하지 않는 경로는 현재 위치(pwd)를 기준으로 동작함

Directory 목록 (내용) 보기 ls

Directory 내의 숨겨진 파일 보기 ls -a

Directory 내용 자세하게 보기 (파일의 퍼미션, 소유자, 생성 날짜, 크기 등 ) ls -l

Directory 내의 파일의 유형 정보 보기 ls -F

Directory 하위 디렉토리를 이동하며 반복적으로 디렉토리 내용 보기 (Recursive) ls -R

파일 내용 보기

cat /etc/hosts

파일의 내용을 터미널(표준출력 장치)에 출력함

페이지 단위로 파일 내용 보기 less /etc/passwd

more : 페이지 단위로 파일 내용 보기 more /etc/passwd

head : 파일의 시작에서부터 지정한 줄 수만큼 내용 보기 (초기 기본 설정값은 10줄)

tail : 파일의 끝에서부터 지정한 줄 수만큼 내용 보기 (초기 기본 설정값은 10줄)

11일차

호타리 — Wed, 4 Jun 2025 10:32:09 +0900

2025.05.30

uart.c

#include <stdio.h>
#include <wiringPi.h>
#include <wiringSerial.h>
#include <pthread.h>
#include <termios.h>
#include <stdlib.h>
#include <string.h>

#define B_RATE B9600

int fd;  // Serial file descriptor

void* ReadProcess(void* arg)
{
    char buf[1024];
    while (1)
    {
        int n = serialDataAvail(fd);
        if (n > 0 && n < sizeof(buf))
        {
            for (int i = 0; i < n; i++)
            {
                char ch = serialGetchar(fd);

                // 줄바꿈 문자 무시 (선택 사항)
                if (ch == '\n' || ch == '\r') {
                    continue;
                }

                buf[i] = ch;
                buf[i + 1] = '\0';  // 실시간 null-terminate
                printf("<< %s\n", buf);  // 수신 데이터 출력
                fflush(stdout);
            }
        }
        delay(10);  // CPU 사용 제한
    }
    return NULL;
}

int main()
{
    if (wiringPiSetup() == -1) {
        fprintf(stderr, "wiringPi setup failed\n");
        exit(1);
    }

    fd = serialOpen("/dev/serial0", 9600);
    if (fd < 0) {
        perror("serialOpen failed");
        exit(1);
    }

    pthread_t rp;
    if (pthread_create(&rp, NULL, ReadProcess, NULL) != 0) {
        fprintf(stderr, "pthread_create failed\n");
        exit(1);
    }

    char buf[500];
    while (1)
    {
        printf(">> ");
        fflush(stdout);
        if (fgets(buf, sizeof(buf), stdin) != NULL) {
            // 개행 문자 제거
            char *newline = strchr(buf, '\n');
            if (newline) *newline = '\0';

            // 시리얼로 전송
            serialPuts(fd, buf);
            serialPutchar(fd, '\n');  // 필요 시 줄바꿈 명시적으로 추가
        }
    }

    return 0;
}

10일차

호타리 — Thu, 29 May 2025 18:38:15 +0900

2025.05.29

sercer.c

// server.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define PORT 9000

static void kill_port_users(int port) {
    char cmd[64];
    snprintf(cmd, sizeof(cmd), "fuser -k %d/tcp 2>/dev/null", port);
    system(cmd);
}

int main(void) {
    int server_sock, client_sock;
    struct sockaddr_in saddr, caddr;
    socklen_t addr_len = sizeof(caddr);
    char buf[1024];
    ssize_t r;
    int opt = 1;

    // 기존 포트 점유 프로세스 제거
    kill_port_users(PORT);

    // 1) socket()
    if ((server_sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        perror("socket");
        return 1;
    }

    // 2) SO_REUSEADDR
    if (setsockopt(server_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
        perror("setsockopt");
        close(server_sock);
        return 1;
    }

    // 3) bind()
    memset(&saddr, 0, sizeof(saddr));
    saddr.sin_family      = AF_INET;
    saddr.sin_addr.s_addr = htonl(INADDR_ANY);
    saddr.sin_port        = htons(PORT);
    if (bind(server_sock, (struct sockaddr*)&saddr, sizeof(saddr)) < 0) {
        perror("bind");
        close(server_sock);
        return 1;
    }

    // 4) listen()
    if (listen(server_sock, 2) < 0) {
        perror("listen");
        close(server_sock);
        return 1;
    }
    printf("▶ Server listening on port %d …\n", PORT);

    // 5) accept()
    if ((client_sock = accept(server_sock, (struct sockaddr*)&caddr, &addr_len)) < 0) {
        perror("accept");
        close(server_sock);
        return 1;
    }

    // 6) 원격 엔드포인트 정보 출력
    printf("▶ Client connected!\n");
    printf("   RemoteEP_ADDR  = %s\n", inet_ntoa(caddr.sin_addr));
    printf("   RemoteEP_port  = %d\n", ntohs(caddr.sin_port));

    // 7) read loop
    while ((r = read(client_sock, buf, sizeof(buf)-1)) > 0) {
        buf[r] = '\0';
        printf("> %s (%zd bytes)\n", buf, r);
    }
    if (r < 0) perror("read");

    close(client_sock);
    close(server_sock);
    return 0;
}

client.c

// client.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define PORT 9000

int main(int argc, char *argv[]) {
    int sock;
    struct sockaddr_in saddr;
    char buf[500];
    ssize_t w;

    if (argc != 2) {
        fprintf(stderr, "Usage: %s <server_ip>\n", argv[0]);
        return 1;
    }
    const char *server_ip = argv[1];

    // 1) 소켓 생성
    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        perror("socket");
        return 1;
    }

    // 2) 서버 주소 세팅
    memset(&saddr, 0, sizeof(saddr));
    saddr.sin_family = AF_INET;
    saddr.sin_port   = htons(PORT);
    if (inet_aton(server_ip, &saddr.sin_addr) == 0) {
        fprintf(stderr, "Invalid IP address: %s\n", server_ip);
        close(sock);
        return 1;
    }

    // 3) 서버에 연결
    if (connect(sock, (struct sockaddr *)&saddr, sizeof(saddr)) < 0) {
        perror("connect");
        close(sock);
        return 1;
    }

    // 4) 연결 정보 출력
    printf("▶ Connected to %s:%d\n", server_ip, PORT);
    printf("   Server_ADDR  = %s\n", inet_ntoa(saddr.sin_addr));
    printf("   Server_PORT  = %d\n", ntohs(saddr.sin_port));

    // 5) stdin에서 한 줄씩 읽어서 서버로 전송 (“> ” 프롬프트 추가)
    while (1) {
        printf("> ");              // 프롬프트
        fflush(stdout);            // 바로 출력되도록 플러시

        if (!fgets(buf, sizeof(buf), stdin))
            break;                 // EOF 또는 에러 시 종료

        size_t len = strlen(buf);
        if (len > 0 && buf[len-1] == '\n')
            buf[len-1] = '\0';     // 개행 제거
        if (buf[0] == '\0')
            continue;              // 빈 줄은 건너뛰기

        w = write(sock, buf, strlen(buf));
        if (w < 0) {
            perror("write");
            break;
        }
    }

    close(sock);
    return 0;
}

9일차

호타리 — Wed, 28 May 2025 17:51:41 +0900

2025.05.28

초음파센서 동작

#include <stdio.h>
#include <wiringPi.h>

#define TRIG 27
#define ECHO 28

void setup() {
    wiringPiSetup();
    pinMode(TRIG, OUTPUT);
    pinMode(ECHO, INPUT);
    digitalWrite(TRIG, LOW);
    delay(30);  // 센서 안정화 대기
}

double getDistance() {
    // Trigger pulse
    digitalWrite(TRIG, HIGH);
    delayMicroseconds(10);
    digitalWrite(TRIG, LOW);

    // Echo 신호가 HIGH가 될 때까지 대기
    while (digitalRead(ECHO) == LOW);

    int startTime = micros();

    // Echo 신호가 LOW가 될 때까지 대기
    while (digitalRead(ECHO) == HIGH);

    int endTime = micros();

    // 거리 계산: 왕복 시간 x 음속(0.017 cm/us)
    double distance = (endTime - startTime) * 0.017;
    return distance;
}

int main() {
    setup();

    while (1) {
        double distance = getDistance();
        printf("Distance: %.2f cm\n", distance);
        delay(500);  // 0.5초 간격
    }

    return 0;
}

서보모터와 초음파센서 연동

#include <stdio.h>
#include <wiringPi.h>
#include <softPwm.h>

#define TRIG 27
#define ECHO 28
#define SERVO_PIN 29
#define PWM_RANGE 200

// 각도를 소프트 PWM duty로 변환 (0도:5 ~ 180도:25)
int angleToDuty(int angle) {
    return (5 * (180 - angle) + 25 * angle) / 180;
}

// 거리 측정 함수
double getDistance() {
    digitalWrite(TRIG, LOW);
    delayMicroseconds(2);
    digitalWrite(TRIG, HIGH);
    delayMicroseconds(10);
    digitalWrite(TRIG, LOW);

    while (digitalRead(ECHO) == LOW);
    int startTime = micros();

    while (digitalRead(ECHO) == HIGH);
    int endTime = micros();

    return (endTime - startTime) * 0.017;  // cm
}

// 초기화
int setup() {
    if (wiringPiSetup() == -1) return 1;

    pinMode(TRIG, OUTPUT);
    pinMode(ECHO, INPUT);
    digitalWrite(TRIG, LOW);
    delay(30);

    if (softPwmCreate(SERVO_PIN, 0, PWM_RANGE) != 0) {
        fprintf(stderr, "softPwmCreate failed\n");
        return 1;
    }

    return 0;
}

int main() {
    if (setup() != 0) return 1;

    while (1) {
        double distance = getDistance();
        printf("Distance: %.2f cm\n", distance);

        if (distance < 10.0) {
            // 역회전: 180° → 0°
            for (int ang = 180; ang >= 0; ang -= 5) {
                softPwmWrite(SERVO_PIN, angleToDuty(ang));
                delay(20);
            }
        } else {
            // 정회전: 0° → 180°
            for (int ang = 0; ang <= 180; ang += 5) {
                softPwmWrite(SERVO_PIN, angleToDuty(ang));
                delay(20);
            }
        }

        delay(500);  // 다음 측정까지 대기
    }

    return 0;
}

스텝모터와 초음파센서 연동

#include <stdio.h>
#include <wiringPi.h>

// 초음파 센서 핀 (wiringPi 번호)
#define TRIG    27
#define ECHO    28

// 스텝모터 핀 (wiringPi 번호)
#define ORANGE  21
#define YELLOW  22
#define PINK    23
#define BLUE    24
#define RED     25  // 모터 전원용

// 초음파 거리 측정 함수 (cm)
double get_distance() {
    digitalWrite(TRIG, LOW);
    delayMicroseconds(2);
    digitalWrite(TRIG, HIGH);
    delayMicroseconds(10);
    digitalWrite(TRIG, LOW);

    // Echo 신호 시작 대기
    while (digitalRead(ECHO) == LOW);
    long start_time = micros();
    // Echo 신호 끝 대기
    while (digitalRead(ECHO) == HIGH);
    long end_time = micros();

    // 거리 계산: 왕복 시간(us) × 음속(cm/us) / 2
    return (end_time - start_time) * 0.017;
}

// Full-step 모드 한 스텝 구동
void step_full(int step) {
    switch(step) {
        case 0:
            digitalWrite(ORANGE, HIGH);
            digitalWrite(YELLOW, HIGH);
            digitalWrite(PINK,   LOW);
            digitalWrite(BLUE,   LOW);
            break;
        case 1:
            digitalWrite(ORANGE, LOW);
            digitalWrite(YELLOW, HIGH);
            digitalWrite(PINK,   HIGH);
            digitalWrite(BLUE,   LOW);
            break;
        case 2:
            digitalWrite(ORANGE, LOW);
            digitalWrite(YELLOW, LOW);
            digitalWrite(PINK,   HIGH);
            digitalWrite(BLUE,   HIGH);
            break;
        case 3:
            digitalWrite(ORANGE, HIGH);
            digitalWrite(YELLOW, LOW);
            digitalWrite(PINK,   LOW);
            digitalWrite(BLUE,   HIGH);
            break;
        default:
            break;
    }
}

int main() {
    // wiringPi 초기화
    if (wiringPiSetup() == -1) {
        fprintf(stderr, "wiringPi setup failed\n");
        return 1;
    }

    // 핀 모드 설정
    pinMode(TRIG, OUTPUT);
    pinMode(ECHO, INPUT);
    pinMode(ORANGE, OUTPUT);
    pinMode(YELLOW, OUTPUT);
    pinMode(PINK, OUTPUT);
    pinMode(BLUE, OUTPUT);
    pinMode(RED, OUTPUT);

    // 모터 전원 공급
    digitalWrite(RED, HIGH);

    while (1) {
        double distance = get_distance();
        printf("Distance: %.2f cm\n", distance);

        if (distance < 10.0) {
            // 역회전: 역방향 인덱스 보정 적용
            for (int i = 0; i < 512; i++) {
                int idx = (3 - (i % 4) + 4) % 4;
                step_full(idx);
                delay(5);
            }
        } else {
            // 정회전
            for (int i = 0; i < 512; i++) {
                step_full(i % 4);
                delay(5);
            }
        }

        delay(1000);  // 1초 대기 후 다음 측정
    }

    return 0;
}

8일차

호타리 — Tue, 27 May 2025 16:56:07 +0900

2025.05.27

스텝 모터 동작

#include <stdio.h>
#include <wiringPi.h>

#define ORANGE  21
#define YELLOW  22
#define PINK    23
#define BLUE    24 
#define RED     25

void step_wave(int step)
{   
   switch(step)
   { 
      case 0:
         digitalWrite(ORANGE,1);
         digitalWrite(YELLOW,0);
         digitalWrite(PINK,0);
         digitalWrite(BLUE,0);
         break;
      case 1:
         digitalWrite(ORANGE,0);
         digitalWrite(YELLOW,1);
         digitalWrite(PINK,0);
         digitalWrite(BLUE,0);
         break;
      case 2:
         digitalWrite(ORANGE,0);
         digitalWrite(YELLOW,0);
         digitalWrite(PINK,1);
         digitalWrite(BLUE,0);
         break;
      case 3:
         digitalWrite(ORANGE,0);
         digitalWrite(YELLOW,0);
         digitalWrite(PINK,0);
         digitalWrite(BLUE,1);
         break;
      default:
         break;
   }
}

int main()
{   
   wiringPiSetup();
   pinMode(ORANGE,OUTPUT);
   pinMode(YELLOW,OUTPUT);
   pinMode(PINK,OUTPUT);
   pinMode(BLUE,OUTPUT);
   pinMode(RED ,OUTPUT);  //power line 
   digitalWrite(7,1);
   
   for(int i=0;i<2048;i++) //half or full(wave)
   { 
      step_wave(i%4); //0 1 2 3 0 1 2 3 
      delay(5);
    }
   return(1);
}

#include <stdio.h>
#include <wiringPi.h>

#define ORANGE  21 // 29 (물리적 pin 번호)
#define YELLOW  22 // 31
#define PINK    23 // 33
#define BLUE    24 // 35
#define RED     25 // 37 임시 전원용 : 사용 불가가
#define GND     39 // 39 참고용

void step_wave(int step)
{   
   switch(step)
   { 
      case 0:
        digitalWrite(ORANGE, 1);
        digitalWrite(YELLOW, 0);
        digitalWrite(PINK, 0);
        digitalWrite(BLUE, 0);
        break;
      case 1:
        digitalWrite(ORANGE, 0);
        digitalWrite(YELLOW, 1);
        digitalWrite(PINK, 0);
        digitalWrite(BLUE, 0);
        break;
      case 2:
        digitalWrite(ORANGE, 0);
        digitalWrite(YELLOW, 0);
        digitalWrite(PINK, 1);
        digitalWrite(BLUE, 0);
        break;
      case 3:
        digitalWrite(ORANGE, 0);
        digitalWrite(YELLOW, 0);
        digitalWrite(PINK, 0);
        digitalWrite(BLUE, 1);
        break;
      default:
        break;
   }
}

void step_full(int step)
{
   switch(step)
   {
      case 0: // Coil 1 + Coil 2
	  	digitalWrite(ORANGE, HIGH);
        digitalWrite(YELLOW, HIGH);
        digitalWrite(PINK,   LOW);
        digitalWrite(BLUE,   LOW);
        break;
      case 1: // Coil 2 + Coil 3
        digitalWrite(ORANGE, LOW);
        digitalWrite(YELLOW, HIGH);
        digitalWrite(PINK,   HIGH);
        digitalWrite(BLUE,   LOW);
        break;
      case 2: // Coil 3 + Coil 4
        digitalWrite(ORANGE, LOW);
        digitalWrite(YELLOW, LOW);
        digitalWrite(PINK,   HIGH);
        digitalWrite(BLUE,   HIGH);
        break;
      case 3: // Coil 4 + Coil 1
        digitalWrite(ORANGE, HIGH);
        digitalWrite(YELLOW, LOW);
        digitalWrite(PINK,   LOW);
        digitalWrite(BLUE,   HIGH);
        break;
      default:
        break;
   }
}

void step_half(int step)
{
   switch(step)
   {
      case 0: // Coil 1 only
	  	digitalWrite(ORANGE, HIGH);
        digitalWrite(YELLOW, LOW);
        digitalWrite(PINK,   LOW);
        digitalWrite(BLUE,   LOW);
        break;
      case 1: // Coil 1 + Coil 2
        digitalWrite(ORANGE, HIGH);
        digitalWrite(YELLOW, HIGH);
        digitalWrite(PINK,   LOW);
        digitalWrite(BLUE,   LOW);
        break;
      case 2: // Coil 2 only
        digitalWrite(ORANGE, LOW);
        digitalWrite(YELLOW, HIGH);
        digitalWrite(PINK,   LOW);
        digitalWrite(BLUE,   LOW);
        break;
      case 3: // Coil 2 + Coil 3
        digitalWrite(ORANGE, LOW);
        digitalWrite(YELLOW, HIGH);
        digitalWrite(PINK,   HIGH);
        digitalWrite(BLUE,   LOW);
        break;
      case 4: // Coil 3 only
        digitalWrite(ORANGE, LOW);
        digitalWrite(YELLOW, LOW);
        digitalWrite(PINK,   HIGH);
        digitalWrite(BLUE,   LOW);
        break;
      case 5: // Coil 3 + Coil 4
        digitalWrite(ORANGE, LOW);
        digitalWrite(YELLOW, LOW);
        digitalWrite(PINK,   HIGH);
        digitalWrite(BLUE,   HIGH);
        break;
      case 6: // Coil 4 only
        digitalWrite(ORANGE, LOW);
        digitalWrite(YELLOW, LOW);
        digitalWrite(PINK,   LOW);
        digitalWrite(BLUE,   HIGH);
        break;
      case 7: // Coil 4 + Coil 1
        digitalWrite(ORANGE, HIGH);
        digitalWrite(YELLOW, LOW);
        digitalWrite(PINK,   LOW);
        digitalWrite(BLUE,   HIGH);
        break;
      default:
        break;
   }
}

int main()
{   
   wiringPiSetup();
   pinMode(ORANGE, OUTPUT);
   pinMode(YELLOW, OUTPUT);
   pinMode(PINK, OUTPUT);
   pinMode(BLUE, OUTPUT);
   pinMode(RED , OUTPUT);  //power line 
   digitalWrite(RED,HIGH);
   
   for(int i=0; i < 4096; i++) //half or full(wave)
   {
		// Wave drive
		//step_wave(i % 4);
		//delay(5);
		// Full drive
		step_full(i % 4);
		delay(5);
		// Half-drive
		//step_half(i % 8);
		//delay(5);
   }
   return(1);
}

서보 모터 동작

#include <stdio.h>
#include <wiringPi.h>
#include <softPwm.h>

#define SERVO_PIN 29   // wiringPi 번호 21 → 물리적 핀 29 (BCM 5)
#define PWM_RANGE 200 // 소프트 PWM 분해능 (0–200)

// 서보 펄스 폭(duty)을 각도로 변환: 0° → 5, 90° → 15, 180° → 25 정도
int angleToDuty(int angle) {
    return (5 * (180 - angle) + 25 * angle) / 180;
}

int main(void) {
    // wiringPi 초기화
    if (wiringPiSetup() == -1) {
        fprintf(stderr, "wiringPi setup failed\n");
        return 1;
    }

    // SERVO_PIN에 소프트 PWM 설정 (초기값 0, 범위 PWM_RANGE)
    if (softPwmCreate(SERVO_PIN, 0, PWM_RANGE) != 0) {
        fprintf(stderr, "softPwmCreate failed\n");
        return 1;
    }

    // 서보를 좌우로 왕복시키며 테스트
    while (1) {
        // 0° → 180°
        for (int ang = 0; ang <= 180; ang += 5) {
            int duty = angleToDuty(ang);
            softPwmWrite(SERVO_PIN, duty);
            delay(20);  // 펄스 간격 유지 (20 ms 주기)
        }
        // 180° → 0°
        for (int ang = 180; ang >= 0; ang -= 5) {
            int duty = angleToDuty(ang);
            softPwmWrite(SERVO_PIN, duty);
            delay(20);
        }
    }

    return 0;
}

7일차

호타리 — Tue, 27 May 2025 09:29:42 +0900

2025.05.26

가상환경 (Gstreamer 사용 불가)

기본환경(Gstreamer 사용 가능)

파일 실행 시 Gstreamer 사용 가능한 기본환경으로 실행되도록 설정

import cv2

gst = (
    "v4l2src device=/dev/video0 ! "
    "video/x-raw,format=YUY2,width=640,height=480,framerate=30/1 ! "
    "videoconvert ! "
    "video/x-raw,format=BGR ! "
    "appsink drop=true max-buffers=1"
)
cap = cv2.VideoCapture(gst, cv2.CAP_GSTREAMER)

if not cap.isOpened():
    print("Failed to open pipeline")
    exit()

print("Pipeline opened, starting frame display")
while True:
    ret, frame = cap.read()
    if not ret:
        print("Failed to receive frame")
        break

    cv2.imshow("Live Camera", frame)
    if cv2.waitKey(1) & 0xFF == 27:
        break

cap.release()
cv2.destroyAllWindows()

sudo apt install cmake build-essential pkg-config git

sudo apt install libjpeg-dev libtiff-dev libjasper-dev libpng-dev libwebp-dev libopenexr-dev

방법 1: libjasper-dev 생략하기

OpenCV 대부분의 기능은 libjasper-dev 없이도 잘 동작

sudo apt install libavcodec-dev libavformat-dev libswscale-dev \
libv4l-dev libxvidcore-dev libx264-dev libdc1394-22-dev \
libgstreamer-plugins-base1.0-dev libgstreamer1.0-dev

각 패키지 간단 설명:

패키지	설명
libavcodec-dev, libavformat-dev, libswscale-dev	FFmpeg 관련, 영상 코덱 인코딩/디코딩
libv4l-dev	Video4Linux – 웹캠 등 비디오 입력 장치 지원
libxvidcore-dev, libx264-dev	Xvid, H.264 인코딩 라이브러리
libdc1394-22-dev	FireWire(IEEE 1394) 카메라 지원
libgstreamer1.0-dev, libgstreamer-plugins-base1.0-dev	GStreamer – 멀티미디어 처리 파이프라인 [출처] [Rasberrypi]Open CV\|작성자 jjwkth2

2. 직접 빌드해서 설치 (고급, 성능 최적화 가능)

OpenCV를 직접 빌드하면, 하드웨어 최적화, 모듈 선택, CUDA 지원 등을 세밀하게 설정할 수 있습니다.

사전 패키지 설치

sudo apt update
sudo apt install -y build-essential cmake git pkg-config
sudo apt install -y libjpeg-dev libtiff-dev libpng-dev
sudo apt install -y libavcodec-dev libavformat-dev libswscale-dev
sudo apt install -y libv4l-dev v4l-utils
sudo apt install -y libxvidcore-dev libx264-dev
sudo apt install -y libgtk-3-dev
sudo apt install -y libatlas-base-dev gfortran
sudo apt install -y python3-dev python3-numpy

OpenCV 소스 다운로드

cd ~
git clone https://github.com/opencv/opencv.git
git clone https://github.com/opencv/opencv_contrib.git
cd opencv
git checkout 4.x   # 최신 4버전 사용
cd ../opencv_contrib
git checkout 4.x

CMake로 빌드 설정

cmake -D CMAKE_BUILD_TYPE=RELEASE \
      -D CMAKE_INSTALL_PREFIX=/usr/local \
      -D OPENCV_EXTRA_MODULES_PATH=~/Work/opencv_contrib/modules \
      -D BUILD_EXAMPLES=ON \
      -D WITH_OPENCL=ON \
      -D WITH_TBB=ON \
      -D WITH_OPENGL=ON \
      -D WITH_V4L=ON \
      -D WITH_QT=OFF \
      -D WITH_GTK=ON \
      -D WITH_FFMPEG=ON \
      -D BUILD_OPENCV_PYTHON3=ON \
      -D OPENCV_GENERATE_PKGCONFIG=ON \
      ..

빌드 및 설치

make -j$(nproc)   # 코어 수만큼 병렬 빌드
sudo make install
sudo ldconfig

6일차

호타리 — Fri, 23 May 2025 16:51:05 +0900

2025.05.23

sudo apt install gstreamer1.0-tools gstreamer1.0-plugins-base gstreamer1.0-plugins-good gstreamer1.0-plugins-bad gstreamer1.0-plugins-ugly gstreamer1.0-libav

gst-launch-1.0 v4l2src device=/dev/video0 ! video/x-raw,width=640,height=480,framerate=30/1 ! videoconvert ! jpegenc ! rtpjpegpay ! udpsink host=127.0.0.1 port=5000

Downloads - VideoLAN

목표

Raspberry Pi에 연결된 USB 웹캠 영상을 → GStreamer로 캡처하여 → RTSP 서버로 전송

⇒ 다른 장치에서 실시간 스트리밍 가능 (VLC, OpenCV 등으로 수신)

시스템 구성

[ Raspberry Pi ]
 └── USB Webcam
     └── GStreamer Pipeline
         └── RTSP 서버 (ex: gst-rtsp-server)
             └── RTSP 클라이언트(다른 PC, VLC 등)

✅ 방법 1: GStreamer + gst-rtsp-server 사용 (Python X)

사전 설치

sudo apt update
sudo apt install gstreamer1.0-tools gstreamer1.0-plugins-base gstreamer1.0-plugins-good    gstreamer1.0-plugins-bad gstreamer1.0-plugins-ugly gstreamer1.0-libav

UDP 서버 실행 (예: 640x480 MJPEG)

gst-launch-1.0 v4l2src device=/dev/video0 ! \\
video/x-raw,width=640,height=480,framerate=30/1 ! \\
videoconvert ! \\
x264enc tune=zerolatency ! rtph264pay config-interval=1 pt=96 ! \\ 
udpsink host=127.0.0.1 port=5000

위는 기본 UDP 전송 예제이며, RTSP 서버 구성이 필요할 경우 gst-rtsp-server를 Python 또는 C로 직접 작성해야 합니다.

v=0
c=IN IP4 <127.0.0.1>
m=video 5000 RTP/AVP 96
a=rtpmap:96 H264/90000

✅ 방법 2: Python + GStreamer + RTSP Server 연동

GStreamer 기반 Python RTSP 스트림 생성 예시

Python 코드로 스트리밍 파이프라인 구성:

pip install opencv-python

import cv2
import subprocess

cap = cv2.VideoCapture(0)  # /dev/video0

gst_cmd = (
    "gst-launch-1.0 -v fdsrc ! videoparse width=640 height=480 format=rgb "
    "! videoconvert ! x264enc tune=zerolatency bitrate=512 speed-preset=superfast "
    "! rtph264pay config-interval=1 pt=96 ! udpsink host=127.0.0.1 port=5000"
)

process = subprocess.Popen(gst_cmd, shell=True, stdin=subprocess.PIPE)

while True:
    ret, frame = cap.read()
    if not ret:
        break
    process.stdin.write(frame.tobytes())

✅ 방법 3: gst-rtsp-server (C or Python) 사용

GStreamer 공식 RTSP 서버 라이브러리:

소스: https://github.com/GStreamer/gst-rtsp-server
Raspberry Pi에 빌드하거나 Python 바인딩(py-gst) 사용 가능

예제 코드 참고:

https://github.com/GStreamer/gst-rtsp-server/blob/master/examples/test-launch.c

✅ RTSP 클라이언트에서 수신 (VLC, OpenCV 등)

vlc rtsp://<raspberrypi-ip>:8554/test

또는 OpenCV에서:

cap = cv2.VideoCapture("rtsp://192.168.0.10:8554/test")

테스트 팁

Raspberry Pi에서 v4l2-ctl --list-formats-ext -d /dev/video0 명령어로 해상도/포맷 확인
초기에 MJPEG 포맷이 안정적이며 H264로 전환 시 GPU 부하 주의
RTSP 포트(8554) 방화벽 열려 있어야 외부 접근 가능

GStreamer 개요 및 기본 구조 이해

목표: GStreamer의 기본 철학, 구조, 구성 요소(Element, Pad, Pipeline 등)를 이해하고 CLI 도구를 활용한 구조 확인을 시도한다.

꼭 설명할 개념 + 상세 설명

GStreamer란 무엇인가?
- GStreamer는 영상, 오디오, 네트워크 스트리밍 등 모든 멀티미디어 흐름을 처리할 수 있는 오픈소스 프레임워크입니다.
- 플러그인 기반 구조로 매우 유연하고 확장성이 높습니다.
Pipeline(파이프라인) 구조 이해
- 파이프라인은 여러 요소(Element)를 ! 기호로 연결한 데이터 흐름 구조입니다.
- 데이터를 처음부터 끝까지 순차적으로 처리합니다.
Element란 무엇인가?
- GStreamer의 구성 단위로, 각 Element는 특정 기능을 수행합니다. 예: videotestsrc(소스), autovideosink(출력)
- Source, Filter, Sink 타입으로 구분됨.
Pad란 무엇인가?
- Pad는 Element의 입출력 인터페이스입니다.
- src pad는 데이터를 내보내고, sink pad는 데이터를 받습니다.
- Element 간 연결은 pad를 통해 이루어집니다.
Capabilities (Caps)의 개념
- 데이터의 포맷/속성(해상도, 프레임률, 색상 포맷 등)을 명시하는 구조입니다.
- 서로 다른 Element 간 데이터 연결 가능 여부를 결정합니다.
Push vs Pull 모드
- Push 모드: Source가 데이터를 밀어넣음 (실시간 스트림)
- Pull 모드: Sink가 데이터를 끌어옴 (파일 읽기 등)
플러그인 기반 아키텍처
- GStreamer는 수백 개의 플러그인으로 기능이 확장됩니다.
- 필요 시 사용자 정의 플러그인도 제작 가능.
gst-launch-1.0 도구 소개
- 파이프라인을 CLI로 실행할 수 있는 명령어입니다.
- GStreamer 실습의 핵심 도구로, 빠른 테스트에 유용합니다.
gst-inspect-1.0 도구 사용법
- 특정 Element의 상세한 정보(설정값, 가능한 caps, pad 연결 정보 등)를 보여줍니다.
- 예: gst-inspect-1.0 videoconvert
설치 및 버전 확인 방법

설치: sudo apt install gstreamer1.0-tools
버전 확인: gst-launch-1.0 --version

️ 시범 시연

bash
복사편집
gst-launch-1.0 videotestsrc ! autovideosink

테스트 패턴 영상 출력 확인
Ctrl+C로 중지 가능

실습 과제

videotestsrc, audiotestsrc, audioconvert, autoaudiosink 등을 조합한 파이프라인 구성 실습
gst-inspect-1.0 명령어를 사용해 3개의 Element 정보를 조사하고 발표하기
CLI 기반으로 caps 정보 검색 및 출력 포맷 비교 실습

과제 1: videotestsrc, audiotestsrc 조합 파이프라인 구성

bash
복사편집
gst-launch-1.0 videotestsrc ! autovideosink
gst-launch-1.0 audiotestsrc ! autoaudiosink

과제 2: gst-inspect-1.0 videotestsrc 결과 분석 예시

# 출력 중 주요 부분:
Pad Templates:
  SRC template: 'src'
    Availability: Always
    Capabilities:
      video/x-raw
          format: (string)I420

수업 목표

GStreamer의 파이프라인 구성을 심화하여 다양한 필터와 옵션을 적용하는 법을 익힌다.
capsfilter, videoconvert, filesink 등을 활용한 실제 응용 파이프라인 작성을 실습한다.

핵심 개념 + 상세 설명

Element 간 연결 (!)의 의미
- ! 기호는 Element를 연결하며, 내부적으로는 pad를 연결함.
- 파이프라인 데이터 흐름은 왼쪽 → 오른쪽으로 진행됨.
capsfilter의 개념과 사용 목적
- capsfilter는 특정 포맷, 해상도, 프레임레이트 등으로 데이터 포맷을 고정하는 역할.
- 파이프라인 내 Element 간 caps negotiation을 명시적으로 조절함.
caps 표현 형식
- 예: video/x-raw, width=640, height=480, framerate=30/1
- 쉼표로 구분된 속성들은 AND 조건, 여러 옵션은 OR 형태로 caps 표현 가능.
videotestsrc의 다양한 pattern 사용
- 기본값: smpte, 기타 예: ball, snow, zone-plate
- 패턴을 바꾸면 영상 시각적 특성이 달라짐.
videoconvert의 중요성
- 서로 다른 색상 포맷 간 자동 변환을 지원함.
- 영상 출력 전 videoconvert가 없으면 sink와 연결 실패 가능성 있음.
autovideosink의 동작 방식
- 시스템에 설치된 sink를 자동 선택함 (Xv, OpenGL, Wayland 등)
- 교차 호환성을 위해 권장되는 Sink
gst-inspect를 활용한 caps 확인
- 출력 가능한 형식 및 지원 범위를 직접 확인 가능
gst-inspect-1.0 videotestsrc | grep Caps
filesink Element를 통한 출력 저장
- filesink location=output.raw 과 같이 사용
- 인코딩하지 않은 raw 영상 저장 가능
파이프라인 오류 발생 예시와 분석
- caps 불일치, 누락된 필터, 싱크 미설치 시 negotiation failure 발생
- 예외 메시지 해석 연습
프레임레이트 설정 방식
- framerate=15/1, framerate=30/1 등으로 설정
- 일부 Element는 정확한 fps 지정 없이는 작동 안 됨
dot 파일로 파이프라인 구조 시각화
- 환경 변수로 .dot 파일 생성 → Graphviz로 시각화 가능
```
GST_DEBUG_DUMP_DOT_DIR=/tmp gst-launch-1.0 ...
dot -Tpng /tmp/pipeline.dot -o output.png
```

실습 과제

과제 1: 해상도 지정 파이프라인 구성

gst-launch-1.0 videotestsrc ! video/x-raw,width=320,height=240 ! autovideosink

결과: 320x240 해상도로 출력되는 테스트 영상

과제 2: fps 조절 + pattern 변경 조합 실습

gst-launch-1.0 videotestsrc pattern=ball ! video/x-raw,framerate=10/1 ! videoconvert ! autovideosink

결과: 낮은 fps로 천천히 움직이는 볼 패턴 영상 출력

과제 3: 파일로 영상 저장

gst-launch-1.0 videotestsrc num-buffers=100 ! video/x-raw,format=I420 ! filesink location=test.raw

결과: 100프레임 분량의 raw 영상이 test.raw 파일로 저장됨

예제 코드 설명

num-buffers: 생성할 프레임 수 제한
video/x-raw, format=I420: 기본 색상 포맷 지정
videoconvert 생략 시 오류 발생 가능 (sink의 요구 형식과 불일치할 경우)

✅ 결과 검증 방법

저장된 파일 확인:
ls -lh test.raw
caps 설정 변경에 따른 출력 영상 변화를 직접 시각적으로 비교
잘못된 파이프라인 실행 시 ERROR: from element 로그 해석 훈련

라즈베리파이에서 웹캠 이미지 실시간 송출

윈도우에서 웹캠 이미지 실시간 수신

라즈베리파이 터미널 명령어

gst-launch-1.0 v4l2src device=/dev/video0 ! video/x-raw, width=640, height=480, framerate=30/1 ! videoconvert ! x264enc tune=zerolatency bitrate=800 speed-preset=superfast ! rtph264pay config-interval=1 pt=96 ! udpsink host=10.10.16.11 port=5000

윈도우 텍스트 파일

sudo lsof /def/video0

sudo kill -9 (번호)

실시간 웹캠 영상 녹화 후 저장

카메라 입력 처리 (v4l2src)

목표: Raspberry Pi 또는 일반 Linux 환경에서 USB 웹캠을 GStreamer에 연결하고, 실제 영상을 캡처하여 파이프라인으로 처리할 수 있도록 한다.

꼭 설명할 개념 + 상세 설명

/dev/video0의 의미와 다중 장치 식별

Linux 시스템에서 /dev/video0, /dev/video1은 각각의 비디오 입력 장치를 나타냅니다.

웹캠이 하나만 연결되어 있다면 보통 /dev/video0에 해당합니다.

ls /dev/video*로 연결 상태를 확인하고, v4l2-ctl --list-devices로 장치 목록 조회 가능.

v4l2src Element의 역할

v4l2src는 Video4Linux2 장치 인터페이스를 통해 웹캠에서 실시간으로 영상을 받아오는 GStreamer Source Element입니다.

Raspberry Pi나 USB 기반 웹캠에서 모두 사용할 수 있음.

웹캠 장치 지원 포맷 확인

Shell

복사

bash 복사편집 v4l2-ctl --list-formats-ext

출력되는 포맷(MJPEG, YUYV 등)과 해상도/프레임레이트 목록을 바탕으로 GStreamer 파이프라인 구성 필요.

지원 포맷에 맞는 caps 명시

v4l2src는 장치에서 지원하는 포맷과 해상도로만 데이터를 출력 가능함.

예시:

Shell

복사

bash 복사편집 gst-launch-1.0 v4l2src ! video/x-raw, width=640, height=480 ! autovideosink

MJPEG과 YUY2(YUYV)의 차이

MJPEG: 이미 압축된 JPEG 프레임을 순차적으로 전송 → CPU 부하 적음

YUY2: 압축되지 않은 RAW 포맷 → 후속 변환 필수

videoconvert 필수성

v4l2src에서 출력된 포맷이 Sink와 맞지 않으면 중간에 변환 Element 필요

예: MJPEG → RGB → autovideosink 출력 위해 jpegdec + videoconvert 필요

sync=false 설정 이해

실시간 성능 향상을 위해 autovideosink sync=false 옵션을 사용하면 버퍼 지연 없이 출력 가능

지연 시간이 문제될 경우 유용함

fps 조절 (프레임레이트 설정)

Shell

복사

bash 복사편집 video/x-raw, framerate=30/1

웹캠이 지원하는 최대 프레임레이트 확인 후 설정해야 함

잘못 설정 시 pipeline negotiation 실패 발생

latency 및 출력 지연 분석

MJPEG과 YUYV 포맷 비교 시 latency 차이 체험

실시간 영상 처리에 있어 필터 수, 포맷 복잡도 등이 지연에 영향을 줌

다양한 Sink 조합

autovideosink, glimagesink, fakesink 등 다양한 출력 장치 실험

Raspberry Pi에서는 glimagesink가 GPU 가속 지원

시범 시연

Shell

복사

bash 복사편집 # 기본 실시간 영상 출력 gst-launch-1.0 v4l2src device=/dev/video0 ! videoconvert ! autovideosink # MJPEG 포맷을 명시 gst-launch-1.0 v4l2src device=/dev/video0 ! image/jpeg, width=1280, height=720 ! jpegdec ! videoconvert ! autovideosink

실습 과제

v4l2-ctl을 사용해 사용 가능한 해상도와 포맷을 조사하고 노트에 정리

MJPEG / YUYV 포맷 각각을 이용해 영상 출력 파이프라인 구성

sync=false vs 기본 모드의 출력 지연 차이 비교

해상도별 처리 속도 차이 비교 (640x480 / 1280x720 / 1920x1080)

파이프라인 중 videoconvert 제거 후 오류 발생 여부 확인

과제 1: 포맷 확인

Shell

복사

bash 복사편집 v4l2-ctl --list-formats-ext

과제 2: MJPEG 기반 웹캠 출력

Shell

복사

bash 복사편집 gst-launch-1.0 v4l2src ! image/jpeg,width=1280,height=720 ! jpegdec ! autovideosink

과제 3: sync=false 실험

Shell

복사

bash 복사편집 gst-launch-1.0 v4l2src ! videoconvert ! autovideosink sync=false

IM 시리즈

호타리 — Fri, 23 May 2025 16:08:52 +0900

대답의 처음 5초는 스크립트 냄새가 난다

질문에 어떻게 대답을 시작할 지 미리 연습하기

시작하는 방법이 매번 다를 수 있을 정도로 다양해야 함

단, 그 자리에서 바로 생각하는 것처럼 들리는 것이 중요

ex) Well... / You know... / Let me see... / Oh, you wanna know about... / etc

가장 중요한 영어 공부법

1. 컨트롤 전략 → MP → 나머지 대답

2. MP → 컨트롤 전략 → 나머지 대답

MP 마스터하기

- 대답은 2분 내로 짧고 깔끔하게 하는 것이 좋음

- MP를 통해 요점을 깔끔하게 말할 수 있음

- 일부러 길게 말할 필요 없음

- 연습할 때는 엄청 간단히 짧게 한 문장으로 대답

질문 컨트롤하기

- 포괄적으로 질문 → 하나로 답하기

- general → singular control 전략

- 대화하는 느낌

질문 들을 때

- 처음 들을 때 Topic과 카테고리가 무엇인지

- 두 번째 들을 때 카테고리에 따른 전략 생각하기

- 카테고리 모르겠거나 무슨 질문인지 이해안가면 과갑하게 스킵

7규칙

1. 질문할 때는 대답이 필요없는 질문으로 하기

2. 불편하고 어려운 단어 사용하지 않기 (사용하기 편하고 자신 있는 간단한 단어 사용)

3. 한 문장에서 같은 단어 반복 X

4. 무언가를 묘사하거나 감정단어 2개를 말할 때 'and' 사용하지 말고 단어 2개를 두 문장으로 나누기

5. 한 가지에 대해서만 말하기, 질문이 여러 개이면 하나를 선택해서 집중적으로 대답

6. 긴장이 되고 할 일이 없을 땐 바로 결론으로 가기 (너무 짧아도 그냥 끝내기)

7. '솔직한 변명'은 나중에 하기, 처음 부분에서 하지 않기, 두괄식으로 말하기

Combo Set

1. description + past experience

2. habit + past experience

3. comparison + past experience

- 의사소통 기술 향상

- 문법을 잘 하는 것처럼 보이게 하기 위해서

4 카테고리

1. Description 설명

2. Habit 습관

3. Past Experience 과거 경험 (제일 중요)

4. Comparison 비교

다른 문법보다 과거 문법이 제일 중요

어떤 질문을 연습하더라도 과거형으로 대답하기

대답을 깔끔하게 하는법

- 4가지 카테고리에 따라 다름

- 설명과 습관에 대한 대답은 짧다고 느껴지는 정도

- quick comparison 전략 → 과거에 대해 살짝 이야기

Description 전략 (설명 / 묘사)

- 짧게 이야기하고 넘어가도 됨

- 15번 문제에 나오면 빠른 비교로 보충 설명하기

- MP 2문장으로 설명 : 좋은지 싫은지, 그 이유

- people (MP) → me (나의 생각) → 감정 넣어서 설명 → 돌아가서 다시 MP 설명

1. 말하고 싶은 것 말하기 (MP)

2. 어떻게 느끼는지

3. 왜 그렇게 느끼는지

4. 결론

ex) My favorite ~ 대신 사용하기 좋은 표현

- I like / I really like / I love / I really love / etc

- What I reaaly love/like/hate about ~

Habit 전략 (습관)

- 일반적인 MP 설명 : 감정 설명 X

- 항상 현재나 미래로 대답

- 반드시 '한가지'에 대해서 말할 것

- 설명보다는 행동 묘사하는 질문일 경우에 해당

usually do

first thing that you do

- 스크립트 X

- 표현만 익히고 샘플 외우지 말고 프리토킹

- 살짝 변형해서 본인의 것으로 만들기

1. 뭐하는지 나의 습관 설명

2. 나한테는 너무 중요하다고 표현

3, 4. 프리토킹

5, 6. 빠른 비교 (과거 → 현재)

빠른 비교 방법

- 빨리 과거로 갔다가 바로 원래 이야기로 돌아오기

- 예전에는 이랬는데 요새는 이렇다

- 1, 2 문장 추가

ex) I never really did this before, but nowadays, I just love doing this. I just can't explain it.

Past Experience 전략

- MP에 클라이맥스를 미리 말하기

- 주제를 예측할 수 있도록

1. MP (무엇을, 어떻게, 왜)

2. Direct quatation (직접화법)

3. 결론

IM : 직접화법 = 나에 대해서 집중

IH : 직접화법 + 간접화법 = 나 + 다른 사람 (내가 이렇게~, 그/그녀가 이렇게~) (이름 직접 언급하면 더 자연스러움)

Comparison 전략

= description 전략 + past experience 전략

- 비교 질문에 대답하는데 멘붕이 될 때

1. 스킵

2. 이미 대답을 시작했다면 : MP없이 바로 과거부터 설명, 과거 사실에 집중 → 현재 설명 → 결론

시간 비교 전략

1. MP : Pure present

완전 현재형으로, 현재에 대해서만 집중해 간단하게

2. 과거에 대해서만 말하기

3. 현재 설명

4. 결론

일반 비교 전략 (none-time)

1. general MP (전반적인 이야기)

2. A 설명 → B 설명 → 결론

Habit 예시
Bank 은행

ex) What do you usually do whenever you go to the bank?

[무조건] No matter what

[있잖아]

Well, here's the thing

I'll tell you what

You know what?

[내가 ~할 때, 나는 ~ 한다]

1. Whenever I ~ I always make sure to ~

2. Every time ~ I always check to see that/if I have ~ with me.

[이건 정말 중요해요. 왜냐하면 ~]

This is crucial because ~

This is very important because ~

I find this very important to me because ~

[~할 수 밖에 없었다] I was forced ~

[아무것도 할 수 없었다]

I wasn't able to do anything ~

I couldn't do anything ~

Transportation 교통

<메인 포인트>

기본구조, 1가지에 대해서만 말하도록

1. No matter what,

whenever I need to go somewhere.

I always take the 'subway or bus'.

2. This is crucial,

It's quite rare for me to take other potions.

<부연설명, 프리스타일> how → why 설명

3. I love 'how' I can read something while taking the public transit.

4. It's the only time I can actually (정말로, 진짜로) read.

<빠르게 과거로 갔다가 현재로 돌아오기> 빠른 비교

5. It's interesting cos I've never liked reading before.

6. I still don't, but I love how it helps me to kill time especially while I'm commuting.

Recycling 재활용

<메인포인트>

1. Every time I need to recycle, I always check to see that all the cans and plastic bottles are crushed to save space.

2. This is very important.

It's really rare for me to forget to check.

<프리스타일>

3. I'm quite lazy so I hate having to recycle if I don't have to.

4. I take out the recycling only when my bins are full to the max.

<빠른 비교>

5. It's interesting cos I had to recycle nearly every day before.

6. But now, with my new method of cushing everything. I recycle every 2 weeks.

Appointments 예약

1. I'll tell you what. I always make a hair appointment pretty much every 2 weeks.

2. I find this very important. It's very rare for me to skip a hair-cut.

3. Of course, I make other appointments as well in my life, but this one is the most important to me.

4. My hair has a mind of its own, so I need it to be well maintained.

5. It's interesting cos I never cared about my hair before.

6. But these days, I feel my hair gives me confidence.

Filler 필러

- 필러는 엑스트라 추가

- 빨리 말해야 함

- 대화가 부드럽게 만들어주는 것

- you know, right, um('엄...')

ex) When ever I recycle right, I always make sure to you know tie my bag.

추천 표현/문장/감탄사

- Wow, It's quite a tough question.

- Wow, That's tough.

- Wow, Ididn't expect such a hard question.

- Wow, That's not an easy question.

- 대답 시작 시 Umm... 길게

- 같은 것을 다시 설명할 때 you know ~

- 다른 것을 부연 설명할 때 I mean ~

- 나의 생각, 감정 나타내기

I love ~ / I think ~

- (내가 이렇게 느꼈다) 감정표현

I feel/felt like

- ~한 기분이 든다

It makes me feel ~

- even : 놀라운 것에 대한 대답에 사용

- Oh : oh로 시작하여 질문 BUT 어색한 질문 금지

- wanna : 발음 부드럽게

- (looks) like : similar (직유법)

- home : house, apartment 대신 집 표현

- space : place 대신 장소 표현

- usually : 보통

- just : '단지' 주어 바로 뒤에 자연스럽게 사용

- That's why : 그러니까, 그래서

- 질문 복기, alright ~ : 짧은 문장으로 질문 복기해 생각하고 있음을 보여줌

- It's just right for me.

- It's perfect.

- And you know what? 그리고 있잖아요?

- I just don't know why! 나도 이유를 모르겠어!

- I just can't explain! 설명은 못하겠어!

- Whether I like it or not 좋던 싫던

- as I already told you before 내가 전에 말했던 것처럼

- don't get me wrong 오해하진 마

- I love them to death 그들을 죽을만큼 사랑해

- That's all / That's it / Thank you 사용 금지

주제별 표현
집

- low rent → save money

- less cleaning → save time

- stronger wifi signal

- I'm barely/rarely home

- I'm like never home

- I only come home to sleep

- everything what I want 대신

I can do whatever I feel like.

I really love having my own time. It's the best.

- It helps me to relax

- It makes me feel so good to watch movies all day.

- I can't remember very specifically, but one thing I do remember is that it was clearly a huge house.

- Even though it's definitely a bigger place. I still feel like it's not that big.

- My place is big, but I still want a bigger place.

휴가

- So, whether I like it or not.

- I have to be with my parents.

- I have no choice but to be with my parents.

- I'm totally stuck with my parents.

- I'm not an outgoing person at all.

- I'm not extroverted at all.

- So, I prefer to be by myself.

- So, I prefer to spend time alone.

- ~ rather than spend time with someone.

- ~ rather than hang out/meet people/go out

- I really hope I can move out soon.

- I really want to get out of here soon.

- out of은 [outta]로 부드럽게 발음

방구 표현 4가지

- fart = 방구

- let it rip / let one rip

- cut cheese

- thunder from down under

- silent but deadly

응가 표현 4가지

- number 1 (소변)

- number 2 (대변)

- take a dump 응가 마렵다

- deuce it 응가하다

집 설명 → MP 살리기

1. You know, I got to say, what I really love about my place is my storage room.

2. It's just so spacious.

3. You see, My home isn't all that big.

4. But, you know, it's not all that small either.

5. But none of that really matters I guess because I love how big my storage room is.

패션 묘사

Q. What do people usually wear in your country?

1. You know, I gotta say, what I really hate about fashion here in Korea is that people tend to only wear safe colors.

2. I find it quite boring (find it = think, quite = little, so)

3. You see, for me, I try not to follow those trends.

4. I try to be as colorful as possible.

5. I guess, you can say that I like to stand out.

가구 묘사

Q. Tell me about the furniture in your home.

1. What I really find interesting about my work dsek is that it's the only dark furniture I have at home.

2. It's completely black and totally stands out in my living room.

3. It's funny cos (all) my other furniture is light in color.

4. black 책상 이야기

5일차

호타리 — Thu, 22 May 2025 16:38:03 +0900

2025.05.22

source yolov5/yolov5-env/bin/activate

1. 라즈베리파이의 Pictures 디렉토리에 있는 이미지 파일을 선택하여 YOLO 모델 탐지를 수행하고 그 결과 이미지를 화면에 출력하시오. 출력 화면에는 TrackBar 를 설치하여 Slide를 조정함에 따라 Confidence 값이 미달하는 객체는 탐지결과에서 제외되도록 구성하시오.

2. 동일한 기능을 WebCam 화면에도 적용하여 동영상 객체 인식을 구현하시오.

import cv2
import torch
import numpy as np
import os
from glob import glob

# Load YOLOv5s model (pretrained)
model = torch.hub.load('ultralytics/yolov5', 'yolov5s', pretrained=True)
model.eval()

def detect_and_show_static(img_path):
    img = cv2.imread(img_path)
    if img is None:
        print(f"Failed to load {img_path}")
        return

    window = 'Image Detection'
    cv2.namedWindow(window)
    cv2.createTrackbar('Confidence %', window, 50, 100, lambda x: None)

    while True:
        thresh = cv2.getTrackbarPos('Confidence %', window) / 100.0
        model.conf = thresh
        results = model(img)

        display = img.copy()
        for *box, conf, cls in results.xyxy[0].cpu().numpy():
            x1, y1, x2, y2 = map(int, box)
            label = f"{model.names[int(cls)]}: {conf:.2f}"
            cv2.rectangle(display, (x1, y1), (x2, y2), (0, 255, 0), 2)
            cv2.putText(display, label, (x1, y1 - 5),
                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)

        cv2.imshow(window, display)
        key = cv2.waitKey(30) & 0xFF
        if key == 27:  # ESC
            break
        elif key == ord('n'):
            break

    cv2.destroyWindow(window)

img_files = glob(os.path.expanduser('~/Pictures/*.[jp][pn]g'))
for img_path in img_files:
    print("Showing:", img_path)
    detect_and_show_static(img_path)

def webcam_detection():
    window = 'WebCam Detection'
    cv2.namedWindow(window)
    cv2.createTrackbar('Confidence %', window, 50, 100, lambda x: None)

    cap = cv2.VideoCapture(0)
    if not cap.isOpened():
        print("Webcam open failed")
        return

    while True:
        ret, frame = cap.read()
        if not ret:
            break

        thresh = cv2.getTrackbarPos('Confidence %', window) / 100.0
        model.conf = thresh
        results = model(frame)

        for *box, conf, cls in results.xyxy[0].cpu().numpy():
            x1, y1, x2, y2 = map(int, box)
            label = f"{model.names[int(cls)]}: {conf:.2f}"
            cv2.rectangle(frame, (x1, y1), (x2, y2), (255, 0, 0), 2)
            cv2.putText(frame, label, (x1, y1 - 5),
                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 1)

        cv2.imshow(window, frame)
        if cv2.waitKey(1) & 0xFF == 27:
            break

    cap.release()
    cv2.destroyAllWindows()

webcam_detection()

3. 'Person' 이 감지될 경우 영상을 저장하고 계속 감시. (기타 객체 무시)

import cv2
import torch
import numpy as np
import os
from glob import glob
from datetime import datetime

model = torch.hub.load('ultralytics/yolov5', 'yolov5s', pretrained=True)
model.eval()

SAVE_DIR = "person_captures"
os.makedirs(SAVE_DIR, exist_ok=True)

def detect_and_show_static(img_path):
    img = cv2.imread(img_path)
    if img is None:
        print(f"Failed to load {img_path}")
        return

    window = 'Image Detection'
    cv2.namedWindow(window)
    cv2.createTrackbar('Confidence %', window, 50, 100, lambda x: None)

    while True:
        thresh = cv2.getTrackbarPos('Confidence %', window) / 100.0
        model.conf = thresh
        results = model(img)

        display = img.copy()
        for *box, conf, cls in results.xyxy[0].cpu().numpy():
            x1, y1, x2, y2 = map(int, box)
            label = f"{model.names[int(cls)]}: {conf:.2f}"
            color = (0, 255, 0) if int(cls) == 0 else (255, 0, 0)
            cv2.rectangle(display, (x1, y1), (x2, y2), color, 2)
            cv2.putText(display, label, (x1, y1 - 5),
                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 1)

        cv2.imshow(window, display)
        key = cv2.waitKey(30) & 0xFF
        if key in (27, ord('n')):
            break

    cv2.destroyWindow(window)

img_files = glob(os.path.expanduser('~/Pictures/*.[jp][pn]g'))
for img_path in img_files:
    print("Showing:", img_path)
    detect_and_show_static(img_path)

def webcam_detection():
    window = 'WebCam Detection'
    cv2.namedWindow(window)
    cv2.createTrackbar('Confidence %', window, 50, 100, lambda x: None)

    cap = cv2.VideoCapture(0)
    if not cap.isOpened():
        print("Webcam open failed")
        return

    while True:
        ret, frame = cap.read()
        if not ret:
            break

        thresh = cv2.getTrackbarPos('Confidence %', window) / 100.0
        model.conf = thresh

        results = model(frame)
        detections = results.xyxy[0].cpu().numpy()

        person_detected = False
        for x1, y1, x2, y2, conf, cls in detections:
            cls = int(cls)
            label = f"{model.names[cls]}: {conf:.2f}"
            color = (255, 0, 0)
            cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), color, 2)
            cv2.putText(frame, label, (int(x1), int(y1) - 5),
                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 1)

            if cls == 0:
                person_detected = True

        if person_detected:
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
            save_path = os.path.join(SAVE_DIR, f"person_{timestamp}.jpg")
            cv2.imwrite(save_path, frame)
            print(f"??? Person detected! Saved to {save_path}")

        cv2.imshow(window, frame)
        if cv2.waitKey(1) & 0xFF == 27:
            break

    cap.release()
    cv2.destroyAllWindows()

webcam_detection()

4일차

호타리 — Wed, 21 May 2025 16:51:31 +0900

2025.05.21

OpenCV: OpenCV-Python Tutorials

import cv2

def nothing(x):
    pass

cap = cv2.VideoCapture(0)

cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)

cv2.namedWindow('Filtered')

cv2.createTrackbar('Filter', 'Filtered', 0, 3, nothing)
cv2.createTrackbar('Kernel', 'Filtered', 1, 20, nothing)
cv2.createTrackbar('Thresh', 'Filtered', 127, 255, nothing)
cv2.createTrackbar('Canny Min', 'Filtered', 50, 255, nothing)
cv2.createTrackbar('Canny Max', 'Filtered', 150, 255, nothing)

while True:
    ret, frame = cap.read()
    if not ret:
        break

    filter_type = cv2.getTrackbarPos('Filter', 'Filtered')
    kernel_size = cv2.getTrackbarPos('Kernel', 'Filtered')
    thresh_val = cv2.getTrackbarPos('Thresh', 'Filtered')
    canny_min = cv2.getTrackbarPos('Canny Min', 'Filtered')
    canny_max = cv2.getTrackbarPos('Canny Max', 'Filtered')

    if kernel_size % 2 == 0:
        kernel_size += 1
    if kernel_size < 1:
        kernel_size = 1

    result = frame.copy()

    if filter_type == 1:
        result = cv2.GaussianBlur(result, (kernel_size, kernel_size), 0)
    elif filter_type == 2:
        gray = cv2.cvtColor(result, cv2.COLOR_BGR2GRAY)
        _, result = cv2.threshold(gray, thresh_val, 255, cv2.THRESH_BINARY)
    elif filter_type == 3:
        gray = cv2.cvtColor(result, cv2.COLOR_BGR2GRAY)
        result = cv2.Canny(gray, canny_min, canny_max)

    cv2.imshow('Filtered', result)

    if cv2.waitKey(1) & 0xFF == 27:
        break

cap.release()
cv2.destroyAllWindows()

3일차

호타리 — Tue, 20 May 2025 16:52:30 +0900

2025.05.20

Raspberry Pi 4(Bookworm)에서 WiringPi 설치해서 사용하기

sudo apt-get install python3-opencv -y

2일차

호타리 — Thu, 15 May 2025 16:40:52 +0900

2025.05.15

무선 LAN 설정

sudo nmtui

sudo raspi-config

cd /etc/NetworkManager/system-connections

sudo apt-get update

sudo apt-get install vim

sudo apt-get install ibus ibus-hangul

sudo apt-get install fonts-nanum fonts-unfonts-core

1일차

호타리 — Wed, 14 May 2025 16:47:29 +0900

2025.05.14

라즈베리 파이란?

- 영국의 라즈베리 재단에서 학교와 개발도상국의 기초 컴퓨터 교육의 증진을 위해 개발한 싱글 보드 컴퓨터

- 신용카드 크기의 초소형 컴퓨터

- 뛰어난 그래픽 성능과 저렴한 가격

- CPU는 브로드컴 사의 BCM 시리즈를 주로 사용

- 기존 데스크탑 PC와 비슷하게 키보드, 모니터 등의 주변기기와 연결해 사용 가능

장점

- 온전히 독립된 컴퓨터

- 다양하고 풍부한 공개 소프트웨어

- 주변 장치를 연결하기 쉬운 인터페이스

- 신용카드 크기로 소지하기에 부담이 없음

- 활용도가 높아 다양한 프로젝트 작품에 사용되고 있음

IPv4 주소 확인

Mini Project1 - No Smoking Area Project (with YOLOv8)

호타리 — Tue, 13 May 2025 14:18:24 +0900

2025.05.13

금연구역 흡연자 식별 프로젝트 개요

프로젝트 개요

프로젝트명: 금연구역 흡연자 실시간 탐지 및 웹 알림 시스템
목표: CCTV 또는 웹캠으로 입력되는 영상에서 흡연 행위 탐지 후 웹 서버를 통해 경고 및 저장하는 시스템 구축
기술요소: YOLOv8 + Flask + OpenCV 기반 영상 스트리밍 및 객체 탐지

️ 실행 흐름 요약

[웹캠 영상 수신]
        ↓
[YOLOv8로 person/cigarette 탐지]
        ↓
[담배가 사람 박스 내부? → YES]
        ↓
[30 프레임 이상 유지? → YES]
        ↓
[1회 카운트 증가 + 이미지 저장 + 빨간 화면 + 경고 문구 출력]

주요 기능

기능설명

객체 탐지	person, cigarette 클래스 YOLOv8 모델로 실시간 탐지
포함 판단	담배 박스가 사람 박스 안에 포함되면 흡연 행위로 판단
️ 프레임 저장	탐지된 흡연 이미지 자동 저장 (폴더 및 static 디렉토리)
경고 출력	"Stop Smoking Please." 문구 및 빨간 오버레이 처리
웹 제공	Flask 서버에서 실시간 스트리밍 + 최근 이미지 확인 UI 제공

이미지 저장 조건	지속 시간 조건 만족 시 한 번만 저장
중복 저장 방지	✅ is_counted 플래그로 1회 저장 후 무시
프레임 기반 조건	✅ SMOKE_DETECT_THRESHOLD (기본 30프레임) 도입
탐지 시 오버레이	동일하게 붉은 배경 + 텍스트 출력 유지

️ 기술 구성

항목사용 기술

웹 서버	Flask
영상처리	OpenCV (cv2.VideoCapture, cv2.rectangle, cv2.imwrite)
객체탐지	YOLOv8 (ultralytics 라이브러리)
실시간 스트리밍	multipart/x-mixed-replace MIME 타입 사용
UI 템플릿	index.html (최근 감지 이미지와 흡연자 수 표시)

data.yaml (Roboflow 기반) 분석

주요 요소 해설

항목설명

train, val, test	각각의 이미지 경로 지정. 절대경로를 사용하여 Windows PC 환경에서 구성됨
nc	클래스 수: 2개 (cigarette, person)
names	클래스 이름 리스트
roboflow	Roboflow에서 자동으로 추가된 메타데이터 정보. 데이터셋의 출처, 프로젝트명, 라이선스 등 포함

학습 과정 개요

✅ 데이터셋 구성

항목내용

클래스	person, cigarette
총 인스턴스 수	person: 약 6,800개 / cigarette: 약 6,400개
이미지 내 객체 위치	대부분 중앙 중심에 분포 (center bias 존재)
바운딩 박스 크기	cigarette는 작고 compact, person은 상대적으로 큼
데이터 불균형 여부	심각한 imbalance는 아님 (비슷한 수준)

바운딩 박스 통계 시각화

cigarette: 소형 객체, 중앙 밀집
person: 다양한 크기와 위치
너비-높이 분포에서 cigarette는 작은 범위에 집중

학습 결과 분석

성능 지표

F1 최적 confidence: 0.308 (F1 score = 0.77)
Precision 최적 confidence: 0.874 (Precision = 1.00)
Recall 최고점: 0.90 (at confidence = 0.0)

학습 곡선 분석 (results.png)

항목경향

train/box_loss, cls_loss, dfl_loss	안정적 감소
val/cls_loss, val/dfl_loss	일부 노이즈 존재, 전체적 감소 추세
precision, recall	점진적 상승 (최종 Precision ~0.78, Recall ~0.75)
mAP@0.5	약 0.775 도달
mAP@0.5:0.95	약 0.32 도달

문제점 및 개선점

cigarette 클래스에서 Precision/Recall 낮음 → 작은 객체 탐지 강화 필요
중앙 밀집 데이터 특성으로 인해 실제 응용시 오탐 가능성 존재 → 배경 다양화 필요

모델 응용: 실시간 경고 시스템

동작 방식

실시간 웹캠 또는 영상 스트림 처리
객체 탐지 수행 후, 담배 bounding box가 사람 bounding box에 완전히 포함되면:
- "금연구역입니다. 나가주세요" 문구 화면 출력
- (선택) TTS로 음성 경고 가능

사용 코드

YOLO('best.pt') 로 커스텀 모델 불러오기
OpenCV VideoCapture로 프레임 추출
box.xyxy, box.cls, results.names를 활용한 후처리
포함 조건: person_box가 cigarette_box를 완전히 포함할 경우
cv2.putText()로 경고 문구 표시

향후 개선 방향

데이터 증강: Mosaic, CutMix, Copy-Paste
소형 객체 특화 백본 적용 (YOLO-NAS, EfficientDet 등)
CCTV 연동 및 경고 시스템 자동화
TTS 및 알람 시스템 연동 (ESP32, Raspberry Pi로 IoT 연동도 가능)

1. F1-Confidence Curve 분석 (F1_curve.png)

전체 최고 F1 score = 0.77 @ confidence = 0.308
클래스별 F1 성능:
- person: 전체적으로 높은 F1-score 유지 (최고 약 0.9)
- cigarette: F1-score가 낮고 변동폭이 큼 (최고 약 0.65)
해석:
- 모델은 사람(person)을 잘 탐지하지만 담배(cigarette) 탐지는 상대적으로 어려움
- 가장 이상적인 confidence threshold는 약 0.308

2. Precision-Confidence Curve 분석 (P_curve.png)

전체 precision = 1.0 @ confidence = 0.874
클래스별 precision:
- person: 높은 precision 유지 (0.9 이상)
- cigarette: 낮은 confidence에선 precision 저조, 0.8 부근에서 최댓값 근접
해석:
- 높은 confidence일수록 precision 향상됨
- cigarette 클래스는 오탐지 비율이 높음 (false positive 많음)

3. Recall-Confidence Curve 분석 (R_curve.png)

전체 recall = 0.90 @ confidence = 0.000
confidence가 증가할수록 recall 감소
person: 높은 recall 유지 (0.85 이상)
cigarette: confidence 0.3 이상에서 recall 급감
해석:
- 낮은 confidence에서도 많은 객체 탐지됨 (recall ↑) → false positive 증가 가능성 있음
- cigarette은 recall과 precision을 균형 있게 잡기 어려움

4. 학습 곡선 (results.png)

Training 손실 감소:
- box_loss, cls_loss, dfl_loss 모두 꾸준히 감소 → 학습은 잘 진행됨
Validation 손실:
- val_cls_loss: 안정적으로 감소
- val_box_loss, val_dfl_loss: 비교적 노이즈 많고 다소 불안정
성능 지표:
- Precision(B): 점진적으로 상승 (약 0.78)
- Recall(B): 0.60 → 0.75까지 향상
- mAP50(B): 약 0.775 도달
- mAP50-95(B): 약 0.32 도달
해석:
- 전반적으로 precision, recall, mAP 모두 향상 중
- validation loss에서 약간의 노이즈는 있지만 추세는 안정적임
- 모델 성능은 양호하지만 cigarette 클래스 개선 필요

✅ 종합 평가

항목평가

사람(person) 탐지 성능	매우 우수 (Precision/Recall/F1 모두 높음)
담배(cigarette) 탐지 성능	낮음 (precision, recall, F1 모두 낮고 민감)
F1 최적 threshold	0.308 (전체 F1 score 최대화 지점)
최종 Precision	1.00 (confidence 0.874에서)
모델 개선 포인트	담배 객체 탐지 데이터 추가 학습 / class imbalance 해결 / hard negative mining 적용 권장

1. 클래스별 인스턴스 수 분포 (좌측 상단 바 그래프)

클래스:
- cigarette: 약 6,400개
- person: 약 6,800개
해석:
- 두 클래스 간 데이터 수는 비교적 균형적이나, 약간의 불균형은 존재함 (person이 조금 더 많음)
- class imbalance 문제가 심각하진 않음 → 모델 학습에 큰 영향을 주진 않지만 정밀한 탐지를 위해 담배 클래스 추가 확보 고려 가능

2. 바운딩 박스 시각화 (우측 상단)

이미지 전체에서 각 클래스의 바운딩 박스 위치를 선으로 표시한 것
cigarette: 진한 파란색 / person: 밝은 하늘색
해석:
- 대부분의 객체는 이미지 중앙에 위치
- cigarette 클래스는 크기가 작고 상대적으로 중앙에 몰림
- person 클래스는 크고 화면 전체에 고르게 분포됨
- 이 차이 때문에 모델이 cigarette을 잘 탐지하지 못할 수 있음 (작은 객체 탐지 어려움)

3. 중심 좌표 분포 (좌측 하단, x-y 분포 히트맵)

바운딩 박스 중심의 (x, y) 좌표 히트맵
중심은 대체로 이미지 중앙 근처 (0.5, 0.5)에 밀집됨
해석:
- 데이터셋이 중앙에 객체가 위치한 경우가 많음 → 중심성 편향(Center Bias) 존재
- 이는 모델의 일반화 성능에 영향을 줄 수 있음 (모델이 중심에만 집중하게 됨)

4. 크기 분포 (우측 하단, width-height 히트맵)

바운딩 박스의 너비와 높이 분포
대부분의 객체는 (width, height) ≈ (0.1~~0.3, 0.1~~0.3) 영역에 분포
cigarette 클래스는 더 작은 영역에 몰릴 가능성이 큼
해석:
- 작은 객체 비율이 높고, 비율이 다양한 객체 존재
- 이는 소형 객체 검출에 어려움을 줄 수 있음
- anchor 설정 / augmentation 전략에서 이 특성을 고려할 필요 있음

✅ 종합 분석

항목평가 및 제안

클래스 수 분포	비교적 균형적이나, cigarette 클래스는 소형 객체로 탐지 성능 낮음
위치 분포	중심에 객체 몰림 → 중심성 편향 가능성 있음
크기 분포	많은 객체가 작고 좁은 영역에 분포 → 작은 객체 탐지 강화 필요
바운딩 박스 분포	cigarette는 크기 작고 central density 높음

https://github.com/taehuenkang/No_Smoking_Area_Project

16일차

호타리 — Mon, 12 May 2025 16:53:25 +0900

2025.05.12

시멘틱 세그멘테이션(Semantic Segmentation)

컴퓨터 비전 분야에서 중요한 과제 중 하나로, 이미지 내 각 픽셀을 해당하는 클래스에 매핑하는 기술임(예를 들어, 도시 풍경 사진에서 자동차, 건물, 도로 등의 각 객체를 픽셀 단위로 분류하여 특정 색상이나 라벨을 부여하는 작업이 이에 해당)

시멘틱 세그멘테이션의 사용 사례
1. 자율 주행 자동차: 도로에서 자동차, 보행자, 신호등, 도로 경계 등을 분류하여 안전한 주행을 돕습니다.
2. 의료 영상 분석: MRI나 CT 스캔에서 장기나 병변의 정확한 위치를 파악하고 진단에 활용됩니다.
3. 위성 이미지 분석: 농지, 도시, 산림 등의 영역을 파악하여 지리적 변화를 감시합니다.

주요 알고리즘 소개
1. **Fully Convolutional Network (FCN)**: 모든 계층을 convolutional layer로 구성하여 이미지를 픽셀 단위로 분류하는 최초의 신경망 구조입니다. 기존의 이미지 분류용 네트워크를 기반으로 하며, 마지막 레이어에서 픽셀마다 클래스 스코어를 예측합니다.

2. Encoder-Decoder 구조
   - Encoder는 이미지를 받아 고차원 특징을 추출하는 부분입니다. 깊은 신경망을 통해 점진적으로 공간 정보를 압축하면서 중요한 특징을 추출합니다.
   - Decoder는 압축된 특징을 사용해 고해상도로 복원하는 부분입니다. 주로 업샘플링 과정을 통해 입력 크기로 복원하며, 픽셀 단위로 분류를 수행합니다.

    - Skip Connection: 일반적으로 Encoder-Decoder 구조에서 활용. 단순한 Encoder-Decoder 구조의 경우 공간 정보를 압축하는 과정에서 해상도가 손실되는데 이를 보완하기 위해 Encoder에서 추출된 저차원 특징을 Decoder에 직접 연결하여 결합함으로써 보다 정확한 픽셀 분류가 가능하도록 합니다.

예시 알고리즘
- UNet: 의료 영상 분야에서 잘 알려진 알고리즘으로, 고해상도의 세그멘테이션을 위한 효과적인 구조를 갖추고 있습니다. Encoder-Decoder 구조와 함께 skip connection을 활용합니다.

- DeepLab: 디렉셔널 필터링과 아트리션 컨볼루션을 활용하여 객체 경계를 세밀하게 분리합니다.

R-CNN: https://arxiv.org/abs/1311.2524
  - 객체 탐지에 사용된 초기 모델
  - 주요 객체들을 바운딩 박스로 표현하여 정확히 식별하는게 목표
  - Selective Search를 통해 다양한 크기의 박스를 만들고, region proposal 영역 생성
  - region proposal 영역을 warp하여 표준화된 크기로 변환
  - AlexNet을 개량한 CNN 모델을 이용하고, 마지막 층에 SVM을 통해 객체 분류

Fast R-CNN: https://arxiv.org/abs/1504.08083
  - R-CNN의 단점인 느린 속도를 빠른 속도로 개선
  - ROI(Region of Interest) 풀링을 통해 한 이미지의 subregion에 대한 forward pass 값을 공유
  - R-CNN은 CNN 모델로 image feature를 추출, SVM 모델로 분류, Regressor 모델로 bounding box를 맞추는 작업으로 분류되어 있지만, Fast R-CNN은 하나의 모델로 동작
  - Top layer에 softmax layer를 둬서 CNN 결과를 class로 출력
  - Box regression layer를 softmax layer에 평행하게 두어 bounding box 좌표를 출력

Faster R-CNN: https://arxiv.org/abs/1506.01497
  - Fast R-CNN은 가능성 있는 다양한 bounding box들, 즉 ROI를 생성하는 과정인 selective search가 느려 region proposer에서 병목이 발생
  - 이미지 분류(classification)의 첫 단계인 CNN의 forward pass를 통해 얻어진 feature들을 기반으로 영역을 제안
  - CNN 결과를 selective search 알고리즘 대신 region proposal에 이용

- k개의 일반적인 비율을 지닌 anchor box를 이용하여 하나의 bounding box 및 score를 이미지의 위치별로 출력

Mask R-CNN: https://arxiv.org/abs/1703.06870
  - Pixel 레벨의 세그멘테이션
  - RolPool에서 선택된 feature map이 원래 이미지 영역으로 약간 잘못된 정렬이 발생한 부분을 RolAlign을 통해 조정하여 정확하게 정렬
  - Mask R-CNN은 Mask가 생성되면, Faster R-CNN으로 생성된 classification과 bounding box들을 합쳐 정확한 세그멘테이션 가능

U-Net 기반 세그멘테이션

- 사용된 모델은 수정된 U-Net(https://arxiv.org/abs/1505.04597)
- U-Net이라 불리는 인코더(다운샘플링- Contracting Path:피처맵의 크기가 줄어듬, 572-> 284->140->68->332->30)와 디코더(업샘플링-expanding path:피처맵의 크기가 커)를 포함한 구조는 정교한 픽셀 단위의 segmentation이 요구되는 biomedical image segmentation task의 핵심 요소
- 다운샘플링과정에서 피처맵 사이즈는 줄어드나 채널의 수는 증가하기 때문에 압축되는 과정에서 정보가 손실된다기보다 다른 형태로 추출한다고 생각할 수 있음
- 최종 output 이 2 는 388*388 피처에서 binary classifcation 진행
- Encoder-decoder 구조 또한 semantic segmentation을 위한 CNN 구조로 자주 활용
- Encoder 부분에서는 점진적으로 spatial dimension을 줄여가면서 고차원의 semantic 정보를 convolution filter가 추출해낼 수 있게 함
- Decoder 부분에서는 encoder에서 spatial dimension 축소로 인해 손실된 spatial 정보를 점진적으로 복원하여 보다 정교한 boundary segmentation을 완성

- Skip connection : input -> output 채널 방향으로 concatenate 함 (다운샘플링과 업샘플링을 거친값과 입력 X 값을 그대로 가져와 둘 다 활용)

- U-Net은 기본적인 encoder-decoder 구조와 달리 Spatial 정보를 복원하는 과정에서 이전 encoder feature map 중 동일한 크기를 지닌 feature map을 가져 와 prior로 활용함으로써 더 정확한 boundary segmentation이 가능하게 함

Oxford-IIIT Pets 데이터셋

- Parkhi et al이 만든 [Oxford-IIIT Pet Dataset](https://www.robots.ox.ac.uk/~vgg/data/pets/) 데이터 세트는 영상, 해당 레이블과 픽셀 단위의 마스크로 구성
- 마스크는 기본적으로 각 픽셀의 레이블
- 각 픽셀은 다음 세 가지 범주 중 하나
  *   class 1 : 애완동물이 속한 픽셀
  *   class 2 : 애완동물과 인접한 픽셀
  *   class 3 : 위에 속하지 않는 경우/주변 픽셀

- Images: https://www.robots.ox.ac.uk/~vgg/data/pets/data/images.tar.gz
- Annotations: https://www.robots.ox.ac.uk/~vgg/data/pets/data/annotations.tar.gz

DeepLab 기반 세그멘테이션

DeepLab V1: [Semantic Image Segmentation with Deep Convolutional Nets and Fully Connected CRFs](https://arxiv.org/abs/1412.7062), ICLR 2015.
  - Atrous convolution은 기존 convolution과 다르게 필터 내부에 빈 공간을 둔 채로 작동
  - 기존 convolution과 동일한 양의 파라미터와 계산량을 유지하면서 field of view (한 픽셀이 볼 수 있는 영역)를 크게 가져갈 수 있음
  - Semantic segmentation에서 일반적으로 높은 성능을 내기 위해서는 convolutional neural network의 마지막에 존재하는 한 픽셀이 입력값에서 어느 크기의 영역을 커버할 수 있는지를 결정하는 receptive field 크기가 중요
  - Atrous convolution을 활용하면 파라미터 수를 늘리지 않으면서도 receptive field를 크게 키울 수 있기 때문에 DeepLab 계열에서는 이를 적극적으로 활용

DeepLab V2: [DeepLab: Semantic Image Segmentation with Deep Convolutional Nets, Atrous Convolution, and Fully Connected CRFs](https://arxiv.org/abs/1606.00915), TPAMI 2017.
  - Semantic segmentaion의 성능을 높이기 위한 방법 중 하나로, spatial pyramid pooling 기법을 자주 사용
  - Feature map으로부터 여러 개의 rate가 다른 atrous convolution을 병렬로 적용한 뒤, 이를 다시 합쳐주는 atrous spatial pyramid pooling (ASPP) 기법을 활용
  - multi-scale context를 모델 구조로 구현하여 보다 정확한 semantic segmentation을 수행할 수 있도록 함

DeepLab V3: [Rethinking Atrous Convolution for Semantic Image Segmentation](https://arxiv.org/abs/1706.05587), arXiv 2017.

  - Encoder: ResNet with Atrous convolution
  - Atrous Spatial Pyramid Pooling (ASPP)
  - Decoder: Bilinear Upsampling

DeepLab V3+: [Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation](https://arxiv.org/pdf/1802.02611.pdf), arXiv 2018.

  - Encoder: ResNet with Atrous Convolution → Xception (Inception with Separable Convolution)
  - ASPP → ASSPP (Atrous Separable Spatial Pyramid Pooling)
  - Decoder: Bilinear Upsampling → Simplified U-Net style decoder

모델 구성

인코더-디코더 구조를 확장
인코더 모듈: 확장된 컨볼루션을 여러 척도로 적용하여 다중 스케일 상황 정보 처리
디코더 모듈: 객체 경계를 따라 분할 결과 조정

확장된 컨볼루션(Dilated convolution)
  - 컨볼루션 확장을 통해 네트워크 깊숙히 들어가며 스트라이드를 일정하게 유지 가능
  - 매개변수의 수나 계산량을 늘리지 않고도 더 큰 시야를 가질 수 있음
  - 더 큰 특징 맵 출력이 가능하여 세그멘테이션에 유용함

확장된 공간 피라미드 풀링(Dilated Spatial Pyramid Pooling)
  - 샘플링 속도가 커질수록 유효한 필터 가중치(유효한 특징 영역에 적용되는 가중치)의 수가 작아짐

사전 훈련된 ResNet50을 백본 모델로 사용
`conv4_block6_2_relu` 블록에서 저수준의 특징 사용

인코더 특징은 인자 4에 의해 쌍선형 업샘플링
동일한 공간 해상도를 가진 네트워크 백본에서 저수준 특징과 연결

Detectron Mask R-CNN

페이스북 인공지능 연구소(FAIR)에서 공개한 플랫폼
빠르고 유연한 사물 탐지 가능

Detectron2

페이스북 인공지능 연구소(FAIR)에서 개발한 객체 세그멘테이션 프레임워크
페이스북에서 개발한 DensePose, Mask R-CNN 등을 Detectron2에서 제공
손쉽게 다양한 사물들을 탐지하고 세그먼테이션하여, 객체의 유형, 크기, 위치 등을 자동으로 얻을 수 있음

03-11_InstanceSegmentation_YOLOv8_Basic.ipynb

6.23MB

03-12_InstanceSegmentation_YOLOv8_CustomData_TACO_Roboflow_Windows.ipynb

3.03MB

04-11_PoseEstimation_YOLOv8_Basic.ipynb

1.39MB

04-13_FacePoseHandsDetection_Mediapipe.ipynb

0.01MB

01-1_imgClassifcation.ipynb

0.03MB

01-2_videoClassification.ipynb

4.46MB

02_objDetection.ipynb

2.46MB

03_imgCaptioning.ipynb

0.00MB

04_imgTextGeneration.ipynb

0.01MB

ObjectDetection : Custom Datasets 만들기

< Object Detection을 위한 Custom Datasets 만들기 >

1. Data Labelling 도구

2. CVAT 을 사용하여 Annotation 하기

1) Project 생성하기

2) Project Name 지정 후 [ Constructor] 탭에서 label 생성하기

- ② ~ ⑤ 번까지 반복하여 20개의 label 생성하기 : 색상은 각기 다르게 지정

20개 label :

20개의 label 생성 후 “Submit & Open” 버튼 클릭하기

3) Task 생성하기

압축파일 해제하여 file upload하기

custom_yolo_images.zip

“Submit & Open” 클릭하기
1. Task 목록에서 생성된 Task를 open 한 후 Jobs 실행하기
- Job 번호 클릭하기

labelling 진행하기

5장의 이미지의 labelling 완료되면 상단 ‘Save” 버튼 후 “Export job dataset” 클릭하기

내보내기 형식 지정하고 이름 지정후 “OK” 클릭하기

3. Roboflow 을 사용하여 Annotation 하기

1) 프로젝트 생성하기 : New Project

2) 데이터파일 업로드하기 : Upload Data

3) 클래스 등록하기

4) 어노테이팅하기 : Start Annotation

5) 버전 생성하기 : 3~5번 단계까지 진행하기

6) 데이터셋 다운로드하기

15일차

호타리 — Fri, 9 May 2025 12:59:47 +0900

2025.05.09

Pytorch 및 필요한 라이브러리 설치하기

Anaconda3 내 설정만으로 PyTorch GPU 환경을 설정하는 방법

conda 업데이트
- conda update -n base -c defaults conda
가상환경 생성 (torch-gpu로 생성, 필요하면 이름 변경)
- conda create -n torch-gpu python=3.10
- conda activate torch-gpu
CUDA 11.8 / CuDNN 8.9.7 설치
- conda install -c conda-forge cudatoolkit=11.8 cudnn=8.9.7 ( or conda-forge와 defaults 채널에서는 cudatoolkit=12.8이 제공되지 않음)
PyTorch 2.3.0 설치
- conda install pytorch==2.3.0 torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia
커널 생성
- pip install ipykernel
- python -m ipykernel install --user --name=torch-gpu
설치 확인

Object Detection

Teachable Machine

1. 객체 탐지 (Object Detection)

- 객체 탐지는 컴퓨터 비전과 이미지 처리와 관련된 컴퓨터 기술로써 디지털 이미지와 비디오를 특정한 계열의 시멘틱 객체 인스턴스를 감지하는 일을 다룬다
- 각 객체 범주의 모든 인스턴스의 위치와 배율을 나타내는 축 정렬 경계 상자와 함께 이미지에 있는 객체 범주 목록 생성
    - 한 이미지에서 여러 객체와 그 경계 상자(bounding box)를 탐지(여러 객체를 분류하고 위치를 추정하는 방법)
    - 객체 탐지 알고리즘은 일반적으로 이미지를 입력으로 받고, 경계 상자와 객체 클래스 리스트를 출력
    - 경계 상자에 대해 그에 대응하는 예측 클래스와 클래스의 신뢰도(confidence)를 출력

Applications

- 자율 주행 자동차에서 다른 자동차와 보행자를 찾을 때
- 의료 분야에서 방사선 사진을 사용해 종양이나 위험한 조직을 찾을 때
- 제조업에서 조립 로봇이 제품을 조립하거나 수리할 때
- 보안 산업에서 위협을 탐지하거나 사람 수를 셀 때

1) Bounding Box

- 이미지에서 하나의 객체 전체를 포함하는 가장 작은 직사각형

2) IOU (Intersection Over Union)

- 실측값(Ground Truth)과 모델이 예측한 값이 얼마나 겹치는지를 나타내는 지표, 0~1 사이

- 예측 Bounding Box와 실제 Ground Truth가 겹치는 부분/예측 Bounding Box와 Ground Truth 겹치는 부분, 즉 두 집합의 교집합/합집합

- Object 영역을 얼마나 정확하게 찾는지 판단. IOU가 0.5 이상이면 2/3 정도 겹치는 정도로 이 정도면 예측을 성공했다고 할 수 있음

- IOU가 높을수록 잘 예측한 모델

- 예시

3) NMS (Non-Maximum Suppression, 비최댓값 억제)

- 다수의 중복된 예측을 제거하여 최종적으로 하나의 예측만 남기는 과정

- 확률이 가장 높은 상자와 겹치는 상자들을 제거하는 과정

- 최댓값을 갖지 않는 상자들을 제거

- 과정

1. 확률 기준으로 모든 상자를 정렬하고 먼저 가장 확률이 높은 상자를 취함

2. 각 상자에 대해 다른 모든 상자와의 IOU를 계산

3. 특정 임곗값을 넘는 상자는 제거

1.2 모델 성능 평가

1) 정밀도(Precision)와 재현율(Recall)

- 일반적으로 객체 탐지 모델 평가에 사용되지는 않지만, 다른 지표를 계산하는 기본 지표 역할을 함
  - True Positives(`TP`): 예측이 동일 클래스의 실제 상자와 일치하는지 측정
  - False Positives(`FP`): 예측이 실제 상자와 일치하지 않는지 측정
  - False Negatives(`FN`): 실제 분류값이 그와 일치하는 예측을 갖지 못하는지 측정

  - Precision : 찾았다고 주장한 경우에 대한 정확도
    - 모델이 안정적이지 않은 특징을 기반으로 객체 존재를 예측하면 거짓긍정(FP)이 많아져서 정밀도가 낮아짐
    - 존재한다고 또는 찾았다고 긍정적(Positive)으로 판단한 결과가 얼마나 정확한가 측정
    - 어떤 Object가 존재한다고 답한경우에 대해 맞춘 경우의 비율 ( 존재한다고 한 주장에 대한 신뢰도 측정의 의미)

  - Recall : 존재하는 Object중에 총 몇 퍼센트나 찾았는지에 대한 비률
    - 모델이 너무 엄격해서 정확한 조건을 만족할 때만 객체가 탐지된 것으로 간주하면 거짓부정(FN)이 많아져서 재현율이 낮아짐
    - 실제로는 존재하는데 못 찾는 경우가 얼마나 되는지 확인하는 의미

2) 정밀도-재현율 곡선(Precision-Recall Curve)

- 신뢰도 임계값마다 모델의 정밀도와 재현율을 시각화
- 모든 bounding box와 함께 모델이 예측의 정확성을 얼마나 확실하는지 0 ~ 1사이의 숫자로 나타내는 신뢰도를 출력
- 임계값 T에 따라 정밀도와 재현율이 달라짐
  - 임계값 T 이하의 예측은 제거함
  - T가 1에 가까우면 정밀도는 높지만 재현율은 낮음
  - 놓치는 객체가 많아져서 재현율이 낮아짐. 즉, 신뢰도가 높은 예측만 유지하기때문에 정밀도는 높아짐
  - T가 0에 가까우면 정밀도는 낮지만 재현율은 높음
  - 대부분의 예측을 유지하기때문에 재현율은 높아지고, 거짓긍정(FP)이 많아져서 정밀도가 낮아짐
- 예를 들어, 모델이 보행자를 탐지하고 있으면 특별한 이유없이 차를 세우더라도 어떤 보행자도 놓치지 않도록 재현율을 높여야 함
- 모델이 투자 기회를 탐지하고 있다면 일부 기회를 놓치게 되더라도 잘못된 기회에 돈을 거는 일을 피하기 위해 정밀도를 높여야 함

3) AP (Average Precision, 평균 정밀도) 와 mAP(mean Average Precision)

- 곡선의 아래 영역에 해당
- 항상 1x1 정사각형으로 구성되어 있음
  즉, 항상 0 ~ 1 사이의 값을 가짐
- 단일 클래스에 대한 모델 성능 정보를 제공
- 전역 점수를 얻기위해서 mAP를 사용
- 예를 들어, 데이터셋이 10개의 클래스로 구성된다면 각 클래스에 대한 AP를 계산하고, 그 숫자들의 평균을 다시 구함

- mAP 사용 : Object Detection의 성능 평가 지표
  - 2개의 Hyper Parameter 사용
    - Confidence Threshold : 탐지한 객체 인식에 대한 신뢰도로 보통 0.5 사용
    - IOU Threshold : Precision과 Recall로부터 계산. Confidence 를 1.0 에서 0으로 조금씩 줄이면서 Recall값을 0에서 1사이에서 0.1 간격으로 11개 레벨값에 대한 Precision 값을 구해 각 Recall 레벨값에 대한 Precision 값들의 평균값 구
  - 최소 2개 이상의 객체를 탐지하는 대회인 PASCAL Visual Object Classes와 Common Objects in Context(COCO)에서 mAP가 사용됨
  - COCO 데이터셋이 더 많은 클래스를 포함하고 있기 때문에 보통 Pascal VOC보다 점수가 더 낮게 나옴

1.3 데이터셋 (Dataset)

1) VOC Dataset

- PASCAL VOC (시각적 객체 클래스) 데이터 세트는 잘 알려진 객체 감지, 분할 및 분류 데이터 세트
- 2005년에서 2012년까지 진행되었던 PASCAL VOC challenge에서 쓰이던 데이터셋
- Object Detection 기술의 benchmark로 간주
- 데이터셋에는 20개의 클래스가 존재

      background
      aeroplane
      bicycle
      bird
      boat
      bottle
      bus
      car
      cat
      chair
      cow
      diningtable
      dog
      horse
      motorbike
      person
      pottedplant
      sheep
      sofa
      train
      tvmonitor

- 훈련 및 검증 데이터 : 11,530개
- 이미지 개수:
    - object detection: 총 9,963개의 주석이 달린(annotated) 이미지가 포함. 이 중에서 5,011개가 학습 데이터
    - segmentation: 422개의 학습 데이터
- ROI에 대한 27,450개의 Annotation이 존재
- 이미지당 2.4개의 객체 존재

2) COCO Dataset

- Common Objects in Context
- 200,000개의 이미지
    - 학습(training) 데이터셋: 118,000장의 이미지
    - 검증(validation) 데이터셋: 5,000장의 이미지
    - 테스트(test) 데이터셋: 41,000장의 이미지
- COCO 데이터셋의 장점
    - 다양한 크기의 물체가 존재
    - 높은 비율로 작은 물체들이 존재
    - Object들이 혼잡하게 존재하고, occlusion(폐색)이 많이 존재
    - 덜 iconic 합니다. 여기서 iconic의 의미는 이미지가 특정 카테고리에 명확하게 속해있는 경우를 말합니다. 예를 들어 아래 이미지의 (a)의 이미지들은 누가봐도 명확하게 개, 소 등의 명확하게 특정 카테고리에 속한걸 누구나 알 수 있습니다. (b)의 이미지들은 (a) 보다는 모호하지만, 특정 카테고리에 속하다고 말할 수 있습니다. 그런데 (c)의 경우 어떤 카테고리에 속하는지 분류하기가 모호합니다. 현실세계 사진에서는 (a)나 (b)보단 (c)에 속하는 경우가 훨씬 많이 존재합니다.

- 80개의 카테고리에 500,000개 이상의 객체 Annotation이 존재
      person
      bicycle
      car
      motorbike
      aeroplane
      bus
      train
      truck
      boat
      traffic light
      fire hydrant
      stop sign
      parking meter
      bench
      bird
      cat
      dog
      horse
      sheep
      cow
      elephant
      bear
      zebra
      giraffe
      backpack
      umbrella
      handbag
      tie
      suitcase
      frisbee
      skis
      snowboard
      sports ball
      kite
      baseball bat
      baseball glove
      skateboard
      surfboard
      tennis racket
      bottle
      wine glass
      cup
      fork
      knife
      spoon
      bowl
      banana
      apple
      sandwich
      orange
      broccoli
      carrot
      hot dog
      pizza
      donut
      cake
      chair
      sofa
      pottedplant
      bed
      diningtable
      toilet
      tvmonitor
      laptop
      mouse
      remote
      keyboard
      cell phone
      microwave
      oven
      toaster
      sink
      refrigerator
      book
      clock
      vase
      scissors
      teddy bear
      hair drier
      toothbrush

- https://cocodataset.org/

2. 객체 탐지의 역사

* RCNN (2013)
  - Rich feature hierarchies for accurate object detection and semantic segmentation (https://arxiv.org/abs/1311.2524)
  - 물체 검출에 사용된 기존 방식인 sliding window는 background를 검출하는 소요되는 시간이 많았는데, 이를 개선시킨 기법으로 Region Proposal 방식 제안
  - 매우 높은 Detection이 가능하지만, 복잡한 아키텍처 및 학습 프로세스로 인해 Detection 시간이 매우 오래 걸림

* SPP Net (2014)
  - Spatial Pyramid Pooling in Deep Convolutional Networks for Visual Recognition (https://arxiv.org/abs/1406.4729)
  - RCNN의 문제를 Selective search로 해결하려 했지만, bounding box의 크기가 제각각인 문제가 있어서 FC Input에 고정된 사이즈로 제공하기 위한 방법 제안
  - SPP은 RCNN에서 conv layer와 fc layer사이에 위치하여 서로 다른 feature map에 투영된 이미지를 고정된 값으로 풀링
  - SPP를 이용해 RCNN에 비해 실행시간을 매우 단축시킴

* Fast RCNN (2015)
  - Fast R-CNN (https://arxiv.org/abs/1504.08083)
  - SPP layer를 ROI pooling으로 바꿔서 7x7 layer 1개로 해결
  - SVM을 softmax로 대체하여 Classification 과 Regression Loss를 함께 반영한 Multi task Loss 사용
  - ROI Pooling을 이용해 SPP보다 간단하고, RCNN에 비해 수행시간을 많이 줄임

* Fater RCNN(2015)
  - Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks (https://arxiv.org/abs/1506.01497)
  - RPN(Region proposal network) + Fast RCNN 방식
  - Selective Search를 대체하기 위한 Region Proposal Network구현
  - RPN도 학습시켜서 전체를 end-to-end로 학습 가능 (GPU사용 가능)
  - Region Proposal를 위해 Object가 있는지 없는지의 후보 Box인 Anchor Box 개념 사용
  - Anchor Box를 도입해 FastRCNN에 비해 정확도를 높이고 속도를 향상시킴

* SSD (2015)
  - SSD: Single Shot MultiBox Detector (https://arxiv.org/abs/1512.02325)
  - Faster-RCNN은 region proposal과 anchor box를 이용한 검출의 2단계를 걸치는 과정에서 시간이 필요해 real-time(20~30 fps)으로는 어려움
  - SSD는 Feature map의 size를 조정하고, 동시에 앵커박스를 같이 적용함으로써 1 shot으로 물체 검출이 가능
  - real-time으로 사용할 정도의 성능을 갖춤 (30~40 fps)
  - 작은 이미지의 경우에 잘 인식하지 못하는 경우가 생겨서 data augmentation을 통해 mAP를 63에서 74로 비약적으로 높임

* RetinaNet (2017)
  - Focal Loss for Dense Object Detection (https://arxiv.org/abs/1708.02002)
  - RetinaNet이전에는 1-shot detection과 2-shot detection의 차이가 극명하게 나뉘어 속도를 선택하면 정확도를 trade-off 할 수 밖에 없는 상황
  - RetinaNet은 Focal Loss라는 개념의 도입과 FPN 덕분에 기존 모델들보다 정확도도 높고 속도도 여타 1-shot detector와 비견되는 모델
  - Detection에선 검출하고 싶은 물체와 (foreground object) 검출할 필요가 없는 배경 물체들이 있는데 (background object) 배경 물체의 숫자가 매우 많을 경우 배경 Loss를 적게 하더라도 숫자에 압도되어 배경의 Loss의 총합을 학습해버림 (예를 들어, 숲을 배경으로 하는 사람을 검출해야하는데 배경의 나무가 100개나 되다보니 사람의 특징이 아닌 나무가 있는 배경을 학습해버림)
  - Focal Loss는 이런 문제를 기존의 crossentropy 함수에서 (1-sig)을 제곱하여 background object의 loss를 현저히 줄여버리는 방법으로 loss를 변동시켜 해결
  - Focal Loss를 통해 검출하고자 하는 물체와 관련이 없는 background object들은 학습에 영향을 주지 않게 되고, 학습의 다양성이 더 넓어짐 (작은 물체, 큰 물체에 구애받지 않고 검출할 수 있게됨)
  - 실제로 RetinaNet은 object proposal을 2000개나 실시하여 이를 확인

* Mask R-CNN (2018)
  - Mask R-CNN (https://arxiv.org/pdf/1703.06870.pdf)

* YOLO (2018)
  - YOLOv3: An Incremental Improvement (https://arxiv.org/abs/1804.02767)
  - YOLO는 v1, v2, v3의 순서로 발전하였는데, v1은 정확도가 너무 낮은 문제가 있었고 이 문제는 v2까지 이어짐
  - 엔지니어링적으로 보완한 v3는 v2보다 살짝 속도는 떨어지더라도 정확도를 대폭 높인 모델
  - RetinaNet과 마찬가지로 FPN을 도입해 정확도를 높임
  - RetinaNet에 비하면 정확도는 4mAP정도 떨어지지만, 속도는 더 빠르다는 장점

* RefineDet (2018)
  - Single-Shot Refinement Neural Network for Object Detection (https://arxiv.org/pdf/1711.06897.pdf)

* M2Det (2019)
  - M2Det: A Single-Shot Object Detector based on Multi-Level Feature Pyramid Network (https://arxiv.org/pdf/1811.04533.pdf)

* EfficientDet (2019)
  - EfficientDet: Scalable and Efficient Object Detection (https://arxiv.org/pdf/1911.09070v1.pdf)

* YOLOv4 (2020)
  - YOLOv4: Optimal Speed and Accuracy of Object Detection (https://arxiv.org/pdf/2004.10934v1.pdf)
  - YOLOv3에 비해 AP, FPS가 각각 10%, 12% 증가
  - YOLOv3와 다른 개발자인 AlexeyBochkousky가 발표
  - v3에서 다양한 딥러닝 기법(WRC, CSP ...) 등을 사용해 성능을 향상시킴
  - CSPNet 기반의 backbone(CSPDarkNet53)을 설계하여 사용

* YOLOv5 (2020)
  - YOLOv4에 비해 낮은 용량과 빠른 속도 (성능은 비슷)
  - YOLOv4와 같은 CSPNet 기반의 backbone을 설계하여 사용
  - YOLOv3를 PyTorch로 implementation한 GlennJocher가 발표
  - Darknet이 아닌 PyTorch 구현이기 때문에, 이전 버전들과 다르다고 할 수 있음

* 이후
  - 수 많은 YOLO 버전들이 탄생
  - Object Detection 분야의 논문들이 계속해서 나오고 있음

3. 객체 탐지 아키텍처

- Two Stage Detector: object가 있을 법한 위치의 후보(proposals)들을 뽑아내는 단계, 이후 실제로 object가 있는지를 Classification과 정확한 바운딩 박스를 구하는 Regression을 수행하는 단계가 분리되어 있음. 예:Faster-RCNN
- One Stage Detector:객체의 검출과 분류, 그리고 바운딩박스 regression을 한 번에 하는 방법

< 전통적인 객체 탐지 기법 - 영역 제안(Region Proposal) 기법 >
- Sliding Window 기법

    - 이미지를 다양한 크기의 창(window)으로 스캔하면서 각 위치에서 객체가 있는지 분류하는 방식 (검출하고자 하는 입력 이미지에 정해진 크기의 Bounding Box를 만들어 방향을 이동하면서 물체가 있을 법한 box나 영역을 추출하는 것)
    - 모든 영역을 탐색해야 하기 때문에 시간이 많이 소요되어 비효율적이라는 특성이 있습니다.
    - 이미지를 가로 질러 고정 된 크기의 window를 여러 배율로 슬라이드하는 것을 볼 수 있음.
    - 이러한 각 단계에서 window가 중지되고 일부 feature를 계산한 다음 영역을 아래와 같이 분류
        - 이 영역에 얼굴이 포함되어 있습니다 à Yes
        - 이 영역에 얼굴이 포함되어 있지 않습니다 à No
    [작동 방식]
    1. 창 생성: 다양한 크기와 비율(예: 64×64, 128×128 등)의 탐색 창을 준비합니다.
    2. 슬라이딩 과정: 각 창을 일정 스텝(보통 4~8픽셀)씩 이동하며 이미지 전체를 스캔합니다.
    3. 특징 추출: 각 창에서 HOG(Histogram of Oriented Gradients), SIFT 등의 특징을 추출합니다.
    4. 분류: SVM(Support Vector Machine)이나 AdaBoost 같은 분류기로 각 창에 객체가 있는지 판단합니다.
    5. 후처리: NMS(Non-Maximum Suppression)를 적용해 중복 검출을 제거합니다.
    => 계산 복잡도: 이미지 크기 × 창 크기 종류 × 스케일 수 → 수만~수십만 번의 분류 연산

- Selective Search (SS) 기법

    - 이미지의 특성(색상, 질감, 크기 등)을 고려해 객체가 있을 법한 영역(Region Proposal)을 먼저 제안하고, 그 영역들만 분류하는 방식입니다.
    - Selective Search(SS)는 색상, 질감 및 모양과 같은 다양한 하위 수준 이미지 기능을 결합하여 이미지 영역의 계층적 그룹을 만드는
    방식으로 작동
    [작동방식]
    1. 초기 분할: 이미지를 작은 초기 영역들로 과분할합니다(약 2,000개 정도).
    2. 유사도 계산: 인접 영역 간 색상, 질감, 크기, 형태 유사도를 계산합니다.
    3. 영역 병합: 유사도가 가장 높은 영역들부터 점진적으로 병합합니다.
    4. 후보 영역 생성: 병합 과정에서 생성된 모든 영역들을 객체 후보(약 2,000개)로 간주합니다.
    5. 분류: 각 후보 영역에서 특징을 추출하고 분류기를 적용해 객체 여부를 판단합니다.

4. YOLO (You Only Look Once)
- https://www.ultralytics.com/ko/yolo : 테스트해보기
- https://velog.io/@choonsik_mom/Object-Detection-with-yolo-NAS-zpetis4o 성능비

- 2015년 Joseph Redmon 이 아키텍처를 논문과 함께 발표함, 가장 빠른 객체 검출 알고리즘 중 하나
- Yolo 형식 : 클래스 번호|x의 center좌표|y의 center좌표|너비|높이
- 256x256 사이즈의 이미지
- Yolov4까지는 파이썬, 텐서플로 기반 프레임워크가 아닌 C++로 구현된 코드 기준 GPU 사용 시, 초당 170 프레임(170 FPS, frames per second), Yolov5부터는  PyTorch로 개발이 이루어져 2023년 현재 빠른속도, 사용자 친화적인 파이썬 인터페이스를 제공하는 Yolov8 (SOFA) 아키텍처로 진화
- 작은 크기의 물체를 탐지하는데는 어려움
[작동 방식]
1. 그리드 분할: 이미지를 S×S 그리드(일반적으로 7×7 또는 13×13)로 분할합니다.
2. 네트워크 구조: 단일 CNN(Convolutional Neural Network)을 통과시켜 전체 이미지의 특징을 추출합니다.
3. 예측 값:
    - 각 그리드 셀마다 B개의 바운딩 박스를 예측
    -  바운딩 박스는 5개 값(x, y, w, h, confidence) 포함
    - 각 그리드 셀에서 C개 클래스의 조건부 확률 예측
4. 출력 형태: S×S×(5B+C) 텐서
    - 예: 7×7 그리드, 2개 바운딩 박스, 20개 클래스 → 7×7×30 텐서
5. 후처리: 낮은 신뢰도의 박스 제거 및 NMS 적용

= > 특징: 전체 이미지를 한 번에 처리하므로 매우 빠르며(초당 45~155프레임), 객체의 전체적인 컨텍스트를 고려할 수 있습니다.

4.1 YOLO 아키텍처

- 백본 모델(backbone model) 기반

- 특징 추출기(Feature Extractor)라고도 불림

- YOLO는 자체 맞춤 아키텍처 사용

- 어떤 특징 추출기 아키텍처를 사용했는지에 따라 성능 달라짐

- 마지막 계층은 크기가 w x h x D인 특징 볼륨 출력

- w x h는 그리드의 크기이고 D는 특징 볼륨 깊이

4.2 YOLO 계층 출력

- 마지막 계층 출력은 w x h x M 행렬
  - M = B x (C + 5)
    - B : 그리드 셀당 경계 상자 개수
    - C : 클래스 개수
  - 클래스 개수에 5를 더한 이유는 해당 값 만큼의 숫자를 예측해야함
    - tx, ty는 경계상자의 중심 좌표를 계산
    - tw, th는 경계상자의 너비와 높이를 계산
    - c는 객체가 경계 상자 안에 있다고 확신하는 신뢰도
    - p1, p2, ..., pC는 경계상자가 클래스 1, 2, ..., C의 객체를 포함할 확률

- Objectness Score : 바운딩 박스에 객체가 포함되어 있을 확률

4.2 앵커 박스 (Anchor Box)

- YOLOv2에서 도입

- 사전 정의된 상자(prior box)

- 객체에 가장 근접한 앵커 박스를 맞추고 신경망을 사용해 앵커 박스의 크기를 조정하는 과정 때문에 tx, ty, tw, th이 필요

4.4 YOLOv8

* https://github.com/ultralytics/
* https://www.ultralytics.com

1.Yolov8 이란?
- YOLOv8은 객체 탐지(Object Detection), 이미지 분류(Image Classification), 인스턴스 분할(Instance Segmentation) 작업에 사용할 수 있는 최신 기술의 YOLO 모델입니다. YOLOv8은 영향력 있는 YOLOv5 모델을 개발한 [Ultralytics](https://ultralytics.com/?ref=blog.roboflow.com)에 의해 개발되었습니다. YOLOv8은 YOLOv5와 비교하여 수많은 구조적 및 개발자 경험의 변화와 개선 사항을 포함하고 있습니다.

- YOLOv8은 이 글을 쓰는 시점에서 Ultralytics가 새로운 기능을 개발하고 커뮤니티로부터의 피드백에 응답하면서 활발한 개발이 진행되고 있습니다. 실제로 Ultralytics가 모델을 출시하면 장기적인 지원을 받게 됩니다. 이 기관은 커뮤니티와 협력하여 모델을 최상의 상태로 만들기 위해 노력합니다.

- 강력한 기초 모델과 함께 YOLOv5 관리자들은 모델을 둘러싼 건강한 소프트웨어 생태계를 지원하는 데 전념했습니다. 그들은 적극적으로 문제를 해결하고 커뮤니티의 요구에 따라 레포의 기능을 향상시켰습니다.

- 지난 두 해 동안, YOLOv5 PyTorch 레포에서 다양한 모델들이 파생되었으며, [Scaled-YOLOv4](https://roboflow.com/model/scaled-yolov4?ref=blog.roboflow.com), [YOLOR](https://blog.roboflow.com/train-yolor-on-a-custom-dataset/), [YOLOv7](https://blog.roboflow.com/yolov7-breakdown/) 등이 포함됩니다. [YOLOX](https://blog.roboflow.com/how-to-train-yolox-on-a-custom-dataset/) 및 [YOLOv6](https://blog.roboflow.com/how-to-train-yolov6-on-a-custom-dataset/)와 같은 다른 모델들은 각자의 PyTorch 기반 구현에서 세계적으로 등장했습니다. 이 과정에서 각 YOLO 모델은 모델의 정확도와 효율성을 향상시키는 새로운 SOTA 기술을 가져왔습니다.

- 최근 6개월 동안, Ultralytics는 최신 SOTA 버전인 YOLOv8을 연구하는 데 집중했습니다. YOLOv8은 2023년 1월 10일에 출시되었습니다. 이 모델은 이전 YOLO 버전들의 효율성과 정확도를 향상시킨 새로운 기술을 결합하여 더욱 강력한 객체 탐지 및 인스턴스 분할 성능을 제공합니다. 또한, YOLOv8은 사용자 친화적인 API와 확장성 있는 구조를 제공하여 더 많은 개발자들이 이 모델을 쉽게 적용하고 수정할 수 있게 되었습니다.

- YOLOv8은 계속해서 발전하고 있으며, Ultralytics 및 커뮤니티는 이 모델을 개선하기 위해 지속적으로 협력하고 있습니다. 이렇게 함으로써 YOLO 시리즈는 앞으로도 컴퓨터 비전 분야에서 지속적으로 중요한 역할을 하게 될 것입니다.

YOLOv8 vs YOLOv7 vs YOLOv6 vs YOLOv5

- 당장 YOLOv8 모델은 이전 YOLO 모델에 비해 훨씬 더 나은 성능을 보이는 것 같습니다. YOLOv5 모델뿐만 아니라 YOLOv8 모델도 YOLOv7 및 YOLOv6 모델에 비해 앞서고 있습니다.

5. SSD (Single Shot MultiBox Detector)

- SSD는 "Single Shot MultiBox Detector"의 약자로, 객체 탐지를 위한 딥러닝 알고리즘입니다. "Single Shot"은 객체 위치와 클래스를 단일 네트워크 통과로 예측한다는 의미이고, "MultiBox"는 다양한 크기와 비율의 기본 박스를 사용한다는 의미입니다.
1. 기본 네트워크: VGG16이나 ResNet과 같은 사전 학습된 네트워크를 기반으로 합니다.
2. 다중 스케일 특징 맵: 기본 네트워크의 여러 층에서 특징 맵을 추출합니다.
    - 38×38, 19×19, 10×10, 5×5, 3×3, 1×1 등 다양한 해상도
3. 기본 박스(Default Box):
    - 각 특징 맵의 각 위치마다 여러 개의 기본 박스 설정
    - 다양한 크기와 비율(aspect ratio) 사용
    - 총 약 8,000개의 기본 박스 생성
4. 예측 값:
    - 각 기본 박스마다 위치 오프셋(cx, cy, w, h) 예측
    - 각 기본 박스마다 C+1개 클래스(배경 포함) 신뢰도 예측
5. 후처리: 임계값 이하 박스 제거 및 NMS 적용

= > 특징: 다양한 스케일의 특징 맵을 사용하므로 다양한 크기의 객체를 효과적으로 탐지할 수 있으며, YOLO와 마찬가지로 단일 네트워크로 실시간 처리가 가능합니다.

<4가지 방법의 주요 차이점 비교>

Object Detection - Yolov8 [사전학습된 모델 사용하여 예측]

- Yolo는 워싱턴대의 Joseph Redmon등이 주축이 되서 만든 알고리즘으로 Darknet이라는 C 기반의 딥러닝 프레임에서 만듬 (Darknet은 Tensorflow와 같은 딥러닝 프레임웍)
- 이후 Joseph Redmon 이 더이상 computer vision연구를 하지 않겠다고 선언한뒤 Yolo의 후속 버전은 계속 다른 사람들이 연구하게 됨
- Yolo v4는 이후  Alexey Bochkoviskiy가 구현했는데, 얼마되지 않아서 glenn jocher가 Ultralytics 라는 개인 스타트업을 만들고 다시 Yolo v5를 내놓음

< 진행 절차 >
1. MS COCO Dataset으로 사전학습된 Yolov8 모델 Prediction 기능이용 시 예측에 사용할 이미지 준비
2. Colab 으로 데이터셋 업로드

3. ultralytics 패키지 설치하기
- https://www.ultralytics.com/ko
- https://github.com/ultralytics
```python
    pip install ultralytics
```
4. 모델 사용하기
```python
    from ultralytics import YOLO
    model = YOLO('yolov8n.pt')
```
5. 예측하기
```python
    results = model.predict('test_image.jpg')

    # Process results list
    for result in results:
        boxes = result.boxes  # Boxes object for bounding box outputs
        masks = result.masks  # Masks object for segmentation masks outputs
        keypoints = result.keypoints  # Keypoints object for pose outputs
        probs = result.probs  # Probs object for classification outputs
        obb = result.obb  # Oriented boxes object for OBB outputs
        result.show()  # display to screen
        result.save(filename="result.jpg")  # save to disk

02-11_ObjectDetection_YOLOv8_Basic.ipynb

6.84MB

02-12_ObjectDetection_YOLOv8_CustomData-Roboflow_Windows.ipynb

0.20MB

02-21_FaceDetection_SSD_yolo.ipynb

0.45MB

1일차

호타리 — Thu, 8 May 2025 18:27:31 +0900

2025.05.08

Visual Studio Installer

클래스뷰에서 CMFC1View에서 OnDraw 찾기

<실행 결과>

CString

<실행 결과>

14일차

호타리 — Thu, 8 May 2025 12:57:42 +0900

2025.05.08

Banana Classification

7_10_Banana_Classification.ipynb

0.21MB

crawling.ipynb

0.02MB

<이진분류 프로젝트>

1. 정상/폐렴 데이터셋 사용 : https://www.kaggle.com/datasets/paultimothymooney/chest-xray-pneumonia
2. 데이터셋 로드하기
레이블(클래스) 리스트 선언하여 폴더 하위 이미지 읽어 입력 및 출력(X, y) 데이터 생성
3. 데이터 전처리하기
4. 모델 구성하기
CNN 모델 구성하고 Compile 하기
5. 모델 학습하기
6. 모델 학습과정 살펴보기(학습횟수에 따른 accuracy/loss 그래프 그리기)
7. 모델 평가 및 예측하기
8. 모델 예측 결과 출력(이미지+결과)하기 ( pred_label / true_label )
9. 모델 저장하기

폐렴이란?
폐렴은 주로 폐포라고 알려진 작은 공기주머니에 영향을 미치는 폐의 염증성 질환입니다.증상에는 일반적으로 마른 기침, 가슴 통증, 발열 및 호흡곤란 등이 있습니다. 증상의 심각도는 다양합니다. 폐렴은 보통 바이러스나 박테리아에 감염되어 발생하며, 다른 미생물, 특정 약물, 자가면역질환 등으로 발병하는 경우는 적습니다. 위험인자로는 낭포성 섬유증, 만성폐쇄성폐질환(COPD), 천식, 당뇨병, 심부전, 흡연 이력, 뇌졸중 발생, 면역력 약화 등이 있습니다. 폐렴 진단은 증상 발생과 신체검사를 기반으로 이루어 집니다. 흉부 엑스레이, 혈액 검사, 가래 배양 등이 진단을 확인하는 데 도움이 될 수 있습니다. 이 질병은 지역사회, 병원, 의료 관련 등 발병 장소에 따라 분류할 수 있습니다.

폐렴 데이터 세트에 대한 설명
데이터 세트는 3개의 폴더(train, test, val)로 구성되며 각 이미지 범주(Pneumonia/Normal)에 대한 하위 폴더를 포함합니다. 5,863개의 X-Ray 이미지(JPEG)와 2개의 카테고리(Pneumonia/Normal)가 있습니다. 흉부 X선 영상(전후방)은 소아 환자 소급 집단에서 선택되었습니다. 모든 흉부 X선 영상 촬영은 환자의 일상적인 임상 치료의 일부로 수행되었습니다. 흉부 X선 영상의 분석을 위해, 흉부 X선 사진은 품질 관리를 위해 품질이 낮거나 읽을 수 없는 이미지는 모두 제거하고 선별하였습니다. AI 시스템을 훈련시키기 전에 두 명의 전무 의사가 이미지에 대한 라벨 분류 작업을 진행하였습니다. 오류를 방지하기 위해 세 번째 전문가가 평가 세트도 확인했습니다.

7-12_신경망모델_Prj1_이진분류_폐렴분류_1.ipynb

3.12MB

감정 분류 (Emotion Classification)

keras의 이미지 증강 방식 사용

Datasets 로드하고 확인하기

https://www.kaggle.com/datasets/msambare/fer2013

7-13_신경망모델_Prj2_다중분류_감정분류_windows.ipynb

0.41MB

CNN 을 사용한 이진/다중 분류 프로젝트 가이드

< 다중분류 프로젝트 >
> 1. 정상/폐렴/Covid-19 데이터셋
> - https://www.kaggle.com/datasets/pranavraikokte/covid19-image-dataset/data
> 2. 데이터셋 준비하기
>    텐서플로우 ImageDataGenerator 사용
> 3. 데이터 전처리하기
> 4. Pretrained-model 모델(VGG19 or Xception or MobileNetV2 등 ) 로드하기
>    새로운 분류층 추가하기
>    Compile 하기
> 5. 모델 학습하기
> 6. 모델 학습과정 살펴보기 (학습횟수에 따른 accuracy/loss 그래프 그리기)
> 7. 모델 평가 및 예측하기
> 8. 모델 예측 결과 출력(이미지+결과)하기 ( pred_label / true_label )
> 9. 모델 저장하기

COVID_PROJECT.ipynb

0.34MB

13일차

호타리 — Wed, 7 May 2025 16:49:20 +0900

2025.05.07

차선감지

cv_8_lane_detection_pipeline.py

0.01MB

cv_8_lane_detector.py

0.00MB

1. JdOpencvLaneDetect 클래스

curr_steering_angle
- 프레임 간 “이전 조향각”을 저장합니다. 기본값은 90° (직진).
get_lane(frame)
1. 원본 프레임을 윈도우에 띄우고 (show_image)
2. detect_lane로부터 검출된 차선 좌표(lane_lines)와 차선만 그린 이미지(frame)를 반환
get_steering_angle
1. 차선을 못 찾으면 (0, None) 반환
2. compute_steering_angle → new_angle 계산
3. stabilize_steering_angle로 급격한 변화 제한 → curr_steering_angle 업데이트
4. 최종 조향각 시각화 (display_heading_line)

2. 프레임 처리 파이프라인

2.1 엣지 검출: detect_edges(frame)

BGR → HSV 변환
- HSV 공간에서 ‘색상(H)’ 필터링이 쉽기 때문
두 구간의 적색 마스크
- [0–40] 구간 + [160–180] 구간을 합쳐 빨간색 계열 포괄
- S, V 채널은 [50–255]로 충분히 밝고 선명한 빨간색만 잡음
Canny 엣지 검출
- 1차 threshold = 200, 2차 = 400
- 작은 노이즈는 무시하고, 강한 경계선만 검출

2.2 관심 영역 마스킹 : region_of_interest(canny)

왜 하단 절반?
- 카메라가 앞쪽 도로만 보도록, 하늘·차량 전면부는 제외
fillPoly + bitwise_and
- 마스크 영역만 살리고 나머지는 0(검정) 처리

2.3 허프 선분 검출 : detect_line_segments(cropped_edges)

rho, angle: 그리드 정밀도(1px, 1°)
min_votes: 직선으로 간주하려면 최소 10개의 뷰(교차점) 필요
minLineLength/maxLineGap
- 짧은 선분을 버리고, Gap 4px 이하 이으면 연결

2.4 선분 평균화 : average_slope_intercept(frame, line_segments)

1. 기울기·절편 계산

fit = np.polyfit((x1, x2), (y1, y2), 1)  
slope, intercept = fit

2. 좌/우 차선 분류

slope<0 & 화면 왼쪽 2/3에 있을 때 → 좌측 후보
slope>0 & 화면 오른쪽 1/3에 있을 때 → 우측 후보
|slope|>0.75 로 너무 완만한 선분 버림

3. 평균화 & 좌표 변환

avg = np.average(fits, axis=0)  # [slope, intercept]
[[x1, y1, x2, y2]] = make_points(frame, avg)

make_points는 y1=바닥, y2=중간 높이로 고정한 뒤
x = (y − intercept) / slope 로 계산, 프레임 밖 좌표는 클램핑

2.5 조향 각도 계산 : compute_steering_angle

단일 차선: 선분 끝점(x2) 기준으로 얼마나 벗어났는지
이중 차선: 좌·우 차선 끝점 평균과 화면 중앙(mid) 차이
+90: 90°가 “직진” 기준, <90°는 좌회전, >90°는 우회전

2.6 각도 안정화 : stabilize_steering_angle

두 차선 모두 검출되면 ±5°까지, 한 차선이면 ±1° 허용
급격한 휠 턴 방지

3. 시각화 유틸

display_lines
- 빈 이미지에 녹색 차선 그린 뒤 원본과 α-blend
display_heading_line
- 빨간색 화살표 : 화면 하단 중앙 → 화면 중간 높이, steering angle 방향

4. 나머지 헬퍼 함수

length_of_line_segment: 피타고라스
show_image(title, frame, show):
- show 플래그가 True일 때만 cv2.imshow
- 주의: cv2.waitKey(1)가 밖에서 반드시 호출되어야 창이 갱신됩니다.
make_points:
- (slope, intercept) → (x1,y1),(x2,y2) 좌표 생성
- 프레임 밖 좌표는 [-width, 2*width] 범위로 클램핑

핵심 정리

색상 필터 → 엣지 검출 → ROI 마스크 → 허프 변환 →
선분 분류·평균화 → 조향각 계산 → 각도 안정화 → 시각화

이 파이프라인 하나하나가 자율주행의 ‘차선 인식 → 차선 유지’ 로직을 구현합니다.
각 함수의 파라미터(HSV 임계치, Canny threshold, Hough 파라미터, 안정화 임계)를 튜닝해 주행 환경(조명, 도로 색상)에 맞춰 조절하면 훨씬 견고한 시스템을 만들 수 있습니다.

#   자율주행 라인 감지 주요 함수 정리 (OpenCV 중심)

---

##   1. `detect_edges(frame)`

```python
def detect_edges(frame):
    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)

    lower_red = np.array([0, 70, 50])
    upper_red = np.array([10, 255, 255])
    mask1 = cv2.inRange(hsv, lower_red, upper_red)

    lower_red2 = np.array([170, 70, 50])
    upper_red2 = np.array([180, 255, 255])
    mask2 = cv2.inRange(hsv, lower_red2, upper_red2)

    red_mask = mask1 | mask2
    edges = cv2.Canny(red_mask, 200, 400)

    return edges
```

-   **역할**: 빨간색 차선의 에지(윤곽선) 검출  
-   **사용 함수**:
  - `cv2.cvtColor`: HSV 색 변환
  - `cv2.inRange`: 빨간색 마스크 추출
  - `cv2.Canny`: 에지 검출

---

##   2. `region_of_interest(canny)`

```python
def region_of_interest(canny):
    height, width = canny.shape
    mask = np.zeros_like(canny)
    polygon = np.array([[(0, height), (width, height), (width, height // 2), (0, height // 2)]], np.int32)
    cv2.fillPoly(mask, polygon, 255)
    cropped_edges = cv2.bitwise_and(canny, mask)
    return cropped_edges
```

-   **역할**: 화면 하단 절반만 관심 영역으로 설정  
-   **사용 함수**:
  - `cv2.fillPoly`: 마스크 생성
  - `cv2.bitwise_and`: ROI 외 제거

---

##   3. `detect_line_segments(cropped_edges)`

```python
def detect_line_segments(cropped_edges):
    return cv2.HoughLinesP(cropped_edges, 1, np.pi / 180, 10, np.array([]), minLineLength=8, maxLineGap=4)
```

-   **역할**: 차선으로 추정되는 직선 구간 검출  
-   **사용 함수**:
  - `cv2.HoughLinesP`: 확률적 허프 변환

---

##   4. `average_slope_intercept(frame, line_segments)`

```python
def average_slope_intercept(frame, line_segments):
    height, width, _ = frame.shape
    left_fit = []
    right_fit = []

    for segment in line_segments:
        x1, y1, x2, y2 = segment[0]
        if x1 == x2:
            continue
        slope = (y2 - y1) / (x2 - x1)
        intercept = y1 - slope * x1

        if slope < 0:
            left_fit.append((slope, intercept))
        else:
            right_fit.append((slope, intercept))

    lane_lines = []
    if left_fit:
        left_fit_avg = np.average(left_fit, axis=0)
        lane_lines.append(make_points(frame, left_fit_avg))
    if right_fit:
        right_fit_avg = np.average(right_fit, axis=0)
        lane_lines.append(make_points(frame, right_fit_avg))

    return lane_lines
```

-   **역할**: 좌/우 차선 평균화 및 대표 선 생성  
-   **관련 함수**: `make_points`

---

##   5. `make_points(frame, line)`

```python
def make_points(frame, line):
    height, width, _ = frame.shape
    slope, intercept = line
    y1 = height
    y2 = int(y1 * 0.5)
    x1 = int((y1 - intercept) / slope)
    x2 = int((y2 - intercept) / slope)
    return [[x1, y1, x2, y2]]
```

-   **역할**: 평균화된 직선 정보 → 이미지상의 점 좌표 변환

---

##   6. `display_lines(frame, lines)`

```python
def display_lines(frame, lines, line_color=(0, 255, 0), line_width=6):
    line_image = np.zeros_like(frame)
    if lines is not None:
        for line in lines:
            x1, y1, x2, y2 = line[0]
            cv2.line(line_image, (x1, y1), (x2, y2), line_color, line_width)
    return cv2.addWeighted(frame, 0.8, line_image, 1, 1)
```

-   **역할**: 검출된 차선을 원본 영상에 시각화  
-   **사용 함수**:
  - `cv2.line`: 선 그리기
  - `cv2.addWeighted`: 원본과 선 이미지 합성

---

##   7. `compute_steering_angle(frame, lane_lines)`

```python
def compute_steering_angle(frame, lane_lines):
    height, width, _ = frame.shape
    if len(lane_lines) == 1:
        x1, _, x2, _ = lane_lines[0][0]
        x_offset = x2 - x1
    elif len(lane_lines) == 2:
        _, _, left_x2, _ = lane_lines[0][0]
        _, _, right_x2, _ = lane_lines[1][0]
        mid = width // 2
        x_offset = (left_x2 + right_x2) // 2 - mid
    else:
        x_offset = 0

    y_offset = height // 2
    angle_to_mid_radian = math.atan(x_offset / y_offset)
    angle_to_mid_deg = int(angle_to_mid_radian * 180.0 / math.pi)
    return angle_to_mid_deg + 90
```

-   **역할**: 현재 차선 기준 조향 각도 계산

---

##   8. `display_heading_line(frame, steering_angle)`

```python
def display_heading_line(frame, steering_angle, line_color=(0, 0, 255), line_width=5):
    heading_image = np.zeros_like(frame)
    height, width, _ = frame.shape
    steering_angle_radian = steering_angle / 180.0 * math.pi
    x1 = width // 2
    y1 = height
    x2 = int(x1 - height / 2 / math.tan(steering_angle_radian))
    y2 = int(height / 2)
    cv2.line(heading_image, (x1, y1), (x2, y2), line_color, line_width)
    return cv2.addWeighted(frame, 0.8, heading_image, 1, 1)
```

-   **역할**: 현재 조향 방향을 시각적으로 표현  
-   **사용 함수**: `cv2.line`, `cv2.addWeighted`

---

##   9. `stabilize_steering_angle(...)`

```python
def stabilize_steering_angle(curr_angle, new_angle, lines_count, max_deviation=5):
    max_deviation *= lines_count
    angle_diff = new_angle - curr_angle

    if abs(angle_diff) > max_deviation:
        stabilized_angle = int(curr_angle + max_deviation * angle_diff / abs(angle_diff))
    else:
        stabilized_angle = new_angle

    return stabilized_angle
```

-   **역할**: 조향각 급변 방지, 안정적인 주행 유지

왜 CNN인가?

- 이미지를 1D 벡터 입력으로 평면화하면 2D 이미지의 공간적 특징이 손실됨

CNN (Convolution Neural Network, 합성곱신경망)

- CNN 구조

CNN 개요

- Input Image : 이미지를 하나의 입력으로 취함

- Convolution Layers : Feature Extraction을 수행하는 Layer

- Convolution Layer + ReLU : Feature 추출, 의미 없는 특징을 zero화

- Pooling Layer : Feature 개수 축소, 중요한 Feature만 유지 (선택적 작업)

- Fully-Connected Layer : 비선형 조합 학습 및 분류 작업 수행하는 Layer

- Output Class : 작업의 결과

CNN 활용분야

- 분류 (Classification)

- 지역화 (Localization)

- 이미지 세분화 (Image Segmentation)

- 물체 감지 (Object Detection)

CNN 이해 - 필터 커널 (Filter Kernel)

- Filter (Convolution Kernel Matrix)를 적용하여 입력에 대해 특정 성분에 대해서만 뽑아내는 작업

- 예) 사선 정보, 직선 정보, 동그란 정보, 각진 정보, ...

- 알고 싶은 특정 성분에 따라 Filter의 모양이 다름

- CNN은 Filter를 갱신하면서 학습하는 것임

- Image에 특정 Filter를 Convolution한 결과를 Feature Map이라고 함

- Feature Map은 Image에 적용된 Filter 개수 만큼의 Channel을 갖게 됨

- n개의 Filter가 적용된 경우 n개 Channel

- Stride : Filter를 순회하는 간격, Stride가 2로 설정되면 2칸씩 이동하면서 convolution하게 됨

Image Kernels explained visually

- 원본 이미지에 특수한 행렬로 컨볼루션을 취함

- 행렬의 특성에 따라 원본 이미지로부터 특성이 강조된 이미지를 얻을 수 있음

https://cs231n.github.io/convolutional-networks/

CNN 이해

- 신경망의 높은 계층이 낮은 게층의 출력에 기반한 가중치가 적용된 합으로 형성됨

- 각 높은 계층의 뉴런은 낮은 계층의 특징들을 받아 이들의 가중합을 계산하고 이를 바탕으로 더 복잡한 특징을 인식

- Transfer Learning : 이미 대규모 데이터셋에서 사전 훈련된 모델의 지식을 새로운 문제에 적용하는 방법론으로 이때 낮은 계층의 일반적인 특징은 유지되고 높은 계층의 특징은 새로운 문제에 맞게 조정

- Capsule Network : 개별 뉴런 대신 "켑슐"이라 불리는 뉴런의 그룹을 사용하여 이미지 내 객체의 다양한 속성과 공간적인 관계를 보다 효과적으로 인식하는 신경망 구조

CNN 이해 - Padding

- Convolution Layer에서 Filter를 사용하여 Feature Map을 생성할 때, 이미지 크기가 작아지는 것을 막기 위해 테두리에 Filter 크기를 고려하여 특정 값(일반적으로 0)으로 채우는 작업

- 5x5 이미지에서 3x3 Filter를 사용하면 3x3 크기의 Feature Map이 만들어짐

즉, 5x5 이미지의 둘레에 0을 채워 7x7의 이미지로 만들어서 3x3 Filter를 적용해 5x5의 Feature Map을 얻음

- Padding 작업을 통해 인공신경망 이미지 외곽을 인식하도록 하는 효과도 있음 (필수 작업은 아님)

CNN 이해 - Pooling

- Convolution Layer의 Output을 Input으로 받아 Feature Map의 크기를 줄이거나 특정 데이터를 강조하는 용도로 사용

- Max Pooling, Min Pooling, Average Pooling 등의 종류가 있음

- Pooling Size를 Stride로 지정하며 이 크기에 따라 줄어드는 양이 줄어듬

- 입력 데이터의 행, 열 크기는 Pooling 사이즈의 배수(나누어 떨어지는 수)이어야 함

CNN 이해 - Filter & Pooling

CNN 이해 - Fully Connected Layer

- Flatten Layer : CNN의 데이터를 Fully Connected Neural Network의 형태로 변경하는 Layer

- 입력 데이터의 Shape 변경만 수행

- 입력 Shape이 (8, 8, 10)이면 Flatten이 적용된 Shape은 (640, 1)이 됨

- Softmax Layer : Flatten Layer의 출력을 입력으로 사요하며 분류 클래스에 매칭시키는 Layer

- 분류 작업을 실행해 결과를 얻게됨

- 입력 Shape이 (640, 1)이고 분류 클래스가 10인 경우 Softmax가 적용된 출력 Shape은 (10, 1)이 됨. 이때 weight의 shape은 (10, 640)이며 Softmax Layer의 parameter가 6,400개임

다양한 CNN 네트워크

전이학습의 필요성

- 딥러닝 모델 학습의 계산 자원과 시간

- MNIST 흑백 이미지 인식 모델 → 최소 3개의 convolution layer + 1개의 fully connected layer 필요

- CPU 환경에 따라 수 분~수십 분 소요됨

- CIFAR-10 고해상도 컬러 이미지 → 최소 5개의 convolution layer + 2개의 fully connected layer 필요

- 일반 CPU에서 수 시간~수십 시간 소요됨

- 최신 대규모 CNN 아키텍쳐(ResNet-152, EfficientNet-B7 등) → 수백 GPU 시간 + 대량의 데이터 필요함

- 전이학습의 해결책

- Pre-trained CNN 모델 활용 → 분석 데이터에 맞게 Fine-tuning

- 학습 시간 획기적 단축됨

- 데이터 부족 상황에서도 우수한 성능 확보 가능함

동작 원리

- 다른 도메인 간의 전이

- 동물 사진으로 학습한 모델 → 자동차/오토바이 분류에 활용 가능함

- 도메인 간 거리가 멀수록 효과는 감소함

- Fine-tuning 통해 우수한 성능 확보 가능함

- 딥러닝 모델의 층별 특성

- 초기 층 → "일번적인(general)" 특징 추출함 (에지, 색상, 텍스처 등)

- 마지막 층 → "구체적인(specific)" 특징 추출함 (얼굴 특징, 특정 객체 부분 등)

- 시각적 특징 추출 과정

- 초기 층 → 수평선, 수직선, 에지, 단순 텍스처 감지함

- 중간 층 → 복잡한 패턴, 질감, 단순 형태 감지함

- 마지막 층 → 고수준 특징 (얼굴, 바퀴, 눈 등) 식별함

- 재사용 가능성

- 초기 층 → 다른 데이터셋에도 재사용 가능함

- 마지막 층 → 새로운 문제마다 새로 학습 필요함

**기계학습-신경망(CNN) 알아보기**

1. TensorFlow에서 사용하는 CNN 메서드 탐구하기
2. 데이터셋, 데이터 정규화, 모델, loss, accuracy의 개념을 정리하기
3. VGGNet 그림을 보고 직접 만들어보기

**[CNN 기반의 숫자 이미지 분류 - MNIST 데이터셋 활용_by Tensorflow]**

1.라이브러리 가져오기

# tensorflow 불러오기
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
print(tf.__version__)

2.데이터셋 로드 및 전처리하기

- MNIST는 0부터 9까지 숫자 손글씨로 이루어진 데이터셋으로\
28X28사이즈의 60000의 훈련 데이터와 10000개의 테스트 데이터로 구성되어 있습니다.
    - x_train.shape == (60000, 28, 28)
    - x_test.shape == (10000, 28, 28)
    - y_train.shape == (60000,)
    - y_test.shape == (10000,)

- Convolution Neural Network를 구성하고 있는 매개변수(Arguments)는 filters부터 bias_contraint까지 총 16개로 구성되어 있습니다.

- **filters** : 출력되는 결과의 차원수를 의미합니다.
- filter가 영향을 준 부분은 Tuple의 마지막 부분인 channel파트입니다. 즉 filter를 몇개 주는지에 따라서 channel수가 바뀌게 되고 이는 차원수가 바뀌는 것을 의미합니다.

- **kernel_size** : kernel_size가 위에 있는 코드는 3, 아래에 있는 코드는 2로 되어 있습니다. 그래서 output이 바뀐 파트는 Tuple의 2번째, 3번째에 영향을 줍니다.

위에 있는 gif를 보게 되면 빨간색 6x6 이미지를 3x3 filter를 이용해 convolution 연산이 진행되고 결과값은 보라색 이미지인 4x4이미지입니다.

해당 방식을 수학적으로 표현하면 다음과 같이 표현가능합니다.

output = input - filter + 1

- **strides**\ : strides는 filter 이동을 1개씩 가는 것이 아니라 n개씩 가도록 설정하는 매개변수입니다.

위에 있는 그림을 보게 되면 5x5 이미지를 3x3 filter가 2개씩 가도록 설정되어 있습니다.\
해당 설정을 하지 않았다면 output의 크기는 3x3이 되어야 하지만 stride가 설정되면서 2x2로 출력값이 나오게 되었습니다. 해당 내용도 코드로도 확인해보도록 하겠습니다.

stride가 적용되면 실제 output의 크기는 step만큼 나누어져서 계산됩니다.
그렇기에 stride가 적용된 output_shape은 다음과 같습니다.

- **padding**
- padding을 하는 이유는 filter는 가운데 파트는 몇번씩 거치면서 계산되지만 끝에 있는 edge부분은 한번밖에 계산되지 않습니다. 그렇기에 padding을 주어서 edge를 잘 볼 수 있게 하는 장치입니다.

- TensorFlow의 경우 padding은 '자동'으로 적용하며 'valid'는 적용하지 않은 것이며 'same'은 padding이 적용된 상황입니다.

padding이 적용되었을 때 Output shape은 다음과 같이 계산됩니다.

- **input_shape** : 처음 layer를 쌓을 떄 설정해주는 값이며
- **activation** : convolution 연산 이후 활성화함수를 고르는 매개변수입니다.

- 신경망 모델을 만들려면 모델의 층을 구성한 다음 모델을 컴파일합니다.

from tensorflow import keras

# 모델 아키텍처 정의
model = keras.Sequential([
    # 입력 레이어 정의
    keras.layers.Input(shape=(28, 28, 1)),
    # 첫 번째 Convolution layer를 정의
    keras.layers.Conv2D(16, (3, 3), activation='relu'),
    # 두 번째MaxPooling2D layer 추가 (pooling size: (2, 2))
    keras.layers.MaxPooling2D(pool_size=(2, 2)),

    # 두 번째 Convolution layer 추가 (output 차원수: 32, filter 사이즈: 3, 활성화 함수: relu)
    keras.layers.Conv2D(32, (3, 3), padding='same', activation='relu'),
    # 두 번째 MaxPooling2D layer 추가
    keras.layers.MaxPooling2D(pool_size=(2, 2)),

    # 차원을 줄이는 Flatten layer 추가
    keras.layers.Flatten(),

    # Dense layer 추가 (output unit: 32, 활성화 함수: relu)
    keras.layers.Dense(32, activation='relu'),

    # 최종 Dense layer 추가 (output unit: 10, 활성화 함수: softmax)
    keras.layers.Dense(10, activation='softmax')
])

# 모델 확인
model.summary()

# 모델 컴파일. 손실 함수, 옵티마이저, 메트릭 정의
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])
              
# 훈련 데이터를 이용해 모델 학습
model.fit(train_images, train_labels, epochs=5)

# 테스트 데이터로 모델 평가. 손실과 정확도 출력
test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)
print('테스트 loss:', test_loss, '테스트 정확도:', test_acc)

# 예측 결과 시각화
predictions = model.predict(test_images)
num_rows = 3
num_cols = 3
num_images = num_rows * num_cols
plt.figure(figsize=(2*num_cols, 2*num_rows))
for i in range(num_images):
    plt.subplot(num_rows, num_cols, i+1)
    plt.imshow(test_images[i], cmap=plt.cm.binary)
    plt.xticks([])
    plt.yticks([])
    predicted_label = np.argmax(predictions[i])
    true_label = test_labels[i]
    if predicted_label == true_label:
        color = 'green'
    else:
        color = 'red'
    plt.xlabel("{} ({})".format(predicted_label, true_label), color=color)
plt.show()

7-11_신경망모델_CNN알아보기_분류(이미지)_손글씨숫자분류_Tensorflow.ipynb

0.95MB

이미지 데이터 수집

7_10_Image_Downloader.ipynb

0.01MB

7_10_Banana_Classification.ipynb

0.16MB

12일차

호타리 — Tue, 29 Apr 2025 16:31:11 +0900

2025.04.29

이미지 변형 - 흐림

흐림 효과 (Blur)

- 블러링(Blurring) 또는 스무딩(Smoothing)이라 불림
- 영상이나 이미지를 번지게 하며, 해당 픽셀의 주변 값들과 비교하고 계산해서 픽셀들의 색상을 재조정함
- 단순히 이미지를 흐리게 만드는 것뿐만 아니라 노이즈를 제거해서 연산 시 계산을 빠르고 정확하게 수행하는 데 도움을 줌
- 노이즈를 줄이거나 외부 영향을 최소화하는 데 사용
- 의도적으로 이미지를 흐리게 하는 이유는 보이는 정보를 조정함으로써 외곽선 정보를 보다 단순하게 처리함

cv2.blur()
   - 이것은 단순 평균 블러링을 수행합니다.
   - 지정된 커널 크기 내의 모든 픽셀 값의 평균을 계산하여 이미지를 흐리게 만듭니다.
   - 결과적으로 동일한 가중치로 주변 픽셀의 값을 평균화합니다.
`dst = cv2.blur(src, ksize, anchor, borderType)` :입력 이미지(src)를 커널 크기(ksize), 고정점(anchor), 테두리 외삽법(borderType)으로 흐림 효과를 적용한 결과 이미지(dst)를 반환
- ksize : 커널(kernel) 크기-이미지에서 (x, y)의 픽셀과 설정한 크기의 사각형 커널이며 커널 크기가 클수록 더 흐려짐
- anchor :(-1, -1) 커널의 중심을 의미함, 기본값: 커널 내에서의 앵커 포인트(커널을 이미지에 적용할 때 기준이 되는 특정 픽셀 위치)
- borderType : 테두리 외삽법(Border Extrapolation) - 컨벌루션을 적용할 때, 이미지 가장자리 부분의 처리 방식
    - borderType=cv2.BORDER_DEFAULT : 기본 테두리 유형 사용

가우시안 블러

`blurred_image = cv2.GaussianBlur(source_image, (kernel_width, kernel_height), sigmaX, sigmaY)`
- 이미지를 흐리게 하면서도 노이즈도 제거함. 이렇게 하면 이미지 연산할때 보다 빠르게 정확하게 처리할 수 있음 = > 노이즈 제거, 이미지 부드럽게 처리, 엣지 검출을 위한 사전 처리 단계 등 다양한 목적으로 활용

   - 가우시안 함수를 기반으로 한 가중치를 사용하여 블러링을 수행합니다.
   - 커널의 중심에 가까운 픽셀은 더 높은 가중치를 가지며, 멀리 떨어진 픽셀은 더 낮은 가중치를 가집니다.
   - 커널의 크기는 블러링의 정도를 결정
       - 큰 커널은 이미지를 더 흐리게 만들며,
       - 작은 커널은 덜 흐리게 만듬
   - sigmaX : 가우시안 블러에서 X 방향의 표준 편차는 블러의 정도와 연관이 있음
        - 큰 표준 편차는 이미지를 더 흐리게 만들며,
        - 작은 표준 편차는 덜 흐리게 만듬
   - sigmaY : Y 방향(세로) 가우시안 커널 표준편차 (기본값은 0)

cv2.blur() vs cv2.GaussianBlur() vs cv2.medianBlur()

- `cv2.blur()`평균블러링링: 단순히 주변 픽셀 평균 계산- 더 단순하고 빠르게 이미지를 흐리게 만들 수 있습니다. 특정 애플리케이션에서는 이것이 더 적합할 수 있음
- `cv2.GaussianBlur()`:가중 평균 (중앙 픽셀에 더 많은 가중치) - 이미지의 노이즈를 줄이는 데 특히 효과적입니다. 가우시안 블러는 노이즈 제거와 동시에 이미지의 경계를 부드럽게 만들어 주기 때문에 많은 컴퓨터 비전 작업에서 선호됨.
- `cv2.medianBlur()`: 미디언 블러링 (cv2.medianBlur) - 주변 픽셀의 중앙값을 사용, 노이즈 제거에 최고(특히 소금-후추 노이즈 제거 효과 뛰어남)

샤프닝 (Sharpening)

- 영상을 날카롭게 만드는 처리
- 영상을 선명하게 할 때 사용
- 중심 화소값과 인접 화소값의 차이를 더 크게 만듬
- cv2.filter2D : OpenCV 라이브러리에서 제공하는 함수로, 사용자가 정의한 커널(또는 필터)를 이미지에 적용하여 2차원 필터링을 수행하는 기능을 제공
- `dst = cv2.filter2D(src, ddepth, kernel, anchor, delta, borderType)`
    - src: 입력 이미지입니다. 보통 numpy 배열로 표현됩니다.
    - ddepth: 결과 이미지의 깊이(비트 단위)입니다. -1로 지정하면 입력 이미지와 동일한 깊이를 사용합니다.
    - kernel: 필터링에 사용될 커널입니다. numpy 배열로 정의되며, 일반적으로 부동소수점 값으로 구성됩니다.
    - anchor: 선택적으로 커널의 중심을 지정하는 점입니다. 기본값은 (-1, -1)로, 커널의 중심을 사용합니다.
    - delta: 필터링된 픽셀에 추가적으로 더해질 값. 기본값은 0입니다.
    - borderType: 이미지 가장자리 픽셀을 확장하는 방식을 결정합니다. 예를 들어, cv2.BORDER_CONSTANT, cv2.BORDER_REFLECT, cv2.- BORDER_WRAP 등이 있습니다.

이미지 검출 (경계선)

Canny Edge Detection
- 이미지에서 **윤곽선(에지)**를 똑똑하게 찾아주는 아주 중요한 기법
- 컬러이미지에 적용할 경우 내부적으로 회색조로 변경한 후 에지 검출을 수행함.

- Canny Edge Detection 4단계
    - 1️⃣ Noise Reduction (노이즈 제거) : 잡음 때문에 잘못된 엣지를 검출하는 걸 막기 위해 **Gaussian Blur (가우시안 블러링)**을 적용해서 부드럽게 만들기
        ```python
        blur = cv2.GaussianBlur(img, (5,5), 1.4)
        ```
    - 2️⃣ Finding Intensity Gradient (기울기(gradient) 계산) : 밝기가 얼마나 급격하게 변하는지 (밝기 차이) 계산. 변하는 정도(기울기)와 방향(어디로 밝아지는지)을 알아내기 위해 OpenCV 내부에서는 Sobel 연산 사용
        ```python
        Gx = Sobel(blur, 방향=x)  # 수평 기울기
        Gy = Sobel(blur, 방향=y)  # 수직 기울기
        magnitude = sqrt(Gx^2 + Gy^2)  # 전체 기울기 크기
        direction = atan2(Gy, Gx)      # 기울기 방향
        ```
    - 3️⃣ Non-Maximum Suppression (비최대 억제) : 기울기(gradient)가 가장 강한 부분만 살리고, 주변 약한 부분은 지움 => 가장 뾰족한(최고점)만 남겨서 엣지를 가늘게 만들어주는 단계 (최대 크기의 픽셀만 골라내서 에지 픽셀로 설정)

    - 4️⃣ Hysteresis Thresholding (이력 기반 문턱값 처리) : 모든 에지 후보들이 실제 에지인지 아닌지를 결정
        - 조명이나 다른 변수의 영향으로 인해 영상의 그래디언트가 미세하게 변화할 수 있기때문에 픽셀 값이 임계점보다 커지거나 낮아질 수 있는데, 이를 방지하기 위해 두 개의 임계값을 이용함.
        - 강한 엣지는 무조건 엣지로 채택하고, 약한 엣지는 강한 엣지와 연결된 경우에만 엣지로 인정 => 진짜 엣지와 연결된 부분만 살려서 깔끔하게 정리. OpenCV에서는 두 개의 문턱값을 설정
        ```python
        edges = cv2.Canny(img, threshold1=50, threshold2=150)
        ```
- `cv2.Canny(img, threshold1, threshold2)`
    - threshold1 (하위 임계값, minVal): 이 값 이하의 그레이디언트(명암 변화율)를 가진 픽셀은 에지가 아니라고 간주함(에지로 간주되기 위한 최소한의 명암 변화량)

    - threshold2 (상위 임계값, maxVal): 이 값 이상의 그레이디언트를 가진 픽셀은 강한 에지로 간주되며, threshold1과 threshold2 사이의 그레이디언트를 가진 픽셀은 연결된 강한 에지가 존재할 경우에만 에지로 간주함

이미지 검출 - 윤곽선

1. 컨투어(Contour) : 경계선을 연결한 선

- 컨투어(우리말로 등고선, 윤곽선, 외곽선 등으로 번역)s는 지도에서 지형의 높이가 같은 영역을 하나의 선으로 표시하는 용도로 많이 사용됨
- 영상에서는 같은 색상이나 밝기의 연속된 점을 찾아 잇는 곡선을 찾아내면 모양 분석과 객체 인식에 사용할 수 있음
- `contour, hierarchy = cv2.findCountours(src, mode, method[, contours, hierarchy, offset])[-2:]`
    - src : 입력 이미지, 바이너리 스케일, 검은색 배경 흰색 전경
    mode : 컨투어 제공 방식 선택
    - cv2.RETR_EXTERNAL : 가장 바깥쪽 라인만 제공
    - cv2.RETR_LIST : 모든 라인을 계층 없이 제공
    - cv2.RETR_CCOMP : 모든 라인을 2계층으로 제공
    - cv2.RETR_TREE : 모든 라인의 모든 계층 정보를 트리 구조로 제공
    - method : 근사 값 방식 선택
    - cv2.CHAIN_APPROX_NONE : 근사 계산하지 않고 모든 좌표 제공
    - cv2.CHAIN_APPROX_SIMPLE : 컨투어 꼭짓점 좌표만 제공
    - cv2.CHAIN_APPROX_TC89_L1 : Teh-Chin 알고리즘으로 좌표 개수 축소
    - cv2.CHAIN_APPROX_TC89_KCOS : Teh-Chin 알고리즘으로 좌표 개수 축소
    - contours : 검출한 건투어 좌표, 파이썬 리스트
    - hierarchy : 컨투어 계층 정보
- `cv2.drawContours(img, contours, contourIdx, color, thickness)`
    - img : 입력 영상
    - contours : 그림 그릴 컨투어 배열
    - contourIdx : 그림 그릴 컨투어 인덱스, -1 : 모든 컨투어 표시
    - color : 색상
    - thickness : 선 두께, 0:채우기

2. 윤곽선 검출 : findContours()
- 원본이미지를 직접 수정하는 함수임. 따라서 원본이미지를 보존하기위해 복사해서 사용

3. 윤곽선 그리기 : drawContours()

윤곽선 찾을 때 근사치 방법

- cv2.findContours() : 이진화 이미지에서 윤곽선(컨투어)를 검색

- `contours, hierarchy = cv2.findContours(binary, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)`
- contours : 이미지에서 경계를 찾고, 경계 좌표를 contours와 같은 형태로 반환합니다.
- 윤곽선, 계층구조 = cv2.findContours(이진화 이미지, 검색 방법, 근사화 방법)
    - 검색 방법
        - cv2.RETR_EXTERNAL : 외곽 윤곽선만 검출하며, 계층 구조를 구성하지 않습니다.
        - cv2.RETR_LIST : 모든 윤곽선을 검출하며, 계층 구조를 구성하지 않습니다.
        - cv2.RETR_CCOMP : 모든 윤곽선을 검출하며, 계층 구조는 2단계로 구성합니다.
        - cv2.RETR_TREE : 모든 윤곽선을 검출하며, 계층 구조를 모두 형성합니다. (Tree 구조)
    - 근사화 방법
        - cv2.CHAIN_APPROX_NONE : 윤곽점들의 모든 점을 반환합니다.
        - cv2.CHAIN_APPROX_SIMPLE : 윤곽점들 단순화 수평, 수직 및 대각선 요소를 압축하고 끝점만 남겨 둡니다.
        - cv2.CHAIN_APPROX_TC89_L1 : 프리먼 체인 코드에서의 윤곽선으로 적용합니다.
        - cv2.CHAIN_APPROX_TC89_KCOS : 프리먼 체인 코드에서의 윤곽선으로 적용합니다.
    - contours : Numpy 구조의 배열로 검출된 윤곽선의 지점들이 담겨있음
    - hierarchy : 윤곽선의 계층 구조를 의미. 윤곽선의 포함 관계 여부 나타냄 (외곽/내곽/같은 게층구조)윤곽선에 해당하는 속정 정보 포함함

윤곽선 찾기 모드

- cv2.RETR_EXTERNAL : 가장 외곽의 윤곽선만 찾음

- cv2.RETR_LIST : 모든 윤곽선 찾음 (계층 정보 없음)

- cv2.RETR_TREE : 모든 윤곽선 찾음 (계층 정보를 트리 구조로 생성)

- cv2.drawContours() : 검출된 윤곽선 그리기

- `cv2.drawContours(image, contours, contourIdx, color[, thickness[, lineType[, hierarchy[, maxLevel[, offset]]]]] ) -> image`
    - cv2.drawContours(이미지, [윤곽선], 윤곽선 인덱스, (B, G, R), 두께, 선형타입)
    - image : 윤곽선을 그릴 대상 이미지 - 빈 캔버스에 그림
    - 윤곽선 : 검출된 윤곽선들이 저장된 Numpy 배열(좌표 리스트)
    - 윤곽선 인덱스: 검출된 윤곽선 배열에서 몇 번째 인덱스의 윤곽선을 그릴지를 의미합니다.
        - 윤곽선 인덱스를 0으로 사용할 경우 0 번째 인덱스의 윤곽선을 그리게 됩니다. 하지만, 윤곽선 인수를 대괄호로 다시 묶을 경우, 0 번째 인덱스가 최댓값인 배열로 변경됩니다.
        - 동일한 방식으로 [윤곽선], 0과 윤곽선, -1은 동일한 의미를 갖습니다. (-1은 윤곽선 배열 모두를 의미)
        - 예시 [ 2 -1 1 -1]  : [다음 윤곽선, 이전 윤곽선, 내곽 윤곽선, 외곽 윤곽선]에 대한 인덱스 정보를 포함
            - 인덱스 0의 윤곽선의 다음 윤곽선은 인덱스 2의 윤곽선을 의미하며 이전 윤곽선은 존재하지 않다는 것을 의미
            - 내곽 윤곽선은 인덱스 1에 해당하는 윤곽선을 자식 윤곽선으로 두고 있다는 의미입니다.즉, 인덱스 0 윤곽선 내부에 인덱스 1의 윤곽선이 포함되어 있습니다.
            - 외곽 윤곽선은 -1의 값을 갖고 있으므로 외곽 윤곽선은 존재하지 않습니다.

경계 사각형

- 윤곽선의 경계면을 둘러싸는 사각형 : boundingRect()

면적

- 특정 면적 이상의 윤곽선만 찾고 싶을 때 사용 : contourArea()

44_윤곽선검출&외곽선그리기.ipynb

0.25MB

HOG (Histogram of Oriented Gradient)

- 주로 **사람 인식(Human Detection)**과 보행자 검출을 하기 위해 널리 사용되는 기법 중 하나로 이미지의 지역적 형태(윤곽선, 경계)를 잡아내는 특성(Feature) 추출 알고리즘
- 그래디언트 방향 히스토그램을 의미하며 사람이 서 있는 영상에서 그래디언트를 구하고, 그래디언트의 크기와 방향 성분을 이용하여 사람이 서 있는 형태에 대한 특징 벡터를 정의 => 모양(shape) 정보에 강함, 배경 노이즈에 강인
- 이미지를 일정한 셀로 나누고, 각 셀에서 그래디언트 방향의 히스토그램을 계산

    - 1)대상 영역을 일정 크기의 셀로 분할
    - 2)각 셀마다 edge 픽셀(gradient magnitude가 일정 값 이상인 픽셀)들의 방향에 대한 히스토그램을 구한 후
    - 3)이들 히스토그램 bin 값들을 일렬로 연결한 벡터

- 템플릿 매칭과 히스토그램 매칭의 중간 단계에 있는 매칭 방법으로 볼 수 있으며 블록 단위로는 기하학적 정보를 유지하되, 각 블록 내부에서는 히스토그램을 사용함으로써 로컬한 변화에는 어느정도 강인한 특성을 가짐
    - 1) 입력영상에서 부분영상 추출
    - 2) 크기 정규화 : 64X128

    - 3) 64X128영상의 gradient 계산하여 방향과 크기 성분 파악
    - 4) 8*8 크기의 셀분할
    - 5) 방향 시스토그램의 bin 개수 = 9 => 360도를 9개 구간으로 나옴
        > 8*8 셀 4개를 하나의 블록을 지정 ( 블록 하나의 크기는 16X16  => 각 블록의 히스토그램 빈 개수는 4X9=36개)

- `hog(gray, orientations=9, pixels_per_cell=(8, 8), cells_per_block=(2, 2), visualize=True, block_norm='L2-Hys')
    - orientations=9 : 방향(bin) 개수 (360도를 9등분)
    - pixels_per_cell=(8, 8) : 한 셀(cell) 크기
    - cells_per_block=(2, 2) : 블록(block) 내 셀 개수 (정규화 단위)
    - visualize=True : HOG 시각화 결과도 리턴
    - block_norm='L2-Hys' :블록 정규화 방법 (L2-Hysteresis) => 블록(block) 안의 HOG 히스토그램 벡터를
"너무 작거나 너무 큰 값을 정리(normalize)해서 비교가 잘 되게" 하는 과정

-`cv2.HOGDescriptor.detectMultiScale(img, hitThreshold=None, winStride=None, padding=None, scale=None, finalThreshold=None, useMeanshiftGrouping=None) -> foundLocations, foundWeights`
    - img: 입력 영상. cv2.CV_8UC1 또는 cv2.CV_8UC3.
    - hitThreshold: 특징 벡터와 SVM 분류 평면까지의 거리에 대한 임계값
    - winStride: 셀 윈도우 이동 크기. (0, 0) 지정 시 셀 크기와 같게 설정.
    - padding: 패딩 크기
    - scale: 검색 윈도우 크기 확대 비율. 기본값은 1.05.
    - finalThreshold: 검출 결정을 위한 임계값
    - useMeanshiftGrouping: 겹쳐진 검색 윈도우를 합치는 방법 지정 플래그
    - foundLocations: (출력) 검출된 사각형 영역 정보
    - foundWeights: (출력) 검출된 사각형 영역에 대한 신뢰도

SIFT (Scale Invariant Feature Transform)

- 크기(Scale), 회전(Rotation), 조명 변화에 강인한 특징점(keypoint)을 추출하는 알고리즘
- 이미지에서 눈에 띄는 지점(코너, 엣지 등)을 찾고, 해당 위치에서 128차원 디스크립터를 계산함
- 이미지 매칭, 객체 인식 등에서 사용됨

- SIFT는 영상에서 코너점 등 식별이 용이한 특징점들을 선택한 후에 각 특징점을 중심으로 한 로컬 패치(local patch)에 대해 아래 그림과 같은 특징 벡터를 추출한 것을 말함.

- 1)특징점 주변의 영상패치를 4 x 4 블록으로 나누고
- 2)각 블록에 속한 픽셀들의 gradient 방향과 크기에 대한 히스토그램을 구한 후 이 히스토그램 bin 값들을 일렬로 쭉 연결한 128차원 벡터

Haar-like Feature (Haar Cascade)

- 사각형 박스를 기준으로 밝기 차이를 비교하는 간단한 특징
- 빠르고 효율적이지만 딥러닝에 비해 정밀도는 낮음
- 주로 얼굴 검출에 사용됨 (Haar Cascade Classifier)

01_imaging_1-Mission1.py

0.00MB

01_imaging_2_Mission2.py

0.00MB

03_video_3-Mission3.py

0.00MB

04_processing_2_1-Mission4.py

0.00MB

# OpenCV를 사용하여 실시간으로 웹캠에서 움직임을 감지하고, 움직임이 일정 기준 이상 발생하면 녹화를 시작하는 프로그램
################################################################################################ # 미션 1:
#    - 웹캠에서 실시간으로 움직임을 감지하여 자동으로 녹화를 시작하세요.
#    - 움직임이 감지되면 최소 5초 동안 동영상을 저장하고, 움직임이 멈추면 녹화를 종료하세요.
#    - 각 프레임에 현재 시간을 표시하여 저장된 영상에 타임스탬프를 추가하세요.
#    - 결과:
#        - 움직임 감지 결과(diff)와 현재 시간을 표시한 프레임을 화면에 출력.
#        - 움직임이 감지되면 "Recording..." 메시지 출력.
#        - 녹화된 영상 파일은 'Capture' 폴더에 저장 (예: 녹화_YYYY_MM_DD_HH_MM_SS.avi).
#    - 조건:
#        - 연속된 3개의 프레임을 비교하여 움직임 감지 (absdiff 사용).
#        - 움직임 픽셀 수가 특정 임계값(diff_min)을 초과하면 움직임으로 간주.
#        - 타임스탬프는 영상 상단에 표시 (PIL.ImageFont 사용).
#    - 주의:
#        - 녹화 파일명에 타임스탬프를 포함하여 중복되지 않도록 설정.
################################################################################################

cv_5-2_CCTV-motion_detection_recording-Mission1.py

0.00MB

################################################################################################
# 미션 2 :
#    - 이미지에서 파란색, 노란색, 초록색 네모 상자를 감지하세요.
#    - HSV 색상 공간에서 각 색상에 해당하는 범위를 지정하고 마스크를 생성하여 윤곽선을 감지하세요.
#    - 각 윤곽선에 대해 최소 바운딩 박스를 계산하고, 상자의 중심 좌표와 회전 각도를 구하세요.
#    - 감지된 상자 주변에 외곽선을 색상별로 그리세요:
#        - 파란색 상자: 파란 외곽선
#        - 노란색 상자: 노란 외곽선
#        - 초록색 상자: 초록 외곽선
#    - 결과:
#        - 각 색상의 상자 중심 좌표 및 각도를 콘솔에 출력.
#        - 이미지에 각 상자의 외곽선을 그려 시각적으로 결과를 확인.
#    - 조건:
#        - HSV 색상 범위를 정확히 지정하여 노이즈를 최소화.
#        - 윤곽선의 면적 기준(100 픽셀)으로 노이즈 필터링.
#        - 박스는 `cv2.minAreaRect`와 `cv2.boxPoints`를 이용해 그리기.
#    - 주의:
#        - 여러 색상을 한꺼번에 처리하여 코드의 효율성을 유지.
#        - 각 색상별로 구분된 결과를 명확히 표시.
################################################################################################

cv_7-4_find_and_draw_colorboxes-Mission2.py

0.00MB

< OpenCV 얼굴인식 프로젝트1 >
## Step1 : 데이터 수집하기
- 웹캠에서 얼굴 부분만 검출하여 사진 100장 찍어 폴더에 저장하기

1) cv2.CascadeClassifier() 객체 선언하기
2) cv2.VideoCapture(0) 객체 선언하기
3) 웹캠이 열려있으면
- frame 을 읽어서
- 회색조로 변경
- detectMultiScale() 사용하여 얼굴 감지하기
- 감지된 얼굴에 대해 사이즈  줄여 지정한 폴더에 구분자를 붙여 이미지로 저장하기(cv2.imwrite())
- 화면에는 카운트 숫자 표기하기
- 'q'로 종료하거나 count 가 100일때 종료하기

## Step2 : 모델 학습하기
- 저장된 얼굴 이미지를 읽어서 모델 학습하기
1) 저장된 폴더에서 이미지를 읽어(cv2.imread() ) 회색조로 저장하기
2) 100장의 이미지를 리스트에 학습할 데이터(Training_Data) 와 Labels을 append 하여 각각 저장하기
3) 모델 객체 생성하기 : model = cv2.face.LBPHFaceRecognizer_create()
4) 모델 학습하기 : model.train(Training_Data, Labels)
5) 훈련된 모델 파일로 저장하기 :model.write('face_model.yml')

### 주의!
-  cv2.face.LBPHFaceRecognizer_create()
을 이용해 모델을 학습시키기 할때 다음 에러 발생 시 설치하기
> !pip install --user opencv-python-headless==4.8.1.78
> !pip install --user opencv-contrib-python==4.8.1.78
> !python -m pip install --upgrade pip
> !pip3 install scikit-build
> !pip install cmake

## Step3 : 얼굴 인식하기
- 분류기를 사용하여 웹캠에 비친 얼굴 중 학습한 사용자 인식하기
1) cv2.CascadeClassifier() 객체 선언하기
2) cv2.VideoCapture(0) 객체 선언하기
3) 웹캠이 열려있으면
- frame 을 읽어서
- 회색조로 변경
- detectMultiScale() 사용하여 얼굴 감지하기
- 얼굴이 검출된 경우
- 회색조로 변경하고
             - 모델 예측하기 : model.predict()
             - 예측 결과 신뢰도로가 75 이상인경우 화면에 "ACCESS GRANTED"
                아니면 "ACCESS DENIED"
- 'q'로 종료

### 주의! : step3 에서 'AttributeError: module 'cv2.cv2' has no attribute 'face' 발생시
> !pip install --user opencv-contrib-python==4.6.0.66

11일차

호타리 — Mon, 28 Apr 2025 16:53:51 +0900

2025.04.28

06_컴퓨터비전.pdf

2.98MB

창(window) 관리

cv2.namedWindow(winname, flags) 함수 : winname이라는 이름을 갖는 창을 생성

- winname : 창 구분자로 활용될 창 이름

- flags : 창 옵션 (cv2.WINDOW_NORMAL : 사용자가 창 크기를 조정할 수 있음, cv2.WINDOW_AUTOSIZE : 이미지와 동일한 크기로 창 크기를 재조정할 수 없음

cv2.moveWindow(winname, x, y) 함수 : 원하는 위치로 창을 옮길 수 있음

- winname : 위치를 변경할 창 이름

- x, y : 변경할 위치 (x, y 좌표)

cv2.resizeWindow(winname, width, height) 함수 : winname 창의 크기를 (width, height) 크기로 변경

cv2.destroyWindow(winname) 함수 : winname에 해당하는 창을 닫음

cv2.destroyAllwindows() 함수 : 열린 모든 창을 닫음

imread() : 파일 읽기 함수

- `image = cv2.imread(fileName[, flags])`->retval
    - fileName:읽어올 파일명
    - flags : 이미지를 초기에 불러올 때 적용할 초기 상태를 의미합니다.
        - cv2.IMREAD_UNCHANGED : 원본 사용(-1), alpha channel까지 포함해읽음(png파일)
        - cv2.IMREAD_GRAYSCALE : 그레이스케일로 읽음(0), 1 채널, 실제 이미지 처리시 중간단계로 많이 사용한다.
        - cv2.IMREAD_COLOR : COLOR로 읽음(1) , 3 채널, 투명한 부분은 무시되며, flag디폴트 값이다.

imshow() : 화면 표시 함수

- 이미지 배열을 창(window)에 표시하며, 창 이름과 이미지 데이터를 인수로 받음
- 이미지를 출력한 후에는 반드시 cv2.waitKey로 사용자 입력을 기다리거나, 창이 유지되어야 함함
- `cv2.imshow(Title, imageObject)`
- Title (Required): 이미지를 보여주는 Window 창의 이름임.
- imageObject (Required): 이미지 객체행렬로 cv2.imread()의 반환값을 입력하면 됨.
- Google Colab에서는 cv2_imshow() 사용

imwrite() : 이미지 파일 저장

-cv2.imwrite(filename, img[, params])

이미지 이해

- shape : 이미지의 height, width, channel 정보 - 저장된 이미지의 Numpy 배열 크기(높이, 너비, 채널)

img = [
        [ [B,G,R], [B,G,R], [B,G,R], ..., [B,G,R] ],  ← img[0]: 첫 번째 행 (y = 0)
        [ [B,G,R], [B,G,R], [B,G,R], ..., [B,G,R] ],  ← img[1]: 두 번째 행 (y = 1)
        ...
        [ ... ]                                        ← img[389]: 마지막 행
]

온라인에 있는 이미지 파일 읽기

- JPEG 바이트 (압축된 데이터) → [bytearray] → cv2.imdecode() → 3차원 배열 (H x W x 3)

VideoCapture(index)

VideoCapture(index) 클래스

- index = 0 시스템 기본 카메라

- 카메라가 열렸는지 확인

if not cap.isOpened():
	print("Camera open failed!") # 열리지 않았으면 문자열 출력  
    sys.exit()

- ret, frame = cap.read() # 열리지 않았으면 문자열 출력

- return value - true/false

if not ret: # 새로운 프레임을 못받아 왔을 때 braek   
   break

13_동영상 입출력.ipynb

0.01MB

도형 그리기

빈 스케치북 만들기

- 크기와 초깃값으로 생성
Numpy 배열을 생성할 때 사용할 값을 가지고 있지 않은 경우가 많기 때문에 초기 값을 지정해서 생성하는 방법을 사용

    - numpy.empty(shape [, dtype]) : 초기화되지 않는 값(쓰레기 값)으로 배열 생성
    - numpy.zeros(shape [,dtype]) : 0으로 초기화된 배열 생성
    - numpy.ones(shape [,dtype]) : 1로 초기화된 배열 생성
    - numpy.full(shape, fill_value [,dtype]) : fill_value로 초기화된 배열 생성

- 시퀀스와 난수로 생성
Numpy 배열을 생성하는 방법 중에는 일정한 범위 내에서 순차적인 값을 갖게하는 방법과 난수로 채우는 방법

    - numpy.arange([start=0, ] stop [, step=1, dtype = float64]) : 순차적인 값으로 생성
        - start : 시작 값
        - stop : 종료 값, 범위에 포함되는 수는 ~ stop -1
        - step : 증가 값
        - dtype : 데이터 타입
     - numpy.random.rand(array크기) : 0과 1 사이의 무작위 수 생성
    array크기를 생략하면 난수 1개 반환, 나머지는 해당 크기만큼 값을 반환
    - numpy.random.randn(array크기) : 표준 정규 분포를 따르는 무작위 수 생성

직선

직선의 종류(line type)

1. cv2.LINE_4 : 상하좌우 4 방향으로 연결된 선

2. cv2.LINE_8 : 대각선을 포함한 8방향으로 연결된 선(기본값)

3. cv2.LINE_AA : 부드러운 선(anit-aliasing)

그림판에서 확인 : 그림판은 LINE_8을 사용하고 있음(확대하면 확인 가능)

14_도형그리기.ipynb

0.01MB

텍스트

- cv2.putText(img, 'Coding Simplex', (20, 50), cv2.FONT_HERSHEY_SIMPLEX, SCALE, COLOR, THICKNESS)
- 그릴 위치, 텍스트 내용, 시작위치, 폰트 종류, 크기, 색깔, 두께

OpenCV에서 사용하는 글꼴 종류
1. cv2.FONT_HERSHEY_SIMPLEX : 보통 크기의 산 세리프(sans-serif)글꼴
2. cv2.FONT_HERSHEY_PLAIN : 작은 크기의 산 세리프 글꼴
3. cv2.FONT_HERSHEY_SCRIPT_SIMPLEX : 필기체 스타일 글꼴
4. cv2.FONT_HERSHEY_TRIPLEX : 보통 크기의 산 세리프 글꼴
5. cv2.FONT_ITALIC : 기울림(이탤릭체)

15_텍스트.ipynb

0.00MB

관심 영역(Region of Interest, ROI)

- 이미지 내에서 원하는 피사체를 따로 분리하여 특정 처리를 하고싶을 때 사용하는 방법

- 연산할 데이터의 양을 줄이고 수행 시간을 단축시키기 때문에 특정 연산을 적용해 새로운 이미지와 정보를 획득할 때 전체 이미지로 연산을 하는 것보다 관심이 있는 부분만 연산하는 것이 효과적임

1. Numpy 이용한 ROI 지정

2. 함수 활용하여 ROI 지정

- `cv2.selectROI([win_name,], img[,showCrossHair=True, fromCenter=False])`
    - win_name : ROI 선택을 진행할 창의 이름
    - img : ROI 선택을 진행할 이미지
    - showCrossHair : 선택 영역 중심에 십자 모양 표시 여부
    - fromCenter : 마우스 시작 지점을 영역의 중심으로 지정
    - ret : 선택한 영역 좌표와 크기

21_관심영역.ipynb

0.82MB

이미지색 공간변환

색공간 변환하기

- cv2.cvtColor(img, 옵션값)
    - 색상 공간 변환(Convert Color)은 본래의 색상 공간에서 다른 색상 공간으로 변환할 때 사용
    - 입력된 이미지는 8 비트, 16 비트, 32 비트의 정밀도를 갖는 배열을 사용할 수 있음
    - 데이터 값이 변경되거나 채널 순서가 변경될 수 있음
    - COLOR_BGR2GRAY, COLOR_GRAY2BGR, COLOR_RGB2GRAY, COLOR_GRAY2RGB...

주피터 노트북에 나타내기 - matplotlib 이용

- OpenCV : 다차원 NumPy 배열로 RGB 영상을 표현하지만 순서가 BRG로 반대임
- <b> Matplotlib 에서 opencv 로 읽은 파일 사용하려면 BGR을 RGB로 순서 변경하고 그래프를 그려야함 </b>
- `plt.imshow (src, cmap='plt.cm.원하는 색깔', interpolation='')`
2차원 배열 객체를 색깔로 표시해하는 이미지를 출력할 수 있는 함수임.
[Interpolations for imshow]( https://matplotlib.org/stable/gallery/images_contours_and_fields/interpolation_methods.html)
- `plt.show()`
그림을 표시하고 사용 중인 GUI 백엔드의 메인 루프로 들어갑니다. 플롯을 만들고 표시되는 것을 보고 싶을 때까지 호출하면 안 됩니다.

22_이미지색공간변환.ipynb

1.12MB

크기 조정

- `cv2.resize(원본이미지, (new_width, new_height))`
- img.shape → (height, width, channels) : (width, height) 순서로 지정

보간법

이미지를 변경할 때 자연스럽게 하는 방법

1. cv2.INTER_AREA : 크기 줄일 때 사용

2. cv2.INTER_CUBIC : 크기 늘일 때 사용 (속도 느림, 퀄리티 좋음)

3. cv2.INTER_LINEAR : 크기 늘릴 때 사용 (기본값)

31_크기조정.ipynb

0.01MB

이미지 연산

비트와이즈(bitwise) 연산

- bitwise_and(img1, img2, mask=None) : 각 픽셀에 대한 비트와이즈 AND 연산
- bitwise_or(img1, img2, mask=None) : 각 픽셀에 대한 비트와이즈 OR 연산
- bitwise_xor(img1, img2, mask=None) : 각 픽셀에 대한 비트와이즈 XOR 연산
- bitwise_not(img1, mask=None) : 각 픽셀에 대한 비트와이즈 NOT 연산

23_이미지연산.ipynb

0.70MB

이미지 변형

이진화

- 이진화(Binary)는 어느 지점을 기준으로 값이 높거나 낮은 픽셀의 값을 대상으로 특정 연산을 수행할 때 사용
- 일반적으로 값이 높거나 낮은 픽셀을 검은색 또는 흰색의 값으로 변경
- 기준값에 따라 이분법적으로 구분해 픽셀을 참 또는 거짓으로 나누는 연산이며, 이미지 행렬에서 모든 픽셀에 대해 연산이 수행됩니다.
- 이진화하면 어떠한 경곗값을 기준으로 이진화하면 물체가 선명(뚜렷해짐)해지고 처리해야할 화소가 줄게되어 영상의 용량도 줄어듬

임계처리(Thresholing)

- 임계처리(thresholding)는 이미지 행렬에서 하나의 픽셀값을 사용자가 지정한 기준값(threshold)를 사용하여 이진화(binarization)하는 가장 단순한 필터임. 이진화는 이름에서 알 수 있듯이, 영상(사진)을 이진법처럼 두 가지로만 분류하는 것입니다.
- openCV에서 이진화는 기존의 영상을 검은색과 흰색으로만 이루어진 영상으로 바꾸어주는 작업
- <font color=blue>임계처리(thresholding)는 이미지를 그레이스케일로 변환한 후에 주로 수행</font>됩니다.
- `ret, dst = threshold(src, thresh, maxval, type)`
    - src : 그레이 스케일 이미지
    - thresh : 기준값
    - maxval : 기준값을 넘었을 때 적용할 최대값
    - type : 임계처리 유형
        - THRESH_BINARY : 임계값 이상 = 최댓값, 임계값 이하 = 0
        - THRESH_BINARY_INV : 위의 반전, 임계값 이상 = 0, 임계값 이하 = 최댓값
        - THRESH_TRUNC : 임계값 이상 = 임계값, 임계값 이하 = 원본값
        - THRESH_TOZERO : 임계값 이상 = 원본값, 임계값 이하 = 0
        - THRESH_TOZERO_INV : 위의 반전, 임계값 이상 = 0, 임계값 이하 = 원본값

- ret : 임계값 반환
- dst : 이진화된 영상이 저장

Adaptive Threshold (적응형 스레스홀딩)

- 이미지를 작은 영역으로 나누어서 임계치 적용 - 이진화 처리가 어려운경우
(한쪽은 밝거나 한쪽은 어두운경우, 반사가 심하거나조명이 일정하지 않아 밝고 어둡고 한경우)
- `cv2.adaptiveThreshold(img, value, method, type_flag, block_size, C)`
    - img: 원본 이미지
    - value: 임계값을 만족하는 픽셀에 적용할 값
    - method: 임계값 설정 방법
    - cv2.ADAPTIVE_THRESH_MEAN_C: 이웃 픽셀의 평균으로 결정
    - cv2.ADAPTIVE_THRESH_GAUSSIAN_C: 가우시안 분포에 따른 가중치의 합으로 결정
    - type_flag: 스레시홀딩 적용 방법
    - block_size: 영역으로 나눌 이웃의 크기(n x n), 홀수
    - C: 계산된 임계값 결과에서 가감할 상수(음수 가능)

오츠 알고리즘

최적의 임계값 찾기 - trackbar 사용 안해도 됨 모든 이미지에 최적의 임계값을 찾는 건 아님 Bimodal Image에 사용하기에 적합(최적의 임계치를 자동으로 발견)

24_임계처리.ipynb

0.02MB

히스토그램 분석

- 히스토그램은 특정한 값을 가진 화소가 영상 안에 몇 개나 있는지를 막대그래프로 표시한 것으로 이미지의 픽셀 값(밝기 또는 색상)을 X축으로, 해당 값을 가진 픽셀의 개수를 Y축으로 표현합니다.

    - 그레이스케일 히스토그램: 0(검정)부터 255(흰색)까지의 밝기 값 분포를 보여줍니다.
    - 컬러 히스토그램: RGB 각 채널별로 별도의 히스토그램이 존재합니다

- 히스토그램으로 알 수 있는 정보
    - 전체 밝기 분포: 이미지가 전반적으로 어두운지, 밝은지, 중간 톤인지 판단할 수 있습니다.
    - 대비(Contrast): 히스토그램이 넓게 분포되어 있으면 대비가 높고, 좁게 모여있으면 대비가 낮습니다.
    - 노출 상태: 히스토그램이 오른쪽으로 치우쳐 있으면 과노출, 왼쪽으로 치우쳐 있으면 저노출입니다.
    - 다이내믹 레인지: 픽셀 값이 분포된 범위로, 이미지가 표현하는 밝기의 범위를 나타냅니다.

- 이미지 유형에 따른 히스토그램 해석석
    - 1. 일반적인 고품질 이미지
        - 픽셀 값이 전체 범위(0~255)에 골고루 분포
        - 히스토그램이 양 끝(0이나 255)에 과도하게 집중되지 않음
    - 2. 저대비 이미지
        - 히스토그램이 중앙 부분에 좁게 집중됨
        - 검정과 흰색 부분이 거의 없고 회색조가 대부분
    - 3. 고대비 이미지
        - 히스토그램이 넓은 범위에 분포함
        - 어두운 부분과 밝은 부분의 차이가 뚜렷함
    - 4. 저노출(어두운) 이미지
        - 히스토그램이 왼쪽(어두운 부분)에 집중됨
        - 오른쪽 부분(밝은 값)이 거의 비어있음
    - 5. 과노출(밝은) 이미지
        - 히스토그램이 오른쪽(밝은 부분)에 집중됨
        - 왼쪽 부분(어두운 값)이 거의 비어있음

- cv2.calcHist(img, channel, mask, histSize, ranges)
    - img: 히스토그램을 구하고 싶은 이미지 영상, [img]와 같이 리스트로 입력해주어야 함
    - channel: 히스토그램을 구할 영상의 채널, grayscale 이미지의 경우 [0]을 인자로 입력하고 color 이미지일 경우 B, G, R에 대한 히스토그램을 구하기 위해서 [0], [1], [2]를 인자로 입력
    - mask: 히스토그램을 구할 영역을 지정하는 마스크, None을 입력하면 전체 영상에서 히스토그램을 구함
    - histSize: 히스토그램의 칸의 수를 지정, 보통 한 pixel당 0~255까지의 값을 가져 명암단계가 L = 256이기 때문에 [256]과 같이 리스트로 전달해주면 됨. 128로 지정하면 0과 1을 0, 2와 3을 1, ...로 간주해 128개의 칸을 가진 히스토그램을 구함.
    - ranges: 각 픽셀값이 가질 수 있는 범위, 보통 [0,256]으로 지정, 만약 [0,128]로 지정했다면 128 이상인 값은 세지 않음.

- cv2.equalizeHist()

25_히스토그램분석.ipynb

1.38MB

히스토그램 평활화(Histogram Equalization)

- 특정 영역에 집중되어 있는 영상의 히스토그램 분포를 평평하게 만들어 명암 대비를 높이는 기법
- 명암 값이 몰려 있어서 어둡기만 한 영상 또는 밝기만 한 영상을 평활화하여 좀 더 선명한 영상을 얻음음
- 영상의 명암 대비가 높아지면 영상에 있는 물체를 더 잘 식별할 수 있게됨

< L = 8인 4 x 4 크기의 영상 >
        1) 계산된 히스토그램 분포 h(g)에 전체 크기인 16씩을 나눠주어 정규화 히스토그램 p(g)를 계산
        2) 각 명암값 별로 이전까지의 정규화 히스토그램 p(g)값을 합쳐 누적 정규화 히스토그램 cdf(g)를 계산 : 마지막 1
        3) 각 누적 정규화 히스토그램 값 cdf(g)에 최대 명암값(LmaxLmaxL_{max})인 7씩을 곱하고 반올림

- 이미지의 전반적인 대비를 개선하기 위해 사용되는 방법
    - 특정 밝기 계급에 픽셀이 지나치게 집중되어 있을 때, 이 방식은 몇 가지 문제점을 초래할 수 있다. 예를 들면, 평활화 후의 이미지에서 나머지 계급의 세부 정보가 손실되거나, 비자연스러운 노이즈나 패턴이 발생할 수 있음

- 히스토그램 매칭(Histogram Matching)은 원하는 히스토그램 분포를 가진 참조 이미지를 사용하여, 타겟 이미지의 분포를 조정하는 방법(입력 이미지에 참조 이미지의 색감을 입히는 기법)

- **히스토그램 평활화 효과**
    - 히스토그램이 너무 한쪽(어두운 쪽)에 몰려 있으면 전체적으로 밝게 펴주는 효과가 있음 => 하지만 무조건 밝게 만드는 게 아니라, 명암 대비(contrast)를 전체적으로 넓게 분포시키는 게 목적임.
    - 히스토그램 평활화는 밝고 어두운 영역의 구분을 명확하게 해줍니다. => 흐릿하거나 뿌연 이미지를 더 뚜렷하게(선명하게) 보이게 만들 수 있음.

- `cv2.equalizeHist(img, dst)`
    - img: 히스토그램 평활화를 적용시키고자 하는 영상
    - dst: 결과 이미지(입력 안해도됨)

히스토그램 평활화 : 컬러 이미지

- 컬러영상에 히스토그램 평활화를 적용할 때 RGB 채널 각각에 히스토그램 평활화를 적용한 후 합치면 색이 변하는 문제가 일어날 수 있음(색이 왜곡되어 부자연스러운 이미지가 되기 때문)
    - RGB는 색상(Hue), 명도(Value), 채도(Saturation)가 섞여 있어서, 각 채널을 독립적으로 평활화하면 원래 색상 관계가 깨져버리기 때문
- 먼저 RGB로 받은 이미지를 HSV 또는 YCrCb 형태의 이미지로 변경한 다음에 밝기값(V(Value)) 채널에 해당하는 V 또는 Y 채널에 대해서만 히스토그램 평활화를 적용해야 색을 변경하지 않고 선명하게 만들 수 있음
    - HSV의 V만 평활화 : 색상 유지, 명도만 개선
    - YCrCb의 Y만 평활화 : 방송용 영상에 적합

26_히스토그램평활화및대비조정.ipynb

어핀 변환(Affine Transform)

- 평행 이동, 확대 및 축소, 회전, 스케일 변경, 뒤틀기 등 다양한 방식으로 변환할 수 있게 해주는 기법.
- 이 과정에서 이미지의 병렬성은 유지되지만, 각도와 크기는 변할 수 있음
    - 영상에 어파인 변환을 적용할 경우 직선은 그대로 직선으로 나타나고,
    - 직선 간의 길이 비율과 평행 관계가 그대로 유지된다.
    - 직사각형 형태의 영상은 어파인 변환에 의해 평행사변형에 해당하는 모습으로 변경된다.

- 영상을 구성하는 픽셀의 배치 구조를 변경함으로써 전체 영상의 모양을 바꾸는 작업

1. 어파인 변환 행렬 구하기

    - `martix = cv2.getAffineTransform(pts1, pts2)`
        - pts1: 변환 전 영상의 좌표 3개, 3 x 2 배열
        - pts2: 변환 후 영상의 좌표 3개, 3 x 2 배열
        - matrix: 변환 행렬 반환, 2 x 3 행렬

2. 어파인 변환하기
    - warpAffine() : src 영상을 어파인 변환하여 dst 영상을 생성하는 함수
    - `cv2.warpAffine(src, M, dsize, dst=None, flags=None, borderMode=None, borderValue=None) -> dst`
        • src: 입력 영상
        • M: 2x3 어파인 변환 행렬. 실수형.
        • dsize: 결과 영상 크기. (w, h) 튜플. (0, 0)이면 src와 같은 크기로 설정.
        • dst: 출력 영상
        • flags: 보간법. 기본값은 cv2.INTER_LINEAR.
        • borderMode: 가장자리 픽셀 확장 방식. 기본값은 cv2.BORDER_CONSTANT.
        • borderValue: cv2.BORDER_CONSTANT일 때 사용할 상수 값. 기본값은 0(검정색).

35_어파인변환.ipynb

0.03MB

원근 변환(Perspective Transform) : 원근 이미지 ↔ 평면 이미지

스마트폰으로 문서를 찍으면 주변이 삐둘거리거나 사다리꼴형으로 되는데 이런 이미지를 직사각형으로 펼치는 방법

https://bkshin.tistory.com/entry/OpenCV-14-%EC%9D%B4%EB%AF%B8%EC%A7%80-%EB%92%A4%ED%8B%80%EA%B8%B0%EC%96%B4%ED%95%80-%EB%B3%80%ED%99%98-%EC%9B%90%EA%B7%BC-%EB%B3%80%ED%99%98

원근 변환은 이미지를 3차원으로 변환 - 원근법의 원리를 적용해 변환

- mtrx = cv2.getPerspectiveTransform(pts1, pts2)
    - pts1: 변환 이전 영상의 좌표 4개, 4 x 2 배열
    - pts2: 변환 이후 영상의 좌표 4개, 4 x 2 배열
    - mtrx: 변환행렬 반환, 3 x 3 행렬

- cv2.warpPerspective()

36_원근변환.ipynb

0.04MB

영상 필터링 및 이미지 향상

블러링, 샤프닝, 에지 검출, 컨투어 검출 및 외곽선 그리기

41_블러링.ipynb

0.01MB

특징 추출 및 고급 처리

SIFT, HOG, Haar

051_SIFT.ipynb

0.00MB

10일차

호타리 — Mon, 28 Apr 2025 09:11:36 +0900

2025.04.25

병가

9일차

호타리 — Thu, 24 Apr 2025 16:46:07 +0900

2025.04.24

04-32_군집화모델-Prj1_마케팅고객군집화-연습파일_0424.ipynb

0.29MB

Windows 에서 NVIDA GPU 사용하기

[ 기본사항 ]

NVIDIA 드라이버 설치 (또는 업데이트) : 최신 설치

현재 교육장 PC에 설치된 NVIDIA 드라이버 : GeForce RTX 4060
https://www.nvidia.co.kr/Download/index.aspx?lang=kr

설치 확인 : cmd 에서 nvidia-smi 실행

딥러닝 프레임워크 Timeline

딥러닝 프레임워크 비교

Keras

Keras를 이용하여 딥러닝 학습하기 프로세스

딥러닝 작동 원리

MLP의 한계

MLP의 한계 극복

- 1980 ~ 1990년대 후반까지 MLP의 한계를 극복하지 못했지만, 이후 딥러닝 연구와 함께 다음의 혁신적인 기술들로 해결됨

딥러닝 작동 원리 - 활성화함수

- 활성화함수(activation function) : 생물학전 뉴런에서 입력 신호가 일정 크기 이상일 때만 신호를 전달하는 메커니즘을 모방한 함수

딥러닝 작동 원리 - 선형변환

딥러닝 작동 원리 - 비선형변환

딥러닝 작동 원리 - 비용함수 업데이트 &학습률

딥러닝 작동 원리 - 옵티마이저

딥러닝 작동 원리 - 순전파 / 역전파

딥러닝 작동 원리 - 역전파에 체인룰 적용

딥러닝 작동 원리 - 분류 : 손실함수

데이터셋 사용

- 훈련데이터셋, 테스트 데이터셋, 검증데이터셋

A Neural Network Playground

[ 딥러닝 프레임워크에서 gpu 사용하기 ]

1.Tensorflow 및 필요한 라이브러리 설치하기

anaconda prompt 에서 라이브러리 설치

https://www.tensorflow.org/install/pip?hl=ko

tensorflow - gpu 만나게 하기 (1)

1. Anaconda prompt로 새로운 가상환경을 만든다.

conda create -n (가상환경의 이름) python=3.10
예) conda create -n tf-gpu python=3.10

2. 새로 만든 가상환경을 Activate한다.

conda activate tf-gpu

3. 가상환경에서 다음을 설치한다.

pip install "numpy<2.0" 

conda install -c conda-forge cudatoolkit=11.8 cudnn=8.9.7
pip install tensorflow-gpu==2.10

( or conda-forge와 defaults 채널에서는 cudatoolkit=12.8이 제공되지 않음)

4. 커널 생성 : 주피터 노트북 파일 사용할 경우

pip install ipykernel

5. 주피터 노트북 프로그램에서 커널 이름 보이게 하기

python -m ipykernel install --user --name=tf-gpu

6. 주피터 노트북 셀에서 코드를 돌려보고 확인한다.

import tensorflow as tf
print(tf.config.list_physical_devices('GPU'))"

마지막 명령어를 쳤을 때 아래와 같이 나오면, 70퍼센트 성공왜냐하면 이 상태로는 주피터 노트북에서 실행이 안 되기 때문이다…
새로운 주피터 노트북 ipykernel 만들기 오른쪽 상단의 커널 버튼을 누르고 가상환경의 이름을 선택한다

위와 같이 해도 문제 발생 시

추가로 tensorflow-gpu 2.10.0, CUDA 12, 11 를 모두 설치했음에도 GPU 가 정상적으로 로드 되지 않았던 경험이 있었습니다. 
해당 현상은 환경 변수에 "C:\\tools\\cuda\\bin"를 추가하여 해결한 정보를 공유드립니다.
> 출처: <https://www.tensorflow.org/install/gpu?hl=ko>

2.Pytorch 및 필요한 라이브러리 설치하기

Anaconda3 내 설정만으로 PyTorch GPU 환경을 설정하는 방법

conda 업데이트
- conda update -n base -c defaults conda
가상환경 생성 (torch-gpu로 생성, 필요하면 이름 변경)
- conda create -n torch-gpu python=3.10
- conda activate torch-gpu
CUDA 11.8 / CuDNN 8.9.7 설치
- conda install -c conda-forge cudatoolkit=11.8 cudnn=8.9.7 ( or conda-forge와 defaults 채널에서는 cudatoolkit=12.8이 제공되지 않음)
PyTorch 2.3.0 설치
- conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia
커널 생성
- pip install ipykernel
- python -m ipykernel install --user --name=torch-gpu
설치 확인

import torch

print(torch.__version__)
print(torch.cuda.is_available())
print(torch.cuda.current_device())
print(torch.cuda.get_device_name(0))

05-11_신경망모델-DNN 알아보기_분류_Tensorflow.ipynb

0.16MB

05-12_신경망모델-DNN-회귀-주택가격예측 - 완성코드.ipynb

0.10MB

05-13_신경망모델-DNN_분류(이미지)-손글씨숫자분류_Tensorflow-완성코드.ipynb

0.42MB