๐ค Arduino Nano๋ก ๋ง๋๋ ์ด์ํ ๊ฑฐ๋ฆฌ ์ธก์ ๊ธฐ ๐

์๋ , ์น๊ตฌ๋ค! ์ค๋์ ์ ๋ง ์ฌ๋ฐ๋ ํ๋ก์ ํธ๋ฅผ ํจ๊ป ํด๋ณผ ๊ฑฐ์ผ. ๋ฐ๋ก Arduino Nano์ ์ด์ํ ์ผ์๋ฅผ ์ด์ฉํด์ ๊ฑฐ๋ฆฌ ์ธก์ ๊ธฐ๋ฅผ ๋ง๋ค์ด ๋ณผ ๊ฑฐ๋ ๋ง์ด์ง! ๐ ์ด ํ๋ก์ ํธ๋ฅผ ํตํด ์ฐ๋ฆฌ๋ ํ๋ก๊ทธ๋๋ฐ์ ๊ธฐ์ด๋ถํฐ ํ๋์จ์ด ์ ์ด๊น์ง ๋ค์ํ ๊ฑธ ๋ฐฐ์ธ ์ ์์ ๊ฑฐ์ผ. ๊ทธ๋ผ ์ด์ ๋ถํฐ ์ฐ๋ฆฌ์ ๋ฉ์ง ์ฌ์ ์ ์์ํด๋ณด์๊ตฌ!
๐ก ์ฐธ๊ณ : ์ด ๊ธ์ ์ฌ๋ฅ๋ท(https://www.jaenung.net)์ '์ง์์ธ์ ์ฒ' ๋ฉ๋ด์ ๋ฑ๋ก๋ ์์ ์ด์ผ. ์ฌ๋ฅ๋ท์ ๋ค์ํ ์ฌ๋ฅ์ ๊ฑฐ๋ํ๋ ํ๋ซํผ์ด๋, ์ด ํ๋ก์ ํธ๋ฅผ ๋ง์คํฐํ๊ณ ๋๋ฉด ๋์ ์๋ก์ด ์ฌ๋ฅ์ ๊ณต์ ํด๋ณผ ์๋ ์๊ฒ ์ง?
๐ ๏ธ ์ค๋น๋ฌผ
์, ๊ทธ๋ผ ์ฐ๋ฆฌ์ ๋ฉ์ง ๊ฑฐ๋ฆฌ ์ธก์ ๊ธฐ๋ฅผ ๋ง๋ค๊ธฐ ์ํด ํ์ํ ์ค๋น๋ฌผ๋ค์ ์ดํด๋ณผ๊น?
- Arduino Nano ๋ณด๋
- HC-SR04 ์ด์ํ ์ผ์
- ๋ธ๋ ๋๋ณด๋
- ์ ํผ ์์ด์ด (์-์, ์-์)
- USB ์ผ์ด๋ธ (Arduino Nano ์ฐ๊ฒฐ์ฉ)
- OLED ๋์คํ๋ ์ด (์ต์ )
- 9V ๋ฐฐํฐ๋ฆฌ + ๋ฐฐํฐ๋ฆฌ ํด๋ฆฝ (ํด๋์ฉ์ผ๋ก ๋ง๋ค๊ณ ์ถ๋ค๋ฉด)
์ด ์ ๋๋ฉด ์ถฉ๋ถํด! ํน์ ์ด ์ค์ ๋ญ๊ฐ ์๋ค๊ณ ? ๊ฑฑ์ ๋ง, ์ฌ๋ฅ๋ท์์ ๋ค๋ฅธ ์ฌ๋๋ค์ ๋์์ ๋ฐ์ ๊ตฌํ ์ ์์ ๊ฑฐ์ผ. ์ฌ๋ฅ๋ท์ ์ด๋ฐ ์์ผ๋ก ์๋ก์ ์ฌ๋ฅ๊ณผ ์์์ ๊ณต์ ํ๋ ๋ฉ์ง ํ๋ซํผ์ด์ง. ๐
๐ง Arduino Nano: ์์ง๋ง ๊ฐ๋ ฅํ ๋๋
์ฐ๋ฆฌ์ ํ๋ก์ ํธ์ ํต์ฌ, Arduino Nano์ ๋ํด ์ข ๋ ์์ธํ ์์๋ณผ๊น? Arduino Nano๋ ์์ ํฌ๊ธฐ์ ์์ฒญ๋ ์ฑ๋ฅ์ ๊ฐ์ง ๋ง์ดํฌ๋ก์ปจํธ๋กค๋ฌ ๋ณด๋์ผ. ์ด๋ฆ์์ ์ ์ ์๋ฏ์ด, ์ ๋ง '๋๋ ธ' ์ฌ์ด์ฆ์ง๋ง ๊ทธ ์์ ๋ด๊ธด ๊ธฐ๋ฅ์ ์ด๋ง์ด๋งํด!
Arduino Nano์ ์ฃผ์ ํน์ง์ ์ดํด๋ณผ๊น?
- ๋ง์ดํฌ๋ก์ปจํธ๋กค๋ฌ: ATmega328
- ๋์ ์ ์: 5V
- ์ ๋ ฅ ์ ์: 7-12V
- ๋์งํธ I/O ํ: 14๊ฐ (6๊ฐ๋ PWM ์ถ๋ ฅ ๊ฐ๋ฅ)
- ์๋ ๋ก๊ทธ ์ ๋ ฅ ํ: 8๊ฐ
- ํ๋์ ๋ฉ๋ชจ๋ฆฌ: 32 KB
- SRAM: 2 KB
- EEPROM: 1 KB
- ํด๋ญ ์๋: 16 MHz
์ด ์์ ๋ณด๋ ํ๋๋ก ์ฐ๋ฆฌ๋ ์ ๋ง ๋ค์ํ ํ๋ก์ ํธ๋ฅผ ๋ง๋ค ์ ์์ด. ์ค๋ ์ฐ๋ฆฌ๊ฐ ๋ง๋ค ๊ฑฐ๋ฆฌ ์ธก์ ๊ธฐ๋ ๊ทธ์ค ํ๋์ผ ๋ฟ์ด์ง. ์์๋ ฅ์ ๋ฐํํด๋ณด๋ฉด Arduino Nano๋ก ํ ์ ์๋ ์ผ๋ค์ด ๋ฌด๊ถ๋ฌด์งํด!
๐ ์ด์ํ ์ผ์: ์๋ฆฌ๋ก ๊ฑฐ๋ฆฌ๋ฅผ ์ธก์ ํ๋ค๊ณ ?
์, ์ด์ ์ฐ๋ฆฌ์ ๋ ๋ฒ์งธ ์ฃผ์ธ๊ณต์ธ ์ด์ํ ์ผ์์ ๋ํด ์์๋ณผ ์ฐจ๋ก์ผ. ์ฐ๋ฆฌ๊ฐ ์ฌ์ฉํ HC-SR04 ์ด์ํ ์ผ์๋ ์ด๋ป๊ฒ ๊ฑฐ๋ฆฌ๋ฅผ ์ธก์ ํ ๊น? ๐ค
๐ฆ ์ฌ๋ฏธ์๋ ์ฌ์ค: ๋ฐ์ฅ๋ค๋ ์ด์ํ๋ฅผ ์ด์ฉํด ์ฃผ๋ณ ํ๊ฒฝ์ ํ์งํ๊ณ ๋จน์ด๋ฅผ ์ฐพ์๋ค๋ . ์ฐ๋ฆฌ์ ์ผ์๋ ๋ง์น ์์ ๋ฐ์ฅ์ฒ๋ผ ๋์ํ๋ค๊ณ ๋ณผ ์ ์์ง!
์ด์ํ ์ผ์์ ๋์ ์๋ฆฌ๋ ๋ค์๊ณผ ๊ฐ์:
- ์ด์ํ ๋ฐ์ฌ: ์ผ์์์ ์ด์ํ๋ฅผ ๋ฐ์ฌํด.
- ๋ฐ์ฌํ ๋๊ธฐ: ๋ฐ์ฌ๋ ์ด์ํ๊ฐ ๋ฌผ์ฒด์ ๋ถ๋ชํ ๋์์ฌ ๋๊น์ง ๊ธฐ๋ค๋ ค.
- ์๊ฐ ์ธก์ : ์ด์ํ๊ฐ ๋์์ค๋ ๋ฐ ๊ฑธ๋ฆฐ ์๊ฐ์ ์ธก์ ํด.
- ๊ฑฐ๋ฆฌ ๊ณ์ฐ: ์ธก์ ๋ ์๊ฐ์ ์ด์ฉํด ๊ฑฐ๋ฆฌ๋ฅผ ๊ณ์ฐํด.
์ด์ํ์ ์๋๋ ๋๋ต 340m/s์ผ. ์ด ์๋๋ฅผ ์ด์ฉํด์ ์ฐ๋ฆฌ๋ ์์ฃผ ์ ํํ๊ฒ ๊ฑฐ๋ฆฌ๋ฅผ ์ธก์ ํ ์ ์์ง!
HC-SR04 ์ด์ํ ์ผ์์ ์ฃผ์ ํน์ง์ ์ดํด๋ณผ๊น?
- ๋์ ์ ์: 5V
- ๋์ ์ ๋ฅ: 15mA
- ๋์ ์ฃผํ์: 40Hz
- ์ต๋ ๋ฒ์: 4m
- ์ต์ ๋ฒ์: 2cm
- ์ธก์ ๊ฐ๋: 15๋
- ํธ๋ฆฌ๊ฑฐ ์ ๋ ฅ ์ ํธ: 10ยตs TTL ํ์ค
- ๋ฐํฅ ์ถ๋ ฅ ์ ํธ: ์ ๋ ฅ ๋น๋ก TTL ํ์ค ํญ
์ด ์ผ์๋ ์ ๋ง ๋๋จํด! 2cm์์ 4m๊น์ง์ ๊ฑฐ๋ฆฌ๋ฅผ ์์ฃผ ์ ํํ๊ฒ ์ธก์ ํ ์ ์์ง. ๊ฒ๋ค๊ฐ ์ฌ์ฉํ๊ธฐ๋ ๊ต์ฅํ ์ฌ์. Arduino์ ์ฐ๊ฒฐํด์ ๋ช ์ค์ ์ฝ๋๋ง ์์ฑํ๋ฉด ๋ฐ๋ก ๊ฑฐ๋ฆฌ๋ฅผ ์ธก์ ํ ์ ์๋ค๋, ์ ๋ง ๋๋์ง ์์?
๐ ์ฐ๊ฒฐ: Arduino์ ์ด์ํ ์ผ์์ ๋ง๋จ
์, ์ด์ ์ฐ๋ฆฌ์ ๋ ์ฃผ์ธ๊ณต์ ์ฐ๊ฒฐํ ์๊ฐ์ด์ผ! Arduino Nano์ HC-SR04 ์ด์ํ ์ผ์๋ฅผ ์ด๋ป๊ฒ ์ฐ๊ฒฐํ๋ฉด ๋ ๊น? ๊ฑฑ์ ๋ง, ์๊ฐ๋ณด๋ค ํจ์ฌ ์ฌ์. ๐
๋จผ์ , HC-SR04 ์ด์ํ ์ผ์์ ํ ๊ตฌ์ฑ์ ์ดํด๋ณผ๊ฒ:
- VCC: ์ ์ ๊ณต๊ธ (5V)
- Trig: ํธ๋ฆฌ๊ฑฐ ์ ํธ ์ ๋ ฅ
- Echo: ์์ฝ ์ ํธ ์ถ๋ ฅ
- GND: ์ ์ง
์ด์ ์ด ํ๋ค์ Arduino Nano์ ์ฐ๊ฒฐํด๋ณผ ๊ฑฐ์ผ. ์ฌ๊ธฐ ์ฐ๊ฒฐ ๋ฐฉ๋ฒ์ ์์ธํ ์ค๋ช ํด์ค๊ฒ:
- VCC โ 5V: ์ผ์์ ์ ์์ ๊ณต๊ธํด์ค์ผ ํด. Arduino Nano์ 5V ํ๊ณผ ์ผ์์ VCC ํ์ ์ฐ๊ฒฐํด์ค.
- Trig โ D9: ํธ๋ฆฌ๊ฑฐ ์ ํธ๋ฅผ ๋ณด๋ด๊ธฐ ์ํด Arduino์ ๋์งํธ ํ 9๋ฒ๊ณผ ์ผ์์ Trig ํ์ ์ฐ๊ฒฐํด.
- Echo โ D10: ์์ฝ ์ ํธ๋ฅผ ๋ฐ๊ธฐ ์ํด Arduino์ ๋์งํธ ํ 10๋ฒ๊ณผ ์ผ์์ Echo ํ์ ์ฐ๊ฒฐํด.
- GND โ GND: ๋ง์ง๋ง์ผ๋ก, ์ผ์์ GND ํ์ Arduino์ GND ํ๊ณผ ์ฐ๊ฒฐํด์ค.
์ด๋ ๊ฒ ์ฐ๊ฒฐํ๋ฉด ๊ธฐ๋ณธ์ ์ธ ์ธํ ์ ๋์ด์ผ! ์ ๋ง ๊ฐ๋จํ์ง?
์ด ์ฐ๊ฒฐ๋๋ฅผ ๋ณด๋ฉด์ ์ฐจ๊ทผ์ฐจ๊ทผ ๋ฐ๋ผ ํด๋ณด์. ์ฒ์์๋ ์ข ํท๊ฐ๋ฆด ์ ์์ง๋ง, ๋ช ๋ฒ ํด๋ณด๋ฉด ๊ธ๋ฐฉ ์ต์ํด์ง ๊ฑฐ์ผ. ๊ทธ๋ฆฌ๊ณ ๊ธฐ์ตํด, ํญ์ ์ ์์ ์ฐ๊ฒฐํ๊ธฐ ์ ์ ๋ชจ๋ ์ฐ๊ฒฐ์ด ์ ๋๋ก ๋์๋์ง ๋ค์ ํ ๋ฒ ํ์ธํ๋ ๊ฒ ์ข์. ์์ ์ด ์ต์ฐ์ ์ด๋๊น! ๐ก๏ธ
๐ป ์ฝ๋ฉ ์์: ๊ฑฐ๋ฆฌ ์ธก์ ์ ๋ง๋ฒ
์, ์ด์ ํ๋์จ์ด ์ฐ๊ฒฐ์ ๋๋ฌ์ด. ๋ค์์ ๋ญ๋ค? ๋ฐ๋ก ์ฝ๋ฉ์ด์ง! ๐งโโ๏ธ ์ฐ๋ฆฌ์ Arduino์๊ฒ ์ด๋ป๊ฒ ๋์ํด์ผ ํ๋์ง ์๋ ค์ค ์๊ฐ์ด์ผ. ๊ฑฑ์ ๋ง, ์ด๋ ค์ด ๊ฑฐ ์๋์ผ. ํ ์ค ํ ์ค ์ฐจ๊ทผ์ฐจ๊ทผ ์ค๋ช ํด์ค๊ฒ.
๋จผ์ , Arduino IDE๋ฅผ ์ด๊ณ ์๋ก์ด ์ค์ผ์น๋ฅผ ์์ํด๋ณด์. ๊ทธ๋ฆฌ๊ณ ๋ค์ ์ฝ๋๋ฅผ ์ ๋ ฅํด๋ด:
// HC-SR04 ์ด์ํ ์ผ์ ํ ์ค์
const int trigPin = 9;
const int echoPin = 10;
// ๋ณ์ ์ ์ธ
long duration;
int distance;
void setup() {
// ์๋ฆฌ์ผ ํต์ ์์
Serial.begin(9600);
// ํ ๋ชจ๋ ์ค์
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
}
void loop() {
// ํธ๋ฆฌ๊ฑฐ ํ ์ด๊ธฐํ
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
// ํธ๋ฆฌ๊ฑฐ ํ์ 10ยตs ๋์ HIGH ์ ํธ ๋ณด๋ด๊ธฐ
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
// ์์ฝ ํ์ผ๋ก๋ถํฐ ์ ํธ ์ฝ๊ธฐ
duration = pulseIn(echoPin, HIGH);
// ๊ฑฐ๋ฆฌ ๊ณ์ฐ
distance = duration * 0.034 / 2;
// ์๋ฆฌ์ผ ๋ชจ๋ํฐ์ ๊ฑฐ๋ฆฌ ์ถ๋ ฅ
Serial.print("Distance: ");
Serial.print(distance);
Serial.println(" cm");
delay(1000); // 1์ด ๋๊ธฐ
}
์ฐ์, ์ฝ๋๊ฐ ์ข ๊ธธ์ด ๋ณด์ด์ง? ํ์ง๋ง ๊ฑฑ์ ๋ง. ํ๋์ฉ ๋ฏ์ด๋ณด๋ฉด ์ ๋ง ๊ฐ๋จํด. ์, ์ด์ ์ฝ๋๋ฅผ ์์ธํ ์ดํด๋ณผ๊ฒ.
1. ๋ณ์ ์ ์ธ ๋ฐ ํ ์ค์
const int trigPin = 9;
const int echoPin = 10;
long duration;
int distance;
์ฌ๊ธฐ์๋ ์ฐ๋ฆฌ๊ฐ ์ฌ์ฉํ ํ ๋ฒํธ์ ๋ณ์๋ค์ ์ ์ธํ๊ณ ์์ด. trigPin
์ 9๋ฒ, echoPin
์ 10๋ฒ์ผ๋ก ์ค์ ํ์ด. ์ด๊ฑด ์ฐ๋ฆฌ๊ฐ ์์ ์ฐ๊ฒฐํ ๋๋ก์ผ. duration
์ ์ด์ํ๊ฐ ๋๋์์ค๋ ์๊ฐ์, distance
๋ ๊ณ์ฐ๋ ๊ฑฐ๋ฆฌ๋ฅผ ์ ์ฅํ ๊ฑฐ์ผ.
2. setup() ํจ์
void setup() {
Serial.begin(9600);
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
}
setup()
ํจ์๋ ํ๋ก๊ทธ๋จ์ด ์์๋ ๋ ํ ๋ฒ๋ง ์คํ๋ผ. ์ฌ๊ธฐ์๋ ์๋ฆฌ์ผ ํต์ ์ ์์ํ๊ณ (์ฐ๋ฆฌ๊ฐ ๊ฑฐ๋ฆฌ๋ฅผ ๋ชจ๋ํฐ๋ก ๋ณผ ์ ์๊ฒ), ํ ๋ชจ๋๋ฅผ ์ค์ ํ๊ณ ์์ด. trigPin
์ ์ ํธ๋ฅผ ๋ณด๋ด๋๊น ์ถ๋ ฅ์ผ๋ก, echoPin
์ ์ ํธ๋ฅผ ๋ฐ์ผ๋๊น ์
๋ ฅ์ผ๋ก ์ค์ ํ์ง.
3. loop() ํจ์
์ด์ ์ง์ง ์ค์ํ ๋ถ๋ถ์ด์ผ. loop()
ํจ์๋ ๊ณ์ํด์ ๋ฐ๋ณต ์คํ๋๋ ๋ถ๋ถ์ด์ผ.
void loop() {
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
duration = pulseIn(echoPin, HIGH);
distance = duration * 0.034 / 2;
Serial.print("Distance: ");
Serial.print(distance);
Serial.println(" cm");
delay(1000);
}
์ด ๋ถ๋ถ์ ๋จ๊ณ๋ณ๋ก ์ค๋ช ํด์ค๊ฒ:
- ํธ๋ฆฌ๊ฑฐ ์ ํธ ๋ณด๋ด๊ธฐ:
trigPin
์ ์ ๊น HIGH๋ก ์ค์ ํ๋ค๊ฐ ๋ค์ LOW๋ก ๋ฐ๊ฟ. ์ด๊ฒ ์ด์ํ๋ฅผ ๋ฐ์ฌํ๋ ์ ํธ์ผ. - ์์ฝ ์ ํธ ๋ฐ๊ธฐ:
pulseIn()
ํจ์๋กechoPin
์ด HIGH๊ฐ ๋๋ ์๊ฐ์ ์ธก์ ํด. ์ด๊ฒ ์ด์ํ๊ฐ ๋ฌผ์ฒด์ ๋ถ๋ชํ๊ณ ๋์์ค๋ ๋ฐ ๊ฑธ๋ฆฐ ์๊ฐ์ด์ผ. - ๊ฑฐ๋ฆฌ ๊ณ์ฐ: ์ธก์ ๋ ์๊ฐ์ ์ด์ฉํด ๊ฑฐ๋ฆฌ๋ฅผ ๊ณ์ฐํด. ์ฌ๊ธฐ์ 0.034๋ ์ํ์ ์๋(340m/s)๋ฅผ cm/ยตs ๋จ์๋ก ๋ฐ๊พผ ๊ฐ์ด์ผ. 2๋ก ๋๋๋ ์ด์ ๋ ์ด์ํ๊ฐ ์๋ณตํ๋๊น!
- ๊ฒฐ๊ณผ ์ถ๋ ฅ: ๊ณ์ฐ๋ ๊ฑฐ๋ฆฌ๋ฅผ ์๋ฆฌ์ผ ๋ชจ๋ํฐ์ ์ถ๋ ฅํด.
- ๋๊ธฐ: 1์ด ๋์ ๊ธฐ๋ค๋ ธ๋ค๊ฐ ๋ค์ ์ธก์ ์ ์์ํด.
์ด๋ ๊ฒ ํ๋ฉด ์ฐ๋ฆฌ์ ๊ฑฐ๋ฆฌ ์ธก์ ๊ธฐ๊ฐ ์์ฑ๋๋ ๊ฑฐ์ผ! ์ ๋ง ๋๋จํ์ง ์์? ์ด์ ์ด ์ฝ๋๋ฅผ Arduino Nano์ ์ ๋ก๋ํ๊ณ ์คํํด๋ณด์.
๐ ์คํ ๋ฐ ํ ์คํธ: ์ฐ๋ฆฌ์ ์ํ์ ์ํํด๋ณด์!
๋๋์ด ์ฐ๋ฆฌ์ ๊ฑฐ๋ฆฌ ์ธก์ ๊ธฐ๊ฐ ์์ฑ๋์ด! ์ด์ ์ค์ ๋ก ๋์ํ๋์ง ํ ์คํธํด๋ณผ ์๊ฐ์ด์ผ. ์ ๋ง ํฅ๋ฏธ์ง์งํ์ง ์์? ๐
ํ ์คํธ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์:
- Arduino IDE์์ '์ ๋ก๋' ๋ฒํผ์ ๋๋ฌ ์ฝ๋๋ฅผ Arduino Nano์ ์ ๋ก๋ํด.
- ์ ๋ก๋๊ฐ ์๋ฃ๋๋ฉด, IDE์ ์๋จ ๋ฉ๋ด์์ '๋๊ตฌ' โ '์๋ฆฌ์ผ ๋ชจ๋ํฐ'๋ฅผ ์ ํํด.
- ์๋ฆฌ์ผ ๋ชจ๋ํฐ๊ฐ ์ด๋ฆฌ๋ฉด, ์ฐ์ธก ํ๋จ์ '9600 ๋ณด๋'๊ฐ ์ ํ๋์ด ์๋์ง ํ์ธํด.
- ์ด์ ์ด์ํ ์ผ์ ์์ ๋ฌผ์ฒด๋ฅผ ๋๊ณ ๊ฑฐ๋ฆฌ๋ฅผ ์ธก์ ํด๋ด!
์๋ฆฌ์ผ ๋ชจ๋ํฐ์ "Distance: XX cm"์ ๊ฐ์ ํ์์ผ๋ก ๊ฑฐ๋ฆฌ๊ฐ ํ์๋ ๊ฑฐ์ผ. ๋ฌผ์ฒด๋ฅผ ์๋ค๋ก ์์ง์ฌ๋ณด๋ฉด์ ๊ฑฐ๋ฆฌ๊ฐ ์ด๋ป๊ฒ ๋ณํ๋์ง ๊ด์ฐฐํด๋ด.
๐ก ํ: ์ฒ์์๋ ์๋ฅผ ์ด์ฉํด์ ์ค์ ๊ฑฐ๋ฆฌ์ ์ธก์ ๋ ๊ฑฐ๋ฆฌ๋ฅผ ๋น๊ตํด๋ณด๋ ๊ฒ๋ ์ข์. ์ด๋ ๊ฒ ํ๋ฉด ์ฐ๋ฆฌ์ ๊ฑฐ๋ฆฌ ์ธก์ ๊ธฐ๊ฐ ์ผ๋ง๋ ์ ํํ์ง ์ ์ ์์ง!
๋ง์ฝ ๊ฒฐ๊ณผ๊ฐ ์์๊ณผ ๋ค๋ฅด๋ค๋ฉด, ๋ค์ ์ฌํญ๋ค์ ์ฒดํฌํด๋ด:
- ๋ชจ๋ ์ฐ๊ฒฐ์ด ์ ๋๋ก ๋์ด์๋์ง ํ์ธํด.
- ์ฝ๋์ ์คํ๊ฐ ์๋์ง ๋ค์ ํ ๋ฒ ํ์ธํด.
- ์ผ์ ์์ ์ฅ์ ๋ฌผ์ด ์๋์ง ํ์ธํด.
- ์ผ์๊ฐ ๋ฌผ์ฒด๋ฅผ ํฅํด ์ ๋๋ก ์ ๋ ฌ๋์ด ์๋์ง ํ์ธํด.
๋๋ถ๋ถ์ ๊ฒฝ์ฐ, ์ด ์ ๋๋ง ์ฒดํฌํด๋ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์์ ๊ฑฐ์ผ. ๊ทธ๋๋ ์ ๋๋ค๋ฉด? ๊ฑฑ์ ๋ง, ์ฐ๋ฆฌ์๊ฒ ์ฌ๋ฅ๋ท์ด ์์์! ๊ฑฐ๊ธฐ์ ๋ค๋ฅธ ๊ฐ๋ฐ์๋ค์ ๋์์ ๋ฐ์ ์ ์์ ๊ฑฐ์ผ.
๐ง ๊ฐ์ ๋ฐ ํ์ฅ: ๋ ๋ฉ์ง ๊ธฐ๋ฅ์ ์ถ๊ฐํด๋ณด์!
์ฐ๋ฆฌ์ ๊ธฐ๋ณธ์ ์ธ ๊ฑฐ๋ฆฌ ์ธก์ ๊ธฐ๊ฐ ์ ๋์ํ๊ณ ์๋ค๋ฉด, ์ด์ ๋ ๋ฉ์ง ๊ธฐ๋ฅ๋ค์ ์ถ๊ฐํด๋ณผ ์ฐจ๋ก์ผ. ์ด๋ค ๊ฒ๋ค์ ํด๋ณผ ์ ์์๊น? ๐
1. LED๋ก ๊ฑฐ๋ฆฌ ํ์ํ๊ธฐ
๊ฑฐ๋ฆฌ์ ๋ฐ๋ผ ๋ค๋ฅธ ์์ LED๋ฅผ ์ผ๋ณด๋ ๊ฑด ์ด๋? ์๋ฅผ ๋ค์ด:
- 0-10cm: ๋นจ๊ฐ์ LED
- 11-50cm: ๋ ธ๋์ LED
- 51cm ์ด์: ์ด๋ก์ LED
์ด๋ ๊ฒ ํ๋ฉด ์๊ฐ์ ์ผ๋ก๋ ๊ฑฐ๋ฆฌ๋ฅผ ์ฝ๊ฒ ํ์ธํ ์ ์๊ฒ ์ง? ์ฝ๋๋ ์ด๋ ๊ฒ ์์ ํ ์ ์์ด:
const int redLED = 3;
const int yellowLED = 4;
const int greenLED = 5;
void setup() {
// ๊ธฐ์กด ์ฝ๋...
pinMode(redLED, OUTPUT);
pinMode(yellowLED, OUTPUT);
pinMode(greenLED, OUTPUT);
}
void loop() {
// ๊ธฐ์กด์ ๊ฑฐ๋ฆฌ ์ธก์ ์ฝ๋...
// LED ์ ์ด
if (distance <= 10) {
digitalWrite(redLED, HIGH);
digitalWrite(yellowLED, LOW);
digitalWrite(greenLED, LOW);
} else if (distance <= 50) {
digitalWrite(redLED, LOW);
digitalWrite(yellow LED, HIGH);
digitalWrite(greenLED, LOW);
} else {
digitalWrite(redLED, LOW);
digitalWrite(yellowLED, LOW);
digitalWrite(greenLED, HIGH);
}
}
์ด๋ ๊ฒ ํ๋ฉด ๊ฑฐ๋ฆฌ์ ๋ฐ๋ผ ๋ค๋ฅธ ์์ LED๊ฐ ์ผ์ง ๊ฑฐ์ผ. ์ ๋ง ๋ฉ์ง์ง ์์?
2. ๋ถ์ ๋ก ๊ฒฝ๊ณ ์ ๋ด๊ธฐ
๋ฌผ์ฒด๊ฐ ๋๋ฌด ๊ฐ๊น์์ง๋ฉด ๊ฒฝ๊ณ ์์ ๋ด๋ ๊ธฐ๋ฅ์ ์ถ๊ฐํด๋ณด์. ์ด๊ฑด ์ฃผ์ฐจ ๋ณด์กฐ ์์คํ ๊ฐ์ ๊ฑธ ๋ง๋ค ๋ ์ ์ฉํ ๊ฑฐ์ผ!
const int buzzerPin = 6;
void setup() {
// ๊ธฐ์กด ์ฝ๋...
pinMode(buzzerPin, OUTPUT);
}
void loop() {
// ๊ธฐ์กด์ ๊ฑฐ๋ฆฌ ์ธก์ ์ฝ๋...
// ๋ถ์ ์ ์ด
if (distance < 20) {
tone(buzzerPin, 1000, 100); // 1kHz ์๋ฆฌ๋ฅผ 100ms ๋์ ๋
} else {
noTone(buzzerPin);
}
}
์ด์ ๋ฌผ์ฒด๊ฐ 20cm ์ด๋ด๋ก ๊ฐ๊น์์ง๋ฉด ๊ฒฝ๊ณ ์์ด ์ธ๋ฆด ๊ฑฐ์ผ. ์ฃผ์ํด์ผ ํ ๋ ๊ท๋ก๋ ์ ์ ์๊ฒ ๋์์ด!
3. OLED ๋์คํ๋ ์ด๋ก ๊ฑฐ๋ฆฌ ํ์ํ๊ธฐ
์๋ฆฌ์ผ ๋ชจ๋ํฐ ๋์ OLED ๋์คํ๋ ์ด๋ฅผ ์ฌ์ฉํ๋ฉด ๋ ๋ฉ์ง ๊ฑฐ๋ฆฌ ์ธก์ ๊ธฐ๊ฐ ๋ ๊ฑฐ์ผ. ์ด๋ ๊ฒ ํ๋ฉด ์ปดํจํฐ ์์ด๋ ๊ฑฐ๋ฆฌ๋ฅผ ํ์ธํ ์ ์์ง!
๋จผ์ , Adafruit_SSD1306 ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ค์นํด์ผ ํด. ๊ทธ๋ฆฌ๊ณ ์ฝ๋๋ฅผ ์ด๋ ๊ฒ ์์ ํด๋ณด์:
- ์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์ฌ๋ฅ๋ท์ ์ต์ AI ๊ธฐ์ ๊ณผ ๋ฒ๋ฅ ์ ๊ธฐ๋ฐํ์ฌ ์์ฌ์ ์ง์ ์ฌ์ฐ๊ถ์ ์ ๊ทน์ ์ผ๋ก ๋ณดํธํ๋ฉฐ,
๋ฌด๋จ ์ฌ์ฉ ๋ฐ ์นจํด ํ์์ ๋ํด ๋ฒ์ ๋์์ ํ ๊ถ๋ฆฌ๋ฅผ ๋ณด์ ํฉ๋๋ค.
ยฉ 2025 ์ฌ๋ฅ๋ท | All rights reserved.
๋๊ธ 0๊ฐ