[아두이노] 게임 조종기 아두이노

• 온라인 가상시뮬레이터 : https://www.tinkercad.com
• 참고 :
  [아두이노] 조이스틱 방향키 값 출력
  [아두이노] 아두이노 키보드 제어

오늘은 모바일 게임을 모모앱플레이어로 했을 때 PC에서 조정이 가능합니다. 이 때 게임 조정키를 키보드로 세팅해놓으면 이전 시간에 아두이노 키보드를 이용하면 모바일 게임을 조정할 수 있게 됩니다. 여기서, 키보드 방향 조정을 조이스틱으로 표현하면 좀 더 조정기 다운 표현이 되겠죠.

아두이노 마이크로에서 게임 조정기를 만들어 볼까요.

1. 방향키 제어 복습

• 사전학습 출처 : [아두이노] 조이스틱 방향키 값 출력

사전학습에 가시면 조이스틱을 방향키를 조절하는 방법에 대해 나와 있습니다.

[기본소스]

  if(analogRead(AXIS_X)<=300){
    Serial.println('a');
  }
  else if(analogRead(AXIS_X)>=700){
    Serial.println('d');   
  }
  //Y축 방향값
  if(analogRead(AXIS_Y)<=300){
    Serial.println('w');      
  }
  else if(analogRead(AXIS_Y)>=700){
    Serial.println('s');
  }

X축과 Y축의 아날로그 신호값을 나눠서 X축 방향으로 300이하면 왼쪽(a)키이고 700이상은 오른쪽(d)키이다. Y축 방향으로 300이하면 위쪽(w)키이고 700이상이면 아래쪽(s) 키이다 라고 정의해 놓았으면 아두이노 마이크로에서 키보드 라이브러리로 이용하면 아래와 같이 코딩하면 됩니다.

  //X축 방향값
  if(AXIS_X<=300){
     Keyboard.press('a');
     delay(50);
  }
  else if(AXIS_X>=700){
     Keyboard.press('d');
     delay(50);
  }
  else{
    Keyboard.release('a');
    Keyboard.release('d');  
  }
  //Y축 방향값
  if(AXIS_Y<=300){
    Keyboard.press('w');
    delay(50);
  }
  else if(AXIS_Y>=700){
    Keyboard.press('s');
    delay(50);    
  }
  else{
    Keyboard.release('w');
    Keyboard.release('s');
  }

비슷한데 좀 차이가 있죠. 키고 눌름 press()함수를 키 누름을 표현하지만 조이스틱이 키누름 값을 갖지 않을 때에만 해제 release() 함수로 표현 했습니다. 왜! 이렇게 표현했을까요.

Keyboard.press('a');
delay(100);
Keyboard.release('a');

가 한쌍으로 키 클릭을 표현했었죠. 이렇게 하면 0.1초간 눌러지고 키가 해제해 버립니다. 즉 순간 찰라에 키가 누르고 해제되면 조이스틱의 조정 방향으로 움찍하다가 끝나버리게 됩니다. 지속성이 사라져버리는 것이죠. 그렇기 때문에 조정키가 계속 지속성을 조이스틱의 키 누름 상태를 계속 유지해야 합니다. 그러면 release()함수를 쓰지 말아야 합니다. 이때 해제 함수를 안쓰면 계속 특정 키가 눌러지니깐 이때 문제가 생기기 때문에 조이스틱 방향으로 움직일 때는 키 누름을 하고 움직이지 않을 때는 키 누름을 해제하게 코딩을 하면 되겠죠. else 이하문에서 키누름을 해제하는 함수를 표현하여 조정 안하고 있을 때 키누름의 문제가 해결 됩니다.

좀 코딩이 약간 길어 졌지만 이렇게 표현하면 조이스틱으로 좀 더 자연스럽게 조정이 됩니다. 이방법은 문득 떠오른 생각을 코딩한 거라 최근 일이 있어서 집중을 못하고 그냥 대충 표현한 코딩이네요. 이 방법이 아닌 더 좋은 방볍으로 조이스틱을 방향키로 조절을 해보세요.

2. 아두이노 조이스틱 게임 조정기 회로도

• 준비물 : 조이스틱 1개, 스위치버턴 1개, LED 1개, 저항 220옴 1개, 스위치버턴 5개, 아두이노 마이크로
• 내용 : 조이스틱 xAxis, yAxis축은 A0, A1 핀에 연결하고 방향스위치버턴은 3,4,5,6번에 연결하시오. 인터럽트스위치버턴은 2번에 연결하고 LED 7번에 연결하면 됩니다.

조이스틱은 X,Y축값만 사용합니다. 스위치버턴은 사용하지 않았습니다. 위 그림에서 스위치버턴중 노란전선색의 스위치버턴은 인터럽트스위치로 아두이노 조이스틱 게임 조정기의 사용 가능/불가를 나타내고 나머지 스위치는 스킬키버턴으로 사용됩니다. Green LED은 게임 조정기의 사용 가능/불가 상태를 시각적으로 표현는데 사용합니다.

3. 코딩

• 사전학습 : [아두이노] 아두이노 키보드 제어

**설계 : **

• 조이스틱 방향키(위쪽-w, 아래쪽-s, 왼쪽-a, 오른쪽-d)로 조정
• 스킬키 4개의 키보드 키는 "u,i,o,p"로 조정(스위치버턴의 한계로 스킬장 전환은 못함)
• 실험 게임(검사 모바일)

[검사모바일] - 아두이노 게임 조정기를 만들어 단순히 게임을 컨트롤 해보기 위해서 1회 실험 목적으로 사용함.

대충 가상 키들을 방향키와 스킬키로 나누어 배치해 놓았습니다.

다음으로는 코딩인데 스킬키는 스위치버턴으로 키보드 키값을 누름을 표현했던 아두이노 키보드 제어편의 내용을 그대로 적용하면 되고 조이스틱 방향키만 위에서 복습한 내용을 아두이노 키보드 제어편 소스를 합치면 됩니다.

종합해보면,

#include <Keyboard.h>

const byte interruptPin = 2;
boolean state = true;

const byte xAxis = A0;         //X axis
const byte yAxis = A1;         //Y axis
const byte Pin_U = 3;
const byte Pin_I = 4;
const byte Pin_O = 5;
const byte Pin_P = 6;
const int ledPin = 7;         // Mouse control LED 

void setup() {
  pinMode(ledPin, OUTPUT);
  pinMode(Pin_U, INPUT_PULLUP); 
  pinMode(Pin_I, INPUT_PULLUP);
  pinMode(Pin_O, INPUT_PULLUP);
  pinMode(Pin_P, INPUT_PULLUP);
  
  pinMode(interruptPin, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(interruptPin), exchange, FALLING);  //인터럽트 발생 시 호출
  
  Keyboard.begin();
}

void loop() {
  
  if(state==false){ //인터럽트스위치 버턴에 의해서 열림/닫힘
    int AXIS_X = analogRead(xAxis);
    int AXIS_Y = analogRead(yAxis);
     
  //X축 방향값
  if(AXIS_X<=300){
     Keyboard.press('a');
     delay(50);
  }
  else if(AXIS_X>=700){
     Keyboard.press('d');
     delay(50);
  }
  else{
    Keyboard.release('a');
    Keyboard.release('d');  
  }
  //Y축 방향값
  if(AXIS_Y<=300){
    Keyboard.press('w');
    delay(50);
  }
  else if(AXIS_Y>=700){
    Keyboard.press('s');
    delay(50);    
  }
  else{
    Keyboard.release('w');
    Keyboard.release('s');
  }
    
  //스킬키 제어
  if(digitalRead(Pin_U) == LOW){
    Keyboard.press('u');
    delay(100);
    Keyboard.release('u');
  }
  if(digitalRead(Pin_I) == LOW){
    Keyboard.press('i');
    delay(100);
    Keyboard.release('i');      
  }
  if(digitalRead(Pin_O) == LOW){
    Keyboard.press('o');
    delay(100);
    Keyboard.release('o');      
  }
  if(digitalRead(Pin_P) == LOW){
    Keyboard.press('p');
    delay(100);
    Keyboard.release('p');      
  }     
 }  
}
void exchange() { //인터럽트스위치버턴  이벤트
 state=!state;
 digitalWrite(ledPin, !state);
}

방향키 IF문과 스킬키 스위치버턴 IF문 두개만 자세히 보시면 그렇게 어렵지 않을꺼에요.

4. 결과

아래 실험영상은 우선 인터럽트 스위치 버턴은 게임조성기를 활성화 하는 버턴입니다. 불이 들어오면 게임조정기를 조정할 수 있고 불이 안들어오면 게임 조정기를 사용할 수 없습니다. 한손으로 촬영하고 한손으로 조정하다 보니 케릭터 방향조정 따로 스킬키 동작 따로 단순한 동작만 실험했네요. 감안하시고 대충 이런 느낌으로 아두이노 조정기로 게임을 조정할 수 있구나 정도로 이해하시면 됩니다.

실험하려고 잠깐 검사모바일 게임 케릭터를 하나 만들어서 테스트 해 봤네요.

마무리

며칠 바빠서 post를 작성 할 시간도 스팀잇 접속도 어려웠네요. 오늘도 겨우 짬내서 급하게 코딩을 만들고 실험을 했네요. 코딩해 놓은게 별로 맘에 들지 않네요. 원하는 스타일도 아니고 대충 느낌만 전달하고자 간단히 실험했습니다.

[아두이노] 아두이노 조이스틱마우스 제어

• 온라인 가상시뮬레이터 : https://www.tinkercad.com
• 참고 : [아두이노] 아두이노 마우스 제어

지난 시간에 아두이노 마우스 제어를 스위치버턴으로 실험해 보았습니다. 스위치 버턴의 경우는 위/아래, 좌/우, 대각선 방향으로 선형 이동을 하게 됩니다. 곡선 이동은 스위치버턴으로 표현하기가 힘듭니다. 실제 마우스의 움직임을 보면 원형 방향을 회전을 하면 약간 곡선 모양으로 움직이는데 스위치버턴으로는 그 표현이 어렵습니다. 그래서, 좀 더 부르겁게 움직이게 하기 위해서 조이스틱을 이용하여 실험을 해보겠습니다. 아두이노 IDE의 USB 예제 중 "JoystickMouseControl"소스를 기반으로 실험을 하겠습니다.

조이스틱에는 xAxis, yAxis 값과 swPin(스위치버턴) 값을 출력합니다. 조이스틱의 x,y과 스위치버턴 이벤트만 적용하여 실험이 이루어집니다. 아래 사진의 3개의 파란버턴을 있는데 한개 버턴만 인터럽트스위치버턴으로 마우스 동작을 수행할 것인지 안할 것인지 결정하는 안정장치 버턴으로 활용합니다. 사실 스위치 버턴을 사진에 들어가 있지만 표현할 필요는 없습니다. 조이스틱이 버턴 한개가 내장 되어있으니깐 원래는 스위치 버턴이 필요 업습니다.

아두이노 마이크로에서 조이스틱을 제어해 볼까요.

1. 조이스틱 마우스 사전학습

• 사전학습 출처 : https://www.arduino.cc/en/Tutorial/JoystickMouseControl (아두이노공식홈페이지)

조이스틱 마우스 예제인 "JoystickMouseControl" 설명이 잘 나와 있습니다. 사실 조이스틱으로 직접 제어하는 코딩을 만들어 보긴 했는데 위 사전학습의 예제가 너무 완벽해서 제가 만든 방식을 포기하게 되었네요.

[조이스틱 핵심 코딩] - 출처 : https://www.arduino.cc/en/Tutorial/JoystickMouseControl (코딩 일부분)

int readAxis(int Axis_Val) { 
  int reading = analogRead(Axis_Val); //해당 축핀의 아날로그 값을 읽음
  reading = map(reading, 0, 1023, 0, 12); //읽은 아날로그 신호를 0~12 사이의 값으로 변환
  int distance = reading - 6; //축값은 0~12인데 중심값이 6을 기준으로 +방향과 -방향값을 갖음
  if (abs(distance) < 3) { //+방향, -방향값이 3이하면 마우스 이동을 안하기 위해 0으로 초기화
    distance = 0;
  }
  return distance; //해당 축의 마우스 이동값을 반환
}

위 코딩에서 조이스틱이 특정 축(Axis_Val)의 기준으로 이동할 경우 0~1023일때 0~12값으로 변환하면 조이스틱의 움직임 값은 중심은 512가 6이 됩니다. 6을 기준으로 +방향과 -방향으로 나뉘게 됩니다. 중심값 6을 기준으로 얼마만큼 조이스틱이 움직였는가에 따라서 그 움직임을 마우스를 움직이게 합니다. 이때 움직임 값이 3이상 조이스틱이 움직여야지 움직임으로 인정을 하게 됩니다.

아래의 그림에서 노란색 원 모양의 영역이 조이스틱의 움직임을 불인정 구간이 됩니다. 조이스틱의 움직임을 인정하는 영역이 초록색이 됩니다.

왜! 이러헥 튜토리얼 예제에서는 표현했을까요. 실제 조이스틱은 전류를 측정하면 정확히 중심축(x,y)이 (512,512)가 되지 않습니다. 그래서 오차 중심축 값이 발생합니다. 그래서 오차의 영역이 되는 위의 원 영역의 부분은 움직임으로 판정을 내리지 않게 되면 오차값에 의한 움직임이 발생하지 않습니다. 그리고 튜토리얼에서는 0~12로 숫자의 범위를 최대한 줄였고 움직임 판정 받을 수 있는 영역도 6에서 3인 불인정이기 때문에 나머지 3의 영역만 인정을 받게 됩니다. 즉, 조이스틱의 크게 움직여야만 그 움직임을 인정받을 수 있게 됩니다. 각 1의 영역도 아날로그 신호값을 기준으로 85.25정도의 신호값을 1로 하기 때문에 오차가 발생하더라고 그렇게 크게 조이스틱 움직이에 영향을 주지 않습니다.

위 공식홈페이지에서 조이스틱 조정으로 측정되는 x,y축 값은 이보다 훌륭한 코딩은 없다고 생각되네요. 제가 만들어서 실험한 코딩은 위와 좀 비슷하지만 위 튜토리얼 코딩이 너무 훌륭해서 위 함수을 인용해서 실험하게 되었습니다.

2. 아두이노 조이스틱 마우스 회로도

• 준비물 : 조이스틱 1개, 스위치버턴 1개, LED 1개, 저항 220옴 1개, 아두이노 마이크로
• 내용 : 조이스틱 xAxis, yAxis축은 A0, A1 핀에 연결하고 swPin은 3번에 연결하시오. 인터럽트스위치버턴은 2번에 연결하고 LED 4번에 연결하면 됩니다.

조금 선 연결이 복잡해 보일 수 있는데 위의 내용부분의 핀 연결만 제대로 하시면 나머지 Vcc, Gnd 핀이기 때문에 어렵지 않을꺼에요.

3. 코딩

• 출처 : https://www.arduino.cc/en/Tutorial/JoystickMouseControl (아두이노공식홈페이지)
• 참조 예제 : "JoystickMouseControl" 예제 소스

위 사이트에 가시면 "JoystickMouseControl" 예제에 대해서 설명이 나와 있습니다. 한번 읽어주시기 바랍니다.

[JoystickMouseControl 소스 인용] - 출처 : https://www.arduino.cc/en/Tutorial/JoystickMouseControl (아두이노공식홈페이지)

#include <Mouse.h>

const byte interruptPin = 2;
boolean state = true;

const byte xAxis = A0;         //X axis
const byte yAxis = A1;         //Y axis
const byte mouseButton = 3;  //LEFT BUTTON
const int ledPin = 4;         // Mouse control LED 

void setup() {
  pinMode(ledPin, OUTPUT);
  pinMode(mouseButton, INPUT_PULLUP);       
  pinMode(interruptPin, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(interruptPin), exchange, FALLING);  //인터럽트 발생 시 호출
  
  Mouse.begin();
}

void loop() {
  
  if(state==false){ //인터럽트스위치 버턴에 의해서 열림/닫힘
    int Axis_X = readAxis(xAxis); //x축 조이스틱 이동값
    int Axis_Y = readAxis(yAxis); //y축 조이스틱 이동값
        
    Mouse.move(Axis_X, Axis_Y, 0); //마우스 이동

    if (digitalRead(mouseButton) == LOW) { //마우스 스위치가 눌러졌는가
      if (!Mouse.isPressed(MOUSE_LEFT)) Mouse.press(MOUSE_LEFT);      
    }
    else if(Mouse.isPressed(MOUSE_LEFT) == 1){ //MOUSE_LEFT 상태인지 확인
        Mouse.release(MOUSE_LEFT);
    }
    delay(10);
  }
  
}

int readAxis(int Axis_Val) { 
  int reading = analogRead(Axis_Val); //해당 축핀의 아날로그 값을 읽음
  reading = map(reading, 0, 1023, 0, 12); //읽은 아날로그 신호를 0~12 사이의 값으로 변환
  int distance = reading - 6; //축값은 0~12인데 중심값이 6을 기준으로 +방향과 -방향값을 갖음
  if (abs(distance) < 3) { //+방향, -방향값이 3이하면 마우스 이동을 안하기 위해 0으로 초기화
    distance = 0;
  }
  return distance; //해당 축의 마우스 이동값을 반환
}

void exchange() { //인터럽트스위치버턴  이벤트
 state=!state;
 digitalWrite(ledPin, !state);
}

위 소스는 "JoystickMouseControl" 예제를 기반의 코딩입니다. 제가 코딩한 것이 아니라 아두이노 공식홈페이지의 소스를 기반으로 했기 때문에 인용 코딩으로 보시면 됩니다. 인용 부분은 readAxis(int Axis_Val) 함수입니다.

4. 결과

우선 웹문서에 켄버스에 영역을 지정하고 그 영역에 마우스가 움직여서 특정 위치를 마우스 왼쪽버턴을 클릭하게 클릭된 위치에 마우스 좌표를 출력하는 html를 만들었습니다. 자바스크립트로 만들었는데 이건 여러분들이 만드실 필요 없습니다. 동영상 촬영을 위한 체크용으로 간단히 만들어서 조이스틱 마우스를 움직임과 클릭 이벤트가 정상적으로 수행되는지 보기 위한 예제입니다.

그리고, 영상을 보시면 처음에 파란스위치 버턴을 클릭하면 초록색 불이 들어오는 것을 보실 수 있을 꺼에요. 인터럽트 스위치 버턴을 클릭 했을 때 초록색 LED에 불이 들어오고 이 상태는 조이스틱마우스를 제어할 수 있는 열림상태가 된다는 의미이고 초록색 불이 꺼져있으면 조이스틱마우스가 아무리 움직여도 PC 모니터에 움직임이 표시되지 않는 잠금상태가 된다고 생각하시면 됩니다.

화살표로 표시된 스위치버턴(인터럽트스위치)은 조이스틱마우스 사용을 제어하는 안정장치 버턴입니다. 열림/닫힘으로 조이스틱마우스를 사용을 결정하게 됩니다.

마우스 이동과 클릭 이벤트가 정상적으로 수행되는 것을 아래 동영상으로 확인하실 수 있을 꺼에요

마무리

제가 직접 자작한 코딩으로 보여주면 좋은데 튜토리얼 조이스틱 움직임 readAxis()함수 너무 훌륭해서 인용한 실험이 되고 말았네요. 키보드 였다면 간단히 직선적 움직임으로 제어하면 코딩이 쉽지만 마우스를 제어하기 때문에 곡선적 움직임을 제어하기 위해서는 인용한 저 함수가 딱인 것 같네요

아무튼 해당 예제를 기반으로 실험을 했지만 조이스틱마우스의 조정과 클릭 이벤트가 정상적으로 결과를 얻을 수 있었네요. 다음 실험을 조이스틱키보드로 해서 특정 게임을 직접 조정하는 실험을 해볼까 생각중이네요. 아직 어떤 게임을 아두이노 조이스틱으로 조정할지는 결정을 못했고 며칠 일이 생겨서 잠시 post 며칠 미루어 질 것 같네요.

[아두이노]아두이노 매크로 키보드 제어

• 온라인 가상시뮬레이터 : https://www.tinkercad.com

지난 시간까지 해서 아두이노 기본 키보드/마우스 동작 명령을 실험을 해보았습니다. 오늘은 아두이노 IDE의 USB 예제에서 "KeyboardReprogram" 소스가 있는데 매크로 키보드 제어 예제로 딱 좋을 것 같아서 소개를 하도록 하겠습니다. 아두이노를 이용하여 PC에서 수행 할 명령을 기록해 놓았다가 기록 된 순서대로 명령을 내릴 수 있습니다. 이 원리를 이용하면 상상력에 따라 다양한 오토 매크로 프로그램을 만들 수 있습니다.

오늘 실험 할 내용을 "KeyboardReprogram" 예제는 동작은 현재 사용되는 보드에 새로운 프로그램을 스스로 업로드하는 시키는 예제입니다. 이 예제를 약간 변형시켜서 아두이노 마이크로에서 아두이노우노에 프로그램을 매크로를 통해서 이식하는 실험을 해보도록 하겠습니다.

아두이노 마이크로에서 매크로 키보드를 이용하여 아두이노우노에 프로그램을 이식 시키는 실험입니다.

1. 아두이노 매크로 키보드 회로도

• 준비물 : 스위치버턴 3개, LED 2개, 저항 220옴 2개, 아두이노 마이크로, 아두이노우노
• 내용 : 스위치버턴을 아두이노 마이크로 2,3,4번핀에 순서대로 연결하고 LED은 11, 12번에 연결하시오

아두이노 마이크로 2(인터럽트핀), 3(A코딩매크로스위치), 4(B코딩매크로스위치) 번 핀을 사용합니다.
아두이노우노 9(RedLED핀), 10(GreeenLED핀) 번 핀을 사용합니다.

2. 코딩

• 사전학습 참고 : http://www.arduino.cc/en/Tutorial/KeyboardReprogram (아두이노공식홈페이지)
• 참조 예제 : "KeyboardReprogram" 예제 소스

위 사이트에 가시면 "KeyboardReprogram" 예제에 대해서 설명이 나와 있습니다. 이 예제는 간단히 설명을 하면 스위치 버턴을 누르면 아두이노 IDE 창에서 새로운 창을 열고 거기에 특정 아두이노 소스를 코딩하고 코딩된 명령을 현재 보드에 새롭게 업로드하게 됩니다. 즉, 현재 아두이노보드에 인식된 프로그렘에서 다시 새로운 프로그램이 이식되도록 하는 명령을 내린다고 이해하시면 됩니다. 한번 위 사이트에 가셔서 어떻게 코딩되어 있는지 살펴보시기 바랍니다.

본격적으로, "KeyboardReprogram" 예제 소스를 기반으로 설명합니다. 전체소스는 위 공식홈페이지에 가셔서 예제를 보시기 바랍니다. 좋은 예제여서 새롭게 뭘 만들기 보다는 이 예제로 자세히 설명하는 위주로 우선 이야기 하겠습니다.

"KeyboardReprogram" 예제 소스를 보면아두이노에서 새로운 프로그램을 이식하는 매크로 코딩을 하면 다음과 같습니다.

• 아두이노 새창 띄우기
• 아두이노 새창에 코딩 지우기
• 아두이노 매크로 이식 코딩
• 자동 포맷
• 업로드(추가 저장하기)

1) 아두이노 IDE 새창 띄우기

현재 아두이노 IDE 창이 있다면 아래 명령을 수행하면 새로운 아두이노 IDE 편집창이 뜹니다.

[Ctrl+n(새창)]

  Keyboard.press(KEY_LEFT_CTRL);
  Keyboard.press('n');
  delay(100);
  Keyboard.releaseAll();  
  delay(1000);

2) 아두이노 새창에 코딩 지우기

새로운 창에는 기본 아두이노 코딩이 되어 있습니다. 이 코딩은 지우셔야 합니다. 지우기 위해서 코딩 전체 영역을 지정하기 위해서 "Ctrl+a"키를 누르면 새로운 창에서 전체 영역을 지정합니다. 그리고 나서 KEY_BACKSPACE 키를 누르면 전체 지정된 영역은 삭제 됩니다. 이 과정을 코딩으로 표현하면 아래와 같습니다.

[Ctrl+a 키 동작(창안 전체 영역 지정)]

  Keyboard.press(KEY_LEFT_CTRL);
  Keyboard.press('a');
  delay(500);
  Keyboard.releaseAll();

[지우기]

  Keyboard.write(KEY_BACKSPACE);
  delay(500);

3) 아두이노 매크로 이식 코딩

간단한 프로그램을 이식하는 예제로는 blink만한게 없죠. 그 예제로 하번 코딩해 볼까요.

[blink소스]

void setup(){
  pinMode(10, OUTPUT);
}
void loop(){
  digitalWrite(10, HIGH);
  delay(1000);
  digitalWrite(10, LOW);
  delay(1000);
}

blink 코딩 소스를 아두이노 이식 시키는 매크로 코딩을 하면 아래 와 같습니다.

Keyboard.println("void setup() {");
Keyboard.println("pinMode(10, OUTPUT);");
Keyboard.println("}");
Keyboard.println();
Keyboard.println("void loop() {");
Keyboard.println("digitalWrite(10, HIGH);");
Keyboard.print("delay(1000);");
Keyboard.println("digitalWrite(10, LOW);");
Keyboard.print("delay(1000);");
Keyboard.println("}");

어렵지 않죠. 아두이노 IDE 편집창에서 실제 키보드로 치는 것처럼 위 코딩을 치면 됩니다.

4) 자동 포맷

[Ctral+t(자동포맷)]

Keyboard.press(KEY_LEFT_CTRL);
Keyboard.press('t');
delay(100);
Keyboard.releaseAll();
delay(3000);

5) 업로드(추가 저장하기)

아두이노 IDE에서 업로드 단축키를 누르면 저장창이 뜹니다. 이때 랜덤이름으로 KEY_RETURN키로 저장하고 계속 진행하게 한다면 아래와 같이 코딩하면 됩니다.

[Ctrl+u(업로드)]

Keyboard.press(KEY_LEFT_CTRL);
Keyboard.press('u');    
delay(100);
Keyboard.releaseAll();
delay(1000);

Keyboard.press(KEY_RETURN);
delay(100);
Keyboard.releaseAll();

만약, 저장하기를 안하고 계속 진행할려면 저장하기 창에서 KEY_ESC키를 누르시면 해당 창이 취소됩니다. 그리고 나서 계속 업로드가 진행이 이루어 집니다.

Keyboard.press(KEY_ESC);
delay(100);
Keyboard.releaseAll();

6) 아두이노 마이크로에서 아두이노 우노에 blink 코딩 업로드 시키기

위 "KeyboardReprogram" 예제 소스의 원리를 이해 하셨으면 약간 변형하여 아두이노 마이크로에서 아두이노 우노에 두개의 프로그램을 업로드 시키는 과정을 매크로 코딩으로 만들어 실험을 해봅시다. 이식 할 프로그램은 blink 예제 소스로 두가지 형태의 프로그램을 이식 하겠습니다.

• A 코딩 : Red LED를 1초 단위로 깜박이게 하기
• B 코딩 : Green LED를 1초 단위로 깜박이게 하기

기본 과정은 위에서 코딩 설명한 과정을 그대로 적용합니다.

• 아두이노 새창 띄우기
• 아두이노 새창에 코딩 지우기
• 아두이노 매크로 이식 코딩
• 자동 포맷
• 업로드 & 저장취소

여기서 새창에 매크로 이식 코딩을 A 상황과 B상황으로 코딩이 이루어지게 할 예정입니다. 즉, Pin_A, Pin_B 스위치를 클릭하면 A와 B blink 코딩이 아두이노우노에 업로드 되고 해당 9(Red), 10(Green) LED가 깜박이게 하기 위해서 매크로 이식 코딩을 외부 사용자 정의함수로 빼서 해당 핀값만 수정하여 코딩하도록 만들어 보았습니다.

기본 코딩 과정 설명은 위에서 설명을 했기 때문에 종합한 소스를 위 코딩한 내용을 기반으로 살펴보시기 바립니다.

#include "Keyboard.h"

const byte Pin_A = 3;
const byte Pin_B = 4;

const byte interruptPin = 2;
boolean state = true;

void setup() {
  pinMode(Pin_A, INPUT_PULLUP);
  pinMode(Pin_B, INPUT_PULLUP);
  pinMode(interruptPin, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(interruptPin), exchange, FALLING);

  Keyboard.begin();
}

void loop() {
  if (state == false) { //키보드 안전장치
    if (digitalRead(Pin_A) == LOW) { //A코딩 이식 명령
      delay(1000);
      programming(9); //제어핀은 9번으로 blink 코딩
      delay(5000);
    }
    if (digitalRead(Pin_B) == LOW) { //B코딩 이식 명령
      delay(1000);
      programming(10);      //제어핀은 10번으로 blink 코딩
      delay(5000);
    }
  }
}

//매크로 이식 코딩
void programming(int Pin_Val) {
  //Ctrl+N 새창 열기
  Keyboard.press(KEY_LEFT_CTRL);
  Keyboard.press('n');
  delay(100);
  Keyboard.releaseAll();
  delay(1000);
  
  //Ctrl+A 키 동작(코딩창 안의 전체 영역 지정)
  Keyboard.press(KEY_LEFT_CTRL);
  Keyboard.press('a');
  delay(500);
  Keyboard.releaseAll();

  //지우기
  Keyboard.write(KEY_BACKSPACE);
  delay(500);

  //이식 할 코딩
  Keyboard.println("void setup() {");
  Keyboard.print("pinMode(");
  Keyboard.print(Pin_Val);
  Keyboard.println(",OUTPUT);");
  Keyboard.println("}");
  Keyboard.println();
  Keyboard.println("void loop() {");
  Keyboard.print("digitalWrite(");
  Keyboard.print(Pin_Val);
  Keyboard.println(",HIGH);");
  Keyboard.print("delay(1000);");
  Keyboard.print("digitalWrite(");
  Keyboard.print(Pin_Val);
  Keyboard.println(",LOW);");
  Keyboard.print("delay(1000);");
  Keyboard.println("}");

  //자동포맷
  Keyboard.press(KEY_LEFT_CTRL);
  Keyboard.press('t');
  delay(100);
  Keyboard.releaseAll();
  delay(3000);
  
  //업로드
  Keyboard.press(KEY_LEFT_CTRL);
  Keyboard.press('u');
  delay(100);
  Keyboard.releaseAll();
 
  delay(500);
  Keyboard.press(KEY_ESC); //저장취소
  delay(100);
  Keyboard.releaseAll();
}
void exchange() {
  state = !state;
}

보시면 programming(9), programming(10)으로 해서 Pin값만 바꿔서 코딩을 하고 해당 코딩을 아두이노 우노에 이식하게 됩니다.

4. 결과

결과는 좀 복잡한 과정을 거칩니다. 왜냐면 위 코딩은 우선 아두이노 마이크로 이식합니다.

위와 같이 보드/포트를 지정하고 아두이노 마이크로에 이식을 먼저 한 다음에 아두이노우노에 프로그램을 이식하기 위해서는 아두이노 IDE 창에 보드/포트를 아두이노우노 보드에 맞춰서 미리 세팅을 해놔야 합니다.

1) A 코딩

A버턴을 누르면

자세히 보시면 핀 번호가 9번이 보일꺼에요.

2) B 코딩

B버턴을 누르면

자세히 보시면 핀 번호가 10번이 보일꺼에요.

3) 결과

A, B 버턴을 누르고 해당 매크로 코딩 이식과정을 PC 창에서 진행 되는 모습을 보시면 한줄로 쭉 코딩이 되어지네요. println()함수를 치면 다음라인으로 넘어 갈 줄 알았는데 다음 라인으로 커서가 넘어가지 않더군요.

억지로 한줄 끝날때마다

  Keyboard.press(KEY_RETURN);
  delay(100);
  Keyboard.releaseAll();

이 명령으로 커서를 강제로 넘길 수 있지만 그러면 코딩이 너무 길어지기 때문에 그리고 어짜피 가독성이 떨어지게 코딩 한다고 해서 이식이 안되는 것도 아니기 때문에 그냥 억지로 다음라인으로 넘기는 코딩은 하지 않았습니다.

그리고, 아두이노 IDE가 매번 클릭 할 때마다 새로운 창이 뜹니다. 이부분도 사실 이식이 끝나면 해당 코딩창을 "Ctrl+q"로 창 닫기를 누르면 되는데 이 부분도 생략했네요. 이 부분을 하려면 프로그램이 어느정도 정상적으로 이식과정이 끝났다는 것을 확인이 필요합니다. 그냥 대충 창 종료를 누르면 업로드 중간에 창이 닫히기 때문에 오류 발생을 줄이고 간단히 특정 동작을 실험하는게 목적이기 때문에 여러가지 문제 상황에 대해서 정교하게 코딩은 하지 않았습니다. 기본 의미 전달이 목적이기 때문입니다.단순히 아두이노 마이크로에서 아두이노우노에 새롭운 프로그램을 이식 시킬 수 있는지 보기 위한 실험이기 때문에 복잡한 코딩은 생략합니다.

아래 동영상에서 3개의 버턴 중 하나는 인터럽트 버턴으로 키보드 동작 명령에 에러가 발생할 때 중지할 수 있는 버턴으로 활용하고 나머지 2개의 버턴은 A코딩 이식과 B코딩 이식하는 과정의 매크로 명령을 수행합니다. Red LED가 1초 단위로 깜박이는 코딩과 Green LED가 1초 단위로 깜박이는 코딩인데 실제로 스위치 버턴을 누를 때 아두이노우노에 프로그램을 이식하는데 이식이 정상적으로 되었는지 어떤 LED가 깜박이는지 보시면 눈으로 확인 하실 수 있을꺼에요. PC랑 실제 스위치를 누르는 장면을 같이 담아야 하는데 폰이 구려서 같이 찍으면 PC 모니터의 진행 과정이 흐리게 나오기 때문에 그냥 LED의 변화의 모습으로 아두이노우노에 코딩이식이 이루어지는지 확인하실 수 있습니다.

마무리

아두이노 마이크로에서 아두이노우노에 프로그램을 이식시키는 과정을 실험 했습니다. 참고로, "KeyboardReprogram" 예제 소스는 자기 자신에 새로운 프로그램을 이식하는 예제입니다. 자기 자신의 보드에 프로그램을 이식 원리와 다른 보드에 프로그램을 이식시키는 원리를 이번 시간에 제대로 이해하셨으면 합니다.

자기 자신에 새로운 프로그램을 이식하는 경우는 어떤 특정한 프로그램을 아두이노 마이크로 업로드 했을 때 프로그램이 어떤 동작에 약간 오차값이나 보정이 필요할 경우 지금까지는 변수를 만들어 넣고 그 변수의 보정값을 저장하여 다음 동작을 수행했습니다. 매번 전원이 새롭게 공급할 때마다 이 과정을 반복합니다. 그런데 자기 자신에 새로운 프로그램을 이식할 수 있다면 처음 한번만 조정이 되고 그 값을 기준으로 새롭게 프로그램을 스스로 재이식할 수 있게 되면은 해당 아두이노보드는 스스로 진화하게 됩니다. 여기서 아두이노 IDE로 프로그램을 업로드 했지만 따로 컴파일과 이식하는 과정을 아두이노 IDE를 통하지 않고 직접 수행 할 수 있는 방법을 찾아 낸다면 직접 스스로 새로운 프로그램으로 업로드하여 아두이노가 스스로 업데이트 할 수 있게 되겠죠.

다른보드에 프로그램을 이식하는 경우는 새로운 보드에 원하는 형태로 프로그램을 자동으로 A보드는 A코딩을 B보드는 B코딩을 이식할 수 있게 됩니다. 학습할 수 있는 아두이노라면 학습을 통해서 원하는 방향으로 다른 보드에 프로그램을 이식시킬 수 있게 된다면 상상을 해보세요. 위 두 과정을 상상하면 약간 테미네이트 영화처럼 되지 않을가 싶네요. 기계가 다른 기계에 프로그램을 이식하는 것은 엄청난 것입니다.

아무튼 오늘은 매크로 코딩 이식과정을 실험했지만 꽤 중요하고 상상을 하기에 따라 엄청난 결과물을 만들어 낼 수도 있습니다. 한번 상상의 나래를 펼쳐서 자신의 상상력이 어디까지 바라볼 수 있는지 도전해 보세요.

[아두이노] 아두이노 마우스 제어

• 온라인 가상시뮬레이터 : https://www.tinkercad.com
• 참고 :
  [아두이노] 아두이노 키보드 제어
  https://www.arduino.cc/reference/ko/language/functions/usb/mouse/mousemove/ (아두이노공식홈페이지)

지난 시간에 아두이노 마이크로 보드로 키보드 제어를 해 보았습니다. 오늘은 마우스를 제어해보는 시간을 갖도록 하죠. 키보드와 마찬가지로 마우스도 몇개의 함수만 이해하시면 쉽게 아두이노를 이용해서 마우스의 동작을 수행할 수 있습니다.

이제 본격적으로 마우스 제어를 해볼까요.

1. 아두이노 키보드 제어

• 사전학습 참조 :https://www.arduino.cc/reference/ko/language/functions/usb/mouse/mousemove/ (아두이노공식홈페이지)

위 사전학습으로 읽고 오시면 됩니다. 사전학습 자료를 보시면 7개의 함수가 있는데 이 함수만 알면 마우스 제어를 마음대로 할 수 있습니다. 간단히 함수에 대해 살펴 볼까요.

• button : MOUSE_LEFT (default), MOUSE_RIGHT, MOUSE_MIDDLE
• 마우스 시작 : Mouse.begin()
• 마우스 클릭 : Mouse.click() or Mouse.click(button)
• 마우스 종료 : Mouse.end()
• 마우스 이동 : Mouse.move(xVal, yPos, wheel) - x축, 축, 스크롤 휠의 움직임 양
• 마우스 버턴 클릭 : Mouse.press() or Mouse.press(button)
• 마우스 버턴 해제 : Mouse.release() or Mouse.release(button)
• 현재 마우스가 눌러진 정보 반환 : Mouse.isPressed() or Mouse.isPressed(button)

함수도 그렇게 어렵지 않죠. 기본적으로 마우스 클릭과 마우스 이동에 관한 함수만 이해하시면 됩니다.

1) 마우스 이동 제어

마우스 이동 제어하는 방법은 다음과 같습니다.

[기본소스]

#include <Mouse.h>

void setup(){
  Mouse.begin();
}
void loop(){
  if(버턴누름){
    Mouse.move(x, y, 스크롤휠);
  }
}

위 소스가 기본 마우스 이동 동작입니다. 마우스로 위로 이동한다면 어떻게 코딩할까요.

if(digitalRead(Pin_Up) == LOW){ //위로
  Mouse.move(0, -1, 0);
}

참골, 위/아래, 좌/우로 움직임을 x,y값만 바꾸시면 되고, 위로 이동하는 위 명령문을 수정하여 코딩하시면 나머지 동작 명령을 수행할 수 있게 됩니다.

2) 마우스 클릭 제어

[기본소스]

#include <Mouse.h>

void setup(){
  Mouse.begin();
}

void loop(){ 
  if(버턴누름){
    Mouse.click();
  }
}

기본 보스를 보면 Mouse.click()함수는 디폴트로 MOUSE_LEFT 클릭이 됩니다. 특정 키를 누르고 싶다면 어떻게 코딩할까요.

Mouse.click(MOUSE_RIGHT);

어떤 느낌인지 아시겠지요.

• button : MOUSE_LEFT (default), MOUSE_RIGHT, MOUSE_MIDDLE

기본적으로 버턴은 위의 세가지 왼쪽, 오른쪽, 중앙 버턴으로 나뉘고 지정해주면 해당 버턴이 클릭됩니다. 지정하지 않으면 디폴트로 왼쪽 버턴을 클릭하신다고 보시면 됩니다.

추가로, Mouse.click()함수는 클릭 이벤트입니다. 다른 방식으로 표현하면은 다음과 같습니다.

void loop(){ 
  if(버턴누름){
    Mouse.press(MOUSE_LEFT);
    delay(100);
    Mouse.release(MOUSE_LEFT);
    delay(200);
  }
}

마우스 키를 누름과 해제로 마우스 클릭 이벤트를 만들어 냅니다. 이와 같은 방식은 사실 클릭함수만 있으면 되지 구지 이 함수로 표현을 하냐 하실분들이 있을거에요. 누름(press)과 해제(release) 함수는 사용되는 곳이 따로 있습니다. 가령, 웹페이지가 있으면 특정 영역을 복사하기 위해서 어떻게 하나요 마우슨 왼쪽을 누른 상태에서 드래그를 하고 복사할 위치에서 마우스 누른 상태를 해제합니다. 이렇게 마우스의 클릭이 아니라 일정시간 마우스의 누름이 필요할 때는 사용되는 함수입니다. 클릭으로 사용해도 되고 또는 특정한 누름 일정시간 동안 유지가 필요할 때도 사용됩니다.

  if(버턴누름){
    Mouse.press(MOUSE_LEFT);        
  }else if(버턴 해제 && Mouse.isPressed()==1){
    Mouse.release(MOUSE_LEFT);
  } 

버턴을 누르고 있는 동안은 마우스 왼쪽 버턴이 클릭된 상태가 되겠죠. 이방식은 계속 클릭 명령을 내리기 때문에 별로 좋지 않습니다. 한 상태를 계속 유지하고 클릭을 반복 명령을 내리게 하고 싶지 않다면 아래와 같이 변경해야 합니다.

 if(버턴누름){
    if( Mouse.isPressed()==0) Mouse.press(MOUSE_LEFT);      
  }else if(버턴 해제 && Mouse.isPressed()==1){
    Mouse.release(MOUSE_LEFT);
  } 

이런게 마우스 클릭 상태정보가 0이면 클릭상태가 아니기 때문에 마우스왼쪽 버턴을 클릭하고 클릭상태가 1이면 클릭되어 있으니깐 계속 그 상태를 유지되고 있으니 구지 다시 클릭명령을 내릴 필요가 없습니다.

3) 마우스 상태 정보 반환

Mouse.isPressed() or Mouse.isPressed(button) 함수로 현재 마우스 상태 정보를 읽어 올 수 있습니다. 만약에 마우스 왼쪽 버턴을 눌렀다면 왼쪽버턴을 누른 상태 정보를 반환해 오겠죠.

정확히 어떤 값을 갖는지 살펴볼까요.

if(digitalRead(버턴핀) == LOW){ //버턴클릭
  Mouse.press(MOUSE_LEFT);
  Serial.println(Mouse.isPressed());
  delay(100);
  Mouse.release(MOUSE_LEFT);
  Serial.println(Mouse.isPressed());
  delay(200);     
}

[결과]

1
0

이렇게 출력됩니다 마우스를 press() 클릭하면 isPressed()함수로 해당 클릭 상태 정보 1을 반환합니다. 그리고 다시 release()함수로 해제하니깐 isPressed()함수로 반환되는 값은 0이 됩니다.

마우스 상태 정보 반환하는 함수는 해당 마우스버턴을 현재 클릭 정보를 통해서 다른 동작 명령을 다른 동작을 수행하거나 락을 걸어주거나 어떤 조건을 만들어 주기위해서 사용합니다. 위의 마우스 클릭 처럼 버턴을 클릭했다면 클릭했을 때 상태정보가 1이면 다음 클릭에서도 그 상태를 유지하니깐 구지 두번 명령을 내릴 필요가 없게 표현이 가능합니다. 그리고 어떤 클릭된 상태가 되었을 때 그 상태를 해제하고 싶을 때 먼저 클릭이 되었는지 확인하는 목적으로 사용됩니다. 클릭도 안했는데 클릭해제를 수행할 필요는 없겠죠.

2. 아두이노 키보드 제어 회로도

• 준비물 : 스위치버턴 5개, 아두이노 마이크로
• 내용 : 스위치버턴을 아두이노 마이크로 2,3,4,5,6번핀에 순서대로 연결하시오.
• 참고 : [아두이노] 아두이노 키보드 제어 회로도

지난 시간의 회로도를 그대로 적용합니다.

3. 코딩

스위치 버턴은 5개 입니다. 실험에서 2번 핀은 인터럽트 핀으로 사용하여 안전장치를 마련하고 나머지 3,4,5,6번 핀은 마우스 위치를 조절하는 핀으로 사용하겠습니다. 아쉬운 점은 스위치 버턴이 더 없어서 마우스클릭 이벤트까지는 적용을 못하였네요. 인터럽트 핀을 마우스 클릭 이벤트로 사용하면 좋은데 혹시 모를 에러를 예방하는 차원으로 안전장치가 필요하기 때문에 마우스 클릭 이벤트는 실험하지 않겠습니다.

1) 키보드 안전장치

지난 시간의 소스를 그대로 가져 왔네요. 복습차원으로 다시 봐 주시기 바랍니다.
[기본소스]

const byte interruptPin = 2;
boolean state = true;

void setup() {   
  pinMode(interruptPin, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(interruptPin), exchange, FALLING);  
}
void loop(){
  if(state==false){
    
    키보드 명령;
    
    }
}
void exchange() {
 state=!state;
}

위 코딩의 설명은 지난 시간 post를 보시기 바랍니다.

2) 마우스 이동 실험

• Mouse.move(x, y, 휠) 함수로 마우스를 직접 움직이는 실험을 해 보겠습니다.

핀번호을 선언 합니다.

const byte Pin_Up = 3;
const byte Pin_Down = 4;
const byte Pin_Left = 5;
const byte Pin_Right = 6;

스위치 버턴 모두 내부풀업모드 방식을 사용하니깐 pinMode()은 다음과 같이 INPUT_PULLUP 모드로 선언 합니다.

 pinMode(Pin_Up, INPUT_PULLUP); 
 pinMode(Pin_Down, INPUT_PULLUP);
 pinMode(Pin_Left, INPUT_PULLUP);
 pinMode(Pin_Right, INPUT_PULLUP);

Pin_Up키 누름 이벤트 명령은 다음과 같습니다. 내부풀업모드로 초기상태가 HIGH 입니다. 그래서 스위치를 누르면 LOW로 바뀌게 되고 IF문이 참이 되어 키 누름과 해제 명령을 수행하게 됩니다.

 if(digitalRead(Pin_A) == LOW){
    Mouse.move(0, -1, 0);
 }

나머지 스위치 버턴도 위와 같이 동일하게 코딩하면 됩니다.

3) 종합소스

위 안전장치 코딩과 키 누름 코딩을 합쳐서 종합해 보면 아래와 같이 코딩을 할 수 있습니다.

#include <Mouse.h>

const byte Pin_Up = 3;
const byte Pin_Down = 4;
const byte Pin_Left = 5;
const byte Pin_Right = 6;

const byte interruptPin = 2;
boolean state = true;

void setup() {    
  pinMode(Pin_Up, INPUT_PULLUP); 
  pinMode(Pin_Down, INPUT_PULLUP);
  pinMode(Pin_Left, INPUT_PULLUP);
  pinMode(Pin_Right, INPUT_PULLUP);

  pinMode(interruptPin, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(interruptPin), exchange, FALLING);  

   Mouse.begin();
}

void loop() {
  if(state==true){
    if(digitalRead(Pin_Up) == LOW){ //위로
       Mouse.move(0, -1, 0);
    }else if(digitalRead(Pin_Down) == LOW){ //아래로
       Mouse.move(0, 1, 0);
    }
    if(digitalRead(Pin_Left) == LOW){ //왼쪽
       Mouse.move(-1, 0, 0);
    }else if(digitalRead(Pin_Right) == LOW){ //오른쪽
       Mouse.move(1, 0, 0);
    }   
  } 
}
void exchange() {
 state=!state;
}

스위치 버턴을 누름으로써 마우스의 해당 방향으로 움직이게 됩니다.

여기서, if문의 표현을 잘 봐주세요.

if문이 위/아래를 한쌍으로 묶었고 좌/우를 한쌍으로 묶었습니다. 왜 이렇게 했을까요. 바로 위를 누른 상태에서 아래를 누를 수 없고 좌를 누른 상태에서 우를 누를 수 없잖아요. 즉, 위/아래는 하나의 상태만 존재하고 좌/우는 하나의 상태만이 존재하기 때문에 위와 같이 IF 조건문으로 표현한 것이죠.

주의할점은, 4개의 상태를 if문으로 4개를 개별적으로 만들면 안됩니다.

예)

 if(digitalRead(Pin_Up) == LOW) {  }
 if(digitalRead(Pin_Down) == LOW) {  }

이렇게 코딩하면 안됩니다. 버턴을 동시에 누른다면 어떤 현상이 발생할까요. 두가지 상태를 모두 수행하기 때문에 어떤 의미로는 충돌에 가깝다고 보시면 됩니다. 그렇다고 해서 위 코딩이 동작하지 않는 것은 아닙니다. 의미상으로 코딩의 문제가 있는 것이죠. 어느시점에 오로지 딱 하나의 조건만이 있어야지 위/아래가 동시에 일어나는 것은 좀 문제가 있겠죠.

그리고, 위/아래의 하나의 상태와 좌/우의 하나의 상태는 동시에 일어날 수 있기 때문에 if문으로 분리해 줘야 합니다.

왜! 위에서 IF문을 저렇게 표현했는지에 대한 의미를 정확히 이해해 주세요.

이 코딩은 단지 동작을 테스트 할 목적의 코딩이기 때문에 복잡한 동작 명령은 생략합니다.

4. 결과

스위치버턴은 말풍선의 순서대로 해당 키보드 키명령을 가지고 있습니다. 해당 스위치 버턴을 해당 명령을 PC에서 수행합니다.

결과는 아래 동영상에서 확인하시면 됩니다.

영상을 보시면 처음 업로드 키를 눌러야 하는데 컴파일 키가 눌러졌네요. 이미 해당 코딩이 업로드 된 상태입니다. 업로드 부분부터 촬영을 하려고 하다 보니깐 실수가 발생했네요. 업로드가 이미 된 상태이다 보니깐 업로드 버턴이 아닌 컴파일 버턴을 누르고 영상을 계속 진행시켜 버렸네요. 재촬영하기 귀찮아서 그냥 올렸네요. 감안하시고 보세요. 참고로 한손에는 폰이 한손에는 마우스조정기가 있다 보니깐 대각선 움직임을 제대로 보여드리지 못했네요. 위/아래, 좌/우로만 움직였는데 실제로 조정하면 대각선으로도 움직입니다.

마무리

간단히 마우스 이동만 시켰네요. 키 누름 이벤트까지 3개를 만들고, 마우스 휠을 움직이는 명령까지 수행하게 했다면 완벽한 마우스가 완성되었겠죠. 약간 아쉬운 실험이 되었네요.

Mouse 라이브러리를 이용하니깐 Mouse.move()함수로 쉽게 PC 마우스를 움직일 수 있게 되었습니다. 이처럼 아두이노는 오픈소스로 많은 것들을 제공해주고 우리들은 제공된 라이브러리를 이용하여 쉽게 아두이노를 제어할 수 있습니다. 여러분들에게 필요한 것은 단지 뭘 만들고 싶은가의 상상만 필요할 뿐이죠.

여러분들은 지난시간에 배운 키보드 제어와 오늘 배운 마우스 제어를 통해 뭘 만들고 싶으신가요. 한번 상상의 나래를 펼쳐 보세요.

[아두이노] 아두이노 키보드 제어

• 온라인 가상시뮬레이터 : https://www.tinkercad.com

지난 시간에 아두이노 마이크로 보드를 간단히 테스트를 했으니 이제 본격적으로 키보드 제어를 실험해 봅시다. 아두이도 키보드/마우스 제어를 하기 위한 목적으로 아두이노 마이크로 보드를 구매 했습니다. 오늘은 키보드 제어에 대해서 이야기를 할까 합니다. 프로그램언어를 공부하신분들은 오토키보드, 오토마우스 프로그램을 한번쯤을 사용해 보셨을 꺼에요. 게임을 할 때 오토 매크로 프로그램으로 게임을 자동사냥에 이용을 해보셨던 분도 아마 있을 꺼에요. C언어에서 키관련 핸들러를 이용해서 오토매크로 프로그램을 만들 수 있습니다. 이걸 코딩하기 위해서는 좀 코딩하기도 힘들고 복잡합니다. 저도 예전에 학창시절에 한번 코딩해보고 이제는 코딩 기억도 안나는 그런 것들이 있었지 정도에 기억만 남았네요.

그런데 아두이노에서 키보드 제어를 무지 쉽게 할 수 있는 방법을 제공합니다. 키보드 라이브러리가 오픈소스로 제공되고 단지 여러분들은 함수 몇개만 알고 있으면 쉽게 키보드 제어를 할 수 있습니다. 키보드 제어 코딩이 쉽지 않는데 이렇게 비전공자들도 쉽게 제어할 수 있는 방법을 제공하니 진짜 아두이노는 못하는 것이 없는 만능 싱글보드라고 생각됩니다.

이제 본격적으로 키보드 제어를 해볼까요.

1. 아두이노 키보드 제어

• 사전학습 참조 :https://www.arduino.cc/reference/ko/language/functions/usb/keyboard/ (아두이노공식홈페이지)

위 사전학습으로 읽고 오시면 됩니다. 사전학습 자료를 보시면 8개의 함수가 있는데 이 함수만 알면 키보드 제어를 마음대로 할 수 있습니다. 간단히 함수에 대해 살펴 볼까요.

• 키보드 시작 : Keyboard.begin()
• 키보드 종료 : Keyboard.end()
• 키 누름 : Keyboard.press()
• 키 해제 : Keyboard.release()
• 키 전체 해제 : Keyboard.releaseAll()
• 키 문자열 출력 : Keyboard.print(), Keyboard.println() , Keyboard.write()

함수도 그렇게 어렵지 않죠. 기본적으로 3개의 함수만 알고 있으면 키보드 키를 마음대로 제어할 수 있습니다.

1) 키 제어

키보드의 키를 제어하는 방법을 살펴보도록 하죠.

[기본소스]

#include <Keyboard.h>

void setup(){
 Keyboard.begin();
}
void loop(){
  if(버턴누름){
    Keyboard.press('a'); //키 누름
    delay(100);
    Keyboard.releaseAll(); //키 해제
    delay(200);     
  }
}

Keyboard.press(KEY_LEFT_CTRL);
Keyboard.press('n');
delay(100);
Keyboard.releaseAll(); //키 해제

Keyboard.println("STEEMIT!");

const byte interruptPin = 2;
boolean state = true;

void setup() {   
  pinMode(interruptPin, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(interruptPin), exchange, FALLING);  
}
void loop(){
  if(state==false){
    
    키보드 명령;
    
    }
}
void exchange() {
 state=!state;
}

const byte Pin_A = 3;
const byte Pin_B = 4;
const byte Pin_Return = 5;
const byte Pin_Backspace = 6;
스위치 버턴 모두 내부풀업모드 방식을 사용하니깐 pinMode()은 다음과 같이 INPUT_PULLUP 모드로 선언 합니다.
pinMode(Pin_A, INPUT_PULLUP); 
pinMode(Pin_B, INPUT_PULLUP);
pinMode(Pin_Return, INPUT_PULLUP);
pinMode(Pin_Backspace, INPUT_PULLUP);

 if(digitalRead(Pin_A) == LOW){
    Keyboard.press('a');
    delay(100);
    Keyboard.releaseAll();
    delay(200);  
 }

#include <Keyboard.h>

const byte Pin_A = 3;
const byte Pin_B = 4;
const byte Pin_Return = 5;
const byte Pin_Backspace = 6;

const byte interruptPin = 2;
boolean state = true;

void setup() {  
  Serial.begin(9600);
  Keyboard.begin();
  pinMode(Pin_A, INPUT_PULLUP); 
  pinMode(Pin_B, INPUT_PULLUP);
  pinMode(Pin_Return, INPUT_PULLUP);
  pinMode(Pin_Backspace, INPUT_PULLUP);

  pinMode(interruptPin, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(interruptPin), exchange, FALLING);  
}

void loop() {
  if(state==false){
    if(digitalRead(Pin_A) == LOW){
      Keyboard.press('a');
      delay(100);
      Keyboard.releaseAll();
      delay(200);  
    }
    if(digitalRead(Pin_B) == LOW){
      Keyboard.press('b');
      delay(100);
      Keyboard.releaseAll();
      delay(200);  
    }
    if(digitalRead(Pin_Return) == LOW){
      Keyboard.press(KEY_RETURN);
      delay(100);
      Keyboard.releaseAll();
      delay(200);  
    }
    if(digitalRead(Pin_Backspace) == LOW){
      Keyboard.press(KEY_BACKSPACE);
      delay(100);
      Keyboard.releaseAll();
      delay(200);  
    }   
  }
}
void exchange() {
 state=!state;
}

[아두이노] 4-Digit 7-Segment Display 시계 리모콘 제어

• 온라인 가상시뮬레이터 : https://www.tinkercad.com
• 참조 :
  [아두이노] 리모콘(IRremote) 제어
  [아두이노] 4-Digit 7-Segment Display 가상시뮬레이터 실험
  [아두이노] 6-Digit 7-Segment Display 시계 리모콘 제어

지난 시간에 6-Digit 7-Segment Display 아두이노 시계에서 리모콘 시간 입력을 가상시뮬레이터로 실험을 하였습니다. 오늘은 다행히 IR Sensor(수신부) 부품을 찾아서 실제 리모콘으로 제어하는 실험을 할 수 있게 되었네요. 참고로 4-Digit 7-Segment Display 부품이라서 4개의 숫자 밖에 출력을 못합니다. 그래서 시/분을 리모콘으로 제어할 것인지 분/초를 제어할지 고민하다가 분/초를 리모콘으로 제어하고 제어된 결과가 정상적으로 동작하는지 살펴보는게 나을 것 같아서 분/초 시계를 만들어 보았습니다.

1. 4-Digit 7-Segment Display 회로도

• 준비물 : 4-Digit 7-Segment Display 1개, IR Sensor 1개, IR remote 1개, 아두이노우노
• 내용 : 7-Segment Display 부품의 핀 번호 순서에 맞게 아두이노우노에 연결하고, IR Sensor 핀을 2번핀에 연결하시오.

IR Sensor(수신부)는 핀 위치가 다를 수 있습니다. fritzing에 제공되는 핀위치에 따라 연결했기 때문에 연결하실 때 해당 수신부 부품이 어떤 부품이냐에 따라 주의해서 연결해 주세요.

아래 IR Sensor(수신부) 부품이면 핀 번호를 보시고 연결하시면 됩니다.

2. 코딩

• 사전학습 : [6-Digit 7-Segment Display 시계 리모콘 제어(아두이노)]https://steemit.com/kr-arduino/@codingman/6-digit-7-segment-display)
• 리모콘 키값 조회 공개회로도 :https://www.tinkercad.com/things/3FjkW4Qftm4

사전학습 post의 소개한 소스를 실제 코딩에도 그대로 적용됩니다. 사전학습 종합소스와 아래 수정 할 부분을 같이 보고 어느 부분을 수정되었는지 같이 보시면서 읽어주세요. 아니면 아래 수정한 종합소스를 보면서 수정한 부분의 위치가 어느 위치이고 수정됐는지 같이 보면서 이해하시기 바랍니다. 그 이유는 그냥 아래 수정 할 부분에 이부분을 수정합니다라고 이야기 하기 때문에 말하는 부분이 정확이 어느 부분인지 혼동할 수 있기 때문에 꼭 종합소스를 같이 봐주세요.

수정 할 부분은 리모콘 키값부분입니다.

사용할 버턴은 위 사진에서 보는 버턴들을 이용 합니다. 이 부분의 키값을 알려면 리모콘 키값 조회 공개회로도 보시고 맞게 코딩을 수정한 뒤에 키 값을 알아내고 그 키값을 아래와 같이 수정하변 됩니다.

#define STATE 16736925 // ch버턴
#define SELECT_TIME 16748655 // EQ버턴
#define TIME_UP 16754775 // +버턴
#define TIME_DOWN 16769055 // -버턴

다음으로 4-Digit 7-Segment Display 핀 번호에 대해서 변수 수정을 해야 합니다.

const byte segPin[8]={7,3,A3,A1,A0,6,A4,A2}; //사용핀{a,b,c,d,e,f,g,dp} 순서대로임
const byte digitPin[4] = {8,5,4,A5}; //segment 위치 핀

다음 수정부분은

     if(output==true){
       if(results.value==SELECT_TIME){
         selectVal++;
         if(selectVal==3)selectVal=0;
       }

이 부분으로 원래는 시/분/초 3개의 시간위치가 기존 소스에 있었지만 두개를 분/초를 이용하기 때문에 분/초 위치만 왔다 갔다 하여야 하기 때문에 다음과 같이 수정이 됩니다.

if(selectVal==2)selectVal=0;

만약, 시/분만 왔다 갔다 해야 한다면

if(selectVal==3)selectVal=1;

어떻게 변경해야 할지 아시겠지요.

나머지도 수정해야 하는데 그대로 뒀습니다. 그냥 둬도 동작에는 영향이 없습니다.

출력부분에서 4개의 숫자만 출력되기 때문에 다음 부분을 수정해야 합니다.

void loop() {
  IRremoteRead(); //리모콘 읽기

  if(output==false){ //시간 출력
    readTime = millis()/1000;
    if(millis()>=86400000){
       timer0_millis=0;
    }
    sec = readTime%60;
    min = (readTime/60)%60;
    hour = (readTime/(60*60))%24; 

    segOutput(3,sec%10,0); //sec 1의 자리
    segOutput(2,sec/10,0); //sec 10의 자리
    segOutput(1,min%10,1); //min 1의 자리
    segOutput(0,min/10,0); //min 10의 자리
 //  segOutput(1,hour%10,1); //hour 1의 자리
 //  segOutput(0,hour/10,0); //hour 10의 자리      
  }
  else{ //시간 조정     
    segOutput(3,clockVal[0]%10,0); //sec 1의 자리
    segOutput(2,clockVal[0]/10,0); //sec 10의 자리
    segOutput(1,clockVal[1]%10,1); //min 1의 자리
    segOutput(0,clockVal[1]/10,0); //min 10의 자리
//    segOutput(1,clockVal[2]%10,1); //hour 1의 자리
//    segOutput(0,clockVal[2]/10,0); //hour 10의 자리      
  }
}

분/초를 출력하기 때문에 시 부분을 주석 처리하시면 됩니다. 만약에 시/분을 출력하고 싶다면 초 부분을 주석처리하면 됩니다.

참고로,

** segOutput(segment display 위치,시간값,dp핀값)**

4개의 segment display으로 {0,1,2,3} 순서로대로 위치값을 갖기 때문에 출력 시간값의 위치는 정확히 지정해주시고 코딩해주세요.

수정한 부분을 종합 완성하면,

#include <IRremote.h>

#define STATE 16736925 // ch버턴
#define SELECT_TIME 16748655 // EQ버턴
#define TIME_UP 16754775 // +버턴
#define TIME_DOWN 16769055 // -버턴
  
const byte IRpin = 2;  
IRrecv irrecv(IRpin);
decode_results results;

//a,b,c,d,e,f,g 상태값
const byte segValue[10][7] = {
   {1,1,1,1,1,1,0}, //0
   {0,1,1,0,0,0,0}, //1
   {1,1,0,1,1,0,1}, //2
   {1,1,1,1,0,0,1}, //3
   {0,1,1,0,0,1,1}, //4
   {1,0,1,1,0,1,1}, //5
   {1,0,1,1,1,1,1}, //6
   {1,1,1,0,0,0,0}, //7
   {1,1,1,1,1,1,1}, //8
   {1,1,1,1,0,1,1}  //9  
};

const byte segPin[8]={7,3,A3,A1,A0,6,A4,A2}; //사용핀{a,b,c,d,e,f,g,dp} 순서대로임
const byte digitPin[4] = {8,5,4,A5}; //segment 위치 핀

boolean output = false;//시간 출력형식 지정
byte selectVal = 0;
int clockVal[3]={0,0,0};


extern volatile unsigned long timer0_millis; //타이머변수
unsigned long readTime; //현재타이머시간
int hour, min, sec;

void setup() {
  Serial.begin(9600);  
  irrecv.enableIRIn(); // 리모콘 시작
 
  for(int i=0;i<10;i++){
    pinMode(segPin[i], OUTPUT);
  }
  for(int j=0;j<6;j++){
    pinMode(digitPin[j], OUTPUT);    
    digitalWrite(digitPin[j], HIGH); 
  }  
}

void loop() {
  IRremoteRead(); //리모콘 읽기
   
  if(output==false){ //시간 출력
    readTime = millis()/1000;
    if(millis()>=86400000){
       timer0_millis=0;
    }
    sec = readTime%60;
    min = (readTime/60)%60;
    hour = (readTime/(60*60))%24; 

    segOutput(3,sec%10,0); //sec 1의 자리
    segOutput(2,sec/10,0); //sec 10의 자리
    segOutput(1,min%10,1); //min 1의 자리
    segOutput(0,min/10,0); //min 10의 자리
 //  segOutput(1,hour%10,1); //hour 1의 자리
 //  segOutput(0,hour/10,0); //hour 10의 자리      
  }
  else{ //시간 조정     
    segOutput(3,clockVal[0]%10,0); //sec 1의 자리
    segOutput(2,clockVal[0]/10,0); //sec 10의 자리
    segOutput(1,clockVal[1]%10,1); //min 1의 자리
    segOutput(0,clockVal[1]/10,0); //min 10의 자리
//    segOutput(1,clockVal[2]%10,1); //hour 1의 자리
//    segOutput(0,clockVal[2]/10,0); //hour 10의 자리      
  }
}

void IRremoteRead(){
   if (irrecv.decode(&results)) //리모콘 누른값이 없다면 패스
    {
     if(results.value==STATE){
       output=!output;       
       if(output==false){
         hour = clockVal[2];
         min = clockVal[1];
         sec = clockVal[0];
         timer0_millis = ((long)hour*3600+min*60+sec)*1000;         
       }
       else{
         selectVal=0;
         for(int i=0;i<3;i++){
           clockVal[i]=0;
         }         
       }       
     }
     
     if(output==true){
       if(results.value==SELECT_TIME){
         selectVal++;
         if(selectVal==2)selectVal=0;
       }
         
       if(results.value==TIME_UP)clockVal[selectVal]++;
       else if(results.value==TIME_DOWN) clockVal[selectVal]--;
       

       if(selectVal==2){                  
         if(clockVal[selectVal]==24)clockVal[selectVal]=0;
         else if(clockVal[selectVal]==-1)clockVal[selectVal]=23;
       }
       else{
         if(clockVal[selectVal]==60)clockVal[selectVal]=0;
         else if(clockVal[selectVal]==-1)clockVal[selectVal]=59;         
       }

     }
    //Serial.println(results.value); //key value
     irrecv.resume(); // 다음값
    }
}

//LED 초기화
void segClear(){ 
  for(int i=0;i<8;i++){
    digitalWrite(segPin[i], LOW);        
  }
}
//LED 출력
void segOutput(int d, int Number, int dp){ 
  segClear();
  digitalWrite(digitPin[d], LOW); 
  for(int i=0;i<7;i++){
     digitalWrite(segPin[i], segValue[Number][i]);        
  }
  digitalWrite(segPin[7], dp);
  delayMicroseconds(1000);
  digitalWrite(digitPin[d], HIGH); 
}

3. 결과

• CH => 시간입력 ON/OFF
• EQ => 시간 입력 제어 위치
• +/-=> 숫자 증감/감소

CH 버턴을 누르면 시간을 입력 할 준비 상태가 됩니다. +/- 바로 누르면 sec가 움직입니다. EQ를 누르면 min 위치로 이동하고 다시 +/-를 누르면 min이 움직입니다. 입력 할 시간 세팅이 끝나면 CH 버턴을 누르면 입력된 시간이 타이머변수에 세팅이 되고 그때부터 시간이 흘러가고 4-Digit 7-Segment Display에 현재 분/초를 출력하게 됩니다.

마무리

오늘은 Digit 7-Segment Display 부품에 분/초가 출력되는데 여기에 리모콘을 누르면 분/초를 조정할 수 있게 됩니다. 참고로 실험에서는 시 부분은 0시로 무조건 초기 세팅이 되고 분/초가 제어가 이루어지기 때문에 위 소스로만 제작한다면 약간 아두이노 시계라고 보기 어렵습니다. 수정하셔서 시/분으로 제작하시고 60초를 버리고 시/분을 입력하여 초는 무조건 0초부터 시작하게 수정하시면 진자 아두이노 시계 느낌으로 제작이 완료 됩니다. 이 부분은 위 코딩 수정부분을 보시면 어디를 수정하면 원하는 결과가 나올지는 찾을 수 있을거라 생각됩니다. 한번 수정해 보세요.

여기서 직접 리모콘까지 아두이노로 만들어 보았으면 좋은데 송신부 부품이 없어서 아깝게 아두이노 리모콘 제작은 못 보여드리네요. 혹시 관심이 있으시면 아두이노 리모콘 만들기를 구글 검색하시면 간단한 에제 소스를 보실 수 있으니깐 만들어 보실분들은 한번 도전해 보세요. 아두이노 리모콘을 만드시면 나중에 가정 전자제품의 리모콘의 키값을 아두이노로 IR Sensor(수신부)로 읽을 수 있으면 아두이노 리모콘에 그 키값을 저장했다가 실제 가정 전자제품을 직접 만든 아두이노 리모콘으로 제어할 수 있습니다. 여러개의 리모콘 값을 아두이노 리모콘으로 통합시키면 하나의 리모콘으로 모든 가전제품을 제어할 수 있게 되니깐 호기심이 있는 분들은 꼭 실험해 보세요.

[아두이노] 6-Digit 7-Segment Display 시계 리모콘 제어

• 온라인 가상시뮬레이터 : https://www.tinkercad.com
• 참조 :
  [아두이노] 리모콘(IRremote) 제어
  [아두이노] 4-Digit 7-Segment Display 가상시뮬레이터 실험
• 공개회로도 : https://www.tinkercad.com/things/i6uyRD2EEyd (아두이노 시계 리모콘 제어)
  https://www.tinkercad.com/things/3FjkW4Qftm4 (리모콘키값 조회)

6-Digit 7-Segment Display 지난 시간에 아두이노 시계를 제작하여 가상 실험을 하였습니다. 그런데 아두이노 시계의 초기값을 PC 시리얼모니터에서 시간을 입력하는게 좀 불편해 보여서 다른 외부 장치로 시간을 입력하는 방법이 없을까 고민하다가 무선으로 시간값을 입력하는 방법을 상상하다가 몇가지 상상한 방법 중에 리모콘으로 시간을 입력해볼까 하는 호기심이 생겨서 좋은 학습 자료가 될 것 같아서 리모콘으로 아두이노 시간값을 입력하는 실험하게 되었네요. 리모콘으로 시간을 입력하는데 그 입력된 시간을 리모콘이 누를때 숫자가 변경되고 그 값이 6-Digit 7-Segment Display 부품에 출력되게 해야 하는데 6개의 7-Segment Display을 각각 개별적으로 6개의 숫자를 갱신하게 할지 아니면 시/분/초 단위로 3개의 숫자로 리모콘으로 제어해서 3개의 숫자값을 출력해야 할지 아니면 다른 방법으로 시간 숫자를 제어할지 여러개를 고민하고 실험해 보았습니다. 그중 하나를 선택하여 post로 소개 합니다.

1. 6-Digit 7-Segment Display 회로도

• 준비물 : 7-Segment Display 6개, IR Sensor 1개, IR remote 1개, 아두이노우노
• 내용 : 7-Segment Display 부품의 핀 번호 순서에 맞게 아두이노우노에 연결하고, IR Sensor 핀을 2번핀에 연결하시오.

지난 시간의 회로도에서 스위치버턴핀으로 사용한 2번핀을 IR Sensor핀으로 사용했습니다. 수정 부분은 IR Sensor 핀만 변경해주시면 됩니다.

2. 코딩

• 사전학습 :
  [아두이노] 리모콘(IRremote) 제어
  [아두이노] 4-Digit 7-Segment Display 가상시뮬레이터 실험
• 리모콘 키값 조회 공개회로도 : https://www.tinkercad.com/things/3FjkW4Qftm4

리모콘 제어를 간단히 복습을 해 볼까요.

[IRemote]

• 선언 :

#include <IRremote.h>
 
int IRpin = 2;  // IR Sensor Pin
IRrecv irrecv(IRpin);
decode_results results;

• 초기세팅 : 리모콘 시작

void setup(){
  irrecv.enableIRIn(); // 리모콘 시작
}

• 리모콘 읽기 : results.value으로 리모콘이 읽은 키 값이 저장되어 있음

void loop(){
  if (irrecv.decode(&results)){ //리모콘 누른값이 없다면 패스
      //results.value 로 리모콘이 눌린 값이 들어 있음.
        
        irrecv.resume(); // 다음값
  }
}

몇달 전 post의 내용인데 오랫만의 리모콘을 아두이노 시계에 적용합니다. 참고로 IRremote 라이브러리 설치는 사전학습에 가시면 나와 있으니깐 보시고 설치한 다음 사용하세요. 혹시 위와 같이 코딩했는데 작동을 안하면 라이브러리를 확인하시고 설치하시면 됩니다.

1) 리모콘 키값 찾기

위 그림의 리모콘의 버턴 4개를 사용할 예정입니다.

• FUNC/STOP => 시간입력 ON/OFF
• ST/REPT => 시간 입력 제어 위치
• 세모 위/아래 => 숫자 증감/감소

가상시뮬레이터로 사전학습의 회로도와 키값 확인 소스를 누르시면 해당 results.value을 확인 할 수 있습니다.

위 코딩에서

Serial.println(results.value);

이렇게 해서 리모콘의 해당 키값을 시리얼모니터로 확인 한 다음 기록해 주세요.

#define STATE 16597183  //FUNC/STOP
#define SELECT_TIME 16609423 //ST/REPT
#define TIME_UP 16601263 //세모 UP
#define TIME_DOWN 16584943 //세모 DOWN

참고로, 실제로 실험하실 때는 리모콘 키값을 직접 누르시고 해당 키 값을 메모장에 기록했다가 위처럼 표현하시면 됩니다. 리모콘 종류에 따라 키 값이 다를 수 있음으로 꼭 사전에 키값을 확인하시고 코딩해 주세요.

2) 시간 입력 리모콘 제어

• FUNC/STOP => 시간입력 ON/OFF

시간을 입력받을지 결정해야 합니다. 상태변수를 하나 만들어서 아래와 같이 IF 조건문을 만들면 됩니다.

if (irrecv.decode(&results)) //리모콘 누른값이 없다면 패스
    {
     if(results.value==STATE){
           output=!output;
     }
}

FUNC/STOP 리모콘 버턴을 누르면 output가 true or false 교대로 상태값을 갖게 됩니다. output가 true면 시간 입력이고 false면 입력된 시간이 흘러가게 하는 코딩을 하겠습니다.

if(리모콘키값==STATE){
  output=!output; 
  if(output==false){
    timer0_millis 시간 설정;
  }
  else{
    시간 전 입력 초기화;    
  } 
}
if(output==true){        
   시간 입력;
}

코딩을 하면,

 if (irrecv.decode(&results)) //리모콘 누른값이 없다면 패스
    {
     if(results.value==STATE){ //시간 입력 결정
       output=!output;       
       if(output==false){  //리모콘으로 시/분/초 입력한 값을 타이머변수에 저장;
         hour = clockVal[2];
         min = clockVal[1];
         sec = clockVal[0];
         timer0_millis = ((long)hour*3600+min*60+sec)*1000;         
       }
       else{  //시간 입력 전 입력 변수을 초기화
         selectVal=0;
         for(int i=0;i<3;i++){
           clockVal[i]=0;
         }         
       }       
     }
     if(output==true){ //시간 입력 제어
        시간입력;        
     }       
     irrecv.resume(); // 다음값
    }
}

clockVal[3]은 hour, min, sec의 값을 저장하게 됩니다. 그리고 selectVal은 시/분/초의 위치를 나타냅니다.

if(results.value==SELECT_TIME){ //시/분/초 위치 선택
  selectVal++;
  if(selectVal==3)selectVal=0;
}

ST/REPT를 누를 때 시/분/초가 selectVal이 0이면 sec이고, 1이면 min, 2이면 hour를 가리킵니다. selectVal가 3이 되면 다시 0으로 초기화됩니다. 해당 리모콘의 키 버턴을 통해 시/분/초 위치값을 지정할 수 있게 됩니다.

이제 세모 UP/DOWN 버턴을 통해서 시간값을 증감/감소를 제어를 해 볼까요.

if(results.value==TIME_UP) clockVal[selectVal]++;  //시간값 증가
else if(results.value==TIME_DOWN) clockVal[selectVal]--;  //시간값 감소

"clockVal[selectVal]++" or "clockVal[selectVal]--"로 시/분/초 값을 증가/감소를 시키게 됩니다. 여기서, 시간은 24시, 분은 60분, 초는 60초가 max 값입니다. 그래서 증가할 때 숫자는 시간은 24시를 넘지 말아야 하고 분/초는 60을 넘지 말아야 합니다.

그 부분을 IF문으로 표현을 하면 다음과 같습니다.

if(selectVal==2){ //hour 일때              
  if(clockVal[selectVal]==24)clockVal[selectVal]=0;
  else if(clockVal[selectVal]==-1)clockVal[selectVal]=23;
}
else{ //min, sec 일때
  if(clockVal[selectVal]==60)clockVal[selectVal]=0;
  else if(clockVal[selectVal]==-1)clockVal[selectVal]=59;         
}

selectVal가 2이면 시간이니깐 IF문에서 24가 되면 clockVal[selectVal]으로 0으로 만들고 감소할 때 -1이 되면 23으로 만들어 주면 0~23시간 조절하면 됩니다

그리고 그외 0~1이면 분/초로 60이 max이니깐 IF문으로 60이면 clockVal[selectVal]으로 0으로 만들고 감소할 때 -1이 되면 59으로 만들어 주면 0~59분/초를 조절하면 됩니다

3) 출력

  if(output==false){ //시간 출력
    readTime = millis()/1000;
    if(millis()>=86400000){
       timer0_millis=0;
    }
    sec = readTime%60;
    min = (readTime/60)%60;
    hour = (readTime/(60*60))%24; 

    segOutput(5,sec%10,0); //sec 1의 자리
    segOutput(4,sec/10,0); //sec 10의 자리
    segOutput(3,min%10,1); //min 1의 자리
    segOutput(2,min/10,0); //min 10의 자리
    segOutput(1,hour%10,1); //hour 1의 자리
    segOutput(0,hour/10,0); //hour 10의 자리      
  }
  else{ //시간 조정     
    segOutput(5,clockVal[0]%10,0); //sec 1의 자리
    segOutput(4,clockVal[0]/10,0); //sec 10의 자리
    segOutput(3,clockVal[1]%10,1); //min 1의 자리
    segOutput(2,clockVal[1]/10,0); //min 10의 자리
    segOutput(1,clockVal[2]%10,1); //hour 1의 자리
    segOutput(0,clockVal[2]/10,0); //hour 10의 자리      
  }

output가 false이면 시간을 출력하니깐 타이머변수를 세팅하면 millis()함수 현재 시간을 구하여 출력하면 됩니다. 지난시간의 출력 부분하고 같기 때문에 그대로 적용합니다. 하지만 시간을 입력할 때도 6-Digit 7-Segment Display 출력해야 하기 때문에 output가 true일때는 입력상황이니깐 그 입력에 대한 출력부분도 코딩해야 합니다. 입력시간은 clockVal[3] 배열변수에 저장되기 때문에 10의 자리와 1의 자리를 쪼개서 각 숫자를 해당 위치에 맞게 출력시키면 됩니다.

위의 표현한 코딩을 지난시간의 아두이노 시계에 합쳐 보도록 하겠습니다.

4) 종합 소스

#include <IRremote.h>

#define STATE 16597183
#define SELECT_TIME 16609423
#define TIME_UP 16601263
#define TIME_DOWN 16584943
  
const byte IRpin = 2;  
IRrecv irrecv(IRpin);
decode_results results;


//a,b,c,d,e,f,g 상태값
byte segValue[10][7] = {
   {1,1,1,1,1,1,0}, //0
   {0,1,1,0,0,0,0}, //1
   {1,1,0,1,1,0,1}, //2
   {1,1,1,1,0,0,1}, //3
   {0,1,1,0,0,1,1}, //4
   {1,0,1,1,0,1,1}, //5
   {1,0,1,1,1,1,1}, //6
   {1,1,1,0,0,0,0}, //7
   {1,1,1,1,1,1,1}, //8
   {1,1,1,1,0,1,1}  //9  
};

const byte segPin[8]={3,4,5,6,7,8,9,10}; //사용핀{a,b,c,d,e,f,g,dp} 순서대로임
const byte digitPin[6] = {A0,A1,A2,A3,A4,A5}; //segment 위치 핀

boolean output = false;//시간 출력형식 지정
byte selectVal = 0;
int clockVal[3]={0,0,0};

extern volatile unsigned long timer0_millis; //타이머변수
unsigned long readTime; //현재타이머시간
int hour, min, sec;


void setup() {
  Serial.begin(9600);  
  irrecv.enableIRIn(); // 리모콘 시작
 
  for(int i=0;i<10;i++){
    pinMode(segPin[i], OUTPUT);
  }
  for(int j=0;j<6;j++){
    pinMode(digitPin[j], OUTPUT);    
    digitalWrite(digitPin[j], HIGH); 
  }  
}

void loop() {
  IRremoteRead(); //리모콘 읽기
   
  if(output==false){ //시간 출력
    readTime = millis()/1000;
    if(millis()>=86400000){
         timer0_millis=0;
    }
    sec = readTime%60;
    min = (readTime/60)%60;
    hour = (readTime/(60*60))%24; 

    segOutput(5,sec%10,0); //sec 1의 자리
    segOutput(4,sec/10,0); //sec 10의 자리
    segOutput(3,min%10,1); //min 1의 자리
    segOutput(2,min/10,0); //min 10의 자리
    segOutput(1,hour%10,1); //hour 1의 자리
    segOutput(0,hour/10,0); //hour 10의 자리      
  }
  else{ //시간 조정     
    segOutput(5,clockVal[0]%10,0); //sec 1의 자리
    segOutput(4,clockVal[0]/10,0); //sec 10의 자리
    segOutput(3,clockVal[1]%10,1); //min 1의 자리
    segOutput(2,clockVal[1]/10,0); //min 10의 자리
    segOutput(1,clockVal[2]%10,1); //hour 1의 자리
    segOutput(0,clockVal[2]/10,0); //hour 10의 자리      
  }
}

void IRremoteRead(){
   if (irrecv.decode(&results)) //리모콘 누른값이 없다면 패스
    {
     if(results.value==STATE){ //시간 입력 결정
       output=!output;       
       if(output==false){ //리모콘으로 시/분/초 입력한 값을 타이머변수에 저장;
         hour = clockVal[2];
         min = clockVal[1];
         sec = clockVal[0];
         timer0_millis = ((long)hour*3600+min*60+sec)*1000;         
       }
       else{  //시간 입력 전 입력 변수을 초기화
         selectVal=0;
         for(int i=0;i<3;i++){
           clockVal[i]=0;
         }         
       }       
     }
     
     if(output==true){ //시간 입력 제어
       if(results.value==SELECT_TIME){ //시/분/초 위치 선택
         selectVal++;
         if(selectVal==3)selectVal=0;
       }
             
       if(results.value==TIME_UP)clockVal[selectVal]++; //시간값 증가
       else if(results.value==TIME_DOWN) clockVal[selectVal]--; //시간값 감소
 
       if(selectVal==2){ //hour 일때                 
         if(clockVal[selectVal]==24)clockVal[selectVal]=0;
         else if(clockVal[selectVal]==-1)clockVal[selectVal]=23;
       }
       else{ //min, sec 일때
         if(clockVal[selectVal]==60)clockVal[selectVal]=0;
         else if(clockVal[selectVal]==-1)clockVal[selectVal]=59;         
       }

     }   
     irrecv.resume(); // 다음값
    }
}

//LED 초기화
void segClear(){ 
  for(int i=0;i<8;i++){
    digitalWrite(segPin[i], LOW);        
  }
}
//LED 출력
void segOutput(int d, int Number, int dp){ 
  segClear();
  digitalWrite(digitPin[d], LOW); 
  for(int i=0;i<7;i++){
     digitalWrite(segPin[i], segValue[Number][i]);        
  }
  digitalWrite(segPin[7], dp);
  delayMicroseconds(1000);
  digitalWrite(digitPin[d], HIGH); 
}

지난시간의 아두이노 시계 소스를 이해 하셔야 오늘 리모콘 제어 부분을 이해할 수 있습니다. 단편적으로 설명하다 보니 아두이노시계 소스를 모른 상태에서 이해하시기가 좀 어려울 수 있겠네요. 사전학습을 미리 하시고 post를 읽어 주시기 바랍니다.

3. 결과

• FUNC/STOP => 시간입력 ON/OFF
• ST/REPT => 시간 입력 제어 위치
• 세모 위/아래 => 숫자 증감/감소

FUNC/STOP 버턴을 누르면 시간을 입력 할 준비 상태가 됩니다. 세모 위/아래 바로 누르면 sec가 움직입니다. ST/REPT를 누르면 min 위치로 이동하고 다시 세모 위/아래를 누르면 min이 움직입니다. 또, ST/REPT를 누르면 hour 위치로 이동하고 다시 세모 위/아래를 누르면 hour이 움직입니다. 입력 할 시간 세팅이 끝나면 FUNC/STOP 버턴을 누르면 입력된 시간이 타이머변수에 세팅이 되고 그때부터 시간이 흘러가고 6-Digit 7-Segment Display에 현재 시간을 출력하게 됩니다.

한번 위의 순서대로 시간을 입력해 보세요.

아래 동영상은 회로도가 복잡해서 가상시뮬레이터를 실행하면 지연 렉이 발생합니다. 그래서 1초가 움직이는데 좀 오래 걸리는데 이게 잘못된 코딩은 아니고 지연 렉이니깐 감안하시고 보세요.

마무리

오늘은 가상시뮬레이터에서 가상으로 아두이노 시계를 만들었는데 거기에다가 리모콘을 연결하여 시간 입력을 실험 하였습니다. 약간 시간을 입력하는 로직이 좀 복잡할 수 있습니다. 혹시 위 post 이해가 안가지면 if문 단위로 가상 데이터를 넣어서 어떤 동작을 하는지 체크하시면서 테스트 해보시기 바랍니다.

참고로, 실제 구현 한것도 post에 올릴려고 했는데 IR Sensor를 찾지 못해서 실제로는 구현을 못해 봤네요. 만약 찾게 되면은 4-Digit 7-Segment Display 부품에 IR Sensor를 연결하여 실제로 실험한 post를 올리겠습니다.

[아두이노] 4-Digit 7-Segment Display 가상시뮬레이터 실험

• 온라인 가상시뮬레이터 : https://www.tinkercad.com
• 공개회로도
  https://www.tinkercad.com/things/gfxPtEALiPU (숫자 카운터)
  https://www.tinkercad.com/things/cZMIpmyS1DC (시/분 아두이노시계)
  https://www.tinkercad.com/things/6IoV7yvXbE5 (6-Digit 7-Segment Display 아두이노 시계)

4-Digit 7-Segment Display 지난 시간에 실험했던 것을 가상시뮬레이터로 회로도을 만들어 보았습니다. 시계 회로도에서 추가로 6-Digit 7-Segment Display 형식으로 아두이노 시계를 만들어 보았으니깐 가상시뮬레이터로 한번 체험해보시고 수정할 코딩이 있으면 추가 코딩을 해보시기 바랍니다.

1. 4-Digit 7-Segment Display

1) 숫자 카운트 (0~9999)

• 준비물 : 7-Segment Display 4개, 아두이노우노
• 내용 : 7-Segment Display 부품의 핀 번호 순서에 맞게 아두이노우노에 연결하시오.

2-Digit 7-Segment Display 회로도에서 2개를 더 추가해서 4-Digit 7-Segment Display 회로도를 완성 했네요.

• 참조 : [아두이노] 4-Digit 7-Segment Display 제어

참조 링크 post에서 숫자 카운트 (0~9999) 소스를 실험하시면 됩니다. 주의할 점은 아두이노 핀 번호에 대한 변수지정은 수정해야 합니다.

const byte segPin[8]={7,3,A3,A1,A0,6,A4,A2}; //사용핀{a,b,c,d,e,f,g,dp} 순서대로임
const byte digitPin[4] = {8,5,4,A5}; //segment 위치 핀

이 부분을 아래와 같이 수정하시고 소스는 동일합니다.

const byte segPin[8]={2,3,4,5,6,7,8,9}; //사용핀{a,b,c,d,e,f,g,dp} 순서대로임
const byte digitPin[4] = {A0,A1,A2,A3}; //segment 위치 핀

결과

0.01초 단위로 카운트를 하는 결과입니다.

2) 시간 출력

• 준비물 : 7-Segment Display 4개, 스위치버턴 1개, 아두이노우노
• 내용 : 7-Segment Display 부품의 핀 번호 순서에 맞게 아두이노우노에 연결하고, 스위치 버턴은 2번핀에 연결하시오.

스위치 버턴이 추가 된 회로도 입니다. 지난시간의 실제 4-Digit 7-Segment Display 부품으로 생각하시면 됩니다.

• 참조 : [아두이노] 4-Digit 7-Segment Display 시계 만들기

참조 링크 post에서 아두이노 시계 소스를 실험하시면 됩니다. 여기에서 주의 할 점은 아두이노 핀 번호에 대한 변수지정입니다. 그 부분은 방금 했던 방식으로 그대로 변경하시면 됩니다.

const byte segPin[8]={7,3,A3,A1,A0,6,A4,A2}; //사용핀{a,b,c,d,e,f,g,dp} 순서대로임
const byte digitPin[4] = {8,5,4,A5}; //segment 위치 핀

이 부분을 아래와 같이 수정하시고 소스는 동일합니다.

const byte segPin[8]={2,3,4,5,6,7,8,9}; //사용핀{a,b,c,d,e,f,g,dp} 순서대로임
const byte digitPin[4] = {A0,A1,A2,A3}; //segment 위치 핀

결과

시리얼 모니터로 입력하면 시/분이 가상시뮬레이터의 7-Segment Display 부품에 출력됩니다. 참고로, 가상시뮬레이터가 회로도 복잡해서 실행 시 지연이 발생해서 1초 단위의 움직임이 발생하지 않습니다. "23:59:57"시간을 입력해서 3초 후 "00:00:00"이 되어야 하는데 움짤에 몇십초가 걸렸네요. 감안하시고 결과를 보시기 바랍니다. 그리고 스위치버턴을 누르면 12시 기준으로 시간 표시와 아니면 24시 기준으로 시간 표시로 변경할 수 있는 기능을 추가했습니다.

2. 6-Digit 7-Segment Display 회로도

• 준비물 : 7-Segment Display 6개, 스위치버턴 1개, 아두이노우노
• 내용 : 7-Segment Display 부품의 핀 번호 순서에 맞게 아두이노우노에 연결하고, 스위치 버턴은 2번핀에 연결하시오.

위에서 만든 회로도에서 2개의 7-Segment Display을 추가 연결했네요.

• 참조 : [아두이노] 4-Digit 7-Segment Display 시계 만들기

참조 링크 post에서 아두이노 시계 소스를 실험하시면 됩니다. 시/분 출력을 시/분/초까지 출력시키면 됩니다. 마무리 부분이니 이부분은 지난 시간의 소스를 가져와서 수정된 부분을 보도록 할까요.

[종합소스]

//a,b,c,d,e,f,g 상태값
byte segValue[10][7] = {
   {1,1,1,1,1,1,0}, //0
   {0,1,1,0,0,0,0}, //1
   {1,1,0,1,1,0,1}, //2
   {1,1,1,1,0,0,1}, //3
   {0,1,1,0,0,1,1}, //4
   {1,0,1,1,0,1,1}, //5
   {1,0,1,1,1,1,1}, //6
   {1,1,1,0,0,0,0}, //7
   {1,1,1,1,1,1,1}, //8
   {1,1,1,1,0,1,1}  //9  
};

const byte segPin[8]={3,4,5,6,7,8,9,10}; //사용핀{a,b,c,d,e,f,g,dp} 순서대로임
const byte digitPin[6] = {A0,A1,A2,A3,A4,A5}; //segment 위치 핀


const byte interruptPin = 2;//인터럽트핀

boolean state = false;//시간 출력형식 지정
extern volatile unsigned long timer0_millis; //타이머변수
unsigned long readTime; //현재타이머시간
int hour, min, sec;


void setup() {
  Serial.begin(9600);  
  
  pinMode(interruptPin, INPUT_PULLUP); 
  attachInterrupt(digitalPinToInterrupt(interruptPin), switchFn, FALLING);
  
  for(int i=0;i<10;i++){
    pinMode(segPin[i], OUTPUT);
  }
  for(int j=0;j<6;j++){
    pinMode(digitPin[j], OUTPUT);    
    digitalWrite(digitPin[j], HIGH); 
  }  
}

void loop() {   
  if(Serial.available()){
    String inString = Serial.readStringUntil('\n');    
    int index1 = inString.indexOf(':'); 
    int index2 = inString.indexOf(':',index1+1);   
    int index3 = inString.length();
    
    hour = inString.substring(0, index1).toInt();
    min = inString.substring(index1+1,index2).toInt();
    sec = inString.substring(index2+1,index3).toInt(); 
    
    timer0_millis = ((long)hour*3600+min*60+sec)*1000;   
  } 
  readTime = millis()/1000;
  if(millis()>=86400000){
     timer0_millis=0;
  }
  sec = readTime%60;
  min = (readTime/60)%60;
  hour = (readTime/(60*60))%24; 

  if(state==true){ //12시 or 24시 출력모드
    hour = hour%12;
  } 
  segOutput(5,sec%10,0); //sec 1의 자리
  segOutput(4,sec/10,0); //sec 10의 자리
  segOutput(3,min%10,1); //min 1의 자리
  segOutput(2,min/10,0); //min 10의 자리
  segOutput(1,hour%10,1); //hour 1의 자리
  segOutput(0,hour/10,0); //hour 10의 자리    
}

//12시 or 24시 출력 변경
void switchFn(){
  state=!state;
}

//LED 초기화
void segClear(){ 
  for(int i=0;i<8;i++){
    digitalWrite(segPin[i], LOW);        
  }
}
//LED 출력
void segOutput(int d, int Number, int dp){ 
  segClear();
  digitalWrite(digitPin[d], LOW); 
  for(int i=0;i<7;i++){
     digitalWrite(segPin[i], segValue[Number][i]);        
  }
  digitalWrite(segPin[7], dp);
  delayMicroseconds(1000);
  digitalWrite(digitPin[d], HIGH); 
}

결과

"23:59:57" 시간을 입력하지만 이 역시 회로도가 복잡하게 디자인 되어 지연 렉이 발생하네요. 3초가 꽤 길게 걸리네요. 코딩에 문제가 있는게 아니라 지연 렉이니깐 감안하시고 동영상을 보시기 바랍니다.

시계 결과가 너무 흐리게 나왔네요. 위에 링크 된 6-Digit 7-Segment Display 공개 회로도에 가셔서 테스트를 해 보시기 바랍니다.

마무리

오늘은 가상시뮬레이터로 3개의 회로도를 만들고 간단히 실험을 해 보았습니다. 실제로 제작해서 실험을 해보시는 것도 괜찮ㅅ브니다. 가상 시뮬레이터로 여러분들도 간접 체험을 할 수 있게 회로도를 개별적으로 만들어 놓았습니다. 위에 공개회로도를 링크 걸어놓은 곳에 가셔서 한번 테스트 해보세요. 그리고 따로 상상하는 부분이 있으면 가상시뮬레이터를 복사하셔서 직접 수정해 보세요.

[아두이노] 4-Digit 7-Segment Display 시계 만들기

• 온라인 가상시뮬레이터 : https://www.tinkercad.com
• 참고 :
  [아두이노] 4-Digit 7-Segment Display 제어
  [아두이노] 시간 millis() 함수로 시계 코딩

지난 시간에 4-Digit 7-Segment Display을 사용하는 방법을 실험 하였습니다. 오늘은 지난시간에 만든 회로도와 기본소스를 기반으로 아두이노 시계를 실제 만들어 보겠습니다.

1. 4-Digit 7-Segment Display 회로도

• 준비물 : 4-Digit 7-Segment Display 1개, 스위치버턴 1개, 아두이노우노
• 내용 : 4-Digit 7-Segment Display 부품의 핀 번호 순서에 맞게 아두이노우노에 연결하고, 스위치 버턴은 2번핀에 연결하시오.
• 참조 : [아두이노] 4-Digit 7-Segment Display 제어

지난 시간의 회로도와 동일합니다.

2. 시계 코딩

• 참조 : [아두이노] 시간 millis() 함수로 시계 코딩
  

시간을 참조 Post에 가셔서 사전 학습 해주세요.

1) 시간 구하기

시간은 시리얼통신으로 입력을 받을 경우를 가정해서 시간을 구해 볼까요.

if(Serial.available()){
  String inString = Serial.readStringUntil('\n');    
}

inString에 시간 문자열을 읽습니다.

int index1 = inString.indexOf(':'); 
int index2 = inString.indexOf(':',index1+1);   
int index3 = inString.length();
    
hour = inString.substring(0, index1).toInt();
min = inString.substring(index1+1,index2).toInt();
sec = inString.substring(index2+1,index3).toInt(); 

위와 같이 코딩해서 hour, min, sec 구하게 됩니다. 지난시간에 설명을 다했기 때문에 간단히 넘어 갑니다.

timer0_millis = ((long)hour*3600+min*60+sec)*1000;   

hour, min, sec 값을 초로 변환하여 timer0_millis 변수에 저장하면 타이머는 입력된 시간을 기준으로 돌아가게 됩니다. 즉, 입력된 시간에서 타이머 시간이 흐른다고 보시면 됩니다.

readTime = millis()/1000;

sec = readTime%60;
min = (readTime/60)%60;
hour = (readTime/(60*60))%24; 

readTime 변수에는 millis()함수에서 읽은 타이머 시간값을 1000으로 나눈 몫 값을 저장하기 때문에 입력된 시간을 기준으로 1초 단위로 값이 변화가 일어 나겠죠. 입력시간을 기준으로 흐르는 시간값을 hour, min, sec값으로 다시 구하면 현재 시간을 구할 수 있게 됩니다.

이 값을 4-Digit 7-Segment Display로 출력하면 실제 아두이노 시계가 완성 됩니다.

2) 시간 타이머리셋 지정

24시간을 기준으로 시간을 리셋 시킬 예정입니다. 그러면 어떻게 코딩해야 할까요.

if(millis()>=86400000){ //타이머 리셋
     timer0_millis=0;
}

if문으로 1day는 24시간이고 이 시간은 "60x60x24" 가 됩니다. 여기에 1초(1000)을 곱해주면 86400000의 타이머 시간값이 만들어 집니다. 이 시간이 되면 timer0_millis=0으로 리셋 시키면 24시간 단위로 타이머는 처음부터 다시 돌게 됩니다.

3) 인터럽트 스위치버턴 활용

지난시간에 인터럽트 스위치버턴을 추가했는데 그러면 이 스위치버턴을 그냥 두기가 아쉬워서 어떤 기능을 넣을까 고민하다가 시간 표시를 제어하는 스위치버턴으로 변경해 보았습니다.

void switchFn(){
  state=!state;
}

스위치 버턴이 눌러지면 state 변수가 반전이 일어나게 했습니다.

if(state==true){ //12시 or 24시 출력모드
  hour = hour%12;
}   

이렇게 수정했습니다. 현재 시간 hour를 12시 기준으로 출력할 것인지 24시 기준으로 출력할 건지를 스위치버턴으로 제어하는 기능을 추가 했네요.

4) 종합소스

이제 지난시간의 소스에다가 위 설계 코딩을 삽입하면 아래와 같이 완성 됩니다.

//a,b,c,d,e,f,g 상태값
const byte segValue[10][7] = {
   {1,1,1,1,1,1,0}, //0
   {0,1,1,0,0,0,0}, //1
   {1,1,0,1,1,0,1}, //2
   {1,1,1,1,0,0,1}, //3
   {0,1,1,0,0,1,1}, //4
   {1,0,1,1,0,1,1}, //5
   {1,0,1,1,1,1,1}, //6
   {1,1,1,0,0,0,0}, //7
   {1,1,1,1,1,1,1}, //8
   {1,1,1,1,0,1,1}  //9  
};

const byte segPin[8]={7,3,A3,A1,A0,6,A4,A2}; //사용핀{a,b,c,d,e,f,g,dp} 순서대로임
const byte digitPin[4] = {8,5,4,A5}; //segment 위치 핀

const byte interruptPin = 2;//인터럽트핀

boolean state = false;//시간 출력형식 지정
extern volatile unsigned long timer0_millis; //타이머변수
unsigned long readTime; //현재타이머시간
int hour, min, sec;

void setup() {
  Serial.begin(9600);  
  
  pinMode(interruptPin, INPUT_PULLUP); 
  attachInterrupt(digitalPinToInterrupt(interruptPin), switchFn, FALLING);
  
  for(int i=0;i<10;i++){
    pinMode(segPin[i], OUTPUT);
  }
  for(int j=0;j<4;j++){
    pinMode(digitPin[j], OUTPUT);    
    digitalWrite(digitPin[j], HIGH); 
  }  
}

void loop() {   
  if(Serial.available()){ //입력시간 읽기
    String inString = Serial.readStringUntil('\n');    
    int index1 = inString.indexOf(':'); 
    int index2 = inString.indexOf(':',index1+1);   
    int index3 = inString.length();
    
    hour = inString.substring(0, index1).toInt();
    min = inString.substring(index1+1,index2).toInt();
    sec = inString.substring(index2+1,index3).toInt(); 
    
    timer0_millis = ((long)hour*3600+min*60+sec)*1000;   //입력시간 초변환
  } 
    
  if(millis()>=86400000){ //타이머 리셋
     timer0_millis=0;
  }
  readTime = millis()/1000; //현재시간 읽기
  sec = readTime%60;
  min = (readTime/60)%60;
  hour = (readTime/(60*60))%24; 

  if(state==true){ //12시 or 24시 출력모드
    hour = hour%12;
  } 
  segOutput(3,min%10,0); //min 1의 자리
  segOutput(2,min/10,0); //min 10의 자리
  segOutput(1,hour%10,1); //hour 1의 자리
  segOutput(0,hour/10,0); //hour 10의 자리    
}

//12시 or 24시 출력 변경
void switchFn(){
  state=!state;
}

//LED 초기화
void segClear(){ 
  for(int i=0;i<8;i++){
    digitalWrite(segPin[i], LOW);        
  }
}
//LED 출력
void segOutput(int d, int Number, int dp){ 
  segClear();
  digitalWrite(digitPin[d], LOW); 
  for(int i=0;i<7;i++){
     digitalWrite(segPin[i], segValue[Number][i]);        
  }
  digitalWrite(segPin[7], dp);
  delayMicroseconds(1000);
  digitalWrite(digitPin[d], HIGH); 
}

3. 결과

1) 분/초 출력

숫자를 4개 뿐이 출력을 못하기 때문에 간단히 시간이 흐르는 것을 확인 할 수 있게 출력 숫자는 분/초로 세팅했습니다.

  segOutput(3,sec%10,0); //min 1의 자리
  segOutput(2,sec/10,0); //min 10의 자리
  segOutput(1,min%10,1); //min 1의 자리
  segOutput(0,min/10,0); //min 10의 자리    

입력은 정상적으로 시간 "23:59:50"을 입력할 때는 내부적으로 시간은 정확하게 흘러갑니다. 여기서, 출력은 분/초만 표시될 뿐이죠

분/초만 아래와 같이 출력되어 정상적으로 시간이 흘러가네요.

2) 시/분 출력

종합 소스에 시/분 코딩을 그대로 실험한 결과입니다. 출력은 시/분만 출력됩니다.

  segOutput(3,min%10,0); //min 1의 자리
  segOutput(2,min/10,0); //min 10의 자리
  segOutput(1,hour%10,1); //hour 1의 자리
  segOutput(0,hour/10,0); //hour 10의 자리    

입력은 시간 "23:59:10"을 입력했습니다.

결과는 아래의 동영상에 보시면 "23:59"만 출력됩니다. 내부적으로 초는 계속 흘러가고 있습니다. 인터럽트 스위치버턴을 누르면 12시 기준으로 시간을 표시되고 다시 누르면 23시 기준으로 시간이 표시 되는 실험 결과를 보실 수 있을 꺼에요. 그리고 24시가 되면은 "00:00"으로 리셋되는 것 까지 보실 수 있을 꺼에요.

마무리

4-Digit 7-Segment Display 부품 밖에 없어서 안타깝게 6자리 시간 표시를 못했네요. 그러다보니 분/초 아니면 시/분으로 표시할 수 밖에 없었고 결과 동영상으로는 표현의 한계가 있었네요.

개별 7-Segment가 2개 있으면 추가로 연결해서 표시 할 수 있었겠지만 한개뿐이라 연결을 포기 했습니다. 아무튼 이런식으로 아두이노 시계를 만들 수 있다는 것을 보여드리는 걸로 정리를 할까 합니다. Stepper Motor로 시계를 표시하고 싶은데 4-Digit 7-Segment Display가 post 주제에서 나중에 응용편으로 기회가 된다면 그때 보여드릴게요. 주제에 맞게 post를 하기 위해서 그 실험은 생략하도록 하겠습니다.

가상시뮬레이터에서 6개 7-Segment를 이용해서 확실히 시계를 만들어서 보여드릴까 고민 좀 해보겠습니다. 여러분들은 실제 제작을 안하더라고 가상시뮬레이터에서 동일한 실험이 체험할 수 있게 귀찮은 회로선 연결을 해야하지만 한번 생각해보고 다음 post으로 올릴지 결정할께요. 될 수 있으면 가상시뮬레이터로 한번 제작해서 보여드리는 방향으로 할께요.

[아두이노] 4-Digit 7-Segment Display 제어

• 온라인 가상시뮬레이터 : https://www.tinkercad.com
• 참고 :
  [아두이노] 7 Segment LED 제어
  [아두이노] 시간millis()함수로 시간 카운트
  [아두이노] 2-Digit 7-Segment Display

지난시간에 2-Digit 7-Segment Display(애노드형)을 가상시뮬레이터에서 실험 했었습니다. 오늘은 실제로 4-Digit 7-Segment Display로 숫자를 출력해보는 실험을 해보겠습니다. 4-Digit 7-Segment Display 부품은 캐소드형이고 지난시간에 일부 변수값과 상태값은 전부 반전된 형태로 표현해야 하기 때문에 회로도를 만들고나서 코딩을 할 때 혼동하지 말고 주의해서 코딩하시기 바랍니다.

1. 4-Digit 7-Segment Display(캐소드형)

4-Digit 7-Segment Display 부품은 아래 이미지와 같습니다. 대충 그렸는데 썩 마음에 들지 않네요.

내부 회로도를 살펴보면 지난 시간에 애노드형 2-Digit 7-Segment Display 회로도를 보셨을 꺼에요. 오늘은 실제 사용되는 4-Digit 7-Segment Display 부품은 캐소드형으로 아래와 같은 회로도로 구성되어 있습니다.

4개의 7-Segment가 a,b,c,d,e,f,g,dp 핀을 공유하고 제어는 D1, D2, D3, D4로 각 D핀을 개방함으로써 해당 7-Segment에 숫자나 문자를 출력하게 됩니다.

캐소드형이기 때문에 D1, D2, D3, D4 핀은 LOW가 될때 a,b,c,d,e,f,g,dp 핀이 HIGH일 때 해당 LED에 불이 들어오게 됩니다. 지난시간의 애노드형 2-Digit 7-Segment Display 반대입니다.

2. 4-Digit 7-Segment Display 핀 번호

위 표를 꼭 기억해 주세요. 4-Digit 7-Segment Display 부품의 위의 부품이미지처럼 순서대로 1~12번까지 있는데 각 핀에 해당된 값을 기억해 주세요. 세개의 표가 있는데 양쪽 표는 여러분들이 보기 편한 것을 참조해 주시고요. 가운데 표는 아두이노와 연결했을 때의 표입니다. 아두이노 핀은 여러분들이 실제 4-Digit 7-Segment Display 부품의 핀을 아두이노에 어떤식으로 연결하느냐에 따라서 아두이노핀 번호는 달라집니다. 가운데 표는 여러분들이 실제 구현을 할 때 표로 직접 작성해주세요. 그리고 나서 코딩을 할 때 해당 4-Digit 7-Segment Display 핀의 값을 기준으로 변수를 선언하실 수 있습니다.

즉, 위 표와 같이 연결을 한다면,

byte segPin[8]={7,3,A3,A1,A0,6,A4,A2}; //사용핀{a,b,c,d,e,f,g,dp} 순서대로임
byte digitPin[4] = {8,5,4,A5}; //segment 위치 핀

이런식으로 pin번호를 순서대로 4-Digit 7-Segment Display 핀값에 매칭되는 아두이노 핀번호를 선언해주면 됩니다. 위 배열 변수에 저장된 값은 4-Digit 7-Segment Display부품과 아두이노에 어떻게 연결했느냐에 따라서 값이 달라집니다.

여러분들이 편한 방식으로 마음대로 연결하시고 코딩할 때만 핀변수값을 정확히 선언하시면 부품을 제어하는데 어려움은 없을 거라 생각됩니다.

참고로, 선 연결 할 때 a,b,d,c,e,f,g,dp핀을 한쪽으로 뭉쳐서 순서대로 아두이노에 연결하고 나머지 4개의 핀은 d1,d2,d3,d4에 순서대로 연결하셔도 됩니다. 하지만 이경우는 4-Digit 7-Segment Display 부품의 핀 위치값을 정확히 알고 있을 때 선을 연결하는 방법인데 좀 지져분하게 선이 연결 됩니다. 그리고, 선 연결 할 때 실수 할 가능성이 가장 큽니다. 별로 추천드리지 않습니다.

쉽게, 4-Digit 7-Segment Display 부품 핀번호 1~12번을 아두이노 2~12번으로 순서대로 매칭시켜서 선을 연결하거나 아니면 아두이노의 아날로그와 디지털핀을 이용하여 4-Digit 7-Segment Display 부품 핀 번호 1~6번은 아두이노 A0~A5에 연결하고 나머지 7~12번은 아두이노 2~7번으로 위아래 순서대로 선을 연결하셔도 됩니다. 그냥 순서대로 핀을 보기 좋게 연결하시고 코딩에서 해당핀에 대한 변수만 제대로 선언하시면 제어하는데 어려움이 없을 꺼에요

2. 4-Digit 7-Segment Display 회로도

준비물 : 4-Digit 7-Segment Display 1개, 아두이노우노
내용 : 4-Digit 7-Segment Display 부품의 핀 번호 순서에 맞게 아두이노우노에 연결 하시오.

위 회로도는 4-Digit 7-Segment Display 핀번호 1~6번은 아날로그 핀 A0~A5에 순서대로 연결하고 7~12번은 순서대로 2~7번으로 연결하려다가 따로 스위치버턴을 인터럽트 핀을 이용할 까 고민중이라 인터럽트핀이 2,3 번 핀 중에 우선 2번핀 하나정도는 남겨 두기 위해서 3~8번으로 순서대로 핀을 연결했네요.

핀 연결은 여러분들이 편하신 방법으로 연결하시면 됩니다. 규칙도 없고 그냥 여러분이 원하는 스타일로 연결만 해주세요. 연결하시고 나서 코딩을 할 때 해당핀에 대한 변수를 선언할 때 정확히 지정만 해주면 됩니다.

2. 코딩

1)LED 숫자 패턴

[애노드형]

//a,b,c,d,e,f,g
byte segValue[10][7] = {
   {0,0,0,0,0,0,1}, //0
   {1,0,0,1,1,1,1}, //1
   {0,0,1,0,0,1,0}, //2
   {0,0,0,0,1,1,0}, //3
   {1,0,0,1,1,0,0}, //4
   {0,1,0,0,1,0,0}, //5
   {0,1,0,0,0,0,0}, //6
   {0,0,0,1,1,1,1}, //7
   {0,0,0,0,0,0,0}, //8
   {0,0,0,0,1,0,0}  //9  
};

캐소드형 회로도이기 때문에 아래와 같이 1은 0으로 0은 1로 변경만 시키면 됩니다.

//a,b,c,d,e,f,g 상태값
byte segValue[10][7] = {
   {1,1,1,1,1,1,0}, //0
   {0,1,1,0,0,0,0}, //1
   {1,1,0,1,1,0,1}, //2
   {1,1,1,1,0,0,1}, //3
   {0,1,1,0,0,1,1}, //4
   {1,0,1,1,0,1,1}, //5
   {1,0,1,1,1,1,1}, //6
   {1,1,1,0,0,0,0}, //7
   {1,1,1,1,1,1,1}, //8
   {1,1,1,1,0,1,1}  //9  
};

2) 숫자 카운트 (0~9999)

아래와 같이 millis()함수는 실시간으로 현재 타이머시간값을 읽어옵니다 그 값을 기준으로 각 자릿숫자를 d1,d2,d3,d4에 저장됩니다.

readTime = millis()/1000;
d1 = readTime%10; //1의 자리
d2 = (readTime/10)%10; //10의 자리
d3 = (readTime/100)%10; //100의 자리
d4 = (readTime/1000)%10; //1000의 자리

2-Digit 7-Segment Display 에서 100의 자리, 1000의 자리가 추가 되었을 뿐 따로 코딩에는 변동이 없습니다.

2) 숫자 카운트 출력(0~9999)

segOutput(3,d1,0); //1의 자리
if(readTime>=10) segOutput(2,d2,0); //10의 자리  
if(readTime>=100) segOutput(1,d3,0); //100의 자리  
if(readTime>=1000) segOutput(0,d4,0); //1000의 자리  

출력되 100의 자리, 1000의 자리로 segOutput()함수 인자만 맞게 넣어주시면 4자리 숫자가 카운트 되어 출력됩니다.

3) 종합소스

//a,b,c,d,e,f,g 상태값
byte segValue[10][7] = {
   {1,1,1,1,1,1,0}, //0
   {0,1,1,0,0,0,0}, //1
   {1,1,0,1,1,0,1}, //2
   {1,1,1,1,0,0,1}, //3
   {0,1,1,0,0,1,1}, //4
   {1,0,1,1,0,1,1}, //5
   {1,0,1,1,1,1,1}, //6
   {1,1,1,0,0,0,0}, //7
   {1,1,1,1,1,1,1}, //8
   {1,1,1,1,0,1,1}  //9  
};

byte segPin[8]={7,3,A3,A1,A0,6,A4,A2}; //사용핀{a,b,c,d,e,f,g,dp} 순서대로임
byte digitPin[4] = {8,5,4,A5}; //segment 위치 핀

unsigned long readTime=0; //현재시간
int d1 = 0; //1의 자리
int d2 = 0; //10의 자리
int d3 = 0; //100의 자리
int d4 = 0; //1000의 자리

void setup() {
  for(int i=0;i<10;i++){
    pinMode(segPin[i], OUTPUT);
  }
  for(int j=0;j<4;j++){
    pinMode(digitPin[j], OUTPUT);   
    digitalWrite(digitPin[j], HIGH); 
  }
}

void loop() {   
  readTime = millis()/1000;
  d1 = readTime%10; //1의 자리
  d2 = (readTime/10)%10; //10의 자리
  d3 = (readTime/100)%10; //100의 자리
  d4 = (readTime/1000)%10; //1000의 자리
  
  segOutput(3,d1,0); //1의 자리
  if(readTime>=10) segOutput(2,d2,0); //10의 자리  
  if(readTime>=100) segOutput(1,d3,0); //10의 자리  
  if(readTime>=1000) segOutput(0,d4,0); //10의 자리  
}
//LED 초기화
void segClear(){ 
  for(int i=0;i<8;i++){
    digitalWrite(segPin[i], LOW);        
  }
}
//LED 출력
void segOutput(int d, int Number, int dp){ 
  segClear();
  digitalWrite(digitPin[d], LOW); 
  for(int i=0;i<7;i++){
     digitalWrite(segPin[i], segValue[Number][i]);        
  }
  digitalWrite(segPin[7], dp);
  delayMicroseconds(1000);
  digitalWrite(digitPin[d], HIGH); 
}

[아두이노] 2-Digit 7-Segment Display

• 온라인 가상시뮬레이터 : https://www.tinkercad.com
• 참고 :
  [아두이노] 7 Segment LED 제어
  [아두이노] 시간millis()함수로 시간 카운트
• 공개회로도 : https://www.tinkercad.com/things/2qXbInnfnz5

지난 시간까지 해서 시간에 대해서 여러가지 원리에 대해서 살펴 보았습니다. 오늘은 7-Segment Display을 이용하여 지난 시간에 공부했던 코딩 결과를 출력해보는 시간을 갖도록 하죠. 원래는 4-Digit 7-Segment Display를 회로도를 만들어서 실험한 결과를 보여드릴려고 했는데 회로도를 너무 복잡하고 지져분하게 표현하면 가독성이 떨어지기 때문에 간단히 2개로 2-Digit 7-Segment Display로 구성하고 출력 원리만 설명하면 될 것 같아서 회로도를 최소화 했습니다. 실제 실험을 하신다면 이 원리를 기반으로 4-Digit 7-Segment Display로 실험하셔도 됩니다.

1. 7-Segment 복습

• 사전학습 : [아두이노] 7 Segment LED 제어

너무 오래전에 이야기 했던 거라 간단히 복습차원으로 설명할께요. 각 post 연계를 하면서도 해당 post는 독립적인 내용을 담고 있어야 해서 어쩔 수 없이 중복된 복습 내용을 간단히 소개하도록 하게 합니다.

위 그림처럼 a,b,c,d,e,f,g,dp 핀과 com1,2핀으로 기본 구성되어 있습니다.

• 애노드 : com1,2 중 하나에 Vcc가 공급되고 나머지 a,b,c,d,e,f,g,dp에 0V(gnd)상태가 되면 LED에 불이 들어옴
• 캐소드 : com1,2 중 하나에 Gnd에 연결되면 나미저 a,b,c,d,e,f,g,dp에 5V(Vcc)상태가 되면 LED에 불이 들어옴

이 두 개념만 가지고 있으면 됩니다. LED은 +,-가 연결되어 불이 들어오기 때문에 7-Segment도 한쪽이 +면 반대쪽이 -가 되어야 불이 들어옵니다. 어떤 원리인지 아시겠지요.

참고로, 실험은 애노드 2-Digit 7-Segment Display 회로도로 구성했습니다. 실제로 4-Digit 7-Segment Display를 구매 하시면 캐소드 부품으로 실험 하실 꺼에요. 혹시, 자신이 쓰는 부품이 다를 수 있으니 부품에 대한 데이터시트를 꼭 확인하시고 실험하세요. 왜! 불이 안들어오지 하는 이유가 대부분 핀 연결을 반대로 하는 경우가 대부분입니다. 그리고, 왜! 숫자가 정상적으로 안나오지 하면 애노드와 캐소드는 a,b,c,d,e,f,g,dp 핀 값이 반대 값을 갖기 때문에 반대 LED에 불이 들어오는 경우입니다. 꼭! 제대로 확인하시고 실험하시기 바랍니다.

2. 2-Digit 7-Segment Display 원리(애노드형)

2-Digit 7-Segment Display or 4-Digit 7-Segment Display 의 원리는 동일합니다. 같은 a,b,c,d,e,f,g,dp핀을 공유하고 Vcc핀은 각각의 7-Segment의 전원을 공급하는 별도 핀으로 나눠주면 2개든 4개든 상관없이 동시에 제어가 가능합니다.

위 그림처럼 각각 D1의 7-Segment와 D2의 7-Segment에 HIGH 되면 a,b,c,d,e,f,g,dp핀이 LOW가 되면 LED에 불이 들어오는데 D1, D2가 동시에 HIGH되면 2개의 7-Segment에는 동일한 문자가 출력됩니다. 2개의 7-Segment에 서로 다른 문자가 출력되게 할려면 각 D1, D2의 전원 공급의 시간차를 두고 a,b,c,d,e,f,g,dp핀을 제어하면 됩니다. 즉, 전류 공급에 의한 일시적 잔상효과를 이용한 방법이지요.

두개의 7-Segment에 시간차 전원 공급으로 문자를 출력하게 함으로서 서로 다른 문자를 출력할 수 있게 됩니다. 여기서, 주의할 점은 시간차의 값이 크면 동시에 출력되는 효과를 볼 수 없으며 시간차를 최소화 하여 잔상효과로 동시에 2개의 7-Segment에 문자가 출력되는 듯한 착시효과가 나타나게 시간차를 잘 조절하셔야 합니다.

//D1 출력
digitalWrite(D1, HIGH); 
for(int i=0;i<7;i++){
   digitalWrite(segPin[i], D1문자LED값);        
}
digitalWrite(segPin[7], dp);
delayMicroseconds(1000);
digitalWrite(D1, LOW); 

//D2 출력
digitalWrite(D2, HIGH); 
for(int i=0;i<7;i++){
   digitalWrite(segPin[i], D2문자LED값);        
}
digitalWrite(segPin[7], dp);
delayMicroseconds(1000);
digitalWrite(D2, LOW); 

이렇게 delayMicroseconds(1000)의 시간만큼 D1, D2 LED에 전원을 공급하게 됩니다. 이 명령문이 교대로 loop()함수로 반복하면 D1과 D2가 동시에 문자를 출력하는 효과가 발생합니다. (1초는 100만 마이크로 초)

참고로, 짧은 시간차를 이용하기 위해서 delay()함수 대신 delayMicroseconds()함수를 사용했네요.

같은 a,b,c,d,e,f,g,dp핀을 공유하면서 D1, D2의 전원 공급의 시간차로 서로 다른 문자를 출력할 수 있게 됩니다. 만약에 4-Digit 7-Segment Display 이면 D1, D2, D3, D4로 각각 시간차를 두고 전원을 공급한다면 4개의 문자가 동시에 출력되는 듯한 착시효과로 동시에 4개의 서로다른 문자를 출력하는 것 같은 결과를 얻게 됩니다.

3. 2-Digit 7-Segment Display 회로도

• 준비물 : 7-Segment 2개, 330옴 2개, 아두이노우노
• 내용 : 애노드형 방식으로 핀은 연결하는데 a,b,c,d,e,f,g,dp은 원하는 디지털핀에 연결하시오.

혹시, 위 그림이 복잡해 보이시면 사전학습 Post [아두이노] 7 Segment LED 제어 의 글을 보시면 애노드형으로 한개짜리 7-Segment로 구성된 회로도가 있을 꺼에요. 그걸 보시고 한개 더 중복해서 연결하시면 됩니다.

4. 숫자 카운트 코딩(0~99)

위의 2-Digit 7-Segment Display 원리의 코딩을 기반으로 숫자를 카운트 해 볼까요.

1) LED 숫자 패턴 만들기

//a,b,c,d,e,f,g
byte segValue[10][7] = { //애노드형
   {0,0,0,0,0,0,1}, //0
   {1,0,0,1,1,1,1}, //1
   {0,0,1,0,0,1,0}, //2
   {0,0,0,0,1,1,0}, //3
   {1,0,0,1,1,0,0}, //4
   {0,1,0,0,1,0,0}, //5
   {0,1,0,0,0,0,0}, //6
   {0,0,0,1,1,1,1}, //7
   {0,0,0,0,0,0,0}, //8
   {0,0,0,0,1,0,0}  //9  
};

D1의 숫자를 만든다면 D1이 Vcc면 a,b,c,d,e,f,g의 핀이 0일때 불이 들어옵니다

0의 숫자를 만들려면 LED에 불은 g핀을 제외한 나머지가 다 0이 되어야 합니다.

0 => 0,0,0,0,0,0,1

나머지 숫자도 이런식으로 만들면 됩니다, 참고로 저장변수공간을 줄일려면 아예 7개의 값을 byte형으로 만드셔도 됩니다.

0 => 0,0,0,0,0,0,1 =>OB00000010

이렇게 해서 10개의 byte 배열변수로 만들면 저장공간을 대폭 줄일 수 있습니다. 이해를 돕기 위해서 그냥 개별적으로 저장공간에 하나의 상태값만 저장되게 코딩하겠습니다. 'OB00000010'으로 표현하면 bitRead()함수로 각각 해당 위치의 값을 읽어와서 해당 LED에 불이 들어오게 제어하는 코딩을 하면 되는데 이 부분은 여러분들에게 숙제로 남겨두겠습니다.

2) millis()함수로 시간값 쪼개기

시간 함수에 대해서 지난 시간에 꽤 오래 동안 몇일에 걸쳐 이야기를 했기 때문에 생략하고 간단히 코딩으로 소개하는 수준으로 넘어가겠습니다.

readTime = millis()/1000; //초단위로 만듬
d1 = readTime%10; //1의 자리
d2 = (readTime/10)%10; //10의 자리

millis()함수로 읽은 타이머 시간값을 1000으로 나눠서 초단위로 시간값으로 readTime변수에 저장합니다. 이 초 값을 지난시간에 배웠던 방식으로 1의 자리와 10의 자리로 분리해 내서 d1, d2의 해당 숫자를 저장합니다.

3) 숫자 출력

위 2-Digit 7-Segment Display 원리에서 Segment의 숫자를 출력하기 위해서 코딩부분을 따로 외부 사용자정의 함수로 빼서 아래와 같이 segOutput()함수로 만들었습니다. d은 digit 위치이고, Number은 출력되는 숫자, dp은 Segment의 왼쪽 사이드에 있는 dot LED의 상태값입니다.

//LED 출력
void segOutput(int d, int Number, int dp){ 
  segClear();
  digitalWrite(digitPin[d], HIGH); 
  for(int i=0;i<7;i++){
     digitalWrite(segPin[i], segValue[Number][i]);        
  }
  digitalWrite(segPin[7], dp);
  delayMicroseconds(1000);
  digitalWrite(digitPin[d], LOW); 
}

코딩에 보시면 segClear()함수가 있는데 이것 역시 사용자 정의 함수로 제가 만든 함수입니다. 함수단어명을 유심히 보면 Segment를 뭔가 Clear한다는 의미를 담고 있는 걸 보실 수 있을거에요. 즉, LED를 초기화 상태로 되돌리는 함수를 하나 더 만들었습니다.

그 이유는, 연속으로 각 Segment에 숫자를 출력하면 한쪽 Segment의 값이 유지된 상태에서 다른 Segment에 LED에 불이 들어오게 할때 기존에 남아 있는 a,b,c,d,e,f,g,dp핀의 상태값이 유지된 상태에서 전류가 일시적으로 공급되어 양쪽 Segment에 일부 핀에 전류가 동시 공급되는 현상이 발생합니다. 그래서 잔상으로 두 Segment의 일부 LED에 불이 겹쳐서 나오게 됩니다. 그렇기 때문에 각 Segment에 불이 들어오게 하기전에 초기화 작업을 해줘야 겹치는 LED의 문제를 해결 할 수 있습니다.

void segClear(){
  for(int i=0;i<8;i++){
    digitalWrite(segPin[i], HIGH);        
  }
}

이렇게 간단하게 a,b,c,d,e,f,g,dp핀 HIGH 상태로 초기화 하시면 됩니다.

4) 전체소스

//a,b,c,d,e,f,g 상태값
byte segValue[10][7] = { //애노드형
   {0,0,0,0,0,0,1}, //0
   {1,0,0,1,1,1,1}, //1
   {0,0,1,0,0,1,0}, //2
   {0,0,0,0,1,1,0}, //3
   {1,0,0,1,1,0,0}, //4
   {0,1,0,0,1,0,0}, //5
   {0,1,0,0,0,0,0}, //6
   {0,0,0,1,1,1,1}, //7
   {0,0,0,0,0,0,0}, //8
   {0,0,0,0,1,0,0}  //9  
};

byte segPin[8]={2,3,4,5,6,7,8,9}; //사용핀{a,b,c,d,e,f,g,dp} 순서대로임
byte digitPin[2] = {A0,A1}; //segment 위치 핀

unsigned long readTime=0; //현재시간
int d1 = 0; //1의 자리
int d2 = 0; //10의 자리

void setup() {
  for(int i=0;i<10;i++){
    pinMode(segPin[i], OUTPUT);
  }
  pinMode(digitPin[0], OUTPUT);
  pinMode(digitPin[1], OUTPUT);    
  digitalWrite(digitPin[0], LOW); 
  digitalWrite(digitPin[1], LOW);      
}

void loop() {  
  //시간 갱신
  readTime = millis()/1000;
  d1 = readTime%10; //1의 자리
  d2 = (readTime/10)%10; //10의 자리
  
  segOutput(1,d1,1); //1의 자리
  if(readTime>=10) segOutput(0,d2,1); //10의 자리  
}
//LED 초기화
void segClear(){ 
  for(int i=0;i<8;i++){
    digitalWrite(segPin[i], HIGH);        
  }
}
//LED 출력
void segOutput(int d, int Number, int dp){ 
  segClear();
  digitalWrite(digitPin[d], HIGH); 
  for(int i=0;i<7;i++){
     digitalWrite(segPin[i], segValue[Number][i]);        
  }
  digitalWrite(segPin[7], dp);
  delayMicroseconds(1000);
  digitalWrite(digitPin[d], LOW); 
}

5. 결과

digitalWrite(digitPin[d], HIGH); 
  for(int i=0;i<7;i++){
     digitalWrite(segPin[i], segValue[Number][i]);        
  }
  digitalWrite(segPin[7], dp);
  delayMicroseconds(1000);
digitalWrite(digitPin[d], LOW); 

digitalWrite(digitPin[d], HIGH); 
숫자 LED 출력;
delayMicroseconds(1000);
digitalWrite(digitPin[d], LOW); 

[아두이노] 시간 millis() 함수로 시계 코딩

• 온라인 가상시뮬레이터 : https://www.tinkercad.com
• 공개회로도 : https://www.tinkercad.com/things/eWbQaEXD7WK

오늘은 millis() 함수를 이용한 시계 코딩을 실험 할 예정입니다. 지난 시간의 초를 시/분/초를 변환하거나 시/분/초를 초로 변환하는 코딩을 실험 하였습니다. 여기에, millis()함수와 전역 타이머변수를 이용하여 아두이노 시계 코딩을 만들어 보겠습니다. 시계 코딩의 결과는 시리얼모니터로 간단히 출력하는 실험이지만 나중에 외부 출력 부품을 이용하여 디지털 시계를 만들거나 아날로그 시계를 만들어 볼 예정입니다. 우선은 시계 코딩으로 어떻게 동작하는지 먼저 만들어 봐야 겠지요.

이제 본격적으로 실험을 해볼까요.

1. 시간

• 공개회로도 : https://www.tinkercad.com/things/eWbQaEXD7WK

시간은 하루를 기준으로 24시간, 1시간은 60분, 1분은 60초로 이루어져 있습니다. 누구나 다 아는 기본 내용이지요. 시계는 하루 24시간을 표시하는 기계입니다. 즉, 24시간 이상의 시간이 흐르는 다시 리셋되어 시간이 0시부터 흐르게 됩니다. 가령, 25시가 입력되면 다음날 새벽 1시가 되겠죠. 이처럼 몇시간이 입력되었던 24시간을 기준으로 표시됩니다.

표시 => 전체시간 % 24 = 현재시간
예) 25%24 =1

몇시간이 입력되었던 날짜와 상관없이 24시간을 기준으로 표시만 하면 됩니다. 대충 시간은 어떤 느낌으로 출력해야 할지 아시겠지요. "23:59:59"가 되었을 때 1초가 흐르면 바로 "0:0:0"으로 리셋을 시키게 하여 24시간 기준으로 표시되게 하면 되겠죠.

2. 시간 입력

• 사전학습 : [아두이노] Serial 통신 때 String 사용

  // 시:분:초 입력
  if(Serial.available()){
    String inString = Serial.readStringUntil('\n');    
    int index1 = inString.indexOf(':'); 
    int index2 = inString.indexOf(':',index1+1);   
    int index3 = inString.length();
    int hour = inString.substring(0, index1).toInt();
    int min = inString.substring(index1+1,index2).toInt();
    int sec = inString.substring(index2+1,index3).toInt();
}

위 코딩은 지난시간에 시리얼모니터로 시/분/초를 입력한 값을 각각 hour, min, sec 변수에 저장하는 코딩입니다. 시간을 입력하고 그 시간문자열에서 시간들을 분리해 냅니다. 위 코딩 설명은 사전학습에서 이야기 했기 때문에 생략합니다.

3. 시간 동작

아두이노는 시간을 어떻게 흐르게 할까요. 아두이노 내부에 타이머가 있고 이 타이머시간값을 millis()함수를 사용하여 타이머시간값을 가져올 수 있고 이 값을 통해서 아두이노 시간을 흐르게 할 수 있습니다. 아두이노는 1초 단위의 시간을 구할 수 있습니다. delay(1000) 하고 시간변수를 +1씩 증가시키면 쉽게 1초단위로 시간값을 구할 수 있지만, 다른 부품들과 연동하기 위해서는 delay()함수를 될 수 있으면 쓰면 안됩니다. 그래서, millis()함수를 사용하는 데 다음 아래와 같이 코딩하면 됩니다.

if(millis()-timeVal>=1000){
  sec++; //1초증가
}

여기서, 시간을 외부로 부터 입력받아 세팅한 뒤에 시간이 흘러가게 해야 한다면 위 명령문에서 1초 증가를 변수에다 저장하여 시간을 돌리면 초, 분, 시 기준으로 아래 if문을 만들어 시간값이 증가하도록 코딩을 하면 됩니다.

if(sec==60){
  sec=0;
  min++; //1분증가
}
if(min==60){
  min=0;
  hour++; //1시간증가
}
if(hour==24){
  hour=0;  
}

이렇게 3개의 if문을 만들어서 시간값을 만들어 낼 수 있지만 이 방법으로 하지 않을 겁니다. 다른 방식으로 타이머변수에 현재시간으로 초기화하는 방법으로 코딩하겠습니다.

extern volatile unsigned long timer0_millis; //타이머변수
timer0_millis = ((long)hour*3600+min*60+sec)*1000;

이렇게, 시리얼모니터에서 시간을 입력 받은 hour, min, sec값을 초로 변환 한 값을 timer0_millis값으로 초기화 하면 어떤 현상이 발생할까요. timer0_millis 시간을 기준으로 타이머는 계속 흘러가기 때문에 millis()함수로 읽은 시간값은 입력된 시간을 기준으로 시간이 흘러가게 됩니다. 그렇게 되면 지난시간에 배운 millis()함수 값을 읽어서 시/분/초로 변환만 하면 현재 시간을 실시간으로 얻을 수 있습니다.

readTime = millis()/1000;
      
sec = readTime%60;
min = (readTime/60)%60;
hour = (readTime/(60*60))%24; 

이렇게 하면 시간을 알 수 있게 됩니다. 이게 바로 아두이노 시계가 되는 것이죠. 위의 if문으로 시간을 1초씩 증가해서 초, 분, 시를 증가시키든 방금했던 방식으로 아예 timer0_millis을 현재 시간으로 초기화 할지는 여러분이 선택만 하시면 됩니다.

두번째 timer0_millis변수로 초기화 하는 방법을 취하고 24시간 기준으로 timer0_millis를 리셋시키는 방법으로 코딩을 수정하면 다음과 같은 코딩이 됩니다.

readTime = millis()/1000;
      
if(millis()>=86400000){ //24시간 초기화
  timer0_millis=0;
}
sec = readTime%60;
min = (readTime/60)%60;
hour = (readTime/(60*60))%24; 

millis() 현재 시계의 시간값으로 타이머가 돌고 있습니다. 그 값이 24시간이 되면 0시로 리셋이 되어야 합니다.

1일 24시간 => 1x60x60x24 = 86400 x 1000(1초) = 86400000

위처럼, millis() 시간값이 86400000이 되면 1일이 됩니다. 24시간이라는 소리죠. 그러면 0시로 리셋을 해야 합니다. 간단히, timer0_millis 변수를 0으로 초기화 하면 0시부터 타이머가 돌게 됩니다. 이렇게 하면 24시간 기준으로 무한으로 아두이노 시계가 돌게 되겠죠.

그냥, 계속 millis()함수로 읽으면 되지 하실 분도 있을거에요. timer0_millis변수는 unsigned long 자료형입니다. 수치를 저장하는 값이 한계가 있습니다. 한달 조금 지나면 리셋이 되고 사실 그전에 시간에 대해 정확히 리셋 시점을 잡아줘야 합니다. 안그러면 리셋되는 시점에서 시간에 문제가 생길 수 있습니다. 편하게 24시간 기준으로 리셋을 시키는 것이 좋겠죠. 리셋 시점은 여러분들의 자유입니다.

4. 종합 소스

extern volatile unsigned long timer0_millis; //타이머변수
unsigned long timeVal; //이전시간
unsigned long readTime; //현재타이머시간
int hour, min, sec;
boolean state=false;

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

void loop()
{ 
  if(Serial.available()){
    String inString = Serial.readStringUntil('\n');    
    int index1 = inString.indexOf(':'); 
    int index2 = inString.indexOf(':',index1+1);   
    int index3 = inString.length();
    
    hour = inString.substring(0, index1).toInt();
    min = inString.substring(index1+1,index2).toInt();
    sec = inString.substring(index2+1,index3).toInt();
  
    
    timer0_millis = ((long)hour*3600+min*60+sec)*1000;
    state=true;
    timeVal=millis();
  }
  if(state==true){ //시리얼모니털 출력 시작
    
    if(millis()-timeVal>=1000){ //1초 단위 출력
     readTime = millis()/1000;
      
     if(millis()>=86400000){
       timer0_millis=0;
     }
     timeVal = millis();
   
     sec = readTime%60;
     min = (readTime/60)%60;
     hour = (readTime/(60*60))%24;       
      
     Serial.print(hour);
     Serial.print(" : ");
     Serial.print(min);
     Serial.print(" : ");
     Serial.println(sec);      
    }
  }
}

위 소스에서는 1초 단위로 출력하기 위해서

if(millis()-timeVal>=1000){ //1초 단위 출력
 timeVal = millis();
}

이 명령문을 사용했습니다. 이것은 1초 단위로 시리얼모니터로 출력하기 위한 락을 걸어놓은 느낌의 조건문입니다. 1초가 되었을 때 시간 값을 시리얼모니터로 출력을 할꺼야 하는 조건문으로 생각하세요. 위에서 설명했던 각각의 내용들을 전체 소스에 배치한 것 뿐이니깐 혹시 이해 안되면 위 설명을 다시 보시기 바랍니다.

5. 결과

시리얼모니터로 시간값을 입력하면 그 시간을 기준으로 타이머가 계속 흘러간다. 그래서 시계처럼 시간을 출력할 수 있다.

6. millis() 함수 대신에 timer0_millis 사용 가능

extern volatile unsigned long timer0_millis; //타이머변수

이렇게 선언하게 되면 구지 millis()함수를 사용안하고 timer0_millis로 시간값을 가져올 수 있습니다.

Serial.print(timer0_millis);

이렇게 한번 찍어보세요. millis()함수와 같은 시간값을 출력됩니다. 내부적으로 타이머변수 값이 갱신이 되는데 이 변수를 호출할 때 호출한 시점의 시간값을 담고 있습니다. timer0_millis를 millis()함수 대신해서 사용할 수 있습니다. 그런데 추천은 드리지 않습니다. 외부전역변수 자체가 하드웨어 내부에 사용하는 변수들을 건들게 되면 정상적으로 하드웨어가 동작하지 못하는 경우가 발생하기 때문에 특별한 목적이 없는 한 사용하지 않는 방향으로 코딩 하셨으면 합니다.

마무리

이렇게 해서 시리얼모니터로 입력한 시간값을 기준으로 아두이노의 시계는 동작하게 됩니다. 이걸 시리얼모니터로 출력했지만 다른 외부 출력 부품을 이용하면 아두이노 전용 시계가 만들어 지겠죠. 참고로 7-Segment Dispaly로 출력하면 디지털 시계가 되는 것이고 Stepper Motor로 회전 시키면 아날로그 시계가 됩니다. LED로 시계판을 만들면 LED 시계가 되겠죠. 이건 어떤 출력부품을 사용하느냐에 따라서 다양한 아두이노 시계를 만들 수 있게 됩니다.

한번 오늘 배운 시계 원리를 이용하여 어떤 아두이노 시계를 만들지 상상의 나래를 펼쳐 보세요.

[아두이노] 온도센서를 이용한 경보 온도계 다른 접근 

• 온라인 가상시뮬레이터 : https://www.tinkercad.com
• 참고 :
  [아두이노] 인터럽트(Interrupt) 제어
  [아두이노] 온도센서(TMP36)+LCD16x2 경보 온도계 응용
• 공개회로도 : https://www.tinkercad.com/things/9dLzYhf5Wec

[주제 ]

• 일반스위치버턴을 인터럽트스위치버턴으로 변경
• 50도 이상 증가 한 후 50이하로 떨어진 순간에 현재 온도가 출력되게 변경

지난시간에 간단히 경보 온도계를 만들었는데 그냥 넘어가기가 그래서 코딩적 접근 방법을 다르게 시도해보는 시간을 갖도록 하겠습니다. 하드웨어 부분은 동일하지만 어떻게 코딩을 하냐에 따라서 다양한 결과를 만들어 낼 수 있습니다.

1. 경보 온도계 회로도

• 준비물 : LCD16x2 모듈 1개, 피에조 부저 1개, 스위치버턴 1개, TMP36 1개, 아두이노우노
• 참고 : [아두이노] 온도센서(TMP36)+LCD16x2 경보 온도계 응용

경보 온도계는 지난 시간과 동일합니다. 참고에 지난시간의 post를 보고 사전학습을 미리 해주세요.

2. 코딩

[ 기본 소스 ]

#include <LiquidCrystal.h>

//LiquidCrystal(rs, enable, d4, d5, d6, d7) 
LiquidCrystal lcd(3, 4, 8, 9, 10, 11);

const int switchPin = 2;
const int piezoPin = 12;
unsigned long timeVal=0;
float V=0;
float C=0;
float F=0;

void setup() {
  pinMode(switchPin, INPUT_PULLUP);

  lcd.begin(16,2);
  lcd.setCursor(0, 0);
  lcd.print("Hello World");
  delay(1000);
  lcd.clear();
}

void loop() { 
  V =fmap(analogRead(A0),0,1023,0,5); //map함수 원리를 이용한 다이렉트 Voltage계산
  //float V = analogRead(A0)*5.0/1023;

  C = (V-0.5)*100;  //섭씨 C = (F-32)*1.8;
  F = C*9.0/5.0+32; //화씨 F = C*1.8+32;
    
  if(digitalRead(switchPin)== LOW){
    output();
    timeVal=millis();
    delay(500);
  }
  if(millis()-timeVal>=2000){
    output();  
    timeVal=millis();
  }
  if(C>50){
    output();
    tone(piezoPin,523,1000/8);     // 도음으로 8분음표(음길이)
    delay(1000/4*1.30);             
    noTone(12);
    timeVal=millis();
  }
}  
 void output(){
   lcd.clear();
   lcd.setCursor(0, 0);
   lcd.print("C : ");
   lcd.setCursor(6, 0);
   lcd.print(C);  
   lcd.setCursor(0, 1);
   lcd.print("F : ");
   lcd.setCursor(6, 1);
   lcd.print(F);  
  }

float fmap(long x, long in_min, long in_max, float out_min, float out_max)
{
  return (x - in_min) * (out_max - out_min) /(float) (in_max - in_min) + out_min;
}

지난시간의 실험한 기본 소스입니다. 이 소스에 대한 설명은 생략하겠습니다. 모르는분들은 지난시간의 post를 보고 오시기 바랍니다. 기본소스에 어떤 부분이 수정되고 추가 되었는지를 비교하면서 보시기 바랍니다.

1) 스위치 버턴을 인터럽트 스위치버턴으로 변경

const int interruptPin = 2;//인터럽트핀

void setup() { 
  pinMode(interruptPin, INPUT_PULLUP); 
  attachInterrupt(digitalPinToInterrupt(interruptPin), switchFn, FALLING);
}

void switchFn(){
   인터럽트 발생 시 처리 명령문;
}

아두이노우노는 2,3번이 인터럽트 핀입니다. 다른 핀을 사용 할 경우는 반응하지 않습니다. 다른 아두이노보드 일 경우는 해당 보드의 인터럽트 핀 넘버가 다를 수 있음으로 해당 보드의 인터럽트 핀 정보를 찾아보시기 바랍니다.

attachInterrupt(digitalPinToInterrupt(interruptPin), switchFn, FALLING);
FALLING : HIGH -> LOW로 변할때

이렇게 setup()함수 안에다 인터럽트 함수를 선언해 놓으면 해당 interruptPin에 전류가 HIGH->LOW로 변할 때 switchFn()함수를 호출하게 됩니다. 해당 인터럽트 2번핀은 풀업모드의 스위치버턴입니다. 처음 상태가 HIGH이고 스위치를 누르면 LOW이기 때문에 스위치를 누를대 HIGH->LOW로 변하게 됩니다. 그러면, switchFn()함수가 호출이 됩니다. 어떤 원리인지 아시겠지요.

[기존소스]

const int switchPin = 2;
void setup() {
  pinMode(switchPin, INPUT_PULLUP);
}
void loop(){
  if(digitalRead(switchPin)== LOW){
    output();
    timeVal=millis();
    delay(500);
  }
}   

변경 후,

boolean switchState=false; //스위치 상태값

void setup() { 
  pinMode(interruptPin, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(interruptPin), switchFn, FALLING);
}
void loop(){
  if(switchState==true){
    output();    
    timeVal=millis();    
    switchState=false;
  }
}   
void switchFn(){
  switchState=true;
}

같은 동작의 같은 느낌의 코딩입니다. 하지만 어떤 차이가 있을까요. 변경 전 스위치 버턴은 loop()함수에서 무한 반복할때 순서대로 명령문을 처리할 때 스위치가 눌러졌는지 확인하는 원리이고 변경 후 스위치 버턴은 loop()함수에서 무한 반복하는 명령문들의 순서랑 상관없이 스위치버턴 이벤트가 발생합니다. 즉, loop()함수와는 별개로 독립적으로 스위치버턴 동작을 수행합니다.

loop()함수의 지배권에 있느냐 독립적으로 있느냐에 차이인 것이죠. 사용목적에 따라서 사용하시면 됩니다.

2) 경보 해제 후 온도 출력

[기존소스]

void loop(){
  if(C>50){ 
    output();
    tone(piezoPin,523,1000/8);     // 도음으로 8분음표(음길이)
    delay(1000/4*1.30);             
    noTone(12);    
    timeVal=millis();    
    tmpState=true;    
  }  
}

지난시간에 숙제로 남겨 둔 50이상일 때 경보음과 현재 온도를 출력하게 코딩을 했었습니다. 그렇다면 50도 이상이 되었다가 50도 이하가 되는 순간 온도는 수정되어야 하지만 지난 소스에서는 바로 수정되는게 아니라 정해진 시간이 될 때까지는 온도값이 출력되지 않습니다. 그 부분을 해결하라고 숙제를 내줬는데 해결책은 알아 볼까요.

어떤 상태가 되면 그 상태가 되었을 때 그 상태에 대한 상태값을 변수로 저장하면 됩니다. 50이상이 된다면 이상이 되었을 때의 상태값을 가지고 있을 때 그 상태값을 기준으로 50이하가 된 순가 현재 온도를 출력시키면 해결 됩니다. 설명이 어렵게 되었는데 코딩을 살펴볼까요.

if(C>50){
 tmpState=true;
}
if(tmpState==true){
  if(C<50){
    tmpState=false;
  }
}

C의 온도가 50도 이상이면 tmpState은 true로 50이상인 상태가 되었다는 것을 상태변수에 저장해 놓습니다. 그러기 다음 if문을 통해서 50이상인 상태가 되었다면 다시 if문으로 C가 50이하로 떨어졌는지 체크하게 되고 50이하로 떨어졌다면 다시 tmpState의 상태값은 원상태로 돌아가서 50이상이 될때까지는 false가 됩니다. 이 원리는 자주 사용하는 원리이니깐 이참에 꼭 알아두시기 바랍니다.

if문은 어떤 A조건의 상태가 되면 그 A상태를 기억 할 수 있고 그 A상태를 기준으로 B조건에 들어 갈 수 있고 B라 상태를 만들 수 있습니다. 서로 다른 조건에 대해서 상태에 따라서 개입을 하고 싶을 때 if문을 활용 한다는 점을 꼭 기억해 두세요.

변경 후,

boolean tmpState = false; //온도 상태값

void loop(){
  if(C>50){ 
    output();
    tone(piezoPin,523,1000/8);     // 도음으로 8분음표(음길이)
    delay(1000/4*1.30);             
    noTone(12);    
    timeVal=millis();    
    tmpState=true;    
  }  
  
  if(tmpState==true){
    if(C<50){ 
      timeVal=millis();    
      tmpState=false;    
      output();
    }    
  }
}

3. 종합 소스

2초 단위로 LCD16x2에 온도와 습도가 출력됩니다. 여기서 스위치버턴을 누르면 인터럽트함수가 호출되고 switchState 값을 true로 변경하여 스위치가 눌러졌음을 나타냅니다 그리고 나서 if문에서 switchState가 true면 현재 온도와 습도를 출력하게 되게 코딩이 되어 있습니다. 스위치를 눌렀을 때 현재 온도와 습도를 출력하게 만든 것이죠. 다음으로, 온도가 50이상일 때 경보음과 현재 온도가 출력되는데 tmpState 변수에 true로 50이상인 상태를 나타냅니다. 그 다음 if문으로 온도가 50이하가 될때 현재 온도가 출력되게 함으로써 실시간으로 50이상으로 올라갔다가 50이하로 떨어졌을 때 현재 온도가 출력되게 함으로써 지난 시간의 코딩에 비해 경보 온도계를 매끄럽게 표현이 되었네요.

#include <LiquidCrystal.h>

//LiquidCrystal(rs, enable, d4, d5, d6, d7) 
LiquidCrystal lcd(3, 4, 8, 9, 10, 11);


//const int switchPin = 2;
const int interruptPin = 2;//인터럽트핀
boolean switchState=false; //스위치 상태값
boolean tmpState = false; //온도 상태값

const int piezoPin = 12;
unsigned long timeVal=0;
float V=0;
float C=0;
float F=0;


void setup() { 
  pinMode(interruptPin, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(interruptPin), switchFn, FALLING);
  
  lcd.begin(16,2);
  lcd.setCursor(0, 0);
  lcd.print("Hello World");
  delay(1000);
  lcd.clear();

}

void loop() {
 
  V =fmap(analogRead(A0),0,1023,0,5); //map함수 원리를 이용한 다이렉트 Voltage계산
  
  //float V = analogRead(A0)*5.0/1023;

  C = (V-0.5)*100;  //섭씨 C = (F-32)*1.8;
  F = C*9.0/5.0+32; //화씨 F = C*1.8+32;
  
  
  if(switchState==true){
    output();    
    timeVal=millis();    
    switchState=false;
  }
  if(millis()-timeVal>=2000){
    output();  
    timeVal=millis();
  }
  
  if(C>50){ 
    output();
    tone(piezoPin,523,1000/8);     // 도음으로 8분음표(음길이)
    delay(1000/4*1.30);             
    noTone(12);    
    timeVal=millis();    
    tmpState=true;    
  }  
  
  if(tmpState==true){
    if(C<50){ 
      timeVal=millis();    
      tmpState=false;    
      output();
    }    
  }
}  

void output(){
   lcd.clear();
   lcd.setCursor(0, 0);
   lcd.print("C : ");
   lcd.setCursor(6, 0);
   lcd.print(C);  
   lcd.setCursor(0, 1);
   lcd.print("F : ");
   lcd.setCursor(6, 1);
   lcd.print(F);  
}
void switchFn(){
  switchState=true;
}
float fmap(long x, long in_min, long in_max, float out_min, float out_max)
{
  return (x - in_min) * (out_max - out_min) /(float) (in_max - in_min) + out_min;
}

4. 결과

영상으로는 정확히 의미를 전달되지 않은 것 같습니다. 직접 공개회로도에 가셔서 TMP36 온도센서를 가상시뮬레이터에서 직접 제어해서 결과를 직접 체험해 보셨으면 합니다.

마무리

오늘은 코딩에 대해서 살펴 보았습니다. 지난시간의 소스는 약간 불안정한 소스였고 오늘은 좀 더 개선된 소스 이면서 새롭게 인터럽트 방식을 적용해 보았습니다. 코딩은 딱 하나의 정답은 없습니다. 지난시간의 소스와 오늘 소스를 통해서 다양한 접근 방식의 코딩을 하셨으면 합니다. 어떤 코딩을 하고 그 코딩으로 결과가 나왔으니깐 마무리하지 말고 이런식으로 또 다른 접근법이 없는지 계속 상상을 하면 보이지 않았던 것이 보이고 코딩이 개선되고 상상코딩의 능력이 올라가게 됩니다.

그리고, 여러분들은 지금까지의 배웠던 부품 중 떠오르시는 것이 있으면 부품을 더 결합해서 재밌는 형태로 변형 시켜 보셨으면 합니다.

[아두이노] 온도센서(TMP36)+LCD16x2 경보 온도계 응용

• 온라인 가상시뮬레이터 : https://www.tinkercad.com
• 참고 :
  [아두이노] 온도센서(TMP36) 제어
  [아두이노] 스위치 버턴 제어
  [아두이노] 피에조부저 제어
  [아두이노] LCD16x2 (LiquidCrystal) 제어
  [아두이노] delay()함수 안쓰고 delay 제어하기
• 공개회로도 :
  https://www.tinkercad.com/things/k9ksK4Tk94a (TMP36+스위치버턴)
  https://www.tinkercad.com/things/20FHbzZpihk (TMP36+스위치버턴+피에조부저)
  https://www.tinkercad.com/things/bDw0caLiMb5 (TMP36+스위치버턴+피에조부저+LCD16x2)

오늘은 @uuu95님이 질문한 DHT11 실험을 가상시뮬레이터에서 한번 구현해보고 싶어서 실험을 하게 되었네요. DHT11 부품이 가상시뮬레이터에서 제공되지 않기에 TMP36 부품으로 대신하여 실험을 할까 합니다. 내용을 보니깐 온도를 읽어서 LCD16x2 모니터에 결과를 출력하는데 5초단위로 지속적으로 출력하고 스위치를 누르면 현재 온도를 출력하고 일정온도 이하가 되면 피에조부저가 경고음을 울리게 하는 실험이더군요. 한번 위 내용을 가상시뮬레이터에서 제 나름대로 재구성하여 실험을 하겠습니다.

참고로 오늘 실험을 하기전에 위에 링크가 걸린 참고 post들은 각 부품에 대한 기초 내용으로 구성되어 있기 때문에 가셔서 각 부품의 사용법을 사전학습하시고 오세요. 아시는 분들은 그냥 넘어가셔도 되고요 중복되는 내용은 구지 처음부터 설명을 할 필요는 없겠죠.

1. 온도계 회로도

• 준비물 : 스위치버턴 1개, TMP36 1개, 아두이노우노
• 내용 : 스위치버턴은 2번핀에 연결하고 TMP36은 A0핀에 연결하여 값을 읽는다.
• 공개회로도 : https://www.tinkercad.com/things/k9ksK4Tk94a(TMP36+스위치버턴)

온도센서와 스위치 버턴을 사용하여 온도값을 시리얼 모니터로 출력시켜 코딩을 우선 합시다.

2. 코딩

코딩은 5초 단위로 TMP35 센서의 값을 읽어와 온도와 습도를 출력하도록 할려고 했는데 시뮬레이터를 빠르게 동작시키기 위해 2초 단위로 수정하여 온도와 습도가 나오게 할 예정입니다. 이때 스위치 버턴을 누르면 현재 온도와 습도가 출력되게 설계합니다. 그런데 2초 단위로 온도와 습도가 출력되는데 delay(2000) 함수를 사용하면 2초 동안은 스위치를 눌러도 반응을 하지 않습니다. 대기 시간에는 아두이노는 휴먼상태가 되기 때문에 스위치를 누를 수 없기 때문에 delay()함수를 사용하지 않는 delay 효과를 부여해서 제어함으로써 실시간으로 스위치가 눌러지면 현재 온도와 습도가 출력되고 2초 단위로 현재 온도와 습도가 출력되게 코딩을 만들어 봅시다.

[delay()함수 없이 delay] 2초 단위로 if문 안에 명령문 수행

unsigned long timeVal=0; //이전시간

void loop(){
  if(millis()-timeVal>=2000){ //딜레이 시간 2초(2000)
    2초 단위로 동작;
    timeVal=millis();
  }
}

식 : 현재시간(millis) - 이전시간(timeVal) > 딜레이시간(2000)

와 같이 코딩을 하면 2초 단위로 if문안의 명령문을 수행합니다. 수행하고 수행 후 timeVal은 수행된 시간 millis()시간을 저장함으로써 다음 2초 시간을 구할 때 사용합니다.

[스위치버턴 풀업모드버턴]

const int switchPin = 2;
void setup() { 
  pinMode(switchPin, INPUT_PULLUP);
}
void loop(){
  if(digitalRead(switchPin)== LOW){
    스위치가 눌러질때 명령문;
    delay(500);
  }
}

풀엄모드 스위치버턴이라서 pinMode()은 INPUT_PULLUP으로 선언됩니다. 동작은 스위치를 누르지 않는 상태는 HIGH상태이고 스위치를 누르면 LOW상태가 됩니다 그래서, loop()함수에서 스위치가 눌러졌을 때 LOW랑 같은지로 체크하게 됩니다.

[온/습도 계산]

float V=0;
float C=0;
float F=0;

void loop(){
  V =fmap(analogRead(A0),0,1023,0,5); //map함수 원리를 이용한 다이렉트 Voltage계산
  //V = analogRead(A0)*5.0/1023;
  C = (V-0.5)*100;  //섭씨 C = (F-32)*1.8;
  F = C*9.0/5.0+32; //화씨 F = C*1.8+32;
}

float fmap(long x, long in_min, long in_max, float out_min, float out_max)
{
  return (x - in_min) * (out_max - out_min) /(float) (in_max - in_min) + out_min;
}

C, F 공식에 대입하기 위해서 V값을 구할때 0~5V 사이의 전류값을 알아야 합니다. 하지만, analogRead(A0)함수로 읽게 되면은 0~1023의 값으로 읽게 되는데 그러면 주석으로 처리한 식으로 계산을 한번 더 해야 합니다. 그래서, map()함수를 변형 시켜서 다이렉트로 0~5V 사이의 전류값을 구하도록 수정했습니다. 원래 map()함수는 float형이 아닌데 실수값을 구해야 해서 float형으로 변형 사용자정의함수로 직접 만들었습니다 전류를 구해서 C, F를 식에 대입하여 온도와 습도를 구하게 됩니다.

설계

1. TMP36을 읽어 온/습도를 계산한다.
2. 스위치가 눌러졌는지 확인(스위치가 눌러졌으면 현재 온/습도 출력한다.) 출력된 시점을 기준으로 2초후 온습도가 출력하게 만든다.
3. 2초단위로 온/습도를 출력한다.

const int switchPin = 2;
unsigned long timeVal=0;
float V=0;
float C=0;
float F=0;

void setup() {
  Serial.begin(9600);
  pinMode(switchPin, INPUT_PULLUP);
}

void loop() {

  //TMP36읽어 온도와 습도 계산
  V =fmap(analogRead(A0),0,1023,0,5); //map함수 원리를 이용한 다이렉트 Voltage계산
  //V = analogRead(A0)*5.0/1023;

  C = (V-0.5)*100;  //섭씨 C = (F-32)*1.8;
  F = C*9.0/5.0+32; //화씨 F = C*1.8+32;
  
  
  if(digitalRead(switchPin)== LOW){ //스위치 눌러졌는지
    output();
    timeVal=millis(); //현재시간을 이전시간변수에 저장
    delay(500);
  }
  if(millis()-timeVal>=2000){ //현재시간-이전시간의 차이 2000인지 확인
    output();  
    timeVal=millis(); //현재시간을 이전시간변수에 저장
  }  
}  

//온도와 습도 출력
void output(){   
   Serial.print("C : ");
   Serial.println(C);  
   Serial.print("F : ");   
   Serial.println(F);  
}

// TMP36에서 읽은 0~1023값을 0~5V로 변환
float fmap(long x, long in_min, long in_max, float out_min, float out_max)
{
  return (x - in_min) * (out_max - out_min) /(float) (in_max - in_min) + out_min;
}

딜레이 함수를 사용하지 않기 때문에 실시간으로 계속 온도가 측정이 되고 스위치가 눌러지면 그때 현재 온/습도 값이 시리얼모니터로 출력된다. 그리고 출력된 시점이 이전시간이 되어 다음 2초 후에 온/습도가 출력된다. 스위치가 안눌러졌다면 2초단위로 온/습도가 출력된다.

3. 결과

2초후 부터 지속적으로 온도와 습도가 출력되는데 스위치 버턴을 누르면 바로 온도와 습도가 출력됩니다. 출력시간은 여러분들이 2000 대신에 다른 값으로 수정하시면 원하는 시간대 출력되도록 만들 수 있습니다.

4. 온도계에 피에조부저로 경보 알림

1) 회로도

• 준비물 : 피에조 부저 1개, 스위치버턴 1개, TMP36 1개, 아두이노우노
• 내용 : 추가로 피에조 부저를 12번 핀에 연결한다.
• 공개회로도 : https://www.tinkercad.com/things/20FHbzZpihk(TMP36+스위치버턴+피에조부저)

12번 핀을 통해 피에조부저에 경보음을 출력한다.

2) 코딩

if(온도>50){
    tone(12,523,1000/8);     // 도음으로 8분음표(음길이)
    delay(1000/4*1.30);             
    noTone(12);            
}

온도가 50도 이상이면 경보음이 울리게 됩니다. tone()~noTone()으로 도음을 끊어서 경보음이 울리게 한다.

[수정소스] 추가된 코드영역만 표시 합니다.

... 생략
const int piezoPin = 12;

void setup(){
  ... 생략
}
void loop() {
 
  ... 생략
    
    //온도가 50도이상이면 경보음
  if(C>50){
    output();
    tone(piezoPin,523,1000/8);     // 도음으로 8분음표(음길이)
    delay(1000/4*1.30);             
    noTone(12);
    timeVal=millis();
  }
}
... 생략

나머지 부분은 위의 소스랑 동일합니다. 온도가 50도 이상이면 해당 온도/습도를 시리얼모니터에 출력하고 경보움이 짧게 끊어서 울린다. 그리고 현재시간을 이전시간으로 저장한다. 용도는 온도가 50도 이하로 떨어질때까지 지속적으로 경보음이 울리게 하는 목적이라고 생각하시면 되겠습니다.

3)결과

움짤로 만들다 보니깐 소리가 안나네요. 참고로 온도가 50도 이상이 되면 연속으로 온도와 습도가 출력되는 모습을 보실꺼에요. 그때 피에조부저도 같이 소리가 나온다고 생각하시면 될 듯 싶네요. 피에조부저가 울리는 명령문 안에 온도와 습도가 같이 출력되도록 하는 명령이 들어 있으니깐요. 그걸 감안하시고 연속으로 온도와 습도가 나오는 이미지 위치가 피에조부저가 같이 경고음을 울린다고 상상하시면 되겠습니다. 단점은 50이상인 경우는 연속적으로 온도가 출력되지만 50 이상이였다가 50이하로 떨어지면 2초후에나 결과를 확인할 수 있습니다. 스위치 버턴을 눌러서 바로 결과를 확인할 수 있지만 2초간의 딜레이 시간이 주어지기 때문에 이부분은 또다른 if문 락을 걸어서 50이상였다가 이하로 떨어지는 순간에 if문 락이 걸린 문장이 수행되어 현재온도를 출력되게 수정하면 됩니다. 이부분은 코딩하지 않았습니다. 숙제로 한번 이문제를 해결해 보세요.

5. 온도계에 LCD16x2 연결

1) 회로도

• 준비물 : LCD16x2 모듈 1개, 피에조 부저 1개, 스위치버턴 1개, TMP36 1개, 아두이노우노
• 내용 : LCD 16x2모듈의 핀을 아두이노와 연결한다.
• 사전학습 : [아두이노] LCD16x2 (LiquidCrystal) 제어
• 공개회로도 : https://www.tinkercad.com/things/bDw0caLiMb5(TMP36+스위치버턴+피에조부저+LCD16x2)

//LiquidCrystal(rs, enable, d4, d5, d6, d7)
LiquidCrystal lcd(3, 4, 8, 9, 10, 11);

핀이름을 잘보시고 해당 핀을 연결하시면 됩니다. 어려우시다면 위 링크된 사전학습 자료에 가셔서 사전학습을 하고 오세요.

선 연결이 좀 복잡하실꺼에요. 그래서 위에서 부터 나눠서 회로도를 순차적으로 만들었네요.

3) 코딩

LCD16x2 모니터 출력하기 위해서는

#include <LiquidCrystal.h>

//LiquidCrystal(rs, enable, d4, d5, d6, d7) 
LiquidCrystal lcd(3, 4, 8, 9, 10, 11);

데이터 4개의 핀으로 해서 글자를 출력합니다.

void setup(){
  lcd.begin(16,2); //가로x세로
  lcd.setCursor(0, 0); //시작위치 첫번째줄의 0번째칸 위치에서 시작
  lcd.print("Hello World"); //시작위치에서 글자를 순서대로 출력
  delay(1000); 
  lcd.clear(); //출력된 값을 지움
}   

위 주석을 잘 확인하시면 됩니다.

 void output(){
   lcd.clear(); //LCD16x2에 값을 지우기
   lcd.setCursor(0, 0); //첫번째줄의 0번째 칸 위치
   lcd.print("C : "); //문자열 출력
   lcd.setCursor(6, 0); // 첫번째 줄 6번째 칸 위치
   lcd.print(C);  //C(온도값) 출력
   lcd.setCursor(0, 1); //두번째줄의 0번재 칸 위치
   lcd.print("F : "); //문자열 출력
   lcd.setCursor(6, 1); //두번째줄의 6번째 칸 위치
   lcd.print(F);  
 }

사용자 정의 output() 함수는 위에서는 Serial 모니터에 출력했다면 이제는 LCD16x2에 출력되어야 하기 때문에 Serial 대신에 lcd로만 변경해주시면 됩니다 lcd은 젤 처음 LCD16x2 객체변수로 선언한 네임입니다. 주석으로 다 달아놓았으니깐 간단히 읽어보시면 됩니다.

lcd.setCursor(칸, 줄) : 줄, 칸의 위치를 가리킴
lcd.print(값) : 줄, 칸의 위치에 값을 출력

이 두개의 함수만 알면 쉽게 LCD16x2에 값을 출력할 수 있습니다.

4) 종합소스

#include <LiquidCrystal.h>

//LiquidCrystal(rs, enable, d4, d5, d6, d7) 
LiquidCrystal lcd(3, 4, 8, 9, 10, 11);

const int switchPin = 2;
const int piezoPin = 12;
unsigned long timeVal=0;
float V=0;
float C=0;
float F=0;

void setup() {
  pinMode(switchPin, INPUT_PULLUP);

  lcd.begin(16,2);
  lcd.setCursor(0, 0);
  lcd.print("Hello World");
  delay(1000);
  lcd.clear();
}

void loop() { 
  V =fmap(analogRead(A0),0,1023,0,5); //map함수 원리를 이용한 다이렉트 Voltage계산
  //float V = analogRead(A0)*5.0/1023;

  C = (V-0.5)*100;  //섭씨 C = (F-32)*1.8;
  F = C*9.0/5.0+32; //화씨 F = C*1.8+32;
    
  if(digitalRead(switchPin)== LOW){
    output();
    timeVal=millis();
    delay(500);
  }
  if(millis()-timeVal>=2000){
    output();  
    timeVal=millis();
  }
  if(C>50){
    output();
    tone(piezoPin,523,1000/8);     // 도음으로 8분음표(음길이)
    delay(1000/4*1.30);             
    noTone(12);
    timeVal=millis();
  }
}  
 void output(){
   lcd.clear();
   lcd.setCursor(0, 0);
   lcd.print("C : ");
   lcd.setCursor(6, 0);
   lcd.print(C);  
   lcd.setCursor(0, 1);
   lcd.print("F : ");
   lcd.setCursor(6, 1);
   lcd.print(F);  
  }

float fmap(long x, long in_min, long in_max, float out_min, float out_max)
{
  return (x - in_min) * (out_max - out_min) /(float) (in_max - in_min) + out_min;
}

5) 결과

이 결과도 움짤로 하려다가 소리도 들리는 결과물이 있어야 할 것 같아서 그냥 동영상으로 결과물을 만들었네요.

마무리

세 파트로 나눠서 설명을 했네요. 한번에 전부 다 합쳐진 상태로 설명을 하면 좀 코딩을 어려워 할 수 있고 회로도도 너무 복잡해 보일 수 있기 때문에 나눠서 설명했습니다. 결과적으로 post가 좀 길어졌네요. 설명도 사전학습내용은 다 뺄려고 했는데 빼면은 설명이 안되는 부분이 있어서 어쩔 수 없이 복습차원으로 추가했네요.

아무튼 @uuu95님이 실험하시는 주제에 대해 가상시뮬레이터로 재미있게 실험을 하셨습니다. 참고로 세파트로 나누어진 회로도는 공개회로도에 다 있으니깐 가셔서 한번 가상시뮬레이터를 직접 돌려보시고 어떻게 동작하는지 살펴보셨으면 합니다.

[아두이노] 수위 센서(Water Level Sensor) 제어

• 온라인 가상시뮬레이터 : https://www.tinkercad.com

오늘은 수위 센서라는 물의 높이를 측정할 수 있는 부품 사용법에 대해서 간단히 살퍄보도록 하겠습니다. 수위 센서 표면에 물이 닿는 위치에 따라서 수위 센서의 값이 0~1023사이의 값을 발생합니다. 그 값을 통해서 물의 높이를 알 수 있는 부품입니다. 실험에 사용한 수위 센서는 정교한 측정 도구는 아니고 간단히 물의 높이를 측정하는 실험용 모듈로 생각하시면 될 듯 싶습니다.

본격적으로 Water Level Sensor에 대해 알아보도록 할까요.

1. Water Level Sensor

• Water Level Sensor 출처 : http://omnigatherum.ca/wp/?p=228

위 센서는 세개의 핀이 있는데 보시는 것처럼 (-,+,S)로 표시되어 있는데 해당핀들은 (Gnd, Vcc, Analog Signal)로 구성되어 있습니다. 수위 센서의 표면에 긴선 모양을 보이실 꺼에요 이 센서의 전류가 공급되면 물이 이 센서의 표현에 닿게 되면은 전류의 값이 변화게 됩니다. 물은 전류가 흐르기 때문에 이 선들이 물에 접촉하게되면 전류의 값이 증가하게 됩니다. 물의 접촉에 따라서 늘어날수록 전류의 값은 커지겠지요. 이때 Analog Signal Pin을 통해서 그 전류의 값이 읽게 됩니다. 아두이노에서는 아날로그 신호를 읽을 때 0~1024사이의 값을 읽게 됩니다.

아날로그 읽기 : analogRead(아날로그핀)

2. Water Level Sensor 회로도

• 준비물 : Water Level Sensor 1개, 아두이노우노
• 내용 : A0에 Analog Signal Pin을 연결한다.

선 연결은 위 그림처럼 단순합니다.

3. 코딩

• analogRead(A0) : A0핀에서 아날로그 신호(0~1024) 읽음

analogRead(A0) 함수로 아날로그 읽기함수로 수위 센서의 전류 0~1023사이의 값을 읽게 됩니다. 전류 신호값이 크면 클수록 물의 수위가 높아집니다.

void setup(){
  Serial.begin(9600);
}
void loop(){
  int waterSensorVal = analogRead(A0); 
  Serial.print("Water Sensor : ");
  Serial.println(waterSensorVal);
  delay(100);  
}

4. 결과

post를 등록할려고 보니 영상물에 결과에서 글자가 오타가 났네요. water를 warter라고 오타 났네요.(ㅋㅋ)

Water Level Sensor 문제점

수위 센서는 사실 접촉식은 별로 추천하지 않습니다. 그 이유는 물을 직접적으로 접촉하기 때문에 장시간 물에 접촉된다면 부식과 이물질이 붙는 문제도 있고 물기가 남아있으면 정상적인 결과가 나오지 않습니다. 즉, 수위가 낮아져도 물기가 수위 센서에 뭍어있기 때문에 그 물기가 수위 값으로 판정해 버린다는 문제점이 있습니다. 영상을 보시면 컵에서 꺼낸 수위 센서에서 계속 수위 값을 출력되고 화장지로 닦으니깐 수위 센서값이 0으로 되돌아가는 것을 영상에서 보실 수 있을 꺼에요. 그래서, 뭔가를 만들고 싶다면 접촉식보다 비접촉식으로 수위를 측정하는 센서를 사용하는게 좋습니다. 비접촉식 수위 센서는 구글검색으로 통해서 한번 찾아보세요.

마무리

오늘이 간단히 이런 종류의 센서가 있다는 것을 알려드리려고 post에 담았습니다. 수위를 측정하는 방법이 단순하죠. 수위 센서로 여러분들은 어떤 것을 하고 싶으신지 한번 상상을 해보세요. 일상에서 물의 높이를 측정하는 곳은 물탱크가 있는 곳에서 일반적으로 사용합니다. 물탱크의 물의 수위를 측정하여 물탱크의 물을 채울 수 있습니다. 즉, 물의 높이를 측정하면 물의 용량을 조절할 수 있게 됩니다. 물이 있는 곳에서는 수위센서가 요긴하게 사용됩니다. 수위조절에 필요한 물의 대한 기본 데이터를 제공하기 때문이지요. 수위를 측정하는 예를 들면, 댐이나 강에서 물의 높을 측정할 수 있다면 수문 제어를 할 수 있습니다. 수문을 언제 개방하도 닫을 것인지를요. 수경재배의 물탱크에도 식물에 물 공급과 양액 공급에 조절을 할 수 있겠죠.

수위 센서를 어디에 쓸지 상상을 해보세요. 제가 이 수위 센서를 사용한다면 물기에 대해 센서의 값의 변화가 일어나기 때문에 물기 감지센서로도 사용하면 것은 어떨까 하고 상상하게 되네요. 즉, 물기가 없으면 수위센서의 값은 0이 됩니다. 하지만 물기가 수위센서에 닿게 되면은 닿은 면적에 대한 전류값이 발생하고 수위센서의 물기에 대한 일정 전기신호가 만들어 집니다. 물기 감지센서로 사용하면 좋겠죠.

여러분들도 물에 대해 측정할 수 있는 이 수위 센서를 가지고 어떤 것을 만들 지 한번 상상의 나래를 펼쳐 보세요.