개발하는 디자이너의 DIY 일상

만능 리모컨을 만들기로 해놓고 정말 많은 시간이 흘렀습니다.

2019.11.10 - [DIY/Arduino] - [DIY] 아두이노로 만능 (통합) 리모콘 만들기 1/3

2019.11.10 - [DIY/Arduino] - [DIY] 아두이노로 통합(만능) 리모콘 만들기 2/3

2020.06.17 - [DIY/Arduino] - [DIY] 아두이노로 통합(만능) 리모콘 만들기 3/3

결국 이번에도 완성되지 못한채 프로젝트가 끝나는것이 안타까워 마무리를 해보기로 합니다.

(리모컨 신호 따기, 각 기능별 동작 확인하는 과정 등은 위 링크의 글을 참고해 주세요)

사실 로직도 다 만들었고 테스트도 어느정도 완료 했으니 하드웨어만 만들면 되는데요, 항상 그렇지만 적당한 하드웨어를 구성하는 것이 쉬운일은 아닙니다. 3D 프린터가 있긴 하지만 완전한 완성품을 만드는게 쉽지 않더군요.

저처럼 DIY 를 하는 경우에는 개조에 적당한 다른 하드웨어를 가지고 튜닝을 하는게 더 쉽고 완성도도 높다 보니 적당한 녀석을 찾는 것이 일이었습니다.

그러던 와중!

완전 적당한 녀석을 발견했지 뭡니까.

바로 알리에서 구입한 18650 배터리를 이용한 파워뱅크 케이스 입니다. 병렬로 2개의 18650 배터리가 들어가게 되는데 그 중 하나를 넣지 않아도 정상 동작하기에 다른 한쪽에 아두이노 나노와 필요한 부품을 넣으면 되겠다 싶더군요.

그냥 이전에 만들었던거 집어 치우고 새로 만들겁니다.

바로 작업에 들어갑니다.

아래 사진처럼 납작한 택트 스위치를 덮개 위에 얹으면 될 것 같았습니다.

음.. 그럴싸 하군요.

하지만 작업의 편의성을 위해 만능 기판 위에 올리기로 합니다.

네.. 요게 더 작업이 수월할 것 같군요.

요렇게 가기로 합니다.

표면에 스위치가 그대로 노출되면 예쁘지 않으니 덮개를 만들어야 겠습니다.

잽싸게 3D 모델링을 한 다음 바로 3D 프린터로 프린트 해 봅니다.

네.. 잘 맞는 군요. (몇차례 수정이 있었습니다)

그럼 이제 만능 기판위에 스위치와 인디케이터용 LED 를 납땜해 봅니다.

양면으로 사용가능한 만능 기판이므로 위쪽에 버튼과 LED 를 모두 붙여 준 뒤 아래 쪽에서 실제 배선을 하기로 합니다.

지금 보이는 모든 점퍼 선은 그라운드에 연결할 예정이에요. 

그리고 인디케이터 용으로 LED 를 장착 했는데요, 위쪽에 보이는 4개는 각각 제가 선택한 제품을 표시하도록 하고 아래쪽 한개는 동작 할 때마다 신호가 나가는지 확인하기 위한 용도로 사용하기로 하였습니다.

워낙 SMD 부품이 작아 삐뚤빼뚤 하긴 하지만 뭐 큰 문제는 없습니다.

실제 버튼별 기능 목록과 각 기능별로 전달될 신호는 위와 같습니다.

뒷면에서 보면 위와 같은 모양으로 버튼들이 배치되어 있습니다. 헷갈리지 않도록 저렇게 만들어 놓고 배선을 시작하기로 합니다.

이제 실제 아두이노와 연결을 해야 겠죠?

파워뱅크 덮개 중앙을 뚫어 배선이 내부로 들어갈 수 있도록 해 주었고요,

안쪽에 아두이노 나노를 넣어서 문제 없이 장착이 될 지 확인해 봅니다.

네.. 아주 딱 맞아 떨어집니다.

이제 살인적인 납땜이 남았군요.

배선 시작 

..

분노의 땜질 시작!!!!

..

네.

끝냈습니다.

.

.

네.. 아두이노의 거의 모든 포트와 연결이 되어있기 때문에 정말 힘들었습니다.

신호를 전달 하는 케이블은 사용하지 않는 랜선 내부의 케이블을 이용해서 연결해 주었습니다.

그리고 아두이노 나노의 USB 연결 포트를 노출 시켜서 나중에라도 프로그래밍을 손쉽게 변경할 수 있도록 했고요, 구석쪽으로 IR LED 를 꺼내주었습니다.

배터리를 넣고 동작이 되는지 테스트 해보았습니다.

네 일단 동작은 되는 것 같군요.

TV 에 와서 동작하는지도 확인해 보았고,, 약간의 코드 수정이 필요해 보이는 것을 제외하면 버튼들은 모두 동작하는 것을 확인했습니다.

그리고 단순히 리모컨으로써의 기능 뿐만 아니라 간단한 플래쉬와 레이저 포인터 기능도 동작하도록 할 생각입니다.

리모컨은 항상 거실의 중심에 있으니 플래쉬가 필요할 때도 빠르게 찾아 사용할 수 있을 것입니다.

최종 마무리가 된 모습은 아래와 같습니다.

좌측 하단에 1W LED 를 넣어주고 아래쪽으로 푸쉬락 기능이 있는 스위치를 하나 달아 주었고요,

좌측 위쪽으로는 레이저 다이오드를 넣은뒤 택트 스위치를 연결해주었습니다.

배터리에서 아두이노로 전원을 공급하기 위해 5V 승압 보드를 연결해서 전원 공급을 해주게 됩니다. 물론 스압 보드와 배터리 사이에 푸쉬락 기능이 있는 스위치를 하나 달아 주었습니다.

이렇게 하면 일반 USB 충전기를 이용해서 리모컨을 충전할 수 있으며 만약 배터리가 방전되어 교체가 필요하더라도 18650 배터리만 교체하면 되므로 사용성이나 유지보수도 용이한 구성이 되겠습니다.

UI 디자인 올리기

이제 슬슬 마무리를 해야하는데요,

어떤 버튼이 어떤 동작을 하는지 알아야 하지 않겠습니까? 그래서 전면부 UI 디자인을 해보았습니다.

이래뵈도 디자이너 아뉘겠습니까?

일러스트로 버튼의 위치에 맞게 UI 를 그려보았습니다.

좌측에 뒤집혀 있는 그림은 뭘까요?

조금뒤에 알려드리겠습니다.

일단 프린트해서 크기와 위치, 배치 등이 적당한지 확인해 봅니다.

또 실제 버튼의 모양, 위치, 기능이 모두 정상 동작하는지 최종 확인을 해봅니다.

그럼 이제 OHP 필름을 꺼내 프린트를 다시 합니다!

네. 바로 OHP 필름입니다.

자 OHP 필름에도 출력이 잘 되었습니다.

그럼 출력된 면에 

띠용~ 락카가 등장했네요.

네 출력된 면에 백색 락카를 칠해주면 

칠해주면~

그리고 뒤집으면 ~ 

쨔쟌~

요렇게 반짝 반짝 하는 예쁜 그래픽을 볼 수 있답니다. 손으로 눌르거나 해도 지워질 염려가 없지요.

요렇게 만들어진 전면부를 제작한 리모컨 위에 똭 붙여 주면

완 to the 성!

오예~

완성 되었습니다.

사실 처음 계획이랑 전원 스위치 와 제품 변경 기능이 뒤바뀌긴 했지만 뭐 괜찮습니다.

부가기능들을 볼까요? 

오~예! 오~ 예!

모두 잘 동작 합니다. ㅋㅋ

며칠에 한번씩 배터리 방전을 막기 위해 핸드폰 충전기로 배터리를 충전해 주면 끝

네.. 이렇게 마무리가 되었습니다.

어휴 생각보다 힘들었지만 이제 거실 테이블 위에 널브러져 있는 리모컨들을 치울 수 있다고 생각하니 후련 합니다.

끝으로 최종으로 적용한 아두이노 소스코드를 아래에 올립니다.

상당히 긴 코드가 되어 버렸네요. 

#include <boarddefs.h>
#include <IRremote.h>
#include <IRremoteInt.h>
#include <ir_Lego_PF_BitStreamEncoder.h>
#include <EEPROM.h>
/*
 * IRremote: IRsendDemo - demonstrates sending IR codes with IRsend
 * An IR LED must be connected to Arduino PWM pin 3.
 * Version 0.1 July, 2009
 * Copyright 2009 Ken Shirriff
 * http://arcfn.com
 */
/*
 * tv (NEC)
 * power :      0x2DF10EF, 32
 * input :      0x2DFD02F, 32
 * chnnel up :  0x2DF00FF, 32
 * chnnel dn :  0x2DF807F, 32
 * volumn up :  0x2DF40BF, 32
 * volumn dn :  0x2DFC03F, 32
 * OK :         0x2DF22DD, 32
 * sw up :      0x2DF02FD, 32
 * sw dn :      0x2DF827D, 32
 * sw left :    0x2DFE01F, 32
 * sw right :   0x2DF609F, 32
 * 
 * android tv (NEC)
 * power :      0x807F02FD, 32
 * sw up :      0x807F6897, 32
 * sw dn :      0x807F58A7, 32
 * sw left :    0x807F8A75, 32
 * sw right :   0x807F0AF5, 32
 * sw OK :      0x807FC837, 32
 * back :       0x807F9867, 32
 * volumn up :  0x807F18E7, 32
 * volumn dn :  0x807F08F7, 32
 * 
 * 
 * lonpoo speaker
 * power :      0x40BF807F, 32
 * volumn up :  0x40BF50AF, 32
 * volumn dn :  0x40BFD02F, 32
 * bt :         0x40BFA05F, 32
 * bt esc :     0x40BF906F, 32
 * opt :        0x40BF20DF, 32
 * 
 * 
 * LED
 * tv :     9
 * tv box : 10
 * btv :    11
 * spk :    12
 * 
 * input
 * s01 
 * 
 * 
 * 
 * 
 */

#include <IRremote.h>

const int s01 = 0;
const int s02 = 18;   // select sw 
const int s03 = 1;
const int s04 = 2;
const int s05 = 19;
const int s06 = 4;
const int s07 = 5;
const int s08 = 6;
const int s09 = 7;
const int s10 = 8;
const int s11 = 14;
const int s12 = 15;
const int s13 = 16;
const int s14 = 17;
//LED
const int L00 = 9;    // TV
const int L01 = 10;   // TV BOX
const int L02 = 11;   // BTV
const int L03 = 12;   // LONPOO SPEAKER

//
// define sw value
int sw_01;
int sw_02;
int sw_03;
int sw_04;
int sw_05;
int sw_06;
int sw_07;
int sw_08;
int sw_09;
int sw_10;
int sw_11;
int sw_12;
int sw_13;
int sw_14;

bool canWorking_01 = true;
bool canWorking_02 = true;
bool canWorking_03 = true;
bool canWorking_04 = true;
bool canWorking_05 = true;
bool canWorking_06 = true;
bool canWorking_07 = true;
bool canWorking_08 = true;
bool canWorking_09 = true;
bool canWorking_10 = true;
bool canWorking_11 = true;
bool canWorking_12 = true;
bool canWorking_13 = true;
bool canWorking_14 = true;
// 
int productIdx = 0; //0 : TV / 1: TV BOX / 2: BTV / 3: SPK

int addr = 0;
bool chkon = false;
IRsend irsend;

void setup()
{
  pinMode(s01, INPUT_PULLUP);
  pinMode(s02, INPUT_PULLUP);
  pinMode(s03, INPUT_PULLUP);
  pinMode(s04, INPUT_PULLUP);
  pinMode(s05, INPUT_PULLUP);
  pinMode(s06, INPUT_PULLUP);
  pinMode(s07, INPUT_PULLUP);
  pinMode(s08, INPUT_PULLUP);
  pinMode(s09, INPUT_PULLUP);
  pinMode(s10, INPUT_PULLUP);
  pinMode(s11, INPUT_PULLUP);
  pinMode(s12, INPUT_PULLUP);
  pinMode(s13, INPUT_PULLUP);
  pinMode(s14, INPUT_PULLUP);
  
  pinMode(L00, OUTPUT);
  pinMode(L01, OUTPUT);
  pinMode(L02, OUTPUT);
  pinMode(L03, OUTPUT);
  
  pinMode(13, OUTPUT);
  //EEPROM.write(0, productIdx);  
  productIdx = EEPROM.read(0);

  sw_01 = HIGH;
  sw_02 = HIGH;
  sw_03 = HIGH;
  sw_04 = HIGH;
  sw_05 = HIGH;
  sw_06 = HIGH;
  sw_07 = HIGH;
  sw_08 = HIGH;
  sw_09 = HIGH;
  sw_10 = HIGH;
  sw_11 = HIGH;
  sw_12 = HIGH;
  sw_13 = HIGH;
  sw_14 = HIGH;
  
  canWorking_01 = true;
  canWorking_02 = true;
  canWorking_03 = true;
  canWorking_04 = true;
  canWorking_05 = true;
  canWorking_06 = true;
  canWorking_07 = true;
  canWorking_08 = true;
  canWorking_09 = true;
  canWorking_10 = true;
  canWorking_11 = true;
  canWorking_12 = true;
  canWorking_13 = true;
  canWorking_14 = true;

  Serial.begin(9600);
  Serial.println(productIdx);

  
}

void loop() {

  digitalWrite(13, LOW);
  
  sw_01 = digitalRead(s01);
  sw_02 = digitalRead(s02);
  sw_03 = digitalRead(s03);
  sw_04 = digitalRead(s04);
  sw_05 = digitalRead(s05);
  sw_06 = digitalRead(s06);
  sw_07 = digitalRead(s07);
  sw_08 = digitalRead(s08);
  sw_09 = digitalRead(s09);
  sw_10 = digitalRead(s10);
  sw_11 = digitalRead(s11);
  sw_12 = digitalRead(s12);
  sw_13 = digitalRead(s13);
  sw_14 = digitalRead(s14);
  

  // change product
  if (sw_02 == HIGH) {
    chkon = true;
    ledON(productIdx);
  }else{
    if (chkon)
    {
      productIdx++;
      if (productIdx > 3) productIdx = 0;
      EEPROM.write(0, productIdx);
      chkon = false;
    }
    ledON(productIdx);
  }
  
  if (sw_01 == HIGH) {    
    canWorking_01 = true;
  }else{
    digitalWrite(13, HIGH);
    if (canWorking_01)
    {
      press_S01(productIdx);
      canWorking_01 = false;
    }
  }
  if (sw_03 == HIGH) {   
    canWorking_03 = true; 
  }else{
    digitalWrite(13, HIGH);
    if (canWorking_03)
    {
      press_S03(productIdx);
      canWorking_03 = false;
    }
  }
  if (sw_04 == HIGH) {
    canWorking_04 = true;     
  }else{
    digitalWrite(13, HIGH);
    if (canWorking_04)
    {
      press_S04(productIdx);
      canWorking_04 = false;
    }
  }
  if (sw_05 == HIGH) {  
    canWorking_05 = true;    
  }else{
    digitalWrite(13, HIGH);
    if (canWorking_05)
    {
      press_S05(productIdx);
      canWorking_05 = false;
    }
  }
  if (sw_06 == HIGH) {    
    canWorking_06 = true;  
  }else{
    digitalWrite(13, HIGH);
    if (canWorking_06)
    {
      press_S06(productIdx);
      canWorking_06 = false;
    }
  }
  if (sw_07 == HIGH) {  
    canWorking_07 = true;    
  }else{
    digitalWrite(13, HIGH);
    if (canWorking_07)
    {
      press_S07(productIdx);
      canWorking_07 = false;
    }
  }
  if (sw_08 == HIGH) {    
    canWorking_08 = true; 
  }else{
    digitalWrite(13, HIGH);
    if (canWorking_08)
    {
      press_S08(productIdx);
      canWorking_08 = false;
    }
  }
  if (sw_09 == HIGH) {  
    canWorking_09 = true;   
  }else{
    digitalWrite(13, HIGH);
    if (canWorking_09)
    {
      press_S09(productIdx);
      canWorking_09 = false;
    }
  }
  if (sw_10 == HIGH) {    
    canWorking_10 = true;   
  }else{
    digitalWrite(13, HIGH);
    if (canWorking_10)
    {
      press_S10(productIdx);
      canWorking_10 = false;
    }
  }
  if (sw_11 == HIGH) {    
    canWorking_11 = true;   
  }else{
    digitalWrite(13, HIGH);
    if (canWorking_11)
    {
      press_S11(productIdx);
      canWorking_11 = false;
    }
  }
  if (sw_12 == HIGH) {    
    canWorking_12 = true;  
  }else{
    digitalWrite(13, HIGH);
    if (canWorking_12)
    {
      press_S12(productIdx);
      canWorking_12 = false;
    }
  }
  if (sw_13 == HIGH) {    
    canWorking_13 = true;  
  }else{
    digitalWrite(13, HIGH);
    if (canWorking_13)
    {
      press_S13(productIdx);
      canWorking_13 = false;
    }
  }
  if (sw_14 == HIGH) {    
    canWorking_14 = true;  
  }else{
    digitalWrite(13, HIGH);
    if (canWorking_14)
    {
      press_S14(productIdx);
      canWorking_14 = false;
    }
  }

	delay(10); //5 second delay between each signal burst
}

void press_S14 (int idx) // vol -
{
  switch (idx) {
  case 0:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x2DFC03F,32);   // tv vol -
    break;
  case 1:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x807F06F9,32);  // tv box vol -
    break;
  case 2:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x1FE42BD,32);  // BTV box vol -
    break;
  case 3:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x40BFD02F,32);  //  spk vol -
    break;
  default:
    // statements
    break;
  }
}

void press_S13 (int idx) // chnl -
{
  switch (idx) {
  case 0:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x2DF807F,32);   // tv chnl -
    break;
  case 1:
    //for (int i = 0; i < 1; i++) irsend.sendNEC(0x807F18E7,32);  // tv box vol +
    break;
  case 2:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x1FE827D,32);   // Btv chnl -
    break;
  case 3:
    //for (int i = 0; i < 1; i++) irsend.sendNEC(0x40BF50AF,32);  //  spk vol +
    break;
  default:
    // statements
    break;
  }
}

void press_S12 (int idx) //vol +
{
  switch (idx) {
  case 0:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x2DF40BF,32);   // tv vol +
    break;
  case 1:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x807F18E7,32);  // tv box vol +
    break;
  case 2:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x1FEC23D,32);   // Btv vol +
    break;
  case 3:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x40BF50AF,32);  //  spk vol +
    break;
  default:
    // statements
    break;
  }
}

void press_S11 (int idx) // chnl +
{
  switch (idx) {
  case 0:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x2DF00FF,32);   // tv chnl +
    break;
  case 1:
    //for (int i = 0; i < 1; i++) irsend.sendNEC(0x807F58A7,32);  // tv box
    break;
  case 2:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x1FE02FD,32);   // Btv chnl +
    break;
  case 3:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x40BF906F,32);  //  spk bt esc
    break;
  default:
    // statements
    break;
  }
}

void press_S10 (int idx) // down
{
  switch (idx) {
  case 0:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x2DF827D,32);   // tv down
    break;
  case 1:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x807F58A7,32);  // tv box down 
    break;
  case 2:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x1FE52AD,32);   // Btv down
    break;
  case 3:
    //for (int i = 0; i < 1; i++) irsend.sendNEC(0x40BF20DF,32);  //  
    break;
  default:
    // statements
    break;
  }
}

void press_S09 (int idx) // right
{
  switch (idx) {
  case 0:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x2DF609F,32);   // tv right
    break;
  case 1:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x807F0AF5,32);  // tv box right 
    break;
  case 2:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x1FE32CD,32);   // Btv right
    break;
  case 3:
    //for (int i = 0; i < 1; i++) irsend.sendNEC(0x40BF20DF,32);  // tv box up 
    break;
  default:
    // statements
    break;
  }
}
void press_S08 (int idx) // ok
{
  switch (idx) {
  case 0:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x2DF22DD,32);   // tv ok
    break;
  case 1:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x807FC837,32);  // tv box ok 
    break;
  case 2:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x1FE629D,32);   // Btv ok
    break;
  case 3:
    //for (int i = 0; i < 1; i++) irsend.sendNEC(0x40BF20DF,32);  // tv box up 
    break;
  default:
    // statements
    break;
  }
}

void press_S07 (int idx) // arrow left
{
  switch (idx) {
  case 0:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x2DFE01F,32);   // tv left
    break;
  case 1:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x807F8A75,32);  // tv box left 
    break;
  case 2:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x1FED22D,32);   // Btv left
    break;
  case 3:
    //for (int i = 0; i < 1; i++) irsend.sendNEC(0x40BF20DF,32);  // tv box up 
    break;
  default:
    // statements
    break;
  }
}
void press_S06 (int idx)
{
  switch (idx) {
  case 0:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x2DF02FD,32);   // tv back
    break;
  case 1:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x807F9867,32);  // tv box back 
    break;
  case 2:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x1FE728D,32);   // Btv back
    break;
  case 3:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x40BF20DF,32);  // spk OPT 
    break;
  default:
    // statements
    break;
  }
}

void press_S05 (int idx) // arrow up
{
  switch (idx) {
  case 0:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x2DF02FD,32);   // tv up
    break;
  case 1:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x807F6897,32);  // tv box up 
    break;
  case 2:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x1FE926D,32);   // Btv up
    break;
  case 3:
    //irsend.sendNEC(0x40BFA05F,32);  
    break;
  default:
    // statements
    break;
  }
}

void press_S04 (int idx)
{
  switch (idx) {
  case 0:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x2DFD02F,32);   //외부입력
    break;
  case 1:
    //for (int i = 0; i < 1; i++) irsend.sendNEC(0x2DF10EF,32);   
    break;
  case 2:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x1FE40BF,32);   // Btv home
    break;
  case 3:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x40BFA05F,32);   // blue tooth
    break;
  default:
    // statements
    break;
  }
}

void press_S03 (int idx) // power
{

  irsend.sendNEC(0x2DFD02F,32); // tv 외부입력
  // S03 번은 편의를 위해 항상 외부입력으로 동작한다
  /*
  switch (idx) {
  case 0:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x2DF10EF,32);   // tv power
    break;
  case 1:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x807F02FD,32);   // tv box power
    break;
  case 2:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x1FE807F,32);   // Btv power1 
    break;
  case 3:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x40BF807F,32);   
    break;
  default:
    // statements
    break;
  }*/
}
void press_S01 (int idx) //  S01
{
  Serial.println(productIdx);
  switch (idx) {
  case 0:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x2DF10EF,32);   
    break;
  case 1:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x807F02FD,32);   
    break;
  case 2:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x1FE807F,32);   
    break;
  case 3:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x40BF807F,32);   
    break;
  default:
    // statements
    break;
  }
}
void ledON (int idx)
{
  digitalWrite(L00, LOW);
  digitalWrite(L01, LOW);
  digitalWrite(L02, LOW);
  digitalWrite(L03, LOW);
  switch (idx) {
  case 0:
    digitalWrite(L00, HIGH);
    break;
  case 1:
    digitalWrite(L01, HIGH);
    break;
  case 2:
    digitalWrite(L02, HIGH);
    break;
  case 3:
    digitalWrite(L03, HIGH);
    break;
  default:
    // statements
    break;
  }
}

이상으로 아두이노 만능 리모컨 만들기를 마칩니다. 

자 어느새 목표했던 RC headtracking FPV 만들기의 종착역을 다가가고 있습니다.

앞서 소개해 드렸던 2축 서보마운트 제작 및 서보컨트롤과 mpu6050 을 이용하여 2축 서보모터를 제어하는 내용은 잘 보셨나요? 아직 못보신분은 아래 글을 참고 부탁드립니다

2022.01.31 - [DIY/Arduino] - [아두이노]2축 서보모터 초간단 제어하기, 간단한 프레임 제작까지

2022.01.31 - [DIY/Arduino] - [아두이노]mpu6050 을 이용하여 2축 서보모터 제어하기

오늘은 앞에서 소개해드린 mp6050 을 이용하여 측정한 회전 정보를 이용하여 서보모터를 제어하는 것을 응용하여 무선으로 서보모터를 제어하는 과정을 소개해 드릴 예정인데요, 여기에서는 아주아주 놀랍고 멋진 무선 송수신 칩인 nrf24L01 칩을 이용하여 구현을 할 계획입니다.

nrf24L01 칩의 경우 저렴하면서도 놀라운 성능을 보여주는 아주아주 애정하는 부품입니다.

실제로 해당 칩을 이용하여 RC 카 조종장치와 수신 장치를 만들기도 한적이 있습니다. 제어되는 범위, 거리도 아주 훌륭하고 신호 수준도 좋으며 중요한 것은 1개의 송신부에서 여러개의 수신장치를 제어할 수 있는 멋진 칩 입니다. 게다가 송신과 수신을 하나의 칩에서 지원하고 있으므로 양방향 통신을 구현하는데에도 어려움이 없습니다.

일단 오늘 도전할 목표는 앞서 말씀 드렸던것 처럼 mp6050 자이로 센서에서 측정된 회전 값을 NRF24L01 칩을 이용하여 보내고 또다른 NRF24L01 칩에서 이 신호를 받아 2축 서보모터를 제어하는 과제가 되겠습니다.

이전 포스팅에서 소개해 드린 것에서 무선 송수신이 추가만 되었을 뿐 크게 달라지는 건 없습니다.

무선 송수신을 위한 라이브러리는 웹상에도 많이 있고요, 아래 첨부해둔 라이브러리를 받으셔서 바로 내문서-아두이노 폴더에 넣으셔도 됩니다.

자 이젠 무선 송수신 칩이 들어오면서 배선이 조금 복잡해 집니다.

차근차근 따라 오시면 됩니다.

NRF24L01 칩에 대하여

여기서 NRF24L01 칩 외에 추가 준비물이 필요한데요, 준비물은 바로 10uf 전해콘덴서 입니다. 이 전해 콘덴서를 nrf24l01 의 전원 (3.3v) 단에 연결을 해 주셔야 문제 없이 잘 동작합니다. 용량은 가능하면 10uf 로 준비해 주세요, 제가 처음 테스트 할 때 전해 콘덴서 용량이야 뭔들 중요하랴... 싶어 용량이 안 맞는 부품을 적당히 연결해서 해보았지만 잘 안되서 정말 골머리를 썩었는데요, 10uf 콘덴서를 달면 정말 거짓말처럼 동작이 잘 됩니다. 

물론 소스코드나 배선에 실수는 없어야 겠지요.

한가지더, nrf24l01 칩은 몇가지 타입이 있는데요, 크기가 작은 SMD 타입과 일반 핀이 달려있는 Dip 타입, 그리고 원거리 송수신이 가능한 PA LN 타입이 있습니다. 핀 구성은 모두 동일하고 배열만 약간 차이가 있으며 코드는 모두 동일하게 지원 합니다. 저는 소형화된 부품이 좋아 보통은 SMD 타입 부품을 사용하고요, 배선이 일렬로 되어 있어 브래드 보드 등에 테스트 하기도 편리한 점이 장점이라 할 수 있습니다. 해외 어떤 사용자 분은 성능도 SMD 타입이 좋다고 하시는데.. 실제로 그런지는 잘 모르겠습니다. (- -)>;;

DIP 타입을 이용하실 경우 확장 보드가 있으면 조금더 편리하게 사용하실 수 있지만 부피가 조금 커진다고 보시면 되고, PA-LNA 보드는 DIP 타입의 확장보드와 호환이 가능하며 아래쪽에 SMD 타입과 같은 보드 실장을 위한 연결 단자가 있으므로 보드에 바로 연결이 가능합니다. PA-LNA 보드의 경우 NRF24L01 칩이 기본 탑제되어 있고 위에서 말씀드린것과 같이 코드 및 배선은 동일하게 하시면 되며 원거리까지 송수신이 가능하므로 무선으로 멀리까지 신호를 보내고 받아야 하는 경우 사용하시면 되겠습니다.

배선 시작

자 이제 배선을 해보겠습니다.

먼저 제가 사용할 SMD 타입은 만능기판에 바로 핀을 꼽기가 어려운데요. 그래서 생각해낸 것이 아래와 같은부품을 이용하는 것 입니다.

가운데 있는 보드를 가운데를 잘라주고 반쪽만 사용하게 되는데요, 이 pcb 를 이용하면 NRF24L01 SMD 칩의 핀 간격과 정확히 일치 하게 되며 실제로 사용하지 않는 가장 오른쪽 IRQ 는 무시하고 왼쪽부터 맞추어 납을 흘려넣어 납땜을 해주면 됩니다.

하단의 구멍에는 1.24mm pin 이 정확히 맞으므로 일렬로 배열된 핀을 만능기판에 꼽아 사용할 수 있게 됩니다.

위에서 말씀드린 10uF 전해 콘덴서까지 연결하게 되면 아래와 같은 모양이 됩니다.

NRF24L01 칩은 아래와 같은 핀 구성을 하고 있고요, 각각 아두이노와 그림처럼 연결하시면 됩니다.

CE, CSN 은 각각 7번 8번에 연결하여야 하는데 이 두핀은 위치가 바뀌어도 상관 없습니다. 코드상에서 정의해준 핀의 번호와 일치하기만 하면 되고요, 나머지 핀은 지정된 핀에 연결하시면 됩니다.

저처럼 SMD 타입을 사용할 경우 전원은 아두이노의 반드시 3.3V 에 연결해 주셔야 하고 dip 타입을 사용하시는 경우 확장보드를 이용하시면 5V 를 바로 연결하셔도 되며 10uf 전해 콘덴서는 필요 없습니다.

특별 초대손님이 있다고?

자~ 오늘의 특별 초대손님이 계신데요...

두구두구

두구

두구

짜잔~

네~ 바로 아두이노로 제작한 RC 카 수신기 입니다. 물론 송신기도 아두이노로 만들었었습니다.

해당 보드는 왼쪽 상단에 3핀 소켓을 통해 ESC 로부터 전원을 입력 받고 신호 선을 통해 모터스피드(속도)를 제어하게 되고요, 우측 아래 두개의 3핀 소켓을 통해 조향서보와 2-speed gear 의 조작용 서보에 연결하게 제작되었습니다. 오늘은 해당 두개의 서보모터 핀을 이용하여 x,y 축을 제어해 보도록 할 계획입니다. 보드 중간에 가로로 보이는 구멍이 NRF24L01 보드를 장착하기 위한 소켓입니다.

무선 모듈을 연결하면 아래와 같은 모양이 됩니다.

한동안 즐겁게 가지고 놀았었는데요, 일반적인 RC 카 수신기에 비하면 덩치가 조금 크기는 하지만 4개의 2pin 포트를 통해 헤드라이트나 후미등, 좌우측 깜박이 등을 이 보드 하나로 제어할 수 있어 멀펑 보드가 별도로 필요하지 않으므로 나름 쓸만하다고 할 수 있겠습니다. 

언제 시간이 나면 핀 사진의 커넥터 대신 일반 적인 RC 카에 많이 사용하는 후타바 짹이나 JR 커넥터 등을 이용하여 부피를 줄여볼 계획입니다. 나중에 작업하게 되면 소개해 드리겠습니다.,

배선은 송신부, 수신부 두개의 아두이노에 동일하게 해주시면 되고 송신부와 수신부는 코드에서 정의를 해주게 됩니다.

배선이 완료된 송신부 입니다.

네 사진상으로는 조금 복잡하지만 기존 설명드린데로 잘 연결 하셨다면 어려움 없이 잘 하실 수 있으리라 믿습니다.

수신기 쪽을 볼까요?

네 수신부에는 예상하시다 시피 두개의 서보모터와 NRF24L01 보드가 연결되어 있습니다.

코딩을 해보자

코드를 볼까요?

먼저 송신부 입니다. 기존 작성해 놓은 mp6050 코드에 무선 송수신 코드만 추가할 예정입니다.

// init for nrf24L01 
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>

RF24 radio(8,7);  //  CE, CSN 
const byte address[6] = "00001"; //송신기와 수신기 동일한 주소 사용
int msg[8]; 


//pinout smd version
//3.3v  --- 3.3v
//GND  ---  GND
//CE   ---  8
//CSN  ---  7
//SCK  ---  13
//MOSI ---  11
//MISO ---  12
//IRQ  ---  none

// init for mpu6050
#include "I2Cdev.h"
#include "MPU6050_6Axis_MotionApps_V6_12.h"
#if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
#include "Wire.h"
#endif

MPU6050 mpu;
#define OUTPUT_READABLE_YAWPITCHROLL
#define INTERRUPT_PIN 2  // use pin 2 on Arduino Uno & most boards
#define LED_PIN 13 // (Arduino is 13, Teensy is 11, Teensy++ is 6)
bool blinkState = false;

// MPU control/status vars
bool dmpReady = false;  // set true if DMP init was successful
uint8_t mpuIntStatus;   // holds actual interrupt status byte from MPU
uint8_t devStatus;      // return status after each device operation (0 = success, !0 = error)
uint16_t packetSize;    // expected DMP packet size (default is 42 bytes)
uint16_t fifoCount;     // count of all bytes currently in FIFO
uint8_t fifoBuffer[64]; // FIFO storage buffer

// orientation/motion vars
Quaternion q;           // [w, x, y, z]         quaternion container
VectorInt16 aa;         // [x, y, z]            accel sensor measurements
VectorInt16 gy;         // [x, y, z]            gyro sensor measurements
VectorInt16 aaReal;     // [x, y, z]            gravity-free accel sensor measurements
VectorInt16 aaWorld;    // [x, y, z]            world-frame accel sensor measurements
VectorFloat gravity;    // [x, y, z]            gravity vector
float euler[3];         // [psi, theta, phi]    Euler angle container
float ypr[3];           // [yaw, pitch, roll]   yaw/pitch/roll container and gravity vector

volatile bool mpuInterrupt = false;     // indicates whether MPU interrupt pin has gone high
void dmpDataReady() {
  mpuInterrupt = true;
}

void setup() {

  // join I2C bus (I2Cdev library doesn't do this automatically)
  #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
    Wire.begin();
    Wire.setClock(400000); // 400kHz I2C clock. Comment this line if having compilation difficulties
  #elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE
    Fastwire::setup(400, true);
  #endif
  
  Serial.begin(115200);
  while (!Serial); // wait for Leonardo enumeration, others continue immediately

 
  // initialize device
  Serial.println(F("Initializing I2C devices..."));
  mpu.initialize();
  pinMode(INTERRUPT_PIN, INPUT);

  // verify connection
  Serial.println(F("Testing device connections..."));
  Serial.println(mpu.testConnection() ? F("MPU6050 connection successful") : F("MPU6050 connection failed"));

  // wait for ready
  Serial.println(F("\nSend any character to begin DMP programming and demo: "));
  //while (Serial.available() && Serial.read()); // empty buffer
  //while (!Serial.available());                 // wait for data
  //while (Serial.available() && Serial.read()); // empty buffer again

  // load and configure the DMP
  Serial.println(F("Initializing DMP..."));
  devStatus = mpu.dmpInitialize();

  // supply your own gyro offsets here, scaled for min sensitivity
  mpu.setXGyroOffset(51);
  mpu.setYGyroOffset(8);
  mpu.setZGyroOffset(21);
  mpu.setXAccelOffset(1150);
  mpu.setYAccelOffset(-50);
  mpu.setZAccelOffset(1060);
  // make sure it worked (returns 0 if so)
  if (devStatus == 0) {
    // Calibration Time: generate offsets and calibrate our MPU6050
    mpu.CalibrateAccel(6);
    mpu.CalibrateGyro(6);
    Serial.println();
    mpu.PrintActiveOffsets();
    // turn on the DMP, now that it's ready
    Serial.println(F("Enabling DMP..."));
    mpu.setDMPEnabled(true);

    // enable Arduino interrupt detection
    Serial.print(F("Enabling interrupt detection (Arduino external interrupt "));
    Serial.print(digitalPinToInterrupt(INTERRUPT_PIN));
    Serial.println(F(")..."));
    attachInterrupt(digitalPinToInterrupt(INTERRUPT_PIN), dmpDataReady, RISING);
    mpuIntStatus = mpu.getIntStatus();

    // set our DMP Ready flag so the main loop() function knows it's okay to use it
    Serial.println(F("DMP ready! Waiting for first interrupt..."));
    dmpReady = true;

    // get expected DMP packet size for later comparison
    packetSize = mpu.dmpGetFIFOPacketSize();
  } else {
    // ERROR!
    // 1 = initial memory load failed
    // 2 = DMP configuration updates failed
    // (if it's going to break, usually the code will be 1)
    Serial.print(F("DMP Initialization failed (code "));
    Serial.print(devStatus);
    Serial.println(F(")"));
  }

  // Radio setup
  //setupRadio();
  
  msg[0] = 0; 
  msg[1] = 0; 
  msg[2] = 0; 
  msg[3] = 0;
  msg[4] = 0; 
  msg[5] = 0; 
  msg[6] = 0; 
  msg[7] = 0;
  
  radio.begin();
  radio.openWritingPipe(address); //이전에 설정한 5글자 문자열인 데이터를 보낼 수신의 주소를 설정
  radio.setPALevel(RF24_PA_MIN); //전원공급에 관한 파워레벨을 설정합니다. 모듈 사이가 가까우면 최소로 설정합니다.
  radio.stopListening();  //모듈을 송신기로 설정
}

void loop() {

  // if programming failed, don't try to do anything
  if (!dmpReady) return;
  // read a packet from FIFO
  if (mpu.dmpGetCurrentFIFOPacket(fifoBuffer)) { // Get the Latest packet 

  #ifdef OUTPUT_READABLE_YAWPITCHROLL
    // display Euler angles in degrees
    mpu.dmpGetQuaternion(&q, fifoBuffer);
    mpu.dmpGetGravity(&gravity, &q);
    mpu.dmpGetYawPitchRoll(ypr, &q, &gravity);
    
    float angle_x = (ypr[0] * 180 / M_PI) * -1 + 90 ; //* -1 + 90;
    float angle_y = (ypr[1] * 180 / M_PI) + 90 ; //* -1 + 30;    
   
    if (angle_y < 60) angle_y = 60;
    if (angle_y > 120) angle_y = 120;
    
    if (angle_x < 30) angle_x = 30;
    if (angle_x > 150) angle_x = 150;

    msg[0] = int(angle_x);
    msg[1] = int(angle_y);
    
    radio.write(&msg, sizeof(msg)); //해당 메시지를 수신기로 보냄
    
    Serial.print("ypr\tx:");
    Serial.print(int(angle_x));
    Serial.print("\ty:");
    Serial.print(int(angle_y));
    Serial.print("\t");
    
    

  #endif
  }
  Serial.println(".");
  delay(10);
  
}

아무래도 셋업해주는 부분이 약간 생소할 수 있겠습니다만 저도 인터넷에서 긁어 모은 코드를 조합하였을 뿐 상세하게는 모른답니다. 중요한 것은 노드의 이름을 정해주었는데요, 수신부에서도 동일한 이름을 지정해 주어야 한다는 점과, 다른 분들과의 혼선을 막기 위하여는 해당 이름을 유니크한 이름으로 정해주는 것이 좋다는 것 정도 입니다.

제가 사용한 코드는 (존경하는)새다리 님의 코드를 참고 하였고 NRF24L01 로 검색하시면 해외 여러 개발자 분들이 올려주신 멋진 코드들이 많이 있으므로 참고하시면 좋을 것 같습니다.

이번에는 수신부 입니다.

 #include <SPI.h> 
#include <nRF24L01.h>
#include <RF24.h>

RF24 radio(8,7); //  CE, CSN 
const byte address[6] = "00001"; //송신기와 수신기 동일한 주소 사용
int msg[8]; 

//pinout smd version
//NRF24L01    ARDUINO
//3.3v    ---   3.3v
//GND     ---   GND
//CE      ---   8
//CSN     ---   7
//SCK     ---   13
//MOSI    ---   11
//MISO    ---   12
//IRQ     ---   none

#include <Servo.h>

Servo myservo_LR;   
Servo myservo_UD; 

int pin_servo_LR = 9;
int pin_servo_UD = 10;

void setup() {
  radio.begin();
  radio.openReadingPipe(1, address);
  radio.setPALevel(RF24_PA_MIN); //
  // RF24_PA_MIN / RF24_PA_LOW / RF24_PA_HIGH / RF24_PA_MAX
  radio.startListening(); //수신기로 설정
  
  //setting 2 servo
  myservo_LR.attach(pin_servo_LR);
  myservo_LR.write (90);
  myservo_UD.attach(pin_servo_UD);
  myservo_UD.write (90);
}

void loop() {

  if (radio.available()) {
    radio.read(&msg, sizeof(msg));
    for(int i = 0; i < 8 ; i ++)
    {
      Serial.print(msg[i]);
      Serial.print("\t");
    }

    int angle_x = int(msg[0]);
    int angle_y = int(msg[1]);
    
    if (angle_x < 150 && angle_x > 30)
    {
      myservo_LR.write (angle_x);          
    }
    if (angle_y < 120 && angle_y > 60)
    {
      myservo_UD.write(angle_y);
    }
  }
}

수신부는 서보모터 제어코드와 무선 수신 코드가 있는데요, 송신부에 비하면 간단하게 구성되어 있습니다.

무선 패킷이 들어오면 동작하도록 되어 있으므로 수신에 실패하면 아무런 동작도 하지 않도록 되어 있으며 만약을 대비하여 잘못된 값이 수신되더라도 서보모터에 전달되지 않도록 최대, 최소 범위를 제한하여 서보에 입력되도록 하였습니다.

과연 잘 동작 할런지???

동작하는 모습을 볼까요?

ㅋㅋ 네 잘 되는군요. 이제 뭐 거의 다 온 것 같습니다.

다음 편에는 카메라를 연결하고 차량안에 장착할 준비를 한번 해봐야 겠습니다.

머릿속에 아주 좋은 그림이 있거든요~ ㅎㅎ

기대해 주세요 ~ ^^

2022.01.31 - [DIY/Arduino] - [아두이노]2축 서보모터 초간단 제어하기, 간단한 프레임 제작까지

2022.01.31 - [DIY/Arduino] - [아두이노]mpu6050 을 이용하여 2축 서보모터 제어하기

2020.10.29 - [DIY] - [DIY] 오래된 다목적 캠핑용 랜턴 ▶ LED 램프, 충전식으로 교체하기

2019.10.13 - [DIY] - [DIY] 아이방 수면등 만들기 (feat. 아이그림)

아두이노와 같은 마이크로 칩을 이용하여 무엇인가를 해보다 보면 정말 놀라운 경험들을 많이 하게 됩니다. 그 중 하나가 바로 mpu6050 같은 센서가 될 수 있겠습니다.

요 조그만 칩을 이용하여 기울어진 정도나 각도, 나침반과 같은 방향 등을 알아낼 수 있다니 놀랍지 않으신가요?

오늘 소개해 드릴 내용은 RC Headtracking FPV 만들기의 두번째 스탭인 6축 자이로 센서를 이용한 움직임 신호 받기와 해당 신호를 이용 하여 2축 서보모터를 제어하는 내용 입니다.

헤드트래킹 무선 FPV 를 만들기 위하여 지난 포스트에서 2축 서보모터 마운트를 아주~ 아~~~주 간단하게 만드는 방법을 소개해 드렸었는데요, 해당 프레임에 부착한 서보모터를 이번 시간에 자이로 센서를 이용하여 제어를 해보도록 하겠습니다.

2022.01.31 - [DIY/Arduino] - 2축 서보모터 초간단 제어하기, 간단한 프레임 제작까지

먼저 라이브러리를 받아야 할텐데요,  아래 첨부된 라이브러리를 다운 받으셔서 바로 내문서- Arduino-libraries 폴더에 압축을 해제하여 넣으시면 됩니다. 

혹시 Wire.h 라이브러리가 없으시면 아래 파일도 다운 받으시면 됩니다.

mpu6050 라이브러리를 받으시면 예제 소스코드가 들어있을 텐데요, 저는 여기서 시작 이후 실제 회전하는 값, 즉 상대 회전 값만을 이용할 계획이고 아래의 코드를 이용하여 회전 값을 추출할 계획입니다. 본 포스트에서 소개해 드리는 예제 외에도 라이브러리가 제공하는 예제 코드를 실행해보시면 다른 창작품 제작에도 도움이 될 수 있을 것 같습니다. ^^

기존 조이스틱 대신 이번에는 mpu6050 보드를 연결해야 하는데요. I2C 방식으로 연결할 것이므로 선은 4가닥만 있으면 되며 vcc 는 3.3v 에 연결해 주시고, GND 는 아두이노의 GND 에 연결, SDA 는 아두이노의 A4 번에 SCL 은 아두이노의 A5에 연결하시면 됩니다. (다른 핀은 안됩니다. 정확히 A4, A5에 연결해 주셔야 합니다)

코딩을 해보자

mpu6050 에 대한 자세한 내용은 이미 여러분들께서 다루어 주시고 있으므로 저는 실제 이번 프로젝트에 사용한 코드만 보여드리도록 하겠습니다.

#include <Servo.h>
#include "I2Cdev.h"
#include "MPU6050_6Axis_MotionApps_V6_12.h"
#if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
#include "Wire.h"
#endif

MPU6050 mpu;
#define OUTPUT_READABLE_YAWPITCHROLL
#define INTERRUPT_PIN 2  // use pin 2 on Arduino Uno & most boards
#define LED_PIN 13 // (Arduino is 13, Teensy is 11, Teensy++ is 6)
bool blinkState = false;

// MPU control/status vars
bool dmpReady = false;  // set true if DMP init was successful
uint8_t mpuIntStatus;   // holds actual interrupt status byte from MPU
uint8_t devStatus;      // return status after each device operation (0 = success, !0 = error)
uint16_t packetSize;    // expected DMP packet size (default is 42 bytes)
uint16_t fifoCount;     // count of all bytes currently in FIFO
uint8_t fifoBuffer[64]; // FIFO storage buffer

// orientation/motion vars
Quaternion q;           // [w, x, y, z]         quaternion container
VectorInt16 aa;         // [x, y, z]            accel sensor measurements
VectorInt16 gy;         // [x, y, z]            gyro sensor measurements
VectorInt16 aaReal;     // [x, y, z]            gravity-free accel sensor measurements
VectorInt16 aaWorld;    // [x, y, z]            world-frame accel sensor measurements
VectorFloat gravity;    // [x, y, z]            gravity vector
float euler[3];         // [psi, theta, phi]    Euler angle container
float ypr[3];           // [yaw, pitch, roll]   yaw/pitch/roll container and gravity vector

volatile bool mpuInterrupt = false;     // indicates whether MPU interrupt pin has gone high
void dmpDataReady() {
  mpuInterrupt = true;
}

Servo myservo_LR;   // streering servo
Servo myservo_UD;  // 2speed gear box servo

int pin_servo_LR = 9;
int pin_servo_UD = 10;

int pin_x = A3;
int pin_y = A4;
int angle_x = 512 ;
int angle_y = 512 ;

void setup() {

  // join I2C bus (I2Cdev library doesn't do this automatically)
  #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
    Wire.begin();
    Wire.setClock(400000); // 400kHz I2C clock. Comment this line if having compilation difficulties
  #elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE
    Fastwire::setup(400, true);
  #endif
  
  Serial.begin(115200);
  while (!Serial); // wait for Leonardo enumeration, others continue immediately

 
  // initialize device
  Serial.println(F("Initializing I2C devices..."));
  mpu.initialize();
  pinMode(INTERRUPT_PIN, INPUT);

  // verify connection
  Serial.println(F("Testing device connections..."));
  Serial.println(mpu.testConnection() ? F("MPU6050 connection successful") : F("MPU6050 connection failed"));

  // wait for ready
  Serial.println(F("\nSend any character to begin DMP programming and demo: "));
  //while (Serial.available() && Serial.read()); // empty buffer
  //while (!Serial.available());                 // wait for data
  //while (Serial.available() && Serial.read()); // empty buffer again

  // load and configure the DMP
  Serial.println(F("Initializing DMP..."));
  devStatus = mpu.dmpInitialize();

  // supply your own gyro offsets here, scaled for min sensitivity
  mpu.setXGyroOffset(51);
  mpu.setYGyroOffset(8);
  mpu.setZGyroOffset(21);
  mpu.setXAccelOffset(1150);
  mpu.setYAccelOffset(-50);
  mpu.setZAccelOffset(1060);
  // make sure it worked (returns 0 if so)
  if (devStatus == 0) {
    // Calibration Time: generate offsets and calibrate our MPU6050
    mpu.CalibrateAccel(6);
    mpu.CalibrateGyro(6);
    Serial.println();
    mpu.PrintActiveOffsets();
    // turn on the DMP, now that it's ready
    Serial.println(F("Enabling DMP..."));
    mpu.setDMPEnabled(true);

    // enable Arduino interrupt detection
    Serial.print(F("Enabling interrupt detection (Arduino external interrupt "));
    Serial.print(digitalPinToInterrupt(INTERRUPT_PIN));
    Serial.println(F(")..."));
    attachInterrupt(digitalPinToInterrupt(INTERRUPT_PIN), dmpDataReady, RISING);
    mpuIntStatus = mpu.getIntStatus();

    // set our DMP Ready flag so the main loop() function knows it's okay to use it
    Serial.println(F("DMP ready! Waiting for first interrupt..."));
    dmpReady = true;

    // get expected DMP packet size for later comparison
    packetSize = mpu.dmpGetFIFOPacketSize();
  } else {
    // ERROR!
    // 1 = initial memory load failed
    // 2 = DMP configuration updates failed
    // (if it's going to break, usually the code will be 1)
    Serial.print(F("DMP Initialization failed (code "));
    Serial.print(devStatus);
    Serial.println(F(")"));
  }

  
  myservo_LR.attach(pin_servo_LR);
  myservo_LR.write (90);
  myservo_UD.attach(pin_servo_UD);
  myservo_UD.write (90);
}

void loop() {

  // if programming failed, don't try to do anything
  if (!dmpReady) return;
  // read a packet from FIFO
  if (mpu.dmpGetCurrentFIFOPacket(fifoBuffer)) { // Get the Latest packet 

  #ifdef OUTPUT_READABLE_YAWPITCHROLL
    // display Euler angles in degrees
    mpu.dmpGetQuaternion(&q, fifoBuffer);
    mpu.dmpGetGravity(&gravity, &q);
    mpu.dmpGetYawPitchRoll(ypr, &q, &gravity);
    
    float angle_x = (ypr[0] * 180 / M_PI) * -1 + 90 ; //* -1 + 90;
    float angle_y = (ypr[1] * 180 / M_PI) + 90 ; //* -1 + 30;    
   
    if (angle_y < 60) angle_y = 60;
    if (angle_y > 120) angle_y = 120;
    
    if (angle_x < 30) angle_x = 30;
    if (angle_x > 150) angle_x = 150;

    myservo_LR.write (angle_x);  
    myservo_UD.write (angle_y);
  
    Serial.print("ypr\tx:");
    Serial.print(int(angle_x));
    Serial.print("\ty:");
    Serial.print(int(angle_y));
    Serial.print("\t");
    
    

  #endif
  }
  Serial.println(".");
  delay(10);
  
}

코드가 조금 길어졌기는 하지만 기존 첫번째 과정에 mpu6050 관련 코드가 추가되었고 크게 달라진것은 없습니다. mpu6050 관련된 상세한 코드는 저도 잘 모르고요. 그냥 예제에서 긁어온 코드입니다. ^^;; (불필요한 내용이 들어 있을 수도 있고요... 어쨌든 위의 코드면 잘 실행됩니다.)

위 코드에서 아래 부분이 실제 회전 값을 받아서 내가 원하는 각도로 세팅하는 부분인데요. 입력 값이 최초 실행된 위치로부터의 상대 값이므로 가만히 있으면 0 이 들어오게 됩니다. 그러므로 기준이 되는 앵글을 더해주면 기준이 되는 앵글에  + - 로 각도가 변경되게 되며 저의 x 위치에 -1 이 들어있는 것은 서보 모터의 설치 방향 때문에 방향을 뒤집어 주기 위함입니다. Y 값 역시 서보모터의 방향이 저와 다른 방향으로 설치되어 반대로 움직인다면 센서의 값에 -1 을 곱해 주시면 됩니다.

	float angle_x = (ypr[0] * 180 / M_PI) * -1 + 90 ; //* -1 + 90;
    float angle_y = (ypr[1] * 180 / M_PI) + 90 ; //* -1 + 30;    
   
    if (angle_y < 60) angle_y = 60;
    if (angle_y > 120) angle_y = 120;
    
    if (angle_x < 30) angle_x = 30;
    if (angle_x > 150) angle_x = 150;

어쨌든 서보모터 제어를 위한 부분은 이전에 소개해 드린 코드 그대로 가져왔고요, 회전 정보를 받아 서보모터로 전달하는 과정에서 축의 기준위치, 방향 등을 변경해주기 위하여 위와 같이 약간의 코드가 추가되었습니다. if 구문을 이용하여 입력된 값 + 기준값이 모터의 최대 회전 범위 보다 크다면 최대 회전 범위의 값으로 설정을 해주면 됩니다.

저는 기준위치를 서보의 상하, 좌우 90도를 기준으로 설정하였고 상하로는 ±30도씩, 좌우로는 ±60도씩 움직일 수 있도록 하였습니다.

참 쉽죠?

과연 잘 동작할런지??

자 구동 되는 모습은 아래와 같습니다.

아주 잘 되죠?

기존 조이스틱이 움직이는 범위에 비하여 출력되는 범위가 리니어 하지 않은지 휙휙 움직이던것에 비하면 아주 아주 잘 동작하는 것을 확인할 수 있습니다. 

이렇게 mpu6050 6축 지자기센서를 이용하여 2축 서보모터를 제어하는 것까지 마쳤습니다. 

생각보다 어렵지 않죠?

다음은 이제 대망의 무선 입니다. 

다음 포스트를 기대해 주세요.

2022.01.31 - [DIY/Arduino] - [아두이노]NRF24L01을 이용하여 무선으로 mpu6050 신호 전달하기

2022.01.25 - [DIY/RC] - 20년된 엔진 RC 카 전동화 해보자 [kyosho inferno]

2022.01.31 - [DIY/Arduino] - 2축 서보모터 초간단 제어하기, 간단한 프레임 제작까지

2020.11.29 - [DIY/RC] - 1/24 완벽한 RC 카 RGT ADVENTURE

뭔가 목표가 생기면 과정이 분명해 진다.

RC 카에 헤드트래킹을 이용한 FPV 를 구현하려는 목표가 생기고나니 과정을 잘 정리하는게 필요하겠다 싶어 포스트를 남깁니다.

우선 첫번째 스텝으로 2축으로 제어가 가능한 서보모터 마운트를 만들고 서보모터를 제어하는 것인데요, 이미 언젠가 사용하겠지 싶어서 구입해 둔 2축 서보모터 마운트가 있기에 이 부분은 간단히 해결될 거라 생각했습니다.

바로 중국에서 구입한 이런 제품이죠.

9g 서보모터를 이용하여 바로 연결이 가능하도록 나온 제품이고 약간 헷갈리기는 하지만 조립이 어렵지는 않습니다. 

그런데 너무 쉽게 생각한게 오산이었을까요?

일단 어떻게 연결해도 약간 제가 생각하는 머리의 움직임과 괴리감이 있었습니다. 

사람은 목이라는 놀라운 구조에 의해 상하좌우 회전이 거의 동일한 한 점에서 이루어 집니다. 심지어는 틸트까지 되죠, 3축이 하나의 구조에서 이루어지는 놀라운 구조가 아닐수 없습니다. 

제가 구입하였던 2축 서보 마운트는 그런 개념에서 완전히 빗나가 있더군요. 일단 x, y 축의 회전 축이 상당히 어긋나 있다는 점이 첫번째 문제점이었고 두번째로는 기본 각도가 수평에서 시작한다는 점 이었습니다.

위의 사진에서 보이는 것처럼 상단 평평한 면이 이미 최대 상향(y축) 각도인데요, 말하자면 더이상 고개를 들거나 또는 내리는건 불가능한 상태 입니다. 물론 90도를 꺽은 상태에서 카메라를 부착하는 방법도 있지만 그렇게 되면 축에서 더욱 멀어지게 되므로 이미 상당한 수준의 거북목이 진행된 것처럼 되어 버립니다. 무슨 목을 쭉 앞으로 뺀 거북이처럼 회전이 되게 되는 것이죠.

세번째 문제는 전체 부품의 부피가 너무 크다는 것인데요, RC 카 운전석 안에 장착을 해야 하는데 이런 저런 부품이 너무 자리를 많이 차지하더군요, 음...

2축 서보 연결을 위한 브라켓 제작하기

그래서 아주 간단한 구조에 부피도 아주 작은 2축 회전축을 만들어 보기로 하였습니다.

제 포스트를 보시는 분도 제가 만든 것처럼 구현하시면 축의 위치를 거의 같은 선상에 두고 사람의 머리처럼 제어되는 축을 만드실 수 있을 거에요.

저는 3D 프린터를 이용하여 핵심 부품을 출력하였습니다만, 구조상 그냥 L 자 꺽쇠를 이용하여 만드시는 것도 가능합니다. 필요하신 크기로 가공만 하면 되는 것이죠. 

저는 부품의 부피를 최소화 하기 위하여 서보모터의 고정 부품 안쪽으로 브라켓이 장착되도록 제작을 하였습니다.

이렇게 되면 상단의 서보모터는 Y 축(상하회전)을 제어하고 하단의 서보모터는 X 축(좌우회전)을 제어하게 되는데요, 우리의 목의 구조를 봐도 보통 회전은 귀를 중심으로 머리통이 상하로 움직이고 좌우 회전은 목 전체가 회전되므로 상대적으로 제가 만든것과 유사한 구조로 움직이는 것을 알 수 있습니다. 물론 사람의 목은 대단히 유연하고 훌륭한 관절이어서 상하회전이 꼭 한군데서 이루어지는 것은 아닙니다만 유사한 움직임이 구현되기는 합니다.

제가 만든 것처럼 브라켓의 상하 길이를 작게 만들게 되면 상하 회전 움직임에 제약이 있기는 합니다. 서보모터에 부딪힐 수 있기 때문인데요, 사람의 목이 상하로 180도를 움직이지 않는 것을 고려해보면 크게 문제될 것은 없어 보입니다.

만약 서보모터의 동작 범위 전체를 커버하기를 원하시면 브라켓의 상하 길이를 서보모터의 회전 반경보다 크게 제작하면 문제 없이 동작하게 됩니다.

아두이노와 연결을 해보자

자 이제 아두이노로 잘 제어가 되는지 확인해 보도록 하겠습니다.

2축 제어를 위하여 간단하게 2축 아날로그 조이스틱을 연결하고 제어를 해봅니다.

연결은 아래와 같이 하시면 됩니다.

소스코드는 아주 간단합니다.

아날로그 신호를 받아 서보모터를 움직이는 기본 소스코드 그대로 약간만 응용하면 구현이 가능합니다.

다만 저처럼 상하 움직임에 제한이 있는 경우는 서보로 가는 신호에 제한을 주어야 합니다.

#include <Servo.h>

Servo myservo_LR;   // streering servo
Servo myservo_UD;  // 2speed gear box servo

int pin_servo_LR = 9;
int pin_servo_UD = 10;

int pin_x = A3;
int pin_y = A4;
int angle_x = 512 ;
int angle_y = 512 ;
void setup() {

  myservo_LR.attach(pin_servo_LR);
  myservo_LR.write (90);
  myservo_UD.attach(pin_servo_UD);
  myservo_UD.write (90);
}

void loop() {
  angle_x = analogRead(pin_x);
  angle_y = analogRead(pin_y);
  
  angle_x = map(angle_x, 0, 1024, 30, 150);
  angle_y = map(angle_y, 0, 1024, 60, 120);

  myservo_LR.write (angle_x);  
  myservo_UD.write (angle_y);

  delay(10);
  
}

90도를 기준 각도로 하여 상하는 60~120도, 좌우는 30~150도의 움직임을 범위로 하였습니다.

자 이제 테스트를 해볼까요?

잘 동작하네요.

일단 첫번째 관문은 통과한 셈 입니다.

다음 편에는 mp6050 을 이용하여 회전한 각도 만큼 서보모터를 움직이는 방법을 알아보도록 하겠습니다.

아래 링크된 글을 이용하여 바로 보실 수 있습니다.

그럼 이만~

2022.01.31 - [DIY/Arduino] - [아두이노]mpu6050 을 이용하여 2축 서보모터 제어하기

2022.01.31 - [DIY/Arduino] - [아두이노]NRF24L01을 이용하여 무선으로 mpu6050 신호 전달하기

2020.06.29 - [DIY/Arduino] - C# 에서 아두이노로 시리얼 통신 하기

2020.10.28 - [DIY/Arduino] - 아두이노로 아이방 스탠드 개조하기 - 자동 꺼짐 기능

오늘 소개드릴 내용은 간단한 내용인데요.

아두이노 아날로그 핀을 이용하여 스텝모터 28BYJ-48 을 돌려보도록 하겠습니다.

보통은 디지털 핀을 이용하여 스텝모터를 돌리는 예제로 나와 있기 때문에 아날로그 핀을 이용하여 돌리는 방법이 궁금하신 분들이 계실 것 같아 포스팅을 하게 되었습니다.

준비물

• 아두이노 나노 (또는 우노)
• 28BYJ-48 stepper motor (5V)
• ULN2003 stepper moter driver
• 점퍼선 6개 (male --> female)

스텝모터는 아두이노 나노의 핀으로 직접 구동하기는 어렵습니다. 대부분의 모터가 사용하는 전력량이 아두이노의 핀의 출력 전류를 초과하기 때문에 직접 연결하시면 아두이노 보드가 망가질 수 있습니다. 그래서 드라이버를 사용하는데요. 보통 모터 드라이버에는 모터에 직접 전류를 인가할 전원을 연결하게 되어있고 2선, 또는 4선으로 신호를 보내 모터의 구동 방향이나 속도, 회전수 또는 각도 등을 입력하게 되죠. 오늘 사용할 ULN2003 의 경우 28BYJ-48 모터와 함께 판매하는 경우가 많으므로 모터와 함께 구입하시는 것이 좋겠습니다.

배선연결

연결은 아래와 같이 하시면 됩니다. 좌측은 아두이노, 우측은 ULN2003 드라이버라고 생각하시면 됩니다.

• A2 - IN1
• A3 - IN2
• A4 - IN3
• A5 - IN4
• 5V - 5V
• GND - GND

네 테스트 삼아 아두이노의 5V 전원을 바로 드라이버에 인가하였는데 문제 없이 잘 동작하는 것을 확인하였습니다. 나중에 문제가 되는지 테스트를 더 해본 뒤 문제가 된다면 변경하도록 해야할것 같아요.

코딩해보자.

해당 모터와 드라이버를 구동하기 위하여 별도의 라이브러리는 필요하지 않습니다. 아두이노에 기본 내장된 stepper 라이브러리를 사용하면 됩니다. 

28BYJ-48 모터는 2048 스텝이 한바퀴로 이루어져 있습니다. 스텝모터를 사용하는 가장 중요한 이유가 정밀한 회전 제어이기 때문에 한바퀴가 몇 스텝으로 이루어져 있는지를 아는 것이 중요합니다.

아두이노 아날로그 핀을 이용하여 간단하게 1초마다 한바퀴씩 돌리는 코드를 작성하면 아래와 같습니다.

#include <Stepper.h>

const int stepsPerRevolution = 64; 
Stepper myStepper(stepsPerRevolution, A5,A3,A4,A2); // 순서가 중요함

void setup() {
  //아날로그 핀을 이용하여 스텝 모터를 돌려본다.
  pinMode(A3, OUTPUT);
  pinMode(A3, OUTPUT);
  pinMode(A4, OUTPUT);
  pinMode(A5, OUTPUT);  
  myStepper.setSpeed(400);
}

void loop() {

  myStepper.step(2048); 

  delay(1000); 
}

간단하죠? 디지털핀을 이용하여 동작하는것과 다르지 않습니다. 아날로그 핀을 OUTPUT 으로 설정하여 디지털핀처럼 사용하겠다는 선언을 setup 에서 한번 해주면 됩니다.

참고로 A6, A7 은 아날로그 전용 핀이므로 위와 같이 설정해도 디지털핀으로 동작하지 않습니다.

1초마다 한바퀴씩 돌리기로 하였으므로 delay 를 넣어주었고, 한바퀴가 2048 스텝이라고 말씀 드렸으므로 위와 같이 2048 스텝을 돌려주시면 한바퀴씩 돌아갑니다. 만약 반대 방향으로 돌리고 싶으시면 -2048 과 같이 음수값을 넣어 주시면 되고요.

만약 3D 프린터 등에 사용하기 위하여 Lead screw 등을 연결할 경우 한바퀴가 2mm 를 이동하는 Lead screw 를 구입하셨다면 아래와 같이 거리만큼 스텝수를 나누어 이동시킬 수 있습니다.

한바퀴가 2mm 이므로 1mm 는 1024 스텝이 되겠죠.

//lead screw 의 스펙이 한바퀴당 2mm 를 이동하는 경우

int stepMM = 2048 / 2; // 2mm 가 한바퀴 이므로 기준 거리인 1mm 에 대한 스텝수 정의
float moveDistance_mm = 0;

// 1mm 를 이동한느 경우
myStepper.step(stepMM);

// 3mm 를 이동하는 경우
moveDistance_mm = 3;
myStepper.step(stepMM * moveDistance_mm);

// 0.1mm 를 이동하는 경우
moveDistance_mm = 0.1;
myStepper.step(stepMM * moveDistance_mm);

// 반대방향으로 10mm 이동해야 하는 경우
moveDistance_mm = -10;
myStepper.step(stepMM * moveDistance_mm);

역시 간단합니다. 이렇게 하면 1mm 를 이동하든, 0.3mm 를 이동하든 원하는 거리만큼 이동할 수 있게 됩니다.

만약 한바퀴에 8mm 를 이동하는 lead screw 를 구입하셨다면 맨 위의 stepMM 을 8로 나누어 주면 끝 입니다.

이해되시나요? 

네. 오늘은 이만 마치도록 하겠습니다. 궁금하신 내용은 뎃글로 문의 주시면 감사하겠습니다.

2019.06.01 - [DIY/Arduino] - 아두이노를 이용한 RC 카 만들기 1

2020.10.14 - [DIY] - DIY 상식 - 전기/전자에 대하여 알아보자 01

2020.10.28 - [DIY/Arduino] - 아두이노로 아이방 스탠드 개조하기 - 자동 꺼짐 기능

아이가 유치원에서 너무나 예쁜 스탠드를 만들어 왔습니다.. AAA 건전지가 들어가는 예쁜 스탠드.

스텐드 옆면에 예쁘게 그림을 그려서 본인이 자는 방에 가져다 두고는

"오늘부터 얘가 나를 지켜줄꺼야~"

ㅎㅎ

너무나 귀엽지 않습니까?

저녁이 되어 불을 켜보니 

헐랭

정말 오던 잠도 달아날 것 같은 푸르스름한 조명이더군요.

그래서 바꿔주기로 하였습니다.

• 일단 조명 색상은 따뜻한 색상으로 
• 밤새 켜져 있지 않도록 자동으로 소등될 것

요렇게 간단한 요구사항을 작성한뒤에 바로 실행에 들어갑니다.

필요한 재료는 간단합니다.

• Attiny85 (아두이노를 사용하기는 아깝잖아요?)
• 1W LED (5000K 미만)
• 50uf 전해 콘덴서 (작은걸로)
• 전선 조금.

간단하죠?

우선 자동으로 소등이 되어야 하고 소등이 될때는 서서히 어두워 지는 것이 좋을 것 같아 먼저 테스트를 해보기로 하였습니다.

우선 Attiny 에 대하여 간단히 알아 보아야 하는데요. attiny 는 아주 작은 마이크로프로세서로 칩안에 부트로더, 디지털핀, 아날로그핀, PWM 핀을 모두 갖춘 환상적인 부품입니다. 전압만 적당히 주면 칩하나로도 왠만한 동작이 가능한 녀석입니다. 나중에 이녀석을 이용한 작품들을 좀 소개해 드리겠습니다.

소스코드를 업로드 하기 위하여 별도의 프로그래머가 필요하긴 하지만 아두이노를 이용하여 간단하게 프로그래머로 사용할 수 있는 방법이 있으니 걱정마시고 진행하시면 됩니다.

저는PWM 핀에 일정 시간이 지나면 서서히 전압을 감소 시킨뒤 0V 까지 떨어지면 Attiny85를 sleep 모드로 진입시켜 초절전상태가 되도록 할 계획입니다. 

아두이노 ISP 만들기

아두이노를 ISP 와 같이 사용하여 Attiny85 를 프로그래밍 할 건데요. 간단합니다.

아두이노 예제에 있는 ArduinoISP 를 열어 주세요.

해당 소스를 본인의 아두이노 설정에 맞게 세팅한 뒤 업로드를 합니다. 

그런 다음 10uf 전해 콘덴서를 하나 준비해주시고

Arduino reset --  콘덴서의 + ,
Arduino GND -- 콘덴서의 - 를

연결한 뒤 Arduino 와 Attiny85의 각 핀을 아래와 같이 연결합니다.

• Arduino 5V   --  ATTiny85 Pin 8 (Vcc)
• Arduino GND -- ATTiny85 Pin 4 (GND)
• Arduino Pin 13 -- ATTiny85 Pin 8 (SCK)
• Arduino Pin 12 -- ATTiny85 Pin 7 (MISO)
• Arduino Pin 11 -- ATTiny85 Pin 6 (MOSI)
• Arduino Pin 10 -- ATTiny85 Pin 1 (Slave Reset)

전 브래드 보드에 매번 연결하는 것이 귀찮아서 간단한 보드를 하나 만들었습니다.

위 사진과 같이 만들어서 소켓에 아두이노 나노와 attiny85 를 끼웠다 뺐다 할 수 있게 했습니다.

참고로 사진에 보이는 attiny85 는 smd 타입으로 dip 타입보다 작고 가격도 조금 저렴합니다. 저는 smd 타입에 8핀 보드를 붙여서 사용하고는 합니다.

일단 이러면 코드 테스트를 위한 준비가 완료 되었습니다.

코딩을 해보자!

// this code for enter sleep mode
#include <avr/sleep.h>
#ifndef cbi
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#endif
#ifndef sbi
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
#endif

//setting variables
int ledPin = 0;    // LED connected to digital pin 9
float timer = 2400;
float maxBrightness = 255.0;
float a = 0;
float curX = 0;
float curY = 0;

void setup() {
  // 그래프의 기울기 값 계산
  a = maxBrightness / (timer*timer);
}

void loop() {
  curX++;
  curY = a * (curX*curX);
  
  analogWrite(ledPin, maxBrightness - curY);
  
  if (maxBrightness - curY < 1 )
  {
    analogWrite(ledPin, 0);
    system_sleep(); // sleep 모드 진입
  }
  delay(1000);
}

  void system_sleep()
  {
    cbi(ADCSRA, ADEN);                    // switch Analog to Digitalconverter OFF
    set_sleep_mode(SLEEP_MODE_PWR_DOWN);  // sleep mode is set here
    sleep_enable();
    sleep_mode();                         // System sleeps here
    sleep_disable();                      // System continues execution here when watchdog timed out 
    sbi(ADCSRA, ADEN);                    // switch Analog to Digitalconverter ON
  }

코드 위아래에 좀 눈에 익지 않은 코드가 있죠? 그 부분이 바로 sleep 모드 진입을 시키기 위한 코드입니다. attiny85 는 슬립 모드에 진입하면 놀라울 만큼 전기를 먹지 않기 때문에 아주 유용한 기능이 아닐 수 없습니다. sleep 모드에서 깨우기 위하여는 reset pin 에 GND 를 스위치 등으로 순간 연결해 주거나 전원을 껏다가 켜면 다시 최초 상태로 실행이 됩니다.

위에 타이머 부분이 전체 조명이 켜져있는 시간이되겠습니다. 다만 정확한 시간 조정은 안되고 대충 감으로 잡아야 하더군요. 현재 설정은 2400 초 인데요. 대략 40분 내외의 시간이 흐르면 소등됩니다. (한 30분 지나면 점점 어두워집니다)

loop 의 아래쪽에 현재 아날로그 출력값이 1보다 작아지면 sleep 모드로 진입하는 코드가 있고요.

그게 전부입니다. ㅋ

이제 attiny85 에 업로드를 해야하는데요. 

먼저 라이브러리가 없다면 추가를 해주어야 겠죠?

구버전용 라이브러리는 직접 받으셔야 하고요. 신버전은 json 을 추가해주고 설치를 하면 됩니다.

아래 경로에서 라이브러리 설치에 대한 내용을 확인하시면 됩니다.

highlowtech.org/?p=1695

보드는 attiny > attiny85 1Mhz 로 선택해 주시고요.

ISP 는 Arduino as ISP 를 선택해 주시면 됩니다.

그리고 업로드 고고

Hardware 개조 타임

이제 조명을 뜯어서 기존의 LED 를 떼어내고 Attiny 와 LED 를 부착해줄 차례 입니다.

당연한 이야기지만 먼저 배터리를 제거해 줍니다.

상단의 흰색 갓은 위로 잡아 당기면 그냥 빠집니다. 꽉 끼워져 있기는 한데 본드로 붙어있는 것은 아니더군요. 

아래쪽 나사를 모두 풀어주고 분리하면 위와 같은 상태입니다. 심플하네요.

스프링이 도망가지 않게 살살 열어 줍니다.

어쨌든 문제의 LED는 제거합니다.

크기도 엄청 크네요.

스위치에 붙어 있는 저항도 필요 없으니 떼어낼겁니다.

Attiny 에 배터리 (약 4.5v) 를 연결하니 전압이 불안정한지 동작이 원하는데로 되지 않아 굴러다니는 전해 콘덴서를 하나 붙여 주었습니다. 저는 50uf 를 달아 주었는데요. 적당히 아무거나 달아도 될 듯 합니다. 크기가 작아 소켓보드 아래에 쏙 들어가네요. ㅎㅎ

예전에 사두었던 LED 가 적당해 보여 달아주었습니다. 불빛도 너무 노랗지도 않고 방열판도 있으니 적당하다 생각되었습니다.

본딩을 해서 붙인뒤 고정을 위해 일단 테이프로 붙여 둡니다.

자 이제 거의 다 되었습니다.

스위치에 있는 저항을 테어내고 전선을 연결할 겁니다. 스위치로 - 가 연결되고 스위치의 다른 한쪽이 attiny 의 GND 에 연결되면 됩니다.

빨간선은 + 이므로 attiny 의 5V 에 연결합니다.

쨔잔~ 네 예쁘게 잘 들어옵니다.

Attiny 는 3M 양면 테이프로 붙여주면 완성입니다.

참고로 위와 같이 배선하시면 안됩니다. 잘못 배선한 사진인데요. LED 로 가는 굵은 빨간선이 사진상 오른쪽 맨 아래 핀에 연결이 되어야 합니다. ㅜㅜ

아래 사진에는 다시 제자리에 납땜을 했습니다.

자 이제 완성입니다.

배선에 약간 오류가 있기는 했지만 간단한 문제로 바로 해결하였습니다.

최종 결과물은?

ㅋㅋ 처음과 똑같네요. 다시봐도 그림이 너무 예쁩니다. 

어쨌든 이제 아이방에 놔주기만 하면 됩니다.

음~ 마음에 드는군요.

아이도 좋다며 매일 켜고 자고 있습니다. ㅎㅎ

자동으로 소등이 되니 배터리도 많이 먹지 않고요. 

만약 사용해보고 배터리를 많이 먹는다 싶으면 저항을 하나 달아줄 계획입니다. 저항은 아주 작은 용량의 저항이면 됩니다. 

자 간단한 작업으로 싸구려 같은 장난감에서 고급스러운 조명 색상에 타이머 기능까지 있는 멋진 조명으로 탈바꿈 하였습니다. 여러분도 한번 도전해 보시면 어떨까요?

그럼 오늘의 포스팅을 마칩니다. ~

2022.01.31 - [DIY/Arduino] - [아두이노]NRF24L01을 이용하여 무선으로 mpu6050 신호 전달하기

2019/10/13 - [DIY] - [DIY] 아이방 수면등 만들기 (feat. 아이그림)

2020/05/17 - [DIY] - [재활용] 고장난 LED 바 수리하기 > 화장대 조명 만들기

2020/03/23 - [DIY/Arduino] - Arduino(아두이노) 무작정 시작하기

2020/10/29 - [DIY] - [DIY] 오래된 다목적 랜턴 LED 램프, 충전식으로 교체하기

카테고리를 c# 으로 해야 할지 Arduino 로 해야할지 조금 고민이 되는 포스트  입니다.

음....

arduino 로 하는게 좋겠네요. 따지고 보면 C# 으로 만든 어플이 중요한게 아니라 아두에노에서 시리얼 통신으로 메시지를 받는게 중요한거니까요.

일단 한번 해보겠습니다. 자 시작하죠.

우선 이번 포스트에서 다룰 주제는 아래와 같습니다.

• C# 에서 시리얼 통신 사용하기
• 시리얼 통신으로 문자열 송신하기
• 아두이노에서 문자열 수신하기
• LCD 에 수신된 문자열 표시하기

간단하죠?

내용도 간단하니까 걱정 붙들어 매시고 따라오시면 됩니다.

C#에서 시리얼 통신 사용하기

먼저 비주얼 스튜디오를 열고 c# .net 플랫폼을 선택하신 후 window form 프로젝트를 하나 만들어 줍니다.

이렇게 하시고 만들기를 누르시면 윈도우 창이 나올텐데요.

간단하게 label, combobox, button 을 하나씩 만들어주고 사이즈를 적당히 조절합니다.

이제 폼이 실행되면 combobox 에 연결 가능한 시리얼 포트를 띄워 주겠습니다. 그리고 버튼을 누르면 해당 포트로 메시지를 전달하도록 할 예정입니다.

만들어진 UI 상단에 Form1 이라고 써있는 타이틀바를 더블클릭해 줍니다.

그럼 아래와 같이 Load 이벤트와 함께 함수가 하나 만들어 집니다.

이제 이번 포스트에 필요한 지시문과 콤보박스에 시리얼을 연결하는 방법을 소개해 드리겠습니다.

먼저 맨윗줄 지시문이 있는 그룹에 아래와 같이 추가해 줍니다.

using System.IO.Ports;

그런 다음 이번 예제에서 사용할 시리얼 포트를 만들어 주고요 

public partial class Form1 : Form
{
  private SerialPort mySerial; //<-- 요 부분이죠

  public Form1()
  {
  	InitializeComponent();
  }

아까 만들어 진 Form1_Load 함수에 아래와 같이 시리얼포트를 생성해주고 콤보박스에는 데이터를 담습니다.

private void Form1_Load(object sender, EventArgs e)
{
  mySerial = new SerialPort();
  comboBox1.DataSource = SerialPort.GetPortNames();

}

이제는 콤보박스의 선택정보가 변경될 때 시리얼 포트가 열려있지 않다면 포트이름과 설정을 지정해 주고 열도록 하겠습니다. 

UI 메뉴에서 콤보 박스를 더블클릭하면 함수가 자동으로 생성되는데요. 만들어진 함수에 아래와 같이 코드를 작성하시면 됩니다.

private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
{
  if (mySerial.IsOpen) // 특정 포트가 이미 열려 있다면 설정이 되지 않기 때문에 우선 닫는다.
  {
  	mySerial.Close();
  }
  if (!mySerial.IsOpen)  //시리얼포트가 닫혀있을 때만
  {
    mySerial.PortName = comboBox1.Text;  // 선택된 combobox 의 이름으로 포트명을 지정하자
    mySerial.BaudRate = 9600;  //아두이노에서 사용할 전송률를 지정하자
    mySerial.DataBits = 8;
    mySerial.StopBits = StopBits.One;
    mySerial.Parity = Parity.None;

    mySerial.Open();  //시리얼포트 열기
  }
  else
  {
    MessageBox.Show("해당포트가 이미 열려 있습니다.");
  }
}

시리얼 통신으로 문자열 송신하기

뭐 거의 다 되었습니다. 이제 버튼을 누르면 아두이노로 메시지를 전달하기만 하면 됩니다.

문자열을 전송하기 위한 byte 배열로 바꾸어주는 함수를 하나 만들어 보겠습니다.

private byte[] StringToByte(string _str)
{
  byte[] tmpBytes = Encoding.UTF8.GetBytes(_str);
  return tmpBytes;
}

요렇게 만들어 주었다면 이제 UI 생성하는 페이지에서 만들어 두었던 버튼을 두번 클릭하여 버튼을 눌렀을때 실행할 함수를 하나 만들어 줍시다.

그런다음 아래와 같이 메시지를 보내보겠습니다.

private void button1_Click(object sender, EventArgs e)
{
  byte[] datas = StringToByte("Hello Arduino?\n"); // 줄바꿈 기호인 \n 은 끝에 꼭 들어가야 합니다.
  mySerial.Write(datas, 0, datas.Length);
}

자 C# 어플리케이션은 완성이 되었습니다. 

벌써요?

네 벌써 완료 되었습니다. 정상적으로 동작한다면 아두이노 LCD 에 Hello Arduino? 가 뜰 것입니다.

제 포스트를 보시면서 천천히 하셔도 아마 15분이면 충분할만한 분량이지요. 

전체 코드도 올립니다.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.IO.Ports;

namespace csharp2arduino_serial
{
    public partial class Form1 : Form
    {
        private SerialPort mySerial;

        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            mySerial = new SerialPort();
            comboBox1.DataSource = SerialPort.GetPortNames();

        }

        private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
        {
        	if (mySerial.IsOpen)
            {
                mySerial.Close();
            }
            if (!mySerial.IsOpen)  //시리얼포트가 닫혀있을 때만
            {
                mySerial.PortName = comboBox1.Text;  // 선택된 combobox 의 이름으로 포트명을 지정하자
                mySerial.BaudRate = 9600;  //아두이노에서 사용할 전송률를 지정하자
                mySerial.DataBits = 8;
                mySerial.StopBits = StopBits.One;
                mySerial.Parity = Parity.None;

                mySerial.Open();  //시리얼포트 열기
            }
            else
            {
                MessageBox.Show("해당포트가 이미 열려 있습니다.");
            }
        }

        private void button1_Click(object sender, EventArgs e)
        {
            // 텍스트 박스 추가한 버전
            string myMsg = textBox1.Text;
            if (myMsg != "")
            {
                myMsg += "\n";
            }
            else
            {
                myMsg = "Hello Arduino?\n";
            }
            byte[] datas = StringToByte(myMsg);
            mySerial.Write(datas, 0, datas.Length);
        }

        private byte[] StringToByte(string _str)
        {
            byte[] tmpBytes = Encoding.UTF8.GetBytes(_str);
            return tmpBytes;
        }
    }
}

아두이노에서 시리얼 메시지 받기

아두이노에서 시리얼 메시지를 받는것은 사실 매우 쉽습니다. 아두이노 기본 예제 중에 Serial 을 사용하는 것을 많이 보셨죠? 아두이노는 Serial 을 사용하기 위하여 별도로 설정할것이 거의 없습니다.

아두이노를 열어 주시고 아래와 같이 코드를 작성합니다.

String myStr = "";

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
}

void loop() {

  if(Serial.available()){//시리얼에 데이터가 있다면

    char data = (char)Serial.read();//한 문자씩 읽어 문자형 변수에 담고
    
    if((int)data != 10){ //개행문자 '\n' -> newline 이 아니라면 스트링에 계속 저장
      myStr += data;
      
    }else{
      // \n 을 만나면 여기로 와서 문자열을 출력하면 된다.

      // LCD 에 문자를 여기서 출력하면 됨

      //그리고 문자열은 다시 초기화를 해주겠습니다.
      myStr = "";
    }
  }
}

완전 간단하죠? 시리얼 신호가 들어오면 \n 이라는 줄바꿈 문자열이 오기 전까지 계속해서 한글자씩 문자열 변수에 추가를 해주었다가 \n 을 만나면 필요한 결과를 수행하고 원래 문자열 변수를 초기화 하는 것이죠.

물론 아직 LCD 를 붙이지 않았으므로 시리얼을 받아도 뭔가 표시는 안되겠지요?

그래서 이제 LCD 를 붙여 보겠습니다.

아두이노 OLED LCD 에 시리얼 통신 결과 출력하기

지난 LCD 예제를 참고하시면 되며 이번에는 바로 시리얼을 출력해 보겠습니다.

2020/05/26 - [DIY/Arduino] - 0.96 inch OLED 디스플레이 구동하기

상단에 필요한 요소들을 추가해주고 기본적인 셋팅을 해준뒤 제 포스트의 주제인 DIY DEV DESIGN 을 출력하고 시작하겠습니다. ㅋ

(작성자의) 편의상 그냥 전체 코드블럭을 올립니다. 라이브러리나 LCD 구동 관련된사항은 위 포스트에서 확인하시면 됩니다.

#include <Wire.h> 
#include <Adafruit_SSD1306.h>
#include <splash.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SPITFT.h>
#include <Adafruit_SPITFT_Macros.h>
#include <gfxfont.h>
#include <Fonts/FreeMono9pt7b.h>


#define OLED_ADDR   0x3C

// reset pin not used on 4-pin OLED module
Adafruit_SSD1306 display(-1);  // -1 = no reset pin

//#if (SSD1306_LCDHEIGHT != 64)
//#error("Height incorrect, please fix Adafruit_SSD1306.h!");
//#endif

String myStr = "";
int linegap = 2;

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);

  display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR);
  display.setFont();
  display.clearDisplay();
  display.display();
  display.setTextSize(1);

  draw_text(2, 25, "DIY DEV DESIGN", false); // 폰트 표시를 쉽게 하기 위해 제가 만든 함수 입니다.
  draw_text(3, 4, "C# -> Arduino Serial", false);

  display.display();
  delay(3000);
  
}

void loop() {

  if(Serial.available()){//시리얼에 데이터가 있다면

    char data = (char)Serial.read();//한 문자씩 읽어 문자형 변수에 담고
    
    if((int)data != 10){ //개행문자 '\n' -> newline 이 아니라면 스트링에 계속 저장
      myStr += data;
      
    }else{
      // \n 을 만나면 여기로 와서 문자열을 출력하면 된다.

      // LCD 에 문자를 여기서 출력하면 됨
      display.clearDisplay();
      draw_text(2, 10, myStr, false);
      display.display();
      //그리고 문자열은 다시 초기화를 해주겠습니다.
      myStr = "";
    }
  }
}

void draw_text (int line, int xPos, String txt, bool isSelected)
{
   int cHeight = (line-1) * 8 + ((line-1) * linegap);
   if(isSelected)
   {
      display.fillRect(xPos - 2, cHeight, 127, 8, WHITE);
      display.setTextColor(BLACK);
   }else{
      display.setTextColor(WHITE);
   }
   display.setCursor(xPos, cHeight);
   display.print(txt);
}

음 뭐 간단하다면 간단한 내용이죠?

자 아두이노를 컴파일하고 올려야 하는데요. 아까 c#에서 만들어놓은 APP 을 실행해 놓으면 소스가 업로드 되지 않습니다. App 을 열어두었다면 끄고 업로드를 해야 합니다.

결과 확인하기

이제 결과를 확인해 보겠습니다.

먼저 아두이노를 업로드 해보면 아래와 같은 화면이 나오게 됩니다.

만들어 두었던 시리얼 통신용 어플을 실행해 볼까요?

이제 버튼을 눌러보면 아래와 같이 아두이노와 연결된 OLED LCD 에 전송한 글자가 표시됩니다.

전송한 메시지가 잘 표시가 되네요.

우하하하핫

이때가 기분이 제일 좋은 순간이지요. 

끝으로..

C# 으로 개발하기 귀찮은 분들을 위해 테스트용 앱을 만들어 보았습니다.

요렇게 하단에 메시지 박스를 이용해서 원하는 메시지를 보낼 수 있는 툴입니다.

아두이노 LCD 에는 이렇게 받아지죠.

시리얼 메시지 테스터는 아래 파일을 다운로드 받으셔서 압축을 해제하신 후 실행하시면 됩니다.

바이러스 따위는 없으니 안심하셔도 됩니다. 

이렇게 해서 간단하게 아두이노로 PC 에서 메시지를 보내는 방법을 설명해 드렸습니다.

만약 다른 정보일지라도 문자열로 바꾸어서 보내준뒤 아두이노 코드에서 해석해서 받으면 어떤 정보든 전달하는 것이 가능하겠죠? 어렵지 않으리라 생각됩니다.

C# 레퍼런스는 정말 어마어마 하게 많기 때문에 우리가 생각하는 거의 모든 것들을 만들어 내는 것이 가능할 것입니다. 

아두이노같은 작은 컴퓨터에서 우리가 PC 로 하는 많은 것들을 알려주고 동작하게 하는 것. 아두이노 만큼 손쉽게 실제 동작하는 기구를 만들 수 있는 도구가 또 어디 있겠습니까? 

시작이 어렵지 잘만들어진 레퍼런스 하나면 바로 첫 삽을 뜰 수 있답니다.

일단 통신만 뚫었다면 그 다음은 일사 천리아니겠습니까? 

예를 들면 제가 아두이노를 이용해서 TV 리모컨 신호를 해킹한 적이 있는데요. 적외선 기능이 없는 노트북에서 TV 를 켜고 채널을 바꾸는것도 간단한 프로젝트로 해볼만할 것 같습니다. 

그럼 이만~

2020/06/17 - [DIY/Arduino] - [DIY] 아두이노로 통합(만능) 리모콘 만들기 3/3

2020/05/26 - [DIY/Arduino] - 0.96 inch OLED 디스플레이 구동하기

2020/03/23 - [DIY/Arduino] - Arduino(아두이노) 무작정 시작하기

2019/06/27 - [DIY/Arduino] - 아두이노를 이용한 간단한 화분 자동 물주기 시스템

아두이노로 통합(만능) 리모콘 만들기 3/3 이라 쓰고 왠지 이번 포스트에서 끝나지 않을 것 같은 느낌이 강하게 듭니다. 지난 포스트에서 아두이노 IR 센서를 이용하여 신호를 해킹하고 또 필요한 신호를 따서 기록하는 것까지 소개해 드렸는데요.  해당 포스트는 아래 링크를 참고해 주세요.

2019/11/10 - [DIY/Arduino] - [DIY] 아두이노로 만능 (통합) 리모콘 만들기 1/3

2019/11/10 - [DIY/Arduino] - [DIY] 아두이노로 통합(만능) 리모콘 만들기 2/3

이번 포스트에서는 본격적으로 SW 를 설계하고 HW 를 만들어가는 과정을 소개해 드릴까 합니다.

먼저 조사했던 여러가지 기능을 모두 소화하기에 아두이노의 입력핀은 너무 적기 때문에 기기 전환 버튼같은 기능을 두어서 버튼은 동일한 레이아웃을 가지고 아두이노의 동일한 핀으로 입력 신호가 들어가더라도 실제 출력해주는 IR  신호는 다르게 보내주는 방식으로 구현을 할 계획입니다.

필요한 재료

• 3cm x 7cm 양면 만능기판 (2.54mm 규격) x 2EA
• 아두이노 나노
• Attiny85
• SW-200D 진동/틸트 스위치 양쪽 다리형
• Push switch (2pin) x 14 EA
• LED (red, SMD) x 4EA
• LED (green, SMD) x 1EA
• 5V DCDC Converter, Step Up Power Supply 보드
• TP4056 18650 charge module
• 0.1F 전해콘덴서 (슈퍼콘덴서??) 꼭 필요한지 모르겠음
• 대충 33옴 정도되는 저항, 낮아도 별 상관 없음 (SMD LED 연결용)
• IR LED (송신용) x 1EA
• 18650 배터리 1EA

SW 를 대충 설계해보자.

먼저 아두이노의 인풋, 아웃풋 키와 함께 각각의 기능을 매칭하는 테이블을 만들어야겠습니다. 아무래도 여러가지 기능이 동작되어야 하므로 나중에 실수하지 않으려면 각각의 입력핀에 연결될 버튼과 기능을 정의하는게 중요합니다.

위와 같이 각각의 기능을 테이블로 만들어 보았습니다. 가장 우측의 비고에 해당하는 열이 아두이노의 핀번호가 되겠으며 9~12번은 4개의 제품에 해당되는 LED 를 켜주기 위한 출력핀입니다. 18번은 제품전환용 버튼 입력핀이 됩니다.

제일 좌측에 S01~S14까지 번호가 있는데요. 이번호들은 각각 아래와 같은 형태로 배치할 계획입니다.

저는 양면 만능기판을 사용할 계획이고요. 만능기판의 끝부분에 단자용도로 사용할 수 있는 납이 붙어있어 그부분까지 일단 납땜을 하여 연결해 보기로 합니다. 중앙 상단의 네게의 흐릿한 동그라미가 LED 1234 와 연결이 되는 것이죠.

14개의 버튼은 모두 1개의 그라운드핀과 연결되며 나머지 한쪽 다리를 아래쪽 단자에 순차적으로 매칭을 시켜줍니다.

LED 역시 그라운드를 모두 한꺼번에 연결하고 아래쪽 LED 핀은 아두이노 디지털 출력핀과 연결해주어 선택된 제품에 불이 켜지도록 하겠습니다.

만능기판에 버튼을 실장한 사진은 아래와 같습니다.

총 14개의 버튼이 위와 같이 아름답게 배치됩니다. 만능기판의 크기를 생각해보면 아주 아담한 리모컨이 만들어 질 것 같네요.

아두이노 나노와 전원 공급 모듈

전원 입력은 3.7V 리튬이온 18650 배터리를 이용할 계획인데요. 아두이노가 5V 이상의 전압이 필요하기 때문에 5V 로 승압을 해주는 보드를 하나 장착이 필요하고요, 이 제품을 연속으로 사용하지 않을 경우 자동으로 전원 공급이 중단되도록 할 필요가 있을듯 하여 attiny85 를 이용하여 일정 시간이 지나면 전원 공급이 중단되도록 할 계획입니다. atiny는 sleep 모드라는 것을 지원하는데 sleep 모드로 들어가면 거의 전기를 먹지않는 놀라운 기능을 수행하게 됩니다.

다시 동작할때는 reset 핀에 GND 를 입력해주면 다시 동작을 시작하게 되는데 틸트 스위치를 이용하여 움직임을 감지하여 물리적으로 움직임이 발생되면 attiny85의 reset핀으로 신호를 보내줌으로써 attiny 가 전원 공급을 시작하는 것이죠. 이번 제작하는 리모컨 자체가 전류를 거의 사용하지 않기 때문에 문제는 없을 듯 하지만 그래도 attiny 의 디지털 출력핀이 충분한 전기를 공급할 수 있을지는 미지수입니다.

그래서 0.1F 정도의 콘덴서를 전원 공급용으로 하나 달아 보았습니다. ( 사실 전기/전자 지식이 매우 얕아서 저렇게 하면 되는지는 잘 모르겠어요)

그렇게 만들어진 보드가 바로 아래와 같이 만들어졌습니다.

위에서 설명드린 것처럼 우측 상단에 attiny85 가 자리잡고 있고요. (SMD 버전입니다) 중간에 검은 통이 틸트 스위치입니다. 약간 기울여서 달아주어야 평소에 눕혀져 있을때 신호가 끊어지기 때문에 기울여서 부착을 했고요, 아래 검은 네모박스가 0.1F 전해 콘덴서 입니다. 어디서 떼어낸건지는 기억이 안나는데 버리는 가전제품에서 떼어낸 부품입니다.

실제 아두이노 나노로 입력되는 전원은 전해콘덴서와 연결이 되어 있어 attiny 가 sleep 모드로 들어가더라도 일정시간 전원을 공급하여 주는 역할을 하게 됩니다.

우측의 단자부분은 이미 납땜이 마구 되어 있는데요, 위에 소개해드린 버튼부분과 연결이 되게 됩니다.

고난의 시작 ! 인정사정 없이 납땜시작

정말 납땜하다가 정신병 걸리는 줄 알았습니다.

왼쪽은 아두이노 나노를 포함한 메인 컨트롤 부, 오른쪽은 버튼 조작부와 LED 되겠습니다. LED 는 우측 끝에 매달려 있는데 잘 안보이시죠? 작은 회로기판 같은데 신호용으로 아주아주 작은 SMD 타입의 LED가 붙여 있는 것을 보셨을 텐데요, 고 녀석들을 떼어내서 부탁을 해주었습니다. 일부러 구입할일은 없으니까요.

각각의 선들은 위에서 설계한 것처럼 연결을 해주었는데 설계할때는 이게 이렇게나 복잡할거라고는 생각을 못했습니다.

위쪽에 보이는 작은 초록색 기판이 3.7 --> 5V 승압회로 , 그사이에 아주 작게 보이는 파란색 보드가 USB 전원을 이용하여 3.7V 배터리를 충전할 수 있는 충전 보드 입니다. 

이렇게 하면 완전한 하나의 제품에 해당되는 부품을 모두 제작한 셈이 되겠네요.

위에서 보았던 두개의 보드는 위 사진처럼 접어서 조립할 계획입니다. 안쪽역시 매우 지저분하네요. 저렇게 만들어진 배선이 과연 잘 붙어있을까 궁금합니다.

두개의 보드 중간에는 절연을 위하여 얇은 실리폰 패드를 하나 넣어줄 계획입니다.

전원이 들어오게 되면 위사진과 같이 불이 켜집니다. 계획에는 LED가 4개였지만 메인 전원이 들어왔는지 여부를 판단하기 위하여 연두색 SMD LED를 하나 추가하였습니다. 

코딩 시작!

자 순서가 좀 바뀐것 같지만 이제부터는 지루한 SW 코딩 부분입니다.

SW 구현할때 다음의 것들이 동작해야 하는 것이 중요합니다.

• 하나의 버튼에 의해 주어진 신호는 4개의 제품에 대한 신호를 보낼 수 있어야 한다.
• 마지막으로 사용한 제품을 기억했다가 다시 동작할때 세팅해준다.
• 신호가 한번에 입력이 안될 경우를 대비하여 연속으로 n번 보낼 수 있도록 구성한다.

뭐 별건 없습니다만 두번째에 해당되는 부분은 제가 처음해보는 관계로 저도 공부를 좀 했습죠.

EEPROM 을 사용해보자!

아두이노 나노에 사용되는 Atmega328 칩에는 무려 1kb 라는 비 휘발성 저장공간이 존재합니다. EEPROM 이라고 부르는데요, 프로그램이 저장되는 공간 외에 사용자가 데이터를 저장할 수 있는 공간말입니다.

무려 1kb 요.

-_-;;

1kb 라니.. 장난하냐..

싶겠지만 있는게 어딥니까?

이 저장공간을 이용하여 우리는 마지막 동작했던 제품의 정보를 기억할 건데요. 따지고 보면 차고도 넘치는 양이지요.

자 그럼 EEPROM 에 데이터는 어떻게 저장하고 읽어 들이는지 볼까요?

#include <EEPROM.h>

int sw_02;
int productIdx = 0; //0 : TV / 1: TV BOX / 2: BTV / 3: SPK
bool chkon = false;

//LED
const int L00 = 9;    // TV
const int L01 = 10;   // TV BOX
const int L02 = 11;   // BTV
const int L03 = 12;   // LONPOO SPEAKER

void setup()
{
    pinMode(s02, INPUT_PULLUP);
    productIdx = EEPROM.read(0); // EEPROM 에 저장된 제품의 번호를 불러오는 부분
}

void loop() {

  sw_02 = digitalRead(s02);

   // change product
  if (sw_02 == HIGH) {
    chkon = true; // 연속으로 눌리는 것을 방지하기 위하여 on 상태일때만 기기 변경이 되도록 한다.
    ledON(productIdx);
  }else{
    if (chkon)
    {
      productIdx++;
      if (productIdx > 3) productIdx = 0;
      EEPROM.write(0, productIdx); // 이부분이 EEPROM 에 현재 제품의 번호를 저장하는 부분
      chkon = false;
    }
    
    ledON(productIdx);
}

void ledON (int idx) // 선택된 인덱스에 맞게 LED 를 켜주는 함수
{
  digitalWrite(L00, LOW);
  digitalWrite(L01, LOW);
  digitalWrite(L02, LOW);
  digitalWrite(L03, LOW);
  switch (idx) {
  case 0:
    digitalWrite(L00, HIGH);
    break;
  case 1:
    digitalWrite(L01, HIGH);
    break;
  case 2:
    digitalWrite(L02, HIGH);
    break;
  case 3:
    digitalWrite(L03, HIGH);
    break;
  default:
    break;
  }
}

어렵지 않죠? 제일 위에 해당 라이브러리를 불러들여 주고요,

Setup 시에 저장되어 있는 값을 불러옵니다.

버튼은 눌렀을때 LOW 가 되도록 하고 항상 HIGH 한 상태를 만들어 줍니다. HIGH 한 상태가 되면 chkon 이 true 가되고 버튼이 눌렸을때 기기의 인덱스를 변경한 뒤 EEPROM 에 값을 저장하고 chkon 을 false 로 만들어 다음 신호를 기다리게 됩니다. 이렇게 하면 버튼을 연속으로 누르고 있어도 신호는 한번만 가게 되겠죠. 마지막으로 사용한 제품도 저장이 됩니다.

버튼 하나로 4개의 제품은 어떻게 제어를 할까요?

//setup, 변수 선언 등은 생략합니다.

void loop() {

if (sw_03 == HIGH) {    //s03 은 전원 버튼입니다.
  }else{    
    digitalWrite(13, HIGH);
    press_S03(productIdx);
  }
  // 생략
}


void press_S03 (int idx) // power
{
  switch (idx) {
  case 0:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x2DF10EF,32);   // tv power
    break;
  case 1:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x807F02FD,32);   // tv box power
    break;
  case 2:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x1FE807F,32);   // Btv power1 
    break;
  case 3:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x40BF807F,32);   
    break;
  default:
    // statements
    break;
  }
}

바로 Switch 문을 이용하여 입력되는 idx 에 따라 각각 다른 신호를 보내주는 것이지요. 

아래 press_S03 버튼이 바로 전원을 켜고 끄는기능을 담당하는 함수가 되는 것이죠.

저런 식으로 버튼 개수만큼 함수를 만들어 주면 됩니다. 좀더 효율적으로 코딩할수도 있겠지만 초보인 저에게는 저렇게 쉽게 코딩하는게 나중에 뜯어 고치지도 좋을 것 같아 이란 저런 방식으로 작성을 하였습니다.

포스트가 점점 길어지네요.. 

자 이제 전체 소스 갑니다.

중요한 내용은 위에 다 설명 드렸고 이전 포스트를 참고하시면서 내용 확인해 보시면 되고요. 꼭 저와 동일하게 만들 필요는 없으니 참고만 해주시면 됩니다.

길이가 대단하니 조심하세요~ ㅋ

#include <boarddefs.h>
#include <IRremote.h>
#include <IRremoteInt.h>
#include <ir_Lego_PF_BitStreamEncoder.h>
#include <EEPROM.h>
/*
 * IRremote: IRsendDemo - demonstrates sending IR codes with IRsend
 * An IR LED must be connected to Arduino PWM pin 3.
 * Version 0.1 July, 2009
 * Copyright 2009 Ken Shirriff
 * http://arcfn.com
 */
/*
 * tv (NEC)
 * power :      0x2DF10EF, 32
 * input :      0x2DFD02F, 32
 * chnnel up :  0x2DF00FF, 32
 * chnnel dn :  0x2DF807F, 32
 * volumn up :  0x2DF40BF, 32
 * volumn dn :  0x2DFC03F, 32
 * OK :         0x2DF22DD, 32
 * sw up :      0x2DF02FD, 32
 * sw dn :      0x2DF827D, 32
 * sw left :    0x2DFE01F, 32
 * sw right :   0x2DF609F, 32
 * 
 * android tv (NEC)
 * power :      0x807F02FD, 32
 * sw up :      0x807F6897, 32
 * sw dn :      0x807F58A7, 32
 * sw left :    0x807F8A75, 32
 * sw right :   0x807F0AF5, 32
 * sw OK :      0x807FC837, 32
 * back :       0x807F9867, 32
 * volumn up :  0x807F18E7, 32
 * volumn dn :  0x807F08F7, 32
 * 
 * 
 * lonpoo speaker
 * power :      0x40BF807F, 32
 * volumn up :  0x40BF50AF, 32
 * volumn dn :  0x40BFD02F, 32
 * bt :         0x40BFA05F, 32
 * bt esc :     0x40BF906F, 32
 * opt :        0x40BF20DF, 32
 * 
 * 
 * LED
 * tv :     9
 * tv box : 10
 * btv :    11
 * spk :    12
 * 
 * input
 * s01 
 * 
 * 
 * 
 * 
 */

#include <IRremote.h>

const int s01 = 0;
const int s02 = 18;   // select sw 
const int s03 = 1;
const int s04 = 2;
const int s05 = 19;
const int s06 = 4;
const int s07 = 5;
const int s08 = 6;
const int s09 = 7;
const int s10 = 8;
const int s11 = 14;
const int s12 = 15;
const int s13 = 16;
const int s14 = 17;
//LED
const int L00 = 9;    // TV
const int L01 = 10;   // TV BOX
const int L02 = 11;   // BTV
const int L03 = 12;   // LONPOO SPEAKER

//
// define sw value
int sw_01;
int sw_02;
int sw_03;
int sw_04;
int sw_05;
int sw_06;
int sw_07;
int sw_08;
int sw_09;
int sw_10;
int sw_11;
int sw_12;
int sw_13;
int sw_14;

// 
int productIdx = 0; //0 : TV / 1: TV BOX / 2: BTV / 3: SPK

int addr = 0;
bool chkon = false;
IRsend irsend;

void setup()
{
  pinMode(s01, INPUT_PULLUP);
  pinMode(s02, INPUT_PULLUP);
  pinMode(s03, INPUT_PULLUP);
  pinMode(s04, INPUT_PULLUP);
  pinMode(s05, INPUT_PULLUP);
  pinMode(s06, INPUT_PULLUP);
  pinMode(s07, INPUT_PULLUP);
  pinMode(s08, INPUT_PULLUP);
  pinMode(s09, INPUT_PULLUP);
  pinMode(s10, INPUT_PULLUP);
  pinMode(s11, INPUT_PULLUP);
  pinMode(s12, INPUT_PULLUP);
  pinMode(s13, INPUT_PULLUP);
  pinMode(s14, INPUT_PULLUP);
  
  pinMode(L00, OUTPUT);
  pinMode(L01, OUTPUT);
  pinMode(L02, OUTPUT);
  pinMode(L03, OUTPUT);
  
  pinMode(13, OUTPUT);
  
  productIdx = EEPROM.read(0);
}

void loop() {

  digitalWrite(13, LOW);
  
  sw_01 = digitalRead(s01);
  sw_02 = digitalRead(s02);
  sw_03 = digitalRead(s03);
  sw_04 = digitalRead(s04);
  sw_05 = digitalRead(s05);
  sw_06 = digitalRead(s06);
  sw_07 = digitalRead(s07);
  sw_08 = digitalRead(s08);
  sw_09 = digitalRead(s09);
  sw_10 = digitalRead(s10);
  sw_11 = digitalRead(s11);
  sw_12 = digitalRead(s12);
  sw_13 = digitalRead(s13);
  sw_14 = digitalRead(s14);
  
  // change product
  if (sw_02 == HIGH) {
    chkon = true;
    ledON(productIdx);
  }else{
    if (chkon)
    {
      productIdx++;
      if (productIdx > 3) productIdx = 0;
      EEPROM.write(0, productIdx);
      chkon = false;
    }
    
    ledON(productIdx);
  }
  
  if (sw_01 == HIGH) {    
  }else{    
    digitalWrite(13, HIGH);
    press_S01(productIdx);
  }
  if (sw_03 == HIGH) {    
  }else{
    digitalWrite(13, HIGH);
    press_S03(productIdx);
  }
  if (sw_04 == HIGH) {    
  }else{
    digitalWrite(13, HIGH);
    press_S04(productIdx);
  }
  if (sw_05 == HIGH) {    
  }else{
    digitalWrite(13, HIGH);
    press_S05(productIdx);
  }
  if (sw_06 == HIGH) {    
  }else{
    digitalWrite(13, HIGH);
    press_S06(productIdx);
  }
  if (sw_07 == HIGH) {    
  }else{
    digitalWrite(13, HIGH);
    press_S07(productIdx);
  }
  if (sw_08 == HIGH) {    
  }else{
    digitalWrite(13, HIGH);
    press_S08(productIdx);
  }
  if (sw_09 == HIGH) {    
  }else{
    digitalWrite(13, HIGH);
    press_S09(productIdx);
  }
  if (sw_10 == HIGH) {    
  }else{
    digitalWrite(13, HIGH);
    press_S10(productIdx);
  }
  if (sw_11 == HIGH) {    
  }else{
    digitalWrite(13, HIGH);
    press_S11(productIdx);
  }
  if (sw_12 == HIGH) {    
  }else{
    digitalWrite(13, HIGH);
    press_S12(productIdx);
  }
  if (sw_13 == HIGH) {    
  }else{
    digitalWrite(13, HIGH);
    press_S13(productIdx);
  }
  if (sw_14 == HIGH) {    
  }else{
    digitalWrite(13, HIGH);
    press_S14(productIdx);
  }
	
	delay(75); //5 second delay between each signal burst
}

void press_S14 (int idx) // vol -
{
  switch (idx) {
  case 0:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x2DFC03F,32);   // tv vol -
    break;
  case 1:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x807F08F7,32);  // tv box vol -
    break;
  case 2:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x1FE42BD,32);  // BTV box vol -
    break;
  case 3:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x40BFD02F,32);  //  spk vol -
    break;
  default:
    // statements
    break;
  }
}

void press_S13 (int idx) // chnl -
{
  switch (idx) {
  case 0:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x2DF807F,32);   // tv chnl -
    break;
  case 1:
    //for (int i = 0; i < 1; i++) irsend.sendNEC(0x807F18E7,32);  // tv box vol +
    break;
  case 2:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x1FE827D,32);   // Btv chnl -
    break;
  case 3:
    //for (int i = 0; i < 1; i++) irsend.sendNEC(0x40BF50AF,32);  //  spk vol +
    break;
  default:
    // statements
    break;
  }
}

void press_S12 (int idx) //vol +
{
  switch (idx) {
  case 0:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x2DF40BF,32);   // tv vol +
    break;
  case 1:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x807F18E7,32);  // tv box vol +
    break;
  case 2:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x1FEC23D,32);   // Btv vol +
    break;
  case 3:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x40BF50AF,32);  //  spk vol +
    break;
  default:
    // statements
    break;
  }
}

void press_S11 (int idx) // chnl +
{
  switch (idx) {
  case 0:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x2DF00FF,32);   // tv chnl +
    break;
  case 1:
    //for (int i = 0; i < 1; i++) irsend.sendNEC(0x807F58A7,32);  // tv box
    break;
  case 2:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x1FE02FD,32);   // Btv chnl +
    break;
  case 3:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x40BF906F,32);  //  spk bt esc
    break;
  default:
    // statements
    break;
  }
}

void press_S10 (int idx) // down
{
  switch (idx) {
  case 0:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x2DF827D,32);   // tv down
    break;
  case 1:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x807F58A7,32);  // tv box down 
    break;
  case 2:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x1FE52AD,32);   // Btv down
    break;
  case 3:
    //for (int i = 0; i < 1; i++) irsend.sendNEC(0x40BF20DF,32);  //  
    break;
  default:
    // statements
    break;
  }
}

void press_S09 (int idx) // right
{
  switch (idx) {
  case 0:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x2DF609F,32);   // tv right
    break;
  case 1:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x807F0AF5,32);  // tv box right 
    break;
  case 2:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x1FE32CD,32);   // Btv right
    break;
  case 3:
    //for (int i = 0; i < 1; i++) irsend.sendNEC(0x40BF20DF,32);  // tv box up 
    break;
  default:
    // statements
    break;
  }
}
void press_S08 (int idx) // ok
{
  switch (idx) {
  case 0:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x2DF22DD,32);   // tv ok
    break;
  case 1:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x807FC837,32);  // tv box ok 
    break;
  case 2:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x1FE629D,32);   // Btv ok
    break;
  case 3:
    //for (int i = 0; i < 1; i++) irsend.sendNEC(0x40BF20DF,32);  // tv box up 
    break;
  default:
    // statements
    break;
  }
}

void press_S07 (int idx) // arrow left
{
  switch (idx) {
  case 0:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x2DFE01F,32);   // tv left
    break;
  case 1:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x807F8A75,32);  // tv box left 
    break;
  case 2:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x1FED22D,32);   // Btv left
    break;
  case 3:
    //for (int i = 0; i < 1; i++) irsend.sendNEC(0x40BF20DF,32);  // tv box up 
    break;
  default:
    // statements
    break;
  }
}
void press_S06 (int idx)
{
  switch (idx) {
  case 0:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x2DF02FD,32);   // tv back
    break;
  case 1:
    //for (int i = 0; i < 1; i++) irsend.sendNEC(0x807F9867,32);  // tv box back 
    break;
  case 2:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x1FE728D,32);   // Btv back
    break;
  case 3:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x40BF20DF,32);  // spk OPT 
    break;
  default:
    // statements
    break;
  }
}

void press_S05 (int idx) // arrow up
{
  switch (idx) {
  case 0:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x2DF02FD,32);   // tv up
    break;
  case 1:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x807F6897,32);  // tv box up 
    break;
  case 2:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x1FE926D,32);   // Btv up
    break;
  case 3:
    //irsend.sendNEC(0x40BFA05F,32);  
    break;
  default:
    // statements
    break;
  }
}

void press_S04 (int idx)
{
  switch (idx) {
  case 0:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x2DFD02F,32);   //외부입력
    break;
  case 1:
    //irsend.sendNEC(0x2DF10EF,32);   
    break;
  case 2:
    //irsend.sendNEC(0x2DF10EF,32);   
    break;
  case 3:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x40BFA05F,32);   // blue tooth
    break;
  default:
    // statements
    break;
  }
}

void press_S03 (int idx) // power
{
  switch (idx) {
  case 0:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x2DF10EF,32);   // tv power
    break;
  case 1:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x807F02FD,32);   // tv box power
    break;
  case 2:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x1FE807F,32);   // Btv power1 
    break;
  case 3:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x40BF807F,32);   
    break;
  default:
    // statements
    break;
  }
}
void press_S01 (int idx) //  S01
{
  switch (idx) {
  case 0:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x2DF10EF,32);   
    break;
  case 1:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x807F02FD,32);   
    break;
  case 2:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x1FE807F,32);   
    break;
  case 3:
    for (int i = 0; i < 1; i++) irsend.sendNEC(0x40BF807F,32);   
    break;
  default:
    // statements
    break;
  }
}
void ledON (int idx)
{
  digitalWrite(L00, LOW);
  digitalWrite(L01, LOW);
  digitalWrite(L02, LOW);
  digitalWrite(L03, LOW);
  switch (idx) {
  case 0:
    digitalWrite(L00, HIGH);
    break;
  case 1:
    digitalWrite(L01, HIGH);
    break;
  case 2:
    digitalWrite(L02, HIGH);
    break;
  case 3:
    digitalWrite(L03, HIGH);
    break;
  default:
    // statements
    break;
  }
}

자 이렇게 해서 프로그램까지 마쳤습니다.

원래 3편에 걸쳐 포스팅을 완료하려고 하였으나 너무 길어져서 최종 케이스제작과 동작 테스트는 다음 포스트로 미루도록 하겠습니다. 죄송합니다.

또 얼마가 걸릴지 모르겠네요. 

어쨌든 핵심이 되는 내용은 이번 편까지인것 같고 하드웨어 구성은 여러분께서 마음껏 하셔도 될 것 같습니다. 기능도 변경해보시고요, 좀 고민해보면 더 많은 기능을 구성하는 것도 가능할 수도 있습니다.

이번 프로젝트로 무려 4개의 리모컨을 1개로 통합하는 작업을 해보았는데요, 사실 제가 생각했던것과 아주 유사한 제품이 판매되는 제품도 있습니다. 가격이 아주 비싼것도 아니고요. 다만 이런것을 직접 해봄으로 해서 우리는 또 많은 것을 배울 수 있지 않겠습니까?

저는 이번 프로젝트에서 EEPROM 과 IR 신호를 제어하는 것을 배울 수 있는 좋은 기회였던 것 같습니다.

자 그럼 케이스 까지 완성되는 그날을 기대하며 ~

완성된 리모컨 구경하려면?

2022.08.16 - [DIY/Arduino] - [DIY] 아두이노로 통합(만능) 리모콘 만들기 (최종)

IR 리모컨 제작 관련 링크는?

2019/11/10 - [DIY/Arduino] - [DIY] 아두이노로 만능 (통합) 리모콘 만들기 1/3

2019/11/10 - [DIY/Arduino] - [DIY] 아두이노로 통합(만능) 리모콘 만들기 2/3

다른 아두이노 예제는?

2020/05/26 - [DIY/Arduino] - 0.96 inch OLED 디스플레이 구동하기

2019/10/29 - [DIY/Arduino] - [DIY] 아두이노를 이용한 수경재배 시스템

2019/06/27 - [DIY/Arduino] - 아두이노를 이용한 간단한 화분 자동 물주기 시스템

2020/03/23 - [DIY/Arduino] - Arduino(아두이노) 무작정 시작하기

2020/06/29 - [DIY/Arduino] - C# 에서 아두이노로 시리얼 통신 하기

가끔 아두이노로 무엇인가를 만들어 보려고 하다보면 디스플레이가 있으면 하는 생각이 들때가 있습니다. 아두이노는 작은 컴퓨터이기는 하지만 모름지기 컴퓨터라 한다면 입력장치 - 중앙처리장치 - 출력장치가 모두 있어야 비로소 컴퓨터라 할수 있겠지요. 센서나 버튼 등은 간단한 입력장치라 볼수 있겠으나 아두이노 기판에 붙어있는 LED 는 출력장치라고 하기에는 조금 부족한 면이 있습니다.

그래서 오늘은 아두이노 나노 에 OLED 디스플레이를 붙여 볼 생각입니다.

오늘도 역시 알리익스프레스에서 구입한 부품으로 시작합니다.

오늘 필요한 부품은

• 아두이노 나노  Arduino Nano (우노가 있으신 분은 그냥 우노로 하시면 됩니다)
• 0.96 inch OLED display (128x64)

이게 전부 입니다.

간단하죠?

참고로 제가 구입한 OLED 보드는 아래의 제품입니다.

I2C 통신이 가능한 모델로 코딩을 간단하게 할수 있고 연결해야 하는 선이 적어 손쉽게 구현이 가능하다는 장점이 있습니다. (4pin)

먼저 OLED 에 무엇인가를 손쉽게 표시하기 위하여는 라이브러리를 받아야 합니다. 

아래의 첨부파일을 받아주세요.

받은신 라이브러리는 압축을 해제하여 내문서> Arduino> Library 폴더안에 아래와 같이 복사해서 넣어주세요.

그럼 기본적인 준비는 끝났습니다. 

아두이노 나노와 OLED 를 아래와 같이 연결해 주세요.

• A4 --> SDA
• A5 --> SCK
• 5V --> VDD
• GND --> GND

요렇게 연결하면 연결도 끝 입니다.

매우 간단하죠?

자 코딩을 해볼까요? 간단하게 텍스트를 출력하는 예제를 짜 보았습니다.

#include <Wire.h> 
#include <Adafruit_SSD1306.h>
#include <splash.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SPITFT.h>
#include <Adafruit_SPITFT_Macros.h>
#include <gfxfont.h>

#define OLED_ADDR   0x3C

// reset pin not used on 4-pin OLED module
Adafruit_SSD1306 display(-1);


void setup() {
  // put your setup code here, to run once:

  display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR);

  display.setFont();
  display.clearDisplay();
  display.display();

  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(2, 25);
  display.print("DIY DEV DESIGN");
  display.display();
}

void loop() {
  // put your main code here, to run repeatedly:

}

setup 에서 한번만 호출해주는 코드 입니다. 나중에 loop 에서 다른 화면을 보여주는 걸로 한다면 인트로 정도가 될 수 있겠습니다.

출력되는 화면을 한번 볼까요?

캬~ 아주 깔끔하고 예쁩니다. 디스플레이 크기가 작은 만큼 글자 크기도 좀 작게 설정을 하였는데요. 선명하고 예쁩니다. 

우리는 이 디스플레이에 무엇인가를 그리거나 표시하기 위하여 위와 같은 방식으로 계속 직접 코딩을 하는 것은 비 효율 적이기 때문에 뭔가 좀저 효율적으로 그릴 수 있도록 코딩을 해볼 계획입니다.

만들어 볼 기능은 아래와 같습니다. (사실 RC 카 조종기에 넣을 기능임)

• 텍스트 표시하기
• 프로그래스 바 표시하기
• 좌우 밸런스 바 표시하기

텍스트 표시하기

// 위쪽은 동일하므로 생략합니다.

void loop() {
  display.clearDisplay();
  draw_text(1, 2, "[ DIY DEV DESIGN ]", false);
  draw_text(2, 2, "This is selected menu", true);
  draw_text(3, 2, "This is 2nd menu", false);
  draw_text(4, 6, "Sub menu 1 line", false);
  draw_text(5, 6, "Sub menu 2 line", false);
  draw_text(6, 2, "This is 3rd menu", false);
  display.display();
  delay(1000);
}

void draw_text (int line, int xPos, String txt, bool isSelected)
{
  
   int cHeight = (line-1) * 8 + ((line-1) * 2);
   if(isSelected)
   {
      display.fillRect(xPos - 2, cHeight, 127, 8, WHITE);
      display.setTextColor(BLACK);
   }else{
      display.fillRect(xPos - 2, cHeight, 127, 8, BLACK);
      display.setTextColor(WHITE);
   }
   display.setCursor(xPos, cHeight);
   display.print(txt);
}

아래쪽에 draw_text 라는 함수를 하나 만들어 주었습니다. 원하는 줄에 원하는 텍스트를 쉽게 표시할 수 있도록 했는데요, 특징으로는 메뉴 등의 기능으로 사용할 수 있도록 해당 라인이 선택 상태인지를 입력할 수 있도록 했습니다.

구현된 화면을 보면 아래와 같죠. 로터리 스위치나 푸쉬스위치의 입력을 받아 선택상태를 바꾸어 주는 방식으로 메뉴를 개발할 수 있을 것 같습니다.

프로그래스 바 만들어 보기

void loop() {
  
  for(int i = 2; i < 127; i++)
  {
    display.clearDisplay();
    draw_text(1, 2, "[ DIY DEV DESIGN ]", false);
    draw_text(2, 2, "progress 1", false);
    draw_progressBox(3, i, false);
    draw_text(4, 2, "progress 2", false);
    draw_progressBox(5, 126-i, true);
    display.display();
    delay(20);
  }
  
}

void draw_progressBox(int line, int val, bool isSelected)
{
  
  int cHeight = (line-1) * 8 + ((line-1) * 2);
  if(isSelected)
    {
      display.fillRect(0, cHeight, 127, 8, WHITE);
      display.drawRect(1,cHeight+1, 126, 6, BLACK );
      display.fillRect(1,cHeight+1, val, 6, BLACK );
    }else{
      display.drawRect(1,cHeight+1, 126, 6, WHITE );
      display.fillRect(1,cHeight+1, val, 6, WHITE );
    }
}

void draw_text (int line, int xPos, String txt, bool isSelected)
{
  
   //생략
}

이번에는 draw_progressBox 라는 함수로 프로그래스 바를 표현해 봤습니다. 역시 라인의 위치를 간단히 설정할 수 있도록 하였으며 val 값을 입력 받도록 하였습니다.

그리고 텍스트와 마찬가지로 선택상태를 주게 되면 색상이 반전되어 보이도록 기능을 주었습니다. 총 2~126 까지의 값이 표현 가능합니다. 깔끔하게 100개만 입력 받도록 넓이를 조정해보는 것도 좋을 것 같네요.

구현하면 아래와 같이 표시 됩니다.

아날로그 발란서 만들어보기

다음은 아날로그 발란서 입니다. 센터를 정해 놓고 좌우로 얼마나 기울었는지 등을 설정하거나 보여주는 기능에 적합한 메뉴 입니다.

void loop() {
  
  for(int i = 2; i < 127; i++)
  {
    display.clearDisplay();
    draw_text(1, 2, "[ DIY DEV DESIGN ]", false);
    draw_text(2, 2, "progress 1", false);
    draw_analogBalancer (3, i, false);
    display.display();
    delay(20);
  }
  
}
void draw_analogBalancer(int line, int val, bool isSelected)
{
  int cHeight = (line-1) * 8 + ((line - 1) * 2);  

  if (isSelected)
  {
    display.fillRect(0, cHeight, 127, 8, WHITE);
    display.drawLine(0, cHeight+3, 127, cHeight+3, BLACK);
    display.drawLine(val, cHeight+1, val, cHeight+5, BLACK);
    display.fillTriangle(64, cHeight+5, 62, cHeight+7, 66, cHeight+7, BLACK);
    display.drawPixel(val-1, cHeight+3, WHITE);
    display.drawPixel(val+1, cHeight+3, WHITE);
  }else{
    display.drawLine(0, cHeight+3, 127, cHeight+3, WHITE);
    display.drawLine(val, cHeight+1, val, cHeight+5, WHITE);
    display.fillTriangle(64, cHeight+5, 62, cHeight+7, 66, cHeight+7, WHITE);
    display.drawPixel(val-1, cHeight+3, BLACK);
    display.drawPixel(val+1, cHeight+3, BLACK);
  }
}

코드가 좀 길죠? 아무래도 표현해야 할 요소가 많기 때문인데요, 역시 선택상태를 표시하기 위하여 두벌로 코딩이 되었습니다. 선택 상태를 만드실 필요가 없다면 else 아래쪽만 코딩을 해주셔도 표현이 가능합니다.

구현된 화면을 한번 보실까요?

가운데 세모가 중심의 위치를 나타내고 세로로 얇은 막대가 현재 입력 받는 val 에 해당되는 위치가 됩니다. 물론 반대로 표시하는 것도 조금만 코드를 수정하면 가능하겠죠?

이렇게 하여 간단하게 아두이노를 이용하여 초소형 OLED 를 구동하는 것을 보여드렸습니다. 전혀 어렵지 않으니 바로 도전해 보시기 바랍니다. 

OLED 가 각종 정보를 표시하는데 생각보다 속도가 많이 느리므로 아두이노 자체 기능이 지연될 수 있습니다. realtime clock 과 같은 실제 시계 등을 만들기 위하여는 위에 표시한 방식과는 다르게 구현을 해야 될 것 같습니다.

궁금하신 것은 뎃글로 문의 해 주시기 바랍니다.

2020/03/23 - [DIY/Arduino] - Arduino(아두이노) 무작정 시작하기

2019/12/23 - [DIY/RC] - 아두이노를 이용한 RC 카 만들기 2

2019/11/10 - [DIY/Arduino] - [DIY] 아두이노로 만능 (통합) 리모콘 만들기 1/3

2019/06/27 - [DIY/Arduino] - 아두이노를 이용한 간단한 화분 자동 물주기 시스템

2019/10/29 - [DIY/Arduino] - [DIY] 아두이노를 이용한 수경재배 시스템