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

파인썬으로 작성된 .py 파일을 파이썬이 설치되어 있지 않거나 다른 누군가에게 파일을 공유하려고 할 때, 혹은 GUI 프로그램을 독립적으로 실행하려면 파이썬 파일을 변환 시켜주어야 한다.

예를 들면 파이썬 파일로 작성된 GUI 계산기 프로그램이 있다고 하자.

이 파일을 Visual Sutudio Code 에서 실행하면 다음과 같이 GUI 파일이 실행될 것이다.

하지만 우리는 계산기를 VS 프로그램이 없이 독립적으로 전자계산기를 실행시켜야 한다. 이를 위해서는 calculator_GUI.py 파일을 앱 형식의 실행 파일로 변환시켜주어야 한다.

파이썬 스크립트를 실행 파일로 만들기 위한 도구는 'PyInstaller'이다. 이 도구는 Python 스크립트를 독립 실행 파일로 패키징 할 수 있어 파이썬이 설치되지 않은 시스템에서도 실행할 수 있다.

파일 변환 : 

1. PyInstaller 설치

먼저 'PyInstaller'를 설치해야 한다. 

터미널에서 다음과 같이 명령어를 입력하여 Pyinstaller를 설치하여 준다.

2. 스크립트를 실행 파일로 변환

터미널이나 명령 프롬프트에서 다음 명령어를 실행하여 Python 스크립트를 실행 파일로 변환할 수 있다.

파일 변환하기 전에 바탕화면에 간편 계산기라는 폴더를 하나 만들고 여기에 calculator_GUI.py 파일을 저장한다.

간편 계산기 폴더 만들기	폴더 안 파이썬 파일

현재 상태에서 보면 간편 계산기라는 폴더안에는 calculator_GUI.py 라는 파일 하나만 있는 것을 볼 수 있다.

다음 VS 코드상에서 파일을 실행시킨 터미널에서 다음 명령어를 입력한다.

그러면 간편 계산기 폴더안에 build, dist라는 파일이 생겨난것을 볼 수 있다.

위 명령어는 다음 작업을 수행한다.

1)  '--onefile' : 모든 파일을 하나의 실행 파일로 만든다.

2) '--window' : 콘솔 창 없이 GUI만 표시되도록 한다.

3) 'calculator_GUI.py' : python 스크립트 파일 이름이다. 해당 이름을 자신이 작성한 스크립트 이름으로 대체하면 된다.

3. 결과물 확인

dist 폴더안에 실행 가능한 파일이 생성된 것을 볼 수 있다. 이 파일을 클릭하면 계산기 프로그램이 실행된다.

dist 폴더안 실행파일

이제 Python 계산기를 독립 실행 파일로 변환하여 다른 사람들과 공유하거나 파이썬이 설치되지 않은 컴퓨터에서 사용할 수 있다.

파이썬 GUI로 간편 계산기를 만들어 보겠다.

파이썬 GUI로 전자 계산기를 만들기 위해서는 tkinter 라이브러리를 활용할 수 있다.

tkinter 라이브러리는 파이썬 표준 라이브러리로 간단한 GUI 애플리케이션을 만들 때 자주 사용된다.

그럼 이제부터 파이썬 GUI로 계산기를 만드는 과정을 설명하겠다.

먼저 Visual Studio Code를 실행하고 새로운 파일을 하나 만든다.

파일 이름을 calculator_GUI.py로 정하고 저장한 다음 다음과 같이 코드를 작성한다.

아래는 tkinter 라이브러리를 사용하여 전자계산기를 만든 파이썬 코드이다.

전체 코드 : 

import tkinter as tk

# 계산기 클래스
class Calculator:
    def __init__(self, root):
        self.root = root
        self.root.title("전자 계산기")

        # 입력창
        self.entry = tk.Entry(root, width=16, font=('Arial', 24), borderwidth=2, relief='solid')
        self.entry.grid(row=0, column=0, columnspan=4)

        # 버튼들
        buttons = [
            '(', ')', 'C', '/',
            '7', '8', '9', '*',
            '4', '5', '6', '-',
            '1', '2', '3', '+',
            '0', '.', '='
        ]

        # 버튼 생성 및 배치
        row_val = 1
        col_val = 0
        for button in buttons:
            if button == '0':
                tk.Button(root, text=button, width=11, height=2, font=('Arial', 18), command=lambda b=button: self.click(b)).grid(row=row_val, column=0, columnspan=2)
                col_val += 2  # '0' 버튼은 두 칸을 차지하므로 col_val을 2 증가시킴
            else:
                tk.Button(root, text=button, width=5, height=2, font=('Arial', 18), command=lambda b=button: self.click(b)).grid(row=row_val, column=col_val)
                col_val += 1
                if col_val > 3:
                    col_val = 0
                    row_val += 1

    # 버튼 클릭 이벤트 처리
    def click(self, button):
        if button == "=":
            try:
                result = str(eval(self.entry.get()))
                self.entry.delete(0, tk.END)
                self.entry.insert(tk.END, result)
            except Exception as e:
                self.entry.delete(0, tk.END)
                self.entry.insert(tk.END, "Error")
        elif button == "C":
            self.entry.delete(0, tk.END)
        else:
            self.entry.insert(tk.END, button)

# 메인 실행 부분
if __name__ == "__main__":
    root = tk.Tk()
    calculator = Calculator(root)
    root.mainloop()

코드 설명 : 

1. Calculator 클래스 : 계산기의 전체 구조를 관리하는 클래스이다.

    . '__init__' 메서드에서 버튼과 입력창을 설정한다.

    . 'click' 메서드는 버튼을 눌렀을 때 실행되는 동작을 정의한다.

# 계산기 클래스
class Calculator:
    def __init__(self, root):
        self.root = root
        self.root.title("Calculator")

2. 입력창 : 사용자가 입력한 계산식을 표시한다.

# 입력창
        self.entry = tk.Entry(root, width=16, font=('Arial', 24), borderwidth=2, relief='solid')
        self.entry.grid(row=0, column=0, columnspan=4)

여기서는 계산기 디자인의 너비, 폰트, 행, 열 등을 설정한다.

3. 버튼들 : 숫자와 연산자를 포함한 계산기의 버튼을 생성한다. 각 버튼은 'click' 메서드에 연결되어 클릭 시 동작을 수행한다.

# 버튼들
        buttons = [
            '(', ')', 'C', '/',
            '7', '8', '9', '*',
            '4', '5', '6', '-',
            '1', '2', '3', '+',
            '0', '.', '='
        ]

        # 버튼 생성 및 배치
        row_val = 1
        col_val = 0
        for button in buttons:
            if button == '0':
                tk.Button(root, text=button, width=11, height=2, font=('Arial', 18), command=lambda b=button: self.click(b)).grid(row=row_val, column=0, columnspan=2)
                col_val += 2  # '0' 버튼은 두 칸을 차지하므로 col_val을 2 증가시킴
            else:
                tk.Button(root, text=button, width=5, height=2, font=('Arial', 18), command=lambda b=button: self.click(b)).grid(row=row_val, column=col_val)
                col_val += 1
                if col_val > 3:
                    col_val = 0
                    row_val += 1

4. 연산처리 : '=' 버튼을 눌렀을 때 'eval' 함수를 사용하여 입력된 수식을 계산한다.

 # 버튼 클릭 이벤트 처리
    def click(self, button):
        if button == "=":
            try:
                result = str(eval(self.entry.get()))
                self.entry.delete(0, tk.END)
                self.entry.insert(tk.END, result)
            except Exception as e:
                self.entry.delete(0, tk.END)
                self.entry.insert(tk.END, "Error")
        elif button == "C":
            self.entry.delete(0, tk.END)
        else:
            self.entry.insert(tk.END, button)

위와 같이 코드를 전부 작성한 다음 메뉴 실행에서 디버깅을 시작한다. 

그러면 다음과 같이 GUI 계산기가 만들어 진것을 볼 수 있다.

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

참고 사항

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

ep02에서는 홈페이지 로고디자인 하는데까지 해보았고, 오늘은 메뉴 부분을 설정해보도록 하겠다.

헤더카테고리에서 메뉴를 선택한다.

펼쳐진 대화창에서 "(대분류)Outerwear"를 클릭하고, 메뉴명 항목에 자신이 생각한 메뉴명을 입력한 다음 적용을 누른다.

아래에 링크부분에는 상품분류, 상품, 게시판, 기획전, URL입력이 있는데 홈페이지 메뉴명 기능에 맞게 선택하여 주면 된다. 

예를 들면 저는 메뉴명을 전체상품으로 정했으므로 링크부분에서 상품을 선택하였다. 

같은 방법으로 메뉴명을 "베스트상품", "신상품" 등으로 수정하면 된다.

메뉴를 더 추가하고 싶으시면 상위메뉴 추가를 누르고 메뉴명을 입력한 다음 같은 방법으로 설정해주면 된다.

추가 메뉴명은 "가전디지털", "패션의류", "주방용품", "식품" 등으로 정하였다.

결과 화면 : 

이정도면 어느정도 쇼핑몰이 형태를 갖추어진것 처럼 보인다.

다음 헤더부분에 언어선택과 기본메뉴제공이 있는데 "언어선택"은 홈페이지를 추가하는 경우 선택을 하면 되고, "기본메뉴제공"은 홈페이지에 기정으로 제공되는 것이므로 수정할 필요가 없다.

스마트 배너 :

스마트 배너는 홈페이지 메인 상단에 위치하고 있으므로 쇼핑몰에서 판매할 주 상품들을 고객들에게 보여주면 된다. 

카테고리에서 스마트 배너를 클릭한다.

다음 배너 등록을 하면 된다. PC 이미지는 1680X712px, 모바일 이미지는 720X536px로 디자인하여 등록하여주면 된다. 

슬라이드 설정에서는 슬라이드 시간, 점형태, 바형태, 없음으로 설정하여주면 된다.

메인상품 분류:

메인상품 분류에서는 상품의 카테고리를 설정하면 상품 등록시 홈페이지에 카테고리별로 보여주게 된다.

추가버튼을 클릭하여 카테고리를 추가할 수 있다. 

아래에 있는 메인상품 분류카테고리, 동영상, 메인상품 분류 슬라이드, 이미지&텍스트 갤러리, 텍스트, 지도 등은 같은 방식으로 수정하여 주면 된다.

푸터 : 

푸터부분에서는 쇼핑몰 기본정보, 고객센터 정보, 결제정보, SNS 등을 등록할 수 있다.

쇼핑몰 기본정보에서는 회사 상호명, 대표자명, 사업장 주소, 고객센터번호, 사업자등록번호, 통신판매업신고 등을 등록하여주면 된다.

결제정보는 대표자의 본인 인증이 필요하므로 휴대폰이나 이메일로 본인인증하고 은행계좌를 등록하여 주면 된다.

본인인증을 마치면 다음과 같은 창이 나오는데 등록버튼을 누르고 은행명, 계좌번호, 예금주 등을 입력하고 저장을 한단. 

참고로 계좌정보를 등록한 다음 결제정보에서 계좌정보 동기화를 반드시 해주어야  홈페이지 푸터부분에 무통장 계좌정보가 현시된다.  

이렇게 쇼핑몰의 디자인은 전부 되었음을 미리보기로 보면 확인할 수 있다.

다음 시간에는 쇼핑몰에 상품등록 하는방법을 해보도록 하겠다.

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

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

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

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

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

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

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와 부저모듈에서 경고음이 울리도록 설계하였다.

오늘은 카페24로 만들어진 쇼핑몰 홈페이지를 자신의 취향에 맞게 디자인 편집하는 기능을 해보도록 하겠다.

ep01에서는 쇼핑몰을 생성하는데까지 해보았다. 혹시 보지 못하신 분들은 아래에 링크를 걸어놓을테니 참고하시면 좋을 것 같다.

https://hanwook-ai.tistory.com/84

카페24홈페이지 : https://www.cafe24.com/

카페24홈페이지로 들어가서 로그인하면 다음과 같은 창이 나온다.

왼쪽에 카테고리 메뉴에서 디자인(PC/모바일을) 누르고 펼쳐진 화면에서 "PC 대표 디자인"의 디자인 편집을 누른다.

그러면 다음과 같이 디자인 편집창이 나온다.

왼쪽 위 메뉴를 보면 "섹션, 스타일, 확장"이라고 3개의 메뉴가 있는데 각각의 기능은 다음과 같다.

섹션 : 쇼핑몰의 띠 배너, 헤더, 메뉴, 스마트배너, 메인 상품 분류, 상품분류 가테고리, 지도, 푸터 등 다양한 디자인을 편집할 수 있는 기능이 있다. 

스타일 : 쇼핑몰의 스타일을 선택하는 기능이다.  여기서는 쇼핑몰의 특성에 테마를 선택하여 주면 된다. 

확장 : 여기서는 SNS나 모바일 앱같은 기능을 추가하는 곳이다. 이 기능은 나중에 별도로 추가해보도록 하겠다.

그럼 이제부터 섹션메뉴에 있는 기능을 차례로 하나하나 편집해보도록 하겠다.

1. 스마트 팝업 

팝업 등록을 누르고 이미지 등록으로 들어간다.

여기서 이미지를 직접 등록할 수도 있고 간편하게 배너를 만들 수도 있다. 여기서는 간편하게 배너 만들기를 하여 배너를 만들겠다. 간편 배너로 들어가면 다양하게 만들어진 배너들이 있는데 필요한 것을 선택하고 자신의 쇼핑몰에 맞게 편집하고 적용하기를 클릭한다. 예를 들어 "초특가 할인 쿠폰"을 선택하고 적용하기를 클릭해본다. 

그러면 다음과 같이  홈페이지에 배너가 추가된것을 볼 수 있다.

2. 띠배너

띠배너는 홈페이지 제일 헤드부문에 나오는 배너인데 이것은 설정하여 배너가 나오게 할 수도 있고 나오지 않게 설정할 수도 있다.

사용함을 선택하여 홈페이지에 들어가보면 다음과 같이 띠배너가 나온 것을 볼 수 있다.

3. 헤더

헤더부분에는 로고, 메뉴, 언어선택, 기본제공 메뉴, 쇼핑기본정보 노출설정이 있다.

1) 로고는 자신의 쇼핑몰 로고를 설정하는 부분이다. 여기서는 자신이 직접만든 로고를 추가할 수도 있고, 간편로고 제작을 선택하여 디자인을 선택하고, 내용만 변경하여 로고를 추가할 수도 있다.

참고로 로고 권장 사이즈는 600X600px이고, 간편로고는 선택만 하여주면 된다. 우리는 간편로고를 선택하여 만들어 보겠다. 로고 탬플릿에 들어가면 다양한 로고가 있는데 자신의 취향에 맞는 것을 선택하고 적용하기를 누른다. 

그러면 홈페이지에 선택한 로고가 적용된 것을 볼 수 있다.

오늘은 쇼핑몰 홈페이지에 스파트 팝업, 띠배너, 헤더부분에서 로고생성 편집까지 해보았다.

다음은 상단 메뉴편집을 하는 것이 있는데 메뉴편집은 카테고리별로 설정해주어야 하므로 좀 복잡하고 시간이 많이 걸린다.

다음시간에는 메뉴만 전문 편집하는 것을 해보도록 하겠다.

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

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

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