2025 ๋ ธ๋ฒจ์์ด ๋ฐํ๋ธ ์๊ฐ๋ฉด์ญ ์งํ ์น๋ฃ์ ์จ๊ฒจ์ง ์ด์ : ‘๋ฉด์ญ ๊ด์ฉ’์ ๋์ฐพ๋ ๊ธฐ์ ์ ์ฌ์ !
์๋์ด๋
ธ ๋ฉ๊ฐ2560 : ๊ณ ๊ธ ํ๋ก์ ํธ๋ฅผ ์ํ ์๋ฒฝํ ๊ฐ์ด๋
์๋์ด๋ ธ ๋ฉ๊ฐ(Arduino Mega)๋ ๋ณต์กํ๊ณ ๋๊ท๋ชจ์ ์ ์ ํ๋ก์ ํธ๋ฅผ ์ํํ๊ธฐ ์ํ ๊ฐ๋ ฅํ ๋ง์ดํฌ๋ก์ปจํธ๋กค๋ฌ ๋ณด๋๋ก, ํนํ ๋ง์ ํ๊ณผ ๋ ํฐ ๋ฉ๋ชจ๋ฆฌ๊ฐ ํ์ํ ํ๋ก์ ํธ์ ์ ํฉํฉ๋๋ค. ์ด ๊ฐ์ด๋์์๋ ์๋์ด๋ ธ ๋ฉ๊ฐ์ ์ฃผ์ ํน์ง, ์ผ๋ฐ์ ์ธ ์์ฉ ๋ถ์ผ, ๊ทธ๋ฆฌ๊ณ ์ฒซ ๋ฒ์งธ ํ๋ก์ ํธ๋ฅผ ์์ํ๋ ๋ฐฉ๋ฒ์ ๋ํด ์์ธํ ์์๋ณด๊ฒ ์ต๋๋ค.
์๋์ด๋ ธ ๋ฉ๊ฐ๋ ๋ฌด์์ธ๊ฐ์?
์๋์ด๋ ธ ๋ฉ๊ฐ๋ ATmega2560 ๋ง์ดํฌ๋ก์ปจํธ๋กค๋ฌ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ ์คํ ์์ค ๋ง์ดํฌ๋ก์ปจํธ๋กค๋ฌ ๋ณด๋์ ๋๋ค. ์ด ๋ณด๋๋ ์๋์ด๋ ธ ์ฐ๋ ธ๋ณด๋ค ๋ ๋ง์ ๋์งํธ ๋ฐ ์๋ ๋ก๊ทธ ํ, ๋ ํฐ ๋ฉ๋ชจ๋ฆฌ, ๊ทธ๋ฆฌ๊ณ ๋ ๋ง์ ๊ธฐ๋ฅ์ ์ ๊ณตํ์ฌ, ๋ณต์กํ ํ๋ก์ ํธ๋ ๋ง์ ์ ๋ ฅ ๋ฐ ์ถ๋ ฅ์ ํ์๋ก ํ๋ ํ๋ก์ ํธ์ ์ด์์ ์ ๋๋ค. ์๋์ด๋ ธ ๋ฉ๊ฐ๋ ์ฐ๋ ธ์ ๋น์ทํ ์ํคํ ์ฒ๋ฅผ ๊ฐ์ง๊ณ ์์ด ์ฐ๋ ธ ์ฌ์ฉ์๋ ์ฝ๊ฒ ์ฌ์ฉํ ์ ์์ต๋๋ค.
์๋์ด๋ ธ ๋ฉ๊ฐ์ ์ฃผ์ ํน์ง
๋ง์ดํฌ๋ก์ปจํธ๋กค๋ฌ: ์๋์ด๋ ธ ๋ฉ๊ฐ๋ ATmega2560 ๋ง์ดํฌ๋ก์ปจํธ๋กค๋ฌ๋ก ๊ตฌ๋๋๋ฉฐ, 256KB์ ํ๋์ ๋ฉ๋ชจ๋ฆฌ, 8KB์ SRAM, 4KB์ EEPROM์ ์ ๊ณตํฉ๋๋ค. ์ด๋ ๋ ๋ณต์กํ ์ฝ๋์ ๋ ๋ง์ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๋ ๋ฐ ์ ํฉํฉ๋๋ค.
๋์งํธ ๋ฐ ์๋ ๋ก๊ทธ ํ: ๋ฉ๊ฐ๋ 54๊ฐ์ ๋์งํธ ์ ์ถ๋ ฅ ํ(๊ทธ ์ค 15๊ฐ๋ PWM ์ถ๋ ฅ์ผ๋ก ์ฌ์ฉ ๊ฐ๋ฅ)๊ณผ 16๊ฐ์ ์๋ ๋ก๊ทธ ์ ๋ ฅ์ ์ ๊ณตํฉ๋๋ค. ์ด๋ก ์ธํด ๋๊ท๋ชจ ์ผ์ ๋คํธ์ํฌ, ์ฌ๋ฌ ๋ชจํฐ ์ ์ด ๋ฑ ๋ณต์กํ ํ๋ก์ ํธ๋ฅผ ์ฒ๋ฆฌํ ์ ์์ต๋๋ค.
ํต์ ๊ธฐ๋ฅ: ์๋์ด๋ ธ ๋ฉ๊ฐ๋ 4๊ฐ์ ํ๋์จ์ด ์๋ฆฌ์ผ ํฌํธ(UART)๋ฅผ ์ ๊ณตํ์ฌ ์ฌ๋ฌ ์ฅ์น์ ๋์์ ํต์ ํ ์ ์์ต๋๋ค. ๋ํ SPI, I2C ํต์ ์ ์ง์ํ์ฌ ๋ค์ํ ์ธ๋ถ ์ฅ์น์์ ์ฐ๊ฒฐ์ด ๊ฐ๋ฅํฉ๋๋ค.
์ ์ ๊ณต๊ธ: ๋ฉ๊ฐ๋ USB ์ฐ๊ฒฐ์ ํตํด ์ ์์ ๊ณต๊ธ๋ฐ๊ฑฐ๋, 7-12V์ ์ธ๋ถ ์ ์ ๊ณต๊ธ ์ฅ์น๋ฅผ ํตํด ์ ์์ ๊ณต๊ธ๋ฐ์ ์ ์์ต๋๋ค. ์ด๋ฅผ ํตํด ์ ๋ ฅ ์๋น๊ฐ ํฐ ํ๋ก์ ํธ์๋ ์์ ์ ์ผ๋ก ์ ์์ ๊ณต๊ธํ ์ ์์ต๋๋ค.
USB ์ฐ๊ฒฐ์ฑ: ํ๋ก๊ทธ๋๋ฐ๊ณผ ์ ์์ ์ํด ํ์ค USB Type-B ์ปค๋ฅํฐ๋ฅผ ์ฌ์ฉํฉ๋๋ค. ์ด ์ปค๋ฅํฐ๋ ์์ ์ ์ธ ์ฐ๊ฒฐ์ ๋ณด์ฅํ๋ฉฐ, ๋ค์ํ ์ด์ ์ฒด์ ์์ ์ฝ๊ฒ ์ธ์๋ฉ๋๋ค.
ํ์ฅ์ฑ: ๋ฉ๊ฐ๋ ๋ค์ํ ์ด๋์ ํธํ๋๋ฉฐ, ๋ธ๋ ๋๋ณด๋์๋ ์ฝ๊ฒ ์ฐ๊ฒฐํ ์ ์์ด ํ์ฅ์ฑ๊ณผ ์คํ์ด ์ฉ์ดํฉ๋๋ค.
์๋์ด๋ ธ ๋ฉ๊ฐ๋ฅผ ์ ํํด์ผ ํ๋ ์ด์
์๋์ด๋ ธ ๋ฉ๊ฐ๋ ๊ณ ๊ธ ํ๋ก์ ํธ๋ ๋ณต์กํ ์ ์ ์์คํ ์ ๊ตฌ์ถํ๋ ค๋ ์ฌ์ฉ์์๊ฒ ์ต์ ์ ์ ํ์ ๋๋ค. ๋ ๋ง์ ์ ์ถ๋ ฅ ํ, ํ์ฅ๋ ๋ฉ๋ชจ๋ฆฌ ์ฉ๋, ๊ทธ๋ฆฌ๊ณ ๊ฐ๋ ฅํ ํต์ ๊ธฐ๋ฅ ๋๋ถ์ ๋ฉ๊ฐ๋ ๋จ์ํ ํ๋ก์ ํธ์์ ๋๊ท๋ชจ์ ํ๋กํ ํ์ดํ ์์ ์ ์ด๋ฅด๊ธฐ๊น์ง ๋ค์ํ ์ฉ๋๋ก ์ฌ์ฉ๋ ์ ์์ต๋๋ค. ํนํ, ์ฐ๋ ธ์์ ํ ์๋ ๋ฉ๋ชจ๋ฆฌ ์ฉ๋์ด ๋ถ์กฑํ ์ฌ์ฉ์์๊ฒ ์๋์ด๋ ธ ๋ฉ๊ฐ๋ ๋งค์ฐ ์ ์ฉํ ๋์์ด ๋ฉ๋๋ค.
์๋์ด๋ ธ ๋ฉ๊ฐ์ ์ผ๋ฐ์ ์ธ ์์ฉ ๋ถ์ผ
์๋์ด๋ ธ ๋ฉ๊ฐ๋ ํนํ ๋ณต์กํ๊ณ ๊ท๋ชจ๊ฐ ํฐ ํ๋ก์ ํธ์ ์ ํฉํฉ๋๋ค:
๋ก๋ด ๊ณตํ: ๋ฉ๊ฐ์ ๋ง์ ํ๊ณผ ๊ฐ๋ ฅํ ์ฑ๋ฅ ๋๋ถ์ ์ฌ๋ฌ ๋ชจํฐ์ ์ผ์๋ฅผ ๋์์ ์ ์ดํ๋ ๋ก๋ด ํ๋ก์ ํธ์ ์ ํฉํฉ๋๋ค. ์๋ฅผ ๋ค์ด, ํ์ด๋ ๋ค๋ฆฌ๊ฐ ์ฌ๋ฌ ๊ฐ์ธ ๋ก๋ด, ๋ฌด์ธ ์๋์ฐจ ๋ฑ์ ์ ์ด์ ์ฌ์ฉ๋ ์ ์์ต๋๋ค.
์๋ํ ์์คํ : ๋ฉ๊ฐ๋ ๋๊ท๋ชจ ์๋ํ ์์คํ ์์ ์ฌ๋ฌ ์ ๋ ฅ๊ณผ ์ถ๋ ฅ์ ๋์์ ์ฒ๋ฆฌํด์ผ ํ ๋ ์ด์์ ์ ๋๋ค. ์๋ฅผ ๋ค์ด, ์ค๋งํธ ๋น๋ฉ์ ์กฐ๋ช , ์จ๋, ๋ณด์ ์์คํ ๋ฑ์ ์ ์ดํ ์ ์์ต๋๋ค.
๋ฐ์ดํฐ ๋ก๊น : ๋ฉ๊ฐ์ ํ์ฅ๋ ๋ฉ๋ชจ๋ฆฌ์ ํต์ ๊ธฐ๋ฅ์ ์ฌ๋ฌ ์ผ์๋ก๋ถํฐ ๋ฐ์ดํฐ๋ฅผ ์์งํ๊ณ ์ ์ฅํ๋ ๋ฐ์ดํฐ ๋ก๊น ์์คํ ์ ์ ํฉํฉ๋๋ค. ์ด๋ ํ๊ฒฝ ๋ชจ๋ํฐ๋ง, ์ฐ๊ตฌ ํ๋ก์ ํธ ๋ฑ์ ํ์ฉ๋ ์ ์์ต๋๋ค.
๋ฉํฐ๋ฏธ๋์ด ํ๋ก์ ํธ: ๋ฉ๊ฐ๋ LED ๋งคํธ๋ฆญ์ค, ์ฌ์ด๋ ์์คํ , ๋ํ ๋์คํ๋ ์ด ๋ฑ ๋ค์ํ ๋ฉํฐ๋ฏธ๋์ด ์ฅ์น๋ฅผ ๋์์ ์ ์ดํ๋ ๋ฐ ์ฌ์ฉ๋ ์ ์์ต๋๋ค.
3D ํ๋ฆฐํฐ ๋ฐ CNC ๊ธฐ๊ณ: ๋ฉ๊ฐ๋ 3D ํ๋ฆฐํฐ๋ CNC ๊ธฐ๊ณ์ ๋ฉ์ธ ์ปจํธ๋กค๋ฌ๋ก ์์ฃผ ์ฌ์ฉ๋ฉ๋๋ค. ์ฌ๋ฌ ์ถ์ ๋์์ ์ ์ดํ๊ณ , ์ ํํ ์์น์ ์๋๋ฅผ ๊ด๋ฆฌํ๋ ๋ฐ ํ์ํ ์ฑ๋ฅ์ ์ ๊ณตํฉ๋๋ค.
์๋์ด๋ ธ ๋ฉ๊ฐ๋ก ์์ํ๋ ๋ฐฉ๋ฒ
์๋์ด๋ ธ ๋ฉ๊ฐ๋ก ์์ํ๋ ๊ฒ์ ๊ธฐ์กด์ ์๋์ด๋ ธ ๋ณด๋ ์ฌ์ฉ ๊ฒฝํ์ด ์๋ค๋ฉด ๋งค์ฐ ๊ฐ๋จํฉ๋๋ค. ๋ค์์ ์์ํ๊ธฐ ์ํ ๊ธฐ๋ณธ ๋จ๊ณ์ ๋๋ค:
์๋์ด๋ ธ IDE ์ค์น: ์๋์ด๋ ธ ๊ณต์ ์น์ฌ์ดํธ์์ ์๋์ด๋ ธ IDE๋ฅผ ๋ค์ด๋ก๋ํ์ฌ ์ค์นํฉ๋๋ค. ์ด ์ํํธ์จ์ด๋ ๋ฉ๊ฐ์ ์ฝ๋๋ฅผ ์์ฑํ๊ณ ์ ๋ก๋ํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค.
์๋์ด๋ ธ ๋ฉ๊ฐ ์ฐ๊ฒฐ: USB Type-B ์ผ์ด๋ธ์ ์ฌ์ฉํด ์๋์ด๋ ธ ๋ฉ๊ฐ๋ฅผ ์ปดํจํฐ์ ์ฐ๊ฒฐํฉ๋๋ค. ์ปดํจํฐ๊ฐ ๋ณด๋๋ฅผ ์ธ์ํด์ผ ํ๋ฉฐ, ์ด์ ์ฒด์ ์ ๋ฐ๋ผ ๋๋ผ์ด๋ฒ๋ฅผ ์ค์นํด์ผ ํ ์๋ ์์ต๋๋ค.
์ฌ๋ฐ๋ฅธ ๋ณด๋ ๋ฐ ํฌํธ ์ ํ: ์๋์ด๋ ธ IDE์์ "๋๊ตฌ" > "๋ณด๋"๋ก ์ด๋ํ์ฌ "Arduino Mega 2560"์ ์ ํํฉ๋๋ค. ๊ทธ๋ฐ ๋ค์ "ํฌํธ"์์ ๋ฉ๊ฐ๊ฐ ์ฐ๊ฒฐ๋ COM ํฌํธ๋ฅผ ์ ํํฉ๋๋ค.
์ฒซ ๋ฒ์งธ ํ๋ก๊ทธ๋จ ์์ฑ: ์๋์ด๋ ธ ์ฐ๋ ธ์์ ํ๋ ๊ฒ์ฒ๋ผ, ๊ฐ๋จํ ํ๋ก๊ทธ๋จ์ผ๋ก ์์ํ์ฌ ํ๊ฒฝ์ ์ต์ํด์ง์ธ์. ์๋ฅผ ๋ค์ด, LED๋ฅผ ๊น๋ฐ์ด๋ "Blink" ์ค์ผ์น๋ก ์์ํ ์ ์์ต๋๋ค.
cpp
์ฝ๋ ๋ณต์ฌ
void setup() {
pinMode(13, OUTPUT); // ๋์งํธ ํ 13์ ์ถ๋ ฅ์ผ๋ก ์ค์
}
void loop() {
digitalWrite(13, HIGH); // LED ์ผ๊ธฐ
delay(1000); // 1์ด ๋๊ธฐ
digitalWrite(13, LOW); // LED ๋๊ธฐ
delay(1000); // 1์ด ๋๊ธฐ
}
ํ๋ก๊ทธ๋จ ์ ๋ก๋: ์๋์ด๋ ธ IDE์์ "์ ๋ก๋" ๋ฒํผ์ ํด๋ฆญํ์ฌ ์ฝ๋๋ฅผ ์ปดํ์ผํ๊ณ ๋ฉ๊ฐ์ ์ ๋ก๋ํฉ๋๋ค. ์ฑ๊ณต์ ์ผ๋ก ์ ๋ก๋๋๋ฉด ์จ๋ณด๋ LED(ํ 13์ ์ฐ๊ฒฐ๋จ)๊ฐ ๊น๋ฐ์ด๊ธฐ ์์ํฉ๋๋ค.
ํ๋ก์ ํธ ํ์ฅ: ๊ธฐ๋ณธ ์ฌํญ์ ์ตํ ํ, ๋ ๋ง์ ์ผ์, ๋ชจํฐ, ๋์คํ๋ ์ด ๋ฑ์ ์ถ๊ฐํ์ฌ ๋ณต์กํ ํ๋ก์ ํธ๋ฅผ ์๋ํ ์ ์์ต๋๋ค. ๋ฉ๊ฐ์ ๋ง์ ํ๊ณผ ํ์ฅ์ฑ ๋๋ถ์ ๊ฐ๋ฅ์ฑ์ ๋ฌด๊ถ๋ฌด์งํฉ๋๋ค.
ํํ ๋ฌธ์ ํด๊ฒฐ ๋ฐฉ๋ฒ
์๋์ด๋ ธ ๋ฉ๊ฐ๋ฅผ ์ฌ์ฉํ๋ฉด์ ๋ง์ฃผํ ์ ์๋ ๋ช ๊ฐ์ง ์ผ๋ฐ์ ์ธ ๋ฌธ์ ์ ํด๊ฒฐ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
๋๋ผ์ด๋ฒ ์ค์น: ์ปดํจํฐ๊ฐ ๋ฉ๊ฐ๋ฅผ ์ธ์ํ์ง ๋ชปํ๋ ๊ฒฝ์ฐ, ํ์ํ ๋๋ผ์ด๋ฒ๋ฅผ ์๋์ผ๋ก ์ค์นํด์ผ ํ ์๋ ์์ต๋๋ค.
ํฌํธ ํ์ ์ ๋จ: Arduino IDE์์ COM ํฌํธ๊ฐ ๋ํ๋์ง ์์ผ๋ฉด, ๋ฉ๊ฐ๋ฅผ ๋ค์ ์ฐ๊ฒฐํ๊ฑฐ๋ ๋ค๋ฅธ USB ์ผ์ด๋ธ์ ์ฌ์ฉํด ๋ณด์ธ์.
์ ๋ก๋ ์ค๋ฅ: Arduino IDE์์ ์ฌ๋ฐ๋ฅธ ๋ณด๋์ ํฌํธ๋ฅผ ์ ํํ๋์ง ํ์ธํ์ธ์. ๊ทธ๋๋ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ฉด, ์ ๋ก๋ ์ ์ ๋ฉ๊ฐ์ ๋ฆฌ์ ๋ฒํผ์ ๋๋ฌ๋ณด์ธ์.
๊ฒฐ๋ก
์๋์ด๋ ธ ๋ฉ๊ฐ๋ ๋ณต์กํ๊ณ ๋๊ท๋ชจ์ ํ๋ก์ ํธ๋ฅผ ์คํํ๊ธฐ ์ํ ์ต์์ ๋๊ตฌ์ ๋๋ค. ๊ทธ ๋ง์ ํ, ํ์ฅ๋ ๋ฉ๋ชจ๋ฆฌ, ๊ฐ๋ ฅํ ์ฑ๋ฅ ๋๋ถ์ ๋ฉ๊ฐ๋ ๋ณต์กํ ์ ์ ์์คํ , ๋ก๋ด, ์๋ํ ์์คํ , ๊ทธ๋ฆฌ๊ณ ๋ฐ์ดํฐ ๋ก๊น ํ๋ก์ ํธ ๋ฑ์์ ํ์์ ์ธ ์ญํ ์ ํฉ๋๋ค. ์๋์ด๋ ธ ๋ฉ๊ฐ๋ ํนํ ํ ์๋ ๋ฉ๋ชจ๋ฆฌ ์ ํ์ผ๋ก ์ธํด ๋ ๋ง์ ๊ธฐ๋ฅ์ด ํ์ํ ํ๋ก์ ํธ์์ ์ฐ๋ ธ๋ฅผ ๋์ ํ ์ ์๋ ์๋ฒฝํ ์ ํ์ ๋๋ค.
๊ฑฐ์ ์ด๊ฒ์ผ๋ก 3d ํ๋ฆฐํฐ์์์ ์ํด ํ์ ์๋ ์์ ์ด ์์์ต๋๋ค. ํํจ์จ๋ณ์ผ๋ก ๊ณ ํต์ค๋ฌ์ ์ผ๋ ๋๋ ๊ทธ์ผ์ ๊ณ์ ์ด์ด๋๊ฐ๋ค๊ณ ํด๋ ๋ฌด๋ฐฉํ ์ ๋๋ก ํ๊ฒจ์ ์ต๋๋ค ์ค๊ตณ ์๋ฆฌ์ต์คํ๋ ์ค์์ ์ด๋์ ๋ชจํฐ๋๋ผ์ด๋ฒ๋ฅผ ๊ตฌ์ ํ๊ณ ์กฐ๊ธ ๋๋ฆฐ๋ค ์ถ์ผ๋ฉด ํ๋ฆฐํฐ๋ ํ๋ก๊ธฐํ์ด ๋จ๊ฑฐ์์ ธ์ ๊ธ๋ฐฉ ๊ณ ์ฅ๋๊ธฐ ์ผ์ค์๊ณ ์์ฆ์ ๊ณผ ๊ฐ์ ๊ณ ๊ธ ํ๋ก๊ธฐํ๊ณผ ์ฟจ๋ง ์์คํ ์ ๊ฑฐ์ ์ฐพ์๋ณด๊ธฐ ํ๋ค๋ ์์ ์ด์์ต๋๋ค ์ง๊ธ ์์ ์์ ๊ทธ๋๋ฅผ ํ์ํ์๋ฉด ์ ๋ง ๋งจ๋ ์ ํด๋ฉํ๊ธฐ ์๋์๋ ์ถ์ ์๊ฐ์ด ๋ญ๋๋ค. ์๊ธ๋ ๋ถ์กฑํ๊ณ ๊ธฐ์ ๋ ฅ๋ ๋ณ๋ก ์์ด์ anet a8 ์ด๋ผ๋ ๋ชจ๋ธ์ ๊ตฌ๋งคํด ์ฌ์ฉํ์๋๋ฐ ์ฒ์๋ถํฐ ํ๋ก๋ ๊ทธ๋ ๊ณ ์์ฃผ ๊ฐํ์ด์์ต๋๋ค. ์๋ฌด๋ฆฌ ๊ฐ๊ฒฉ์ด ๊ทธ๋ ๋๋ผ๋ ๋ง๋ฌด๋ฆฌ๊ฐ ์ ์๋์์ต๋๋ค ๋์ฐํ๋ ๊ดด๋ก์ด ์์์ด์์ต๋๋ค. ๊ทธ๋ ์์๋๋ผ๋ฉด ๋ค์๋ ์๋ ์๋๊ณ ์ถ์์ ๋๋ก ์๋ง์ด์๋ ๊ธฐ์ต์ด ์์ต๋๋ค
๊ธฐํ ํ์ํ ๋ถ์ํํ
๋ธ๋ ๋๋ณด๋๋ ์ผ๋ช ๋นตํ ์ ์ ํ๋ก๋ฅผ ์คํํ ๋ ์ฌ์ฉ๋๋ ๋๊ตฌ๋ก, ๋ฉ๋ ์์ด ๋ค์ํ ์ ์ ๋ถํ๋ค์ ์ฝ๊ฒ ์ฐ๊ฒฐํ ์ ์๋๋ก ์ค๊ณ๋ ํ๋กํ์ ๋๋ค. ์ด ๋๊ตฌ๋ ์ฃผ๋ก ์ ์ ํ๋ก ์ค๊ณ, ๊ต์ก, ํ๋กํ ํ์ดํ์ ์ฌ์ฉ๋ฉ๋๋ค. ๋ธ๋ ๋๋ณด๋๋ ์ค์์ ์ฌ๋ฌ ๊ฐ์ ๊ตฌ๋ฉ์ด ์๋ ํ๋ผ์คํฑ ํ์ผ๋ก ๊ตฌ์ฑ๋์ด ์์ผ๋ฉฐ, ์ด ๊ตฌ๋ฉ๋ค์ ์ ์ ๋ถํ์ ๋ฆฌ๋๋ฅผ ๊ฝ์ ์๋ก ์ฐ๊ฒฐํฉ๋๋ค. ์ด๋ฅผ ํตํด ํ๋ก๋ฅผ ์ ์ํ๊ฒ ๋ณ๊ฒฝํ๊ฑฐ๋ ์์ ํ ์ ์์ต๋๋ค.
๋ธ๋ ๋๋ณด๋์ ์ฃผ์ ๊ตฌ์ฑ ์์๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
๋ธ๋ ๋๋ณด๋๋ ์ฃผ๋ก ์๋์ด๋ ธ, ๋ผ์ฆ๋ฒ ๋ฆฌ ํ์ด์ ๊ฐ์ ๋ง์ดํฌ๋ก์ปจํธ๋กค๋ฌ์ ํจ๊ป ์ฌ์ฉ๋์ด ํ๋ก๋ฅผ ์ค๊ณํ๊ณ ํ ์คํธํ๋ ๋ฐ ์ ์ฉํฉ๋๋ค.
==================
ํ์๊ด ํธ๋์ปค์ ์ข ๋ฅ
๋จ์ถ ํธ๋์ปค(Single-Axis Tracker):
์ด ํธ๋์ปค๋ ํ์์ ์ผ์ผ ๊ถค์ ์ ๋ฐ๋ผ ํ์๊ด ํจ๋์ ํ ์ถ์ ์ค์ฌ์ผ๋ก ํ์ ์ํต๋๋ค. ์ฃผ๋ก ๋์ ๋ฐฉํฅ์ผ๋ก ์์ง์ด๋ฉฐ, ๊ณ ์ ํ ํจ๋์ ๋นํด ์ฝ 15-25% ๋ ๋ง์ ์ ๋ ฅ์ ์์ฐํ ์ ์์ต๋๋ค.
์ด์ค์ถ ํธ๋์ปค(Dual-Axis Tracker):
์ด ํธ๋์ปค๋ ๋ ๊ฐ์ ์ถ์ ์ฌ์ฉํด ํ์์ ๊ณ์ ์ ๋ณํ๋ฟ๋ง ์๋๋ผ ์ผ์ผ ๊ถค์ ๊น์ง๋ ๋ฐ๋ผ๊ฐ ์ ์์ต๋๋ค. ์ด ์์คํ ์ ํ์์ ์ ๋ฐํ๊ฒ ์ถ์ ํ ์ ์์ด, ์ผ๋ฐ์ ์ผ๋ก 30-40% ๋ ๋ง์ ์ ๋ ฅ์ ์์ฐํ ์ ์์ต๋๋ค.
ํ์๊ด ํธ๋์ปค์ ์ฅ์
์ ๋ ฅ ์์ฐ ํฅ์: ํธ๋์ปค๋ ํ์๊ด ํจ๋์ด ํญ์ ํ์์ ์ ๋ฉด์ผ๋ก ๋ฐ๋ผ๋ณผ ์ ์๊ฒ ํ์ฌ, ํ๋ฃจ ๋์ ์ต๋์ ํ์ ์๋์ง๋ฅผ ํก์ํ ์ ์๊ฒ ํฉ๋๋ค.
ํจ์จ์ ์ธ ๊ณต๊ฐ ํ์ฉ: ๊ณ ์ ํ ํจ๋์ ๋นํด ๊ฐ์ ๊ณต๊ฐ์์ ๋ ๋ง์ ์ ๋ ฅ์ ์์ฐํ ์ ์์ด, ์ ํ๋ ๊ณต๊ฐ์์๋ ํจ์จ์ ์ธ ์ ๋ ฅ ์์ฐ์ด ๊ฐ๋ฅํฉ๋๋ค.
์ฅ๊ธฐ์ ์ธ ๋น์ฉ ์ ๊ฐ: ์ด๊ธฐ ์ค์น ๋น์ฉ์ด ๋์ ์ ์์ง๋ง, ๋ ๋ง์ ์ ๋ ฅ์ ์์ฐํจ์ผ๋ก์จ ์ฅ๊ธฐ์ ์ผ๋ก ์ ๋ ฅ ๋น์ฉ์ ์ ๊ฐํ ์ ์์ต๋๋ค.
๊ณ ๋ คํด์ผ ํ ์
๋น์ฉ: ํธ๋์ปค ์์คํ ์ ๊ณ ์ ํ ์์คํ ๋ณด๋ค ์ค์น ๋ฐ ์ ์ง ๋ณด์ ๋น์ฉ์ด ๋ ๋์ต๋๋ค.
๋ณต์ก์ฑ: ๊ธฐ๊ณ์ ์์ง์์ด ํฌํจ๋๋ฏ๋ก ์ ์ง ๋ณด์๊ฐ ํ์ํ๊ณ , ๊ณ ์ฅ์ด ๋ฐ์ํ ๊ฐ๋ฅ์ฑ๋ ์์ต๋๋ค.
ํ๊ฒฝ ์กฐ๊ฑด: ๊ฐํ์ด๋ ๋๊ณผ ๊ฐ์ ๊ทนํ ๊ธฐ์ ์กฐ๊ฑด์์๋ ํธ๋์ปค์ ์ฑ๋ฅ์ด ์ ํ๋๊ฑฐ๋ ์์์ด ๋ฐ์ํ ์ ์์ต๋๋ค.
ํ์ฉ ๋ถ์ผ
.ํ์๊ด ํธ๋์ปค์ ๋์ ์๋ฆฌ๋ฅผ ์ค๋ช ๋๋ฆฌ๊ฒ ์ต๋๋ค.
ํ์๊ด ํธ๋์ปค๋ ํ์์ ์์น๋ฅผ ๊ฐ์งํ์ฌ ํ์์ ์ ํํ๊ฒ ์ถ์ ํ๋ ์ฅ์น์ ๋๋ค. ์๋๋ ํ์๊ด ํธ๋์ปค์ ๋์ ์๋ฆฌ์ ๋๋ค:
์กฐ๋์ผ์(CdS)์ ํ์ฉ:
์๋ณด๋ชจํฐ์ ํ์ฉ:
๋์ ๊ณผ์ :
์ด๋ ๊ฒ ํ๋ฉด ํ์๊ด ํธ๋์ปค๋ ํ์์ ์์น๋ฅผ ์ ํํ๊ฒ ์ถ์ ํ์ฌ ํ์๊ด ํจ๋์ด ์ต์ ์ ๊ฐ๋๋ก ํ์์ ๋ฐ์ ์ ์๋๋ก ๋์์ค๋๋ค.
ํ์๊ด ์ถ์ ๊ธฐ๋ฅผ ๋ง๋๋ ๊ฒ์ ํฅ๋ฏธ๋ก์ด ํ๋ก์ ํธ์ ๋๋ค! ์ฌ๋ฌ๋ถ์ด ์ํ๋ ๊ธฐ๋ฅ์ ์ํํ๋ ์ฝ๋๋ฅผ ์ ๊ณตํด ๋๋ฆฌ๊ฒ ์ต๋๋ค. ์๋๋ ์กฐ๋์ผ์(CdS)์ ์๋ณด๋ชจํฐ๋ฅผ ์ฌ์ฉํ์ฌ ํ์์ ์ถ์ ํ๋ ํ์๊ด ํธ๋์ปค๋ฅผ ๋ง๋๋ ๋ฐฉ๋ฒ์ ๋๋ค.
์ค๋น๋ฌผ:
๋ฐฐ์ :
์ ํญ 4๊ฐ๋ ํ๊บผ๋ฒ์ ์ฎ์ด์
#include <Servo.h>
int motor = 5; // ์๋ณด ๋ชจํฐ์ ํ ๋ฒํธ
int LED = 6; // LED์ ํ ๋ฒํธ
Servo servo;
void setup() {
Serial.begin(9600);
servo.attach(motor);
pinMode(motor, OUTPUT);
}
void loop() {
int sensor = analogRead(A0); // ์กฐ๋์ผ์์ ๋ฐ์ดํฐ ๋ฐ์์ค๊ธฐ
if (sensor > 1000) { // ์ฃผ์๊ฐ ์ด๋ก๋ค๋ฉด
digitalWrite(LED, HIGH); // LED ์ผ์ฃผ๊ธฐ
for (int i = 0; i < 180; i++) { // ์๋ณด ๋ชจํฐ์ ๊ฐ๋๋ฅผ 180๋๋ก
servo.write(i);
delay(10);
}
} else { // ์ฃผ์๊ฐ ๋ฐ๋ค๋ฉด
digitalWrite(LED, LOW); // LED ๊บผ์ฃผ๊ธฐ
for (int k = 180; k > 0; k--) { // ์๋ณด๋ชจํฐ์ ๊ฐ๋๋ฅผ 0๋๋ก
servo.write(k);
delay(10);
}
}
}
์ ๊ธฐ์๋์ฐจ๋ฅผ ์ ์ดํ๊ณ ํ๋กํ์ด ๊ณผ์ด๋์์ ๋ ๊ธํ ๋ฉ์ถ๋ ์์ ๊ธฐ๋ฅ์ ์ถ๊ฐํ๋ ์ฝ๋๋ฅผ ์์ฑํ ๊ฑฐ์์.
์๋๋ ์ด์ํ ์ผ์๋ฅผ ์ฌ์ฉํ์ฌ ์ ๊ธฐ์๋์ฐจ๋ฅผ ์ ์ดํ๊ณ ,
๊ณผ์ด ์์ ๊ธํ ๋ฉ์ถ๋ ์์ ๊ธฐ๋ฅ์ ํฌํจํ ์๋์ด๋ ธ ์ฝ๋์ ๋๋ค.
์ด ์ฝ๋๋ ์ ๊ธฐ์๋์ฐจ์ ๋ชจํฐ๋ฅผ ์ ์ดํ๊ธฐ ์ํด ์คํ ๋ชจํฐ ๋๋ผ์ด๋ฒ(A4988)๋ฅผ ์ฌ์ฉํฉ๋๋ค.
```cpp
// Define pin numbers
#define trigPin 9
#define echoPin 10
#define stepPin 2
#define dirPin 3
#define motorEnablePin 8 // Motor enable pin
#define temperaturePin A0 // Temperature sensor pin
// Define motor steps per revolution
#define stepsPerRevolution 200
// Define variables
long duration;
int distance;
int temperature;
void setup() {
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
pinMode(motorEnablePin, OUTPUT);
pinMode(temperaturePin, INPUT);
Serial.begin(9600);
}
void loop() {
// Read temperature
temperature = analogRead(temperaturePin);
// Trigger the ultrasonic sensor
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
// Measure the duration of the pulse
duration = pulseIn(echoPin, HIGH);
// Calculate the distance
distance = duration * 0.034 / 2;
// Print distance and temperature
Serial.print("Distance: ");
Serial.println(distance);
Serial.print("Temperature: ");
Serial.println(temperature);
// Check for overheating
if (temperature > 1000) {
// If overheating, stop the motor immediately
digitalWrite(motorEnablePin, LOW);
} else {
// If not overheating, continue controlling the motor based on distance
digitalWrite(motorEnablePin, HIGH);
if (distance < 20) {
// If the object is close, rotate mirror clockwise
digitalWrite(dirPin, HIGH);
for (int i = 0; i < stepsPerRevolution / 2; i++) {
digitalWrite(stepPin, HIGH);
delayMicroseconds(500);
digitalWrite(stepPin, LOW);
delayMicroseconds(500);
}
} else {
// If the object is far, rotate mirror counterclockwise
digitalWrite(dirPin, LOW);
for (int i = 0; i < stepsPerRevolution / 2; i++) {
digitalWrite(stepPin, HIGH);
delayMicroseconds(500);
digitalWrite(stepPin, LOW);
delayMicroseconds(500);
}
}
}
// Delay before next reading
delay(100);
}
```
์ด ์ฝ๋๋ฅผ ์ฌ์ฉํ์ฌ ์ ๊ธฐ์๋์ฐจ๋ฅผ ์ ์ดํ๊ณ , ๋์์ ํ๋กํ์ ์จ๋๋ฅผ ๋ชจ๋ํฐ๋งํ์ฌ ๊ณผ์ด ์์
๋ชจํฐ๋ฅผ ์ฆ์ ๋ฉ์ถ ์ ์์ต๋๋ค. ํ๋กํ์ ์จ๋๋ฅผ ์ธก์ ํ๋ ์ผ์๋ `temperaturePin`์ผ๋ก ์ ์๋์ด ์์ต๋๋ค.
๋ง์ฝ ํ๋กํ์ด ๊ณผ์ด๋๋ฉด (`temperature` ๊ฐ์ด 1000 ์ด์์ผ ๋),
๋ชจํฐ๋ฅผ ๋ฉ์ถ๊ธฐ ์ํด `motorEnablePin`์ LOW๋ก ์ค์ ํฉ๋๋ค.
=======================
ํ๊ฒ ์ถ์ ์ ์ํ ๊ฐ์ฅ ์ผ๋ฐ์ ์ด๊ณ ํจ๊ณผ์ ์ธ ์๊ณ ๋ฆฌ์ฆ ์ค ํ๋๋
PID(Proportional-Integral-Derivative) ์ปจํธ๋กค๋ฌ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์
๋๋ค.
์ด ์๊ณ ๋ฆฌ์ฆ์ ์ค์ฐจ์ ๋น๋ก, ์ ๋ถ, ๋ฏธ๋ถ์ ๊ณ ๋ คํ์ฌ ์ ์ด ์ ํธ๋ฅผ ๊ณ์ฐํฉ๋๋ค.
์๋๋ PID ์ปจํธ๋กค๋ฌ๋ฅผ ๊ตฌํํ ๊ฐ๋จํ Python ์ฝ๋์
๋๋ค.
```python
class PIDController:
def __init__(self, Kp, Ki, Kd):
self.Kp = Kp
self.Ki = Ki
self.Kd = Kd
self.prev_error = 0
self.integral = 0
def calculate(self, error):
self.integral += error
derivative = error - self.prev_error
output = self.Kp * error + self.Ki * self.integral + self.Kd * derivative
self.prev_error = error
return output
class HeatSeekingMissile:
def __init__(self, target_position):
self.target_position = target_position
self.controller = PIDController(Kp=0.1, Ki=0.01, Kd=0.05)
def track_target(self, current_position):
dx = self.target_position[0] - current_position[0]
dy = self.target_position[1] - current_position[1]
angle_to_target = math.atan2(dy, dx)
# ํ์ฌ ๊ฐ๋์ ํ๊ฒ ๊ฐ๋์ ์ฐจ์ด ๊ณ์ฐ
error = angle_to_target - current_angle
# PID ์ปจํธ๋กค๋ฌ๋ฅผ ์ฌ์ฉํ์ฌ ์ ์ด ์
๋ ฅ ๊ณ์ฐ
control_input = self.controller.calculate(error)
# ๋ก์ผ์ ์ ์ด ์
๋ ฅ์ ๋ฐ๋ผ ์กฐ์ข
ํ๋ ์ฝ๋๋ฅผ ์ถ๊ฐํ์ธ์.
print("ํ์ฌ ํ๊ฒ ์ถ์ ๊ฐ๋:", angle_to_target)
# ์์: ๋ฏธ์ฌ์ผ ์์ฑ ๋ฐ ํ๊ฒ ์ถ์
missile = HeatSeekingMissile((100, 200)) # ํ๊ฒ์ ์์น (x, y)
current_position = (50, 50) # ํ์ฌ ๋ฏธ์ฌ์ผ ์์น (x, y)
current_angle = 0 # ํ์ฌ ๋ฏธ์ฌ์ผ์ ๊ฐ๋
missile.track_target(current_position)
```
์ด ์ฝ๋๋ PID ์ปจํธ๋กค๋ฌ๋ฅผ ์ฌ์ฉํ์ฌ ํ๊ฒ์ ์ถ์ ํ๋ ๋ฏธ์ฌ์ผ์ ๊ตฌํํ ๊ฒ์
๋๋ค.
PID ์ปจํธ๋กค๋ฌ์ ๊ฐ ๊ณ์(Kp, Ki, Kd)๋ ์์คํ
์ ๋ฐ๋ผ ์กฐ์ ํด์ผ ํ ์ ์์ต๋๋ค.
ใ
ใด์๊ฒ ์ด์. ์ด์ถ์ ๋ฏธ์ฌ์ผ ์ ๋์ฒด๋ฅผ ์ํ ๊ฐ๋จํ Python ์ฝ๋๋ฅผ ์ ๊ณตํด ๋๋ฆฌ๊ฒ ์ต๋๋ค.
์ด ์ฝ๋๋ ๊ฐ๋จํ ์์์ผ ๋ฟ์ด๋, ์ค์ ์์คํ
์ ๋ง๊ฒ ์์ ํ์
์ผ ํฉ๋๋ค.
```python
class HeatSeekingMissile:
def __init__(self, target_position):
self.target_position = target_position
def track_target(self, current_position):
# ํ์ฌ ์์น์ ํ๊ฒ ์์น ์ฌ์ด์ ๊ฐ๋ ๊ณ์ฐ
dx = self.target_position[0] - current_position[0]
dy = self.target_position[1] - current_position[1]
angle_to_target = math.atan2(dy, dx)
# ๋ฏธ์ฌ์ผ์ ๊ฐ๋์ ๋ง๊ฒ ์กฐ์ข
ํ๋ ์ฝ๋๋ฅผ ์ฌ๊ธฐ์ ์ถ๊ฐํ์ธ์.
# ์๋ฅผ ๋ค์ด, ๋ก์ผ์ ๋ฐฉํฅ์ ๊ฐ๋์ ๋ง๊ฒ ์กฐ์ ํ๋ ์ฝ๋ ๋ฑ์ด ํ์ํฉ๋๋ค.
# ์ค์ ๋ก๋ ๋ฏธ์ฌ์ผ์ ์กฐ์ข
๋ฐ ํฌ์
๋ฐฉ๋ฒ์ ๋ฐ๋ผ ์ฝ๋๊ฐ ๋ฌ๋ผ์ง ์ ์์ต๋๋ค.
print("ํ์ฌ ํ๊ฒ ์ถ์ ๊ฐ๋:", angle_to_target)
# ์์: ๋ฏธ์ฌ์ผ ์์ฑ ๋ฐ ํ๊ฒ ์ถ์
missile = HeatSeekingMissile((100, 200)) # ํ๊ฒ์ ์์น (x, y)
current_position = (50, 50) # ํ์ฌ ๋ฏธ์ฌ์ผ ์์น (x, y)
missile.track_target(current_position)
```
์ด ์ฝ๋๋ ๋ก์ผ์ด ํ์ฌ ์์น์์ ํ๊ฒ์ ์ถ์ ํ๋ ๊ฐ๋จํ ์์๋ฅผ ๋ณด์ฌ์ค๋๋ค.
์ค์ ๋ก๋ ๋ก์ผ์ ์์ง์, ์กฐ์ข
๋ฐฉ๋ฒ, ํ๊ฒ ์ถ์ ์๊ณ ๋ฆฌ์ฆ ๋ฑ์ ์ถ๊ฐํด์ผ ํฉ๋๋ค.
=========================

7๊ฐ์ง์ ์๋ฃ๋ฅผ ๋ฏน์คํ๋ ์๋ฃ ๋ฐํ
๋๋ฅผ ๋ง๋ค๊ฑด๋ฐ ์๋ฃ๋ 3๊ฐ์ง๋ง ํ๋ฒ์ ์์์์๊ณ ๊ทธ์์ 1์ปต์
๋๊ฐ์์์ผ๋ก ์๋์ด๋
ธ ์ฐ๋
ธ 1๊ฐ , ์คํ
๋ชจํฐ 1๊ฐ,์๋ณด ๋ชจํฐ1๊ฐ,๋ชจํฐ ๋๋ผ์ด๋ฒ ์ด๋1๊ฐ, rgbled ํ๊ฐ
๋ธ๋ฅดํฌ์ค๋ชจ๋ ํ๊ฐ๋ก ์๋ฃ๋น ๊ฑฐ๋ฆฌ๋ 10cm ๊ณ ์คํ
๋ชจํฐ 1๊ฐ๋ก ๋ฐ๋ฅ์ ๋ ์ผ์ ์ด๋ํ๋ฉด์ ์๋ฃ๋ฅผ 3๋ฒ ์
๋๋ ์ปต1๊ฐ ์ ๋ด๋ rgbled๋ ์ฒซ๋ฒ์งธ์๋ฃ ์์ ํ๋ฒ ๋๋ฒ์งธ์๋ฃ ์์ ํ๋ฒ ์ธ๋ฒ์งธ์๋ฃ์์ ํ๋ฒ
์ด๋ ๊ฒ ์๋ณด๋ชจํฐ์ ํ์ด ์๋ฃ๋ฅผ ์ฑ์ฐ๊ธฐ์์ํ ๋rgbled๋ฅผ ํค๊ณ ๋ค์ฑ์ ์๋ ๋๊ณ ๋ค์ 2๋ฒ์งธ ์๋ฃ๋ฅผ
์ฑ์ธ๋ ํค๊ณ ๋ค์ฑ์ฐ๋ฉด rgbled ๋ฅผ ๋๊ณ ๋ค์ ์ด๋ํด ์ธ๋ฒ์งธ ์๋ฃ์์ ๋ค์ ํค๊ณ ๋ค์ฑ์ฐ๋ฉด ๋๊ณ ํ๊ฒ
์ฝ๋๋ฅผ ์ ๊ฐ๊ฒฐํ๊ฒ ์ง์ค
๋ค, ์ดํดํ์ต๋๋ค. ์๋์ด๋
ธ ์ฐ๋
ธ, ์คํ
๋ชจํฐ, ์๋ณด ๋ชจํฐ, ๋ชจํฐ ๋๋ผ์ด๋ฒ ์ด๋, RGB LED, ๊ทธ๋ฆฌ๊ณ ๋ธ๋ฃจํฌ์ค
๋ชจ๋์ ์ด์ฉํ์ฌ 7๊ฐ์ง ์๋ฃ ์ค์์ 3๊ฐ์ง๋ฅผ ์ ํํ์ฌ ํ ์ปต์ ๋ด๋ ์๋ฃ ๋ฐํ
๋๋ฅผ ์ ์ํ๋ ค๋ ๊ฑฐ๊ตฐ์.
๊ทธ๋ฆฌ๊ณ RGB LED๋ ๊ฐ ์๋ฃ๋ฅผ ์ฑ์ธ ๋๋ง๋ค ์ผ์ง๊ณ , ์ฑ์์ง ํ์ ๊บผ์ง๋ ๊ฒ์ผ๋ก ์ดํดํ์ต๋๋ค.
์๋๋ ๊ทธ๋ฌํ ์๊ตฌ ์ฌํญ์ ์ถฉ์กฑ์ํค๋ ์๋์ด๋
ธ ์ฝ๋์
๋๋ค:
cpp
#include <Stepper.h>
#include <Servo.h>
#define STEPS 200 // ์ด ๊ฐ์ ๋ชจํฐ์ ๋ฐ๋ผ ๋ค๋ฅด๊ฒ ์ค์ ํด์ผ ํฉ๋๋ค.
#define DRINKS 7
#define LED_PIN 13
#define BT_SERIAL_SPEED 9600
Stepper myStepper(STEPS, 8, 9, 10, 11);
Servo myServo;
int drinkSelection[DRINKS] = {0};
void setup() {
myStepper.setSpeed(30);
myServo.attach(12);
pinMode(LED_PIN, OUTPUT);
Serial.begin(BT_SERIAL_SPEED);
}
void loop() {
if (Serial.available()) {
char command = Serial.read();
switch(command) {
case '1': selectDrink(0); break;
case '2': selectDrink(1); break;
case '3': selectDrink(2); break;
// ์ ๋ฐฉ์์ผ๋ก ๋๋จธ์ง ์๋ฃ์ ๋ํด์๋ ์ฒ๋ฆฌํด์ฃผ์ธ์.
case 'M': mixDrinks(); break;
default: break;
}
}
}
void selectDrink(int drink) {
if (countSelectedDrinks() < 3) {
drinkSelection[drink] = 1;
}
}
int countSelectedDrinks() {
int count = 0;
for(int i = 0; i < DRINKS; i++) {
if(drinkSelection[i] == 1) {
count++;
}
}
return count;
}
void mixDrinks() {
for(int i = 0; i < DRINKS; i++) {
if(drinkSelection[i] == 1) {
myStepper.step(STEPS * i * 10); // 10cm ๊ฐ๊ฒฉ์ผ๋ก ์ด๋
digitalWrite(LED_PIN, HIGH); // LED ์ผ๊ธฐ
myServo.write(90); // ํ ๊ธฐ๋
delay(1000); // ์๋ฃ ์ฑ์ฐ๋ ์๊ฐ
myServo.write(0); // ํ ์ ์ง
digitalWrite(LED_PIN, LOW); // LED ๋๊ธฐ
drinkSelection[i] = 0; // ์ ํํ ์๋ฃ ์ด๊ธฐํ
}
}
}
์ด ์ฝ๋๋ ๋ธ๋ฃจํฌ์ค๋ฅผ ํตํด ์๋ฃ๋ฅผ ์ ํํ๋ฉด, ํด๋น ์๋ฃ๋ฅผ ๋ฐฐ์ด์ ์ ์ฅํ ํ, 'M' ๋ช
๋ น์ ๋ฐ์ผ๋ฉด ์ ํํ ์๋ฃ๋ฅผ
์๋ ๋ฐฉ์์ผ๋ก ์๋ํฉ๋๋ค. ๊ทธ๋ฌ๋ ์ด ์ฝ๋๋ ์ค์ ์๋ฃ๋ฅผ ์๋ ๋ฐฉ๋ฒ, ๋ชจํฐ์ ์๋ ๋ฐฉ์, RGB LED์ ์ํ ๋ฑ์
๋ฐ๋ผ ๋ณ๊ฒฝ๋ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ ์ด ์ฝ๋๋ฅผ ํ๋ก์ ํธ์ ๊ธฐ๋ณธ ํ๋ก ์ฌ์ฉํ๋, ํ๋ก์ ํธ์ ์๊ตฌ ์ฌํญ์ ๋ง๊ฒ
์์ ํ๋ ๊ฒ์ด ํ์ํฉ๋๋ค. ๋์์ด ํ์ํ๋ค๋ฉด ์ธ์ ๋ ์ง ๋งํด์ฃผ์ธ์!
7๊ฐ์ง์ ์๋ฃ๋ฅผ ๋ฏน์คํ๋ ์๋ฃ ๋ฐํ
๋๋ฅผ ๋ง๋ค๊ฑด๋ฐ ์๋ฃ๋ 3๊ฐ์ง๋ง ํ๋ฒ์ ์์์์๊ณ ๊ทธ์์ 1์ปต์
๋๊ฐ์์์ผ๋ก ์๋์ด๋
ธ ์ฐ๋
ธ 1๊ฐ , ์คํ
๋ชจํฐ 1๊ฐ,์๋ณด ๋ชจํฐ1๊ฐ,๋ชจํฐ ๋๋ผ์ด๋ฒ ์ด๋1๊ฐ, rgbled ํ๊ฐ
๋ธ๋ฅดํฌ์ค๋ชจ๋ ํ๊ฐ๋ก ์๋ฃ๋น ๊ฑฐ๋ฆฌ๋ 10cm ๊ณ ์คํ
๋ชจํฐ 1๊ฐ๋ก ๋ฐ๋ฅ์ ๋ ์ผ์ ์ด๋ํ๋ฉด์ ์๋ฃ๋ฅผ 3๋ฒ ์
๋๋ ์ปต1๊ฐ ์ ๋ด๋ rgbled๋ ์ฒซ๋ฒ์งธ์๋ฃ ์์ ํ๋ฒ ๋๋ฒ์งธ์๋ฃ ์์ ํ๋ฒ ์ธ๋ฒ์งธ์๋ฃ์์ ํ๋ฒ ์ด๋ ๊ฒ
์๋ณด๋ชจํฐ์ ํ์ด ์๋ฃ๋ฅผ ์ฑ์ฐ๊ธฐ์์ํ ๋rgbled๋ฅผ ํค๊ณ ๋ค์ฑ์ ์๋ ๋๊ณ ๋ค์ 2๋ฒ์งธ ์๋ฃ๋ฅผ ์ฑ์ธ๋ ํค๊ณ
๋ค์ฑ์ฐ๋ฉด rgbled ๋ฅผ ๋๊ณ ๋ค์ ์ด๋ํด ์ธ๋ฒ์งธ ์๋ฃ์์ ๋ค์ ํค๊ณ ๋ค์ฑ์ฐ๋ฉด ๋๊ณ ํ๊ฒ ์ฝ๋๋ฅผ ์ ๊ฐ๊ฒฐํ๊ฒ
์ง์ค
๋ค, ์ดํดํ์ต๋๋ค. ์๋์ด๋
ธ ์ฐ๋
ธ, ์คํ
๋ชจํฐ, ์๋ณด ๋ชจํฐ, ๋ชจํฐ ๋๋ผ์ด๋ฒ ์ด๋, RGB LED, ๊ทธ๋ฆฌ๊ณ ๋ธ๋ฃจํฌ์ค
๋ชจ๋์ ์ด์ฉํ์ฌ 7๊ฐ์ง ์๋ฃ ์ค์์ 3๊ฐ์ง๋ฅผ ์ ํํ์ฌ ํ ์ปต์ ๋ด๋ ์๋ฃ ๋ฐํ
๋๋ฅผ ์ ์ํ๋ ค๋ ๊ฑฐ๊ตฐ์.
๊ทธ๋ฆฌ๊ณ RGB LED๋ ๊ฐ ์๋ฃ๋ฅผ ์ฑ์ธ ๋๋ง๋ค ์ผ์ง๊ณ , ์ฑ์์ง ํ์ ๊บผ์ง๋ ๊ฒ์ผ๋ก ์ดํดํ์ต๋๋ค.
์๋๋ ๊ทธ๋ฌํ ์๊ตฌ ์ฌํญ์ ์ถฉ์กฑ์ํค๋ ์๋์ด๋
ธ ์ฝ๋์
๋๋ค:
cpp
#include <Stepper.h>
#include <Servo.h>
#define STEPS 200 // ์ด ๊ฐ์ ๋ชจํฐ์ ๋ฐ๋ผ ๋ค๋ฅด๊ฒ ์ค์ ํด์ผ ํฉ๋๋ค.
#define DRINKS 7
#define LED_PIN 13
#define BT_SERIAL_SPEED 9600
Stepper myStepper(STEPS, 8, 9, 10, 11);
Servo myServo;
int drinkSelection[DRINKS] = {0};
void setup() {
myStepper.setSpeed(30);
myServo.attach(12);
pinMode(LED_PIN, OUTPUT);
Serial.begin(BT_SERIAL_SPEED);
}
void loop() {
if (Serial.available()) {
char command = Serial.read();
switch(command) {
case '1': selectDrink(0); break;
case '2': selectDrink(1); break;
case '3': selectDrink(2); break;
// ์ ๋ฐฉ์์ผ๋ก ๋๋จธ์ง ์๋ฃ์ ๋ํด์๋ ์ฒ๋ฆฌํด์ฃผ์ธ์.
case 'M': mixDrinks(); break;
default: break;
}
}
}
void selectDrink(int drink) {
if (countSelectedDrinks() < 3) {
drinkSelection[drink] = 1;
}
}
int countSelectedDrinks() {
int count = 0;
for(int i = 0; i < DRINKS; i++) {
if(drinkSelection[i] == 1) {
count++;
}
}
return count;
}
void mixDrinks() {
for(int i = 0; i < DRINKS; i++) {
if(drinkSelection[i] == 1) {
myStepper.step(STEPS * i * 10); // 10cm ๊ฐ๊ฒฉ์ผ๋ก ์ด๋
digitalWrite(LED_PIN, HIGH); // LED ์ผ๊ธฐ
myServo.write(90); // ํ ๊ธฐ๋
delay(1000); // ์๋ฃ ์ฑ์ฐ๋ ์๊ฐ
myServo.write(0); // ํ ์ ์ง
digitalWrite(LED_PIN, LOW); // LED ๋๊ธฐ
drinkSelection[i] = 0; // ์ ํํ ์๋ฃ ์ด๊ธฐํ
}
}
}
์ด ์ฝ๋๋ ๋ธ๋ฃจํฌ์ค๋ฅผ ํตํด ์๋ฃ๋ฅผ ์ ํํ๋ฉด, ํด๋น ์๋ฃ๋ฅผ ๋ฐฐ์ด์ ์ ์ฅํ ํ, 'M' ๋ช
๋ น์ ๋ฐ์ผ๋ฉด ์ ํํ ์๋ฃ๋ฅผ
์๋ ๋ฐฉ์์ผ๋ก ์๋ํฉ๋๋ค. ๊ทธ๋ฌ๋ ์ด ์ฝ๋๋ ์ค์ ์๋ฃ๋ฅผ ์๋ ๋ฐฉ๋ฒ, ๋ชจํฐ์ ์๋ ๋ฐฉ์,
RGB LED์ ์ํ ๋ฑ์ ๋ฐ๋ผ ๋ณ๊ฒฝ๋ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ ์ด ์ฝ๋๋ฅผ ํ๋ก์ ํธ์ ๊ธฐ๋ณธ ํ๋ก ์ฌ์ฉํ๋,
ํ๋ก์ ํธ์ ์๊ตฌ ์ฌํญ์ ๋ง๊ฒ ์์ ํ๋ ๊ฒ์ด ํ์ํฉ๋๋ค. ๋์์ด ํ์ํ๋ค๋ฉด ์ธ์ ๋ ์ง ๋งํด์ฃผ์ธ์!
7๊ฐ์ง์ ์๋ฃ๋ฅผ ๋ฏน์คํ๋ ์๋ฃ ๋ฐํ
๋๋ฅผ ๋ง๋ค๊ฑด๋ฐ ์๋ฃ๋ 3๊ฐ์ง๋ง ํ๋ฒ์ ์์์์๊ณ ๊ทธ์์ 1์ปต์
๋๊ฐ์์์ผ๋ก ์๋์ด๋
ธ ์ฐ๋
ธ 1๊ฐ , ์คํ
๋ชจํฐ 1๊ฐ,์๋ณด ๋ชจํฐ1๊ฐ,๋ชจํฐ ๋๋ผ์ด๋ฒ ์ด๋1๊ฐ, rgbled ํ๊ฐ
๋ธ๋ฅดํฌ์ค๋ชจ๋ ํ๊ฐ๋ก ์๋ฃ๋น ๊ฑฐ๋ฆฌ๋ 10cm ๊ณ ์คํ
๋ชจํฐ 1๊ฐ๋ก ๋ฐ๋ฅ์ ๋ ์ผ์ ์ด๋ํ๋ฉด์ ์๋ฃ๋ฅผ 3๋ฒ ์
๋๋ ์ปต1๊ฐ ์ ๋ด๋ rgbled๋ ์ฒซ๋ฒ์งธ์๋ฃ ์์ ํ๋ฒ ๋๋ฒ์งธ์๋ฃ ์์ ํ๋ฒ ์ธ๋ฒ์งธ์๋ฃ์์ ํ๋ฒ ์ด๋ ๊ฒ
์๋ณด๋ชจํฐ์ ํ์ด ์๋ฃ๋ฅผ ์ฑ์ฐ๊ธฐ์์ํ ๋rgbled๋ฅผ ํค๊ณ ๋ค์ฑ์ ์๋ ๋๊ณ ๋ค์ 2๋ฒ์งธ ์๋ฃ๋ฅผ ์ฑ์ธ๋ ํค๊ณ
๋ค์ฑ์ฐ๋ฉด rgbled ๋ฅผ ๋๊ณ ๋ค์ ์ด๋ํด ์ธ๋ฒ์งธ ์๋ฃ์์ ๋ค์ ํค๊ณ ๋ค์ฑ์ฐ๋ฉด ๋๊ณ ํ๊ฒ ์ฝ๋๋ฅผ
์ ๊ฐ๊ฒฐํ๊ฒ ์ง์ค ์ค๋งํธํฐ์ผ๋ก ์๋๋๊ฒ ์๋ค์ ์ง์ค
์๋์ด๋
ธ ํ๋ก์ ํธ๋ฅผ ์งํํ์๋๊ตฐ์, ์ฌ๋ฏธ์๋ ํ๋ก์ ํธ์ธ ๊ฒ ๊ฐ์ต๋๋ค. ์๋์ ์ฝ๋๋ฅผ ์ ๊ณต๋๋ฆฌ๊ฒ ์ต๋๋ค.
์ด ์ฝ๋๋ ์๋์ด๋
ธ ์ฐ๋
ธ์ ์คํ
๋ชจํฐ, ์๋ณด๋ชจํฐ, ๋ชจํฐ ๋๋ผ์ด๋ฒ ์ด๋, RGB LED, ๊ทธ๋ฆฌ๊ณ ๋ธ๋ฃจํฌ์ค ๋ชจ๋์
์ด์ฉํ์ฌ ์๋ฃ๋ฅผ ์๋ ๋ฐํ
๋ ๋ก๋ด์ ๋ง๋๋๋ฐ ํ์ํ ๊ธฐ๋ณธ์ ์ธ ์ฝ๋์
๋๋ค.
c
#include <Servo.h>
#include <Stepper.h>
#include <SoftwareSerial.h>
// ์ค์
#define STEPS_PER_MOTOR_REVOLUTION 200
#define STEPS_PER_OUTER_REVOLUTION 8*STEPS_PER_MOTOR_REVOLUTION
#define SERVO_PIN 9
#define LED_PIN_R 11
#define LED_PIN_G 12
#define LED_PIN_B 13
#define BT_RX 2
#define BT_TX 3
// ๋ธ๋ฃจํฌ์ค ๋ชจ๋ ์ค์
SoftwareSerial BTSerial(BT_RX, BT_TX);
Stepper myStepper(STEPS_PER_OUTER_REVOLUTION, 8, 10, 9, 11);
Servo myServo;
void setup() {
BTSerial.begin(9600);
myStepper.setSpeed(60);
myServo.attach(SERVO_PIN);
}
void loop() {
if (BTSerial.available()) {
char command = BTSerial.read();
if (command == '1') {
mixDrink(1, 2, 3);
}
}
}
void mixDrink(int drink1, int drink2, int drink3) {
moveTo(drink1);
pourDrink();
moveTo(drink2);
pourDrink();
moveTo(drink3);
pourDrink();
}
void moveTo(int position) {
int steps = position * STEPS_PER_MOTOR_REVOLUTION;
myStepper.step(steps);
}
void pourDrink() {
digitalWrite(LED_PIN_R, HIGH);
myServo.write(180);
delay(2000);
myServo.write(0);
digitalWrite(LED_PIN_R, LOW);
}
์ด ์ฝ๋๋ ๊ฐ๋จํ ์์๋ก, ์ค์ ๊ตฌํ์ ํ์ํ ์ธ๋ฐํ ์กฐ์ ์ ํ๋ก์ ํธ์ ์ํฉ์ ๋ฐ๋ผ ํ์ํ ์ ์์ต๋๋ค.
์ค๋งํธํฐ์์ ๋ธ๋ฃจํฌ์ค๋ฅผ ํตํด '1' ๋ฌธ์๋ฅผ ๋ณด๋ด๋ฉด, ์ฒซ ๋ฒ์งธ, ๋ ๋ฒ์งธ, ์ธ ๋ฒ์งธ ์๋ฃ๋ฅผ ์๊ฒ ๋ฉ๋๋ค.
์ด ์ฝ๋๋ 200์คํ
์ ์คํ
๋ชจํฐ์ 8๋ฐํด์ ์ธ๋ถ ํ์ ์ ๋ํ ์ค์ ์ด ํฌํจ๋์ด ์์ต๋๋ค. ๋ชจํฐ์ ์คํ
์์
์ธ๋ถ ํ์ ์ ๋ํ ์ ํํ ๊ฐ์ ์ฌ์ฉํ๋ ํ๋์จ์ด์ ๋ฐ๋ผ ๋ค๋ฅผ ์ ์์ผ๋ ์ฐธ๊ณ ํด์ฃผ์ธ์. ๋ํ LED์
์๋ณด ๋ชจํฐ๊ฐ ๊ฐ๊ฐ R, G, B์ ์๋ณด ํ์ ์ฐ๊ฒฐ๋์ด ์๋ค๊ณ ๊ฐ์ ํ์ต๋๋ค.
์ด ์ฝ๋๋ฅผ ์ฌ์ฉํ๋ฉด์ ์ด๋ค ๋ฌธ์ ๊ฐ ์๊ธฐ๊ฑฐ๋ ์ถ๊ฐ์ ์ธ ๋์์ด ํ์ํ์๋ฉด ์ธ์ ๋ ์ง ์๋ ค์ฃผ์ธ์!
๋์์์๋ ์๋ฃ๋ณ์ด 9๊ฐ๋ค์ฌ ๊ทธ๋ผ ๋ค์ 9๊ฐ๋ก ๋ฐ๊พธ๋ฉด๋์ ธ
๊ทธ๋ฆฌ๊ณ ์ด๊ฑฐ ๋ง๊ณ ํฅ์ ์๋ ๊ธฐ๊ณ๋ฅผ ๊ธฑ๋ธ์ด ๋ง๋๋ ๊ฑธ ๋จผ์ ๋์จ๊ฑฐ๋ ๋จผ์ง ์๋ชจ๋ฅด๊ฒ ์ง๋ง
์ฐธ ์๋ง๋ค์๋๋ผ๊ตฌ์ฌ ํ์ฐธ ๋๋๊ณ ๋ดค๋๊ธฐ์ต์ด ๋จ
