라즈베리파이 5로 시작하는 AI & IoT 프로젝트: 실전 실습으로 배우는 AIoT 제작 가이드

(주)올딩 2025. 6. 17. 15:20

728x90

라즈베리파이 5로 시작하는 AI & IoT 프로젝트: 실전 실습으로 배우는 AIoT 제작 가이드, 서항주 지음

저자소개

대학과 공공기관, 중소기업 등에서 인공지능, 빅데이터, 클라우드, 정보보안, 프로젝트관리 등의 내용전문가 및 평가위원으로 활동하며 정보통신 분야의 전문성을 강화하고 있으며, 공기업 정책 및 평가기준 수립에 관한 연구 등을 수행하고 있다.

📕 『라즈베리파이 5로 시작하는 AI & IoT 프로젝트』

프롤로그

왜 라즈베리파이인가?
이 책의 구성과 활용법

1부. 라즈베리파이 5 기본 익히기

1장. 라즈베리파이 5란? – 성능, 특징, 활용 분야
2장. 라즈베리파이 5 설치 및 환경 설정
3장. 기본 명령어 및 파일 관리
4장. 파이썬 기초 다지기

2부. GPIO와 센서 실습

5장. GPIO란 무엇인가? – 이론과 핀 구성
6장. GPIO 실습 ① – LED, 버튼 제어
7장. GPIO 실습 ② – 초음파 센서 및 PWM 이해
8장. DC 모터 및 서보 모터 제어하기

3부. 통신과 확장 기술

9장. UART 통신 – 직렬 통신 기초와 실습
10장. 블루투스 통신(Bluetooth) 실습
11장. SPI 통신 – 고속 데이터 전송 이해
12장. I2C 통신 – 다중 장치 제어 실습

4부. 웹 & 네트워크 활용

13장. Flask로 간단한 웹 서버 만들기
14장. 실시간 데이터 웹 대시보드 만들기
15장. 라즈베리파이 카메라 모듈 설치 및 활용
16장. 오픈 API 활용 – 외부 데이터와 라즈베리파이 연동

5부. 인공지능(AI) 실전 프로젝트

17장. OpenCV 활용 – 영상 처리 및 객체 인식 기초
18장. YOLO로 실시간 객체 인식하기
19장. 라즈베리파이 AIKit 실전 활용

6부. 종합 프로젝트

20장. 종합 프로젝트: 스마트 감시 시스템 만들기

부록

A. 자주 묻는 질문 (FAQ)
B. 추천 부품 리스트 및 구매처

에필로그

당신의 첫 AIoT 프로젝트, 어디까지 왔나요?

이 구성으로 책 전체의 흐름이 기초부터 실전, 그리고 종합 프로젝트로 자연스럽게 이어지도록 설계되었습니다. 추가로 구성하고 싶은 장이나 항목이 있으시면 언제든지 말씀해 주세요!

프롤로그 – 미래를 움직이는 작은 컴퓨터, 라즈베리파이 5

당신의 손바닥 위에 있는 이 작은 보드는 단순한 컴퓨터가 아닙니다. 상상을 현실로 바꾸는 마법 상자이자, 세상의 다양한 기술을 탐험할 수 있는 디지털 나침반입니다. 라즈베리파이 5는 성능과 확장성, 그리고 가격 대비 효율성까지 모두 잡은 초소형 컴퓨터로, 이제는 단순한 교육용 기기를 넘어 프로토타입 제작과 실제 산업 현장에서도 주목받고 있습니다.
이 책은 단순한 하드웨어 가이드북이 아닙니다. ‘실제로 작동하는 것’을 만들고 싶었던 수많은 예비 메이커와 개발자들을 위한 실전 지침서입니다. 기본적인 파이썬 프로그래밍부터, 모터 제어, 각종 센서 실습, 그리고 인공지능 기반의 영상 분석까지. 이 책은 라즈베리파이 5를 통해 할 수 있는 거의 모든 것을 하나의 흐름 안에 담고 있습니다.
특히 이번 개정된 라즈베리파이 5는 AIKit과 같은 고급 기능까지 지원하며, 단순한 IOT 제어를 넘어 인공지능 프로젝트 구현까지 가능하게 해주었습니다. 본서는 초보자도 따라할 수 있는 쉬운 설명과 함께, 중급자도 도전할 수 있는 심화 프로젝트를 병행해 구성하였습니다. 코드와 회로도는 물론이고, 웹과의 연동, 카메라 처리, 실시간 센서 모니터링까지 통합적으로 경험할 수 있습니다.
디지털 시대의 교양은 더 이상 단순한 앱 사용법이 아닙니다. 스스로 만들어보고, 연결해보고, 데이터를 해석하고, 그것을 다시 현실에 적용하는 능력입니다. 이 책이 여러분의 첫 번째 프로젝트가 되고, 나아가 세상을 바꾸는 시작이 되기를 바랍니다.
이제, 라즈베리파이 5와 함께 미래를 코딩해봅시다.

1부. 라즈베리파이 5 기본 익히기

1장. 라즈베리파이 5란? – 성능, 특징, 활용 분야

라즈베리파이(Raspberry Pi)는 영국의 비영리 단체 라즈베리파이 재단(Raspberry Pi Foundation)에서 교육용 목적으로 개발한 초소형 컴퓨터입니다. 처음에는 프로그래밍 교육용 도구로 시작했지만, 이제는 IoT 기기, 로봇, 스마트홈, 머신러닝, 웹 서버 등 실생활의 다양한 분야에서 활용되고 있습니다. 특히, 2023년 말 출시된 라즈베리파이 5는 성능 면에서 획기적인 발전을 이루며 본격적인 실무 활용까지 가능하게 만들었습니다.

1.1 라즈베리파이 5의 주요 사양

라즈베리파이 5는 기존 모델 대비 CPU 성능이 대폭 향상되었고, I/O 속도와 카메라 처리 능력 등도 눈에 띄게 업그레이드되었습니다.

프로세서: Broadcom BCM2712, 쿼드코어 ARM Cortex-A76 @ 2.4GHz
메모리: 4GB 또는 8GB LPDDR4X
저장장치: microSD 및 PCIe 2.0 (SSD 확장 가능)
영상 출력: 듀얼 micro HDMI (4K@60Hz 지원)
USB 포트: USB 3.0 x 2, USB 2.0 x 2
이더넷: 기가비트 이더넷
GPIO 핀: 40핀 확장 헤더, 다양한 외부 장치 제어 가능
기타: BLE 5.0, Wi-Fi 802.11ac, 카메라/디스플레이 전용 포트

특히 PCIe 지원은 SSD와의 연결을 가능하게 만들어 데이터 처리 속도를 획기적으로 끌어올렸습니다. 덕분에 라즈베리파이 5는 단순한 제어용 보드를 넘어, AI 애플리케이션이나 엣지 컴퓨팅을 위한 ‘작은 서버’로도 활용할 수 있습니다.

1.2 라즈베리파이의 핵심 장점

저비용 고성능: 10만 원 이내의 가격으로 소형 PC 수준의 기능을 수행
높은 확장성: 다양한 센서 및 모듈과의 연결이 가능
광범위한 커뮤니티: 수많은 오픈소스 프로젝트와 튜토리얼 제공
전력 효율성: 저전력으로 구동되어 휴대성과 지속성이 뛰어남
범용성: 교육용, 상업용, 산업용 등 다양한 프로젝트에 적용 가능

1.3 라즈베리파이 5가 열어주는 활용 세계

1) 교육

초보자가 프로그래밍, 리눅스, 네트워크 등 기본기를 익히기에 최적입니다. 특히 블록 기반의 비주얼 프로그래밍 도구와 연계하면 초등학생도 활용할 수 있습니다.

2) IoT 프로젝트

스마트홈 구현, 온도·습도 모니터링, 환경 감지 시스템 등 실시간 센서 데이터를 수집하고 제어하는 데 이상적입니다.

3) 로봇/자동화 시스템

모터, 서보, 초음파 센서를 제어하여 간단한 로봇부터 산업용 자동화 장비의 프로토타입 제작까지 가능합니다.

4) 멀티미디어/스트리밍

4K 영상 출력이 가능하며, 오디오 출력도 강화되어 미디어 센터나 스트리밍 서버로 활용 가능합니다.

5) AI 및 영상 처리

OpenCV, TensorFlow Lite, YOLO 등과 연계하여 객체 인식, 얼굴 인식, 사람 수 카운팅 등의 AI 기능도 구현할 수 있습니다.

6) 네트워크 및 서버 구축

간단한 웹 서버(Flask, Django)나 VPN, NAS, 파일 서버 등도 라즈베리파이 하나로 구축할 수 있습니다.

1.4 실사용자의 이야기: “초소형 보드로 스마트팜을 만들다”

30대 초반의 스타트업 대표 A씨는 라즈베리파이 5를 활용해 스마트팜 초기 모델을 개발했습니다. 온습도 센서, 조도 센서, 팬 제어 모듈 등을 라즈베리파이에 연결하고, 데이터를 Flask 서버로 시각화했습니다. 이 시스템은 실제로 농장에 설치되어 자동으로 환경을 조절하며, 모바일 웹으로도 모니터링이 가능하도록 설계되었습니다. A씨는 “라즈베리파이 덕분에 큰 비용 없이 아이디어를 구현할 수 있었다”고 말합니다.

1.5 라즈베리파이 5로 무엇을 만들 수 있을까?

분야	예시 프로젝트
교육	코딩 교육 키트, 리눅스 명령어 실습
IoT	스마트홈 제어기, 원격 조명 제어
로봇	라인트레이서, 초음파 장애물 회피 로봇
영상	얼굴 인식 출입 시스템, CCTV 모니터링
서버	개인 블로그 서버, NAS 파일 서버
AI	사람 수 카운팅, 마스크 착용 여부 감지

1.6 시작에 앞서 준비할 것들

라즈베리파이 5를 제대로 활용하려면 몇 가지 준비물이 필요합니다.

라즈베리파이 5 본체
microSD 카드 (32GB 이상, U3 추천)
전원 어댑터 (5V 5A USB-C PD)
HDMI 케이블 및 모니터
키보드 및 마우스
인터넷 연결 (유선 또는 무선)
케이스 및 히트싱크(발열 관리용)
기초 센서 및 브레드보드, 점퍼선

이러한 준비가 끝나면, 이후 장에서는 운영체제 설치부터 실제 코딩 실습까지 하나하나 따라 하며 익혀나갈 수 있습니다.

2장. 라즈베리파이 5 설치 및 환경 설정

라즈베리파이 5를 손에 넣었다면, 이제 본격적으로 사용 준비를 해야 합니다. 컴퓨터처럼 부팅하고, 운영체제를 설치하며, 필요한 기본 소프트웨어를 설정하는 과정입니다. 이 장에서는 라즈베리파이 5의 기본 환경을 구성하는 방법을 단계별로 안내하겠습니다.

2.1 준비물 체크리스트

시작하기 전, 다음의 준비물을 확인하세요.

라즈베리파이 5 본체
microSD 카드 (32GB 이상, Class 10, U3 권장)
microSD 카드 리더기
정격 USB-C 전원 어댑터 (5V 5A PD 지원)
HDMI 케이블과 모니터
USB 키보드와 마우스
인터넷 연결 (Wi-Fi 또는 유선 LAN)
케이스와 히트싱크 (발열 관리용, 선택사항)

2.2 운영체제 설치하기

라즈베리파이 5는 일반적인 x86 계열 PC와 달리 ARM 기반이므로, 전용 운영체제가 필요합니다. 가장 많이 사용되는 운영체제는 ‘Raspberry Pi OS’입니다.

(1) Raspberry Pi Imager 설치

공식 사이트(https://www.raspberrypi.com/software/)에 접속합니다.
사용 중인 운영체제(Windows, macOS, Linux)에 맞는 설치 파일을 다운로드하고 실행합니다.
‘Raspberry Pi Imager’를 설치합니다.

(2) microSD 카드에 OS 굽기

Raspberry Pi Imager를 실행합니다.
“Choose OS”를 클릭하고 **Raspberry Pi OS (64-bit)**를 선택합니다.
“Choose Storage”를 클릭하여 microSD 카드를 선택합니다.
“Write”를 클릭해 OS 이미지를 굽습니다.
완료되면 자동으로 마운트 해제됩니다.

💡 Tip

쓰기 속도가 빠른 microSD 카드일수록 설치 시간이 단축됩니다.
Raspberry Pi OS 외에도 Ubuntu, DietPi, LibreELEC 등 다양한 운영체제를 선택할 수 있습니다.

2.3 첫 부팅 및 초기 설정

microSD 카드를 라즈베리파이에 삽입하고, 모니터와 키보드, 마우스를 연결한 후 전원을 연결하면 부팅이 시작됩니다.

초기 설정 마법사

언어 및 지역 설정 (한국어도 선택 가능)
Wi-Fi 네트워크 연결 (유선 사용 시 생략)
사용자 계정 생성
소프트웨어 업데이트 확인
디스플레이 해상도 자동 조정

초기 설정이 끝나면 바탕화면이 나타나며, 일반적인 데스크탑 환경처럼 사용할 수 있습니다.

2.4 SSH 및 원격 접속 설정

(1) SSH 활성화

터미널을 열고 다음 명령어를 입력합니다:

sudo raspi-config

Interface Options → SSH → Enable

(2) 원격 접속 테스트 (Windows 기준)

PuTTY 같은 SSH 클라이언트를 이용해 IP 주소로 접속할 수 있습니다.

ssh pi@192.168.x.x

비밀번호는 처음 설정한 비밀번호입니다.

💡 Tip

hostname -I 명령어로 현재 IP 주소를 확인할 수 있습니다.
설정 중 “VNC”도 함께 활성화하면 GUI 환경으로 원격 접속이 가능합니다.

2.5 기본 시스템 업데이트

라즈베리파이를 처음 사용할 때는 운영체제와 패키지를 최신 상태로 유지해야 안정적인 사용이 가능합니다.

sudo apt update
sudo apt full-upgrade -y
sudo reboot

2.6 한국어 입력기 설치

기본적으로 영문 환경이므로 한국어 입력을 위해 다음을 설치합니다:

sudo apt install ibus-hangul -y
ibus restart

설정 → Region & Language → Input Sources에서 한국어(Hangul)를 추가합니다.

2.7 기본 소프트웨어 설치

초기 실습을 위해 다음 도구들을 함께 설치해두면 좋습니다:

sudo apt install python3-pip git vim -y
pip3 install RPi.GPIO flask opencv-python

2.8 설정 후 꼭 해볼 테스트

(1) 터미널 열고 Hello World 출력

python3
>>> print("Hello, Raspberry Pi!")

(2) LED 점등 테스트 (3장에서 자세히 설명 예정)

브레드보드에 LED를 연결하고, GPIO 코드를 간단히 실행해보는 것으로 기능을 점검합니다.

2.9 문제 발생 시 대처법

문제	해결 방법
화면이 안 나옴	HDMI 케이블 확인, microSD 재작성
Wi-Fi 연결 안 됨	재부팅 후 네트워크 재설정
발열 과다	케이스/히트싱크 추가 설치
입력기 오류	ibus-hangul 재설치 및 설정

2.10 마무리 및 다음 단계 예고

이제 라즈베리파이 5가 사용 가능한 상태로 준비되었습니다. 운영체제 설치부터 원격 접속까지 설정이 끝났다면, 이제 본격적으로 GPIO와 하드웨어 제어를 시작할 차례입니다.
다음 장에서는 라즈베리파이의 꽃이라 할 수 있는 GPIO 핀의 구조와 사용법을 배우고, LED 점등, 버튼 제어 같은 기초 회로 실습으로 첫 번째 프로젝트를 만들어봅니다.

3장. 기본 명령어 및 파일 관리

라즈베리파이 5는 리눅스 기반의 운영체제를 사용하기 때문에, 명령어 중심의 환경에 익숙해지는 것이 매우 중요합니다. 이 장에서는 터미널 사용법과 주요 명령어, 파일 및 디렉토리 관리 방법을 익히고, 실습을 통해 자연스럽게 손에 익히는 것을 목표로 합니다.

3.1 터미널이란?

터미널(Terminal)은 사용자가 컴퓨터에 명령어를 직접 입력하여 제어할 수 있는 창입니다. 윈도우의 명령 프롬프트(Command Prompt)나 macOS의 터미널과 유사합니다.

터미널 실행 방법

바탕화면 상단 메뉴 → 액세서리 → 터미널
단축키: Ctrl + Alt + T

3.2 기본 파일 명령어

라즈베리파이에서 가장 자주 사용하는 파일 관련 명령어는 다음과 같습니다.

명령어	설명
ls	현재 디렉토리 목록 보기
cd [디렉토리명]	디렉토리 이동
pwd	현재 경로 출력
mkdir [디렉토리명]	새 디렉토리 생성
touch [파일명]	빈 파일 생성
nano [파일명]	텍스트 파일 편집기 실행
rm [파일명]	파일 삭제
rmdir [디렉토리명]	빈 디렉토리 삭제
cp [원본] [대상]	파일 복사
mv [원본] [대상]	파일 이동 또는 이름 변경

3.3 실습: 나만의 프로젝트 디렉토리 만들기

mkdir ~/my_project
cd ~/my_project
touch hello.py
ls

이 과정을 통해 자신의 홈 디렉토리 안에 my_project 폴더를 만들고, hello.py라는 파일을 생성한 후 목록을 확인해볼 수 있습니다.

3.4 파일 내용 보기 및 수정하기

(1) 파일 내용 보기

cat hello.py

(2) 텍스트 편집기 사용

nano hello.py

print("Hello, Raspberry Pi!")

Ctrl + X → Y → Enter 로 저장하고 종료합니다.

3.5 파일 및 디렉토리 경로 이해하기

리눅스의 경로 구조는 윈도우와 다르게 /를 기준으로 계층 구조를 이룹니다.

/home/pi → 기본 사용자 홈 디렉토리
~ → 현재 사용자 홈 디렉토리의 약어
. → 현재 디렉토리
.. → 상위 디렉토리

cd ~        # 홈 디렉토리로 이동
cd ..       # 상위 디렉토리로 이동

3.6 파일 권한 이해하기

ls -l

예: -rw-r--r-- 1 pi pi 1234 Jun 17 10:00 hello.py
의미: 소유자, 그룹, 기타 사용자에 대한 읽기(r), 쓰기(w), 실행(x) 권한

실행 권한 부여하기

chmod +x hello.py

3.7 파일 찾기 및 검색

특정 파일 찾기

find ~/ -name "*.py"

특정 텍스트가 포함된 파일 찾기

grep "Raspberry" hello.py

3.8 실습: 파이썬 스크립트 실행하기

python3 hello.py

“Hello, Raspberry Pi!”라는 출력 결과가 화면에 나타납니다.

3.9 압축 및 해제

압축하기

tar -cvf my_project.tar my_project/

압축 해제

tar -xvf my_project.tar

3.10 시스템 정보 확인

명령어	설명
df -h	디스크 사용량 확인
free -h	메모리 상태 확인
top	실시간 시스템 리소스 확인
uname -a	시스템 정보 확인

3.11 네트워크 상태 확인

ifconfig        # 네트워크 인터페이스 정보
ping 8.8.8.8    # 외부와의 연결 확인
hostname -I     # 현재 IP 주소 확인

3.12 실습 프로젝트: 자동 로그 기록 스크립트

log_writer.py라는 파일을 만들어 아래 내용을 작성해봅니다.

from datetime import datetime

with open("log.txt", "a") as f:
    f.write(f"{datetime.now()} - 실행됨\n")

실행:

python3 log_writer.py
cat log.txt

자동 기록이 추가된 것을 확인할 수 있습니다.

3.13 요약 및 다음 단계 예고

이번 장에서는 라즈베리파이의 기본 명령어와 파일 관리 기초를 익혔습니다. 이 스킬은 앞으로 GPIO 제어나 웹서버 실행, 카메라 처리 등 거의 모든 프로젝트의 기초가 됩니다.
다음 장에서는 라즈베리파이에서 사용되는 가장 중요한 프로그래밍 언어인 파이썬의 기초를 배웁니다. 파이썬으로 센서를 제어하고, 데이터를 처리하며, 웹과 연결하는 모든 기반을 차근차근 쌓아갈 것입니다.

4장. 파이썬 기초 다지기

파이썬은 라즈베리파이에서 가장 많이 사용되는 프로그래밍 언어입니다. 문법이 간결하고 배우기 쉬우며, 센서 제어, 웹 서버 구축, 데이터 처리, 인공지능까지 모두 아우를 수 있는 확장성을 지녔기 때문입니다. 이 장에서는 파이썬을 처음 접하는 사람도 바로 실습할 수 있도록 핵심 개념과 실습 예제를 중심으로 파이썬의 기초를 다지겠습니다.

4.1 파이썬 실행 방법

(1) 대화형 인터프리터 사용

python3
>>> print("Hello, Python!")

Ctrl + D로 종료

(2) 스크립트 실행

nano test.py

print("Hello, Raspberry Pi with Python!")

저장 후 실행:

python3 test.py

4.2 변수와 자료형

name = "Pi"
age = 10
temperature = 24.5
is_on = True

자료형	예시
문자열 (str)	"Hello"
정수 (int)	10
실수 (float)	3.14
불리언 (bool)	True, False

4.3 입력과 출력

name = input("이름을 입력하세요: ")
print(f"안녕하세요, {name}님!")

4.4 조건문

temp = int(input("온도를 입력하세요: "))

if temp > 30:
    print("더워요!")
elif temp < 10:
    print("추워요!")
else:
    print("적당해요!")

4.5 반복문

(1) for문

for i in range(5):
    print(f"{i}번째 반복")

(2) while문

count = 0
while count < 3:
    print("반복 중...")
    count += 1

4.6 리스트와 딕셔너리

리스트

sensors = ["온도", "습도", "조도"]
print(sensors[1])

딕셔너리

data = {"온도": 24.5, "습도": 60}
print(data["온도"])

4.7 함수

def greet(name):
    print(f"안녕하세요, {name}님!")

greet("라즈베리파이")

4.8 모듈과 라이브러리

import time

print("3초 대기 중...")
time.sleep(3)
print("끝!")

외부 모듈 설치:

pip3 install requests

사용 예:

import requests

response = requests.get("https://api.github.com")
print(response.status_code)

4.9 예외 처리

try:
    num = int(input("숫자를 입력하세요: "))
    print(10 / num)
except ValueError:
    print("숫자를 입력해주세요!")
except ZeroDivisionError:
    print("0으로 나눌 수 없습니다.")

4.10 파일 입출력

with open("data.txt", "w") as f:
    f.write("라즈베리파이로 파일 작성\n")

with open("data.txt", "r") as f:
    print(f.read())

4.11 간단한 실습: 온도 변환기 만들기

c = float(input("섭씨 온도 입력: "))
f = (c * 9/5) + 32
print(f"화씨 온도는 {f}도입니다.")

4.12 실전 예제: 센서 데이터 시뮬레이션

import random
import time

for i in range(5):
    temp = round(random.uniform(20, 30), 2)
    humid = random.randint(40, 60)
    print(f"[{i+1}] 온도: {temp}°C, 습도: {humid}%")
    time.sleep(1)

4.13 파이썬에서 GPIO 준비 (다음 장 예고)

pip3 install RPi.GPIO

기초 코드 예:

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)
GPIO.setup(18, GPIO.OUT)

GPIO.output(18, GPIO.HIGH)
time.sleep(1)
GPIO.output(18, GPIO.LOW)

GPIO.cleanup()

4.14 요약 및 다음 단계

이번 장에서는 파이썬의 기본 문법을 실습 위주로 익혔습니다. 이 내용을 바탕으로 다음 장에서는 드디어 하드웨어를 제어하는 GPIO 실습에 들어갑니다. LED를 깜빡이고 버튼을 눌러보는 경험을 통해 라즈베리파이의 진짜 재미를 느낄 수 있을 것입니다.

2부. GPIO와 센서 실습

5장. GPIO란 무엇인가? – 이론과 핀 구성

GPIO(General Purpose Input/Output)는 라즈베리파이의 가장 핵심적인 기능 중 하나입니다. 간단히 말해, 외부 장치(센서, LED, 버튼 등)와 데이터를 주고받기 위한 다목적 입출력 핀입니다. GPIO를 통해 라즈베리파이는 단순한 컴퓨터에서 벗어나, 물리적 세계와 상호작용하는 ‘스마트 컨트롤러’가 됩니다.

5.1 GPIO란?

GPIO는 ‘범용 입출력’을 의미하며, 라즈베리파이 보드 양쪽 상단의 40핀 헤더에 포함되어 있습니다. 이 핀들은 신호를 ‘입력(Input)’으로 받을 수도 있고, ‘출력(Output)’으로 내보낼 수도 있습니다.

예:

입력: 버튼, 초음파 센서, 조도 센서
출력: LED, 모터, 릴레이

5.2 라즈베리파이 5의 GPIO 구조

라즈베리파이 5는 총 40개의 핀으로 구성되어 있으며, 그 중 약 26개 정도가 GPIO로 사용 가능합니다. 나머지는 전원(VCC, GND), I2C, SPI, UART 등 특정 기능을 위한 핀입니다.

핀 구성 예시 (일부)

핀 번호	기능	설명
1	3.3V 전원	센서 전원 공급용
2	5V 전원	고전압 전원 공급
6	GND	그라운드(공통 접지)
11	GPIO 17	범용 입출력 핀
13	GPIO 27	범용 입출력 핀
15	GPIO 22	범용 입출력 핀

5.3 GPIO 번호 체계 이해

파이썬으로 GPIO를 제어할 때는 보통 두 가지 번호 체계를 사용할 수 있습니다.

BOARD: 물리적 핀 번호 (1번부터 40번까지)
BCM: Broadcom 칩셋의 GPIO 번호 (GPIO 2, GPIO 17 등)

GPIO.setmode(GPIO.BOARD)  # 물리적 번호 기준
GPIO.setmode(GPIO.BCM)    # GPIO 번호 기준 (추천)

5.4 GPIO 작동 원리

GPIO는 HIGH(3.3V) 또는 LOW(0V)의 전압 신호를 주고받습니다. 출력 모드로 설정하면 외부 장치에 전류를 흘려 보내고, 입력 모드로 설정하면 외부 신호를 감지합니다.

출력 예시: GPIO 핀을 HIGH로 설정하면 LED에 전류가 흘러 불이 켜짐
입력 예시: 버튼이 눌리면 신호가 LOW → HIGH로 변함

5.5 주의사항: 전압 제한

라즈베리파이의 GPIO는 3.3V 전압만을 지원합니다. 5V 신호를 잘못 연결하면 보드가 손상될 수 있습니다. 외부 모듈을 사용할 때는 반드시 전압을 확인하고, 필요 시 로직레벨 변환기를 사용해야 합니다.

5.6 실습 준비물

브레드보드
LED 1~2개
220Ω 저항
점퍼 와이어(M/M)
버튼 (선택 사항)
라즈베리파이 5 보드
GPIO 핀 연결용 케이블 (40핀 헤더에 맞게)

5.7 회로도 기초 이해

GPIO 실습은 브레드보드와의 연결로 이루어집니다. 브레드보드는 전자 부품을 납땜 없이 연결할 수 있도록 도와주는 툴입니다. 보통 다음과 같이 사용합니다:

세로 열: 전원(VCC, GND) 라인
가로 줄: 부품 연결용 통로

5.8 실습 예고: LED 깜빡이기

다음 장에서는 실제로 LED를 GPIO를 통해 깜빡이게 만들어 보며 GPIO 제어를 실습합니다. 준비물만 있으면 바로 따라할 수 있도록 회로도와 코드, 실행 방법을 모두 제공합니다.

5.9 요약

항목	설명
GPIO	범용 입출력 핀으로 외부와 신호 주고받음
모드	BOARD 또는 BCM (BCM 권장)
HIGH/LOW	3.3V / 0V 신호
위험	5V 입력은 라즈베리파이를 손상시킬 수 있음
실습	LED, 버튼, 센서 등 연결 가능

5.10 다음 단계: 첫 번째 GPIO 제어 실습

이제 준비가 끝났습니다. 다음 장에서는 첫 번째 하드웨어 프로젝트인 LED 제어 실습을 시작합니다. 간단해 보일 수 있지만, 이 경험은 이후 모든 하드웨어 제어의 기초가 됩니다. 실습을 통해 라즈베리파이와 물리 세계의 연결을 직접 느껴보세요.

6장. GPIO 실습 ① – LED, 버튼 제어

이번 장에서는 GPIO의 실제 사용법을 익히기 위한 실습을 진행합니다. 가장 기본적인 프로젝트인 ‘LED 깜빡이기’와 ‘버튼 누르면 LED 켜기’를 통해 GPIO 출력과 입력의 개념을 체득하게 됩니다. 단순한 실습이지만, 모든 하드웨어 제어의 출발점이며 라즈베리파이의 진짜 매력을 느낄 수 있는 첫걸음입니다.

6.1 준비물

라즈베리파이 5 본체
브레드보드
LED (빨강 또는 초록)
220Ω 저항
점퍼 와이어 (수-수, 최소 3개)
푸시 버튼 (선택 사항)
GPIO 확장 케이블 (권장)

6.2 실습 1: LED 깜빡이기

(1) 회로 연결

연결 구성

GPIO 17 (BCM 기준) → 저항 → LED (+)

LED (-) → GND

저항은 LED와 직렬로 연결하여 전류 제한 역할을 합니다.
LED의 긴 다리가 (+), 짧은 다리가 (-)입니다.

(2) 코드 작성 (blink.py)

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)
GPIO.setup(17, GPIO.OUT)

try:
    while True:
        GPIO.output(17, GPIO.HIGH)
        print("LED ON")
        time.sleep(1)
        GPIO.output(17, GPIO.LOW)
        print("LED OFF")
        time.sleep(1)
except KeyboardInterrupt:
    print("종료합니다.")
finally:
    GPIO.cleanup()

(3) 실행

python3 blink.py

(4) 결과

LED가 1초 간격으로 깜빡이며, 터미널에 메시지가 출력됩니다.
Ctrl + C로 실행 중지 가능

6.3 실습 2: 버튼으로 LED 켜기

(1) 추가 연결

구성

버튼 한 쪽 → GPIO 18

버튼 다른 쪽 → GND

버튼은 디지털 입력을 위해 사용됩니다.
풀다운 저항 방식 사용 (내장 풀다운 처리)

(2) 코드 작성 (button_led.py)

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)
GPIO.setup(17, GPIO.OUT)     # LED
GPIO.setup(18, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)  # 버튼

try:
    while True:
        if GPIO.input(18) == GPIO.HIGH:
            GPIO.output(17, GPIO.HIGH)
            print("버튼 눌림 - LED ON")
        else:
            GPIO.output(17, GPIO.LOW)
        time.sleep(0.1)
except KeyboardInterrupt:
    print("종료합니다.")
finally:
    GPIO.cleanup()

(3) 실행

python3 button_led.py

(4) 결과

버튼을 누르면 LED가 켜지고, 놓으면 꺼집니다.
실시간 반응 확인 가능

6.4 실습 심화: LED 토글 기능

버튼을 한 번 누르면 켜지고, 다시 누르면 꺼지도록 구현해보겠습니다.

코드 작성 (toggle_led.py)

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)
GPIO.setup(17, GPIO.OUT)
GPIO.setup(18, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)

led_state = False
button_pressed = False

try:
    while True:
        if GPIO.input(18) == GPIO.HIGH and not button_pressed:
            led_state = not led_state
            GPIO.output(17, led_state)
            print(f"LED 상태: {'ON' if led_state else 'OFF'}")
            button_pressed = True
        elif GPIO.input(18) == GPIO.LOW:
            button_pressed = False
        time.sleep(0.1)
except KeyboardInterrupt:
    print("종료합니다.")
finally:
    GPIO.cleanup()

6.5 에러 및 디버깅 팁

증상	원인	해결 방법
LED 안 켜짐	핀 번호 오류	BCM/BOARD 확인
LED 항상 켜짐	GND 연결 안 됨	회로 점검
버튼 반응 없음	풀다운 미설정	pull_up_down 설정 확인

6.6 실습 확장 아이디어

버튼을 길게 누르면 LED가 빠르게 깜빡이도록 구현
두 개의 버튼으로 각각 ON/OFF 제어
LED 3개를 버튼으로 순차 점등

6.7 요약

실습	주요 개념
LED 깜빡이기	출력 제어 (GPIO.OUT)
버튼 입력	입력 감지 (GPIO.IN)
토글 구현	상태 전환, 조건 제어

6.8 다음 단계 예고

이번 실습을 통해 GPIO의 입력과 출력을 직접 제어해보며 기본 동작 원리를 익혔습니다. 다음 장에서는 센서를 연결해 실시간 거리 측정과 PWM 제어를 함께 경험합니다. 초음파 센서와 서보 모터를 이용해 보다 실제적인 프로젝트로 한 걸음 더 나아가 보겠습니다.

7장. GPIO 실습 ② – 초음파 센서 및 PWM 이해

이번 장에서는 라즈베리파이의 GPIO를 활용해 **초음파 거리 센서(HC-SR04)**와 **PWM(Pulse Width Modulation)**을 이용한 서보 모터 제어를 실습합니다. 두 개념은 스마트 주차 센서, 로봇 팔, 자동문 등 다양한 IoT 시스템에 필수적으로 쓰이는 기술입니다.

7.1 초음파 센서란?

초음파 센서는 초음파를 발사하고 물체에 반사되어 돌아오는 시간을 측정해 거리를 계산하는 센서입니다.

TRIG 핀: 초음파 발사
ECHO 핀: 반사파 수신

거리 계산 공식

거리(cm) = (왕복 시간 × 속도(340m/s)) ÷ 2
→ 거리(cm) = 시간(초) × 17,000

7.2 준비물

라즈베리파이 5
초음파 센서 HC-SR04
브레드보드
점퍼 와이어
330Ω 저항 2개 (ECHO 핀 전압 감소용)

7.3 회로 연결 (BCM 기준)

센서 핀	라즈베리파이
VCC	5V (핀 2)
GND	GND (핀 6)
TRIG	GPIO 23
ECHO	GPIO 24 (330Ω 저항 통해 3.3V 변환 필요)

7.4 코드 작성 (ultrasonic.py)

import RPi.GPIO as GPIO
import time

TRIG = 23
ECHO = 24

GPIO.setmode(GPIO.BCM)
GPIO.setup(TRIG, GPIO.OUT)
GPIO.setup(ECHO, GPIO.IN)

def get_distance():
    GPIO.output(TRIG, False)
    time.sleep(0.1)

    GPIO.output(TRIG, True)
    time.sleep(0.00001)
    GPIO.output(TRIG, False)

    while GPIO.input(ECHO) == 0:
        pulse_start = time.time()

    while GPIO.input(ECHO) == 1:
        pulse_end = time.time()

    pulse_duration = pulse_end - pulse_start
    distance = round(pulse_duration * 17000, 2)
    return distance

try:
    while True:
        dist = get_distance()
        print(f"거리: {dist} cm")
        time.sleep(1)
except KeyboardInterrupt:
    print("종료합니다.")
finally:
    GPIO.cleanup()

실행

python3 ultrasonic.py

7.5 실습: 거리 측정값에 따라 LED 제어

10cm 이내: 빨간 LED 켜기
10~30cm: 노란 LED 켜기
30cm 이상: 초록 LED 켜기

(3색 LED 또는 일반 LED 3개 사용 가능)

7.6 PWM이란?

PWM은 디지털 신호를 이용해 아날로그 제어처럼 보이게 만드는 방식입니다. LED 밝기 조절, 서보 모터 회전 각도 제어 등에 사용됩니다.

Duty Cycle: 신호가 HIGH인 시간의 비율
주파수(Frequency): 초당 신호의 반복 횟수

7.7 서보 모터 제어 실습

준비물

SG90 서보 모터
GPIO 연결용 점퍼선
외부 전원(5V) 권장

서보 핀	라즈베리파이
VCC	5V (핀 2)
GND	GND (핀 6)
Signal	GPIO 18

7.8 코드 작성 (servo.py)

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)
GPIO.setup(18, GPIO.OUT)

pwm = GPIO.PWM(18, 50)  # 50Hz
pwm.start(0)

def set_angle(angle):
    duty = angle / 18 + 2
    pwm.ChangeDutyCycle(duty)
    time.sleep(0.3)
    pwm.ChangeDutyCycle(0)

try:
    while True:
        for angle in [0, 90, 180]:
            print(f"{angle}도로 회전")
            set_angle(angle)
            time.sleep(1)
except KeyboardInterrupt:
    print("종료합니다.")
finally:
    pwm.stop()
    GPIO.cleanup()

실행

python3 servo.py

7.9 에러 해결 팁

증상	해결
거리값 0 또는 고정	TRIG/ECHO 핀 확인, 전압 제한 체크
서보 모터 떨림	외부 전원 공급 필요, GND 공유 확인
파형 불안정	PWM 주파수 및 duty 조정

7.10 실습 확장 아이디어

초음파 거리값에 따라 서보 모터로 물체 방향 회전
물체 감지 시 LED 및 부저 알림 추가
자동문, 스마트 쓰레기통 구현

7.11 요약

주제	내용
초음파 센서	거리 측정, 실시간 반응 구현
PWM	LED 밝기, 모터 제어 등 정밀 제어 가능
서보 모터	각도 제어, 방향 제어 가능

7.12 다음 단계 예고

다음 장에서는 DC 모터와 서보 모터를 함께 제어하며, 라즈베리파이를 활용한 이동형 로봇의 기반을 만들어봅니다. 실제로 움직이는 결과물을 만들며 하드웨어 제어의 성취감을 경험할 수 있습니다.

8장. DC 모터 및 서보 모터 제어하기

이제 라즈베리파이로 ‘움직이는 것’을 만들어볼 시간입니다. 이번 장에서는 DC 모터와 서보 모터의 차이를 이해하고, 각 모터를 제어하는 회로 구성과 파이썬 코드를 실습해봅니다. 특히 L298N 모터 드라이버를 활용한 DC 모터 제어는 로봇 제작의 핵심 기술로, 실제 이동형 시스템을 설계할 수 있는 기반을 제공합니다.

8.1 DC 모터와 서보 모터 비교

항목	DC 모터	서보 모터
회전방식	연속 회전	각도 기반 정밀 회전
제어방법	방향 + 속도 제어	각도 지정
주용도	바퀴, 팬, 펌프 등	로봇 관절, 카메라 각도 제어

8.2 DC 모터 제어 기본

DC 모터는 단순히 전류의 방향을 바꾸면 정/역회전을 할 수 있습니다. 하지만 직접 연결하면 전류를 조절할 수 없고, 라즈베리파이는 전류 공급 능력이 부족하기 때문에 모터 드라이버를 사용해야 합니다.

8.3 L298N 모터 드라이버 이해

IN1, IN2: 방향 제어 신호 (GPIO로 제어)
ENA: 속도 제어 (PWM 가능)
OUT1, OUT2: 모터 연결
VCC: 외부 전원 (모터용 5~12V)
GND: 공통 접지
5V 출력 핀: 라즈베리파이에 전원 공급 가능 (점퍼 설정 필요)

8.4 준비물

라즈베리파이 5
L298N 모터 드라이버
DC 모터 (3~6V)
외부 전원 (배터리 팩 또는 아답터)
점퍼 와이어
브레드보드 (필요 시)

8.5 회로 연결 예시 (단일 DC 모터 제어)

라즈베리파이 L298N

GPIO 20 → IN1
GPIO 21 → IN2
GPIO 18 → ENA (PWM)
5V, GND → GND (공통 접지)
외부 전원 → VCC (9V 권장)

8.6 DC 모터 제어 코드 (dc_motor.py)

import RPi.GPIO as GPIO
import time

IN1 = 20
IN2 = 21
ENA = 18

GPIO.setmode(GPIO.BCM)
GPIO.setup([IN1, IN2, ENA], GPIO.OUT)

pwm = GPIO.PWM(ENA, 1000)
pwm.start(0)

def forward(speed=50):
    GPIO.output(IN1, GPIO.HIGH)
    GPIO.output(IN2, GPIO.LOW)
    pwm.ChangeDutyCycle(speed)

def backward(speed=50):
    GPIO.output(IN1, GPIO.LOW)
    GPIO.output(IN2, GPIO.HIGH)
    pwm.ChangeDutyCycle(speed)

def stop():
    pwm.ChangeDutyCycle(0)
    GPIO.output(IN1, GPIO.LOW)
    GPIO.output(IN2, GPIO.LOW)

try:
    forward(70)
    print("전진")
    time.sleep(2)
    backward(70)
    print("후진")
    time.sleep(2)
    stop()
except KeyboardInterrupt:
    pass
finally:
    pwm.stop()
    GPIO.cleanup()

8.7 서보 모터 복습 + 조합 실습

이제 DC 모터와 서보 모터를 함께 연결해볼 수 있습니다. 예를 들어, 라즈베리파이 기반 로봇 자동차에서:

DC 모터: 이동 및 회전
서보 모터: 전방 카메라 방향 조절

코드 조합 예:

# DC 모터 코드와 서보 코드 통합
# 앞서 정의한 forward(), backward() 등 함수 그대로 사용
from servo_control import set_angle  # 서보 제어 함수 import

forward()
set_angle(90)   # 전방 정면 보기
time.sleep(2)

set_angle(45)   # 좌측 회전
time.sleep(1)
stop()

8.8 실습 아이디어

거리 감지 후 DC 모터 정지
일정 거리 이하일 경우 회피 회전
라인트레이서용 모터 기반 플랫폼 제작

8.9 트러블슈팅

문제	원인	해결 방법
모터 작동 안 함	GND 미연결	GND를 모두 공통으로 연결
회전 방향 반대	IN1/IN2 연결 반대	두 핀 연결 변경
전원 부족	USB만 사용	외부 배터리 또는 어댑터 사용

8.10 요약

항목	주요 내용
DC 모터	방향 및 속도 제어 (모터 드라이버 필요)
서보 모터	각도 제어용, PWM 신호 사용
PWM	디지털 제어로 아날로그적 동작 구현
L298N	안정적인 모터 구동을 위한 필수 장치

8.11 다음 단계 예고

DC 모터와 서보 모터 제어를 익혔다면, 다음은 데이터를 주고받는 방법을 배웁니다. 9장에서는 UART 통신을 통해 라즈베리파이와 외부 기기 간 시리얼 데이터를 주고받는 실습을 진행합니다. 직접 메시지를 송수신하며 통신 제어의 기초를 다져보세요.

3부. 통신과 확장 기술

9장. UART 통신 – 직렬 통신 기초와 실습

UART(Universal Asynchronous Receiver/Transmitter)는 가장 기본적인 통신 방식 중 하나로, 두 장치 간에 데이터를 직렬로 주고받는 구조입니다. 라즈베리파이는 UART 핀을 내장하고 있어, 외부 장치(예: 아두이노, GPS 모듈 등)와 손쉽게 통신할 수 있습니다. 이번 장에서는 UART의 개념과 설정법, 그리고 실습 예제를 통해 실시간 데이터 송수신을 구현해보겠습니다.

9.1 UART 통신이란?

직렬 통신 방식: 한 번에 한 비트씩 데이터를 주고받음
비동기 방식: 별도의 클럭 없이 데이터만 송수신
기본 구성:
- TX (Transmit) : 송신선
- RX (Receive) : 수신선
- GND : 공통 접지

9.2 라즈베리파이 UART 핀

핀 번호	기능
6	GND
8	TXD (GPIO14)
10	RXD (GPIO15)

9.3 UART 활성화하기

(1) raspi-config를 통해 UART 활성화

sudo raspi-config

Interface Options → Serial Port
- 로그인 쉘 비활성화
- 시리얼 포트 하드웨어 사용 활성화

재부팅:

sudo reboot

(2) 시리얼 장치 확인

ls /dev/serial*

/dev/serial0 또는 /dev/ttyAMA0로 표시됨

9.4 파이썬에서 UART 사용

라이브러리 설치

pip3 install pyserial

9.5 실습 1: 라즈베리파이 → 아두이노로 데이터 전송

연결 구성

라즈베리파이	아두이노
TX (GPIO14)	RX
RX (GPIO15)	TX
GND	GND

(전압이 다르므로 로직레벨 변환기 권장)

9.6 송신 코드 (raspi_uart_send.py)

import serial
import time

ser = serial.Serial("/dev/serial0", 9600, timeout=1)
time.sleep(2)  # 연결 안정화

try:
    while True:
        ser.write(b"Hello from Raspberry Pi\n")
        print("메시지 전송 완료")
        time.sleep(2)
except KeyboardInterrupt:
    ser.close()
    print("종료합니다.")

9.7 아두이노 수신 예제 (Serial Monitor 확인용)

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

void loop() {
  if (Serial.available()) {
    String msg = Serial.readStringUntil('\n');
    Serial.println("수신: " + msg);
  }
}

9.8 실습 2: 아두이노 → 라즈베리파이 데이터 수신

아두이노에서 센서 값을 시리얼로 전송:

void loop() {
  int value = analogRead(A0);
  Serial.println(value);
  delay(1000);
}

라즈베리파이 수신 코드:

import serial

ser = serial.Serial("/dev/serial0", 9600, timeout=1)

try:
    while True:
        data = ser.readline().decode("utf-8").strip()
        if data:
            print(f"수신된 데이터: {data}")
except KeyboardInterrupt:
    ser.close()
    print("종료합니다.")

9.9 트러블슈팅

문제	원인	해결
메시지 깨짐	통신속도 불일치	양쪽 모두 9600bps 설정
수신 없음	TX/RX 반대로 연결됨	연결 확인
전압 문제	3.3V ↔ 5V 전압차	로직레벨 변환기 사용

9.10 실습 확장 아이디어

라즈베리파이로 GPS 모듈 수신
아두이노와 양방향 채팅 구현
센서값 모니터링 및 웹 대시보드 연동

9.11 요약

항목	내용
UART	비동기 직렬 통신 방식
라즈베리파이 UART 핀	GPIO14 (TX), GPIO15 (RX)
PySerial	파이썬 시리얼 통신 라이브러리
아두이노 연동	센서 데이터 수신, 명령 전송 가능

9.12 다음 단계 예고

다음 장에서는 무선 통신 기술인 블루투스를 활용합니다. 별도의 케이블 없이 데이터를 송수신하고, 스마트폰과 라즈베리파이를 연동하는 실습으로 이동성과 유연성을 높이는 방법을 익혀봅니다.

10장. 블루투스 통신 – HC‑06 및 BLE 실습

이번 장에서는 라즈베리파이와 외부 디바이스(스마트폰, 아두이노 등)가 무선으로 데이터를 주고받는 방법, 즉 블루투스 통신을 다룹니다. 클래식 블루투스 모듈인 HC‑06을 사용한 UART 방식과 **BLE (Bluetooth Low Energy)**를 활용한 저전력 통신 실습을 통해, 케이블 없는 제어 시스템을 구축할 수 있습니다.

10.1 블루투스 통신 개요

HC‑06 (Classic BT): SPP (Serial Port Profile) 기반, 라즈베리파이와 시리얼처럼 통신 가능
BLE: BLE 프로토콜을 통해 저전력, 센서 연결에 적합

10.2 HC‑06 준비하기

(1) HC‑06 핀 구성

VCC → 5 V
GND → GND
TX → Raspberry Pi RX (GPIO15, +3.3 V 입력)
RX → Raspberry Pi TX (GPIO14, 로직 변환 권장)

10.3 HC‑06 설정

기본 속도: 9600bps, 장치 이름: HC-06, PIN: 1234

모듈 파라미터 변경은 AT 명령으로 수행 가능 (HC‑06 전원 끈 후 AT 모드)

10.4 라즈베리파이 HC‑06 페어링

sudo apt update
sudo apt install bluetooth bluez blueman -y
bluetoothctl
# 아래 명령 실행
power on
agent on
scan on
# HC-06이 검색되면:
pair <MAC주소>
trust <MAC주소>
connect <MAC주소>

10.5 UART처럼 블루투스 통신

HC‑06은 페어링 후 /dev/rfcomm0으로 연결됨. 다음과 같이 연동됩니다:

sudo rfcomm bind /dev/rfcomm0 <MAC주소>

10.6 파이썬 코드 (hc06_send.py)

import serial
import time

ser = serial.Serial("/dev/rfcomm0", 9600, timeout=1)
time.sleep(2)

try:
    while True:
        ser.write(b"블루투스로 전송되는 메시지\n")
        print("전송 완료")
        time.sleep(2)
except KeyboardInterrupt:
    ser.close()

10.7 BLE 실습

BLE는 GATT (Generic Attribute Profile) 기반으로 서비스-특성 구조를 가집니다. 실습에서는 bluepy 라이브러리를 활용합니다.

라이브러리 설치

sudo apt install libglib2.0-dev
pip3 install bluepy

10.8 BLE 예제 (ble_notify.py)

from bluepy.btle import Peripheral, UUID

# MAC 주소 대신 BLE디바이스를 검색한 값으로 설정
p = Peripheral("AA:BB:CC:DD:EE:FF")
svc = p.getServiceByUUID(UUID(0x180D))   # 심박수 서비스 예
ch = svc.getCharacteristics(UUID(0x2A37))[0]

while True:
    data = ch.read()
    print("Read:", data)
    if not data:
        break

p.disconnect()

10.9 실습 아이디어

HC‑06 → 스마트폰 문자 제어
BLE 센서 모듈로 온습도 실시간 모니터링
BLE 기반 비콘 탐지 및 위치 서비스 연동

10.10 디버깅 팁

현상	원인	해결
/dev/rfcomm0 생성 안 됨	페어링 실패	bluetoothctl 출력 확인
BLE 모듈 연결 불가	MAC 주소 또는 어드버타이징 설정 오류	주소 정확히 입력, RSSI 확인
BLE 속도 느림	스캔 속도 설정 문제	제한적 하드웨어·코드 개선 필요

10.11 요약

HC‑06은 직렬 통신 방식 블루투스
BLE는 저전력, 정보 중심에 적합
파이썬 라이브러리로 쉽게 통신 제어 가능

10.12 다음 장 예고

이제 물리 제어 방식(모터, 센서)과 통신 방식(Wire 및 Wireless)을 모두 배웠습니다. 다음 장(11장)에서는 SPI 통신을 다루며, 고속 데이터 전송이 필요한 디바이스(ADC, 디스플레이 등)와의 연결 방법을 익힙니다.

11장. SPI 통신 – 고속 데이터 전송 이해

이번 장에서는 라즈베리파이와 외부 장치 간의 고속 데이터 전송 방식인 SPI(Serial Peripheral Interface) 통신을 다룹니다. SPI는 다수의 센서, 디스플레이, 메모리 장치와 빠르고 안정적으로 데이터를 주고받을 수 있어, 실시간성이 중요한 프로젝트에서 자주 사용됩니다. 이번 장에서는 SPI의 이론을 이해하고, MCP3008 아날로그-디지털 변환기(ADC)를 예로 들어 SPI 통신을 실습합니다.

11.1 SPI 통신이란?

동기식 직렬 통신 방식
마스터-슬레이브 구조
클럭 신호(SCLK)에 동기화된 데이터 송수신

기본 구성 핀

이름	설명	라즈베리파이 핀
MISO	슬레이브 → 마스터	GPIO 9 (핀 21)
MOSI	마스터 → 슬레이브	GPIO 10 (핀 19)
SCLK	클럭 신호	GPIO 11 (핀 23)
CE0	슬레이브 선택 (CS)	GPIO 8 (핀 24)
CE1	보조 슬레이브 선택	GPIO 7 (핀 26)

11.2 SPI 활성화하기

sudo raspi-config

Interface Options → SPI → Enable
이후 재부팅 필요

확인:

ls /dev/spi*

출력: /dev/spidev0.0, /dev/spidev0.1

11.3 실습: MCP3008 ADC로 아날로그 값 읽기

(1) MCP3008이란?

10비트 해상도
8채널 입력
SPI 기반 아날로그 → 디지털 변환기

11.4 회로 연결

MCP3008 핀	라즈베리파이 핀
VDD, VREF	3.3V (핀 1)
AGND, DGND	GND (핀 6)
CLK	GPIO 11 (SCLK)
DOUT	GPIO 9 (MISO)
DIN	GPIO 10 (MOSI)
CS/SHDN	GPIO 8 (CE0)
CH0	가변 저항/센서 연결

11.5 라이브러리 설치

pip3 install spidev

11.6 코드 작성 (mcp3008_read.py)

import spidev
import time

spi = spidev.SpiDev()
spi.open(0, 0)  # bus 0, device 0
spi.max_speed_hz = 1350000

def read_channel(channel):
    adc = spi.xfer2([1, (8 + channel) << 4, 0])
    data = ((adc[1] & 3) << 8) + adc[2]
    return data

try:
    while True:
        value = read_channel(0)
        voltage = round(value * 3.3 / 1023, 2)
        print(f"채널 0 값: {value}, 전압: {voltage} V")
        time.sleep(1)
except KeyboardInterrupt:
    spi.close()
    print("종료합니다.")

11.7 실습 확장

조도 센서(CdS) 연결 → 조도 변화 출력
가변 저항 → 실시간 그래프 시각화
채널 8개 동시 읽기 → 다중 센서 통합 처리

11.8 SPI 통신 vs I2C

항목	SPI	I2C
속도	빠름	느림
배선	4개	2개
구조	마스터 ↔ 슬레이브 1:1 또는 1:N	멀티 슬레이브
예시	MCP3008, OLED 디스플레이	LCD, 온습도 센서

11.9 트러블슈팅

문제	해결
값이 0 또는 고정	채널 번호 확인, 센서 연결 점검
SPI 장치 없음	raspi-config에서 SPI 활성화 여부 확인
전압 오차 큼	VREF 핀 전압 공급 정확히 확인

11.10 요약

SPI는 고속 통신 방식으로 센서 및 디스플레이에 적합
MCP3008은 아날로그 입력을 디지털로 변환하여 라즈베리파이에서 읽을 수 있게 함
실시간 데이터 처리와 시각화로 확장 가능

11.11 다음 장 예고

다음 장에서는 I2C 통신을 다루며, 디지털 방식으로 센서나 LCD와 통신하는 방법을 배웁니다. 적은 핀으로 여러 장치를 연결하는 효율적인 방식으로, 복잡한 IoT 프로젝트에 필수적인 기술입니다.

12장. I2C 통신 – 다중 장치 제어 실습

이번 장에서는 라즈베리파이에서 I2C(Inter-Integrated Circuit) 통신을 활용하는 방법을 다룹니다. I2C는 단 두 개의 신호선으로 여러 장치를 동시에 제어할 수 있는 매우 효율적인 통신 방식입니다. 특히 온습도 센서, LCD, RTC(실시간 시계) 등 다양한 디지털 장치를 간편하게 연결할 수 있어, 복잡한 IoT 시스템 구현에 매우 유용합니다.

12.1 I2C 통신 개요

동기식 직렬 통신 방식
마스터(라즈베리파이) ↔ 슬레이브(센서, 디스플레이 등)
SDA (데이터), SCL (클럭) 두 신호선 사용

12.2 I2C 핀 구성 (라즈베리파이)

기능	GPIO 번호	핀 번호
SDA	GPIO 2	3번
SCL	GPIO 3	5번

12.3 I2C 활성화

sudo raspi-config

Interface Options → I2C → Enable
재부팅 후 I2C 장치 확인

ls /dev/i2c-1

12.4 i2c-tools 설치 및 장치 검색

sudo apt install -y i2c-tools
i2cdetect -y 1

연결된 장치의 주소를 7비트 헥사 형식으로 확인 (예: 0x27)

12.5 실습: I2C LCD 16x2 디스플레이

준비물

I2C LCD 모듈 (16x2, 백패널 포함)
점퍼 와이어 (4개)

회로 연결

LCD 핀	라즈베리파이
GND	GND (6번)
VCC	5V (2번)
SDA	GPIO 2 (3번)
SCL	GPIO 3 (5번)

12.6 라이브러리 설치

pip3 install RPLCD

또는 I2C 전용 LCD용 드라이버:

pip3 install RPLCD[i2c]

12.7 코드 작성 (i2c_lcd.py)

from RPLCD.i2c import CharLCD
from time import sleep

lcd = CharLCD('PCF8574', 0x27)  # 주소는 i2cdetect로 확인

lcd.write_string("Hello, Pi!")
sleep(2)
lcd.clear()

lcd.write_string("I2C LCD Test")
sleep(5)
lcd.clear()

12.8 실습: 온습도 센서(DHT12, SHT30 등) + LCD 출력

센서에서 측정한 값을 LCD로 출력
멀티 슬레이브 구성 가능

# 센서 모듈에서 측정한 값 변수: temp, humid
lcd.write_string(f"T:{temp}C H:{humid}%")

12.9 I2C 통신의 장점

장점	설명
배선 간소화	SDA, SCL 두 선만으로 여러 장치 연결
슬레이브 주소 지정	장치 주소별 독립적 통신 가능
다양한 지원 모듈	LCD, RTC, EEPROM, 센서 등 호환 장치 풍부

12.10 트러블슈팅

문제	해결 방법
장치 검색 안 됨	SDA/SCL 연결 상태 확인, 주소 확인
글자 깨짐	LCD 드라이버, 주소 불일치
라이브러리 오류	RPLCD와 i2c-tools 모두 설치 확인

12.11 실습 확장 아이디어

3~4개의 I2C 센서 동시 연결 → 멀티 데이터 수집
LCD에 날짜+시간 출력 (I2C RTC 모듈 연동)
I2C OLED 디스플레이 활용해 GUI 형태 구현

12.12 요약

항목	내용
I2C	SDA/SCL 2선식 통신, 다중 슬레이브 연결
주소 검색	i2cdetect -y 1 명령 사용
대표 장치	LCD, RTC, 온습도 센서 등

12.13 다음 장 예고

다음 장(13장)에서는 웹과의 연동을 다룹니다. Flask 웹 서버를 라즈베리파이에서 구동해, 브라우저로 데이터를 확인하고 제어하는 방법을 실습합니다. ‘인터넷으로 제어되는 센서 시스템’을 직접 구현해보세요.

4부. 웹 & 네트워크 활용

13장. Flask로 간단한 웹 서버 만들기

라즈베리파이는 센서나 모터를 제어하는 데 유용하지만, 데이터를 사용자와 실시간으로 공유하거나 원격에서 제어하려면 웹 서버가 필요합니다. 이번 장에서는 파이썬 기반의 가볍고 유연한 웹 프레임워크인 Flask를 사용해, 라즈베리파이에서 웹 서버를 직접 구동하고 웹 페이지에 데이터를 표시하는 방법을 알아봅니다.

13.1 Flask란?

파이썬으로 만든 경량 웹 프레임워크
HTML 템플릿 지원 (Jinja2)
REST API 구축 가능
IoT 시스템의 UI 제작에 최적

13.2 설치 방법

sudo apt update
pip3 install flask

13.3 기본 구조

Flask 앱은 app.py 하나로 시작할 수 있습니다.

from flask import Flask

app = Flask(__name__)

@app.route('/')
def home():
    return '라즈베리파이 웹 서버 실행 중!'

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

13.4 웹 서버 실행

python3 app.py

브라우저에서 http://라즈베리파이_IP:5000 접속
외부 접속을 허용하려면 host='0.0.0.0'으로 설정

13.5 HTML 템플릿 연동

(1) 디렉토리 구조

project/
├── app.py
└── templates/
    └── index.html

(2) HTML 파일 작성 (templates/index.html)

<!DOCTYPE html>
<html>
<head><title>라즈베리파이 상태</title></head>
<body>
  <h1>센서 데이터</h1>
  <p>온도: {{ temp }}°C</p>
  <p>습도: {{ humid }}%</p>
</body>
</html>

(3) Flask 수정

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/')
def index():
    temp = 25.3
    humid = 48
    return render_template('index.html', temp=temp, humid=humid)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

13.6 실시간 센서 연동

센서 값이 계속 변하도록, 함수를 통해 데이터를 가져오도록 수정합니다.

import random

def get_sensor_data():
    temp = round(random.uniform(20, 30), 1)
    humid = round(random.uniform(40, 60), 1)
    return temp, humid

@app.route('/')
def index():
    temp, humid = get_sensor_data()
    return render_template('index.html', temp=temp, humid=humid)

13.7 스타일링 (간단한 CSS 추가)

<style>
  body { font-family: Arial; background-color: #f8f9fa; padding: 20px; }
  h1 { color: #007bff; }
</style>

13.8 실습 확장: 버튼으로 LED 제어

/on, /off 라우트를 추가
웹에서 클릭 → 라즈베리파이 GPIO 제어

from flask import redirect
import RPi.GPIO as GPIO

GPIO.setmode(GPIO.BCM)
GPIO.setup(17, GPIO.OUT)

@app.route('/on')
def led_on():
    GPIO.output(17, GPIO.HIGH)
    return redirect('/')

@app.route('/off')
def led_off():
    GPIO.output(17, GPIO.LOW)
    return redirect('/')

13.9 보안 주의사항

Flask는 기본적으로 개발용 서버 → 실제 서비스에는 Nginx, Gunicorn 등 사용 권장
외부 접속 시 방화벽 설정 필수
관리자 접근 제어 필요

13.10 요약

항목 설명

Flask	파이썬 기반 웹 서버 프레임워크
기본 포트	5000번, IP:포트 형식으로 접근
실습	센서 데이터 출력, LED 웹 제어

13.11 다음 장 예고

다음 장에서는 실시간 웹 대시보드를 구축합니다. Chart.js 또는 JavaScript를 활용해 웹에서 센서 데이터를 그래프로 시각화하고, 실시간 변화를 감지할 수 있는 IoT 웹 인터페이스를 제작합니다.

14장. 실시간 데이터 웹 대시보드 만들기

센서 데이터를 웹에서 실시간으로 확인할 수 있다면, 라즈베리파이를 훨씬 강력하게 활용할 수 있습니다. 이번 장에서는 Flask와 JavaScript 라이브러리 Chart.js를 사용하여, 실시간 센서 데이터 웹 대시보드를 제작해봅니다. 이는 스마트팜, 환경 모니터링, 홈 자동화 등 다양한 프로젝트에 응용 가능한 핵심 기능입니다.

14.1 프로젝트 구조

dashboard_project/
├── app.py
├── templates/
│   └── index.html
└── static/
    └── chart.js (CDN으로 대체 가능)

14.2 Flask 앱 구성 (app.py)

from flask import Flask, render_template, jsonify
import random
import time

app = Flask(__name__)

def get_sensor_data():
    temp = round(random.uniform(20, 30), 1)
    humid = round(random.uniform(40, 60), 1)
    return {"temp": temp, "humid": humid, "timestamp": time.time()}

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/data')
def data():
    return jsonify(get_sensor_data())

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=True)

14.3 HTML 템플릿 구성 (templates/index.html)

<!DOCTYPE html>
<html>
<head>
  <title>실시간 대시보드</title>
  <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
</head>
<body>
  <h2>온도 & 습도 실시간 차트</h2>
  <canvas id="sensorChart" width="400" height="200"></canvas>

  <script>
    const ctx = document.getElementById('sensorChart').getContext('2d');
    const data = {
      labels: [],
      datasets: [
        {
          label: '온도 (°C)',
          borderColor: 'rgba(255,99,132,1)',
          data: [],
          fill: false
        },
        {
          label: '습도 (%)',
          borderColor: 'rgba(54,162,235,1)',
          data: [],
          fill: false
        }
      ]
    };

    const config = {
      type: 'line',
      data: data,
      options: {
        animation: false,
        scales: {
          x: { title: { display: true, text: '시간' } },
          y: { beginAtZero: true }
        }
      }
    };

    const myChart = new Chart(ctx, config);

    async function fetchData() {
      const response = await fetch('/data');
      const json = await response.json();
      const now = new Date(json.timestamp * 1000).toLocaleTimeString();

      if (data.labels.length > 10) {
        data.labels.shift();
        data.datasets[0].data.shift();
        data.datasets[1].data.shift();
      }

      data.labels.push(now);
      data.datasets[0].data.push(json.temp);
      data.datasets[1].data.push(json.humid);
      myChart.update();
    }

    setInterval(fetchData, 2000);
  </script>
</body>
</html>

14.4 실행 및 접속

python3 app.py

브라우저에서 http://라즈베리파이_IP:5000 접속 → 실시간 그래프 확인

14.5 실제 센서로 연동하기

get_sensor_data() 함수에서 random.uniform() 대신 실제 센서 코드를 삽입:

import Adafruit_DHT

sensor = Adafruit_DHT.DHT11
pin = 4

def get_sensor_data():
    h, t = Adafruit_DHT.read_retry(sensor, pin)
    return {"temp": t, "humid": h, "timestamp": time.time()}

14.6 사용자 UI 개선 아이디어

Bootstrap으로 스타일 향상
센서 경고 알림 (예: 온도 > 30도일 경우 경고 표시)
온도/습도 외 다른 센서도 추가 (CO₂, 조도 등)

14.7 보안 및 성능 고려

항목	권장 방법
외부 접근 제어	비밀번호 기반 접근제어 구현
데이터 보호	HTTPS 적용 (nginx + certbot)
성능 향상	Chart.js 업데이트 주기 조절, 데이터 양 제한

14.8 요약

항목	설명
Flask	웹 서버 및 API 라우팅 담당
Chart.js	실시간 그래프 시각화
REST API	/data 엔드포인트로 JSON 전송

14.9 다음 장 예고

다음 장에서는 라즈베리파이 카메라를 활용해 실시간 영상 스트리밍 및 이미지 처리를 구현합니다. OpenCV를 활용한 얼굴 인식 및 객체 탐지 기능으로 시각적 AI 프로젝트의 기반을 구축해봅니다.

15장. 라즈베리파이 카메라 모듈 설치 및 활용

라즈베리파이는 전용 CSI(Camera Serial Interface) 포트를 통해 고화질 카메라 모듈을 직접 연결할 수 있습니다. 이를 통해 사진 촬영, 영상 녹화, 실시간 스트리밍, 얼굴 인식 등 다양한 영상 기반 프로젝트가 가능해집니다. 이번 장에서는 라즈베리파이 카메라 모듈의 설치와 설정, 기본 촬영 및 OpenCV 연동까지 실습을 진행합니다.

15.1 라즈베리파이 카메라 종류

Camera Module V2: 8MP Sony IMX219 센서 탑재, 가장 널리 사용됨
HQ Camera: 12.3MP, 렌즈 교환 가능
Raspberry Pi 5 전용 MIPI 포트 카메라: 고속 CSI-2 포트 지원

15.2 카메라 장착 방법

라즈베리파이를 종료하고 전원 분리
카메라 모듈의 플랫 케이블을 라즈베리파이의 CSI 포트에 삽입
파란 면이 USB 포트 방향을 향하도록 정렬
고정 클립을 눌러 단단히 연결

15.3 카메라 인터페이스 활성화

sudo raspi-config

Interface Options → Camera → Enable
재부팅 필요

15.4 카메라 테스트

라즈베리파이 OS에서는 기본적으로 libcamera 기반 유틸리티를 사용합니다.

사진 촬영

libcamera-still -o test.jpg

동영상 촬영

libcamera-vid -t 10000 -o test.h264

-t: 촬영 시간 (ms 단위)

15.5 OpenCV와 카메라 연동

(1) OpenCV 설치

pip3 install opencv-python

(2) 실시간 영상 보기

import cv2

cap = cv2.VideoCapture(0)

if not cap.isOpened():
    print("카메라를 열 수 없습니다.")
    exit()

while True:
    ret, frame = cap.read()
    if not ret:
        break
    cv2.imshow('Camera', frame)
    if cv2.waitKey(1) == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

15.6 얼굴 인식 실습

face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')

while True:
    ret, frame = cap.read()
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    faces = face_cascade.detectMultiScale(gray, 1.3, 5)

    for (x,y,w,h) in faces:
        cv2.rectangle(frame,(x,y),(x+w,y+h),(255,0,0),2)

    cv2.imshow('Face Detection', frame)
    if cv2.waitKey(1) == ord('q'):
        break

15.7 실시간 스트리밍 (Flask 사용)

Flask로 MJPEG 스트리밍 서버 구축

from flask import Flask, Response
import cv2

app = Flask(__name__)
cap = cv2.VideoCapture(0)

def gen_frames():
    while True:
        success, frame = cap.read()
        if not success:
            break
        _, buffer = cv2.imencode('.jpg', frame)
        yield (b'--frame\r\n'
               b'Content-Type: image/jpeg\r\n\r\n' + buffer.tobytes() + b'\r\n')

@app.route('/video')
def video():
    return Response(gen_frames(), mimetype='multipart/x-mixed-replace; boundary=frame')

app.run(host='0.0.0.0', port=5000)

접속: http://라즈베리파이_IP:5000/video

15.8 트러블슈팅

문제	해결 방법
"camera not detected"	케이블 재연결, CSI 활성화 확인
OpenCV 카메라 인식 안 됨	VideoCapture(0) 대신 libcamera 연동 확인
영상 끊김	해상도 조절, 프레임 수 낮추기

15.9 실습 확장 아이디어

얼굴 인식 출입 시스템
물체 감지 후 사진 자동 저장
스마트홈용 실시간 감시 시스템

15.10 요약

항목	내용
카메라 설정	CSI 포트 연결, libcamera 사용
OpenCV 연동	cv2.VideoCapture()로 실시간 영상 처리
Flask 스트리밍	MJPEG 방식으로 브라우저 출력 가능

15.11 다음 장 예고

다음 장에서는 외부 API 데이터를 활용해 라즈베리파이에서 날씨 정보, 위치 기반 데이터, 뉴스 등 다양한 데이터를 웹 또는 하드웨어와 연동하는 실습을 진행합니다.

16장. 오픈 API 활용 – 외부 데이터와 라즈베리파이 연동

라즈베리파이는 주변 환경의 데이터를 수집할 뿐 아니라, 인터넷에서 제공하는 **오픈 API(Open API)**를 통해 외부 정보를 활용할 수도 있습니다. 날씨, 뉴스, 공공데이터, 환율 등 다양한 외부 정보를 가져와 웹 대시보드에 표시하거나 LED/스피커 등과 연동할 수 있습니다. 이번 장에서는 오픈 API의 기본 개념과 활용법을 익히고, 실제 데이터와 라즈베리파이를 연동해보는 실습을 진행합니다.

16.1 오픈 API란?

누구나 사용할 수 있도록 공개된 API
일반적으로 HTTP 요청을 통해 JSON 또는 XML 형식으로 데이터 제공
실시간 날씨, 미세먼지, 환율, 뉴스 등 활용 가능

16.2 필요한 라이브러리

pip3 install requests

16.3 예제 1: OpenWeatherMap API로 날씨 정보 가져오기

(1) API 키 발급

https://openweathermap.org 접속 → 회원가입 → API 키 발급

(2) API 요청 URL 예시

http://api.openweathermap.org/data/2.5/weather?q=Seoul&appid=YOUR_API_KEY&units=metric&lang=kr

(3) 파이썬 코드

import requests

API_KEY = 'YOUR_API_KEY'
city = 'Seoul'
url = f'http://api.openweathermap.org/data/2.5/weather?q={city}&appid={API_KEY}&units=metric&lang=kr'

res = requests.get(url)
data = res.json()

temp = data['main']['temp']
desc = data['weather'][0]['description']
print(f"{city}의 현재 온도는 {temp}°C, 날씨: {desc}")

16.4 예제 2: 공공데이터포털 미세먼지 API

(1) 사이트 가입 및 인증키 발급

https://www.data.go.kr

(2) 요청 예시

import urllib.parse

API_KEY = urllib.parse.quote('인증키')
url = f'http://apis.data.go.kr/B552584/ArpltnInforInqireSvc/...&serviceKey={API_KEY}'

XML → JSON으로 변환 필요 시 xmltodict 라이브러리 사용

16.5 실습: 날씨 정보를 LED로 표현하기

온도 > 30도 → 빨간 LED
흐림 또는 비 → 파란 LED
나머지 → 초록 LED

if temp > 30:
    GPIO.output(RED, GPIO.HIGH)
elif '비' in desc or '흐림' in desc:
    GPIO.output(BLUE, GPIO.HIGH)
else:
    GPIO.output(GREEN, GPIO.HIGH)

16.6 Flask 웹 대시보드와 연동

@app.route('/weather')
def weather():
    data = get_weather()
    return render_template('weather.html', temp=data['temp'], desc=data['desc'])

16.7 실시간 뉴스 헤드라인 출력 (네이버 API 등 활용)

url = 'https://openapi.naver.com/v1/search/news.json?...'
headers = {'X-Naver-Client-Id': '...', 'X-Naver-Client-Secret': '...'}
res = requests.get(url, headers=headers)
news_list = res.json()['items']

for news in news_list[:3]:
    print(news['title'])

16.8 API 사용 시 주의사항

항목	설명
API 호출 제한	분당 또는 일일 요청 수 제한 있음
인증키 보호	코드에 직접 노출하지 않도록 .env 파일 사용 권장
응답 오류 처리	예외 처리 및 오류 코드 확인 필요

16.9 실습 확장 아이디어

공공 API 기반 대중교통 도착 정보 표시기
미세먼지 농도에 따른 자동 환기 시스템
날씨 기반 옷차림 추천 웹 서비스

16.10 요약

항목	내용
Open API	HTTP를 통해 외부 데이터 요청
응답 형식	JSON 주로 사용
활용 분야	날씨, 미세먼지, 뉴스, 위치 등 다양

16.11 다음 장 예고

다음 장에서는 영상 기반 인공지능을 다룹니다. OpenCV와 YOLO를 활용한 객체 인식 및 AI 비전 실습을 통해 라즈베리파이에서 직접 AI 프로젝트를 실행하는 방법을 배워봅니다.

5부. 카메라와 영상 처리

17장. OpenCV 활용 – 영상 처리 및 객체 인식 기초

OpenCV(Open Source Computer Vision Library)는 실시간 영상 처리와 컴퓨터 비전 분야에서 가장 널리 사용되는 라이브러리입니다. 라즈베리파이에서도 충분히 사용할 수 있으며, 카메라와 연동해 다양한 인공지능 비전 프로젝트에 적용할 수 있습니다. 이번 장에서는 OpenCV의 기초 사용법부터, 얼굴 인식 및 객체 탐지까지 실습을 통해 익혀보겠습니다.

17.1 OpenCV 설치

pip3 install opencv-python

17.2 기본 이미지 처리

이미지 불러오기 및 표시

import cv2

img = cv2.imread('test.jpg')
cv2.imshow('Image', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

17.3 이미지 변환

흑백 변환

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

이미지 크기 조정

resized = cv2.resize(img, (320, 240))

이미지 저장

cv2.imwrite('result.jpg', resized)

17.4 카메라 영상 출력

cap = cv2.VideoCapture(0)

while True:
    ret, frame = cap.read()
    if not ret:
        break
    cv2.imshow('Live', frame)
    if cv2.waitKey(1) == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

17.5 얼굴 인식 (Haar Cascade)

모델 불러오기

face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')

인식 및 표시

gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5)

for (x, y, w, h) in faces:
    cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 0, 0), 2)

17.6 사람 전체 인식 (HOG 기반)

hog = cv2.HOGDescriptor()
hog.setSVMDetector(cv2.HOGDescriptor_getDefaultPeopleDetector())

(rects, _) = hog.detectMultiScale(frame, winStride=(8, 8))

for (x, y, w, h) in rects:
    cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)

17.7 YOLO와 연동 개요

YOLO(You Only Look Once)는 실시간 객체 탐지에 특화된 딥러닝 모델입니다. OpenCV에서 YOLOv4, YOLOv5 등의 경량화 모델을 통해 라즈베리파이에서도 사용 가능합니다. 다음 장에서 구체적으로 다룹니다.

17.8 실습: 얼굴 인식 출입 알림 시스템

얼굴 감지 → 인식 시 ‘출입 허가됨’ 출력
미인식 시 ‘출입 불가’ 메시지 및 사진 저장

if len(faces) > 0:
    print("출입 허가됨")
else:
    print("출입 불가 - 감지 실패")
    cv2.imwrite('unauthorized.jpg', frame)

17.9 응용 아이디어

사람 수 카운팅 시스템
카메라 방향 자동 제어 (서보와 연동)
스마트 인터폰, 도어벨 연동

17.10 최적화 팁

항목	방법
프레임 저하	해상도 줄이기, FPS 제한
처리 지연	얼굴만 추적 후 감지
성능 향상	YOLO-tiny, TensorRT 등 사용 고려

17.11 요약

항목	설명
OpenCV	실시간 영상 처리 라이브러리
주요 기능	이미지 필터, 얼굴 인식, 객체 탐지
라즈베리파이 연동	카메라와 실시간 분석 가능

17.12 다음 장 예고

다음 장에서는 본격적인 인공지능 기반 객체 인식 기술인 YOLO를 라즈베리파이에서 활용하는 실습을 진행합니다. YOLO를 통해 ‘사람’, ‘고양이’, ‘가방’ 등 다양한 객체를 실시간으로 감지하고 분석하는 AI 비전 프로젝트를 구축해보겠습니다.

6부. 인공지능 프로젝트

18장. YOLO로 실시간 객체 인식하기

YOLO(You Only Look Once)는 이미지 속 여러 객체를 빠르고 정확하게 실시간으로 탐지할 수 있는 대표적인 딥러닝 기반 객체 인식 모델입니다. 이번 장에서는 YOLOv5의 경량화 모델을 중심으로 라즈베리파이에서 실시간 객체 인식을 수행해보고, 이를 활용한 다양한 IoT 응용 아이디어를 소개합니다.

18.1 YOLO란?

객체 인식을 한 번에 처리하는 구조
YOLOv3/v4: 다크넷 기반 (Darknet)
YOLOv5/v6/v8: PyTorch 기반, 속도/정확도 향상
실시간 영상 처리에 적합한 경량화 모델 존재 (YOLOv5n, YOLOv5s)

18.2 YOLOv5 설치 준비

(1) 의존 라이브러리 설치

sudo apt update
sudo apt install python3-pip
pip3 install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cpu
pip3 install opencv-python
pip3 install matplotlib

(2) YOLOv5 저장소 클론

git clone https://github.com/ultralytics/yolov5
cd yolov5
pip3 install -r requirements.txt

18.3 사전 학습 모델 다운로드 및 테스트

python3 detect.py --source 0 --weights yolov5n.pt --conf 0.5

--source 0: 웹캠 (또는 이미지 경로 가능)
--weights: 사전 학습된 YOLOv5 모델 선택 (n=Nano, s=Small, m=Medium 등)
--conf: 인식 신뢰도 기준

18.4 코드 분석 (detect.py 요약)

# detect.py 내부 주요 코드

model = torch.hub.load('ultralytics/yolov5', 'yolov5n', trust_repo=True)
results = model('test.jpg')
results.print()
results.show()

results.xyxy: 객체 위치 정보
results.pandas(): 판다스 테이블로 변환

18.5 실시간 인식 커스터마이징

detect.py를 수정하거나 별도 스크립트로 작성:

import torch
import cv2

model = torch.hub.load('ultralytics/yolov5', 'yolov5n', trust_repo=True)
cap = cv2.VideoCapture(0)

while True:
    ret, frame = cap.read()
    results = model(frame)
    annotated = results.render()[0]
    cv2.imshow('YOLO', annotated)

    if cv2.waitKey(1) == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

18.6 라즈베리파이 성능 최적화 팁

항목	방법
모델 경량화	yolov5n.pt (Nano 모델) 사용
해상도 축소	--img 320 옵션 사용
프레임 간 간격	sleep 또는 프레임 스킵
하드웨어 가속	Coral Edge TPU, Intel NCS2 등 활용 가능

18.7 실습 예제: 사람 감지 시 경고 출력

for det in results.pred[0]:
    cls = int(det[5])
    if model.names[cls] == 'person':
        print("사람 감지됨!")

18.8 응용 아이디어

사람 수 카운터 → 혼잡도 분석
특정 객체 감지 후 LED 또는 알람 작동
CCTV + YOLO 조합으로 스마트 감시 시스템
로봇 시야 구현 (장애물 감지, 방향 판단)

18.9 YOLO 학습 모델 커스터마이징 (고급)

train.py로 사용자 데이터셋 학습 가능
Custom 클래스 정의, .yaml 설정 필요
학습 후 best.pt 모델 사용하여 detect.py에서 인식 가능

18.10 요약

항목	설명
YOLO	실시간 객체 인식용 딥러닝 모델
모델 선택	yolov5n.pt 라즈베리파이에 적합
사용법	detect.py 통해 웹캠/이미지 분석
활용	스마트 감시, 사람 감지, 물체 추적 등

18.11 다음 장 예고

다음 장에서는 라즈베리파이 전용 AIKit을 활용해, 라즈베리파이 5에서 보다 직관적이고 효율적으로 AI 프로젝트를 구현하는 방법을 다룹니다. 비전, 음성, 사물 인식 등 다양한 AI 기능을 라즈베리파이로 직접 구현해봅니다.

19장. 라즈베리파이 AIKit 실전 활용

AIKit은 라즈베리파이에서 인공지능 프로젝트를 손쉽게 구현할 수 있도록 구성된 통합 도구 모음입니다. 음성 인식, 객체 인식, 자연어 처리 등 다양한 AI 기능을 간단한 코드와 인터페이스로 사용할 수 있게 하여, 초보자도 복잡한 AI 시스템을 빠르게 구현할 수 있도록 도와줍니다. 이번 장에서는 라즈베리파이 AIKit의 설치부터 실전 활용까지 단계적으로 실습해봅니다.

19.1 AIKit이란?

라즈베리파이 재단 또는 서드파티에서 제공하는 AI 지원 패키지
사전 학습된 AI 모델과 연동 가능한 편의 API
주요 기능:
- 얼굴 인식, 객체 탐지 (비전)
- 음성 명령 인식 (STT)
- 간단한 대화형 응답 (TTS, NLP)
- Edge AI 연산 지원 (추론용 경량화 모델 포함)

19.2 설치 및 환경 준비

AIKit은 라즈베리파이 OS 최신 버전에서 다음과 같이 설치할 수 있습니다.

sudo apt update
pip3 install aikit

또는 GitHub에서 클론:

git clone https://github.com/raspberrypi/aikit
cd aikit
pip3 install -r requirements.txt

19.3 카메라 기반 객체 감지 예제

from aikit.vision import ObjectDetector
import cv2

detector = ObjectDetector(model='yolov5n')
cap = cv2.VideoCapture(0)

while True:
    ret, frame = cap.read()
    result = detector.detect(frame)

    for obj in result:
        label = obj['label']
        x, y, w, h = obj['box']
        cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)
        cv2.putText(frame, label, (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)

    cv2.imshow("AIKit Object Detection", frame)
    if cv2.waitKey(1) == ord('q'):
        break

19.4 음성 명령 인식 예제

from aikit.voice import VoiceRecognizer

vr = VoiceRecognizer(language='ko')

print("음성 명령을 기다리는 중...")

while True:
    command = vr.listen()
    if command:
        print("인식된 명령:", command)
        if "종료" in command:
            break

19.5 AIKit + GPIO 연동 예제

"불 켜" → GPIO 17 HIGH
"불 꺼" → GPIO 17 LOW

import RPi.GPIO as GPIO
from aikit.voice import VoiceRecognizer

GPIO.setmode(GPIO.BCM)
GPIO.setup(17, GPIO.OUT)

vr = VoiceRecognizer(language='ko')

while True:
    cmd = vr.listen()
    if "켜" in cmd:
        GPIO.output(17, GPIO.HIGH)
    elif "꺼" in cmd:
        GPIO.output(17, GPIO.LOW)
    elif "종료" in cmd:
        break

19.6 AIKit 대화 응답 (챗봇 기능)

from aikit.chat import SimpleChatbot

bot = SimpleChatbot(model='gpt-mini')

while True:
    question = input("질문: ")
    if question == "종료":
        break
    answer = bot.reply(question)
    print("AI:", answer)

19.7 프로젝트 통합 예시: 스마트 안내 시스템

카메라로 사람 감지 → 음성 안내
사용자가 말하면 음성 인식 → 정보 제공
필요시 웹에서 대시보드 제공

19.8 성능 및 모델 최적화 팁

항목	방법
추론 속도	yolov5n 등 경량 모델 사용
음성 인식 정확도	주변 소음 줄이기, 고감도 마이크
처리 분리	비전/음성 분리 쓰레드 처리

19.9 요약

항목	설명
AIKit	라즈베리파이 AI 기능 통합 패키지
주요 기능	객체 인식, 음성 인식, 대화 응답
응용 가능	스마트홈, 안내 시스템, AI 비서 등

19.10 다음 장 예고

이제 AI와 IoT 기능을 모두 경험해보았습니다. 다음 장(20장)에서는 그동안 배운 기술을 종합하여, 실제로 라즈베리파이로 스마트 감시 시스템을 만들어보는 프로젝트를 진행합니다.

6부. 종합 프로젝트

20장. 종합 프로젝트: 스마트 감시 시스템 만들기

이제까지 라즈베리파이로 GPIO 제어, 카메라 영상 처리, 웹 대시보드, AI 인식 등 다양한 기술을 배웠습니다. 이번 장에서는 그 모든 기능을 스마트 감시 시스템이라는 하나의 프로젝트로 통합해 실전형 AIoT 시스템을 만들어봅니다. 이 시스템은 사람을 감지하면 카메라로 녹화하고, 웹 대시보드로 실시간 상태를 표시하며, 필요 시 경고음을 울리는 등의 기능을 가집니다.

20.1 프로젝트 개요

항목	구성 내용
감지 방식	YOLO 기반 사람 감지
반응 장치	카메라 영상 녹화, 부저/LED, 웹 알림
웹 인터페이스	실시간 상태 표시, 영상 스트리밍
추가 기능	얼굴 인식 기반 출입 통제 가능

20.2 준비물

라즈베리파이 5
카메라 모듈 V2 이상
부저, LED (경고용)
브레드보드 및 점퍼선
Flask 웹 서버
YOLOv5n 모델
OpenCV, GPIO, requests 등

20.3 시스템 아키텍처

[Camera] ─▶ [YOLO 감지] ─▶ [조건 판단]
    └────▶ [녹화/캡처 저장]
    └────▶ [GPIO: LED, 부저 ON]
    └────▶ [웹: 상태 표시 / 실시간 영상]

20.4 코드 구성

(1) 사람 감지 및 반응 처리

import cv2
import torch
import RPi.GPIO as GPIO
import time

model = torch.hub.load('ultralytics/yolov5', 'yolov5n', trust_repo=True)
cap = cv2.VideoCapture(0)

GPIO.setmode(GPIO.BCM)
GPIO.setup(17, GPIO.OUT)  # 부저
GPIO.setup(27, GPIO.OUT)  # LED

def detect_person(frame):
    results = model(frame)
    labels = results.names
    for det in results.pred[0]:
        cls = int(det[5])
        if labels[cls] == 'person':
            return True
    return False

while True:
    ret, frame = cap.read()
    if detect_person(frame):
        print("사람 감지됨!")
        GPIO.output(17, GPIO.HIGH)
        GPIO.output(27, GPIO.HIGH)
        cv2.imwrite(f"alert_{int(time.time())}.jpg", frame)
    else:
        GPIO.output(17, GPIO.LOW)
        GPIO.output(27, GPIO.LOW)
    
    time.sleep(0.5)

20.5 웹 대시보드 연동

실시간 영상 스트리밍 (Flask)

from flask import Flask, Response

app = Flask(__name__)

def gen_frames():
    while True:
        ret, frame = cap.read()
        _, buffer = cv2.imencode('.jpg', frame)
        yield (b'--frame\r\n'
               b'Content-Type: image/jpeg\r\n\r\n' + buffer.tobytes() + b'\r\n')

@app.route('/')
def index():
    return "<h1>감시 시스템 작동 중</h1><img src='/video'>"

@app.route('/video')
def video():
    return Response(gen_frames(), mimetype='multipart/x-mixed-replace; boundary=frame')

app.run(host='0.0.0.0', port=5000)

20.6 경고 조건 다양화

야간만 감시 → 시간 조건 추가
특정 구역만 감시 → ROI 설정
일정 횟수 이상 감지 시 경고음

if detect_count >= 3:
    play_buzzer()

20.7 고급 확장 기능

OpenCV + HaarCascade로 얼굴 인식 후 ‘허가된 인물만’ 출입
Telegram Bot으로 알림 전송
Google Sheets 연동으로 로그 기록

20.8 프로젝트 마무리 및 정리

코드를 모듈화하여 유지보수 용이하게 관리
환경 변수 사용으로 API 키 및 민감 정보 보호
웹 대시보드에 센서, 인식 로그, 장치 제어 메뉴 추가

20.9 실전 활용 사례

장소	활용 예시
창고	사람 감지 후 영상 저장 + 알림 전송
사무실	얼굴 인식 출입 기록
매장	방문객 수 자동 카운팅

20.10 요약

기능	구현 방법
사람 감지	YOLOv5n 모델 사용
반응 장치	LED, 부저 GPIO 제어
웹 대시보드	Flask 기반 실시간 영상
알림 기능	사진 저장, API 연동 가능

20.11 다음 단계 제안

이 프로젝트를 바탕으로 다음과 같은 업그레이드가 가능합니다:

스마트홈 허브 연동 (홈브리지, Node-RED)
마이크로서비스 기반 서버 분리
AI 추론 가속기 활용 (Edge TPU, Jetson Nano)

📎 부록 A. 자주 묻는 질문 (FAQ)

Q1. GPIO 핀 번호가 헷갈려요. BOARD vs BCM은 뭔가요?
→ BOARD는 물리적 핀 번호, BCM은 Broadcom 칩셋 기준의 GPIO 번호입니다. 이 책은 BCM을 기준으로 작성했습니다.
Q2. 카메라가 인식되지 않습니다.
→ raspi-config에서 카메라 인터페이스가 활성화되었는지 확인하고, 케이블 연결 상태를 점검하세요.
Q3. 웹 서버가 외부에서 접속되지 않아요.
→ 방화벽 설정과 IP 주소 확인이 필요합니다. 라우터에서 포트포워딩 설정을 확인하세요.
Q4. OpenCV로 영상이 끊깁니다.
→ 해상도를 낮추고, 프레임 처리 간격을 늘리면 성능이 개선됩니다.

🧰 부록 B. 추천 부품 리스트 및 구매처

분류	부품명	비고
기본	라즈베리파이 5 (4GB 이상)	본체
입력	버튼, 초음파 센서 HC-SR04	GPIO 실습
출력	LED, 부저, 서보 모터 SG90	모터 제어
통신	HC-06 블루투스, I2C LCD	시리얼 및 디스플레이
영상	카메라 모듈 V2, USB 카메라	OpenCV/YOLO용
AI 가속기	Coral Edge TPU (USB)	선택 사항

국내 판매처: 코딩팩토리, 제이엘티, 가우넷, 디바이스마트
해외 구매처: Pimoroni, Adafruit, SparkFun

📘 에필로그 – 당신의 첫 AIoT 프로젝트, 어디까지 왔나요?

지금까지 라즈베리파이 5를 중심으로 다양한 기술을 함께 배워왔습니다. 단순한 GPIO 제어부터 시작해, 실시간 영상 처리, 웹 대시보드 구축, 인공지능 모델을 활용한 객체 인식, 그리고 외부 API와의 연동까지. 어느새 여러분은 단순한 코딩을 넘어서 세상을 제어할 수 있는 도구를 익힌 메이커가 되었습니다.
이 책을 통해 여러분이 얻은 지식은 단지 ‘기술’에 머물지 않습니다. 자신의 아이디어를 직접 구현할 수 있는 힘, 문제를 해결할 수 있는 실전 감각, 그리고 무엇보다도 새로운 기술을 두려워하지 않는 자신감을 얻게 되었기를 바랍니다.
앞으로 여러분이 어떤 길을 걷든, 오늘 만든 첫 프로젝트는 분명히 다음 창작의 발판이 되어줄 것입니다. 더 나아가 누군가의 삶을 바꾸는 서비스가 될지도 모릅니다. 이제 여러분의 다음 프로젝트는 무엇인가요?

728x90

사업자 정보 표시펼치기/접기

저작자표시 (새창열림)