JOYKIT

DHT11 센서는 온도 및 습도를 측정할 수 있는 센서이다. 이 센서는 아두이노나 라즈베리 파이 같은 마이크로컨트롤러에서 많이 사용된다.

DHT11 온습도 센서 특징:

온도 측정 범위 : 0°C ~ 50°C (±2°C의 정확도)

습도 측정 범위 : 20% ~ 90% RH (±5%의 정확도)

응답 시간 : 1초

출력 신호 : 디지털 신호

DHT11 핀:

S (핀) : 데이터 신호

"-"  (핀) : 전원 접지

중간 (핀) : 전원 +5V

오늘 시간에는 DHT11 온습도 센서를 아두이노에 사용하여 온도와 습도를 LCD1602 디스플레이에 출력하는 실험을 해보겠다.

준비품으로는 아두이노 우노 R3, DHT11 온습도 센서, LCD1602 디스플레이 등이 사용된다.

준비 부품: 

아두이노 우노 R3	DHT11 온습도 센서	LCD1602 디스플레이

"이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다."

https://link.coupang.com/a/ch39lc

https://link.coupang.com/a/cdnaEv

https://link.coupang.com/a/b2vTO0

위와 같이 부품들이 준비되면 다음과 같이 회로를 구성한다.

위의 그림과 같이 회로 연결이 끝나면 아두이노 IDE에 다음과 같이 코드를 작성한다.

전체 코드:

#include <Wire.h>
#include <LiquidCrystal_I2C.h>  // LCE패널 함수 선언
#include <DHT.h>


#define DHTPIN 3     // DHT 센서가 연결된 핀 번호
#define DHTTYPE DHT11 // DHT11 또는 DHT22 사용

LiquidCrystal_I2C lcd (0x27,16,2);   

DHT dht(DHTPIN, DHTTYPE);

void setup() {
  lcd.init();           // LCD 초기화
  lcd.backlight();      // LCD 뒷 전등 켬
  Serial.begin(9600); 
  dht.begin();
}

void loop() {
  float h = dht.readHumidity();    // 습도 측정
  float t = dht.readTemperature(); // 온도 측정 (섭씨)

  // 오류 체크
  if (isnan(h) || isnan(t)) {
    Serial.println("Failed to read data from the sensor!");
    return;
  }

  Serial.print("온도: ");
  Serial.print(t);
  Serial.print(" °C ");
  Serial.print("습도: ");
  Serial.print(h);
  Serial.println(" %");

  lcd.setCursor(0,0);            // LCD 1행 2열에 출력
  lcd.print("Temperature:");
  lcd.print(t);
  lcd.print("°C");
  lcd.setCursor(0,1);            // LCD 2행 1열에 출력
  lcd.print("Humidity:");
  lcd.print(h);
  lcd.println("%");  


  delay(2000); // 2초마다 측정

  lcd.clear();  // LCD 클리어
}

코드 작성 후 아두이노 우노 R3에 컴파일 후 업로드 하여준다. 그러면 다음과 같은 출력 결과를 볼 수 있다.

출력 결과:

https://www.youtube.com/watch?v=cDZFRReQ2J8

DC5V 4채널 릴레이 모듈을 사용하면 아두이노와 같은 마이크로 컨트롤러를 사용하여 고전압 및 고전류 장치들을 제어할 수 있다. 각 채널을 개별적으로 제어할 수 있으며 다양한 장치들을 작동 시킬 수 있다.

릴레이 핀 설명 :

1. DC+ : 5V 전원 공급 핀

2. DC- : GND 전원 접지 핀

3. IN1, IN2, IN3, IN4 : 각 릴레이 채널을 제어하는 입력 핀

4. COM : 공동 핀 (제어할 장치에 연결)

5. NO(Normally Open) : 평소에 열려있는 접점(신호를 보냈을 때 연결된다.)

6. NC(Normally Closed) : 평소에 닫혀있는 접점(신호를 보냈을 때 차단된다.)

오늘은 아두이노 우노 R3에 DC5V 4채널 릴레이 모듈을 사용하여 LDE 다이오드를 제어하는 실습을 해보겠다.

준비품 : 

제품에 사용될 부품으로는 아두이노 UNO R3, DC5V 4채널 릴레이, LCD1602 디스플레이, LED다이오드 4개, 220옴 저항 4개 등이 사용된다.

아두이노 우노 R3	DC5V 4채널 릴레이	LCD1602 디스플레이	LED 다이오드

"이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다."

https://link.coupang.com/a/cdnaEv

https://link.coupang.com/a/cdm8hq

https://link.coupang.com/a/b2vTO0

위와 같이 부품들이 준비되면 다음과 같이 회로를 구성한다.

아래에 있는 이미지는 실제 회로연결 상태이다.

위와 같이 회로 연결이 끝나면 다음과 같이 코딩을 한다.

코딩 설명 : 

먼저 4채널 릴레이 1, 2, 3, 4를 아두이노 디지털 핀 D4, D5, D6, D7로 설정한다.

// 릴레이 핀 정의
int relay1 = 4;
int relay2 = 5;
int relay3 = 6;
int relay4 = 7;

직렬 통신은 9600으로 설정하고, LCD1602 디스플레이를 초기화 한다음, 백라이트를 ON 상태로 설정한다.

다음 릴레이 핀모드를 출력으로 정하고, 릴레이 초기 상태를 LOW(꺼짐)으로 설정한다.

void setup() {

  Serial.begin(9600);
                                                                                                             

  lcd.init();    // LCD 초기화 
  lcd.backlight();  // LCD 백라이트 켬

  // 릴레이 핀을 출력으로 설정
  pinMode(relay1, OUTPUT);
  pinMode(relay2, OUTPUT);
  pinMode(relay3, OUTPUT);
  pinMode(relay4, OUTPUT);

  
  // 릴레이 초기 상태 설정 (LOW 상태는 OFF)
  digitalWrite(relay1, LOW);
  digitalWrite(relay2, LOW);
  digitalWrite(relay3, LOW);
  digitalWrite(relay4, LOW);

}

void loop 함수에서는 릴레이 1번부터 4번까지 3초 간격으로 켜졌다 꺼졌다 하는 방식으로 순차적으로 순환하도록 하였다. LCD1602 디스플레이는 각 채널에 연결된 LED 다이오드의 색상에 따라 빨간색이면 LED : R, 파란색이면  LED : B, 노란색이면 LED : Y, 초록색이면 LED : G로 디스플레이에 현시되도록 하였다.

void loop() {

  // 릴레이를 순차적으로 켜고 끄기
  digitalWrite(relay1, HIGH);  // 릴레이1 켜기
  delay(3000);                 // 3초 대기
  digitalWrite(relay1, LOW);   // 릴레이1 끄기
  delay(3000);
  lcd.setCursor(0,0);
  lcd.print("LED:");
  lcd.print("Y"); 
  
  digitalWrite(relay2, HIGH);  // 릴레이2 켜기
  delay(3000);                 // 3초 대기
  digitalWrite(relay2, LOW);   // 릴레이2 끄기
  delay(3000); 
  lcd.setCursor(0,1);
  lcd.print("LED:");
  lcd.print("G");
  
  digitalWrite(relay3, HIGH);  // 릴레이3 켜기
  delay(3000);                 // 3초 대기
  digitalWrite(relay3, LOW);   // 릴레이3 끄기
  delay(3000);
  lcd.setCursor(7,0);
  lcd.print("LED:");
  lcd.print("R"); 
  
  digitalWrite(relay4, HIGH);  // 릴레이4 켜기
  delay(3000);                 // 3초 대기
  digitalWrite(relay4, LOW);   // 릴레이4 끄기
  delay(3000); 
  lcd.setCursor(7,1);
  lcd.print("LED:");
  lcd.print("B");   
 
  
  delay(100); // 3초 대기
  lcd.clear();  // lcd 지우기

}

전체 코드 :

#include <Wire.h>
#include <LiquidCrystal_I2C.h> 

// 릴레이 핀 정의
int relay1 = 4;
int relay2 = 5;
int relay3 = 6;
int relay4 = 7;

LiquidCrystal_I2C lcd (0x27,16,2);   


// 릴레이 상태를 저장할 변수
bool relay1State = false;
bool relay2State = false;
bool relay3State = false;
bool relay4State = false;


void setup() {

  Serial.begin(9600);
                                                                                                             

  lcd.init();    // LCD 초기화 
  lcd.backlight();  // LCD 백라이트 켬

  // 릴레이 핀을 출력으로 설정
  pinMode(relay1, OUTPUT);
  pinMode(relay2, OUTPUT);
  pinMode(relay3, OUTPUT);
  pinMode(relay4, OUTPUT);

  
  // 릴레이 초기 상태 설정 (LOW 상태는 OFF)
  digitalWrite(relay1, LOW);
  digitalWrite(relay2, LOW);
  digitalWrite(relay3, LOW);
  digitalWrite(relay4, LOW);

}

void loop() {

  // 릴레이를 순차적으로 켜고 끄기
  digitalWrite(relay1, HIGH);  // 릴레이1 켜기
  delay(3000);                 // 3초 대기
  digitalWrite(relay1, LOW);   // 릴레이1 끄기
  delay(3000);
  lcd.setCursor(0,0);
  lcd.print("LED:");
  lcd.print("Y"); 
  
  digitalWrite(relay2, HIGH);  // 릴레이2 켜기
  delay(3000);                 // 3초 대기
  digitalWrite(relay2, LOW);   // 릴레이2 끄기
  delay(3000); 
  lcd.setCursor(0,1);
  lcd.print("LED:");
  lcd.print("G");
  
  digitalWrite(relay3, HIGH);  // 릴레이3 켜기
  delay(3000);                 // 3초 대기
  digitalWrite(relay3, LOW);   // 릴레이3 끄기
  delay(3000);
  lcd.setCursor(7,0);
  lcd.print("LED:");
  lcd.print("R"); 
  
  digitalWrite(relay4, HIGH);  // 릴레이4 켜기
  delay(3000);                 // 3초 대기
  digitalWrite(relay4, LOW);   // 릴레이4 끄기
  delay(3000); 
  lcd.setCursor(7,1);
  lcd.print("LED:");
  lcd.print("B");   
 
  
  delay(100); // 3초 대기
  lcd.clear();  // lcd 지우기

}

코딩 작성이 전부 끝나면 아두이노에 컴파일 후 업로드 하여준다.

그러면 아래 영상과 같이 릴레이 각 채널에 연결된 LED 다이오드가 제어되는 모습을 볼 수 있다.

시연 영상 : 

https://www.youtube.com/watch?v=HrvhQfr7nDo

이와 같은 방법으로 8채널 릴레이, 16채널 릴레이 모듈을 사용할 수 있다.

"이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다."

https://link.coupang.com/a/cd1SSL

https://link.coupang.com/a/cd1VxK

LDR(Light Dependent Resistor) 감광저항 센서는 빛의 강도에 따라 저항 값이 변하는 센서이다.

"이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다."

https://link.coupang.com/a/b2bGXl

원리 : 

1. LDR의 재료는 빛을 받으면 전자의 이동이 증가하여 전기 전도도가 높아지고, 그에 따라 저항이 낮아진다. 반대로 빛이 줄어들면 전자의 이동이 줄어들고, 저항은 다시 높아진다. 

2. 이 모듈에는 빛의 강도에 따라 출력 신호를 조절하기 위한 가변 저항기를 포함하고 있는데, 이것을 사용하여 센서의 감도를 조절할 수 있다.

3. 디지털, 아날로그 출력을 제공하여 빛의 강도에 대한 연속적인 값을 변환하여, 특정 임계값을 넘으면 디지털 출력을 트리거 할 수 있다.

모듈 핀 기능 :  

VCC : 작동 전압 ( DC 3.3 ~ 5V )

GND :  전원 접지( - )

DO (핀) : 디지털 출력

AO (핀) : 아날로그 출력

용도 : 

1. 자동 조명 시스템 : 빛의 강도에 따라 조명을 자동으로 조절하는 시스템에 사용된다. 예를 들어 해가 질 때 자동으로 켜지는 가로등 등이 있다.

2. 카메라 노출 조절 : 카메라의 자동 노출 기능에서 조명 상태를 감지하는데 사용된다.

3. 알람 및 보안 시스템 : 빛의 변화로 인해 누군가의 접근을 감지하는 보안시스템에서도 사용된다.

실습 예제 : 

LDR 감광센서 모듈과 아두이노, 소리모듈을 사용하여 간단한 프로젝트를 구현하는 방법을 설명하겠다.

LDR 센서를 아두이노에 연결하여 빛의 강도에 따라 데이터를 수집하여 아두이노에 연결된 LED와 소리모듈의 동작을 제어하여 LCD 디스플레이에 출력결과를 표시해보도록 하겠다.

준비품 : 

아두이노 우노 R3, LDR 감광저항센서, 개짖는 소리 모듈, LED 다이오드, LCD1602 등이 사용된다.

https://joykit.shop/product/%EC%95%84%EB%91%90%EC%9D%B4%EB%85%B8-%EC%9A%B0%EB%85%B8-r3/13/category/23/display/1/

https://joykit.shop/product/ldr%EA%B0%90%EA%B4%91-%EC%A0%80%ED%95%AD%EC%84%BC%EC%84%9C/73/category/23/display/1/

https://joykit.shop/product/%EA%B0%9C%EC%A7%96%EB%8A%94-%EC%86%8C%EB%A6%AC-%EC%9D%8C%EC%84%B1-%EB%AA%A8%EB%93%88/72/category/23/display/1/

https://joykit.shop/product/lcd1602-16x2-4%ED%95%80-%EB%94%94%EC%8A%A4%ED%94%8C%EB%A0%88%EC%9D%B4-%EB%AA%A8%EB%93%88/24/category/23/display/1/

아두이노 우노 R3	LDR 감광저항센서	개짖는 소리 모듈
LCD1602	LED 다이오드	300옴 저항

구성품이 준비되면 다음과 같이 회로를 연결한다.

회로연결 : 

회로도 :

아래 그림은 실지 회로를 연결한 모습이다.

회로 연결이 전부 끝나면 다음과 같이 코드를 작성한다.

#include <LiquidCrystal_I2C.h>

int sensorPin = A0;       // LDR 연결 핀
int ledPin = 9;           // LED 연결 핀
int dogPin = 3;
int threshold = 750;      // 임계값 (0~1023 범위) 

먼저 LCD1602 라이브러리를 설치하고 변수 sensorPin, ledPin, dogPin, threshold 를 선언한다.

여기서 threshold 변수의 임계 값이 750을 넘으면 아두이노에 연결된 LED와 소리모듈을 제어할 수 있다.

LiquidCrystal_I2C lcd (0x27,16,2);   // LCD1602 hexa값, 2행 16열 설정

LCD 1602는 16행 2열로 설정한다.

void setup() {
  lcd.init();    // LCD 초기화 
  lcd.backlight();  // LCD 백라이트 켬
  pinMode(ledPin, OUTPUT);  // LED 핀을 출력 모드로 설정
  pinMode(dogPin, OUTPUT);  // dog 핀을 출력 모드로 설정
  Serial.begin(9600);       // 시리얼 통신 시작
}

LCD 모듈을 초기화하고, 백라이트를 켜준다.

ledPin, dogPin을 출력모드로 설정하고, 시리얼 통신은 9600으로 시작한다.

void loop() {
  int sensorValue = analogRead(sensorPin);  // LDR에서 아날로그 값 읽기
  Serial.println(sensorValue);              // 시리얼 모니터에 값 출력

  // 밝기가 임계값 이하이면 LED 켜기
  if (sensorValue > threshold) {
    digitalWrite(ledPin, HIGH);
    digitalWrite(dogPin, HIGH);
    lcd.setCursor(0,0);   
    lcd.print("LED : ON");
    lcd.setCursor(0,1);  
    lcd.println(sensorValue);
  } else {  // 밝기가 임계값 이상이면 LED 끄기
    digitalWrite(ledPin, LOW);
    digitalWrite(dogPin, LOW);
    lcd.setCursor(0,0);   
    lcd.print("LED : OFF");
    lcd.setCursor(0,1);  
    lcd.println(sensorValue);
  }

sensorValue 변수로 sensorPin의 아날로그 값을 읽어드리고, sensorValue 값에 따라 아두이노에 연결된 모듈을 제어한다.

전체 코드 : 

#include <LiquidCrystal_I2C.h>

int sensorPin = A0;       // LDR 연결 핀
int ledPin = 9;           // LED 연결 핀
int dogPin = 3;
int threshold = 750;      // 임계값 (0~1023 범위)

LiquidCrystal_I2C lcd (0x27,16,2);   // LCD1602 hexa값, 2행 16열 설정

void setup() {
  lcd.init();    // LCD 초기화 
  lcd.backlight();  // LCD 백라이트 켬
  pinMode(ledPin, OUTPUT);  // LED 핀을 출력 모드로 설정
  pinMode(dogPin, OUTPUT);  // dog 핀을 출력 모드로 설정
  Serial.begin(9600);       // 시리얼 통신 시작
}

void loop() {
  int sensorValue = analogRead(sensorPin);  // LDR에서 아날로그 값 읽기
  Serial.println(sensorValue);              // 시리얼 모니터에 값 출력

  // 밝기가 임계값 이하이면 LED 켜기
  if (sensorValue > threshold) {
    digitalWrite(ledPin, HIGH);
    digitalWrite(dogPin, HIGH);
    lcd.setCursor(0,0);   
    lcd.print("LED : ON");
    lcd.setCursor(0,1);  
    lcd.println(sensorValue);
  } else {  // 밝기가 임계값 이상이면 LED 끄기
    digitalWrite(ledPin, LOW);
    digitalWrite(dogPin, LOW);
    lcd.setCursor(0,0);   
    lcd.print("LED : OFF");
    lcd.setCursor(0,1);  
    lcd.println(sensorValue);
  }

  delay(100);  // 100ms 대기 (출력 속도 조절)

  lcd.clear();
}

코드를 전부 작성한 후 컴파일 하고 업로드 하면 다음과 같은 출력 결과를 볼 수 있다.

출력 결과 :

https://www.youtube.com/watch?v=LeMFeUzghe8

HC-SR501 인체 감지 센서는 인체의 움직임을 감지하는 센서 모듈이다.

이 센서는 적외선을 감지하여 동작을 인식하며 주로 보안 시스템, 자동 조명, 스마트 홈 장치 등에 사용된다. 

핀기능 :

VCC : 전원(+5V)

GND : 접지

S : 신호 출력

실습 예제 : 

인체감지 센서모듈을 사용하여 모션이 감지되었을 때 아두이노에 연결된 LED가 제어되는 것을 실습해보겠다.

사용될 부품으로는 아두이노 우노 R3, HC-SR501 인체감지센서, LED 다이오드, LCD1602 디스플레이 등이 사용된다.

아두이노 우노 R3	HC-SR 501 인체감지센서	LED 다이오드	LCD 1602디스플레이

"이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다."

https://link.coupang.com/a/b2bLow

https://link.coupang.com/a/b2vSOT

https://link.coupang.com/a/b2bNt2

회로연결 : 

위의 회로도 그림을 참고하여 회로를 연결한다.

HC-SR501센서의 신호(S)는 아두이노 D8번에 연결하고, LED 다이오드 + 핀은 D4번, LCD1602 SDA는 아두이노의 아날로그 출력핀 A4, SCL은 A5에 연결한다.

아래 그림은 실물 회로 연결한 모습이다.

회로 연결이 전부 마치면 아두이노 IDE에 다음과 같이 코드를 작성한다.

먼저 LCD1602 디스플레이 라이브러리를 설치하여 준다. 

#include <LiquidCrystal_I2C.h>

감지센서의 신호 출력을 변수 pirPin으로 아두이노 D8번으로 선언하여 주고, LED 다이오드는 D4번으로 선언하여 준다.

int pirPin = 8;  // PIR 센서의 출력 핀
int ledPin = 4; // 내장 LED 핀 (동작 감지 시 켜짐)

LCD1602를 초기화 하여주고, 백라이트를 켜준다.

핀모드에서 HC-SR501 센서는 입력 모드로, LED 다이오드는 출력 모드로 선언하여 주고 시리얼 통신은 9600으로 설정한다.

void setup() {
  lcd.init();    // LCD 초기화 
  lcd.backlight();  // LCD 백라이트 켬

  pinMode(pirPin, INPUT); // PIR 핀을 입력으로 설정
  pinMode(ledPin, OUTPUT); // LED 핀을 출력으로 설정
  Serial.begin(9600); // 시리얼 통신 시작
}

다음은 센서 변수 pirState는 디지털 읽기로 선언하여 준다.

pirState 가 HIGH일 때 LED 핀 (ledPin)은 HIGH 상태로 LED 다이오드를 켜주고, 동시에 LCD1602에 "Motion Detected!"라는 문자를 출력하여 준다.

pirState가 LOW일 때는 LED 다이오드는 꺼준다.

void loop() {
  int pirState = digitalRead(pirPin); // PIR 센서의 상태 읽기

  if (pirState == HIGH) {
    digitalWrite(ledPin, HIGH); // 동작 감지 시 LED 켜기
    Serial.println("Motion Detected!");
    lcd.setCursor(0,0);            // LCD 1행 2열에 출력
    lcd.print("Motion Detected"); 
  } else {
    digitalWrite(ledPin, LOW); // 동작이 없을 시 LED 끄기
    Serial.println("Motion no Detected!");
    lcd.setCursor(0,0);            // LCD 1행 2열에 출력
    lcd.print("Motion no Detected"); 
  }

코드 작성이 전부 끝나면 아두이노 IDE에 아두이노 우노 R3 을 USB케이블로 연결하고(보드와 포트를 설정), 작성된 코드를 컴파일하여 업로드 하여 준다. 

전체 코드 : 

#include <LiquidCrystal_I2C.h> 

int pirPin = 8;  // PIR 센서의 출력 핀
int ledPin = 4; // 내장 LED 핀 (동작 감지 시 켜짐)

LiquidCrystal_I2C lcd (0x27,16,2);   // LCD1602 hexa값, 2행 16열 설정

void setup() {
  lcd.init();    // LCD 초기화 
  lcd.backlight();  // LCD 백라이트 켬

  pinMode(pirPin, INPUT); // PIR 핀을 입력으로 설정
  pinMode(ledPin, OUTPUT); // LED 핀을 출력으로 설정
  Serial.begin(9600); // 시리얼 통신 시작
}

void loop() {
  int pirState = digitalRead(pirPin); // PIR 센서의 상태 읽기

  if (pirState == HIGH) {
    digitalWrite(ledPin, HIGH); // 동작 감지 시 LED 켜기
    Serial.println("Motion Detected!");
    lcd.setCursor(0,0);            // LCD 1행 2열에 출력
    lcd.print("Motion Detected"); 
  } else {
    digitalWrite(ledPin, LOW); // 동작이 없을 시 LED 끄기
    Serial.println("Motion no Detected!");
    lcd.setCursor(0,0);            // LCD 1행 2열에 출력
    lcd.print("Motion no Detected"); 
  }

  delay(100); // 짧은 지연 (100ms)
  lcd.clear();  // LCD 클리어
}

인체감지 센서 HC-SR501에 모션이 감지되었을 때 LED 다이오드가 켜지는 모습을 볼 수 있다.

출력 결과 : 

https://www.youtube.com/watch?v=Nl8bPm5bGzU

조이스틱 모듈은 아두이노나 라즈베리 파이와 같은 마이크로컨트롤러와 같이 단일 보드 컴퓨터에 사용하여 입력 장치로 활용할 수 있다. 일반적으로 조이스틱 모듈은 두 개의 아날로그 축(X, Y)과 하나의 디지털 버튼으로 구성되어 있다.

조이스틱 모듈 핀 기능 : 

실습 예제 : 

조이스틱 모듈의 방향에 따라 LED 다이오드를 제어하는 방법을 설명하겠다. 

예들 들어 조이스틱을 위로 움직일 때는 빨간색 LED가 켜지고, 아래로 움직일 때는 파란색 LED를, 왼쪽으로 움직일 때는  녹색 LED, 오른쪽으로 움직일 때는 노란색 LED를 켜지는 식으로 구현하였다. 그리고 조이스틱 버튼이 눌리었을 때는 4개의 LED가 전부 켜지도록 하였다.

필요한 부품 : 

구성품으로는 아두이노 우노 R3, 조이스틱 모듈, LED 다이오드 4개 (빨간색, 파란색, 녹색, 노란색), 저항 4개(220Ω) 등이 쓰인다.

"이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다."

https://link.coupang.com/a/b2S1uP

https://link.coupang.com/a/b2vSOT

https://link.coupang.com/a/b2vTO0

아두이노 우노 R3	조이스틱 모듈	LED다이오드(Red, Bule, Green, Yellow)

회로 연결 : 

구성품이 준비되면 위의 회로도와 아래 표를 참고하여 회로를 연결한다.

위와 같이 회로 연결이 전부 끝나면 아두이노 IDE에 다음과 같이 코드를 작성한다.

코드 설명 : 

1. VRx, VRy, SW, redLED, blueLED, greenLED, yellowLED 핀 번호를 설정한다
2. setup() 함수에서 시리얼 통신을 시작하고, 버튼 핀과 LED 핀을 설정한다.
3. loop() 함수에서 주기적으로 X축, Y축, 버튼 값을 읽는다.
4. 버튼 상태를 확인하여 버튼이 눌렸을 때 모든 LED를 켠다.
5. 버튼이 눌리지 않았을 때는 조이스틱의 방향에 따라 해당 LED를 켜고 끈다.

먼저 아두이노 IDE에 LCD1602 라이브러리를 설치한다. (LiquidCrystal_I2C)

다음 조이스틱 모듈 핀설정을 진행한다.

const int VRx = A0;  // X축 아날로그 핀
const int VRy = A1;  // Y축 아날로그 핀
const int SW = 8;    // 버튼 디지털 핀

LED 다이오드 핀을 정의한다.

const int redLED = 3;     // 빨간 LED 핀
const int blueLED = 4;    // 파란 LED 핀
const int greenLED = 5;   // 녹색 LED 핀
const int yellowLED = 6;  // 노란 LED 핀

void setup() {
  lcd.init();    // LCD 초기화 
  lcd.backlight();  // LCD 백라이트 켬

  Serial.begin(9600);  // 시리얼 통신 시작
  pinMode(SW, INPUT_PULLUP);  // 버튼 핀을 풀업 저항과 함께 입력으로 설정
  pinMode(redLED, OUTPUT);  // LED 핀을 출력으로 설정
  pinMode(blueLED, OUTPUT);
  pinMode(greenLED, OUTPUT);
  pinMode(yellowLED, OUTPUT);
}

  int xValue = analogRead(VRx);  // X축 값 읽기
  int yValue = analogRead(VRy);  // Y축 값 읽기
  int buttonState = digitalRead(SW);  // 버튼 상태 읽기

조이스틱 모듈의 버튼이 눌리었을 때는 4개의 LED가 전부 켜지고, 버튼이 눌리지 않았을 때는 조이스틱 방향에 따라 LED 다이오드가 켜진다.

if (buttonState == HIGH) {  // 버튼이 눌렸을 때
    digitalWrite(redLED, HIGH);
    digitalWrite(blueLED, HIGH);
    digitalWrite(greenLED, HIGH);
    digitalWrite(yellowLED, HIGH);
    lcd.setCursor(0,1);            // LCD 1행 2열에 출력
    lcd.print("ALL LED ON");  
  } else {
    // 버튼이 눌리지 않았을 때 조이스틱 방향에 따라 LED 제어
    if (xValue < 400) {  // 왼쪽
      digitalWrite(greenLED, HIGH);
      lcd.setCursor(0,1);     // LCD 1행 1열에 출력  
      lcd.print("Left_Green"); 
    } else {
      digitalWrite(greenLED, LOW);
    }

    if (xValue > 600) {  // 오른쪽
      digitalWrite(yellowLED, HIGH);
      lcd.setCursor(0,1);            // LCD 1행 2열에 출력
      lcd.print("Right_Yellow");  
    } else {
      digitalWrite(yellowLED, LOW);
    }

    if (yValue < 400) {  // 위쪽
      digitalWrite(redLED, HIGH);
      lcd.setCursor(0,1);            // LCD 1행 2열에 출력
      lcd.print("Up_Red");  
    } else {
      digitalWrite(redLED, LOW);
    }

    if (yValue > 600) {  // 아래쪽
      digitalWrite(blueLED, HIGH);
      lcd.setCursor(0,1);            // LCD 1행 2열에 출력
      lcd.print("Down_Blue");  
    } else {
      digitalWrite(blueLED, LOW);
    }
  }

전체 코드 : 

#include <LiquidCrystal_I2C.h> 

const int VRx = A0;  // X축 아날로그 핀
const int VRy = A1;  // Y축 아날로그 핀
const int SW = 8;    // 버튼 디지털 핀

const int redLED = 3;     // 빨간 LED 핀
const int blueLED = 4;    // 파란 LED 핀
const int greenLED = 5;   // 녹색 LED 핀
const int yellowLED = 6;  // 노란 LED 핀

LiquidCrystal_I2C lcd (0x27,16,2);   // LCD1602 hexa값, 2행 16열 설정

void setup() {
  lcd.init();    // LCD 초기화 
  lcd.backlight();  // LCD 백라이트 켬

  Serial.begin(9600);  // 시리얼 통신 시작
  pinMode(SW, INPUT_PULLUP);  // 버튼 핀을 풀업 저항과 함께 입력으로 설정
  pinMode(redLED, OUTPUT);  // LED 핀을 출력으로 설정
  pinMode(blueLED, OUTPUT);
  pinMode(greenLED, OUTPUT);
  pinMode(yellowLED, OUTPUT);
}

void loop() {
  int xValue = analogRead(VRx);  // X축 값 읽기
  int yValue = analogRead(VRy);  // Y축 값 읽기
  int buttonState = digitalRead(SW);  // 버튼 상태 읽기

  lcd.setCursor(0,0);            // LCD 1행 2열에 출력
  lcd.print("JOYSTIC_CONTROL");  

  if (buttonState == HIGH) {  // 버튼이 눌렸을 때
    digitalWrite(redLED, HIGH);
    digitalWrite(blueLED, HIGH);
    digitalWrite(greenLED, HIGH);
    digitalWrite(yellowLED, HIGH);
    lcd.setCursor(0,1);            // LCD 1행 2열에 출력
    lcd.print("ALL LED ON");  
  } else {
    // 버튼이 눌리지 않았을 때 조이스틱 방향에 따라 LED 제어
    if (xValue < 400) {  // 왼쪽
      digitalWrite(greenLED, HIGH);
      lcd.setCursor(0,1);     // LCD 1행 1열에 출력  
      lcd.print("Left_Green"); 
    } else {
      digitalWrite(greenLED, LOW);
    }

    if (xValue > 600) {  // 오른쪽
      digitalWrite(yellowLED, HIGH);
      lcd.setCursor(0,1);            // LCD 1행 2열에 출력
      lcd.print("Right_Yellow");  
    } else {
      digitalWrite(yellowLED, LOW);
    }

    if (yValue < 400) {  // 위쪽
      digitalWrite(redLED, HIGH);
      lcd.setCursor(0,1);            // LCD 1행 2열에 출력
      lcd.print("Up_Red");  
    } else {
      digitalWrite(redLED, LOW);
    }

    if (yValue > 600) {  // 아래쪽
      digitalWrite(blueLED, HIGH);
      lcd.setCursor(0,1);            // LCD 1행 2열에 출력
      lcd.print("Down_Blue");  
    } else {
      digitalWrite(blueLED, LOW);
    }
  }

  delay(100);  // 100ms 지연
  lcd.clear();  // LCD 클리어
}

코드 작성이 전부 끝나면 아두이노에 컴파일하여 업로드 하여준다.

사용법 : 

1. 아두이노 IDE를 열고, 위의 코드를 복사하여 붙여 넣는다.
2. 아두이노 보드를 컴퓨터에 연결하고, 보드와 포트를 선택한 후 코드를 업로드 한다.
3. 조이스틱을 움직여 각 방향에 따라 LED가 켜지고, 버튼을 누르면 모든 LED가 켜지는 것을 확인한다.

출력 결과 : 

https://www.youtube.com/watch?v=SDMUSQWB1_I

위의 영상에서 본것과 같이 조이스틱 모듈의 버튼을 눌렀을 때 모든 LED가 켜지고, 버튼을 누르지 않았을 때는 조이스틱 방향에 따라 LED가 켜지는 동작에 대해 알아 보았다.

MQ-135 가스 감지 센서는 다양한 가스를 감지할 수 있는 다목적 가스 센서이다.

이 센서는 공기 중의 다양한 가스를 감지하여 아날로그 신호로 출력하는 기능을 수행한다.

MQ-135 가스센서 속성 :

"이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다."

https://link.coupang.com/a/b2TkB7

https://link.coupang.com/a/b2vSOT

https://link.coupang.com/a/b2vTO0

https://link.coupang.com/a/b2E5Xq

사용 범위 : 

공기 질을 실시간으로 모니터링하여 가정이나 사무실의 공기를 측정할 수 있다.

공기 중의 유해 가스 농도를 측정하여 자동 환기 시스템을 제어할 수 있다.

MQ-135 가스 센서를 사용하기 위해서는 센서의 출력을 읽고 해석할 수 있는 마이크로 컨드롤러가 있어야 한다. 

예를 들면 Arduino, Raspberry Pi가 일반적으로 사용된다.

이를 통해 실시간으로 가스 농도를 모니터링하고 필요시 경보를 발생시키는 등 다양한 응용 시스템을 만들 수 있다.

실습 예제

MQ-135 가스감지 센서를 아두이노에 연결하여 "가스감지 측정기"를 만들어 보겠다.

작동 방식은 가스감지 센서가 가스를 감지하면 경고음이 울리면서 LCD 디스플레이에 가스 농도를 현시하여 준다.

회로 구성품 : 

MQ135 가스감지센서	아두이노 우노  R3	LCD 1602 디스플레이 모듈
부저 모듈	LED 다이오드	300옴 저항

구성품이 모두 준비되면 다음과 같이 회로를 연결한다.

회로 연결 : 

회로 연결이 끝나면 아두이노 IDE에 다음과 같이 코드를 작성한다.

코드 : 

#include <LiquidCrystal_I2C.h> 

const int analogPin = A0; // 아날로그 핀 연결
const int digitalPin = 11; // 디지털 핀 연결
int gasLevel = 0;         // 가스 농도 변수
int gasDetected = 0;      // 가스 감지 변수

const int ledPin = 13;      // LED가 연결된 디지털 핀
const int buzzerPin = 9;    // 부저 모듈이 연결된 디지털 핀

LiquidCrystal_I2C lcd (0x27,16,2);   // LCD1602 hexa값, 2행 16열 설정

void setup() {
  lcd.init();    // LCD 초기화 
  lcd.backlight();  // LCD 백라이트 켬

  Serial.begin(9600);        // 시리얼 통신 시작
  pinMode(digitalPin, INPUT); // 디지털 핀을 입력 모드로 설정
}

void loop() {
  // 아날로그 값 읽기
  gasLevel = analogRead(analogPin);
  Serial.print("Gas Level: ");
  Serial.println(gasLevel);
  
  lcd.setCursor(0,0);            // LCD 1행 1열에 출력
  lcd.print("Level : ");
  lcd.print(gasLevel);      // LCD에 센서값 출력

  // 디지털 값 읽기
  gasDetected = digitalRead(digitalPin);
  if (gasDetected == LOW) {
    Serial.println("Gas Detected!");
    digitalWrite(ledPin, HIGH);
    tone(buzzerPin, 1000);    // 부저를 1kHz로 설정하여 소리 출력
    lcd.setCursor(0,1);            // LCD 1행 2열에 출력
    lcd.print("Gas : detection");  

  } else {
    digitalWrite(ledPin, LOW);
    noTone(buzzerPin);        // 부저 소리를 끔
    Serial.println("No Gas Detected.");
    lcd.setCursor(0,1);            // LCD 1행 2열에 출력
    lcd.print("Gas : nodetection");
  }

  delay(1000); // 0.5초 대기

  lcd.clear();  // LCD 클리어
}

코드 작성이 전부 끝나면 파일을 컴파일 하고 아두이노 우노 R3에 USB 케이블을 연결하고 업로드 한다.

다음 MQ-135 센서에 가스를 주입하면 경고음이 울리면서, 가스 감지량과 감지확인 메시지가 LCD 디스플레이에 출력된다.

출력 결과 : 

https://www.youtube.com/watch?v=-rm6w0_ptRU

HW-072 화염감지 센서는 불, 가스, 화염을 감지하는데 사용된다.

핀기능 : 

+ : DC 5V

G : 접지

A0 : 아날로그 출력

D0 : 디지털 출력

활용 분야 : 

주로 가스누출 감지, 화재경보 시스템, 기타 안전 시스템에서 사용된다.

주요 기능 :

1. 화염 감지는 센서의 IR 적외선 스펙트럼에서 화염을 감지한다. 화염이 방출하는 특정 파장을 감지하여 화재를 인식한다.

2. 센서의 출력 신호는 아날로그 값과 디지털 값으로 출력된다. 아날로그 출력신호로 아두이노, 라즈베리파이 등 마이크로 컨트롤러를 제어할 수 있다.

실습 예제 : 

HW-072 화염 감지센서를 사용하여 아두이노 화염감지 측정기를 만들어 보겠다.

작동원리는 화염 감지센서에 화염이 감지되면 아두이노에 연결된 부저모듈에서 경고음이 울리는과 동시에 LED경고등에 불이 켜진다. 또한 LCD 디스플레이에 센서의 측정 값을 출력하고 감지상태를 알려준다. 

구성 요소 : 

구성품으로는  아두이노 우노 R3, LCD1602 디스플레이 모듈, 부저모듈, LED 다이오드 등이 사용된다.

"이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다."

https://link.coupang.com/a/b2UFbQ

https://link.coupang.com/a/b2vSOT

https://link.coupang.com/a/b2vTO0

https://www.coupang.com/vp/products/7702597812?vendorItemId=86328689186&isAddedCart=

HW-072 화염 감지센서	아두이노 우노 R3	LCD 1602 디스플레이
부저 모듈	LED 다이오드	300옴 저항

회로 연결 : 

회로 연결 방법은 아래의 표와 같이 연결한다.

회로 연결 후 아두이노 IDE에 다음과 같이 코딩을 작성한다.

코딩 작성시  LCD1602 디스플레이를 사용하였으므로 LiquidCrystal_I2C 라이브러리를 설치하여준다.

화염센서의 아날로그 출력을 아두이노 A0, 디지털 출력은 D11로 정의하였다. 다음 LED 다이오는 D13, 브저모듈은 D9번으로 설정하였다.

디지털 값은 변수 : (int flameDetectedDigital;)로, 아날로그 값은 변수 : (int flameValueAnalog;)로 정의하였다.

LED 핀은 출력으로(pinMode(ledPin, OUTPUT);), 화염센서는 입력으로 (pinMode(flameSensorDigitalPin, INPUT);) 설정하였다. 

화염센서의 디지털 값을 읽어 기준 값보다 높으면 부저모듈과 LED 다이오드에 신호가 전달되고 기준 값보다 낮을 때는 모든 신호가 차단된다. 

flameDetectedDigital = digitalRead(flameSensorDigitalPin);
  if (flameDetectedDigital == HIGH) {
    Serial.println("Flame Detected (Digital)!");
    digitalWrite(ledPin, HIGH);
    tone(buzzerPin, 1000);    // 부저를 1kHz로 설정하여 소리 출력
    lcd.setCursor(0,1);            // LCD 1행 2열에 출력
    lcd.print("Flame : detection");  
  } else {
    digitalWrite(ledPin, LOW);
    noTone(buzzerPin);        // 부저 소리를 끔
    Serial.println("No Flame (Digital).");
    lcd.setCursor(0,1);            // LCD 1행 2열에 출력
    lcd.print("Flame : nodetection");
  }

아날로그 값은 변수 : flameValueAnalog = analogRead(flameSensorAnalogPin); 로 읽은 다음 LCD1602에 전달하여 준다.

  // 아날로그 값 읽기
  flameValueAnalog = analogRead(flameSensorAnalogPin);
  Serial.print("Analog Value: ");
  Serial.println(flameValueAnalog);
  lcd.setCursor(0,0);            // LCD 1행 1열에 출력
  lcd.print("Flame : ");
  lcd.print(flameValueAnalog);      // LCD에 센서값 출력

전체 코드 : 

#include <LiquidCrystal_I2C.h> 

int flameSensorDigitalPin = 11;  // 디지털 핀
int flameSensorAnalogPin = A0;  // 아날로그 핀
int flameDetectedDigital;
int flameValueAnalog;

const int ledPin = 13;      // LED가 연결된 디지털 핀
const int buzzerPin = 9;    // 부저 모듈이 연결된 디지털 핀

LiquidCrystal_I2C lcd (0x27,16,2);   // LCD1602 hexa값, 2행 16열 설정

void setup() {
  lcd.init();    // LCD 초기화 
  lcd.backlight();  // LCD 백라이트 켬

  Serial.begin(9600);  // 시리얼 통신 시작

  pinMode(ledPin, OUTPUT);  // LED 핀을 출력 모드로 설정
  pinMode(flameSensorDigitalPin, INPUT);  // 디지털 핀 입력 모드 설정
}

void loop() {
  // 디지털 값 읽기
  flameDetectedDigital = digitalRead(flameSensorDigitalPin);
  if (flameDetectedDigital == HIGH) {
    Serial.println("Flame Detected (Digital)!");
    digitalWrite(ledPin, HIGH);
    tone(buzzerPin, 1000);    // 부저를 1kHz로 설정하여 소리 출력
    lcd.setCursor(0,1);            // LCD 1행 2열에 출력
    lcd.print("Flame : detection");  
  } else {
    digitalWrite(ledPin, LOW);
    noTone(buzzerPin);        // 부저 소리를 끔
    Serial.println("No Flame (Digital).");
    lcd.setCursor(0,1);            // LCD 1행 2열에 출력
    lcd.print("Flame : nodetection");
  }

  // 아날로그 값 읽기
  flameValueAnalog = analogRead(flameSensorAnalogPin);
  Serial.print("Analog Value: ");
  Serial.println(flameValueAnalog);

  lcd.setCursor(0,0);            // LCD 1행 1열에 출력
  lcd.print("Flame : ");
  lcd.print(flameValueAnalog);      // LCD에 센서값 출력

  delay(1000);  // 1초 대기

  lcd.clear();  // LCD 클리어
}

위와 같이 코드 작성이 전부 끝나면 컴파일하고 아두이노에 업로드 하여주면 다음과 같은 출력 결과를 볼 수 있다.

출력 결과 : 

https://www.youtube.com/watch?v=iua2kR0FFwU

YX5300 UART TTL 직렬 MP3 음악 플레이어 모듈은 다양한 기능을 제공하는 강력한 오디오 모듈이다.

"이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다."

https://link.coupang.com/a/b2E2vk

 

TFT 디스플레이 1.3인치 IPS 풀컬러 LCD 모듈 - 액세서리 | 쿠팡

쿠팡에서 4.0 구매하고 더 많은 혜택을 받으세요! 지금 할인중인 다른 1 제품도 바로 쿠팡에서 확인할 수 있습니다.

www.coupang.com

 

 

https://smartstore.naver.com/allbrands/products/10004855721

 

YX5300 UART TTL 직렬 MP3 음악 플레이어 모듈 : All Brands

[All Brands] 전자부품 전문쇼핑몰입니다

smartstore.naver.com

 

1. 오디오 형식 : MP3, WAV, WMA 형식의 오디오 파일을 지원한다.

2. 직렬 통신 : UART TTL 직렬 인터페이스를 통해 마이크로컨트롤러에 쉽게 통신할 수 있다.

3. TF 카드 지원 : 최대 32GB의 Micro TF 카드를 지원하여 대용량의 오디오 파일을 저장하고 재생할 수 있다.

4. 내장형 오디오 디코더 : 내장된 오디오 디코더를 사용하여 오디오 파일을 고음질로 재생할 수 있다.

5. 다양한 재생 제어 : 재생, 일시정지, 정지, 다음트랙, 이전트랙, 볼륨_UP, 볼륨_DOWN, 등의 명령을 통해 오디오 재생을 제어할 수 있다.

6. 스피커 연결 : 모듈에 직접 스피커를 연결할 수 있는 단자를 제공하여 외부 앰프 없이도 오디오 출력을 제공한다.

실습 예제 :

YX5300 UART TTL 직렬 MP3 음악 플레이어 모듈을 아두이노와 함께 사용하여 MP3 플레이어를 만들어 보겠다.

구성품으로는 YX5300 MP3 플레이어 모듈, 아두이노 우노 R3, 0.91인치 128X32pixel 디스플레이 모듈, 푸시버튼 등이 사용된다.

구성품 : 

YX5300 MP3 모듈	아두이노 우노 R3	0.91인치 OLED 모듈	푸시버튼

회로도 : 

위와 같이 회로를 연결하고 다음과 같이 코딩을 작성한다.

코딩 설명으로는 먼저 OLED와 YX5300 모듈을 위해 라이브러리를 설치해주어야 한다.

OLED 디스플레이 라이브러리 : Adafruit SSD1306, Adafruit GFX Library

YX5300 mp3 모듈 라이브러리 : DFRobotDFPlayerMini

I2C 통신을 위해 Wire 라이브러리를 포함한다.

#include <Wire.h>: I2C

 다음 디스플레이 너비 : 128,  높이 : 32로 정의하여 준다. 

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 32

YX5300 mp3 모듈의 TX, RX를 디지털핀  D2, D3번으로 설정한다.

버튼설정 : 플레이/정지, 다음, 이전, 볼륨+, 볼륨-, 전원 ON/OFF 버튼을 디지털핀 D4, D5, D6, D7, D8, D9 순서대로 설정하여 준다.

// 버튼 핀 설정
const int playPauseButtonPin = 4;
const int nextButtonPin = 5;
const int prevButtonPin = 6;
const int volumeUpButtonPin = 7;
const int volumeDownButtonPin = 8;
const int powerButtonPin = 9;

초기 볼륨을 0~30 중 10으로, 트랙은 1번으로 변수 volume, trackNumber로 정의하여 준다. 

int volume = 10; // 초기 볼륨 (0-30)
int trackNumber = 1; // 재생할 트랙 번호

버튼 입력 모드를  INPUT_PULLUP으로 설정한다.

  pinMode(playPauseButtonPin, INPUT_PULLUP);
  pinMode(nextButtonPin, INPUT_PULLUP);
  pinMode(prevButtonPin, INPUT_PULLUP);
  pinMode(volumeUpButtonPin, INPUT_PULLUP);
  pinMode(volumeDownButtonPin, INPUT_PULLUP);
  pinMode(powerButtonPin, INPUT_PULLUP);

디스플레이의 I2C 주소를 0X3C로 설정한다. 

if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println(F("SSD1306 allocation failed"));
    while (true);
  }
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);

전원 버튼 설정 : 

if (digitalRead(powerButtonPin) == LOW) {
    delay(50); // 디바운스
    if (digitalRead(powerButtonPin) == LOW) {
      powerOn = !powerOn;
      if (powerOn) {
        myDFPlayer.start();
        isPlaying = true;
        Serial.println(F("Power ON"));
      } else {
        myDFPlayer.pause();
        isPlaying = false;
        Serial.println(F("Power OFF"));
      }
      updateDisplay();
      while (digitalRead(powerButtonPin) == LOW); // 버튼이 릴리스될 때까지 대기
    }
  }

재생/ 정지 버튼 설정 : 

if (digitalRead(playPauseButtonPin) == LOW && powerOn) {
    delay(50); // 디바운스
    if (digitalRead(playPauseButtonPin) == LOW) {
      if (isPlaying) {
        myDFPlayer.pause();
        Serial.println(F("Paused"));
      } else {
        myDFPlayer.start();
        Serial.println(F("Playing"));
      }
      isPlaying = !isPlaying;
      updateDisplay();
      while (digitalRead(playPauseButtonPin) == LOW); // 버튼이 릴리스될 때까지 대기
    }
  }

다음곡 버튼 설정 : 

if (digitalRead(nextButtonPin) == LOW && powerOn) {
    delay(50); // 디바운스
    if (digitalRead(nextButtonPin) == LOW) {
      myDFPlayer.next();
      trackNumber++;
      Serial.print(F("Next track: "));
      Serial.println(trackNumber);
      updateDisplay();
      while (digitalRead(nextButtonPin) == LOW); // 버튼이 릴리스될 때까지 대기
    }
  }

이전곡 버튼 설정 : 

 if (digitalRead(prevButtonPin) == LOW && powerOn) {
    delay(50); // 디바운스
    if (digitalRead(prevButtonPin) == LOW) {
      myDFPlayer.previous();
      if (trackNumber > 1) trackNumber--;
      Serial.print(F("Previous track: "));
      Serial.println(trackNumber);
      updateDisplay();
      while (digitalRead(prevButtonPin) == LOW); // 버튼이 릴리스될 때까지 대기
    }
  }

볼륨 증가 버튼 설정 : 

if (digitalRead(volumeUpButtonPin) == LOW && powerOn) {
    delay(50); // 디바운스
    if (digitalRead(volumeUpButtonPin) == LOW) {
      if (volume < 30) volume++;
      myDFPlayer.volume(volume);
      Serial.print(F("Volume increased to "));
      Serial.println(volume);
      updateDisplay();
      while (digitalRead(volumeUpButtonPin) == LOW); // 버튼이 릴리스될 때까지 대기
    }
  }

볼륨 감소 버튼 설정 :

if (digitalRead(volumeDownButtonPin) == LOW && powerOn) {
    delay(50); // 디바운스
    if (digitalRead(volumeDownButtonPin) == LOW) {
      if (volume > 0) volume--;
      myDFPlayer.volume(volume);
      Serial.print(F("Volume decreased to "));
      Serial.println(volume);
      updateDisplay();
      while (digitalRead(volumeDownButtonPin) == LOW); // 버튼이 릴리스될 때까지 대기
    }
  }

자동재생 처리 설정 :

자동재생처리는 음악 재생시 첫 곡이 끝나면 다음곡으로 자동재생하는 기능이다. 

if (myDFPlayer.available() && powerOn) {
    uint8_t type = myDFPlayer.readType();
    if (type == DFPlayerPlayFinished) {
      Serial.println(F("Track finished, playing next track"));
      myDFPlayer.next();
      trackNumber++;
      updateDisplay();
    }
  }

디스플레이 업데이트 설정 :

void updateDisplay() {
  display.clearDisplay();
  display.setCursor(0, 0);
  if (powerOn) {
    display.print(F("Power: ON"));
    display.print(F("  Volume: "));
    display.println(volume);
    display.print(F("Track: "));
    display.println(trackNumber);
    display.print(F("Status: "));
    display.println(isPlaying ? "Playing" : "Paused");
  } else {
    display.println(F("Power: OFF"));
  }
  display.display();
}

전체 코딩 : 

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <SoftwareSerial.h>
#include <DFRobotDFPlayerMini.h>

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 32
#define OLED_RESET    -1
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

SoftwareSerial mySerial(2, 3); // RX, TX
DFRobotDFPlayerMini myDFPlayer;

// 버튼 핀 설정
const int playPauseButtonPin = 4;
const int nextButtonPin = 5;
const int prevButtonPin = 6;
const int volumeUpButtonPin = 7;
const int volumeDownButtonPin = 8;
const int powerButtonPin = 9;

// 볼륨과 트랙 상태 변수
int volume = 10; // 초기 볼륨 (0-30)
int trackNumber = 1; // 재생할 트랙 번호
bool isPlaying = false;
bool powerOn = true;

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

  // 버튼 입력 모드 설정
  pinMode(playPauseButtonPin, INPUT_PULLUP);
  pinMode(nextButtonPin, INPUT_PULLUP);
  pinMode(prevButtonPin, INPUT_PULLUP);
  pinMode(volumeUpButtonPin, INPUT_PULLUP);
  pinMode(volumeDownButtonPin, INPUT_PULLUP);
  pinMode(powerButtonPin, INPUT_PULLUP);

  // OLED 디스플레이 초기화
  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println(F("SSD1306 allocation failed"));
    while (true);
  }
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  
  // DFPlayer 초기화
  if (!myDFPlayer.begin(mySerial)) {
    Serial.println(F("Unable to begin:"));
    Serial.println(F("1. Please recheck the connection!"));
    Serial.println(F("2. Insert the SD card!"));
    while (true);
  }
  Serial.println(F("DFPlayer Mini online."));
  
  // 초기 볼륨 설정
  myDFPlayer.volume(volume);
  Serial.print(F("Volume set to "));
  Serial.println(volume);

  // 첫 번째 트랙 재생
  myDFPlayer.play(trackNumber);
  isPlaying = true;
  Serial.print(F("Playing track "));
  Serial.println(trackNumber);

  // OLED 디스플레이에 초기 정보 표시
  updateDisplay();
}

void loop() {
  // 전원 버튼 읽기
  if (digitalRead(powerButtonPin) == LOW) {
    delay(50); // 디바운스
    if (digitalRead(powerButtonPin) == LOW) {
      powerOn = !powerOn;
      if (powerOn) {
        myDFPlayer.start();
        isPlaying = true;
        Serial.println(F("Power ON"));
      } else {
        myDFPlayer.pause();
        isPlaying = false;
        Serial.println(F("Power OFF"));
      }
      updateDisplay();
      while (digitalRead(powerButtonPin) == LOW); // 버튼이 릴리스될 때까지 대기
    }
  }

  // 재생/정지 버튼 읽기
  if (digitalRead(playPauseButtonPin) == LOW && powerOn) {
    delay(50); // 디바운스
    if (digitalRead(playPauseButtonPin) == LOW) {
      if (isPlaying) {
        myDFPlayer.pause();
        Serial.println(F("Paused"));
      } else {
        myDFPlayer.start();
        Serial.println(F("Playing"));
      }
      isPlaying = !isPlaying;
      updateDisplay();
      while (digitalRead(playPauseButtonPin) == LOW); // 버튼이 릴리스될 때까지 대기
    }
  }

  // 다음곡 버튼 읽기
  if (digitalRead(nextButtonPin) == LOW && powerOn) {
    delay(50); // 디바운스
    if (digitalRead(nextButtonPin) == LOW) {
      myDFPlayer.next();
      trackNumber++;
      Serial.print(F("Next track: "));
      Serial.println(trackNumber);
      updateDisplay();
      while (digitalRead(nextButtonPin) == LOW); // 버튼이 릴리스될 때까지 대기
    }
  }

  // 이전곡 버튼 읽기
  if (digitalRead(prevButtonPin) == LOW && powerOn) {
    delay(50); // 디바운스
    if (digitalRead(prevButtonPin) == LOW) {
      myDFPlayer.previous();
      if (trackNumber > 1) trackNumber--;
      Serial.print(F("Previous track: "));
      Serial.println(trackNumber);
      updateDisplay();
      while (digitalRead(prevButtonPin) == LOW); // 버튼이 릴리스될 때까지 대기
    }
  }

  // 볼륨 증가 버튼 읽기
  if (digitalRead(volumeUpButtonPin) == LOW && powerOn) {
    delay(50); // 디바운스
    if (digitalRead(volumeUpButtonPin) == LOW) {
      if (volume < 30) volume++;
      myDFPlayer.volume(volume);
      Serial.print(F("Volume increased to "));
      Serial.println(volume);
      updateDisplay();
      while (digitalRead(volumeUpButtonPin) == LOW); // 버튼이 릴리스될 때까지 대기
    }
  }

  // 볼륨 감소 버튼 읽기
  if (digitalRead(volumeDownButtonPin) == LOW && powerOn) {
    delay(50); // 디바운스
    if (digitalRead(volumeDownButtonPin) == LOW) {
      if (volume > 0) volume--;
      myDFPlayer.volume(volume);
      Serial.print(F("Volume decreased to "));
      Serial.println(volume);
      updateDisplay();
      while (digitalRead(volumeDownButtonPin) == LOW); // 버튼이 릴리스될 때까지 대기
    }
  }

  // 자동재생 처리
  if (myDFPlayer.available() && powerOn) {
    uint8_t type = myDFPlayer.readType();
    if (type == DFPlayerPlayFinished) {
      Serial.println(F("Track finished, playing next track"));
      myDFPlayer.next();
      trackNumber++;
      updateDisplay();
    }
  }
}

void updateDisplay() {
  display.clearDisplay();
  display.setCursor(0, 0);
  if (powerOn) {
    display.print(F("Power: ON"));
    display.print(F("  Volume: "));
    display.println(volume);
    display.print(F("Track: "));
    display.println(trackNumber);
    display.print(F("Status: "));
    display.println(isPlaying ? "Playing" : "Paused");
  } else {
    display.println(F("Power: OFF"));
  }
  display.display();
}

위와 같이 코딩을 작성한 후 아두이노에 업로드 하면 다음과 같이 MP3 플레이어가 작동하는 결과를 볼 수 있다.

출력 결과 : 

https://www.youtube.com/watch?v=iIHMpeOKoBc

YX5300모듈을 사용하여 기본적인 MP3 플레이어를 만들어 보았다. 여기서 조금만 더 기능을 추가하면 다양한 형태의 플레이어를 만들 수 있다. 

0.91인치 128X32 OLED 디스플레이 모듈은 디스플레이 출력 장치로 다양한 전자 기기에 적용할 수 있다. 

디스플레이의 해상도는 128X32pxel 이며, 사이즈는 0.91인치이다. 

이 모듈은 주로 아두이노 보드, 라즈베리파이, 마이크로 컨트롤러 등 다양한 임베디드 시스템에서 널리 사용된다.

예를 들면 시계, 날씨정보, MP3 플레이어 정보표시 등과 같이 텍스트, 그래픽 및 도형을 출력할 수 있다.  

※ "이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다."

https://link.coupang.com/a/b2EVNB

https://link.coupang.com/a/b2vSOT

https://link.coupang.com/a/b2EYoZ

오늘은 0.91인치 128X32 OLED 디스플레이 모듈을 아두이노 보드에 연결하여 문자 및 도형을 표시하는 방법을 소개해보도록 하겠다.

우선 OLED 디스플레이 모듈을 아두이노에 다음과 같이 연결한다.

다음은 Arduino IDE에 OLED 모듈에 필요한 라이브러리를 설치한다.

1. 아두이노 IDE에서 새로운 창을 연다.

2. 상단 메뉴에서 Sketch > Include Library > Manage Libraries 를 선택한다.

3. Library Manager 창이 열리면 검색창에 Adafruit SSD1306을 입력하고 설치를 진행한다.

4. Adafruit GFX Library를 설치한다.

라이브러리를 설치한 후 아래 코드를 아두이노에 업로드한다. 

예제코드 : 

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

// 화면의 너비와 높이 정의
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 32

// 아두이노용 I2C 주소 설정 (기본값: 0x3C)
#define OLED_RESET    -1 // 공유 리셋 핀 없음
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

void setup() {
  // 시리얼 통신 시작
  Serial.begin(9600);
  
  // 초기화 코드
  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println(F("SSD1306 allocation failed"));
    for(;;);
  }

  // 화면 초기화
  display.clearDisplay();
  
  // 텍스트 설정
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  display.println(F("Hello, world!"));
  
  // 도형 그리기
  drawShapes();

  // 화면에 출력
  display.display();

}

void loop() {
  // 메인 루프는 비어 있음
}

void drawShapes() {

  // 사각형 그리기
  display.drawRect(0, 15, 10, 10, SSD1306_WHITE);
  
  // 채워진 사각형 그리기
  display.fillRect(30, 15, 10, 10, SSD1306_WHITE);
  
  // 원 그리기
  display.drawCircle(60, 20, 5, SSD1306_WHITE);
  
  // 채워진 원 그리기
  display.fillCircle(90, 20, 5, SSD1306_WHITE);
}

이 코드는 OLED 디스플레이에 "Hello world!"라는 문자와 사각형, 원형 메시지를 표시한다.

 

 

출력 결과 :

이 예제를 통하여 0.91Inch 128X32 OLED 디스플레이 모듈을 사용하여 다양한 형태의 모형들을 표시할 수 있다.

Rain Sensor는 비나 눈이 내리면 감지하여 장치를 제어하는데 사용된다.

활용성 : 

1. 자동차의 와이퍼 시스템에 연결되어 비가 감지되면 와이퍼를 자동으로 작동시킬 수 있다.

2. 스마트 하우스 시스템에서 비가 감지되면 창문을 자동으로 닫는 기능을 수행할 수 있다.

3. 자동관개 시스템에서 비가 감지되면 농작물의 물 공급을 중단하여 에너지를 절양하는 기능을 수행할 수 있다.

구조 원리 : 

이 센서의 구조는 두개의 금속 트랙이 기판에 격자모양과, 골뱅이 모양으로 배열되어 있다.

원리는 빗방울이 금속 트랙에 닿으면 전기 저항값이 변하여 이를 감지하여 장치를 제어할 수 있다.

"이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다."

https://link.coupang.com/a/b2E4y0

https://link.coupang.com/a/b2vTO0

https://link.coupang.com/a/b2vSOT

https://link.coupang.com/a/b2E5Xq

실습 예제 : 

비 감지 센서를 아두이노에 사용하여 자동 와이퍼  시스템을 만들어 보겠다.

작동 방식은 비 감지 센서에 물이 감지되면 서보모터가 90도 회전하면서 와이퍼 작동이 된다. 동시에 LED다이오드가 켜지면서 부저모듈에서 경고음이 울리도록 한다. 또한 LCD 디스플레이에 센서감지 수치와, 와이퍼 작동(OPEN)할 때와 작동하지 않을(CLOSE) 때를 현시하여 준다. 

준비물 :

아두이노 우노 R3, Rain 센서 모듈, LCD1602 디스플레이 모듈, 부저모듈, LED다이오드, 서보모터 등이 사용된다.

Rain 센서 모듈	아두이노 우노 R3	LCD1602 디스플레이 모듈
서보 모터	부저 모듈	LED 다이오드

회로 연결 : 

서보모터:

1.  VCC (Red wire): 아두이노의 5V 핀에 연결
2.  GND (Brown wire): 아두이노의 GND 핀에 연결
3.  Signal (Orange wire): 아두이노의 디지털 핀 (예: D8)에 연결

위와 같이 회로연결이 되면 다음과 같이 코딩을 작성한다.

코드 :

#include <LiquidCrystal_I2C.h> // LCD1602 함수 선
#include <Servo.h> 

// 레인 센서가 연결된 아날로그 핀
const int rainSensorPin = A0;

const int ledPin = 13;      // LED가 연결된 디지털 핀
const int buzzerPin = 9;    // 부저 모듈이 연결된 디지털 핀
const int servoPin = 8;     // 서보모터가 연결된 디지털 핀
const int threshold = 300;  // 비 감지 임계값

LiquidCrystal_I2C lcd (0x27,16,2);   // LCD1602 hexa값, 2행 16열 설정

Servo myServo;       // 서보모터 객체 생성

void setup() {
  lcd.init();    // LCD 초기화 
  lcd.backlight();  // LCD 백라이트 켬
  
  Serial.begin(9600);  // 시리얼 모니터 시작
  
  pinMode(ledPin, OUTPUT);  // LED 핀을 출력 모드로 설정
  
  myServo.attach(servoPin);  // 서보모터 핀 설정
  
  myServo.write(0);   // 초기 위치 설정 (창문 열림 상태)
}

void loop() {
  // 레인 센서의 아날로그 값을 읽음
  int sensorValue = analogRead(rainSensorPin);

  // 시리얼 모니터에 값 출력
  Serial.print("Rain Sensor Value: ");
  Serial.println(sensorValue);

  // 센서 값이 임계값보다 작으면 (비가 내리면) LED 켜기
  if (sensorValue < threshold) {
    digitalWrite(ledPin, HIGH);
    tone(buzzerPin, 1000);    // 부저를 1kHz로 설정하여 소리 출력
    myServo.write(90); // 서보모터를 90도로 회전 (창문 닫기)
    lcd.setCursor(0,1);            // LCD 1행 2열에 출력
    lcd.print("WIPER : CLOSE");
    
  } else {
    digitalWrite(ledPin, LOW);
    noTone(buzzerPin);        // 부저 소리를 끔
    myServo.write(0); // 서보모터를 0도로 회전 (창문 열기)
    lcd.setCursor(0,1);            // LCD 1행 2열에 출력
    lcd.print("WIPER : OPEN");
  }

  lcd.setCursor(0,0);            // LCD 1행 1열에 출력
  lcd.print("Value : ");
  lcd.print(sensorValue);      // LCD에 센서값 출력

  delay(1000);   // 1초 대기

  lcd.clear();  // LCD 클리어
}

코딩 설명 :

Rain 센서는 아날로그 핀(AO)은 아두이노 A0로 설정하였고, 서보모터는 D8, 부저모듈은 D9, LED다이오드는 D13핀으로 설정하였다.

비 감지센서 임계 값은 300으로 설정하였고, 임계 값이 300이하로 떨어지면 아두이노에 연결된 장치들이 작동 되게 하였다. (서보모터 : 90도 회전, 부저모듈 : 경고음 울림, LED다이오드 : ON, LCD1602 : WIPER "OPEN, CLOSE" 출력)

임계 값이 300이상인 경우에는 아두이노에 연결된 모든 장치들은 작동되지 않게 하였다. 

코딩을 전부 작성하고 파일을 아두이노에 업로드 하면 다음과 같은 출력 결과를 볼 수 있다.

출력 결과 :

https://www.youtube.com/watch?v=lHVTQ1rqRyc

결과는 빗물이 감지되었을 때 와이퍼 작동 모터가 움직이고 빗물이 없으면 와이퍼도 멈추게 된다. 

이 빗물감지 센서를 이용하여 강수감지, 자동차 응용, 관개 시스템, 가정 자동화, 산업 및 환경 모니터링 등 다양한 시스템을 개발할 수 있다. 

SW-420 모션센서 모듈은 진동 및 충격을 감지하는데 사용된다.

사용범위는 경보 시스템, 보안시스템, 진동감지 등 다양한 분야에 사용되며, 흔들림이나 충격이 발생했을 때 진동 신호를 출력한다.

모듈 구성 요소

1. 내부에 작은 스프링이 있어 진동이나 충격이 발생하면 아날로그 신호를 발생시킨다.

2. 모듈에는 LM393 비교기가 있는데 센서에서 발생하는 아날로그 신호를 디지털 신호로 변환한다. 비교기는 설정된 기준 전압과 센서의 출력 전압을 비교하여 진동이 감지되면 디지털 신호를 출력한다.

3. 모듈에 감도조절 가변저항이 있는데 이를 통해 사용자가 감지 기준을 설정할 수 있다.

작동 원리

1. 모듈에 전원이 공급되면 센서가 대기 상태에 들어간다.

2. 진동이나 충격이 발생하면 센서 내부의 스프링이 움직이면서 아날로그 신호를 발생한다.

3. 발생된 아날로그 신호가 LM393 비교기로 전달되며, 비교기는 이 신호를 미리 설정된 기준 전압과 비교하여 디지털 신호로 변환한다.

4. 디지털 출력 핀에서 HIGH 신호가 발생하여 진동이나 충격이 감지되었음을 알려준다.

"이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다."

https://link.coupang.com/a/b2Fgl0

https://link.coupang.com/a/b2vSOT

https://link.coupang.com/a/b2vTO0

https://link.coupang.com/a/b2E5Xq

실습 예제

다음은 SW-420 모션센서 모듈을 사용한 진동감지기를 만들어 보도록 하겠다.

모션센서 감지기의 동작원리는 아두이노 우노 R3을 사용하여 센서의 진동이나 충격이 가해지면  부저모듈에 경고음이 울리는과 동시에 경고 신호등이 켜지면서 LCD 디스플레이에 진동이 감지되었음을 현시하여 준다.

구성품 : 

아두이노 우노 R3	SW-420 모션센서	LCD1602	부저 모듈

준비품으로는 아두이노 우노 R3(아두이노는 용도에 맞게 아무거나 사용해도 됨), SW-420모션센서, LCD1602 디스플레이, 부저모듈, led 다이오드, led에 연결할 300옴 저항 등이 필요하다. 

준비가 전부 완료되면 아래와 같이 센서, 모듈들을 아두이노에 연결한다. 

회로 연결 : 

위와 같이 회로를 연결하고 다음과 같이 코딩한다.

코딩에 대해 간단히 설명하자면 모션센서의 디지털 출력핀 DO는 아두이노 D7번으로 설정하였고, LED경고신호는 D13번, 부저모듈의 신호핀은 D9번으로 설정하였다. 

다음 센서핀은 입력(INPUT), led핀은 출력(OUTPUT) 으로 설정하였다. 

감지 기능은 센서값(sensorValue)가 HIGH일 때 ledPin은 HIGH가 되고,  부저핀(buzzerPin)을 1000으로 설정하여 경고음이 울리게 하였고, 동시에 시리얼 모니터와 LCD1602 디스플레이에 모션감지(Motion Detected)라고 현시되게 하였다.

그리고 센서 값이 LOW인 경우에는 LED 다이오드, 부저모듈은 출력되지 않게 하였고, LCD1602에는  감지없음(No Detected)이라고 출력되게 하였다. 

코드 : 

#include <LiquidCrystal_I2C.h>
const int sensorPin = 7; // 모션센서의 디지털 핀을 7번 핀에 연결
const int ledPin = 13;   // LED를 13번 핀에 연결
const int buzzerPin = 9;     // 부저 모듈이 연결된 디지털 핀

LiquidCrystal_I2C lcd (0x27,16,2);   // LCD1602 hexa값, 2행 16열 설정

void setup() {
  lcd.init();    // LCD 초기화 
  lcd.backlight();  // LCD 백라이트 켬
  pinMode(sensorPin, INPUT);
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  int sensorValue = digitalRead(sensorPin);
  if (sensorValue == HIGH) {
    digitalWrite(ledPin, HIGH);
    tone(buzzerPin, 1000);         // 부저를 1kHz로 설정하여 소리 출력
    Serial.println("Motion Detected!");
    lcd.setCursor(0,1);            // LCD 1행 2열에 출력
    lcd.print("Detected!");      // LCD에 센서값 출력
  } else {
    digitalWrite(ledPin, LOW);
    noTone(buzzerPin);             // 부저 소리를 끔
    lcd.setCursor(0,1);            // LCD 1행 2열에 출력
    lcd.print("NO Detected!");      // LCD에 센서값 출력 
  }
 
  lcd.setCursor(0,0);            // LCD 1행 1열에 출력
  lcd.print("Motion:");      // LCD에 센서값 출력
  delay(1000);

  lcd.clear();  // LCD 클리어
}

코딩을 전부 작성하고 파일을 아두이노에 업로드 하면 다음과 같이 출력됨을 보게 될것이다.

출력 결과 :

https://www.youtube.com/watch?v=wwHeBGqORLw

참고 사항

감도 조절 : 포텐셔미터를 사용하여 감도를 조절할 수 있다. 민감하게 설정하면 작은 진동도 감지할 수 있으며, 둔감하게 설정하면 큰 진동만 감지할 수 있다.

압전진동 타진센서는 기계나 구조물의 진동을 감지하고 측정하는 센서이다.

"압전"은 전기적 변환을 나타내며, 압전 센서는 압력이나 변위와 같은 물리적인 변화를 전기적 신호로 변환한다.

"진동 타진"은 기계의 운전 중 발생하는 진동과 타진을 의미한다. 따라서 압전진동 타진센서는 이러한 진동 및 타진을 감지하여 전기적 신호로 변환하여 측정한다.

이러한 센서는 기계의 상태 모니터링, 구조물의 건축 안전 감시, 자동차 엔진의 진동 진단 등 다양한 응용 분야에서 사용된다.

기계 상태 모니터링	구조물 건축 안전 감시	자동차 엔진의 진동 진단

"이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다."

https://link.coupang.com/a/b2FjjH

https://link.coupang.com/a/b2vSOT

https://link.coupang.com/a/b2vTO0

https://link.coupang.com/a/b2E5Xq

실습 : 
아두이노와 압전진동 타진센서를 함께 사용하여 진동을 감지하고 데이터를 수집할 수 있다.

이번 실습은 아두이노에 압전진동 센서를 사용하여 어느한 임계값에 도달하면 LED 다이오드가 켜지면서 부저모듈에서 신호음음 울리는 측정기를 만들어 보겠다.

아래는 압전진동 타진센서를 아두이노와 연결하는 간단한 방법이다:

1. 센서 연결: 일반적으로 압전진동 타진센서에는 세 개의 핀(전원, 지상, 신호)이 있다. 아두이노의 아날로그 입력 핀에 센서의 신호 핀을 연결하고, 전원 핀을 5V에, 지상 핀을 GND에 연결한다.

준비품 : 

아두이노 우노 R3	압전진동 타진센서	LCD1602 디스플레이
부저 모듈	LED 다이오드	300옴 저항

회로 연결 : 

위와 같이 회로를 연결하고 아두이노 IDE에  다음과 같이 코딩을 작성한다.

#include <LiquidCrystal_I2C.h>
const int sensorPin = A0; // 압전진동 타진센서가 연결된 아날로그 핀
const int ledPin = 13;    // LED가 연결된 핀
const int buzzerPin = 9;     // 부저 모듈이 연결된 디지털 핀
int sensorValue = 0;      // 센서 값 저장 변수
int threshold = 13;        // LED를 켜기 위한 임계값

LiquidCrystal_I2C lcd (0x27,16,2);   // LCD1602 hexa값, 2행 16열 설정

void setup() {
  lcd.init();    // LCD 초기화 
  lcd.backlight();  // LCD 백라이트 켬
  Serial.begin(9600);    // 시리얼 통신 시작
  pinMode(sensorPin, INPUT); // 센서 핀을 입력으로 설정
  pinMode(ledPin, OUTPUT);   // LED 핀을 출력으로 설정
}

void loop() {
  sensorValue = analogRead(sensorPin); // 센서 값을 읽음
  Serial.println(sensorValue);         // 시리얼 모니터에 출력

    if (sensorValue > threshold) {   // 센서 값이 임계값을 초과하면
    digitalWrite(ledPin, HIGH);    // LED를 켬
    tone(buzzerPin, 1000);         // 부저를 1kHz로 설정하여 소리 출력
  } else {                         // 그렇지 않으면
    digitalWrite(ledPin, LOW);     // LED를 끔
    noTone(buzzerPin);             // 부저 소리를 끔
  }

  lcd.setCursor(0,0);            // LCD 1행 1열에 출력
  lcd.print("Value : ");
  lcd.print(sensorValue);      // LCD에 센서값 출력
  delay(1000);                          // 1초 간격으로 반복

  lcd.clear();  // LCD 클리어
}

이 코드는 압전진동 타진센서로 감지된 진동이 임계값을 초과할 때 LED를 켜고 부저 모듈로 소리를 출력한다. 임계값 및 소리의 높이와 패턴을 조정하여 원하는 동작을 얻을 수 있다.

출력 결과 :

https://www.youtube.com/watch?v=oK-CpmWpkWM

출력결과는 진동센서가 거의 움직임이 없을 때 값이 13정도가 되었으므로 센서의 임계값을 13으로 설정하였고, 그 이상 초과하면 LED와 부저모듈에서 경고음이 울리도록 설계하였다.

탁도센서는 물의 탁함을 측정하는 데 사용되는 센서이다. 일반적으로 수질 관리, 음료수 생산, 수영장 및 물고기 양식 등 다양한 응용 분야에서 사용된다.

"이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다."

https://link.coupang.com/a/bOcULQ

https://link.coupang.com/a/b2vSOT

https://link.coupang.com/a/b2vTO0

사용 방법 : 

1. 센서 선택: 측정하려는 물의 특성과 환경에 맞는 적절한 탁도센서를 선택한다. 다양한 탁도 범위 및 해상도를 가진 센서가 있으므로 사용 목적과 요구 사항에 따라 선택해야 한다.
2. 센서 설치: 탁도센서를 측정하려는 물에 적절히 설치한다. 대부분의 탁도센서는 물에 직접 담그는 것이 일반적이지만, 일부 센서는 외부에 부착되어 사용될 수도 있다.
3. 보정: 일반적으로 탁도센서는 초기 보정이 필요하다. 이는 센서의 성능을 최적화하고 정확한 측정 값을 보장하기 위해 필요하다. 보정은 제조업체의 지침에 따라 수행되어야 한다.
4. 측정: 센서를 적절히 연결하고 전원을 공급한 후, 탁도를 측정한다. 대부분의 탁도센서는 디지털 또는 아날로그 신호를 출력하며, 이를 적절한 장비나 시스템에 연결하여 데이터를 확인할 수 있다.
5. 데이터 해석: 탁도센서가 측정한 데이터를 해석하여 필요한 작업을 수행한다. 예를 들어, 물의 탁도가 일정 수준을 초과하면 정화 또는 처리 과정을 수행해야 할 수 있다.
6. 유지 보수: 정기적인 유지 보수 및 교정을 통해 탁도센서의 성능을 유지하고 정확한 측정 값을 유지할 수 있다. 필요에 따라 센서를 청소하고 보정해야 한다.

실습 : 

아두이노에 탁도감지 센서를 사용하여 물의 탁도값을 측정하여 LCD 디스플레이에 출력하는 실험을 해보겠다.

준비품 : 

아두이노 우노 R3, 탁도감지센서, LCD1602디스플레이 모듈이 필요하다.

아두이노 우노 R3	탁도감지 센서	LCD1602 디스플레이 모듈

회로 연결 :

위와 같이 회로를 연결하고 아두이노 IDE에 다음과 같이 코딩을 작성한다.

코딩 : 

#include <LiquidCrystal_I2C.h>

const int sensorPin = A0; // 아날로그 핀 A0에 연결된 센서
const int ledPin = 13;    // LED가 연결된 핀

int sensorValue = 0; // 센서로부터 읽은 값

LiquidCrystal_I2C lcd (0x27,16,2);   // LCD1602 hexa값, 2행 16열 설정

void setup() {
  lcd.init();    // LCD 초기화 
  lcd.backlight();  // LCD 백라이트 켬
  Serial.begin(9600); // 시리얼 통신 시작
}

void loop() {
  sensorValue = analogRead(sensorPin); // 센서로부터 아날로그 값을 읽음
  Serial.print("탁도 값: ");
  Serial.println(sensorValue); // 탁도 값을 시리얼 모니터에 출력
  lcd.setCursor(0,0);   
  lcd.print("turbidity Value");
  lcd.setCursor(0,1);  
  lcd.print(sensorValue);

  delay(1000); // 1초 대기
  lcd.clear();  // lcd 지우기

}

위와 같이 코딩을 하고 아두이노에 업로드하고 실험을 하면 다음과 같다.

LCD 출력결과 : 

https://www.youtube.com/watch?v=vFlo90IHGhk

측정 결과를 보면 탁도센서가 빈공간에 있을 때 측정 값이 650정도 나오고, 순수한 물속에 있을 때 750정도, 간장을 희석한 물에 넣었을 때 대략 720정도가 나오는 것을 볼 수 있다. 

따라서 이 데이터에 기초하여 탁도감지 센서를 순수한 물속에 있을 때 초기보정한 다음 다양한 오염물의 농노를 측정할 수 있다. 

액체 감지 센서는 주로 다양한 산업 분야에서 사용되며, 액체의 존재, 레벨, 흐름 등을 감지하는 기능을 수행한다. 이러한 센서는 다양한 방식으로 작동할 수 있으며, 여러 가지 기술과 디자인이 있다. 그 중 일반적으로 사용되는 몇 가지 기능은 다음과 같다.

 

1. 액체 존재 감지: 액체가 특정 지역에 존재하는지 여부를 감지할 수 있다. 이는 액체의 유무를 감지하여 경보를 발생시키거나 자동으로 시스템을 제어하는 데 사용될 수 있다.
2. 액체 레벨 감지: 액체의 레벨을 감지하여 특정한 용기나 탱크의 액체 레벨을 모니터링하고 관리하는 데 사용된다. 이를 통해 생산 프로세스나 저장 용기의 액체 레벨을 실시간으로 모니터링할 수 있다.
3. 액체 흐름 감지: 액체의 흐름을 감지하여 특정한 조건이나 장치가 작동하도록 하는 데 사용된다. 예를 들어, 액체 흐름 감지 센서는 파이프 또는 배관 시스템에서 액체 흐름의 유무를 모니터링하고, 필요한 경우에만 펌프를 가동하거나 밸브를 제어한다.
4. 액체 특성 감지: 센서가 액체의 특성을 감지할 수도 있다. 이는 액체의 온도, pH, 농도 등의 특성을 모니터링하고 조절하는 데 사용될 수 있다.

액체 감지 센서는 주로 산업 자동화, 화학 공정, 식품 및 음료 산업, 환경 모니터링 및 제어 등 다양한 분야에서 사용된다. 이러한 센서는 생산성을 향상시키고 공정의 안전성과 효율성을 높이는 데 중요한 역할을 한다.

 

"이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다."

https://link.coupang.com/a/b2FnNQ

 

아두이노 액체감지 센서 - 기타측정도구 | 쿠팡

쿠팡에서 0.0 구매하고 더 많은 혜택을 받으세요! 지금 할인중인 다른 0 제품도 바로 쿠팡에서 확인할 수 있습니다.

www.coupang.com

 

https://link.coupang.com/a/b2vSOT

 

ATmega328P 마이크로 컨트롤러가 있는 아두이노 우노 R3 개발 보드 - 액세서리 | 쿠팡

쿠팡에서 0.0 구매하고 더 많은 혜택을 받으세요! 지금 할인중인 다른 0 제품도 바로 쿠팡에서 확인할 수 있습니다.

www.coupang.com

https://link.coupang.com/a/b2vTO0

 

아두이노 LCD1602 16x2 4핀 디스플레이 모듈/ Arduino LCD1602 Module - 액세서리 | 쿠팡

쿠팡에서 0.0 구매하고 더 많은 혜택을 받으세요! 지금 할인중인 다른 0 제품도 바로 쿠팡에서 확인할 수 있습니다.

www.coupang.com

 

 

실습 :

아두이노에 액체감지 센서를 사용하여 액체의 유무상태를 나타내는 시스템을 만들어 보겠다.

준비품 : 

아두이노 우노 R3, 액체감지 센서, LCD 1602 디스플레이 모듈

아두이노 우노 R3	액체감지 시스템	LCD 1602 디스플레이 모

위와 같이 회로를 연결하고 아두이노 IDE에 다음과 같이 코딩을 작성한다.

코딩 : 

#include <LiquidCrystal_I2C.h>

const int sensorPin = A0; // 액체 감지 센서의 핀
const int ledPin = 13;    // LED가 연결된 핀

LiquidCrystal_I2C lcd (0x27,16,2);   // LCD1602 hexa값, 2행 16열 설정

void setup() {
  lcd.init();    // LCD 초기화 
  lcd.backlight();  // LCD 백라이트 켬
  Serial.begin(9600);     // 시리얼 통신 시작
  pinMode(sensorPin, INPUT); // 센서 핀을 입력으로 설정
  pinMode(ledPin, OUTPUT);   // LED 핀을 출력으로 설정
}

void loop() {
  int sensorValue = digitalRead(sensorPin); // 액체 감지 센서의 값을 읽음
  
  if (sensorValue == LOW) {
    Serial.println("액체가 감지되었습니다.");
    digitalWrite(ledPin, LOW); // LED를 켬

      // LCD 1602에 센서 값 출력
    lcd.setCursor(0,0);   
    lcd.print("Liquid detection");
   // lcd.println(sensorValue);
  } else {
    Serial.println("액체가 감지되지 않았습니다.");
    digitalWrite(ledPin, HIGH);  // LED를 끔
      // LCD 1602에 센서 값 출력
    lcd.setCursor(0,0);   
    lcd.print("Liquid none");
  //  lcd.println(sensorValue);
  }
  
  delay(1000); // 1초 딜레이

  lcd.clear();

}

위와 같이 코딩 작성후 아두이노에 업로드 한다.

다음 시리얼 모니터를 켜놓은 상태에서 액체감지 센서를 액체속에 넣었다, 뺏다 하면 액체가 감지되었을 때와 없을 때를 분별할 수 있다.

아래는 시리얼 모니터 출력 결과 영상이다.

시리얼 모니터 출력결과 : 

다음은 LCD 디스플레이에 센서를 액체속에 넣었을 때 결과 영상이다.

LCD 출력 결과 : 

https://www.youtube.com/watch?v=LBI3DLIl8C0

이 액체 감지센서를 활용하면 액체 유무상 측정기, 저장탱크안에 있는  액체의 용량, 등 다양한 시스템에 활용될 수 있다.

HW-038 센서의 주요 기능은 수위를 감지하여 측정하고 모니터링하는 기능을 수행한다.

기능 :

수위 측정: HW-038는 액체의 수위를 정확하게 측정할 수 있다. 이를 통해 수조, 탱크, 강, 호수 등의 수위를 감지할 수 있다.

1. 고정밀도: HW-038는 일반적으로 고정밀도를 제공하여 정확한 수위 측정을 가능하게 한다. 
2. 비접촉 감지: 이 센서는 비접촉 방식으로 수위를 감지한다. 즉, 액체에 직접 접촉하지 않고도 수위를 측정할 수 있다.
3. 적용 다양성: 수위 감지 및 제어가 필요한 모든 곳에서 활용될 수 있다.  예를 들면 수위 감지 시스템, 수위 제어 장치, 홍수 감지 시스템 등에 사용될 수 있다.

"이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다."

https://link.coupang.com/a/b2FsLo

https://link.coupang.com/a/b2vSOT

https://link.coupang.com/a/b2vTO0

실습 :

HW-038 수위감지센서를 아두이노에 적용하여 수위를 측정하여 시리얼 모니터와 LCD 디스플레이에 출력하는 프로젝트를 만들어 보겠다.

준비품 : 

아두이노 우노 R3	HW-038 수위센서	LCD 1602 디스플레이

회로도 : 

결선 방법 :

위와 같이 회로를 연결하고 아두이노 IDE에 다음과 같이 코딩을 작성한다.

코딩 : 

// 아두이노에 HW-038 센서 연결
// VCC 핀을 아두이노 5V에 연결
// GND 핀을 아두이노 GND에 연결
// OUT 핀을 아날로그 핀 A0에 연결
#include <LiquidCrystal_I2C.h>

const int sensorPin = A0; // 센서의 아날로그 출력 핀
int sensorValue; // 센서의 아날로그 값

LiquidCrystal_I2C lcd (0x27,16,2);   // LCD1602 hexa값, 2행 16열 설정


void setup() {
  lcd.init();    // LCD 초기화 
  lcd.backlight();  // LCD 백라이트 켬
  Serial.begin(9600); // 시리얼 통신 시작
}

void loop() {
  // 센서 값 읽기
  sensorValue = analogRead(sensorPin);

  // 시리얼 모니터에 센서 값 출력
  Serial.print("Sensor Value: ");
  Serial.println(sensorValue);
   
  // LCD 1602에 센서 값 출력
  lcd.setCursor(0,0);   
  lcd.print("Water Level:");
  lcd.println(sensorValue);

  // 짧은 딜레이를 통해 센서 값을 일정 간격으로 업데이트
  delay(500);
  
  lcd.clear();

}

코딩 작성 후 아두이노에 업로드하고 시리얼 모니터를 작동하면  다음과 같이 수위에 따른 결과 값이 출력되는 것을 볼 수 있다.

LCD 디스플레이 출력 결과 : 

https://www.youtube.com/watch?v=lRT_3HYTTuQ

TEA5767 라디오 모듈은 라디오 수신을 위한 인기 있는 모듈 중 하나이다.

이 모듈은 다양한 라디오 수신기에 사용되며, 아날로그 FM 라디오 수신을 가능하게 한다.

주로 아두이노와 같은 마이크로컨트롤러와 함께 사용되어 프로젝트에 라디오 수신 기능을 추가할 때 편리하게 활용된다.

TEA5767 모듈은 I2C 인터페이스를 통해 제어되며, 사용자는 주파수, 볼륨 및 기타 설정을 조정할 수 있다.

이 모듈은 낮은 전력 소비와 높은 성능을 제공하여 휴대용 라디오에 이상적이다.

"이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다."

https://link.coupang.com/a/b13Sh8

https://link.coupang.com/a/b2vSOT

https://link.coupang.com/a/b2vTO0

TEA5767	아두이노 우노 R3	LCD 1602

이예제는 TEA5767 라디오 모듈을 사용하여 시리얼 모니터의 주파수 값을 키보드 "+" 와 "-"으로 조정하는 예제이다.

주파수 현시는 LCD 1602 디스플레이 모듈을 사용하였다.

회로 연결:

전체 코딩:

#include <Wire.h>
#include <TEA5767Radio.h>
#include <LiquidCrystal_I2C.h>  // LCE패널 함수 선언

unsigned char frequencyH = 0;
unsigned char frequencyL = 0;
unsigned int frequencyB;

double frequency = 0;
LiquidCrystal_I2C lcd (0x27,16,2);   

void setup()
{
  lcd.init();           // LCD 초기화
  lcd.backlight();      // LCD 뒷 전등 켬
  Wire.begin();
  frequency = 88.7; //starting frequency
  setFrequency();
  Serial.begin(9600);
  Serial.println(frequency);
}

void loop()
{
  if(Serial.available()) {
    int rc = Serial.read();
    if(rc == '+' && frequency <= 108.0) {
      frequency += 0.1;
      setFrequency();
      Serial.println(frequency);
    } else if(rc == '-' && frequency >= 88.0) {
      frequency -= 0.1;
      setFrequency();
      Serial.println(frequency);
    } 
  }

  // LCD의 커서를 첫번째 열에 첫번째행으로 설정     
  lcd.setCursor(0, 0);

  // 측정된 주파수 값을 LCD에현시
  lcd.print("RADIO FM:");
  lcd.print(frequency);     //주파수
  lcd.print("Hz");
}

void setFrequency()
{
  frequencyB = 4 * (frequency * 1000000 + 225000) / 32768;
  frequencyH = frequencyB >> 8;
  frequencyL = frequencyB & 0XFF;
  delay(100);
  Wire.beginTransmission(0x60);
  Wire.write(frequencyH);
  Wire.write(frequencyL);
  Wire.write(0xB0);
  Wire.write(0x10);
  Wire.write((byte)0x00);
  Wire.endTransmission();
  delay(100);  
}

위와 같이 회로 연결을 한다음 코딩을 하고 파일을 업로드 한다.

다음 아두이노 IDE의 Tools 메뉴에서 Serial Monitor를 선택한다.

그리고 키보드의 "+"를 누르면 주파수가 하나씩 증가하고, "-"를 누르면 주파수가 하나씩 감소하는 것을 볼 수 있다.

다음은 주파수가 증가하는 모습니다. 

시리얼 모니터 출력과 LCD1602  출력 결과

https://www.youtube.com/watch?v=O7S4utZjfj4

유량센서 YF-S401은 액체 유량을 측정하는 데 사용되는 감지 장치이다.

 
이 센서의 기능은 주로 다음과 같다.

1. 유량 측정: YF-S401은 액체가 흐르는 속도나 양을 측정한다. 이를 통해 액체가 특정 시간 동안 얼마나 많은 양으로 흐르는지 측정할 수 있다.
2. 디지털 출력: 이 센서는 디지털 출력을 생성하여 다른 장치에 전송할 수 있다. 일반적으로 펄스 출력 또는 디지털 시그널을 사용하여 유량 정보를 전송한다.
3. 내구성: YF-S401은 내구성이 뛰어나고 경제적인 장치이다. 플라스틱 또는 금속으로 만들어진 센서가 있으며, 액체가 흐르는 환경에 적합한 다양한 모델이 있다.
4. 낮은 소비 전력: 일반적으로 YF-S401은 낮은 전력을 소비하므로 배터리 또는 기타 전원 공급 장치로 작동할 수 있다.
5. 애플리케이션: 주로 급유 시스템, 농업 자동화, 산업 프로세스 모니터링 등 다양한 응용 분야에서 사용된다.

유량센서 YF-S401는 아두이노와 함께 사용하여 다양한 프로젝트에 활용할 수 있다. 아래는 YF-S401을 아두이노와 함께 사용하는 간단한 예제이다.
 

부품 : 아두이노 우노 R3, YF-S401 유량센서, 12V 소형양수기, 16X2 LCD 디스플레이

"이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다."

https://link.coupang.com/a/b13YHl

https://link.coupang.com/a/b131DK

https://link.coupang.com/a/b2vSOT

https://link.coupang.com/a/b2vTO0

아두이노 우노 R3	YF-S401 유량센서	12V 소형 양수기	1602 LCD 디스플레이

 
결선 방법

아래 코드는 YF-S401 센서로부터 펄스를 받아 유량을 계산하고 시리얼 모니터를 통해 표시한다. 펄스 수를 측정하여 시간당 유량을 계산하고 누적된 총 유량을 추적한다. 

#include <LiquidCrystal_I2C.h>  // LCE패널 함수 선언

const int sensorPin = 2;  // YF-S401 센서 신호 핀
volatile int pulseCount;  // 펄스 카운터
float flowRate;           // 유량
unsigned int flowMilliLitres;
unsigned long totalMilliLitres;
unsigned long oldTime;

 LiquidCrystal_I2C lcd (0x27,16,2);   

void setup() {
  lcd.init();           // LCD 초기화
  lcd.backlight();      // LCD 뒷 전등 켬
  Serial.begin(9600);
  pinMode(sensorPin, INPUT);
  pulseCount = 0;
  flowRate = 0.0;
  flowMilliLitres = 0;
  totalMilliLitres = 0;
  oldTime = 0;
  attachInterrupt(0, pulseCounter, FALLING);
}

void loop() {
  if ((millis() - oldTime) > 1000) {
    detachInterrupt(0);
    flowRate = ((1000.0 / (millis() - oldTime)) * pulseCount) / 7.5;  // 7.5는 센서의 각 유량당 펄스 수
    oldTime = millis();
    flowMilliLitres = (flowRate / 60) * 1000;
    totalMilliLitres += flowMilliLitres;
    pulseCount = 0;
    attachInterrupt(0, pulseCounter, FALLING);
  }
  Serial.print("유량: ");
  Serial.print(flowRate);
  Serial.print(" L/min\t");
  Serial.print("총 양: ");
  Serial.print(totalMilliLitres);
  Serial.println(" mL");

  // LCD에서 한번 현시되고 측정된 값이 바뀌면 지우고 다시 현시 
  lcd.clear();
  // LCD의 커서를 첫번째 열에 첫번째행으로 설정     
  lcd.setCursor(0, 0);

  // 측정된 거리값을 LCD에현시
  lcd.print("flowRate:");
  lcd.print(flowRate);     // 유량
  lcd.print("L/min\t");

  // LCD의 커서를 첫번째 열에 두번째행으로 설정     
  lcd.setCursor(0, 1);
  lcd.print("total:");
  lcd.print(totalMilliLitres);  //총양
  lcd.print("mL");
  delay(200);     // 0.2초간 지연
}

void pulseCounter() {
  pulseCount++;
}

 
아래 영상은 유량 측정기의 유량 및 총양을 시리얼 모니터와 LCD 디스플레이로 출력하는 모습이다.
https://www.youtube.com/watch?v=g6Wszr02FHU&t=2s

 
이 코드를 사용하여 유압 시스템, 농업 자동화, 물 관리 시스템 등 다양한 프로젝트에 적용할 수 있다.
 
 
 
 

아두이노에서 키패드와 LCD 디스플레이, 5V 릴레이를 사용하여 키패드 도어락을 만드는 법을 알아보겠다.

구성요소 : 아두이노 우노 R3, 4X4키패드, LCD1602 디스플레이 듈, 5V릴레이 모듈

"이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다."

https://link.coupang.com/a/b2vSOT

https://link.coupang.com/a/b2vTO0

https://link.coupang.com/a/b2FDaB

https://link.coupang.com/a/b2FEbX

아두이노에 다음과 같이 회로를 구성한다.

회로 결선도

위와 같이 회로를 구성한 다음 아두이노 IED에 LCD 및 키패드 라이브러리를 설치해야 한다.

설치 방법은 Sketch/Include Library/Manage Libraries에 들어간 다음 검색창에 LiquidCrystal_I2C 와 Keypad를 입력한 다음 설치하여 주면 된다.

코딩 :

#include <Wire.h> 
#include <LiquidCrystal_I2C.h>
#include <Keypad.h>

#define Password_Length 6 // 패스워드 길이 설정

int signalPin = 12;  

char Data[Password_Length]; 
char Master[Password_Length] = "1234*";   
byte data_count = 0, master_count = 0;
bool Pass_is_good;
char customKey;

const byte ROWS = 4;  // 키패드 행수 설정
const byte COLS = 4;  // 키패드 열수 설정

char hexaKeys[ROWS][COLS] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};

byte rowPins[ROWS] = {9, 8, 7, 6};  // 키패드 행핀 D6 ~ D9 설정
byte colPins[COLS] = {5, 4, 3, 2};  // 키패드 열핀 D2 ~ D5 설정

Keypad customKeypad = Keypad(makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS);

LiquidCrystal_I2C lcd (0x27,16,2);   // LCD1602 hexa값, 2행 16열 설

void setup(){

  lcd.init(); 
  lcd.backlight();
  pinMode(signalPin, OUTPUT);
  digitalWrite(signalPin, LOW);
}

void loop(){

  lcd.setCursor(0,0);
  lcd.print("PASSWORD_INPUT");

  customKey = customKeypad.getKey();
  if (customKey){
    Data[data_count] = customKey; 
    lcd.setCursor(data_count,1); 
    lcd.print(Data[data_count]); 
    data_count++; 
    }

  if(data_count == Password_Length-1){
    lcd.clear();

    if(!strcmp(Data, Master)){
      lcd.print("DOOR_OPEN");
      digitalWrite(signalPin, HIGH); 
      delay(3000);
      digitalWrite(signalPin, LOW);
      }
    else{
      lcd.print("ERROR");
      delay(3000);
      }
    
    lcd.clear();
    clearData();  
  }
}

void clearData(){
  while(data_count !=0){
    Data[data_count--] = 0; 
  }
  return;
}

코딩 중 char Master[Password_Length] = "1234*";   에서 1234*대신 자신의 비밀번호로 대체하여 변경할 수 있다.

암호 길이는 #define Password_Length 6에서 예를 들면 비밀번호 길이가 7자이면 길이를 8으로 입력하면 된다.

결과 화면

https://www.youtube.com/watch?v=EOxbbC2z40s

아두이노 우노 R3 : https://smartstore.naver.com/allbrands/products/7641474076

4X4키패드 : https://smartstore.naver.com/allbrands/products/7791417895

16x1 12c LCD 디스플레이 : https://smartstore.naver.com/allbrands/products/7649718878

5V릴레이 모듈 : https://smartstore.naver.com/allbrands/products/7640778967

TSOP1838  IR 적외선 센서를 사용하여 리모컨으로 아두이노를 제어하는 프로젝트를 만들어 보겠다.

이를 위해서는 TSOP1838  IR 적외선 감지센서와 리모컨 모듈을 사용하여 리모컨에서 받은 신호를 감지하고, 해당 신호에 따라 아두이노가 작동하도록 프로그래밍 해야 한다.

동작 : 아두이노에 적외선 센서를 연결하여 리모컨으로 LED와 릴레이 모듈을 제어하는 기능을 수행한다.

"이 포스팅은 쿠팡 파트너스 활동의 일환으로, 이에 따른 일정액의 수수료를 제공받습니다."

https://link.coupang.com/a/b2vSOT

https://link.coupang.com/a/b2FHco

https://link.coupang.com/a/b2FEbX

https://link.coupang.com/a/b2FJHB

https://link.coupang.com/a/b2FIQq

준비품 : 아우이노UNO R3, TSOP1838  IR 적외선 센서, 적외선 리모컨, LED_red, LED_blue, 릴레이  모듈, 300옴 저항_2개

아두이노 우노 R3	TSOP1838  IR 적외선 센서	적외선 리모컨	LED	릴레이 모듈
300옴 저항

회로 결선도

위 회로에서 릴레이 모듈의 VCC를 아두이노의 +5V에 연결하고, 릴레이 모듈의 IN을 아두이노핀의 A0에 연결한다.

다음은 실지 회로도이다.

위와 같이 회로를 구성하고 아두이노IDE에 코드를 작성한다.

코딩 

#include <IRremote.h>   // 적외선 함수 라이브러리 선언
int RECV_PIN = A0;    // 적외선 센서 신호를 아날로그핀 A0로 송수신 함
int led_red = 8;  // LED red를 D8로 선언
int led_blue = 9;  // LED blue를 D9로 선언
int swich = 7;    // 릴레이 입력을 D7로 선언

IRrecv irrecv(RECV_PIN);  //  IRremote를 사용하기 위해 irrecv객체 생성
decode_results results;   // 디코드한 결과 값

void setup()
{
 Serial.begin(9600);
  irrecv.enableIRIn();  // Start the receiver
  pinMode(led_red, OUTPUT);  // LED red
  pinMode(led_blue, OUTPUT);  // LED blue
  pinMode(swich, OUTPUT); // swich_on/off
  }

  void loop(){
  if(irrecv.decode(&results)){  // 적외선 리모컨의 신호를 받을 때
  Serial.println(results.value, HEX);  // 결과값을 HEX로 출력
  switch (results.value){
      case 0x80c: digitalWrite(8, HIGH); break; //전원버튼이 눌리면 LED_red ON
      case 0xc: digitalWrite(8, LOW); break; //전원버튼이 다시 눌리면 LED_red OFF
      case 0x80b: digitalWrite(9, HIGH); break; //AV/TV 버튼이 눌리면 LED_blue ON
      case 0xb: digitalWrite(9, LOW); break; //AV/TV버튼이 눌리면 LED_blue OFF
      case 0x80d: digitalWrite(7, HIGH); break; // CH_up버튼이 눌리면 swich ON
      case 0xd: digitalWrite(7, LOW); break;  // CH_down버튼이 눌리면 swich OFF    
        }
       irrecv.resume();  // 수광 다이오드 다음 값 받기
}
}

위의 코딩에서 HEX값인 0x80c, 0xc, 0x80b, 0xb, 0x80d, 0xd는 아두이노를 USB케이블을 연결하고 실행한 다음 리모컨으로 버튼을 눌렀을 때 아두이노 IDE의 툴/ 시리얼 모니터를 실행하면 해당버튼을 눌렀을 때에 따른 HEX값이 출력된다. 

리모컨 버튼 기능마다 HEX값이 다르므로 시리얼 모니터를 확인하고 출력된 값을 코딩에 입력하면 된다.

시리얼 모니터 출력 결과

다음은 리모컨을 눌렀을 때 LED와 릴레이 모듈을 제어하는 영상이다.

출력 결과

https://www.youtube.com/watch?v=hI1UjD9TyUo