2025 ๋ ธ๋ฒจ์์ด ๋ฐํ๋ธ ์๊ฐ๋ฉด์ญ ์งํ ์น๋ฃ์ ์จ๊ฒจ์ง ์ด์ : ‘๋ฉด์ญ ๊ด์ฉ’์ ๋์ฐพ๋ ๊ธฐ์ ์ ์ฌ์ !
์๋์ด๋ ธ ๋๋ ธ: ์์ํ๊ธฐ ์ํ ์ข ํฉ ๊ฐ์ด๋๋ฅผ ๋ง๋ค์ด ๋ณด๊ฒ ์ต๋๋ค
์๋์ด๋ ธ ๋๋ ธ(Arduino Nano)๋ ์ทจ๋ฏธ์, ๋ฉ์ด์ปค, ๊ทธ๋ฆฌ๊ณ ์ ๋ฌธ๊ฐ๋ค ์ฌ์ด์์ ๋งค์ฐ ์ธ๊ธฐ๊ฐ ์๋ ์ํ ๋ง์ดํฌ๋ก์ปจํธ๋กค๋ฌ ๋ณด๋์ ๋๋ค. ์ด ์๊ณ ๊ฐ๋ ฅํ ๋ณด๋๋ ๊ฐ๋จํ LED ๊น๋ฐ์ด๊ธฐ ํ๋ก์ ํธ๋ถํฐ ๋ณต์กํ IoT(์ฌ๋ฌผ ์ธํฐ๋ท) ์ฅ์น๊น์ง ๋ค์ํ ํ์ ์ ์ธ ํ๋ก์ ํธ๋ฅผ ์ฝ๊ฒ ๋ง๋ค ์ ์๋๋ก ํด์ค๋๋ค. ์ด ๊ฐ์ด๋์์๋ ์๋์ด๋ ธ ๋๋ ธ์ ํน์ง, ์์ฉ ๋ถ์ผ, ๊ทธ๋ฆฌ๊ณ ์ฒซ ํ๋ก์ ํธ๋ฅผ ์์ํ๋ ๋ฐฉ๋ฒ์ ๋ํด ์์๋ณด๊ฒ ์ต๋๋ค.
์๋์ด๋ ธ ๋๋ ธ๋ ๋ฌด์์ธ๊ฐ์?
์๋์ด๋ ธ ๋๋ ธ๋ ATmega328P ๋๋ ATmega168 ๋ง์ดํฌ๋ก์ปจํธ๋กค๋ฌ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ ์ํ ๋ธ๋ ๋๋ณด๋ ์นํ์ ์ธ ๋ง์ดํฌ๋ก์ปจํธ๋กค๋ฌ ๋ณด๋์ ๋๋ค. ์ด ๋ณด๋๋ ์ฌ์ฉํ๊ธฐ ์ฌ์ด ์คํ ์์ค ํ๋ซํผ์ธ ์๋์ด๋ ธ ์ ํ๊ตฐ์ ์ผ๋ถ๋ก, ํฌ๊ธฐ๋ ์์ง๋ง ๊ฐ๋ ฅํ ์ฑ๋ฅ์ ์๋ํฉ๋๋ค. ์๋์ด๋ ธ ๋๋ ธ๋ ์๋์ด๋ ธ ์ฐ๋ ธ(Arduino Uno)์ ๋น์ทํ์ง๋ง ํจ์ฌ ์์ ํํ๋ฅผ ๊ฐ์ง๊ณ ์์ด ๊ณต๊ฐ์ด ์ ํ๋ ํ๋ก์ ํธ์ ์ด์์ ์ ๋๋ค.
์๋์ด๋ ธ ๋๋ ธ์ ์ฃผ์ ํน์ง
์ปดํฉํธํ ํฌ๊ธฐ: ์๋์ด๋ ธ ๋๋ ธ๋ 18mm x 45mm ํฌ๊ธฐ๋ก, ๊ฐ์ฅ ์์ ์๋์ด๋ ธ ๋ณด๋ ์ค ํ๋์ด๋ฉฐ, ์ํ ํ๋ก์ ํธ์ ์ ํฉํฉ๋๋ค.
๋ง์ดํฌ๋ก์ปจํธ๋กค๋ฌ: ATmega328P ๋ง์ดํฌ๋ก์ปจํธ๋กค๋ฌ๋ฅผ ์ฌ์ฉํ๋ฉฐ, 32KB์ ํ๋์ ๋ฉ๋ชจ๋ฆฌ, 2KB์ SRAM, 1KB์ EEPROM์ ์ ๊ณตํฉ๋๋ค.
์ ์ ๊ณต๊ธ: ๋๋ ธ๋ USB, 9V ๋ฐฐํฐ๋ฆฌ ๋๋ ์ธ๋ถ ์ ์์ ํตํด ์ ์์ ๊ณต๊ธ๋ฐ์ ์ ์์ผ๋ฉฐ, ์ ๋ ฅ ์ ์ ๋ฒ์๋ 7-12V์ ๋๋ค.
๋์งํธ ๋ฐ ์๋ ๋ก๊ทธ ํ: 14๊ฐ์ ๋์งํธ ์ ์ถ๋ ฅ ํ(๊ทธ ์ค 6๊ฐ๋ PWM ์ถ๋ ฅ์ผ๋ก ์ฌ์ฉ ๊ฐ๋ฅ)๊ณผ 8๊ฐ์ ์๋ ๋ก๊ทธ ์ ๋ ฅ์ ์ ๊ณตํ์ฌ ๋ค์ํ ์ผ์์ ๋ถํ์ ์ฐ๊ฒฐํ ์ ์์ต๋๋ค.
USB ์ฐ๊ฒฐ: ๋๋ ธ๋ ํ๋ก๊ทธ๋๋ฐ ๋ฐ ์ ์์ ์ํด ๋ฏธ๋ USB ๋๋ ๋ง์ดํฌ๋ก USB ํฌํธ๋ฅผ ์ฌ์ฉํฉ๋๋ค(๋ฒ์ ์ ๋ฐ๋ผ ๋ค๋ฆ).
๋ธ๋ ๋๋ณด๋ ์นํ์ฑ: ํ ๊ตฌ์ฑ์ ๋ธ๋ ๋๋ณด๋์ ์ฝ๊ฒ ์ฝ์ ํ ์ ์๋๋ก ์ค๊ณ๋์ด ํ๋กํ ํ์ดํ ๊ณผ์ ์ ๋จ์ํํฉ๋๋ค.
์๋์ด๋ ธ ๋๋ ธ๋ฅผ ์ ํํด์ผ ํ๋ ์ด์
์๋์ด๋ ธ ๋๋ ธ๋ ์ฌ๋ฌ ๊ฐ์ง ์ด์ ๋ก ๋ฉ์ด์ปค๋ค์๊ฒ ์ธ๊ธฐ๊ฐ ์์ต๋๋ค. ์ฒซ์งธ, ์ปดํฉํธํ ํฌ๊ธฐ๋ก ์ธํด ๋ค๋ฅธ ๋ณด๋๊ฐ ๋๋ฌด ํด ์ ์๋ ํ๋ก์ ํธ์ ์ ํฉํฉ๋๋ค. ๋ํ, ๊ฐ๊ฒฉ์ด ์ ๋ ดํ์ฌ ์ ์๊ณตํ๊ณผ ํ๋ก๊ทธ๋๋ฐ์ ์ฒ์ ์์ํ๋ ์ด๋ณด์๋ค์๊ฒ ์ ๊ทผ์ฑ์ด ๋ฐ์ด๋ฉ๋๋ค. ๋๋ ธ๋ ๊ด๋ฒ์ํ ์ฌ์ฉ์ ์ปค๋ฎค๋ํฐ์ ์ง์์ ๋ฐ์ ํ๋ถํ ์๋ฃ, ํํ ๋ฆฌ์ผ, ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ํตํด ์ฝ๊ฒ ์์ํ ์ ์์ผ๋ฉฐ ๋ฌธ์ ํด๊ฒฐ์ ๋์์ด ๋ฉ๋๋ค.
์๋์ด๋ ธ ๋๋ ธ์ ์ผ๋ฐ์ ์ธ ์์ฉ ๋ถ์ผ
์๋์ด๋ ธ ๋๋ ธ์ ๋ค์ฌ๋ค๋ฅํจ์ ๋ค์ํ ์์ฉ ๋ถ์ผ์์ ํ์ฉ๋ ์ ์์ต๋๋ค:
์จ์ด๋ฌ๋ธ ๊ธฐ์ : ์์ ํฌ๊ธฐ๋ก ์ธํด ๋๋ ธ๋ ํผํธ๋์ค ํธ๋์ปค, ์ค๋งํธ ์๋ฅ, ๊ธฐํ ํด๋์ฉ ์ฅ์น์ ๊ฐ์ ์จ์ด๋ฌ๋ธ ์ ์๊ธฐ๊ธฐ์ ์์ฃผ ์ฌ์ฉ๋ฉ๋๋ค.
IoT ํ๋ก์ ํธ: ๋๋ ธ๋ฅผ ์ฌ์ฉํด IoT ์ฅ์น๋ฅผ ๋ง๋ค ์ ์์ผ๋ฉฐ, ์ด๋ฅผ ํตํด ์ธํฐ๋ท์ ํตํด ํ๋ก์ ํธ๋ฅผ ์ฐ๊ฒฐํ๊ณ ์ ์ดํ ์ ์์ต๋๋ค.
๋ก๋ด๊ณตํ: ๋ง์ ์ทจ๋ฏธ์๋ค์ด ๋๋ ธ๋ฅผ ๋ก๋ด์ ๋๋๋ก ์ฌ์ฉํ์ฌ ๋ชจํฐ, ์ผ์ ๋ฐ ๊ธฐํ ๋ถํ์ ์ ์ดํฉ๋๋ค.
ํ ์คํ ๋ฉ์ด์ : ๋๋ ธ๋ ๊ฐ์ ์๋ํ ์์คํ ์ ํตํฉ๋์ด ์กฐ๋ช , ๊ฐ์ ์ ํ ๋ฐ ๊ธฐํ ์ค๋งํธ ํ ์ฅ์น๋ฅผ ์ ์ดํ ์ ์์ต๋๋ค.
๊ต์ก ๋๊ตฌ: ๋๋ ธ๋ ๊ทธ ๋จ์์ฑ๊ณผ ์ ๋ ดํ ๊ฐ๊ฒฉ ๋๋ถ์ ํ์๋ค๊ณผ ์ด๋ณด์๋ค์๊ฒ ์ ์๊ณตํ๊ณผ ํ๋ก๊ทธ๋๋ฐ์ ๊ฐ๋ฅด์น๋ ๋ฐ ๋งค์ฐ ์ ํฉํ ๋๊ตฌ์ ๋๋ค.
์๋์ด๋ ธ ๋๋ ธ๋ก ์์ํ๋ ๋ฐฉ๋ฒ
์๋์ด๋ ธ ๋๋ ธ๋ฅผ ์์ํ๋ ๊ฒ์ ๋ค๋ฅธ ์๋์ด๋ ธ ๋ณด๋๋ฅผ ์ฌ์ฉํ ๊ฒฝํ์ด ์๋ค๋ฉด ๋งค์ฐ ๊ฐ๋จํฉ๋๋ค. ๋ค์์ ์์ํ๊ธฐ ์ํ ๋จ๊ณ๋ณ ๊ฐ์ด๋์ ๋๋ค:
์๋์ด๋ ธ IDE ์ค์น: ์๋์ด๋ ธ ๊ณต์ ์น์ฌ์ดํธ์์ ์๋์ด๋ ธ IDE๋ฅผ ๋ค์ด๋ก๋ํ์ฌ ์ค์นํฉ๋๋ค. ์ด ์ํํธ์จ์ด๋ฅผ ํตํด ๋๋ ธ์ ์ฝ๋๋ฅผ ์์ฑํ๊ณ ์ ๋ก๋ํ ์ ์์ต๋๋ค.
์๋์ด๋ ธ ๋๋ ธ ์ฐ๊ฒฐ: USB ์ผ์ด๋ธ์ ์ฌ์ฉํด ์๋์ด๋ ธ ๋๋ ธ๋ฅผ ์ปดํจํฐ์ ์ฐ๊ฒฐํฉ๋๋ค. ์ด์ ๋ฒ์ ์ ๋๋ ธ๋ฅผ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ FTDI ๋๋ผ์ด๋ฒ๋ฅผ ์ค์นํด์ผ ํ ์๋ ์์ต๋๋ค.
์ฌ๋ฐ๋ฅธ ๋ณด๋ ๋ฐ ํฌํธ ์ ํ: ์๋์ด๋ ธ IDE์์ "๋๊ตฌ" > "๋ณด๋"๋ก ์ด๋ํ์ฌ "Arduino Nano"๋ฅผ ์ ํํฉ๋๋ค. ๊ทธ๋ฐ ๋ค์ "ํฌํธ"์์ ๋๋ ธ๊ฐ ์ฐ๊ฒฐ๋ COM ํฌํธ๋ฅผ ์ ํํฉ๋๋ค.
์ฒซ ๋ฒ์งธ ํ๋ก๊ทธ๋จ ์์ฑ: LED๋ฅผ ๊น๋ฐ์ด๋ ๊ฐ๋จํ ํ๋ก๊ทธ๋จ์ผ๋ก ์์ํด ๋ณด์ธ์. ์ด๋ฅผ ํตํด ๋ชจ๋ ๊ฒ์ด ์ฌ๋ฐ๋ฅด๊ฒ ์๋ํ๋์ง ํ์ธํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด:
ํ๋ก๊ทธ๋จ ์ ๋ก๋: ์๋์ด๋ ธ IDE์์ "์ ๋ก๋" ๋ฒํผ์ ํด๋ฆญํ์ฌ ์ฝ๋๋ฅผ ์ปดํ์ผํ๊ณ ๋๋ ธ์ ์ ๋ก๋ํฉ๋๋ค. ์ฑ๊ณต์ ์ผ๋ก ์ ๋ก๋๋๋ฉด, ์จ๋ณด๋ LED(ํ 13์ ์ฐ๊ฒฐ๋จ)๊ฐ ๊น๋ฐ์ด๊ธฐ ์์ํฉ๋๋ค.
ํ๋ก์ ํธ ํ์ฅ: ์ฒซ ๋ฒ์งธ ํ๋ก๊ทธ๋จ์ ์ฑ๊ณต์ ์ผ๋ก ์ ๋ก๋ํ๊ณ ์คํํ ํ, ๋ค๋ฅธ ์ผ์, ๋ชจํฐ, ๋์คํ๋ ์ด ๋ฑ์ ์ฌ์ฉํด ์คํํด ๋ณด์ธ์. ๊ฐ๋ฅ์ฑ์ ๋ฌด๊ถ๋ฌด์งํฉ๋๋ค!
ํํ ๋ฌธ์ ํด๊ฒฐ ๋ฐฉ๋ฒ
์๋์ด๋ ธ ๋๋ ธ๋ ์ฌ์ฉํ๊ธฐ ์ฝ์ง๋ง, ๋ค์๊ณผ ๊ฐ์ ํํ ๋ฌธ์ ์ ์ง๋ฉดํ ์ ์์ต๋๋ค:
๋๋ผ์ด๋ฒ ๋ฌธ์ : ์ปดํจํฐ๊ฐ ๋๋ ธ๋ฅผ ์ธ์ํ์ง ๋ชปํ๋ ๊ฒฝ์ฐ, ํนํ ์ด์ ๋ชจ๋ธ์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ์๋ ์ฌ๋ฐ๋ฅธ ๋๋ผ์ด๋ฒ๊ฐ ์ค์น๋์ด ์๋์ง ํ์ธํ์ธ์.
ํฌํธ ํ์ ์ ๋จ: ๋๋๋ก Arduino IDE์์ COM ํฌํธ๊ฐ ๋ํ๋์ง ์์ ์ ์์ต๋๋ค. ์ด ๊ฒฝ์ฐ ๋๋ ธ๋ฅผ ๋ค์ ์ฐ๊ฒฐํ๊ฑฐ๋ ๋ค๋ฅธ USB ์ผ์ด๋ธ์ ์ฌ์ฉํด ๋ณด์ธ์.
์ ๋ก๋ ์ค๋ฅ: ์ ๋ก๋ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ฉด ์ฌ๋ฐ๋ฅธ ๋ณด๋์ ํฌํธ๋ฅผ ์ ํํ๋์ง ํ์ธํ์ธ์. ๋ํ ์ ๋ก๋ ์ค์ ๋๋ ธ์ RX ๋ฐ TX ํ์ ๋ค๋ฅธ ์ฅ์น๊ฐ ์ฐ๊ฒฐ๋์ด ์์ง ์์์ง ํ์ธํ์ธ์.
๊ฒฐ๋ก
์๋์ด๋ ธ ๋๋ ธ๋ ๋ฉ์ด์ปค, ์ทจ๋ฏธ์, ์ ๋ฌธ๊ฐ๋ค์๊ฒ ๋ง์ ๊ฐ๋ฅ์ฑ์ ์ด์ด์ฃผ๋ ๊ฐ๋ ฅํ๊ณ ๋ค์ฌ๋ค๋ฅํ ๋ง์ดํฌ๋ก์ปจํธ๋กค๋ฌ ๋ณด๋์ ๋๋ค. ๊ฐ๋จํ ํ๋ก์ ํธ๋ถํฐ ๋ณต์กํ ์์คํ ๊น์ง ๋๋ ธ๋ ํฌ๊ธฐ, ์ฑ๋ฅ, ์ฌ์ฉ์ ์ฉ์ด์ฑ์ ์๋ฒฝํ๊ฒ ๊ท ํ ์ก๊ณ ์์ต๋๋ค. ์ฌ๋ฐ๋ฅธ ๋๊ตฌ์ ์ง์์ ๊ฐ์ถ๊ณ ์๋ค๋ฉด, ์ ์๊ณตํ๊ณผ ํ๋ก๊ทธ๋๋ฐ์ ํฅ๋ฏธ์ง์งํ ์ธ๊ณ์์ ์ฌ๋ฌ๋ถ์ ์์ด๋์ด๋ฅผ ์คํํ ์ ์์ต๋๋ค.
๋ฌผ๋ก ์๋์ด๋ ธ ๋๋ ธ๊ฐ ์ค๋๋๊ธด ํ์ง๋ง ์ฌํ์ ๋ค๋ฅธ pcb๋ฅผ ๋๋ฉด์ ์์ฑํ๋ ค๋ฉด ์ฌ๋ฌ๋ชจ๋ก ์ ๊ณต์ง์์ด ํ์ํ๊ธฐ์ ๋ค๋ฅธ ๊ฑด ์ฌ์ณ๋๊ณ ์ค๋ก์ง ์๋์ด๋ ธ ๋๋ ธ์๋ง ์ง์คํ๊ณ ์ฌ๋ฌ๊ฐ์ง ๋ค๋ฅธ ๋น์ทํ ๋ณด๋๋ค์ ๋ค๋ฃจ๋ ๊ฑด ๋ค์๊ธฐํ์ ํด๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.
c์ธ์ด๊ฐ ๋ณด์์ ์ทจ์ฝํ์ฌ ์ฌ์ฉ์ ์์ ํ๋ผ๊ณ ํ๋๋ฐ ๋ณดํต ์๋์ด๋ ธ๋ c์ธ์ด๋ก ๋ง๋๋๊ฒ ๋ณดํธ์ ์ธ๊ฒ ๊ฐ์ต๋๋ค
๋งจ์ฒ์ ์ด ๋ชจ๋๋ก ๋ง๋ค์ด๋ณธ ๋ก๋ด์ ํ๋ก ๊ฐ ํ๋ ๋ฐ๋์ ์ ํํ ๊ตฌ๋์ ์คํจํ์๋ค ๊ทธ๋ฌ๋ ์์ ๊ณต๊ฐ์ ๋ค์ด๊ฐ ๋ชจ๋๋ก๋ ๊ด์ฐฎ์ง์๋ ์ถ๋ค.
=====================
์๋ณด๋ชจํฐ๋ ์กฐ๊ทธ๋ง๋์ผ๋ก ๊ตฌ๋น๋ฅผ ํ๋๋ฐ ๋ธ๋ก์ฝ๋ฉ์ธ๊ฐ ํ๋ํ๋ก๊ทธ๋จ์ ์จ์ํ๋๋ฐ ์๋์์ง๊ฐ ์ข
์ค๋๋์ ๋ ์ง๋ชจ๋ฅด๊ฒ ์ต๋๋ค
์๋์ด๋
ธ์ฐ๋
ธ1๊ฐ ,5ํ์กฐ์ด์คํฑ 2๊ฐ
์๋์ด๋
ธ์ฐ๋
ธ1๊ฐ ,5ํ์กฐ์ด์คํฑ 2๊ฐ ,sg-90์๋ณด๋ชจํฐ4๊ฐ 18650๋ฐฐํฐ๋ฆฌ 2๊ฐ์ง๋ ฌ ์กฐํฉ์ผ๋ก 4dof ๋ก๋ด์์
๋ง๋ค๊บผ์ผ ์ฝ๋๋ฅผ ๊ฐ๊ฒฐํ๊ณ ์กฐ์ข
์ด ์๋๋๋ก ์ ํด์ ์์ธํ ์ค๋ช
๋ ํด์ค
๋ฌผ๊ฑด ๋ชฉ๋ก๊ณผ ์ํ๋ ๋ชฉํ๋ฅผ ์ ์ ๋ฆฌํด์ฃผ์
จ๋ค์. 4DOF ๋ก๋ด ์์ ๋ง๋ค๊ธฐ ์ํด ํ์ํ ์ฅ๋น๋ค๊ณผ ์ฝ๋์ ๋ํด
์์ธํ ์๋ดํด ๋๋ฆฌ๊ฒ ์ต๋๋ค.
๋จผ์ ํ์ํ ๋ฌผํ๋ค์ ์ดํด๋ณด๊ฒ ์ต๋๋ค:
- ์๋์ด๋
ธ ์ฐ๋
ธ (Arduino Uno): ๋ก๋ด ์์ ์ ์ด๋ฅผ ์ํ ์ฃผ ์ปจํธ๋กค๋ฌ๋ก ์ฌ์ฉ๋ฉ๋๋ค.
- 5ํ ์กฐ์ด์คํฑ 2๊ฐ: ๋ก๋ด ์์ ๋์์ ์กฐ์ข
ํ๊ธฐ ์ํด ์ฌ์ฉ๋ฉ๋๋ค. ์กฐ์ข
๊ธฐ๋ก ์์ง์์ ๊ฐ์งํ๊ณ
- ์๋์ด๋
ธ๋ก ์ ํธ๋ฅผ ์ ๋ฌํฉ๋๋ค.
- SG-90 ์๋ณด๋ชจํฐ 4๊ฐ: ๋ก๋ด ์์ ๊ฐ ๊ด์ ์ ์์ง์ด๋ ๋ฐ ์ฌ์ฉ๋๋ ๋ชจํฐ์
๋๋ค.
- ๊ด์ ์ ์์ง์์ ์ ์ดํ์ฌ ๋ก๋ด ์์ด ์ํ๋ ์์ธ๋ฅผ ์ทจํ ์ ์์ต๋๋ค.
- 18650 ๋ฐฐํฐ๋ฆฌ 2๊ฐ: ์๋์ด๋
ธ์ ์๋ณด๋ชจํฐ์ ์ ์์ ๊ณต๊ธํ๊ธฐ ์ํด ์ฌ์ฉ๋ฉ๋๋ค.
- ๋ฐฐํฐ๋ฆฌ๋ฅผ ์ง๋ ฌ๋ก ์ฐ๊ฒฐํ์ฌ ์ ์์ ์ฆ๊ฐ์ํฌ ์ ์์ต๋๋ค.
์ด์ ์ฝ๋๋ฅผ ๊ฐ๊ฒฐํ๊ณ ์กฐ์ข
์ด ์๋๋๋ก ์ค๊ณํ๋ ๋ฐฉ๋ฒ์ ๋ํด ์ค๋ช
๋๋ฆฌ๊ฒ ์ต๋๋ค.
- ์๋์ด๋
ธ ์ฐ๋
ธ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ค์น: ๋จผ์ ์๋์ด๋
ธ ์ฐ๋
ธ์ SG-90 ์๋ณด๋ชจํฐ๋ฅผ ์ ์ดํ๊ธฐ
- ์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ค์นํด์ผ ํฉ๋๋ค. Arduino IDE๋ฅผ ์ด๊ณ "Sketch" ๋ฉ๋ด์์
- "Include Library"๋ฅผ ์ ํํ ํ "Servo"๋ฅผ ๊ฒ์ํ์ฌ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ค์นํ์ธ์.
- ํ ์ค์ : ์กฐ์ด์คํฑ๊ณผ ์๋ณด๋ชจํฐ๋ฅผ ์ฐ๊ฒฐํ๊ธฐ ์ํด ํ์ ์ค์ ํด์ผ ํฉ๋๋ค.
- ์กฐ์ด์คํฑ์ X์ถ๊ณผ Y์ถ์ ์๋ ๋ก๊ทธ ์
๋ ฅ์ผ๋ก, ์๋ณด๋ชจํฐ๋ ๋์งํธ ์ถ๋ ฅ์ผ๋ก ์ฐ๊ฒฐํฉ๋๋ค.
- ์๋ฅผ ๋ค์ด, ์กฐ์ด์คํฑ X์ถ์ ์๋ ๋ก๊ทธ ํ A0์ ์ฐ๊ฒฐํ๊ณ , Y์ถ์ A1์ ์ฐ๊ฒฐํ๊ณ ,
- ์๋ณด๋ชจํฐ๋ ๋์งํธ ํ 9, 10, 11, 12์ ์ฐ๊ฒฐํ๋ค๊ณ ๊ฐ์ ํด๋ด
์๋ค.
- ์ฝ๋ ์์ฑ: ์๋์ ์์ ์ฝ๋๋ฅผ ์ ๊ณตํด ๋๋ฆฌ๊ฒ ์ต๋๋ค. ์ด ์ฝ๋๋ ์กฐ์ด์คํฑ์ ์์ง์์ ๊ฐ์งํ๊ณ
- ์๋ณด๋ชจํฐ๋ฅผ ์ ์ดํ๋ ๊ธฐ๋ณธ์ ์ธ ์์ ์
๋๋ค. ์ด ์ฝ๋๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ์ํ๋ ๋์์ ์ถ๊ฐํ๊ณ ์์ ํด
- ๋๊ฐ ์ ์์ต๋๋ค.
cpp
#include <Servo.h>
Servo servo1;
Servo servo2;
Servo servo3;
Servo servo4;
int joystickXPin = A0;
int joystickYPin = A1;
int servo1Pin = 9;
int servo2Pin = 10;
int servo3Pin = 11;
int servo4Pin = 12;
void setup() {
servo1.attach(servo1Pin);
servo2.attach(servo2Pin);
servo3.attach(servo3Pin);
servo4.attach(servo4Pin);
}
void loop() {
int joystickXValue = analogRead(joystickXPin);
int joystickYValue = analogRead(joystickYPin);
int servo1Angle = map(joystickXValue, 0, 1023, 0, 180);
int servo2Angle = map(joystickYValue, 0, 1023, 0, 180);
servo1.write(servo1Angle);
servo2.write(servo2Angle);
// ์ถ๊ฐ์ ์ธ ์๋ณด๋ชจํฐ์ ๋์์ ์ ์ดํ๋ ์ฝ๋๋ฅผ ์์ฑํ์ธ์.
delay(10);
}
์์ ์์ ์ฝ๋์์๋ ์กฐ์ด์คํฑ์
์นด๋ฉ๋ผ๋ชจ๋์ด ํ๋ ๋ฌ๋ ธ์ผ๋ฉด ์ข๊ฒ ๊ณ ์นด๋ฉ๋ผ๋ชจ๋์ ์ฌ๋ฌผ์ธ์ํ๋ ์ฝ๋๋ฅผ ๋ฃ์ด์ ๋ผ์ฆ๋ฒ ๋ฆฌํ์ด๋ก
๋ง๋ค์ ์๋ ์กฐํฉ์์ฝ๋๋ก ๋ค์์์ฑํด์ค ๊ฐ๊ฒฐํ๊ฒ
๋ฌผ๊ฑด์ ์ธ์ํ๋ ์ฝ๋๋ฅผ ์ถ๊ฐํ ๋ผ์ฆ๋ฒ ๋ฆฌ ํ์ด์ ๊ฐ๊ฒฐํ ์กฐํฉ ์ฝ๋๋ฅผ ์์ฑํด ๋๋ฆฌ๊ฒ ์ต๋๋ค.
์๋์ ์ฝ๋๋ฅผ ์ฐธ๊ณ ํด์ฃผ์ธ์.
python
import cv2
# ์นด๋ฉ๋ผ ๋ชจ๋ ์ด๊ธฐํ
camera = cv2.VideoCapture(0)
# ์ฌ๋ฌผ ์ธ์์ ์ํ ํ์ต๋ ๋ชจ๋ธ ๋ก๋
model = cv2.dnn.readNetFromTensorflow('path_to_model.pb', 'path_to_config.pbtxt')
while True:
# ์นด๋ฉ๋ผ๋ก๋ถํฐ ํ๋ ์ ์ฝ๊ธฐ
ret, frame = camera.read()
# ํ๋ ์ ํฌ๊ธฐ ๋ณ๊ฒฝ
frame = cv2.resize(frame, (300, 300))
# ์ด๋ฏธ์ง ์ ์ฒ๋ฆฌ
blob = cv2.dnn.blobFromImage(frame, size=(300, 300), swapRB=True, crop=False)
# ๋ชจ๋ธ์ ํตํ ์ถ๋ก
model.setInput(blob)
output = model.forward()
# ์ถ๋ก ๊ฒฐ๊ณผ๋ฅผ ํ๋ฉด์ ํ์
for detection in output[0, 0, :, :]:
confidence = detection[2]
if confidence > 0.5:
class_id = int(detection[1])
class_name = 'ํด๋์ค๋ช
' # ํด๋์ค๋ช
์ ํด๋นํ๋ ๋ฌผ์ฒด ์ด๋ฆ์ผ๋ก ๋ณ๊ฒฝํด์ฃผ์ธ์.
x = int(detection[3] * frame.shape[1])
y = int(detection[4] * frame.shape[0])
w = int(detection[5] * frame.shape[1])
h = int(detection[6] * frame.shape[0])
# ์ฌ๊ฐํ ๊ทธ๋ฆฌ๊ธฐ
cv2.rectangle(frame, (x, y), (w, h), (255, 0, 0), 2)
# ํด๋์ค๋ช
๊ณผ ์ ๋ขฐ๋ ํ์
cv2.putText(frame, f'{class_name}: {confidence:.2f}', (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (255, 0, 0), 2)
# ํ๋ฉด์ ํ๋ ์ ์ถ๋ ฅ
cv2.imshow('Object Detection', frame)
# 'q' ํค๋ฅผ ๋๋ฅด๋ฉด ์ข
๋ฃ
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# ๋ฆฌ์์ค ํด์
camera.release()
cv2.destroyAllWindows()
์์ ์ฝ๋๋ OpenCV์ DNN(Darknet Neural Network)์ ์ฌ์ฉํ์ฌ ์ฌ๋ฌผ ์ธ์์ ๊ตฌํํ ์์์
๋๋ค.
๋ชจ๋ธ์ ์ฌ์ฉํ๊ธฐ ์ํด path_to_model.pb์ path_to_config.pbtxt์ ํด๋นํ๋ ๊ฒฝ๋ก๋ฅผ ์ค์ ๋ชจ๋ธ ํ์ผ๊ณผ
๊ตฌ์ฑ ํ์ผ์ ๊ฒฝ๋ก๋ก ๋ณ๊ฒฝํด์ฃผ์
์ผ ํฉ๋๋ค. ๋ํ, ํด๋์ค๋ช
๋ถ๋ถ๋ ํด๋นํ๋ ๋ฌผ์ฒด์ ์ด๋ฆ์ผ๋ก
๋ณ๊ฒฝํด์ฃผ์
์ผ ํฉ๋๋ค.
์ฝ๋๋ฅผ ์คํํ๋ฉด ๋ผ์ฆ๋ฒ ๋ฆฌ ํ์ด์ ์นด๋ฉ๋ผ ๋ชจ๋๋ก๋ถํฐ ์์์ ์ฝ์ด์ ์ฌ๋ฌผ์ ์ธ์ํ๊ณ , ์ธ์๋
์ฌ๋ฌผ์ ์ฌ๊ฐํ์ผ๋ก ํ์ํ๊ณ ํด๋์ค๋ช
๊ณผ ์ ๋ขฐ๋๋ฅผ ํ๋ฉด์ ํ์ํฉ๋๋ค. 'q' ํค๋ฅผ ๋๋ฅด๋ฉด ํ๋ก๊ทธ๋จ์ด ์ข
๋ฃ๋ฉ๋๋ค.
์ถ๊ฐ๋ก ํ์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋ชจ๋ธ ํ์ผ์ ์ค๋นํ์๊ณ , ์ฝ๋ ๋ด์ ๊ฒฝ๋ก๋ฅผ ์ฌ๋ฐ๋ฅด๊ฒ ์ค์ ํด์ฃผ์๊ธฐ ๋ฐ๋๋๋ค.
ํ์ด์ฌ์ผ๋ก ์นด๋ฉ๋ผ ์ฌ๋ฌผ์ธ์ํ๋ ์ฝ๋ ์์ฑํด์ค
๋ฌผ์ฒด๋ฅผ ์ธ์ํ๋ ์ฝ๋๋ฅผ ํ์ด์ฌ์ผ๋ก ์์ฑํด ๋๋ฆฌ๊ฒ ์ต๋๋ค. ์๋์ ์ฝ๋๋ฅผ ์ฐธ๊ณ ํด์ฃผ์ธ์.
python
import cv2
# ์ฌ๋ฌผ ์ธ์์ ์ํ ํ์ต๋ ๋ชจ๋ธ ๋ก๋
net = cv2.dnn.readNetFromTensorflow('path_to_model.pb', 'path_to_config.pbtxt')
# ์นด๋ฉ๋ผ ๋ชจ๋ ์ด๊ธฐํ
cap = cv2.VideoCapture(0)
while True:
# ์นด๋ฉ๋ผ๋ก๋ถํฐ ํ๋ ์ ์ฝ๊ธฐ
ret, frame = cap.read()
# ํ๋ ์ ํฌ๊ธฐ ๋ณ๊ฒฝ
frame = cv2.resize(frame, (300, 300))
# ์ด๋ฏธ์ง ์ ์ฒ๋ฆฌ
blob = cv2.dnn.blobFromImage(frame, size=(300, 300), swapRB=True, crop=False)
# ๋ชจ๋ธ์ ํตํ ์ถ๋ก
net.setInput(blob)
detections = net.forward()
# ์ถ๋ก ๊ฒฐ๊ณผ๋ฅผ ํ๋ฉด์ ํ์
for i in range(detections.shape[2]):
confidence = detections[0, 0, i, 2]
if confidence > 0.5:
class_id = int(detections[0, 0, i, 1])
class_name = 'ํด๋์ค๋ช
' # ํด๋์ค๋ช
์ ํด๋นํ๋ ๋ฌผ์ฒด ์ด๋ฆ์ผ๋ก ๋ณ๊ฒฝํด์ฃผ์ธ์.
x = int(detections[0, 0, i, 3] * frame.shape[1])
y = int(detections[0, 0, i, 4] * frame.shape[0])
w = int(detections[0, 0, i, 5] * frame.shape[1])
h = int(detections[0, 0, i, 6] * frame.shape[0])
# ์ฌ๊ฐํ ๊ทธ๋ฆฌ๊ธฐ
cv2.rectangle(frame, (x, y), (w, h), (255, 0, 0), 2)
# ํด๋์ค๋ช
๊ณผ ์ ๋ขฐ๋ ํ์
cv2.putText(frame, f'{class_name}: {confidence:.2f}', (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (255, 0, 0), 2)
# ํ๋ฉด์ ํ๋ ์ ์ถ๋ ฅ
cv2.imshow('Object Detection', frame)
# 'q' ํค๋ฅผ ๋๋ฅด๋ฉด ์ข
๋ฃ
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# ๋ฆฌ์์ค ํด์
cap.release()
cv2.destroyAllWindows()
์์ ์ฝ๋๋ OpenCV์ DNN(Darknet Neural Network)์ ์ฌ์ฉํ์ฌ ์ฌ๋ฌผ ์ธ์์ ๊ตฌํํ ์์์
๋๋ค. ๋ชจ๋ธ์
์ฌ์ฉํ๊ธฐ ์ํด path_to_model.pb์ path_to_config.pbtxt์ ํด๋นํ๋ ๊ฒฝ๋ก๋ฅผ ์ค์ ๋ชจ๋ธ ํ์ผ๊ณผ ๊ตฌ์ฑ ํ์ผ์
๊ฒฝ๋ก๋ก ๋ณ๊ฒฝํด์ฃผ์
์ผ ํฉ๋๋ค. ๋ํ, ํด๋์ค๋ช
๋ถ๋ถ๋ ํด๋นํ๋ ๋ฌผ์ฒด์ ์ด๋ฆ์ผ๋ก ๋ณ๊ฒฝํด์ฃผ์
์ผ ํฉ๋๋ค.
์ฝ๋๋ฅผ ์คํํ๋ฉด ์นด๋ฉ๋ผ๋ก๋ถํฐ ์์์ ์ฝ์ด์ ์ฌ๋ฌผ์ ์ธ์ํ๊ณ , ์ธ์๋ ์ฌ๋ฌผ์ ์ฌ๊ฐํ์ผ๋ก ํ์ํ๊ณ
ํด๋์ค๋ช
๊ณผ ์ ๋ขฐ๋๋ฅผ ํ๋ฉด์ ํ์ํฉ๋๋ค. 'q' ํค๋ฅผ ๋๋ฅด๋ฉด ํ๋ก๊ทธ๋จ์ด ์ข
๋ฃ๋ฉ๋๋ค.
์ถ๊ฐ๋ก ํ์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋ชจ๋ธ ํ์ผ์ ์ค๋นํ์๊ณ , ์ฝ๋ ๋ด์ ๊ฒฝ๋ก๋ฅผ ์ฌ๋ฐ๋ฅด๊ฒ ์ค์ ํด์ฃผ์๊ธฐ ๋ฐ๋๋๋ค.
์ค์ ํ๋ ํ์ฌ์ฌ์ฉ ํ๊ณ ์๋์ฌ๋ฌผ์ธ์ ํ๋ ๋ก๋ด์์ ๋ง๋ค๋ ๋ฐ์๋์ผ๋ก ์ฌ๋์ด ์ค๋งํธํฐํ๋ฉด์ ๋ธ๋ฃจํฌ์ค๋ก
๋ณด๋ฉด
๋ก๋ด ํ์ด ๋ฐ์๋์ผ๋ก ์ค๋งํธํฐ ํ๋ฉด์ ๋ธ๋ฃจํฌ์ค๋ก ์ธ์ํ๋ ๋ฐฉ๋ฒ์ ๋ํด ์ค๋ช
ํด ๋๋ฆฌ๊ฒ ์ต๋๋ค.
- ๋ธ๋ฃจํฌ์ค ํต์ ์ค์ :
- ์ค๋งํธํฐ๊ณผ ๋ก๋ด ํ ๊ฐ์ ๋ธ๋ฃจํฌ์ค ํต์ ์ ์ค์ ํด์ผ ํฉ๋๋ค. ์ค๋งํธํฐ์์ ๋ก๋ด ํ๋ก
- ๋ฐ์ดํฐ๋ฅผ ์ ์กํ๊ธฐ ์ํด ๋ธ๋ฃจํฌ์ค ๋ชจ๋์ ์ฌ์ฉํฉ๋๋ค. ๋ก๋ด ํ๋ ๋ธ๋ฃจํฌ์ค ํต์ ์ ์์ ํ ์
- ์๋ ๋ชจ๋์ ์ฅ์ฐฉํด์ผ ํฉ๋๋ค.
- ์ค๋งํธํฐ ํ๋ฉด ์ธ์:
- ์ค๋งํธํฐ ํ๋ฉด์ ์ธ์ํ๊ธฐ ์ํด ์ปดํจํฐ ๋น์ ๊ธฐ์ ์ ํ์ฉํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด,
- OpenCV ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํ์ฌ ํ๋ฉด์์ ํน์ ๊ฐ์ฒด ๋๋ ํจํด์ ์ธ์ํ ์ ์์ต๋๋ค.
- ์ด๋ฅผ ์ํด ์ค๋งํธํฐ์ ์นด๋ฉ๋ผ๋ก๋ถํฐ ์์์ ๊ฐ์ ธ์์ ์ด๋ฏธ์ง ์ฒ๋ฆฌ ๋ฐ ๊ฐ์ฒด ๊ฒ์ถ์ ์ํํฉ๋๋ค.
- ๊ฐ์ฒด ๊ฒ์ถ ๋ฐ ์ถ์ :
- OpenCV๋ฅผ ์ฌ์ฉํ์ฌ ์ค๋งํธํฐ ํ๋ฉด์์ ์ํ๋ ๊ฐ์ฒด๋ฅผ ๊ฒ์ถํ๊ณ ์ถ์ ํ ์ ์์ต๋๋ค.
- ๊ฐ์ฒด ๊ฒ์ถ์ ์ํด ์ฌ์ ์ ํ์ต๋ ๋ชจ๋ธ์ ์ฌ์ฉํ๊ฑฐ๋, ์ปฌ๋ฌ ๋๋ ํน์ ํจํด์ ๊ธฐ๋ฐ์ผ๋ก
- ๊ฐ์ฒด๋ฅผ ๊ฒ์ถํ ์ ์์ต๋๋ค. ๊ฒ์ถ๋ ๊ฐ์ฒด์ ์์น ์ ๋ณด๋ฅผ ํ์ฉํ์ฌ ๋ก๋ด ํ์ ๋์์
- ์ ์ดํ ์ ์์ต๋๋ค.
- ๋ธ๋ฃจํฌ์ค ๋ฐ์ดํฐ ์ ์ก:
- ์ค๋งํธํฐ์์ ์ธ์๋ ๊ฐ์ฒด์ ์์น ์ ๋ณด๋ฅผ ๋ธ๋ฃจํฌ์ค๋ฅผ ํตํด ๋ก๋ด ํ๋ก ์ ์กํฉ๋๋ค.
- ์ด๋ฅผ ์ํด ๋ธ๋ฃจํฌ์ค ํต์ ์ ์ํํ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํ๊ณ , ๊ฐ์ฒด์ ์์น ์ ๋ณด๋ฅผ
- ์ ์ ํ ํ์์ผ๋ก ํจํทํํ์ฌ ์ ์กํฉ๋๋ค.
- ๋ก๋ด ํ ์ ์ด:
- ๋ก๋ด ํ์ ์ ์ก๋ ๊ฐ์ฒด์ ์์น ์ ๋ณด๋ฅผ ์์ ํ์ฌ ํด๋น ์์น๋ก ์ด๋ํ๊ฑฐ๋ ํน์ ๋์์ ์ํํฉ๋๋ค.
- ๋ก๋ด ํ์ ์ ์ด๋ ๋ก๋ด ํ ์ ์ด ์์คํ
์ ๋ง๊ฒ ํ๋ก๊ทธ๋๋ฐ๋์ด์ผ ํฉ๋๋ค.
์์ ๊ณผ์ ์ ๋ฐ์๋์ผ๋ก ์ค๋งํธํฐ ํ๋ฉด์ ์ธ์ํ๊ณ ๋ธ๋ฃจํฌ์ค๋ฅผ ํตํด ๋ก๋ด ํ์ ์ ์ดํ๋ ์์์
๋๋ค.
์ค์ ๊ตฌํ์๋ ์ถ๊ฐ์ ์ธ ์ธ๋ถ ์ฌํญ์ด ํฌํจ๋ ์ ์์ผ๋ฉฐ, ๋ก๋ด ํ์ ํ๋์จ์ด ๋ฐ ์ํํธ์จ์ด ํ๊ฒฝ์ ๋ฐ๋ผ
๊ตฌ์ฒด์ ์ธ ๊ตฌํ ๋ฐฉ๋ฒ์ด ๋ฌ๋ผ์ง ์ ์์ต๋๋ค
esp32์นด๋ฉ๋ผ๋ชจ๋๊ณผ ์ค๋งํธํฐ์ ์ฐ๊ฒฐํด ๋ธ๋ฃจํฌ์ค๋ชจ๋๋ก ํ์ธํด์ฃผ๋ ์ฝ๋๋ฅผ ์์ฑํด์ค
๋ฌผ์ฒด ์ธ์์ ์ํด ESP32 ์นด๋ฉ๋ผ ๋ชจ๋๊ณผ ์ค๋งํธํฐ์ ๋ธ๋ฃจํฌ์ค ๋ชจ๋์ ํตํด ์ฐ๊ฒฐํ๊ณ , ์ค๋งํธํฐ์์
๋ฌผ์ฒด๋ฅผ ํ์ธํ๋ ์ฝ๋๋ฅผ ์์ฑํด ๋๋ฆฌ๊ฒ ์ต๋๋ค. ํ์ง๋ง ESP32 ์นด๋ฉ๋ผ ๋ชจ๋์ ๋ํ ์ง์์ด๋
์ฌ์ฉํ๊ณ ์ ํ๋ ์ฝ๋์ ๋ํ ๊ตฌ์ฒด์ ์ธ ์๊ตฌ์ฌํญ์ ์๋ ค์ฃผ์๋ฉด ๋์ฑ ์ ํํ ์ฝ๋๋ฅผ ์ ๊ณตํ ์ ์์ต๋๋ค.
์๋๋ ESP32 ์นด๋ฉ๋ผ ๋ชจ๋๊ณผ ์ค๋งํธํฐ์ ์ฐ๊ฒฐํ๊ณ ๋ฌผ์ฒด๋ฅผ ํ์ธํ๋ ๊ธฐ๋ณธ์ ์ธ ์ฝ๋์
๋๋ค.
python
# ํ์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ํฌํธ
import bluetooth
from picamera import PiCamera
import time
# ๋ธ๋ฃจํฌ์ค ์๋ฒ ์ด๊ธฐํ
server_socket = bluetooth.BluetoothSocket(bluetooth.RFCOMM)
server_socket.bind(("", bluetooth.PORT_ANY))
server_socket.listen(1)
# ๋ธ๋ฃจํฌ์ค ํด๋ผ์ด์ธํธ ์ฐ๊ฒฐ ๋๊ธฐ
print("Waiting for Bluetooth connection...")
client_socket, address = server_socket.accept()
print("Connected to", address)
# ์นด๋ฉ๋ผ ์ด๊ธฐํ
camera = PiCamera()
try:
while True:
# ์นด๋ฉ๋ผ๋ก ์ฌ์ง ์ดฌ์
image_path = "/path/to/image.jpg" # ์ ์ฅํ ์ด๋ฏธ์ง ๊ฒฝ๋ก
camera.capture(image_path)
# ์ด๋ฏธ์ง ํ์ผ ํฌ๊ธฐ ์ ์ก
image_size = str(os.path.getsize(image_path))
client_socket.send(image_size.encode())
# ์ด๋ฏธ์ง ํ์ผ ์ ์ก
with open(image_path, "rb") as f:
data = f.read(1024)
while data:
client_socket.send(data)
data = f.read(1024)
# ๋ฌผ์ฒด ํ์ธ ๊ฒฐ๊ณผ ์์
result = client_socket.recv(1024)
print("Object detected:", result.decode())
# ์ผ์์ ์ธ ๋๋ ์ด
time.sleep(1)
except Exception as e:
print("Error:", str(e))
finally:
# ์ฐ๊ฒฐ ์ข
๋ฃ
client_socket.close()
server_socket.close()
์ ์ฝ๋๋ Raspberry Pi์ ESP32 ์นด๋ฉ๋ผ ๋ชจ๋์ ์ฌ์ฉํ์ฌ ๋ฌผ์ฒด ์ธ์ ๊ฒฐ๊ณผ๋ฅผ ์ค๋งํธํฐ์ผ๋ก ์ ์กํ๋
์์์
๋๋ค. ์ฝ๋์์ ์ฃผ์์ผ๋ก ํ์๋ ๋ถ๋ถ์ ์ฌ์ฉ์๊ฐ ์ค์ ๋ก ๊ฒฝ๋ก๋ฅผ ์ค์ ํด์ผ ํ๋ ๋ถ๋ถ์
๋๋ค.
๋ํ, ํ์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ค์ ์ค์นํ๊ณ ์ฝ๋๋ฅผ ์คํํ๊ธฐ ์ํด์๋ ํ์ํ ํ๊ฒฝ ์ค์ ์ด ํ์ํ ์ ์์ต๋๋ค.
๋ง์ฝ ์ฌ์ฉํ๊ณ ์ ํ๋ ํ๊ฒฝ์ด Raspberry Pi๊ฐ ์๋๊ฑฐ๋, ๋ค๋ฅธ ์นด๋ฉ๋ผ ๋ชจ๋์ ์ฌ์ฉํ๋ค๋ฉด ํด๋น ํ๊ฒฝ์
๋ง๊ฒ ์ฝ๋๋ฅผ ์์ ํ์
์ผ ํฉ๋๋ค. ๋ํ, ESP32์ ์ค๋งํธํฐ ๊ฐ์ ๋ธ๋ฃจํฌ์ค ํต์ ์ ์ํ ์ค์ ๋
ํ์ํ ์ ์์ผ๋ฏ๋ก ์ฐธ๊ณ ํ์๊ธฐ ๋ฐ๋๋๋ค.
ESP32 cams ๋ชจ๋๋ก Edge Impulse๋ฅผ ํ์ฉํ์ฌ ๋จธ์ ๋ฌ๋์ ํตํด ๊ฐ์ฒด ์ธ์์ ๊ตฌํํ๋ ๋ฐฉ๋ฒ.
Edge Impulse๋ ์จ๋ผ์ธ ํ๋ซํผ์ผ๋ก, ๋จธ์ ๋ฌ๋ ๋ชจ๋ธ์ ์ฝ๊ฒ ๊ตฌ์ถํ๊ณ ๋ฐฐํฌํ ์ ์์ผ๋ฉฐ, ๊ฐ์ธ์ด ์์ ํ๋ก์ ํธ๋ฅผ ๋ฌด๋ฃ๋ก ์งํํ ์ ์์ต๋๋ค.
์ด ํ๋ก์ ํธ์์๋ ESP32 ์นด๋ฉ๋ผ ๋ชจ๋์ ์ฌ์ฉํ์ฌ ๊ฐ์, ํ ๋งํ , ์ํ๋ฅผ ์ธ์ํ๋๋ก ํ์ต์ํค๋ ๋ฐฉ๋ฒ์ ๋ค๋ฃน๋๋ค.
ํ๋์จ์ด ์ค์ , ์ด๋ฏธ์ง ์์ง, ๋ชจ๋ธ ํ๋ จ, ๊ทธ๋ฆฌ๊ณ ์ต์ข ์ ์ผ๋ก ๊ฒฐ๊ณผ๋ฅผ OLED ๋์คํ๋ ์ด์ ํ์ํ๋ ๋ฐฉ๋ฒ๊น์ง ๋จ๊ณ๋ณ๋ก ์๋ดํฉ๋๋ค.
๋ง์ง๋ง์๋ OLED ๋์คํ๋ ์ด๋ฅผ ์ฌ์ฉํด ์ธ์ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํ๋ ๋ชจ์ต์ ๋ณด์ฌ์ฃผ๋ฉฐ, ๊ด๋ จ๋ ์ง๋ฌธ์ด๋ ๋ฌธ์ ๊ฐ ์์ ๊ฒฝ์ฐ ๋๊ธ๋ก ๋์์ ๋ฐ์ ์ ์๋ค๊ณ ์๋ดํฉ๋๋ค.
ESP32 ๋ณด๋์์ Google's Gemini AI๋ฅผ ํ์ฉํ์ฌ ๊ฐ์ธ AI ์ด์์คํดํธ๋ฅผ ๋ง๋๋ ๋ฐฉ๋ฒ.
์ด ํ๋ก์ ํธ์์๋ Gemini API๋ฅผ ์ฌ์ฉํ์ฌ ESP32 ๋ณด๋์์ ์ง๋ฌธ์ ํ๊ณ , ๊ทธ ๋ต๋ณ์ ์๋ฆฌ์ผ ๋ชจ๋ํฐ์ ์ถ๋ ฅํ๋ ๊ณผ์ ์ ๋ณด์ฌ์ค๋๋ค.
ํ๋ก์ ํธ์ ์ฒซ ๋จ๊ณ๋ก, Gemini API ํค๋ฅผ ์์ฑํ๊ณ Postman ์ ํ๋ฆฌ์ผ์ด์ ์์ API๋ฅผ ํ ์คํธํ๋ ๋ฐฉ๋ฒ์ ์ค๋ช ํฉ๋๋ค.
์ดํ ESP32 ๋ณด๋์์ API๋ฅผ ์ฌ์ฉํ๋ ์ฝ๋๋ฅผ ์์ฑํ๊ณ , Wi-Fi์ ์ฐ๊ฒฐํ ํ ์ง๋ฌธ์ ์ ๋ ฅํ๋ฉด Gemini AI๊ฐ ๋ต๋ณ์ ๋ฐํํ๋ ๊ณผ์ ์ ๋ณด์ฌ์ค๋๋ค.
๋ง์ง๋ง์ผ๋ก, ChatGPT API์ Gemini API ์ค ์ด๋ค ๊ฒ์ด ESP32 ๋ณด๋์์ ํตํฉ์ ๋ ์ ํฉํ์ง ๋น๊ตํฉ๋๋ค.
Gemini API๋ Google ๊ณ์ ๊ณผ ์ฐ๋๋์ด ์ฌ์ฉ์ด ๊ฐํธํ๊ณ , ๋ฌด๋ฃ ํ๋์ผ๋ก ์ถฉ๋ถํ ์ง๋ฌธ๊ณผ ํ ํฐ์ ์ ๊ณตํ๋ฏ๋ก, ESP32 ๊ธฐ๋ฐ ํ๋ก์ ํธ์ ์ ํฉํ๋ค๊ณ ๊ฒฐ๋ก ์ง์ต๋๋ค.
Lafayette Systems์์ ๊ฐ๋ฐ ์ค์ธ ๋ชจ๋ธ ๋ก์ผ "Diamond X"์ ๋นํ ์ปดํจํฐ์ ๋ํด ์ค๋ช ํฉ๋๋ค.
Diamond X๋ ๊ณต์ค์์ ์ค์ค๋ก ๋ฐฉํฅ์ ์กฐ์ ํ ์ ์๋ ํ์ ์ฌ์ฉํ์ฌ ๋นํํ๋ฉฐ, ๋ ํฐ ์๋์ ์ฌ๊ฑฐ๋ฆฌ๋ฅผ ์ํด 1๋จ ๋ถ์คํฐ๋ฅผ ์ถ๊ฐํ์ฌ ๊ฐ์กฐ ์ค์ ๋๋ค.
๋นํ ์ปดํจํฐ๋ ๋ก์ผ์ ์์น์ ๋ฐฉํฅ์ ์ง์์ ์ผ๋ก ํ์ ํ๋ฉฐ, ๋ก์ผ์ด ๋ชฉํ ์ง์ ์ ๋๋ฌํ ์ ์๋๋ก ํ์ ์์ง์ด๊ณ ,
์ต๊ณ ๊ณ ๋์ ๋๋ฌํ๋ฉด ๋ํ์ฐ์ ๋ฐฐ์นํ๋ ์ญํ ์ ํฉ๋๋ค. ๋ํ, 2๋ฐฉํฅ ๋ฐ์ดํฐ ๋งํฌ๋ฅผ ํตํด ์ง์์์ ๋ก์ผ์ ์ํ๋ฅผ ๋ชจ๋ํฐ๋งํ๊ณ ๋ช ๋ น์ ์ ์กํ ์ ์์ต๋๋ค.
์์์์๋ ๋นํ ์ปดํจํฐ์ ์ฌ์ฉ๋ ํ๋ก ๊ธฐํ์ ์ค๊ณ์ ๊ตฌ์ฑ ์์๋ค์ ๋ํด ์์ธํ ๋ค๋ฃจ๊ณ , ๊ฐ ํ๋ก๊ฐ ์ด๋ค ์ญํ ์ ํ๋์ง ์ค๋ช ํฉ๋๋ค.
๋ํ, ๋นํ ์ปดํจํฐ์ ์๊ตฌ์ฌํญ์ ์ค์ ํ๊ณ , ์ํํธ์จ์ด๊ฐ ์ด๋ป๊ฒ ๋ก์ผ์ ์์ ์ ์ผ๋ก ๋นํํ๋๋ก ๋์์ฃผ๋์ง ์ค๋ช ํฉ๋๋ค.
Diamond X์ ๋นํ ํ ์คํธ์ ํฅํ ๊ณํ์ ๋ํ ๋ด์ฉ๋ ๋ค๋ฃจ๊ณ ์์ผ๋ฉฐ, ๋ก์ผ์ ์์ ํ๊ฒ ์ด์ํ๊ธฐ ์ํ ํ๋ ์ ๊ณตํฉ๋๋ค.
์ด ํ๋ก์ ํธ์ ๊ด์ฌ ์๋ ์์ฒญ์๋ค์๊ฒ ๊ฐ์ฌ์ ์ธ์ฌ๋ฅผ ์ ํ๋ฉฐ, ๊ณง ๋ค๊ฐ์ฌ ์ถ๊ฐ ์ฝํ ์ธ ๋ฅผ ์๊ณ ํฉ๋๋ค.