iru

Dobot Magician + 터틀봇 제어

haniru — Mon, 13 Apr 2026 12:43:07 +0900

처음에는 DobotLab을 사이트에서 받아서 사용했지만 여러가지 기능을 붙이려다보니 한계가 있었다

(프로그램 다운로드: https://www.dobot-robots.com/service/download-center)

그래서 DOBOT DLL을 사용해서 기능을 구현했다

사용한 DOBOT DLL 파일:

https://github.com/SERLatBTH/StarterGuide-Dobot-Magician-with-Python/tree/master

GitHub - SERLatBTH/StarterGuide-Dobot-Magician-with-Python: Dobot Magician with pure Python - Starter Guide

Dobot Magician with pure Python - Starter Guide . Contribute to SERLatBTH/StarterGuide-Dobot-Magician-with-Python development by creating an account on GitHub.

github.com

파이썬은 32bit 버전을 사용해야 함:

32 bit → Note that Python 3.10.11 cannot be used on Windows 7 or earlier.

https://www.python.org/ftp/python/3.10.11/python-3.10.11.exe

일단 도봇 매지션에 있는 석션으로 간단한 Pick And Place 부터 해봤다

https://youtu.be/cBSbV4C7d6U

그리고 터틀봇과의 소켓 통신으로 터틀봇이 일정 초간 다 움직이면 DOBOT에게 소켓으로 알림을 보내고 -> DOBOT이 다 움직이면 터틀봇에게 또 소켓으로 알림을 주는 동작이다

https://youtu.be/Ut5felQxtw8

DOBOT 이라는게 교육용으로 나와서 그런지 팔을 움직이면 좌표값을 따올 수 있어서 좋았다

import DobotDllType as dType
import time

# 1. 연결 설정
api = dType.load()
state = dType.ConnectDobot(api, "", 115200)[0]

if state == dType.DobotConnect.DobotConnect_NoError:
    saved_points = []
    print("  티칭 모드를 시작합니다.")
    print("[방법] 1. Unlock 버튼을 누르고 팔을 이동")
    print("       2. 기록하고 싶은 지점에서 'Enter' 키 입력")
    print("       3. 종료하려면 'q' 입력 후 Enter")
    print("-" * 50)

    try:
        while True:
            # 현재 위치 실시간 출력
            pose = dType.GetPose(api)
            x, y, z = pose[0], pose[1], pose[2]
            print(f"\r  현재 위치 -> X: {x:7.2f}, Y: {y:7.2f}, Z: {z:7.2f} | 저장된 지점: {len(saved_points)}개", end="")

            # 사용자 입력 확인 (Enter를 치면 기록, q를 치면 종료)
            # input()은 루프를 잠시 멈추기 때문에 정확한 지점 확보에 더 좋습니다.
            cmd = input("\n[명령] Enter(기록) / q(종료): ").lower()

            if cmd == '':
                # 현재 좌표 저장
                saved_points.append([round(x, 2), round(y, 2), round(z, 2)])
                print(f"✅ 지점 저장 완료: {saved_points[-1]}")
            elif cmd == 'q':
                break

    except KeyboardInterrupt:
        pass

    # 종료 후 결과 출력
    print("\n" + "=" * 50)
    print("  기록된 좌표 리스트 (복사해서 main.py에 붙여넣으세요)")
    print("=" * 50)
    for i, pt in enumerate(saved_points):
        print(f"지점 {i + 1}: {pt}")
    print("=" * 50)

    dType.DisconnectDobot(api)
else:
    print("❌ 도봇 연결 실패!")

사용한 코드:

DOBOT - https://github.com/iru-han/dobot_ws.git

GitHub - iru-han/dobot_ws

Contribute to iru-han/dobot_ws development by creating an account on GitHub.

github.com

터틀봇(Remote PC랑 라즈베리파이 둘다 사용 가능) -

import rclpy
from rclpy.node import Node
from geometry_msgs.msg import Twist
import socket
import time

# [설정] 노트북 정보
LAPTOP_IP = '192.168.0.33' 
PORT = 9999

class TurtlebotMissionNode(Node):
    def __init__(self):
        super().__init__('turtlebot_mission_node')
        # 네임스페이스 반영된 토픽 이름 (/r3/cmd_vel)
        self.publisher = self.create_publisher(Twist, '/cmd_vel', 10)
        time.sleep(1.0) # 퍼블리셔 안정화 대기
        self.run_mission()

    def move_turtlebot(self, speed, duration, label):
        """지정된 속도로 지정된 시간만큼 이동하는 함수"""
        print(f">> {label}: 속도 {speed}로 {duration}초간 이동 시작")
        msg = Twist()
        msg.linear.x = speed
        
        start_time = time.time()
        while rclpy.ok() and (time.time() - start_time < duration):
            self.publisher.publish(msg)
            time.sleep(0.1) # 10Hz 주기로 발행
            
        # 정지 명령
        self.publisher.publish(Twist())
        print(f">> {label}: 정지 완료.")

    def run_mission(self):
        # 1. 도봇 앞으로 이동 (몸통 2개 거리만큼 0.01 속도로)
        # 약 27.6초 동안 이동 (0.01m/s * 27.6s = 0.276m)
        self.move_turtlebot(speed=0.01, duration=27.6, label="도봇으로 접근 중")

        # 2. 소켓 통신 (신호 보내기)
        print(">> Arrived at Dobot. Sending signal to Laptop...")
        try:
            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            s.settimeout(60) # 도봇 작업 시간을 고려하여 타임아웃 넉넉히 설정
            s.connect((LAPTOP_IP, PORT))
            
            # 도착 신호 전송
            s.send("ARRIVED".encode())
            print(">> Waiting for Dobot to load object...")
            
            # 도봇으로부터 작업 완료(OK) 신호를 대기
            response = s.recv(1024).decode()
            
            if response == "OK":
                print(">> [SIGNAL RECEIVED] Dobot task finished!")
                
                # 3. 추가 이동 (몸통 반개 거리만큼 0.01 속도로)
                # 약 6.9초 동안 이동 (0.01m/s * 6.9s = 0.069m)
                self.move_turtlebot(speed=0.01, duration=6.9, label="추가 목적지로 이동 중")
                print(">> [MISSION COMPLETE] Arrived at final destination.")
            
            s.close()
        except Exception as e:
            print(f">> [ERROR] Connection or Task failed: {e}")

def main():
    rclpy.init()
    node = TurtlebotMissionNode()
    # 미션 완료 후 노드 종료
    node.destroy_node()
    rclpy.shutdown()

if __name__ == '__main__':
    main()

터틀봇 펌웨어를 수정해서 센서 데이터값 가져오기

haniru — Mon, 13 Apr 2026 09:47:22 +0900

라즈베리파이에 센서를 연결하면 파이썬 코드로 센서값을 가져올 수 있지만, openCR에 연결하면 펌웨어 코드 변경 후 turtlebot_node 코드도 수정해야한다

펌웨어 코드:

https://github.com/iru-han/turtlebot3_ros2.git

먼저 펌웨어코드를 수정해서 PC와 아두이노를 연결해 arduino ide로 올려야한다

turtlebot3_node 코드:

https://github.com/iru-han/turtlebot3.git

GitHub - iru-han/turtlebot3

Contribute to iru-han/turtlebot3 development by creating an account on GitHub.

github.com

Remote PC에 turtlebot3_ws/src 경로에 turtlebot3 를 git pull 받고 colcon build 해줘야한다

turtlebot3_msgs 코드:

https://github.com/iru-han/turtlebot3_msgs.git

GitHub - iru-han/turtlebot3_msgs

Contribute to iru-han/turtlebot3_msgs development by creating an account on GitHub.

github.com

마찬가지로 Remote PC에 turtlebot3_ws/src 경로에 turtlebot3_msgs 를 git pull 받고 colcon build 해줘야한다

(안그럼 센서 데이터값을 못 읽어온다)

센서 모니터링 코드:

위 과정을 거치면 sensor_state에서 센서값을 읽어올 수 있다

https://github.com/iru-han/sensor_monitor_ws.git

GitHub - iru-han/sensor_monitor_ws

Contribute to iru-han/sensor_monitor_ws development by creating an account on GitHub.

github.com

인천인력개발원 - 실무로 배우는 ROS 2 AI 로봇 과정 수강 후기

haniru — Thu, 9 Apr 2026 01:49:28 +0900

평소 로봇공학과 AI에 관심이 많았지만, 독학으로 접한 ROS 2의 진입장벽을 넘기는 쉽지 않았습니다. 이론을 넘어 실제 터틀봇 3 기기를 직접 분해·조립해보고, 센서 데이터를 직접 핸들링하며 자율주행 알고리즘을 구현해보고 싶어 이번 과정을 신청했습니다.

과정을 신청한 이유

평소 로봇공학과 AI에 관심은 많았지만, 독학으로는 ROS 2의 높은 진입장벽을 넘기가 쉽지 않았습니다. 이론뿐만 아니라 실제 터틀봇 3 기기를 직접 제어해보고, 자율주행 알고리즘을 다뤄보고 싶어 이번 과정을 신청하게 되었습니다.

수강 후 배우거나 달라진 점

가장 큰 변화는 로봇의 언어를 이해하게 되었다는 점입니다. Nav2 스택을 다루면서 로봇이 지도를 생성하고(SLAM), 실시간으로 장애물을 회피하며 최적의 경로를 계산하는 메커니즘을 깊이 있게 배웠습니다. 가상 환경뿐만 아니라 실제 하드웨어를 연결해 보며 실무 감각을 익히고 있습니다.

프로젝트·실습을 통해 얻은 성과

최근에는 터틀봇 3를 이용해 특정 좌표로 정밀하게 이동시키는 실습을 진행했습니다.

RViz2를 활용한 실시간 모니터링 및 위치 추정 최적화
YAML 설정 파일 커스터마이징을 통한 장애물 회피 반경(Inflation Radius) 조절
좌표 데이터를 직접 터미널로 전송하여 목적지에 정확히 도달시키는 정밀 주행 성공

단순히 로봇을 움직이는 것을 넘어, 환경에 맞춰 파라미터를 튜닝하고 최적의 주행 효율을 찾아내는 과정을 통해 로봇 소프트웨어 엔지니어로서의 자신감을 얻었습니다.

실습 현장 및 결과물

센서를 달고 주행 준비중인 터틀봇

온습도 센서(D11) openCR 에러

haniru — Thu, 9 Apr 2026 01:45:32 +0900

온습도 센서를 openCR에서 라즈베리로 보내주면 계속 에러가 났다

처음에는 온습도가 문제인지도 모르고 코드랑 주소만 바꿨다

IDLE을 쓰면 해결된다 했는데, There is no status packet! 에러가 늦게 뜰 뿐 여전히 에러가 남

비차단(Non-blocking) 방식의 핵심은 **"데이터가 올 때까지 CPU가 delay()하며 기다리지 않고, 다른 일을 하다가 데이터가 준비되면 낚아채는 것"**입니다.

사용자님의 환경(OpenCR + DHT11)에 맞춰서 DHT_NonBlocking 라이브러리를 사용하는 방식과 이를 상태 머신으로 관리하는 통합 코드를 짜드릴게요.

1. 사전 준비 (라이브러리 설치)

아두이노 IDE의 **라이브러리 관리자(Ctrl+Shift+I)**에서 DHT_NonBlocking (작성자: Ole Wolf)을 검색해서 설치하세요.

2. Turtlebot3Sensor.h (헤더 파일 수정)

기존 DHT 포인터를 새로운 라이브러리 클래스로 교체해야 합니다.

C++

// turtlebot3_sensor.h 내부
#include <dht_nonblocking.h> // 라이브러리 변경

class Turtlebot3Sensor {
private:
  DHT_NonBlocking *p_dht; // 클래스명 변경
  int dht_pin_;

public:
  void initDHT(void);
  bool readDHT(float &temp, float &humi); // 이제 한 번에 온습도를 읽는 방식으로 변경
};

3. Turtlebot3Sensor.cpp (함수 구현 수정)

readDHT 함수는 데이터가 준비되었을 때만 true를 반환하도록 설계합니다.

C++

// turtlebot3_sensor.cpp

void Turtlebot3Sensor::initDHT(void) {
  dht_pin_ = 4; 
  p_dht = new DHT_NonBlocking(dht_pin_, DHT_TYPE_11); // DHT11 지정
}

// 비차단 방식으로 온습도를 읽는 함수
bool Turtlebot3Sensor::readDHT(float &temp, float &humi) {
  // measure 함수는 내부적으로 타이머를 체크하여 
  // 데이터 읽기가 완료된 순간에만 true를 리턴합니다. (내부 delay 없음)
  if (p_dht->measure(&temp, &humi)) {
    return true; 
  }
  return false;
}

4. turtlebot3.cpp (상태 머신 적용)

가장 중요한 부분입니다. update_analog_sensors에서 "데이터가 준비됐을 때만" 제어표(Control Table)를 갱신합니다.

C++

void update_analog_sensors(uint32_t interval_ms)
{
  static uint32_t pre_time = 0;
  
  // [Part 1] 빠른 센서 (가스, 불꽃 등 - 30ms 주기)
  if(millis() - pre_time >= interval_ms){
    pre_time = millis();
    // (기존 가스, 불꽃 센서 로직 유지)
    control_items.flame_digital_status = (analogRead(A2) <= 300) ? 1 : 0;
    control_items.gas_digital_status = (digitalRead(12) == LOW) ? 1 : 0;
  }

  // [Part 2] 비차단 온습도 업데이트 (상태 머신)
  float temp, humi;
  // readDHT는 내부 타이머에 따라 약 2~4초마다 한 번씩만 true를 반환합니다.
  // 그 외의 시간에는 0.001초도 멈추지 않고 바로 false를 뱉고 지나갑니다.
  if (sensors.readDHT(temp, humi)) {
    // 데이터가 준비된 찰나에만 값을 업데이트합니다.
    control_items.dht_temp = (int32_t)(temp * 100.0f);
    control_items.dht_humi = (int32_t)(humi * 100.0f);

    // 디버깅용 로그 (필요할 때만 확인)
    // DEBUG_PRINT("[DHT Success] T: "); DEBUG_PRINT(temp);
    // DEBUG_PRINT(" H: "); DEBUG_PRINTLN(humi);
  }
  
  // 이 함수가 종료되면 즉시 dxl_slave.processPacket()이 실행될 수 있으므로
  // 다이나믹셀 통신이 끊기지 않습니다.
}

이 코드의 작동 원리 (왜 안 멈추나?)

기존 방식: readTemperature() 호출 → 데이터 올 때까지 CPU가 멍하니 기다림(Blocking) → 라즈베리파이가 부르는데 대답 못 함 → 에러 발생
비차단 방식: readDHT() 호출 → "아직 시간 안 됐네?" 또는 "읽는 중이야" 하고 바로 리턴 → 메인 루프 돌면서 dxl_slave.processPacket() 실행 → 라즈베리파이와 사이좋게 대화 → 통신 유지

이렇게 수정하면 온습도 센서 때문에 전체 시스템이 기절하는 현상을 완벽하게 막을 수 있습니다.

지금 바로 DHT_NonBlocking 라이브러리를 설치하고 코드를 적용해 보시겠어요? 설치 중에 막히는 부분이 있으면 바로 말씀해 주세요!

3d 프린터 - 공차 안맞음

haniru — Sun, 5 Apr 2026 20:53:19 +0900

거진 한달에 걸쳐 뽑은 출력물들이 서보 혼 공차가 안맞아서 다시 뽑아야한다고 함

(이방법은 나사 부분까지 커질 수 있어 아래 수정) Horizontal Expansion - -0.2mm로 해보고 출력하려고 한다

서포트도 너무 떼기 힘들어서 설정 변경

벽 라인도 6으로 변경

그리고 빨리 뽑아야 하므로 layer height 도 0.1 에서 0.2로 변경

상자 만들기: 왼쪽 메뉴 아래 **'Support Blocker'**를 누르고 모델의 서보혼 구멍을 클릭합니다. 작은 상자가 생깁니다.
위치 잡기: 상자를 클릭하고 **'Move'**와 'Scale' 도구로 서보혼 구멍 영역만 쏙 덮게 만드세요. (나사 구멍은 피해서!)
개별 설정: 왼쪽 메뉴 세 번째 'Per Model Settings' 아이콘 클릭 -> 'Modify settings for overlaps' 선택.
명령어 추가: 'Select Settings' 누르고 Horizontal Expansion 검색해서 체크.
값 입력: 새로 생긴 칸에 -0.2 입력.
확인: 슬라이싱 후 'Preview' 탭에서 그 상자가 있는 부분만 구멍이 넓어졌는지 확인하세요.

-> 결론: 이방법 해봐도 차이가 없어서 그냥 전체적으로 Horizontal Expansion 설정해줌

아두이노 - 도트 매트릭스

haniru — Sun, 29 Mar 2026 21:57:29 +0900

하트 그리기

#include "NDelayFunc.h"

// R1~R4가 빠져있어서 추가했습니다.
enum { R5=1, R7, C2, C3, R8, C5, R6, R3, R1, C4, C6, R4, C1, R2, C7, C8 };

const unsigned int pins[1+16] = {
  -1, 10, 11, 12, 13, 14, 15, 16, 17, 2, 3, 4, 5, 6, 7, 8, 9
};

const unsigned int R[1+8] = { -1, R1, R2, R3, R4, R5, R6, R7, R8 };
const unsigned int C[1+8] = { -1, C1, C2, C3, C4, C5, C6, C7, C8 }; // C5 중복 및 오타 수정

const unsigned int heart[1+8][1+8] = {
  {-1, -1, -1, -1, -1, -1, -1, -1},
  {-1, 0, 0, 0, 0, 0, 0, 0, 0},
  {-1, 0, 1, 1, 0, 0, 1, 1, 0},
  {-1, 1, 1, 1, 1, 1, 1, 1, 1},
  {-1, 1, 1, 1, 1, 1, 1, 1, 1},
  {-1, 0, 1, 1, 1, 1, 1, 1, 0},
  {-1, 0, 0, 1, 1, 1, 1, 0, 0},
  {-1, 0, 0, 0, 1, 1, 0, 0, 0},
  {-1, 0, 0, 0, 0, 0, 0, 0, 0}
}; // 세미콜론 추가

void dot_matrix_init() {
  for (int n=1; n<=8; n++) {
    pinMode(pins[R[n]], OUTPUT);
    pinMode(pins[C[n]], OUTPUT);
  }
  for (int n=1; n<=8; n++) {
    digitalWrite(pins[R[n]], HIGH);
    digitalWrite(pins[C[n]], HIGH);
  }
}

void dot_matrix_draw(const unsigned int image[1+8][1+8]) {
  static int n = 1;
  
  // 이전 라인 끄기
  digitalWrite(pins[R[n]], HIGH); 

  n++;
  if (n > 8) n = 1;

  // 열 제어 (Common Cathode/Anode에 따라 HIGH/LOW가 달라질 수 있음)
  for (int m=1; m<=8; m++) {
    if (image[n][m] == 1) {
      digitalWrite(pins[C[m]], LOW); // 선택된 열을 LOW로 (일반적 matrix 기준)
    } else {
      digitalWrite(pins[C[m]], HIGH);
    }
  }

  // 현재 행 켜기
  digitalWrite(pins[R[n]], HIGH); 
  // ※ 실제 매트릭스 구동 방식에 따라 HIGH/LOW 논리는 하드웨어에 맞춰 조정해야 합니다.
}

void draw() {
  dot_matrix_draw(heart);
}

NDelayFunc nDelayDraw(1, draw); // 언더바(_)를 공백으로 수정

void setup() {
  dot_matrix_init();
}

void loop() {
  nDelayDraw.run();
}

함수 만들기

DotMatrix.h

#ifndef NDelayFunc_h_
#define NDelayFunc_h_

enum { R5=1, R7, C2, C3, R8, C5, R6, R3, R1, C4, C6, R4, C1, R2, C7, C8 };

class _DotMatrix {
    static const unsigned int pins[1+16];
    static const unsigned int R[1+8];
    static const unsigned int C[1+8];

    public:
        static void init();
        static void draw(const unsigned int image[1+8][1+8]);
};

extern _DotMatrix DotMatrix;

#endif

DotMatrix.cpp

#include "Arduino.h"
#include "DotMatrix.h"

const unsigned int _DotMatrix::pins[1+16] = {
    -1, 10, 11, 12, 13, 14, 15, 16, 17, 2, 3, 4, 5, 6, 7, 8, 9
};

const unsigned int _DotMatrix::R[1+8] = { -1, R1, R2, R3, R4, R5, R6, R7, R8 };
const unsigned int _DotMatrix::C[1+8] = { -1, C1, C2, C3, C4, C5, C6, C7, C8 };

void _DotMatrix::init() {
    for (int n=1; n<=8; n++) {
        pinMode(pins[R[n]], OUTPUT);
        pinMode(pins[C[n]], OUTPUT);
    }

    for (int n=1; n<=8; n++) {
        digitalWrite(pins[R[n]], HIGH);
        digitalWrite(pins[C[n]], HIGH);
    }
}

void _DotMatrix::draw(const unsigned int image[1+8][1+8]) {
    static int n = 1;
    n++;
    if (n>8) n = 1;

    if (n>1) digitalWrite(pins[R[n-1]], HIGH);
    if (n==1) digitalWrite(pins[R[8]], HIGH);

    for (int m=1; m<=8; m++) {
        if (image[n][m] == 1) {
            digitalWrite(pins[C[m]], HIGH);
        } else {
            digitalWrite(pins[C[m]], LOW);
        }
    }

    for (int m=1; m<=8; m++) {
        if (image[n][m] == 1) {
            digitalWrite(pins[R[n]], LOW);
            break;
        }
    }
}

_DotMatrix DotMatrix;

함수 활용해 하트 그리기

#include "NDelayFunc.h"
#include "DotMatrix.h"

const unsigned int heart[1+8][1+8] = {
  {-1, -1, -1, -1, -1, -1, -1, -1},
  {-1, 0, 0, 0, 0, 0, 0, 0, 0},
  {-1, 0, 1, 1, 0, 0, 1, 1, 0},
  {-1, 1, 1, 1, 1, 1, 1, 1, 1},
  {-1, 1, 1, 1, 1, 1, 1, 1, 1},
  {-1, 0, 1, 1, 1, 1, 1, 1, 0},
  {-1, 0, 0, 1, 1, 1, 1, 0, 0},
  {-1, 0, 0, 0, 1, 1, 0, 0, 0},
  {-1, 0, 0, 0, 0, 0, 0, 0, 0}
}; // 세미콜론 추가

void draw() {
  DotMatrix.draw(heart);
}

NDelayFunc nDelayDraw(1, draw);

void setup() {
  DotMatrix.init();
}

void loop() {
  nDelayDraw.run();
}

큰 하트와 작은 하트 교대로 그리기

#include "NDelayFunc.h"
#include "DotMatrix.h"

const unsigned int heart[1+8][1+8] = {
  {-1, -1, -1, -1, -1, -1, -1, -1},
  {-1, 0, 0, 0, 0, 0, 0, 0, 0},
  {-1, 0, 1, 1, 0, 0, 1, 1, 0},
  {-1, 1, 1, 1, 1, 1, 1, 1, 1},
  {-1, 1, 1, 1, 1, 1, 1, 1, 1},
  {-1, 0, 1, 1, 1, 1, 1, 1, 0},
  {-1, 0, 0, 1, 1, 1, 1, 0, 0},
  {-1, 0, 0, 0, 1, 1, 0, 0, 0},
  {-1, 0, 0, 0, 0, 0, 0, 0, 0}
}; // 세미콜론 추가

const unsigned int small_heart[1+8][1+8] = {
  {-1, -1, -1, -1, -1, -1, -1, -1},
  {-1, 0, 0, 0, 0, 0, 0, 0, 0},
  {-1, 0, 0, 0, 0, 0, 0, 0, 0},
  {-1, 0, 0, 1, 0, 0, 1, 0, 0},
  {-1, 0, 1, 1, 1, 1, 1, 0, 0},
  {-1, 0, 0, 1, 1, 1, 1, 0, 0},
  {-1, 0, 0, 0, 1, 1, 0, 0, 0},
  {-1, 0, 0, 0, 0, 0, 0, 0, 0},
  {-1, 0, 0, 0, 0, 0, 0, 0, 0}
}; // 세미콜론 추가

int heart_state = 0;
void choose() {
  heart_state++;
  if (heart_state > 1) heart_state = 0;
}

NDelayFunc nDelayChoose(500, choose);
void draw() {
  if (heart_state == 0) DotMatrix.draw(heart);
  else if (heart_state == 1) DotMatrix.draw(heart_small);
}

NDelayFunc nDelayDraw(1, draw);

void setup() {
  DotMatrix.init();
}

void loop() {
  nDelayChoose.run();
  nDelayDraw.run();
}

벽돌깨기

#include "NDelayFunc.h"
#include "DotMatrix.h"

unsigned int game_display[1+8][1+8] = {
  {-1, -1, -1, -1, -1, -1, -1, -1},
  {-1, 1, 1, 1, 1, 1, 1, 1, 1},
  {-1, 1, 1, 1, 1, 1, 1, 1, 1},
  {-1, 1, 1, 1, 1, 1, 1, 1, 1},
  {-1, 0, 0, 0, 0, 0, 0, 0, 0},
  {-1, 0, 0, 0, 0, 0, 0, 0, 0},
  {-1, 0, 0, 0, 0, 0, 0, 0, 0},
  {-1, 0, 0, 0, 0, 0, 0, 0, 0},
  {-1, 0, 0, 1, 1, 1, 0, 0, 0},
};

unsigned int game_lose[1+8][1+8] = {
  {-1, -1, -1, -1, -1, -1, -1, -1},
  {-1, 0, 0, 0, 0, 0, 0, 0, 0},
  {-1, 0, 0, 0, 0, 0, 0, 0, 0},
  {-1, 0, 1, 1, 0, 0, 1, 1, 0},
  {-1, 0, 0, 0, 0, 0, 0, 0, 0},
  {-1, 0, 0, 0, 0, 0, 0, 0, 0},
  {-1, 0, 0, 1, 1, 1, 1, 0, 0},
  {-1, 0, 1, 0, 0, 0, 0, 1, 0},
  {-1, 0, 0, 0, 0, 0, 0, 0, 0},
};


unsigned int game_win[1+8][1+8] = {
  {-1, -1, -1, -1, -1, -1, -1, -1},
  {-1, 0, 0, 0, 0, 0, 0, 0, 0},
  {-1, 0, 0, 1, 0, 0, 1, 0, 0},
  {-1, 0, 0, 1, 0, 0, 1, 0, 0},
  {-1, 0, 0, 0, 0, 0, 0, 0, 0},
  {-1, 0, 1, 0, 0, 0, 0, 1, 0},
  {-1, 0, 0, 1, 1, 1, 1, 0, 0},
  {-1, 0, 0, 0, 0, 0, 0, 0, 0},
  {-1, 0, 0, 0, 0, 0, 0, 0, 0},
};

enum {PLAY=0, LOSE, WIN};
int game_state = PLAY;

int ball_x = 4;
int ball_x_dir = 1;
int ball_y = 7;
int ball_y_dir = 1;

int how_many_bricks = 24;

void ball_move() {

  if (game_state != PLAY) return;

  game_display[ball_y][ball_x] = 0;
  ball_x += ball_x_dir;
  if (ball_x >= 8) {
    ball_x = 8;
    ball_x_dir = ball_x_dir;
  }

  if (ball_x <= 1) {
    ball_x = 1;
    ball_x_dir = -ball_x_dir;
  }

  ball_y += ball_y_dir;
  if(ball_y>=8) {
    if (game_display[ball_y][ball_x] == 1) {
      ball_y-=2*ball_y_dir;
      ball_y_dir=-ball_y_dir;
    } else {
      game_state = LOSE;
      return;
    }
  }

  if (ball_y <= 1) {
    ball_y = 1;
    ball_y_dir = -ball_y_dir;
  }

  if (game_display[ball_y+ball_y_dir][ball_x]==1) {
    if (ball_y != 7) {
      game_display[ball_y+ball_y_dir][ball_x] = 0;
      how_many_bricks--;
      if (how_many_bricks == 0) game_state = WIN;
    }
    ball_y_dir = -ball_y_dir;
  } else if (game_display[ball_y+ball_y_dir][ball_x+ball_x_dir] == 1) {
    if (ball_y != 7) {
      game_display[ball_y+ball_y_dir][ball_x+ball_x_dir] = 0;
      how_many_bricks--;
      if(how_many_bricks == 0) game_state = WIN;
    }
    ball_y_dir=-ball_y_dir;
    ball_x_dir=-ball_x_dir;
  }

  game_display[ball_y][ball_x] = 1;
}

NDelayFunc nDelayGame(500, ball_move);

void draw() {
  if(game_state == PLAY) DotMatrix.draw(game_display);
  if(game_state == LOSE) DotMatrix.draw(game_lose);
  if(game_state == WIN) DotMatrix.draw(game_win);
}

NDelayFunc nDelayDraw(1, draw);

int bar_x = 4;
const int bar_y = 8;

void bar_move() {
  if (game_state != PLAY) return;

  int analogValue = analogRead(A5);

  static int prevAnalogValue = 0;

  int new_bar_x = bar_x;

  if (analogValue > prevAnalogValue + 1024/8) {
    prevAnalogValue = analogValue;
    new_bar_x++;
    if (new_bar_x >= 7) new_bar_x = 7;
    Serial.println(new_bar_x);
  } else if (analogValue < prevAnalogValue-1024/8) {
    prevAnalogValue = analogValue;
    new_bar_x--;
    if(new_bar_x<=2) new_bar_x = 2;
    Serial.println(new_bar_x);
  }

  if (new_bar_x != bar_x) {
    game_display[bar_y][bar_x] = 0;
    game_display[bar_y][bar_x-1] = 0;
    game_display[bar_y][bar_x+1] = 0;

    bar_x = new_bar_x;

    game_display[bar_y][bar_x] = 1;
    game_display[bar_y][bar_x-1] = 1;
    game_display[bar_y][bar_x+1] = 1;
  }
}

void setup() {
  DotMatrix.init();
  Serial.begin(115200);
}

void loop() {
  bar_move();
  nDelayGame.run();
  nDelayDraw.run();
}

아두이노 millis

haniru — Sun, 29 Mar 2026 20:02:54 +0900

millis 함수로 현재 시간 확인하기

void setup() {
  Serial.begin(115200);
}

void loop() {
  unsigned long t_now = millis();
  Serial.println(t_now);
}

millis 함수로 delay 대체하기

unsigned long t_prev = 0;
const unsigned long t_delay = 1000;

void setup() {
  Serial.begin(115200);
}

void loop() {
  unsigned long t_now = millis();
  if (t_now - t_prev >= t_delay) {
    t_prev = t_now;

    Serial.println(t_now);
  }
}

1초에 한번 t1, 0.5초에 한번 t2 문자열 출력

unsigned long t1_prev = 0;
const unsigned long t1_delay = 1000;

unsigned long t2_prev = 0;
const unsigned long t2_delay = 500;

void setup() {
  Serial.begin(115200);
}

void loop() {
  unsigned long t1_now = millis();
  if (t1_now - t1_prev >= t1_delay) {
    t1_prev = t1_now;

    Serial.println("t1");
  }

  unsigned long t2_now = millis();
  if (t2_now - t2_prev >= t2_delay) {
    t2_prev = t2_now;
    Serial.println("\tt2");
  }
}

LED 점멸 반복해보기 - 0.5초 간격

const int LED = 13;

void setup() {
  pinMode(LED, OUTPUT);
}

void loop() {
  for (int on_off=0; on_off<=1; on_off++) {
    digitalWrite(LED, on_off);
    delay(500);
  }
}

const int LED = 13;
int on_off = 0;

unsigned long t_prev = 0;
const unsigned long t_delay = 500;

void setup() {
  pinMode(LED, OUTPUT);
}

void loop() {
  unsigned long t_now = millis();
  
  if (t_now - t_prev >= t_delay) {
    t_prev = t_now;
    on_off++;
    if (on_off>1) on_off=0;
    digitalWrite(LED, on_off);
  }
}

KakaoTalk_20260329_133054233.mp4

0.54MB

millis 함수로 LED 밝기 조절해보기 - 1초간 256단계로 LED 의 밝기가 증가

const int LED = 10;
int t_high = 0;

unsigned long t_prev = 0;
const unsigned long t_delay = 4;

void setup() {

}

void loop() {
  unsigned long t_now = millis();
  if (t_now - t_prev >= t_delay) {
    t_prev = t_now;
    t_high++;

    if (t_high > 255) t_high = 0;
    analogWrite(LED, t_high);
  }
}

class NDelayFunc {
  unsigned long t_prev;
  const unsigned long t_delay;
  void (* func)();

public:
  NDelayFunc(
    const unsigned long t_delay,
    void (* func)())
    : t_prev(0), t_delay(t_delay), func(func) {}

  void run() {
    unsigned long t_now = millis();
    if (t_now - t_prev >= t_delay) {
      t_prev = t_now;

      func();
    }
  }
};

const int LED = 10;
unsigned int t_high = 0;

void fading() {
  t_high++;
  if(t_high > 255) t_high = 0;
  analogWrite(LED, t_high);
}

NDelayFunc nDelayFading(4, fading);

void setup() {

}

void loop() {
  nDelayFading.run();
}

KakaoTalk_20260329_134209664.mp4

0.47MB

mills 함수로 다중작업 하기

13번은 0.5초 주기로, 10번은 1초 주기로 깜빡깜빡 한다

const int t1_LED = 13;
unsigned int on_off = 0;

const int t2_LED = 10;
unsigned int t_high = 0;

unsigned long t1_prev = 0;
const unsigned long t1_delay = 500;

unsigned long t2_prev = 0;
const unsigned long t2_delay = 4;

void setup() {
  pinMode(t1_LED, OUTPUT);
}

void loop() {
  unsigned long t1_now = millis();
  if (t1_now - t1_prev >= t1_delay) {
    t1_prev = t1_now;
    on_off++;
    if (on_off > 1) on_off = 0;
    digitalWrite(t1_LED, on_off);
  }

  unsigned long t2_now = millis();
  if (t2_now - t2_prev >= t2_delay) {
    t2_prev = t2_now;

    t_high++;

    if (t_high > 255) t_high = 0;
    analogWrite(t2_LED, t_high);
  }
}

KakaoTalk_20260329_155030074.mp4

0.85MB

NDelayFunc 사용자 정의 라이브러리 만들기

(C:\Users\유저명\OneDrive\문서\Arduino\libraries)

NDelayFunc.cpp

#include "Arduino.h"
#include "NDelayFunc.h"

NDelayFunc::NDelayFunc(
    const unsigned long t_delay,
    void (* func)())
    : t_prev(0), t_delay(t_delay), func(func) {}

void NDelayFunc::run() {
    unsigned long t_now = millis();
    if (t_now - t_prev >= t_delay) {
        t_prev = t_now;

        func();
    }
}

NDelayFunc.h

#ifndef NDelayFunc_h_
#define NDelayFunc_h_

class NDelayFunc {
    unsigned long t_prev;
    const unsigned long t_delay;
    void (* func)();

    public:
    NDelayFunc(
        const unsigned long t_delay,
        void (* func)());

    void run();
};

#endif

NDelayFunc 사용자 정의 라이브러리 사용하기1

#include "NDelayFunc.h"

const int LED = 10;
unsigned int t_high = 0;

void fading() {
  t_high++;
  if(t_high>255) t_high=0;
  analogWrite(LED, t_high);
}

NDelayFunc nDelayFading(4, fading);

void setup() {

}

void loop() {
  nDelayFading.run();
}

다운로드

NDelayFunc 사용자 정의 라이브러리 사용하기2

#include "NDelayFunc.h"

const int t1_LED = 13;
unsigned int on_off = 0;

const int t2_LED = 10;
unsigned int t_high = 0;

unsigned long t1_prev = 0;
const unsigned long t1_delay = 500;

unsigned long t2_prev = 0;
const unsigned long t2_delay = 4;

void setup() {
  pinMode(t1_LED, OUTPUT);
}

void loop() {
  unsigned long t1_now = millis();
  if (t1_now - t1_prev >= t1_delay) {
    t1_prev = t1_now;

    on_off++;
    if (on_off>1) on_off = 0;
    digitalWrite(t1_LED, on_off);
  }

  unsigned long t2_now = millis();

  if (t2_now - t2_prev >= t2_delay) {
    t2_prev = t2_now;

    t_high++;
    if (t_high>255) t_high = 0;
    analogWrite(t2_LED, t_high);
  }
}

다운로드

13번 핀에 연결된 LED를 0.5초 간격으로, 10번 핀에 연결된 LED를 1초 간격으로 껐다 켜기

#include "NDelayFunc.h"

const int blink_LED = 13;
unsigned int on_off = 0;

const int fading_LED = 10;
unsigned int t_high = 0;

void blink() {
  on_off++;
  if (on_off > 1) on_off = 0;
  digitalWrite(blink_LED, on_off);
}

void fading() {
  t_high++;
  if (t_high>255) t_high = 0;
  analogWrite(fading_LED, t_high);
}

NDelayFunc nDelayBlink(500, blink);
NDelayFunc nDelayFading(4, fading);

void setup() {
  pinMode(blink_LED, OUTPUT);
}

void loop() {
  nDelayBlink.run();
  nDelayFading.run();
}

아두이노 - 7세그먼트

haniru — Thu, 26 Mar 2026 23:51:56 +0900

세그먼트 활용하기

const unsigned int led_a = 2;
const unsigned int led_b = 3;
const unsigned int led_c = 4;
const unsigned int led_d = 5;
const unsigned int led_e = 6;
const unsigned int led_f = 7;
const unsigned int led_g = 8;

void setup() {
  pinMode(led_a, OUTPUT);
  pinMode(led_b, OUTPUT);
  pinMode(led_c, OUTPUT);
  pinMode(led_d, OUTPUT);
  pinMode(led_e, OUTPUT);
  pinMode(led_f, OUTPUT);
  pinMode(led_g, OUTPUT);

  digitalWrite(led_a, HIGH);
  digitalWrite(led_b, HIGH);
  digitalWrite(led_c, HIGH);
  digitalWrite(led_d, HIGH);
  digitalWrite(led_e, HIGH);
  digitalWrite(led_f, HIGH);
  digitalWrite(led_g, HIGH);
}

void loop() {

}

const unsigned int led[7] = { 2, 3, 4, 5, 6, 7, 8 };

void setup() {
  for (int x=0; x<7; x++) {
    pinMode(led[x], OUTPUT);
  }

  for (int x=0; x<7; x++) {
    digitalWrite(led[x], HIGH);
  }
}

void loop() {

}

LED 켜고 끄기 반복

const unsigned int led[7] = { 2, 3, 4, 5, 6, 7, 8 };

void setup() {
  for (int x=0; x<7; x++) {
    pinMode(led[x], OUTPUT);
  }
}

void loop() {
  for (int x=0; x<7; x++) {
    digitalWrite(led[x], HIGH);
  }
  delay(500);

  for (int x=0; x<7; x++) {
    digitalWrite(led[x], LOW);
  }
  delay(500);

}

KakaoTalk_20260326_221911418.mp4

0.50MB

LED 차례대로 켜고 꺼보기 -> 주파수: 0.286Hz, 0.5초 간격으로 켜지고 꺼짐

delay를 50으로 설정하면 초당 2.86회 / 2.86Hz, delay를 5로하면 초당 28.6회 28.6Hz, delay를 1로하면 초당 143회

const unsigned int led[7] = { 2, 3, 4, 5, 6, 7, 8 };

void setup() {
  for (int x=0; x<7; x++) {
    pinMode(led[x], OUTPUT);
  }
}

void loop() {
  for (int x=0; x<7; x++) {
    for (int x=0; x<7; x++) {
      digitalWrite(led[x], LOW);
    }
    digitalWrite(led[x], HIGH);
    delay(500);
  }
}

KakaoTalk_20260326_222145607.mp4

2.71MB

함수로 만들기

const unsigned int led[7] = { 2, 3, 4, 5, 6, 7, 8 };

void display_init() {
  for (int x=0; x<7; x++) {
    pinMode(led[x], OUTPUT);
  }
}

void display_clear() {
  for (int x=0; x<7; x++) {
    digitalWrite(led[x], LOW);
  }
}

void setup() {
  display_init();
}

void loop() {
  for (int x=0; x<7; x++) {
    display_clear();
    digitalWrite(led[x], HIGH);
    delay(1);
  }
}

const unsigned int led[7] = { 2, 3, 4, 5, 6, 7, 8 };
const unsigned int num_0[7] = { 1, 1, 1, 1, 1, 1, 0 };

void display_init() {
  for (int x=0; x<7; x++) {
    pinMode(led[x], OUTPUT);
  }
}

void display_clear() {
  for (int x=0; x<7; x++) {
    digitalWrite(led[x], LOW);
  }
}

void display_0() {
  for(int x=0; x<7; x++) {
    digitalWrite(led[x], num_0[x]==1?HIGH:LOW);
  }
}

void setup() {
  display_init();
  display_clear();
  display_0();
}

void loop() {
}

0, 1숫자 표시하기

const unsigned int led[7] = { 2, 3, 4, 5, 6, 7, 8 };
const unsigned int num_0[7] = { 1, 1, 1, 1, 1, 1, 0 };
const unsigned int num_1[7] = { 0, 1, 1, 0, 0, 0, 0 };

void display_init() {
  for (int x=0; x<7; x++) {
    pinMode(led[x], OUTPUT);
  }
}

void display_clear() {
  for (int x=0; x<7; x++) {
    digitalWrite(led[x], LOW);
  }
}

void display_0() {
  for(int x=0; x<7; x++) {
    digitalWrite(led[x], num_0[x]==1?HIGH:LOW);
  }
}

void display_1() {
  for(int x=0; x<7; x++) {
    digitalWrite(led[x], num_1[x]==1?HIGH:LOW);
  }
}

void setup() {
  display_init();
}

void loop() {
  display_clear();
  display_0();
  delay(500);

  display_clear();
  display_1();
  delay(500);
}

const unsigned int led[7] = { 2, 3, 4, 5, 6, 7, 8 };
const unsigned int num[2][7] = {
  { 1, 1, 1, 1, 1, 1, 0 },
  { 0, 1, 1, 0, 0, 0, 0 }
};

void display_init() {
  for (int x=0; x<7; x++) {
    pinMode(led[x], OUTPUT);
  }
}

void display_clear() {
  for (int x=0; x<7; x++) {
    digitalWrite(led[x], LOW);
  }
}

void display_0() {
  for(int x=0; x<7; x++) {
    digitalWrite(led[x], num[0][x]==1?HIGH:LOW);
  }
}

void display_1() {
  for(int x=0; x<7; x++) {
    digitalWrite(led[x], num[1][x]==1?HIGH:LOW);
  }
}

void setup() {
  display_init();
}

void loop() {
  display_clear();
  display_0();
  delay(500);

  display_clear();
  display_1();
  delay(500);
}

const unsigned int led[7] = { 2, 3, 4, 5, 6, 7, 8 };
const unsigned int num[2][7] = {
  { 1, 1, 1, 1, 1, 1, 0 },
  { 0, 1, 1, 0, 0, 0, 0 }
};

void display_init() {
  for (int x=0; x<7; x++) {
    pinMode(led[x], OUTPUT);
  }
}

void display_clear() {
  for (int x=0; x<7; x++) {
    digitalWrite(led[x], LOW);
  }
}

void display_number(int n) {
  if (0<=n&&n<=1) {
    for(int x=0; x<7; x++) {
      digitalWrite(led[x], num[n][x]==1?HIGH:LOW);
    }
  }
}

void setup() {
  display_init();
}

void loop() {
  display_clear();
  display_number(0);
  delay(500);

  display_clear();
  display_number(1);
  delay(500);
}

const unsigned int led[7] = { 2, 3, 4, 5, 6, 7, 8 };
const unsigned int num[2][7] = {
  { 1, 1, 1, 1, 1, 1, 0 },
  { 0, 1, 1, 0, 0, 0, 0 }
};

void display_init() {
  for (int x=0; x<7; x++) {
    pinMode(led[x], OUTPUT);
  }
}

void display_clear() {
  for (int x=0; x<7; x++) {
    digitalWrite(led[x], LOW);
  }
}

void display_number(int n) {
  if (0<=n&&n<=1) {
    for(int x=0; x<7; x++) {
      digitalWrite(led[x], num[n][x]==1?HIGH:LOW);
    }
  }
}

void setup() {
  display_init();
}

void loop() {
  for (int n=0; n<=1; n++) {
    display_clear();
    display_number(n);
    delay(500);
  }
}

KakaoTalk_20260326_231304612.mp4

0.25MB

숫자표시 함수 일반화 하기

const unsigned int led[7] = { 2, 3, 4, 5, 6, 7, 8 };
const unsigned int num[10][7] = {
  { 1, 1, 1, 1, 1, 1, 0 },
  { 0, 1, 1, 0, 0, 0, 0 },
  { 1, 1, 0, 1, 1, 0, 1 },
  { 1, 1, 1, 1, 0, 0, 1 },
  { 0, 1, 1, 0, 0, 1, 1 },
  { 1, 0, 1, 1, 0, 1, 1 },
  { 1, 0, 1, 1, 1, 1, 1 },
  { 1, 1, 1, 0, 0, 1, 0 },
  { 1, 1, 1, 1, 1, 1, 1 },
  { 1, 1, 1, 1, 0, 1, 1 },
};

void display_init() {
  for (int x=0; x<7; x++) {
    pinMode(led[x], OUTPUT);
  }
}

void display_clear() {
  for (int x=0; x<7; x++) {
    digitalWrite(led[x], LOW);
  }
}

void display_number(int n) {
  if (0<=n&&n<=9) {
    for(int x=0; x<7; x++) {
      digitalWrite(led[x], num[n][x]==1?HIGH:LOW);
    }
  }
}

void setup() {
  display_init();
}

void loop() {
  for (int n=0; n<=9; n++) {
    display_clear();
    display_number(n);
    delay(500);
  }
}

KakaoTalk_20260326_232353008.mp4

1.85MB

시리얼 입력으로 숫자 표시하기

const unsigned int led[7] = { 2, 3, 4, 5, 6, 7, 8 };
const unsigned int num[10][7] = {
  { 1, 1, 1, 1, 1, 1, 0 },
  { 0, 1, 1, 0, 0, 0, 0 },
  { 1, 1, 0, 1, 1, 0, 1 },
  { 1, 1, 1, 1, 0, 0, 1 },
  { 0, 1, 1, 0, 0, 1, 1 },
  { 1, 0, 1, 1, 0, 1, 1 },
  { 1, 0, 1, 1, 1, 1, 1 },
  { 1, 1, 1, 0, 0, 1, 0 },
  { 1, 1, 1, 1, 1, 1, 1 },
  { 1, 1, 1, 1, 0, 1, 1 },
};

void display_init() {
  for (int x=0; x<7; x++) {
    pinMode(led[x], OUTPUT);
  }
}

void display_clear() {
  for (int x=0; x<7; x++) {
    digitalWrite(led[x], LOW);
  }
}

void display_number(int n) {
  if (0<=n&&n<=9) {
    for(int x=0; x<7; x++) {
      digitalWrite(led[x], num[n][x]==1?HIGH:LOW);
    }
  }
}

void setup() {
  Serial.begin(115200);
  display_init();
}

void loop() {
  if (Serial.available()) {
    char userInput = Serial.read();
    if ('0' <= userInput && userInput <= '9') {
      int num = userInput - '0';
      display_clear();
      display_number(num);
    }
  }
}

아두이노 - 서보모터, 초음파

haniru — Mon, 23 Mar 2026 22:47:41 +0900

서보모터 각도 조절해보기

#include <TimerOne.h>

const int SERVO = 10;
const int SERVO_PERIOD = 20000; // 20ms (50Hz)

// 10비트(1024) 기준으로 0.7ms~2.3ms 계산 (실수 연산 사용)
const int SERVO_MINDUTY = (1024.0 / 20.0) * 0.7; 
const int SERVO_MAXDUTY = (1024.0 / 20.0) * 2.3;

void setup() {
  Timer1.initialize(SERVO_PERIOD); // 초기화 시 주기를 설정하는 것이 좋습니다.
  Timer1.pwm(SERVO, SERVO_MINDUTY);
  
  delay(1000);
}

void loop() {
  // loop 안에 넣어야 계속해서 반복 동작합니다.
  Timer1.setPwmDuty(SERVO, SERVO_MINDUTY);
  delay(1000);
  
  Timer1.setPwmDuty(SERVO, SERVO_MAXDUTY);
  delay(1000);
}

KakaoTalk_20260323_210233184.mp4

1.24MB

서보모터 0~180도 조절해보기

#include <TimerOne.h>

const int SERVO = 10;
const int SERVO_PERIOD = 20000; // 20ms (50Hz)

// 10비트(1024) 기준으로 0.7ms~2.3ms 계산 (실수 연산 사용)
const int SERVO_MINDUTY = (1024.0 / 20.0) * 0.7; 
const int SERVO_MAXDUTY = (1024.0 / 20.0) * 2.3;

void setup() {
  Timer1.initialize(SERVO_PERIOD); // 초기화 시 주기를 설정하는 것이 좋습니다.
  Timer1.pwm(SERVO, SERVO_MINDUTY);
  
  delay(1000);

  for (int angle=SERVO_MINDUTY; angle<=SERVO_MAXDUTY; angle++) {
    Timer1.setPwmDuty(SERVO, angle);
    delay(30);
  }

  Timer1.disablePwm(SERVO);
}

void loop() {
}

KakaoTalk_20260323_210827547.mp4

1.74MB

attachInterrupt(digitalPinToInterrupt(pin), ISR, mode): 버튼을 누르는 순간 또는 떼는 순간을 감지할 수 있다
할당된 핀이 0에서 1로, 또는 1에서 0으로 바뀌는 순간을 감지하고 원하는 동작을 수행하고자 할 때 사용

pin: 핀번호, 아두이노 우노의 경우 2, 3
ISR: 인터럽트가 발생하면 하드웨어적으로 호출되는 인터럽트 처리 함수
mode: 인터럽트 발생 조건, LOW, CHANGE, RISING, FALLING 중 하나

const int ledPin = 13;
const int buttonPin = 2;

int led_state = LOW;
bool led_state_changed = false;

void buttonPressed() {
  led_state = (led_state == LOW) ? HIGH : LOW;
  led_state_changed = true;
}

void setup() {
  pinMode(ledPin, OUTPUT);
  pinMode(buttonPin, INPUT);
  attachInterrupt(digitalPinToInterrupt(buttonPin), buttonPressed, RISING);
}

void loop() {
  if (led_state_changed) {
    led_state_changed = false;
    digitalWrite(ledPin, led_state);
  }
}

KakaoTalk_20260323_213825705.mp4

1.81MB

#include <Servo.h>
 const int SERVO = 10;
 Servo servo;
 const int buttonPin = 2;

 int servo_state = 30;
 bool servo_state_changed = false;

 void buttonPressed() {
  servo_state = (servo_state == 30) ? 150 : 30;
  servo_state_changed = true;
 }

 void setup() {
  pinMode(buttonPin, INPUT);
  attachInterrupt(digitalPinToInterrupt(buttonPin), buttonPressed, RISING);
  servo.attach(SERVO);
  servo.write(0);
  delay(1000);
 }

 void loop() {
  if(servo_state_changed) {
    servo_state_changed = false;
    servo.write(servo_state);
  }
 }

KakaoTalk_20260323_215927936.mp4

1.00MB

attachPCINT(digitalPinToPCINT(pin), ISR, mode): 특정한 핀에 특정한 조건에 맞는 핀 신호 변화 인터럽트가 발생할 경우 수행할 함수를 등록하는 함수
digitalPinToPCINT(pin): 핀번호, 아두이노 우노의 경우 2, 3을 제외한 나머지 핀
ISR: 인터럽트가 발생하면 하드웨어적으로 호출되는 인터럽트 처리 함수
mode: 인터럽트 발생 조건, CHANGE, RISING, FALLING 중 하나

버튼 인터럽트로 LED 켜기

#include "PinChangeInterrupt.h"

const int ledPin = 13;
const int buttonPin = 4;

int led_state = LOW;
bool led_state_changed = false;

void buttonPressed() {
  led_state = (led_state == LOW) ? HIGH : LOW;
  led_state_changed = true;
}

void setup() {
  pinMode(ledPin, OUTPUT);
  pinMode(buttonPin, INPUT);
  attachPCINT(digitalPinToPCINT(buttonPin), buttonPressed, RISING);
}

void loop() {
  if(led_state_changed) {
    led_state_changed = false;
    digitalWrite(ledPin, led_state);
  }
}

KakaoTalk_20260323_221530687.mp4

0.66MB

초음파 센서로 거리 측정해보기

const int trig_pin = 11;
const int echo_pin = 12;

void setup() {
  pinMode(trig_pin, OUTPUT);
  pinMode(echo_pin, INPUT);

  Serial.begin(115200);
}

void loop() {
  digitalWrite(trig_pin, LOW);
  delayMicroseconds(2);
  digitalWrite(trig_pin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trig_pin, LOW);

  long duration = pulseIn(echo_pin, HIGH);
  long distance = (duration/2) / 29.1;

  Serial.print(distance);
  Serial.println("cm");
}

pulseIn 함수 수행 시간 살펴보기

const int trig_pin = 11;
const int echo_pin = 12;

void setup() {
  pinMode(trig_pin, OUTPUT);
  pinMode(echo_pin, INPUT);

  Serial.begin(115200);
}

void loop() {
  digitalWrite(trig_pin, LOW);
  delayMicroseconds(2);
  digitalWrite(trig_pin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trig_pin, LOW);

  unsigned long t_begin = millis();

  long duration = pulseIn(echo_pin, HIGH);
  unsigned long t_end = millis();
  Serial.print(t_end - t_begin);
  Serial.println("ms");
}

핀 신호변화 인터럽트 사용하기

#include <PinChangeInterrupt.h>

const int trig_pin = 11;
const int echo_pin = 12;

unsigned long echo_duration = 0;
void echoIsr(void) {
  static unsigned long echo_begin = 0;
  static unsigned long echo_end = 0;
  unsigned int echo_pin_state = digitalRead(echo_pin);
  if(echo_pin_state == HIGH) {
    echo_begin = micros();
  } else {
    echo_end = micros();
    echo_duration = echo_end - echo_begin;
  }
}

void setup() {
  pinMode(trig_pin, OUTPUT);
  pinMode(echo_pin, INPUT);

  attachPCINT(digitalPinToPCINT(echo_pin), echoIsr, CHANGE);

  Serial.begin(115200);
}

void loop() {
  if (echo_duration == 0) {
    digitalWrite(trig_pin, LOW);
    delayMicroseconds(2);
    digitalWrite(trig_pin, HIGH);
    delayMicroseconds(10);
    digitalWrite(trig_pin, LOW);
  } else {
    unsigned long distance = echo_duration / 58;
    Serial.print(distance);
    Serial.println("cm");

    echo_duration = 0;
  }
}

아두이노 - Timer (빛, 부저)

haniru — Mon, 23 Mar 2026 00:43:11 +0900

Timer1.initialize(): Timer1을 초기화하는 함수

Timer1.pwm(pin, duty): 특정한 핀에 사각 파형을 생성하도록 함
pin: 사각 파형을 내보낼 핀 번호, 9, 10번 핀 중 하나
duty: 사각 파형의 HIGH 구간의 개수, 0~1023 사이 값

Timer.setPeriod(period): 마이크로초 단위로 주기를 설정
period: 마이크로 초 단위 주기, 1~8388480 사이 값, 주파수로는 0.12~1MHz

Timer.setPwmDuty(pin, duty): 주어진 핀에 사각 파형의 duty를 설정하는 함수
pin: 사각 파형의 HIGH 구간 값을 변경할 핀
duty: 변경할 사각 파형의 HIGH 구간 값, 1~1023 사이 값

timerone 설치: 스케치 - 라이브러리 포함하기 - 라이브러리 관리

잘 설치되어있음

LED 켜고 끄기 반복하기 - 1Hz 의 주파수로 LED 점멸 확인 (1초 주기로 LED가 점멸하는 것을 확인)

#include <TimerOne.h>

const int LED = 10;

void setup() {
  Timer1.initialize();
  Timer1.pwm(LED, 0);

  Timer1.setPeriod(1000000);
  Timer1.setPwmDuty(LED, 511);
}

void loop() {
  
}

KakaoTalk_20260323_001003432.mp4

0.68MB

LED 켜고 끄기 간격 줄여보기 - 10Hz의 주파수로 점멸 (초당 10번 점멸)

#include <TimerOne.h>

const int LED = 10;

void setup() {
  Timer1.initialize();
  Timer1.pwm(LED, 0);

  Timer1.setPeriod(1000000/10);
  Timer1.setPwmDuty(LED, 511);
}

void loop() {

}

KakaoTalk_20260323_001137355.mp4

0.32MB

LED 켜고 끄기 간격 줄여보기 - 100Hz의 주파수로 점멸 (불빛이 계속 켜져있는 것 처럼 보임)

#include <TimerOne.h>

const int LED = 10;

void setup() {
  Timer1.initialize();
  Timer1.pwm(LED, 0);

  Timer1.setPeriod(1000000/100);
  Timer1.setPwmDuty(LED, 511);
}

void loop() {

}

KakaoTalk_20260323_001525341.mp4

0.30MB

주파수 늘리기 - 초당 1000번 점멸

#include <TimerOne.h>

const int LED = 10;

void setup() {
  Timer1.initialize();
  Timer1.pwm(LED, 0);

  Timer1.setPeriod(1000000/1000);
  Timer1.setPwmDuty(LED, 511);
}

void loop() {

}

KakaoTalk_20260323_001650988.mp4

0.30MB

LED 어둡게 하기 - 10% 만큼 점등, 90% 만큼 소등

#include <TimerOne.h>

const int LED = 10;

void setup() {
  Timer1.initialize();
  Timer1.pwm(LED, 0);

  Timer1.setPeriod(1000000/1000);
  Timer1.setPwmDuty(LED, 100);
}

void loop() {

}

LED 밝게 하기 - 90% 만큼 점등, 10% 만큼 소등

#include <TimerOne.h>

const int LED = 10;

void setup() {
  Timer1.initialize();
  Timer1.pwm(LED, 0);

  Timer1.setPeriod(1000000/1000);
  Timer1.setPwmDuty(LED, 900);
}

void loop() {

}

LED 밝기를 11단계로 조절해보기

#include <TimerOne.h>

const int LED = 10;

void setup() {
  Timer1.initialize();
  Timer1.pwm(LED, 0);

  Timer1.setPeriod(1000);
}

void loop() {
  for (int t_high=0; t_high<=10; t_high++) {
    Timer1.setPwmDuty(LED, t_high*100);
    delay(100);
  }
}

KakaoTalk_20260323_002217347.mp4

0.54MB

밝기를 1024 단계로 조절

#include <TimerOne.h>

const int LED = 10;

void setup() {
  Timer1.initialize();
  Timer1.pwm(LED, 0);

  Timer1.setPeriod(1000);
}

void loop() {
  for (int t_high=0; t_high<=1023; t_high++) {
    Timer1.setPwmDuty(LED, t_high);
    delay(1);
  }
}

KakaoTalk_20260323_002530069.mp4

0.45MB

피에조 부저 제어

수동 부저 소리내보기 - 도라는 음이 나옴

#include <TimerOne.h>

const int BUZZER = 10;

void setup() {
  Timer1.initialize();
  Timer1.pwm(BUZZER, 0);

  Timer1.setPwmDuty(BUZZER, 512);

  Timer1.setPeriod(1000000/262);

  delay(3000);

  Timer1.setPwmDuty(BUZZER, 0);
}

void loop() {
  
}

KakaoTalk_20260323_003205058.mp4

0.74MB

도, 레 3회 반복

#include <TimerOne.h>

const int BUZZER = 10;

void setup() {
  Timer1.initialize();
  Timer1.pwm(BUZZER, 0);

  Timer1.setPwmDuty(BUZZER, 100);

  for (int cnt=0; cnt<=2; cnt++) {
    Timer1.setPeriod(1000000/262);
    delay(1000);
    Timer1.setPeriod(1000000/294);
    delay(1000);
  }

  Timer1.setPwmDuty(BUZZER, 0);
}

void loop() {

}

KakaoTalk_20260323_003931243.mp4

2.45MB

도레미파솔라시도

#include <TimerOne.h>

const int BUZZER = 10;

const int melody[] = {
  262, 294, 330, 349, 393, 440, 494, 523,
};

void setup() {
  Timer1.initialize();
  Timer1.pwm(BUZZER, 0);

  Timer1.setPwmDuty(BUZZER, 100);

  for (int note=0; note<8; note++) {
    Timer1.setPeriod(1000000/melody[note]);
    delay(500);
  }

  Timer1.setPwmDuty(BUZZER, 0);
}

void loop() {

}

KakaoTalk_20260323_004215778.mp4

1.41MB