본 문서는 아두이노 개발환경(IDE)를 이용해서 ESP8266 모듈을 다루는 예제들을 포함하고 있습니다.

• ESP8266 – ARDUINO IDE 예제 (GPIO 제어)
• ESP8266 – ARDUINO IDE 예제 (WiFi 통신)

ESP8266 Arduino IDE 는 ESP8266 모듈의 펌웨어를 제작하는 가장 간단한 방법입니다. ESP8266 Arduino IDE 개발환경을 설치하는 방법은 아래 문서를 참고하세요.

• http://www.hardcopyworld.com/gnuboard5/bbs/board.php?bo_table=lecture_esp&wr_id=32

ESP8266을 위한 다양한 예제가 이미 갖추어져 있습니다. [Arduino IDE – File – Examples – ESP8266xxx] 예제들을 보면 다양한 기능들을 구현하는 방법이 나옵니다. 여기서 소개하는 예제는 NodeMCU V1 (ESP12E 기반) 보드에서 동작 테스트를 한 예제들입니다. 그리고 소개를 위해 예제 코드에 약간의 변형이 가해졌습니다.

NodeMCU 보드는 아래와 같이 핀이 배치되어 있으며, 펌웨어 업로드를 위해 필요한 FTDI 모듈을 내장하고 있어서 PC에 USB 연결만 하면 사용할 수 있습니다.

Blink (Digital Output)

가장 쉽고 단순한 LED 켜기 예제입니다. 소스코드는 아래 링크에서 보실 수 있습니다.

• https://github.com/godstale/ESP8266_Arduino_IDE_Example/blob/master/example/DigitalOutput_Blink/DigitalOutput_Blink.ino

LED 는 저항과 함께 NodeMCU 보드의 GPIO14 (D5) 핀에 연결하면 됩니다.

int LED = 14;    // Use D5, GPIO14

void setup() {
  pinMode(LED, OUTPUT);     // Initialize the LED pin as an output
}

// the loop function runs over and over again forever
void loop() {
  digitalWrite(LED, LOW);   // Turn the LED
  delay(1000);    // Wait for a seconds
  digitalWrite(LED, HIGH);  // Turn the LED
  delay(1000);    // Wait for a seconds
}

코드를 보시면 아실 수 있듯, 핀 번호 빼고 아두이노 스케치와 완전 동일합니다. pinMode() 함수를 이용해 특정 핀을 초기화 해줬습니다. 그리고 digitalWrite 함수로 3V 출력을 on/off 해줍니다.

아두이노 개발환경이 ESP8266 모듈을 지원하도록 만든 목적이 바로 이겁니다. 전 세계적으로 가장 보편화된 개발방법을 ESP8266 에도 적용함으로써 기존에 존재하던 수 많은 라이브러리를 쓸 수 있게도 해주고, 보다 쉽게 ESP8266 펌웨어 제작을 시작하도록 도와줍니다.

아두이노와 사용법은 동일하지만 한 가지 주의할 점이 있습니다. setup() 함수이후 loop() 함수는 무한 반복됩니다. 이때 loop() 함수가 한번 끝까지 실행되고 다음 loop() 함수가 실행되기전 ESP8266 의 복잡한 WiFi 통신 기능들을 처리하기 위해 ESP8266 core가 실행됩니다. 따라서 loop() 함수에서 너무 복잡한 작업을 처리해버리면 ESP8266 core가 충분히 자기 역할을 할 수 없습니다. 가급적 loop()를 빨리 처리하고 제어권을 넘겨줘야 합니다.

가이드에서는 loop() 안의 사용자 루틴이 50ms 이내에 끝나기를 권장합니다. 만약 이 이상의 시간을 요할경우 중간에 delay() 함수로 약간의 시간 간격을 주는 것이 좋습니다. delay() 는 사용자의 루틴을 잠시 멈추고 ESP8266 core가 동작할 수 있도록 해줍니다. (yield() 함수도 같은 역할을 하는듯 합니다.)

Button (Digital Input)

digitalWrite() 함수를 이용해서 LED 출력을 제어해봤으니 이번에는 digitalRead() 함수를 이용해서 디지털 입력을 받아보겠습니다. 버튼을 연결해서 클릭을 인식한 뒤, LED를 on/off 시키는 예제입니다.

• https://github.com/godstale/ESP8266_Arduino_IDE_Example/blob/master/example/DigitalInput_Button/DigitalInput_Button.ino

버튼을 GPIO4(D2) 핀에 pull-down 저항을 이용해 연결합니다.

• ESP8266 GPIO14 ==> 버튼 다리 1
• ESP8266 3V ==> 버튼 다리 2
• ESP8266 GND ==> 10K 저항 ==> 버튼 다리 2

소스코드는 아래와 같습니다.

int LED = 14;    // Use D5, GPIO14
int BUTTON = 4;    // Use D2, GPIO4

void setup() {
  Serial.begin(115200);
  pinMode(LED, OUTPUT);     // Initialize the LED pin as an output
  pinMode(BUTTON, INPUT);     // Initialize the BUTTON pin as an input
}

// the loop function runs over and over again forever
void loop() {
  boolean buttonPressed = digitalRead(BUTTON);
  Serial.println(buttonPressed);
  digitalWrite(LED, buttonPressed);
  delay(100);  // Wait for a while
}

setup() 초기화 함수에서 버튼 입력을 받기 위해 GPIO 4번 핀을 INPUT 모드로 초기화 했습니다.

그리고 loop() 반복함수에서는 digitalRead() 함수로 버튼 상태를 읽습니다. 값은 HIGH(=true, 3V, 버튼 클릭) 또는 LOW(=false, 0V, GND, 버튼 릴리즈) 값으로 들어옵니다. 따라서 이 값을 그대로 digitalWrite() 함수에 전달해주면 버튼을 누를때마다 LED가 켜집니다.

Potentiometer (ANALOG INPUT)

이번에는 아날로그 입력을 받는 방법입니다. 소스코드는 아래 링크에 있습니다.

• https://github.com/godstale/ESP8266_Arduino_IDE_Example/blob/master/example/AnalogInput_Potentiometer/AnalogInput_Potentiometer.ino

아날로그 입력을 테스트 하기 위해서 포텐셔미터를 사용했습니다. 포텐셔미터를 ADC0(A0) 아날로그 핀에 연결하면 됩니다.

• 포텐셔미터 1 핀 ==> ESP8266 3V
• 포텐셔미터 2 핀 (가운데 핀) ==> ESP8266 ADC0(A0)
• 포텐셔미터 3 핀 ==> ESP8266 GND

그리고 소스코드를 올리면 시리얼 통신으로 포텐셔미터에서 읽은 아날로그 입력값을 출력해줍니다.

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

// the loop function runs over and over again forever
void loop() {
  int analog = analogRead(A0);
  Serial.println(analog);
  delay(100);  // Wait for a while
}

아두이노와 동일합니다. analogRead() 함수로 아날로그 핀의 전압 변화를 읽을 수 있습니다. 단, ESP8266 모듈은 아날로그 입력 핀이 하나(A0, ADC0) 뿐입니다.

소스에서는 시리얼 통신을 위해 Serial.begin() 으로 통신 초기화를 해줬습니다. 아두이노처럼 Serial.print(), println(), available(), read() 함수를 사용할 수 있습니다.

LED DIMMING (PWM – ANALOG OUTPUT)

이번 예제에서는 PWM을 이용해서 LED 밝기를 조절해 볼겁니다. 앞선 예제에서 포텐셔미터를 연결했으니 포텐셔미터로 LED 밝기 조절이 가능하도록 할겁니다. 소스코드는 아래에서 구할 수 있습니다.

• https://github.com/godstale/ESP8266_Arduino_IDE_Example/blob/master/example/AnalogOutput_Dimming/AnalogOutput_Dimming.ino

앞서 사용한 LED, 포텐셔미터를 그대로 사용하시면 됩니다.

int LED = 14;    // Use D5, GPIO14

void setup() {
  Serial.begin(115200);
  pinMode(LED, OUTPUT);     // Initialize the LED pin as an output
}

// the loop function runs over and over again forever
void loop() {
  int analog = analogRead(A0);
  Serial.println(analog);
  analogWrite(LED, analog/4);
  delay(100);  // Wait for a while
}

PWM 사용은 간단합니다. setup() 초기화 함수에서 pinMode()로 LED 핀을 OUTPUT 모드로 초기화 합니다. 그리고 analogWrite() 함수로 값을 써주면 됩니다. (0~255)

포텐셔미터의 값을 읽는 analogRead() 범위가 0~1023이니 4로 나눠준 값을 analogWrite() 함수에 사용하면 됩니다.

기타 예제

위에서 소개한 간단한 예제 외에도 다양한 센서 사용을 위한 아두이노 라이브러리들을 사용할 수 있습니다. 아두이노 제어를 위해 레지스트리를 건드리지 않는 라이브러리의 경우 ESP8266에서도 문제 없이 사용 가능한 것으로 알려져 있습니다. 아래 라이브러리들은 ESP8266에서도 사용 가능한 (테스트 된) 호환 라이브러리입니다.

• Adafruit_ILI9341 – Port of the Adafruit ILI9341 for the ESP8266
• arduinoVNC – VNC Client for Arduino
• arduinoWebSockets – WebSocket Server and Client compatible with ESP8266 (RFC6455)
• aREST – REST API handler library.
• Blynk – easy IoT framework for Makers (check out the Kickstarter page).
• DallasTemperature
• DHT-sensor-library – Arduino library for the DHT11/DHT22 temperature and humidity sensors. Download latest v1.1.1 library and no changes are necessary. Older versions should initialize DHT as follows: DHT dht(DHTPIN, DHTTYPE, 15)
• Encoder – Arduino library for rotary encoders. Version 1.4 supports ESP8266.
• NeoPixel – Adafruit’s NeoPixel library, now with support for the ESP8266 (use version 1.0.2 or higher from Arduino’s library manager).
• NeoPixelBus – Arduino NeoPixel library compatible with ESP8266. Use the “DmaDriven” or “UartDriven” branches for ESP8266. Includes HSL color support and more.
• PubSubClient – MQTT library by @Imroy.
• RTC – Arduino Library for Ds1307 & Ds3231 compatible with ESP8266.
• Souliss, Smart Home – Framework for Smart Home based on Arduino, Android and openHAB.
• ST7735 – Adafruit’s ST7735 library modified to be compatible with ESP8266. Just make sure to modify the pins in the examples as they are still AVR specific.
• Task – Arduino Nonpreemptive multitasking library. While similiar to the included Ticker library in the functionality provided, this library was meant for cross Arduino compatibility.
• UTFT-ESP8266 – UTFT display library with support for ESP8266. Only serial interface (SPI) displays are supported for now (no 8-bit parallel mode, etc). Also includes support for the hardware SPI controller of the ESP8266.
• WiFiManager – WiFi Connection manager with web captive portal. If it can’t connect, it starts AP mode and a configuration portal so you can choose and enter WiFi credentials.
• OneWire – Library for Dallas/Maxim 1-Wire Chips.
• Adafruit-PCD8544-Nokia-5110-LCD-Library – Port of the Adafruit PCD8544 – library for the ESP8266.

인터넷을 검색해 보면 이 외에도 주요한 센서들의 예제를 구하실 수 있습니다.

참고자료

• ESP8266 Arduino IDE official

본 문서는 아두이노 개발환경(IDE)를 이용해서 ESP8266 모듈을 다루는 예제들을 포함하고 있습니다.

• ESP8266 – ARDUINO IDE 예제 (GPIO 제어)
• ESP8266 – ARDUINO IDE 예제 (WiFi 통신)

ESP8266 Arduino IDE 는 ESP8266 모듈의 펌웨어를 제작하는 가장 간단한 방법입니다. ESP8266 Arduino IDE 개발환경을 설치하는 방법은 아래 문서를 참고하세요.

• http://www.hardcopyworld.com/gnuboard5/bbs/board.php?bo_table=lecture_esp&wr_id=32

ESP8266을 위한 다양한 예제가 이미 갖추어져 있습니다. [Arduino IDE – File – Examples – ESP8266xxx] 예제들을 보면 다양한 기능들을 구현하는 방법이 나옵니다. 여기서 소개하는 예제는 NodeMCU V1 (ESP12E 기반) 보드에서 동작 테스트를 한 예제들입니다. 그리고 소개를 위해 예제 코드에 약간의 변형이 가해졌습니다.

NodeMCU 보드는 아래와 같이 핀이 배치되어 있으며, 펌웨어 업로드를 위해 필요한 FTDI 모듈을 내장하고 있어서 PC에 USB 연결만 하면 사용할 수 있습니다.

WiFi 통신 기본

WiFi 통신을 위한 기초 예제입니다. 아래에서 소스코드를 구하실 수 있습니다.

• https://github.com/godstale/ESP8266_Arduino_IDE_Example/blob/master/example/WiFiClientEvents/WiFiClientEvents.ino

이 소스코드는 단순히 ESP8266 모듈을 공유기에 연결만 시킵니다. 그리고 그 과정에서 발생되는 WiFi 이벤트를 받아서 처리하는 방법을 설명합니다.

테스트를 위해서는 파일 상단에 공유기(AP)의 SSID, 비밀번호를 지정해줘야 합니다.

const char *ssid = "your_ssid";
const char *password = "your_pass";

소스코드의 setup() 초기화 함수를 보겠습니다.

void setup() {
    Serial.begin(115200);

    // delete old config
    WiFi.disconnect(true);
    delay(1000);
    WiFi.onEvent(WiFiEvent);
    WiFi.begin(ssid, password);
    Serial.println("Wait for WiFi... ");
}

WiFi 가 ESP8266 core에서 제공하는 통신 기능들에 접근할 수 있는 인스턴스입니다. WiFi.onEvent() 함수를 이용해 이벤트가 발생했을 때 실행될 콜백함수를 지정할 수 있습니다.

WiFi.onEvent(WiFiEvent);

위 처럼 지정되어 있으므로 이벤트가 발생하면 WiFiEvent() 함수가 호출됩니다. 이벤트가 발생했을 때 하고 싶은 작업을 WiFiEvent() 함수에 구현하면 됩니다.

사용가능한 함수는 ESP8266WiFiType.h 에서 확인하실 수 있습니다.

typedef enum {
    WIFI_EVENT_STAMODE_CONNECTED = 0,
    WIFI_EVENT_STAMODE_DISCONNECTED,
    WIFI_EVENT_STAMODE_AUTHMODE_CHANGE,
    WIFI_EVENT_STAMODE_GOT_IP,
    WIFI_EVENT_STAMODE_DHCP_TIMEOUT,
    WIFI_EVENT_SOFTAPMODE_STACONNECTED,
    WIFI_EVENT_SOFTAPMODE_STADISCONNECTED,
    WIFI_EVENT_SOFTAPMODE_PROBEREQRECVED,
    WIFI_EVENT_MAX
} WiFiEvent_t;

보시다시피 AP에 연결된 후 IP를 받아오는 과정까지 이벤트를 발생합니다.

SSID, 패스워드를 이용해 AP에 연결하는 함수는 setup() 안에 있는 WiFi.begin() 입니다.

• WiFi.begin(ssid, password);

WiFi Client (HTTP Request)

이번 예제는 ESP8266 모듈을 공유기에 연결하고, 외부의 HTTP 서버에 요청을 보내서 결과(HTML 또는 파일)를 받아오는 예제입니다.

• https://github.com/godstale/ESP8266_Arduino_IDE_Example/blob/master/example/WiFiClient/WiFiClient.ino

이 문서의 예제들은 모두 아래 SSID, 패스워드를 자신의 환경에 맞게 지정해줘야 동작합니다.

const char *ssid = "your_ssid";
const char *password = "your_pass";

이번 예제에서 HTTP 통신을 통해 받아올 서버도 미리 지정해주세요.

const char* host = "hardcopyworld.com";

먼저 setup() 함수의 내용부터 보겠습니다. 주요 내용만 뽑아내면 아래와 같습니다.

void setup() {
  ......
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  ......
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}

WiFi.begin(ssid, password) 함수를 이용해서 공유기에 연결합니다. 이후 이어지는 while() 반복문은 공유기에 접속할 때까지 기다리기 위해 사용했습니다.

공유기에 접속되면 아래 코드처럼 Serial 통신으로 할당받은 IP를 출력해 주는 것이 편리합니다.

• Serial.println(WiFi.localIP());

loop() 반복함수에서 주기적으로(약 5초 간격) HTTP 요청을 서버로 보냅니다. 그리고 받은 결과를 Serial 통신으로 출력해줍니다. 주요 코드만 발췌하면 아래와 같습니다.

void loop() {
  delay(5000);
  ......
  // Use WiFiClient class to create TCP connections
  WiFiClient client;
  const int httpPort = 80;
  if (!client.connect(host, httpPort)) {
    Serial.println("connection failed");
    return;
  }
  // We now create a URI for the request
  String url = "/";
  // This will send the request to the server
  client.print(String("GET ") + url + " HTTP/1.1\r\n" +
               "Host: " + host + "\r\n" + 
               "Connection: close\r\n\r\n");
  int timeout = millis() + 5000;
  while (client.available() == 0) {
    if (timeout - millis() < 0) {
      Serial.println(">>> Client Timeout !");
      client.stop();
      return;
    }
  }
  
  // Read all the lines of the reply from server and print them to Serial
  while(client.available()){
    String line = client.readStringUntil('\r');
    Serial.print(line);
  }
}

가장 먼저 나오는 WiFiClient 클래스는 TCP 연결을 만들기 위해 사용합니다. host와 port 를 지정하면 해당 서버에 TCP 연결을 만듭니다. 이때 사용되는 host 변수에는 도메인 이름 [hardcopyworld.com] 이 사용되어야 합니다.

WiFiClient client;
  const int httpPort = 80;
  if (!client.connect(host, httpPort)) {
    Serial.println("connection failed");
    return;
  }

TCP 연결이 성공하면 HTTP Request 형식에 맞게 내용을 작성해서 전송하면 됩니다.

client.print(String("GET ") + url + " HTTP/1.1\r\n" +
               "Host: " + host + "\r\n" + 
               "Connection: close\r\n\r\n");

여기서 url 변수는 host 도메인 내부에서 내가 원하는 리소스까지의 경로입니다. 만약 [http://www.google.com/my/resource.html] 에 요청을 보내고 싶다면 host는 [http://www.google.com] 이 됩니다. url 은 [/my/resource.html] 로 지정해줘야 합니다.

만약 http://google.com 메인 페이지의 내용을 얻고 싶다면 host는 [http://google.com], url은 [/] 로 지정해주면 됩니다.

client.print() 함수를 이용해서 요청이 전송되면 일정 시간 후 응답이 옵니다.

while (client.available() == 0) {
    if (timeout - millis() < 0) {
      Serial.println(">>> Client Timeout !");
      client.stop();
      return;
    }
  }

client 의 상태를 체크해서 응답이 왔는지 확인한 코드입니다.

HTTP Response가 도착하면 아래 코드로 한 라인씩 읽어 Serial 통신으로 출력할 수 있습니다. 특별한 기능을 만들고 싶을 때 이 부분을 적절히 수정하면 됩니다.

while(client.available()){
    String line = client.readStringUntil('\r');
    Serial.print(line);
  }

Web server

이번에는 ESP8266 모듈을 웹 서버로 만드는 방법입니다. 이 방법을 사용하면 외부 장치에서 브라우저로 ESP8266 모듈에 접속해서 HTML 페이지를 볼 수 있습니다. 소스코드는 아래에서…

• https://github.com/godstale/ESP8266_Arduino_IDE_Example/blob/master/example/AdvancedWebServer/AdvancedWebServer.ino

테스트 전 GPIO13 (D7) 핀에 LED를 하나 연결해두세요. 외부에서 접속 요청이 오면 LED가 켜지도록 만들겁니다.

파일 상단에서 공유기 설정을 해줘야 합니다.

const char *ssid = "your_ssid";
const char *password = "your_pass";
ESP8266WebServer server ( 80 );
const int led = 13;

ESP8266WebServer 클래스에 웹 서버로 동작하기 위한 기능들이 들어 있습니다. 80번 포트로 HTTP 통신을 하도록 지정되어 있습니다. 일반적인 웹 서버의 통신 포트로 브라우저에서 특별히 지정하지 않으면 80번 포트를 사용합니다.

setup 함수의 주요 코드부터 보겠습니다.

void setup ( void ) {
	......
	WiFi.begin ( ssid, password );
	......
	server.on ( "/", handleRoot );
	server.on ( "/test.svg", drawGraph );
	server.on ( "/inline", []() {
		server.send ( 200, "text/plain", "this works as well" );
	} );
	server.onNotFound ( handleNotFound );
	......
	server.begin();
	......
}

WiFi.begin() 함수로 공유기에 접속합니다. 이후 공유기 접속을 기다리고 할당받은 IP 주소를 Serial 통신으로 출력해줍니다.

sever.on() 함수부터 본격적인 서버설정 코드입니다. 코드에서는 3개의 URL에 대한 콜백함수를 지정해 줬습니다.

• http://192.168.x.x/ : 서버의 루트[/] 경로에 대한 요청은 handleRoot() 콜백함수가 처리
• http://192.168.x.x/inline : [/inline] 경로에 대한 요청은 인라인 함수가 처리 – [this works as well] 메시지를 전달
• http://192.168.x.x/test.svg : [/test.svg] 경로에 대한 접근은 drawGraph 콜백함수가 처리

만약 위 경로에 해당되지 않는 요청이 올 경우는 handleNotFound() 콜백함수가 처리하도록 지정되어 있습니다.

이상 서버 설정이 끝나면 아래 코드로 서버를 시작합니다.

• server.begin();

loop() 함수에서는 외부에서 접속 요청이 오는지 모니터링 하는 코드가 들어 있을 뿐입니다.

void loop ( void ) {
	server.handleClient();
}

요청이 들어오면 해당되는 콜백함수가 실행됩니다. handleRoot() 함수를 보시면 HTML 문자열을 client에게 전송하는 방법을 알 수 있습니다.

조금 특이한게 drawGraph() 콜백함수인데, [/test.svg] 파일에 대한 요청이 오면 처리해주는 함수입니다. svg 는 벡터 이미지를 생성하기 위한 XML 파일입니다. svg 파일은 이미지 파일이 아니라 벡터 이미지를 그리기 위한 정보를 XML 텍스트로 담고 있습니다. 이 파일을 브라우저가 받으면 해당 정보대로 이미지를 그려 보여주기 때문에 마치 이미지 파일처럼 쓸 수 있습니다.

그래서 drawGraph() 콜백함수는 일련의 XML 데이터를 문자열로 만들어 전송해줍니다. 브라우저에서 [http://x.x.x.x/test.svg] 경로에 접속해보면 이미지가 보일껍니다.

앞서 handleRoot() 콜백함수가 생성하는 HTML 코드에도 [/test.svg] 이미지가 포함되어 있습니다. 따라서 브라우저는 [/test.svg] 에 대한 요청도 추가로 해서 벡터 이미지가 포함된 화면을 그려줍니다.

Web Socket (server)

앞선 예제처럼 웹 서버는 외부에서의 요청이 있을때마다 HTML 페이지를 응답으로 보내줍니다. 그럼 브라우저는 HTML 페이지를 화면에 그려줍니다. 이 방식은 전통적인 웹의 동작 방식이지만 화면 혹은 서버에 데이터 변화가 있는지 확인하기 위해 주기적으로 웹 서버에 (같은 URL 주소에) 요청을 다시 보내고 화면을 다시 그려야 합니다. 그보다는 백그라운드로 서버와 브라우저가 연결되어 양방향으로 통신을 할 수 있다면 불필요한 HTTP 요청을 없애고 화면 일부만 업데이트가 가능할 것입니다.

Web Socket 이 이런 자유로운 통신 방식을 제공해줍니다. HTML5에 포함된 Web Socket은 웹 서버와 클라이언트(브라우저의 JavaScript) 간 TCP/IP 연결을 유지하게 해 줌으로써 양방향 데이터 전송도 지원합니다. 브라우저가 업데이트를 확인하기위해 계속 서버를 체크하지 않고도 서버에서 오는 알림에 반응할 수 있는 push가 가능합니다.

다만, 이 기능을 사용하기 위해서는 비교적 최신의 브라우저를 사용해야 하는 제약이 있습니다. 그리고 당연히 서버에는 WebSocket 통신을 위한 준비가 되어 있어야 합니다. 이번 예제는 ESP8266 모듈에 웹 서버 + 웹 소켓 기능을 심을겁니다.

웹 소켓 사용을 위해서는 라이브러리를 추가로 설치해줘야 합니다.

• https://github.com/Links2004/arduinoWebSockets

그리고 불행히도, 현재(2016, 01 기준) 아두이노 IDE – 패키지 매니저로 배포되는 ESP8266 core 에는 라이브러리 지원에 필요한 코드가 일부 빠져있어서 에러가 발생합니다. 따라서 이번 예제를 테스트하기 위해서는 최신 ESP8266 core for Arduino 코드를 받아 수동으로 업데이트 해줘야 합니다.

• https://github.com/esp8266/Arduino

웹 소켓 테스트 예제는 아래 링크에 있습니다.

• https://github.com/godstale/ESP8266_Arduino_IDE_Example/tree/master/example/WebSocketServer_LEDcontrol

ino 스케치 파일의 상단에 보면 웹 서버, 웹 소켓을 위한 인스턴스가 선언되어 있습니다. 코드를 보면 아실 수 있듯 웹 서버와 웹소켓은 각각 80번, 81번 포트를 사용합니다.

ESP8266WebServer server = ESP8266WebServer(80);
WebSocketsServer webSocket = WebSocketsServer(81);

setup() 함수부터 보겠습니다.

void setup() {
    ......
    WiFiMulti.addAP("your_ssid", "your_pass");
    ......
    webSocket.begin();
    webSocket.onEvent(webSocketEvent);
    ......
    // handle index
    server.on("/", []() {
        // send index.html
        server.send(200, "text/html", html_string);
    });
    server.begin();
    ......
}

앞선 예제와는 조금 다르게 WiFiMulti.addAP() 함수로 공유기엔 연결 했습니다. 별 차이 없습니다만, 여러개의 AP를 등록해서 자동 연결되도록 관리해주는 방법입니다.

이어서 웹 소켓을 초기화하고 웹 소켓 관련 이벤트(연결, 데이터수신, 종료)가 발생하면 처래해 줄 콜백 함수 webSocketEvent()를 등록 했습니다.

웹 서버는 [http://192.168.x.x] 처럼 루트[/] 경로에 대한 요청이 올 때 html_string 텍스트를 전달하도록 해뒀습니다. html_string은 html.h 파일에 들어있는 HTML 코드입니다.

HTML 코드에는 같은 서버의 81번 포트에 웹 소켓으로 연결하도록 자바스크립트 코드가 들어가 있습니다. 그리고 웹 소켓으로 RGB LED 밝기를 조절하기 위한 코드가 들어가 있습니다.

즉, 브라우저로 ESP8266 모듈에 [http://192.168.x.x] 경로로 접속하면 HTML 코드를 다운로드 받아 브라우저가 화면을 그려줍니다. 그리고 백그라운드로 웹 소켓을 ESP8266 모듈과 연결해둡니다. 브라우저 화면에는 3개의 슬라이드 바가 있는데, 바를 움직이면 웹 소켓으로 ESP8266 모듈에 데이터를 전송합니다. 그럼 ESP8266 모듈이 데이터를 받아 RGB LED 색상을 조절합니다.

ESP8266 모듈이 데이터를 받으면 앞서 등록한 webSocketEvent() 콜백 함수가 호출됩니다.

void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t lenght) {
    switch(type) {
        case WStype_DISCONNECTED:
            break;
        case WStype_CONNECTED: {
            ......
            webSocket.sendTXT(num, "Connected");
        }
            break;
        case WStype_TEXT:
            USE_SERIAL.printf("[%u] get Text: %s\n", num, payload);
            if(payload[0] == '#') {
                // decode rgb data
                uint32_t rgb = (uint32_t) strtol((const char *) &payload[1], NULL, 16);
                analogWrite(LED_RED,    ((rgb >> 16) & 0xFF));
                analogWrite(LED_GREEN,  ((rgb >> 8) & 0xFF));
                analogWrite(LED_BLUE,   ((rgb >> 0) & 0xFF));
            }
            break;
    }
}

웹 소켓 연결 요청이 와서 연결되면 case WStype_CONNECTED: 부분이 실행됩니다. 여기 코드를 보시면 웹 소켓으로 데이터를 보내는 방법을 알 수 있습니다. 아래 함수를 이용해서 상대방(브라우저)에게 데이터를 보냅니다.

• webSocket.sendTXT(num, “Connected“);

위 함수는 특정 상대방에게 데이터를 보내는 방법입니다. 연결된 장치들 모두에게 데이터를 보낼 때는 아래 함수를 사용하면 됩니다.

• webSocket.broadcastTXT(“Message from ESP8266!!“);

case WStype_CONNECTED: 여기에 적힌 코드들은 웹 소켓으로 데이터를 받았을 때를 위한 것입니다. 데이터를 분석해서 RGB 색상값을 얻은 뒤, RGB LED 색을 조절하겠죠.

이 외에도 2대의 ESP8266 모듈을 이용해 재밌는 실험을 해볼 수 있습니다. 하나의 ESP8266 모듈은 웹 소켓 서버로 만들고, 다른 한 대는 웹 소켓 클라이언트로 만들어서 두 대의 ESP8266 모듈이 웹 소켓 통신을 하도록 하는겁니다.

이 방법은 아래의 두 예제 파일을 참고해서 직접 만들어 보시길 바랍니다.

• ESP8266 웹 소켓 서버 예제
• ESP8266 웹 소켓 클라이언트 예제

HTTP 서버, 클라이언트 기능을 모두 활용하는 아래 예제도 참고하세요.

• https://github.com/amiravni/ESP8266-Water-Heater-Control/blob/master/TheDude.ino

PS.

• ESP8266 Arduino IDE 안에는 WiFi 통신 관련된 다양한 예제가 마련되어 있습니다. [File – Example] 메뉴에서 예제를 불러와 테스트 해볼 수 있습니다. 하지만 최신 ESP8266 core 로 업데이트 한 이후, 많은 예제들이 오동작 하는 문제가 있었습니다.
• 예제들의 동작이 확인 되면 문서에 추가하겠습니다.
• 보다 파워풀한 WiFi 통신 기능을 테스트하고 싶다면 Sming framework 을 추천합니다. 개발환경 구축과정이 조금 복잡해도 아두이노 개발환경보다 더 안정적이고 유용합니다.
• Sming framework 구축방법, Sming 을 이용한 예제들

홈 오토메이션 솔루션 중 하나인 Home_Assistant(이하 HA) 설치 및 기본 설정 방법을 다루는 문서입니다.

파이썬 3.4.x 설치

HA 설치를 위해서는 파이썬 3.4 버전이 필요합니다. 파이썬 해당 버전이 기본으로 설치되어 있는 경우는 아래 내용을 건너 뛰어도 됩니다. 파이썬이 기본으로 설치되어 있어도 버전이 2.x 인 경우는 설치를 해줘야 합니다. 아래 명령으로 버전 확인하세요.

• python -V
• python3 -V

Python 3 다운로드 및 압축해제

• wget https://www.python.org/ftp/python/3.4.4/Python-3.4.4.tgz
• tar xvzf Python-3.4.4.tgz

빌드, 인스톨

• cd Python-3.4.4
• ./configure
• make
• sudo make install

PIP3 업그레이드

• sudo pip3 install –upgrade pip

Home Assistant 설치

홈 어시스턴트 설치

• sudo pip3 install homeassistant

홈 어시스턴트 실행

• hass –open-ui

위 명령을 실행하면 웹 인터페이스가 8123 포트로 열립니다. http://x.x.x.x:8123 주소로 브라우저 접속하면 확인할 수 있습니다.

Home Assistant 설정

OpenHAB, Home Assistant 같은 범용 홈 오토메이션 솔루션들은 설정과정이 꽤나 복잡합니다. 여러가지 시도를 해보고 관련된 자료들도 보고 공부를 해야 제대로 쓸 수 있습니다. 여기서는 가장 간단한 설정만 다루겠습니다.

자신의 홈 디렉터리 아래 [~/.homeassistant] 경로에 있는 configuration.yaml 파일을 이용해 설정을 수정할 수 있습니다.

• cd ~/.homeassistant
• nano configuration.yaml

기본이 되는 환경 변수부터 설정해줍니다.

homeassistant:
  # Name of the location where Home Assistant is running
  name: your_home_name
  # Location required to calculate the time the sun rises and sets
  latitude: 37.5345
  longitude: 127.1324
  # C for Celcius, F for Fahrenheit
  temperature_unit: C
  # Pick yours from here: http://en.wikipedia.org/wiki/List_of_tz_database_time_zones
  time_zone: Asia/Seoul

name, latitude, longitude 등의 값을 원하는 대로 바꿔주면 됩니다.

그리고 아래 내용을 추가해서 웹 인터페이스 접근시 암호를 입력하도록 수정합니다.

http:
  api_password: YOUR_PASSWORD

암호 입력 후 저장합니다. 설정을 적용하기 위해서는 홈 어시스턴트 재실행이 필요합니다.

• hass –open-ui

웹에 다시 접속해보면 아직 화면이 허전할겁니다. 날씨 정보를 상단 동그라미 아이콘으로 추가해 보겠습니다.

# Need to register on Forecast.io for your PRIVATE API
sensor 1:
  platform: forecast
  name: "Weather Seoul"
  api_key: your_api_key
  monitored_conditions:
    - summary
    - temperature
    - humidity
    - ozone
    - wind_speed

위 내용을 입력하면 센서 정보가 추가됩니다. 날씨 정보는 forecast.io 에서 가져오기 때문에 forecast.io 에 브라우저로 접속해서 회원가입-API 키를 발급 받으세요. 그리고 API 키를 적어주면 됩니다.

홈 어시스턴트 재실행 후 다시 접속해보면 상단에 날씨 정보가 표시될겁니다.

유사한 방법으로 HA 가 실행되는 하드웨어 정보도 보여줄 수 있습니다. 아래 내용을 입력 후

sensor 2:
  platform: systemmonitor
  resources:
    - type: 'disk_use'
      arg: '/home'
    - type: 'memory_use_percent'
    - type: 'processor_use'

재실행 하면 상단 정보창이 풍성해집니다.

MQTT 를 이용한 센서 데이터 추가

MQTT 브로커와 센서 장치를 연동해서 HA 에서 센서값을 모니터링 할 수 있도록 해보겠습니다. MQTT 브로커 설치 방법과 센서 장치 제작 방법은 아래 링크를 참고하세요. (일단은 HA 설정부터 하시고 아래 가이드를 참고하세요)

• MQTT 프로토콜 분석과 테스트

HA 에서 MQTT 데이터를 받아오기 위해서는 MQTT 브로커와의 연결 설정을 해줘야 합니다. 아래 내용을 설정 파일에 추가합니다.

mqtt:
  broker: localhost
  port: 1883
  client_id: home-assistant-1
  keepalive: 60
  username:
  password:
  certificate:
  protocol: 3.1

제 경우는 라즈베리파이에 HA, MQTT 브로커가 모두 설치되어 있어서 localhost를 사용했습니다. 외부의 MQTT 브로커를 사용하는 경우 IP 또는 도메인 이름을 적어주면 됩니다.

이제 HA 설정 파일에서 특정 토픽을 구독(subscribe)하고 지정된 형식의 값이 도착하면 화면에 표시해주도록 설정하면 됩니다.

sensor 3:
  platform: mqtt
  state_topic: "home/thirdroom/temp_humi"
  name: "Thirdroom Humidity"
  qos: 0
  unit_of_measurement: "%"
  value_template: '{{ value_json.humi }}'

sensor 4:
  platform: mqtt
  state_topic: "home/thirdroom/temp_humi"
  name: "Thirdroom Temperature"
  qos: 0
  unit_of_measurement: "°C"
  value_template: '{{ value_json.temp }}'

여기까지 설정하면 앞선 날씨, 시스템 정보처럼 상단 동그라미 아이콘으로 온습도가 표시됩니다. 이걸 보기 편하게 하단 카드 형태로 표시하려면 아래와 같이 그룹으로 만들어줍니다.

group:
  Third Room:
    - sensor.thirdroom_temperature
    - sensor.thirdroom_humidity

홈 어시스턴트 서버 설정은 끝났습니다. 이제 MQTT 브로커를 설치하고 센서장치를 제작하면 됩니다. 아래 링크 하단부에 해당 내용이 나와 있습니다.

• MQTT 프로토콜 분석과 테스트

MQTT 브로커와 센서 장치가 준비되면 센서 장치에서 주기적으로 온도, 습도 데이터를 MQTT 브로커에 쏴주면 됩니다. 이때 데이터는 정해진 토픽에 JSON 데이터 형식으로 쏴주도록 만들어둬야 합니다.

• 온습도 데이터
  • 토픽 : home/thirdroom/temp_humi
  • JSON 데이터 형식 : {“temp”: 26.14, “humi”: 68.71}

여기까지 문제가 없으면 주기적으로 도착하는 MQTT 메시지에서 temp, humi 값을 추출해 화면에 표시합니다. HA를 다시 실행하고 웹으로 확인하면 아래처럼 센서값을 계속 모니터링하게 됩니다.

이 외에도 MPD 오디오 스트리밍 제어, Plex 미디어 센터, 매크로, 스크립트 등등 수 많은 기능들을 설정할 수 있습니다. 아래 링크들을 참고해서 직접 추가해 보시길…

• 설정 파일 예제
• 자동화, 커스텀 컴포넌트 및 설정 예제

참고자료

• Home-Assistant Getting Started
• Home-Assistant Official Homepage
• Home-Assistant Components

장고걸 가이드 페이지에서는 virtualenv 가상 환경을 이용해서 장고를 실행하도록 권하는데.. 그러기 위해선 아래 과정을 해두어야함.. 귀찮으면 virtualenv 설정 과정은 안해도 됨.

• 참고 사이트 : http://gyus.me/?p=465

virtualenv 설치

virtualenv를 설치하는 이유

• 파이썬 패키지를 설치할 때 관리자 권한이 아니라 유저 권한으로 설치
• 파이썬의 실행 환경을 리눅스의 것과 온전히 구분 – 디렉터리, 파일 구조를 분리해 둠
• python3 을 사용할 때 python 명령으로 실행
• 개발환경과 실서버환경을 동일하게 맞춤

virtualenvwrapper 설치

• sudo pip install virtualenv
• sudo pip install virtualenvwrapper

virtualenv 환경 설정

디폴트 디렉토리 만들기 (.virtualenv)

• mkdir ~/.virtualenvs

WORKON_HOME 환경 변수에 디폴트 디렉토리 등록

• export WORKON_HOME=~/.virtualenvs

.profile(우분투 기준 유저 로그인시 실행되는 스크립트) 에 virtualenvwrapper를 임포트 하도록 위 파일의 가장 하단에 아래 스크립트 추가

. /usr/local/bin/virtualenvwrapper.sh

적용

• source /usr/local/bin/virtualenvwrapper.sh

가상환경 만들기

위의 과정을 잘 따라했다면 virtualenvwrapper.sh 내에 있는 함수인 mkvirtualenv 함수를 사용할 수 있다.

• mkvirtualenv {{가상환경-이름}}

사용법

• mkvirtualenv py2

요렇게하면 py2라는 이름의 가상환경이 설치되고 그 가상환경을 사용할 수 있게(workon) 된다.

• which python

명령어를 실행했을 때 아래와 같은 경로로 나오면 제대로 된것이다.

• /home/user_name/.virtualenvs/py2/bin/python

가상환경에서 나가려면

• $ deactivate

다시 들어가려면

• $ workon py2

장고(Django) 설치

장고 설치:

• sudo pip install django

프로젝트 생성

• cd ~/pyBook
• python manage.py startapp homepack

테스트

• cd homepack
• python manage.py migrate
• python manage.py runserver

http://rpi_IP_address:8000/ 주소로 접속해서 확인

장고 입문 강좌

• http://blog.hannal.com/category/start-with-django-lectures/ ()
• http://tutorial.djangogirls.org/ko/index.html (장고걸)

1. 사물인터넷 개론

2. 오픈소스를 이용한 사물인터넷 구현

3. 마이크로 컨트롤러 – 아두이노

• 아두이노 소개
• 아두이노 IDE
• 아두이노 라이브러리
• 아두이노 소스 기본구조
• 아두이노 디버깅
• Digital IO
• Analog IO
• 광센서, 온습도 센서
• 서보모터
• 통신 인터페이스
  • I2C 통신 상세 가이드
  • SPI 통신 상세 가이드
  • Serial(UART) 통신 상세 가이드
• 아날로그 온습도계 만들기
• 아두이노와 외부 기기 연결방법
• 예제 프로젝트 : 비접촉식 적외선 체온계, 오픈소스 로봇팔 만들기, 미세먼지 측정기, 층간소음 측정기, 아두이노 게임기 만들기

4. 단일 보드 컴퓨터(SBC) – 라즈베리 파이

• 리눅스 초보자를 위한 가이드
• 라즈베리파이 기본 설정
• GPIO 제어
• I2C/SPI 제어
• Serial 통신 제어
• 파이캠 사진 촬영과 제어, CCTV 기능 구현
• OpenCV 설치와 파이썬 연동, 얼굴인식
• 텔레그램 메신저 연동 (TelegramCLI)
• 텔레그램을 파이썬으로 제어
• 음악 스트리밍 서버 설치와 제어 (MPD)
• MySQL DB 설치
• 장고(Django) 프로그래밍 환경 설정
• Node.js 설치 방법
• 파이썬 프로그래밍 기초 (스레드, 큐)

5. 시리얼 통신

• OTG 케이블을 이용한 USB Host 통신 (아두이노-안드로이드)
• ADK 실드
• 아두이노 레오나르도 보드를 이용한 HID 장치 구현

6. 이더넷 통신

• ENC28J60 이더넷 통신 예제 (HTTP Server)
• ENC28J60 이더넷 통신 예제 (HTTP Request)

7. 블루투스

• 클래식 블루투스
  • Part1 HC-06, RN-41/42, RN-52, AT 커맨드
  • Part2 스마트 밴드 DIY – 가속도 센서
  • Part3 스마트 밴드 DIY – 블루투스 모듈(HC-06)
  • Part4 스마트 밴드 DIY – 스마트 밴드 만들기
  • Part5 스마트 워치 DIY – OLED 디스플레이
  • Part6 스마트 워치 DIY – 스마트 워치 만들기
  • Part7 소형화 방법, 제작 사례 소개

• BLE
  • Part1 BLE 소개와 스펙 정리
  • Part2 iBeacon 장치 DIY
  • Part3 통신 모듈로 활용하는 방법
  • Part4 초소형 웨어러블 장치 만들기
  • Part5 안드로이드 BLE 소스 분석
  • nRF51822 BLE 모듈 심화 과정

8. RF 통신

• RF 모듈과 Mesh 네트워크
• HC-11 433Mhz RF통신 테스트
• RF 통신을 이용한 홈 모니터링 시스템 구축 (라즈베리파이+파이썬)

9. WiFi

• ESP8266 WiFi 모듈
  • ESP8266 Overview
  • AT 커맨드로 제어하기
  • 아두이노와 연동하기 기초, 심화
  • ESP8266 SDK로 펌웨어 만들기
  • ESP8266 ARDUINO IDE 개발환경
  • NODEMCU LUA 개발환경
  • JAVA SCRIPT 개발환경 (ESPRUINO)
  • MICROPYTHON 개발환경
• ESP8266 – Sming framework을 이용한 펌웨어 개발
  • Sming framework 개발환경 설정 (이클립스 C/C++)
  • Sming framework 개발 예제 (GPIO 제어)
  • Sming framework 개발 예제 (네트워크)
  • Sming framework 개발 예제 (웹)

10. MQTT 메시징 프로토콜과 HA(Home Automation)

• 라즈베리파이와 홈 오토메이션
• MQTT 프로토콜 분석과 테스트
• 오픈소스 홈 오토메이션 솔루션
  • OpenHAB
  • Home-Assistant
• 사물인터넷 센서장치 제작과 연동

11. 홈 오토메이션 솔루션 제작

• 홈 오토메이션 솔루션 제작을 위한 준비
• 파이썬 프로그래밍 기초 (스레드와 큐 구조)
• 파이썬과 MQTT 브로커 연동
• 센서 장치 제작
• Django 를 이용한 웹 서비스 구축

MQTT VoiceCon 은 원격에서 음성인식으로 장치를 제어하는데 사용하기 위한 안드로이드 앱입니다.

VoiceCon 앱은 메시지 전송을 위해 MQTT 프로토콜을 사용합니다. 따라서 라즈베리파이 같은 서버에 MQTT broker(server) 프로그램이 실행중이어야 합니다. 일단 MQTT broker 만 준비된다면 다양한 장치를 MQTT broker에 연결하고 VoiceCon 앱으로 음성으로 제어할 수 있습니다.

MQTT 프로토콜과 서버 구성에 대해서는 아래 링크를 참고하세요.

• MQTT 프로토콜 분석과 테스트

MQTT VoiceCon 앱은 Paho MQTT android service library 를 일부 수정해서 사용하고 있습니다. Paho 라이브러리에 대한 상세 내용은 아래 링크를 참고하세요.

• https://eclipse.org/paho/clients/android/

MQTT VoiceCon 앱은 소스가 모두 공개되어 있으니 문서 하단의 GitHub 링크에서 확인하세요.

화면 구성

앱 실행 후 왼쪽 모서리를 드래그하면 Drawer 메뉴가 열립니다. 여기에 보면 4개의 탭과 1개의 설정 화면이 있습니다. 4개의 탭 중 하나를 선택하면 해당 탭으로 이동하고, 설정을 선택하면 다이얼로그가 뜹니다.

4개의 탭은 각 화면에서 좌-우로 드래그 동작을 해도 이동할 수 있습니다.

각각의 탭이 하는 일은 다음과 같습니다.

• Controller :
  각종 컨트롤 버튼, 위젯을 제공. 마이크 이미지를 클릭하면 음성인식을 시작. 마이크 아래에서 [Switch/Slide/Keypad/Text/Color picker] 메뉴를 선택하면 해당 위젯 화면이 보여짐. 인식된 음성이나 사용자 컨트롤 결과가 원격 서버로 전송되기 위해서는 MQTT broker(server) 가 연결되어 있어야하고, 명령어가 전송될 topic을 상단에 적어줘야 함. 전송되는 메시지의 형식은 Settings(설정) 다이얼로그에서 지정할 수 있음
• MQTT History :
  MQTT broker 의 연결 상태나 메시지 송수신 내역이 표시되는 화면. 메시지를 전송(publish) 하거나 특정 topic을 구독(subscribe) 할 수 있음. 메뉴키나 우측 상단의 화살표 아이콘을 클릭하면 publish/subscribe 입력창이 표시됨.
• MQTT Broker list :
  사용자가 입력한 MQTT broker 정보를 리스트로 표시함. 각 아이템을 클릭하면 [연결/연결중단/삭제] 등의 메뉴를 선택가능. 특정 MQTT 서버에 연결된 경우 해당 아이템의 배경은 푸른색으로 하이라이트 되어 표시됨. 복수개의 MQTT broker에 동시 연결이 가능하며, 이 경우 메시지를 전송(public) 할 때 연결된 모든 broker로 전송됨.
• Add MQTT Broker :
  서버 ID, URL, Port 를 지정해서 MQTT broker 정보를 저장할 수 있음. 저장된 정보는 MQTT Broker list에 아이템으로 표시됨. [서버 ID, URL, Port] 는 필수이며 그 외의 부가 기능을 선택적으로 추가할 수 있음.
• Settings 다이얼로그 :
  음성인식 시작을 위한 floating icon 을 show/hide 할 수 있음. Slide bar와 같이 굉장히 빠르게 이벤트를 생성하는 컨트롤의 경우 sending interval을 이용해서 메시지 전송 간격을 조정할 수 있음. 메시지 전송 형식을 [값만/간단한 형식/JSON] 지정할 수 있음.

화면 하단에는 음성인식을 위한 Floating 버튼이 있으며, 상태바에 서버와의 연결 상태가 표시됩니다.

참고자료

Google Play Store 앱 다운로드 (v4.0.3 이상 지원)

• https://play.google.com/store/apps/details?id=com.hardcopy.vcontroller

소스코드 다운로드 (GitHub)

• https://github.com/godstale/VoiceCon

상세한 설치 방법이 아래 Paho 라이브러리 사이트에 나와 있습니다.

• https://www.eclipse.org/paho/clients/python/

파이썬 라이브러리 소스코드는 아래 링크에 공개되어 있으니 필요하신 분은 참고하시고…

• https://github.com/eclipse/paho.mqtt.python

설치는 pip 툴을 이용해서 합니다.

• pip install paho-mqtt

만약 소스를 컴파일해서 설치하고 싶으시다면 아래 방법대로 하세요.

• git clone https://github.com/eclipse/paho.mqtt.python.git
• cd org.eclipse.paho.mqtt.python.git
• sudo python setup.py install

라이브러리를 설치했으면 아래처럼 코드를 작성해서 간단히 테스트 할 수 있습니다.

import paho.mqtt.client as mqtt

# The callback for when the client receives a CONNACK response from the server.
def on_connect(client, userdata, rc):
    print("Connected with result code "+str(rc))
	# Subscribing in on_connect() means that if we lose the connection and
	# reconnect then subscriptions will be renewed.
	client.subscribe("$SYS/#")

# The callback for when a PUBLISH message is received from the server.
def on_message(client, userdata, msg):
	print(msg.topic+" "+str(msg.payload))

client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message

client.connect("iot.eclipse.org", 1883, 60)

# Blocking call that processes network traffic, dispatches callbacks and
# handles reconnecting.
# Other loop*() functions are available that give a threaded interface and a
# manual interface.
client.loop_forever()

on_connect() 함수와  on_message() 함수를 미리 선언해 둔 뒤 아래 코드를 통해 callback 함수로 등록합니다. 그럼 MQTT에 연결되거나 메시지를 받을 때 자동으로 callback 함수가 호출됩니다.

client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message

이 외에도 등록할 수 있는 callback 함수가 많습니다. 아래 링크에 있는 예제 파일들을 읽어보시면 금방 사용법을 터득하실 수 있습니다.

• https://github.com/eclipse/paho.mqtt.python/tree/master/examples

예제를 테스트 하기 전 아래 코드에서 MQTT broker URL을 자신의 환경에 맞게 수정해줘야 합니다.

client.connect("iot.eclipse.org", 1883, 60)

참고자료

• Paho MQTT python library

이전부터 써오던 NAS (Network Attached Storage) 서버가 있었는데 3년 반 쯤 지나니까 맛이 가버린… 그래서 새로 한 대 맞추는 김에 저전력 일체형 PC를 사서 우분투 리눅스를 깔고 가지고 놀았습니다. 2테라 하드를 기반으로 붙은 NAS, 미디어 서버, 클라우드, 토렌트, 뮤직 스트리밍 등등… 활용 방법이 많아서 꽤나 만족스러웠습니다. 헌데 가끔 간단한 설정을 위해 Telnet 접속해서 작업하는게 귀찮기도 하고.. 좀더 간편하게 작업들을 자동으로 처리하도록 해보고 싶었습니다.

그래서 음성인식으로 홈 서버를 제어할 수 있도록 시스템을 구축해 봤습니다.

안드로이드에서 음성인식 구현하는건 생각보다 간단합니다. 구글 음성인식 API가 제공되기 때문에 코드 몇 줄이면 음성인식 기능을 넣을 수 있습니다. 오히려 음성인식 보다는 인식된 음성 명령을 서버, 그리고 다양한 기기들과 공유할 수 있는 방법이 더 중요합니다. 그래서 사용한 것이 MQTT 프로토콜 입니다.

MQTT 프로토콜은 보통 기계를 위한 트위터 시스템으로 소개됩니다. 우리가 트위터에 메시지를 게시(publish)할 수도 있고, 게시된 메시지는 자동으로 팔로워에게 전송되죠. MQTT 에서는 팔로우 대신 subscribe 라는 단어를 사용합니다만 기능은 뭐 비슷합니다. 암튼 MQTT를 사용하면 다양한 기기들이 서로 원하는 메시지만 공유할 수 있다는 겁니다. 자세한 내용은 아래 링크를 참고하세요.

• MQTT 프로토콜 분석과 테스트 방법

전체적인 동작 흐름도는 아래와 같습니다.

라즈베리파이같은 서버에 MQTT 서버 프로그램 (broker라 부름)을 설치하면 다양한 장치들이 broker에 붙어 메시지를 주고 받을 수 있습니다. 폰에서 인식한 음성이 텍스트로 변환되어 MQTT broker로 날라가면 라즈베리파이에서 필요한 처리를 할 수도 있구요, 또는 마이크로 컨트롤러에서 메시지를 받아 명령어에 맞는 동작을 하도록 하면 됩니다.

구현 과정

MQTT broker는 제가 가진 우분투 서버에 이미 설치가 되어 있는 상태여서 특별히 건들건 없었습니다. 라즈베리파이에 설치해서 사용하는 법은 아래 링크에 내용이 포함되어 있으니 참고하세요.

• MQTT 프로토콜 분석과 테스트 방법

음성인식 기능과 MQTT client 기능을 갖춘 안드로이드 앱만 만들면 금방 테스트 해볼 수 있을 것 같았는데… 생각보다 시간이 오래 걸렸네요. 음성인식은 금방 구현했는데, 안드로이드용 MQTT client 소스 공유된게 거의 없더군요. 대부분 Paho 안드로이드용 MQTT 라이브러리를 사용하는 것 같았습니다. 저도 Paho 라이브러리를 받아서 이리저리 수정을 해서 사용했습니다. 음성인식 컨트롤러 만드는데 대부분의 시간은 MQTT 기능 넣는데 들어간…

그렇게 만든 앱이 MQTT VoiceCon 앱입니다.

먼저 MQTT broker (server) 를 등록하고 연결한 뒤, 특정 topic(채널)을 적어둡니다. 그리고 [마이크] 아이콘을 누르고 음성 명령을 내리면 텍스트로 변환되어 MQTT broker 의 topic(채널)으로 전달됩니다.(publish 과정)

해당 topic을 구독(subscribe)하는 장치들은 텍스트로 변환된 음성 명령을 받아서 처리합니다. 라즈베리파이 또는 마이크로 컨트롤러들이 메시지를 받아서 처리하겠죠.

MQTT VoiceCon 앱의 상세 내용은 아래 링크에 있으며 소스코드를 GitHub에 올려두었습니다.

Google Play Store 앱 다운로드 (v4.0.3 이상 지원)

• https://play.google.com/store/apps/details?id=com.hardcopy.vcontroller

소스코드 다운로드 (GitHub)

• https://github.com/godstale/VoiceCon

동작 테스트

음성 메시지가 우분투 서버에 있는 MQTT Broker 까지 전달은 되지만 이 명령어를 받아서 처리할 프로그램 또는 장치를 만들어야죠. 간단히 테스트하기 위해서 ESP8266 wifi 모듈에 LED를 달아서 음성 명령으로 LED를 on/off 할 수 있도록 만들었습니다.

ESP8266 모듈은 부팅이후 공유기에 연결되고, MQTT broker에 접속합니다. 그리고 특정 topic(채널) 으로 들어오는 메시지를 받습니다. 안드로이드 폰에서도 음성 명령이 같은 topic으로 전달되도록 설정하고 음성명령을 내리면 되겠죠. ESP8266 모듈은 [LED on], [LED off] 명령에 반응하도록 만들어 뒀습니다.

직접 해보니 동작 잘 됩니다!! 테스트에 사용된 ESP8266 소스코드는 아래 링크에 있습니다. 소스 컴파일을 위해서는 ESP8266 – Sming 개발환경이 필요합니다.

• ESP8266 Sming 개발환경 만들기
• ESP8266 테스트 예제 소스

뭐 LED 켜고 끄는 것만 제대로 되면 다른 동작도 쉽게 할 수 있겠죠.

좀 더 복잡한 기능을 제어하는 예제도 만들어 봤습니다. 우분투 리눅스가 돌아가는 홈 서버의 일부 기능들도 음성으로 제어하는 겁니다.

이 서버에는 MPD (Music Player Daemon) 가 설치되어 있습니다. MPD를 이용해서 서버에 연결된 스피커로 음악을 재생하기도하고, 온라인으로 스트리밍을 해주기도 합니다. 이걸 음성 명령으로 제어할 수 있도록 만들었습니다.

요걸 위해서 파이썬으로 짠 프로그램을 우분투에서 돌렸습니다. 파이썬 프로그램은 MQTT broker에 연결해서 특정 topic으로 들어오는 메시지를 감시하고 음성 명령어에 따라 해당 동작을 합니다. [음악 재생], [음악 정지] 명령을 내리면 음악이 재생/정지 됩니다.

테스트를 해보니 잘 되네요. 꽤나 간편합니다 ㅎㅎ… TV 도 이걸로 조종할 수 있으면 좋을텐데…

파이썬 프로그램을 작성하기 위해 Paho MQTT Python 라이브러리를 사용했습니다. 아래 링크에 라이브러리 설치방법과 예제 코드가 있으니 참고해서 여러가지 기능을 구현해 보시길…

• 라즈베리파이에 파이썬 MQTT 라이브러리 설치

전 일전에 파이썬으로 홈 오토메이션용 프로그램을 작성해 둔 것이 있어서 재활용 했습니다. 그래서 음악 재생/정지, 사진 촬영 후 메신저로 전송, CCTV on/off 등의 동작을 음성으로 제어할 수 있습니다. 아직 마이크로 컨트롤러를 이용한 기능들은 별루 넣어둔게 없는데… 시간나면 재밌는 기능들 추가해서 소개하도록 하겠습니다.

즐거운 DIY 하시길…

얼굴인식과 같은 이미지 프로세싱이 필요한 경우라면 가장 먼저 떠오르는게 OpenCV 일껍니다.

• 라즈베리파이에 OpenCV + 파이썬 개발환경 설치하기

그런데 OpenCV 는 설치도 쉽지 않고 이걸 제대로 활용해서 원하는 인식 결과를 얻기란 더더욱 어려운 작업이죠. 실시간으로 영상을 처리하는데는 여전히 가장 유용한 도구임에는 분명 합니다만, 적어도 빠른 속도가 요구되지 않는 상황 – 정적인 이미지를 처리한 결과가 필요한 상황이라면 훨씬 구현하기 쉬운 대안이 있습니다. Google Cloud Vision API(이하 구글 비전 API) 입니다.

구글 비전 API 를 사용해서 이미지와 몇 가지 설정을 구글 서버에 던져주면 알아서 이미지 인식을 해서 결과를 알려줍니다. 인터넷 연결만 되어 있다면 프로세싱 파워가 낮은 기기에서도 충분히 이미지 처리를 할 수 있고 사용방법도 쉬운게 장점입니다. 또한 자바, 파이썬 등 주요 언어에서 사용할 수 있도록 라이브러리를 제공하기 때문에 코드 몇 줄로 구현이 가능합니다. 대신 서버에 이미지 보내서 결과를 받아오기까지 딜레이가 있기 때문에 많은 프레임을 실시간으로 처리하는데는 적합치 않아 보입니다.

테스트를 위해 라즈베리 파이를 준비하고 개발환경부터 만들어 보겠습니다.

구글 클라우드 비전 API 개발환경 셋업

구글 클라우드 비전 API 의 가장 좋은 참고자료는 공식 문서입니다. 이 문서에서도 아래 내용을 바탕으로 작성 했습니다.

• https://cloud.google.com/vision/docs/getting-started

계정 세팅

구글 비전 API 사용을 위해서는 먼저 클라우드 비전 API 사용 요청을 하고 인증 방식을 설정해야 합니다. 아래 링크에서 [View my console] 버튼을 클릭하면 .

• https://cloud.google.com/vision/

[cloud vision api] 검색해서 해당 API를 활성화 해줍니다.

활성화가 되었다면 이제 인증 방식을 설정해줘야 합니다. 인증 방식은 API key, OAuth, Service account key 방식이 있는데 어떤걸 사용해도 무방하지만 이 문서에서는 Service account key 방식을 사용할겁니다.

화면 왼쪽 메뉴를 보면 열쇠모양(사용자 인증 정보) 메뉴가 있습니다. 클릭. 여기서 [사용자 인증 정보 만들기 – 서비스 계정 키]를 선택합니다.

새로운 서비스 계정의 이름과 ID를 입력하고

Key type 은 JSON 으로 선택합니다. 서비스 계정이 생성되면 downloaded-filename.json 링크 눌러서 JSON 파일을 다운로드 받아둡니다. 이 파일은 구글이 제공하는 API에서 사용할 인증 파일이므로 자신의 서버에 올려두고 사용해야 합니다.

이제 JSON 파일의 이름을 원하는대로 바꾸고 라즈베리 파이에 저장합니다. 제 경우엔 라즈베리 파이 아래 경로에 올려뒀는데 원하시는 경로를 사용하면 됩니다.

• /home/pi/temp/vision/gac.json

구글 라이브러리는 환경 변수 GOOGLE_APPLICATION_CREDENTIALS 를 이용해서 인증 파일의 위치를 인식합니다. 따라서 console 창에서 아래와 같이 명령을 실행해서 환경변수를 인식시켜 줍니다.

• export GOOGLE_APPLICATION_CREDENTIALS=/home/pi/temp/vision/gac.json

로그인을 다시하면 위 작업을 또 해줘야 하니까 .bashrc 파일 마지막에 위 명령어를 추가해 두는 것이 좋습니다.

파이썬 설치

구글 비전 API는 파이썬 2.x, 3.x 를 모두 지원하므로 자신이 라즈베리 파이가 가진 파이썬 환경을 그대로 사용하면 됩니다.

구글 클라우드 비전 API 라이브러리 설치

구글에서 배포하는 클라우드 비전 API – 파이썬 라이브러리를 설치해야 합니다. 구글이 제공하는 비전 API 예제 파일을 먼저 다운로드 받아두세요.

• https://github.com/GoogleCloudPlatform/cloud-vision

위 링크에서 다운로드 받아 올려도 되고, 라즈베리 파이에서 아래 명령어를 실행해도 됩니다.

• git clone https://github.com/GoogleCloudPlatform/cloud-vision.git

그리고 label 폴더에 들어가 보세요. requirements.txt 파일이 있는데 여기에 예제를 실행하는데 필요한 라이브러리들이 기재되어 있습니다. 여기 기재된 라이브러리들을 아래 명령어로 설치하면 됩니다.

• cd cloud-vision/python/label
• sudo pip install -r requirements.txt

구글에서 제공하는 각 예제들은 필요로 하는 라이브러리들이 틀립니다. 따라서 예제를 테스트 해보기 전에 위 명령어로 라이브러리 설치 작업을 해줘야 합니다.

이제 테스트 해볼 준비가 모두 끝났습니다.

이미지 인식 예제

구글 비전 API는 인식하고자 하는 대상에 따라 카테고리(Feature)가 구분되어 있습니다. 아래와 같은 인식 방법을 제공합니다.

• LABEL_DETECTION : 이미지에 포함된 사물 인식
• FACE_DETECTION : 얼굴 인식
• TEXT_DETECTION : 문자 인식 (OCR, Optical Character Recognition)
• LANDMARK_DETECTION : 지형, 지물 인식
• LOGO_DETECTION : 회사 로고 인식
• SAFE_SEARCH_DETECTION : 19금 이미지 인식?
• IMAGE_PROPERTIES : 이미지의 주요 특성 인식 (주요 색상 등)

이 값들을 중복해서 사용할 수 있습니다. 구글 비전 API 를 사용해서 구글 서버로 이미지 인식 요청(request)을 보낼 때 base64 인코딩 된 이미지를 포함한 JSON 형식의 요청을 보냅니다. 아래와 같은 형식으로 request가 전송됩니다.

{
  "requests":[
    {
      "image":{
        "content":"/9j/7QBEUGhvdG9zaG9...image contents...fXNWzvDEeYxxxzj/Coa6Bax//Z"
      },
      "features":[
        {
          "type":"FACE_DETECTION",
          "maxResults":10
        },
        {
          "type":"LABEL_DETECTION",
          "maxResults":10
        }
      ]
    }
  ]
}

image 항목 뒤에 base64 인코딩 된 이미지 데이터가 붙고 features 항목에는 원하는 인식 방법을 기재합니다. 따라서 인식하고자 하는 목적에 따라 features 항목의 값을 적절히 조절해주면 됩니다.

구글 서버로 요청이 전송되면 잠시 후 결과(response) 값이 JSON 형태로 도착합니다. 아래와 유사한 형식으로 옵니다.

{
  "responses": [
    {
      "labelAnnotations": [
        {
          "mid": "/m/0bt9lr",
          "description": "dog",
          "score": 0.89208293
        }
      ]
    }
  ]
}

위 값은 어떤 인식을 했느냐에 따라 바뀌며, 훨씬 복잡한 형태를 가지기도 합니다. 구글에서 제공한 예제들을 실행해서 결과를 보면 어떤 결과값이 오는지 알 수 있습니다.

Label 인식

Label 인식 예제는 label 디렉토리 안에 있습니다. 먼저 인식할 이미지가 하나 필요하니 다운로드 받습니다. 스핑크스 이미지를 하나 받아서 이름을 sphinx.jpg 로 변경했습니다. 인식할 이미지는 500KB 이내여야 합니다.

• wget http://schools.academytravel.com.au/media/Image/cache/Cc730385-Ancient_Egypt_OneLine_Itineraries_AI_Egypt.jpg
• mv Cc730385-Ancient_Egypt_OneLine_Itineraries_AI_Egypt.jpg sphinx.jpg

인식을 하기 전에 소스코드를 약간 수정해 줍니다. 인식한 결과(response JSON)를 console 창에 출력하도록 하기 위해서 입니다.

• nano label.py

열어본 김에 소스코드를 보면… 모든 작업이 아래 코드에서 다 이루어집니다.

with open(photo_file, 'rb') as image:
        image_content = base64.b64encode(image.read())
        service_request = service.images().annotate(body={
            'requests': [{
                'image': {
                    'content': image_content.decode('UTF-8')
                },
                'features': [{
                    'type': 'LABEL_DETECTION',
                    'maxResults': 1
                }]
            }]
        })
        # [END construct_request]
        # [START parse_response]
        response = service_request.execute()
        label = response['responses'][0]['labelAnnotations'][0]['description']
        print('Found label: %s for %s' % (label, photo_file))
        print response
        return 0
        # [END parse_response]

label.py 를 실행할 때 파라미터로 이미지 파일 이름을 넘길겁니다. 그러면 이미지 파일을 열어서 base64 인코딩을 해줍니다.

• image_content = base64.b64encode(image.read())

이걸 구글 서버로 보낼 request 에 붙이는 겁니다. 바로 이어지는 코드가 구글 서버로 보낼 JSON 문자열을 작성하는 코드입니다. 만약 label 인식 외에 face 인식 등등을 더 추가하고 싶다면 features 항목에 첨삭을 해주면 됩니다.

그리고 아래 코드를 이용해 실제 서버에 request를 보내는 작업을 합니다.

• response = service_request.execute()

request가 정상적으로 처리되면 response를 받는데 JSON 형식의 데이터로 되어 있습니다. 이 데이터를 화면에 표시하고 원하는 작업을 해주면 됩니다. 일단 데이터가 어떻게 구성되어 도착하는지 확인하는게 목적이므로 화면에 출력하도록 코드를 약간 수정해 주겠습니다. return 0 코드 바로 윗 줄에 아래 코드를 추가해줍니다.

• print response

수정된 코드를 저장하고 shell로 빠져 나옵니다. 그리고 label.py 파이썬 파일을 이미지와 함께 실행해 봅니다.

• python label.py sphinx.jpg

모든 과정이 정상적으로 진행된다면 아래처럼 결과가 표시될겁니다.

{u'responses': [{u'labelAnnotations': [{u'score': 0.97231364, u'mid': u'/m/05xh2', u'description': u'pyramid'}]}]}

구글 서버에서 이미지를 인식해서 결과를 보내준겁니다. 이걸 좀 더 보기 좋게 펼치면

{
    u'responses': [
        {
            u'labelAnnotations': [
                {
                    u'score': 0.97231364, 
                    u'mid': u'/m/05xh2', 
                    u'description': u'pyramid'
                }
            ]
        }
    ]
}

u” 라고 표시된 건 문자열 인코딩 방식을 나타내므로 없다 생각하셔도 됩니다.

실제 우리가 원하는 항목은 ‘description’ : ‘pyramid’ 입니다. 스핑크스와 피라미드가 포함된 이미지를 보냈는데 피라미드로 인식했네요. 그래도 만족할만한 결과입니다. 이 값을 파이썬에서 읽기 위해서는 아래처럼 코드를 작성하면 됩니다.

• response[‘responses’][0][‘labelAnnotations’][‘description’]

JSON 데이터를 가져오는 자세한 방법은 생략합니다;;;

얼굴 인식

얼굴 인식도 마찬가지의 과정으로 테스트 해보시면 됩니다. face_detection 폴더로 이동해서 이미지 파일 하나를 넣어준 뒤, faces.py 코드를 수정하고 테스트 하면 됩니다.

detect_face() 함수를 찾아서 return response[‘responses’][0][‘faceAnnotations’] 코드 앞에 아래 코드를 넣어주세요.

• print response

그리고 얼굴인식을 실행해보면…

• python faces.py xxx.jpg

아래처럼 결과가 나옵니다. JSON 결과 파일에서 response – faceAnnotations 항목 내부의 내용들만 표시한 겁니다.

{
    'joyLikelihood': 'VERY_UNLIKELY', 
    'sorrowLikelihood': 'VERY_UNLIKELY', 
    'surpriseLikelihood': 'VERY_UNLIKELY', 
    'angerLikelihood': 'VERY_UNLIKELY', 
    
    'headwearLikelihood': 'VERY_UNLIKELY', 
    'underExposedLikelihood': 'VERY_UNLIKELY', 
    'blurredLikelihood': 'VERY_UNLIKELY', 

    'landmarkingConfidence': 0.54563558, 
    'detectionConfidence': 0.71568185, 
	
    'panAngle': 27.359901, 
    'tiltAngle': -2.6616335, 
    'rollAngle': 14.754687, 

    'boundingPoly': {
        'vertices': [
            {'y': 8, 'x': 4}, 
            {'y': 8, 'x': 191}, 
            {'y': 224, 'x': 191}, 
            {'y': 224, 'x': 4}
        ]
    }, 
    'fdBoundingPoly': {
        'vertices': [
            {'y': 69, 'x': 53}, 
            {'y': 69, 'x': 189}, 
            {'y': 204, 'x': 189}, 
            {'y': 204, 'x': 53}
        ]
    },
	
    'landmarks': [
        {
            'position': {'y': 108.6227, 'x': 105.59975, 'z': 0.00067580346}, 
            'type': 'LEFT_EYE'
        }, 
        {
            'position': {'y': 119.75568, 'x': 148.54039, 'z': 23.859083}, 
            'type': 'RIGHT_EYE'
        }, 
        ......
    ]
}

꽤 긴 결과가 나옵니다.

joyLikelihood, sorrowLikelihood, surpriseLikelihood, angerLikelihood 이 값들은 표정(기쁨, 슬픔, 놀람, 화)을 인식한 결과입니다. headwearLikelihood 는 모자를 썼는지 표시하는 항목인 것 같네요. 결과값은 아래 항목 중 하나의 값을 가집니다.

• UNKNOWN : 인식 실패
• VERY_UNLIKELY : 매우 해당되지 않음
• UNLIKELY : 해당되지 않음
• POSSIBLE : 가능성이 있음
• LIKELY : 해당됨
• VERY_LIKELY : 매우 해당됨

boundingPoly 얼굴 전체의 윤곽을 몇 개의 점으로 근사한 것입니다. 점들을 연결하면 얼굴 부분을 포함하는 다각형이 됩니다. fdBoundingPoly 는 얼굴 윤곽을 boundingPoly 보다 더 타이트하게 피부 경계 부분으로 잡은 것입니다. landmarks 는 얼굴의 각 부분 – 눈, 코, 입, 귀 등의 위치 데이터를 포함하고 있습니다.

랜드마크 인식

랜드마크 예제는 landmark_detection 디렉토리에 있습니다. 특이하게 이 예제는 GCS(Google Cloud Store) 상의 파일을 읽어와서 이미지 인식을 하네요. 아래 링크로 접속해서 Google Cloud Platform – Storage 로 들어갑니다.

• https://cloud.google.com/storage/

아래처럼 좌측 브라우저 탭을 누르고 [버킷]을 하나 생성해야 합니다. 버킷 이름을 넣고 기억해둬야 합니다.

그리고 랜드마크 이미지를 하나 올려두세요. 전 타지마할 이미지를 landmark.jpg 로 올려뒀습니다.

이제 라즈베리 파이로 돌아와서 landmark_detection 디렉토리로 이동합니다. detect_landmark.py 파이선 파일이 있는데 이걸 수정해 줍니다. identify_landmark() 함수를 찾아서 return 바로 앞 줄에 아래 코드를 넣어줍니다.

• print response

그리고 아래 명령어로 테스트 해보세요.

• python detect_landmark.py gs://버킷이름/파일이름

이미지 인식 결과는 아래처럼 옵니다.

{
    'responses': [
        {
            'landmarkAnnotations': [
                {
                    'locations': [
                        {
                            'latLng': {
                                'latitude': 27.174698469698683, 
                                'longitude': 78.042073
                            }
                        }
                    ], 
                    'score': 0.86202425, 
                    'mid': '/m/0l8cb', 
                    'boundingPoly': {
                        'vertices': [
                            {'y': 103, 'x': 204}, 
                            {'y': 103, 'x': 741}, 
                            {'y': 324, 'x': 741}, 
                            {'y': 324, 'x': 204}
                        ]
                    }, 
                    'description': 'Taj Mahal'
                }, 
                ......
                ......
            ]
        }
    ]
}

landmarkAnnotations 항목 안에 인식 결과가 1개 이상 포함되어 있을겁니다. 전 타지마할 이미지를 올렸는데 예상대로 ‘description’: ‘Taj Mahal’ 이라는 응답을 보내주네요.

기타 예제들

이 외에도 몇 가지 예제들이 더 있으므로 직접 테스트 해보시기 바랍니다. 특히 Text 인식은 조금 더 복잡하고 라이브러리를 몇 개 더 설치해야 하긴 하지만 여러모로 유용하게 사용될 수 있습니다.

참고자료

• 구글 클라우드 비전 API – Getting started
• 파이썬 예제 파일
• 얼굴 인식 예제 매뉴얼
• 라벨 인식 예제 매뉴얼
• request, response JSON 파일 매뉴얼

16개의 버튼을 사용할 일이 얼마나 많을지는 모르겠습니다만… 아두이노의 기초 과정인 digital input, digital output 을 연습하기에는 더할나위 없는 모듈이 키패드 모듈입니다.

키패드 모듈은 16개의 푸시 버튼이 4×4 행렬로 배치되어 있습니다.

모듈은 8개의 핀을 가지고 있는데, 1~4 까지 4개의 핀은 버튼을 가로로 연결하고 있습니다. 그리고 5~8까지 4개의 핀은 버튼을 세로로 연결하고 있습니다. (이 배치는 모듈에 따라 틀립니다.)

즉, 1~4 가로로 연결된 회로와 5~8 세로로 연결된 회로가 만나는 지점, 16개의 교차점에 버튼이 올라가 있는겁니다. 버튼을 누르면 두 개의 회로가 서로 연결되겠죠.

따라서 각 버튼이 눌러졌는지 확인하기 위해서는 5~8 핀에 순서대로 HIGH 또는 LOW 신호를 넣어주고, 1~4 핀으로 들어오는 신호가 무엇인지를 체크하면 됩니다.

예를 들어 2행, 2열에 있는 버튼을 체크한다고 가정해보죠.

그럼 세로로 연결된 6번 핀을 OUTPUT 모드로 초기화하고 HIGH 신호를 넣어줍니다. 그리고 2번 핀을 INPUT 모드로 초기화 하고 HIGH 신호가 들어오는지 읽으면 됩니다. 물론 값이 제대로 들어오기 위해서는 2번 핀에 pull-down 저항을 연결해줘야 합니다. 그래야 버튼이 눌러지지 않았을 때는 LOW 값을 읽습니다.

예제 소스

간단하게 1행1열 버튼과 2행 2열 버튼이 눌러졌는지 확인하는 소스코드를 확인해 보겠습니다. 키패드 모듈을 구했는데 8개의 핀이 어떻게 연결되어 있는지 모를 때 이 코드를 응용해 보시면 됩니다.

void setup() {
    Serial.begin(9600);
    pinMode(2, INPUT_PULLUP);
    pinMode(3, INPUT_PULLUP);
    pinMode(6, OUTPUT);
    pinMode(7, OUTPUT);
    digitalWrite(6, HIGH);
    digitalWrite(7, HIGH);
}


void loop() {
    digitalWrite(6, LOW);
    Serial.print("pos 1, 1 = ");
    Serial.println(digitalRead(2));
    digitalWrite(6, HIGH);
    
    digitalWrite(7, LOW);
    Serial.print("pos 2, 2 = ");
    Serial.println(digitalRead(3));
    digitalWrite(7, HIGH);
    delay(1000);
}

1행1열 버튼과 2행 2열 버튼을 체크하기 위해서는 총 4개의 디지털 핀을 사용해야 합니다.

여기서는 1행과 2행으로 들어오는 신호를 읽을 디지털 핀 2개 – D2, D3 를 사용합니다. 5열과 6열로 신호를 보내기 위해서 D6, D7 핀을 사용했습니다.

• 키패드 1 –> 아두이노 D2
• 키패드 2 –> 아두이노 D3
• 키패드 5 –> 아두이노 D6
• 키패드 6 –> 아두이노 D7

그리고 여기서는 저항을 사용하지 않고 값을 읽기 위해서 아두이노의 내부 풀업저항(internal pull-up) 기능을 사용합니다. 내부 풀업저항을 활성화 하기 위해서 아래와 같이 D2, D3 핀을 INPUT_PULLUP 모드로 초기화 했습니다.

pinMode(2, INPUT_PULLUP);
    pinMode(3, INPUT_PULLUP);

이제 D2, D3 핀은 버튼이 눌러지지 않았을 때 내부 풀업저항에 의해 HIGH 신호를 읽게 됩니다. 버튼이 눌러졌을 때는 LOW 신호가 읽어지도록 해야겠죠. 그래서 loop() 반복함수 안에서 output 신호를 주는 D6, D7 핀을 순서대로 LOW 출력으로 바꿉니다.

D6 핀을 LOW 상태로 바꾸고 D2, D3 핀으로 들어오는 값이 어떻게 되는지를 판단하죠. 그리고 D7 핀을 LOW 상태로 바꾸고 D2, D3를 체크합니다.

이렇게 체크하면 1행1열 버튼부터 2행2열 버튼까지 총 4개의 버튼이 눌러졌는지 판별할 수 있습니다.

그럼 16개의 버튼 전부를 체크하고 싶다면?? 1~4행을 담당하는 4개의 디지털 핀(INPUT 체크)과 5~8열을 담당하는 4개의 디지털 핀(OUTPUT 제어)을 사용하면 됩니다.

• 키패드 1~4 –> 아두이노 D2~D5 (INPUT 체크)
• 키패드 5~8 –> 아두이노 D6~D9 (OUTPUT 제어)

아두이노 D6~D9번 핀은 digitalWrite() 함수를 이용해서 순서대로 LOW 신호를 주고, 아두이노 D2~D5번 핀은 digitalRead() 함수를 통해 들어오는 신호를 읽으면 되겠죠. 저항을 사용하기 싫은 경우 1~4번 핀(아두이노 D2~D5) 핀은 pinMode() 함수로 초기화 할 때 INPUT_PULLUP 모드로 초기화 해줍니다.

아래는 각 키 입력을 체크하는 소스코드입니다.

setup() 함수까지는 아래와 같이 처리합니다.

const int numRows= 4;
const int numCols= 4;

int pinRows[numRows] = {2, 3, 4, 5};
int pinCols[numCols] = {6, 7, 8, 9};

void setup() {
    Serial.begin(9600);    // init Serial communication
    
    // initialize row pins as INPUT_PULLUP
    for(int i=0; i<numRows; i++) {
        pinMode(pinRows[i], INPUT_PULLUP);
    }
    
    // initialize column pins as OUTPUT
    for(int j=0; j<numCols; j++) {
        pinMode(pinCols[j], OUTPUT);
        digitalWrite(pinCols[j], HIGH);    // set initial output as HIGH
    }
}

loop() 반복 함수에서는 for 반복문을 2중으로 돌면서 버튼입력을 확인합니다.

void loop() {
    // Check input
    for(int j=0; j<numCols; j++) {
        digitalWrite(pinCols[j], LOW);    // set as LOW to check button press
        for(int i=0; i<numRows; i++) {
            if( digitalRead(pinRows[i]) == LOW ) {    // check input. LOW is pressed
                Serial.print("Pressed row=");
                Serial.print(i);
                Serial.print(", column=");
                Serial.println(j);
            }
        }
        digitalWrite(pinCols[j], HIGH);    // set as default (HIGH)
    }
    delay(500);
}

버튼을 누르면 눌려진 버튼이 무엇인지 아두이노 개발환경의 Serial monitor 를 통해 확인하실 수 있습니다.

직접 코드를 만들어서 사용하셔도 되고, 아래의 라이브러리를 이용해서 사용하셔도 됩니다.

• OneWireKeypad example
• OneWireKeypad library download

아두이노를 사용하신다면 간단한 비프(beep)음을 내는데 사용하는 버저 또는 피에조 스피커를 가지고 계실겁니다. 이걸 이용해서 음악을 연주하는 방법을 소개합니다. 특히 슈퍼마리오 배경음악으로 사용되었던 곡을 연주해 볼겁니다.

버저를 사용하는 기본적인 방법은 아두이노 디지털 핀에 연결해서 digitalWrite() 함수로 5V 전압을 on/off 하는 방식입니다. 하지만 이런 방법으로는 간단한 비프(beep)음만 만들 수 있습니다. 아두이노의 PWM 기능을 이용해서 analogWrite()를 해주면 되지 않을까 생각할 수도 있는데, 실제로 analogWrite()를 사용하면 볼륨 조절의 기능이 될 뿐 음계를 표현할 수는 없습니다.

음악을 만들기 위해서는 각 음계의 주파수에 맞는 사각파(square wave)를 만들어줘야 합니다. 아두이노에서 tone() 함수를 통해 이 기능을 제공합니다. tone() 함수는 analogWrite() 없이 자체적으로 square wave 를 만들어줍니다. 따라서 일반 디지털 핀 아무거나 하나 사용하면 됩니다.

tone() 함수는 주파수에 맞는 square wave 를 만들기 위해 자체적으로 timer를 사용합니다.(타이머 인터럽트로 동작) 따라서 아두이노 setup(), loop() 함수에서 delay()를 사용해 아두이노를 멈추더라도 tone() 함수는 동작합니다. 만약 음악을 중간에 멈추고 싶다면 noTone() 함수를 사용하면 됩니다.

tone()  함수에서 사용하는 타이머는 아두이노 디지털 3번과 11번 PWM 핀과 충돌을 일으킬 수 있으므로 주의해야 합니다.

연결 방법

버저의 사용법은 엄청 간단합니다. 단순히 디지털 핀 하나를 사용하면 됩니다. 볼륨 조절이 필요한 경우 333~1K 옴 저항을 추가로 연결해주면 됩니다.

스케치

음악이 연주되도록 스케치를 작성해 보겠습니다. 먼저 tone() 함수의 사용법 부터 봐야겠습니다.

• tone(pin, frequency)
• tone(pin, frequency, duration)

두 가지 방법이 있는데 여기서는 두 번째 방법을 사용합니다. 음을 재생하는데 필요한 값은 [디지털 핀 번호], [주파수], [재생 시간] 입니다. 따라서 음악을 만들기 위해서는 각 음계에 맞는 주파수 값과 재생 시간을 미리 만들어 둬야 합니다. 아래 스케치에서는 melody[] 배열과 tempo[] 배열로 미리 만들어 뒀습니다.

melody[] 배열을 보시면 NOTE_E7 형식으로 표현되어 있습니다. 7옥타브 미(E) 음을 출력하라는 의미입니다. 그런데 tone() 함수에는 주파수 값을 넣어야한다고 했습니다. 따라서 NOTE_E7 에 해당하는 주파수 값이 어딘가에 정의되어 있어야 합니다.

주파수 값들은 아두이노 공식 사이트에서 배포되고 있으니 링크에서 텍스트를 복사하세요. 그리고 아두이노 개발환경 우측 상단에서 [화살표 아이콘 – 새 탭] 선택하신 뒤 pitches.h 라는 파일을 만들어 여기에 붙여넣으면 됩니다. (Ctrl+Shift+N 키를 눌러 생성해도 됨)

pitches.h 파일이 저장되었으면 준비는 다 됐습니다. 아래 스케치를 복사해서 넣으시고, 업로드 후 음악을 감상하시면 됩니다.

#include "pitches.h"

#define melodyPin 6

unsigned long prevPlayTime = 0;
unsigned long playDuration = 0;
int currentMelody = 0;

//Mario main theme melody
int melodySize = 75;
int melody[] = {
  NOTE_E7, NOTE_E7, 0, NOTE_E7, 0, NOTE_C7, NOTE_E7, 0, NOTE_G7, 0, 0,  0, NOTE_G6, 0, 0, 0, 
  NOTE_C7, 0, 0, NOTE_G6, 0, 0, NOTE_E6, 0, 0, NOTE_A6, 0, NOTE_B6, 0, NOTE_AS6, NOTE_A6, 0, 
  NOTE_G6, NOTE_E7, NOTE_G7, NOTE_A7, 0, NOTE_F7, NOTE_G7, 0, NOTE_E7, 0,NOTE_C7, NOTE_D7, NOTE_B6, 0, 0,
  NOTE_C7, 0, 0, NOTE_G6, 0, 0, NOTE_E6, 0, 0, NOTE_A6, 0, NOTE_B6, 0, NOTE_AS6, NOTE_A6, 0, 
  NOTE_G6, NOTE_E7, NOTE_G7, NOTE_A7, 0, NOTE_F7, NOTE_G7, 0, NOTE_E7, 0,NOTE_C7, NOTE_D7, NOTE_B6, 0, 0
};
//Mario main them tempo
int tempo[] = {
  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 
  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 
  9, 9, 9, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
  12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
  9, 9, 9, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
};


void sing() {
    if(millis() < prevPlayTime + playDuration) {
        // music is playing. do nothing
        return;
    }
    // stop the tone playing:
    noTone(8);
    
    if(currentMelody >= melodySize)
        currentMelody = 0;
    // to calculate the note duration, take one second
    // divided by the note type.
    //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
    int noteDuration = 1000/tempo[currentMelody];

    tone(melodyPin, melody[currentMelody], noteDuration);
    prevPlayTime = millis();
    playDuration = noteDuration * 1.30;
    
    currentMelody++;
}



void setup() {
	pinMode(melodyPin, OUTPUT);
}

void loop() {
	// Do what you want

	// play music
	sing();
}

실제 연주를 하는 부분은 sing() 함수입니다. 소스코드를 조금 더 자세히 살펴보겠습니다.

sing() 함수 첫 부분에서 현재 시간을 체크합니다. loop() 함수가 굉장히 빠르게 반복되면서 계속 sing() 함수를 호출하는데 이미 음을 재생하는 중이라면 음 재생이 끝날 때까지는 다른 음을 재생해서는 안되기 때문입니다.

if(millis() < prevPlayTime + playDuration) {
        // music is playing. do nothing
        return;
    }

일단 음 재생이 끝났으면 다음 음을 재생하기 위해 기존 음 재생을 멈춥니다.

// stop the tone playing:
    noTone(8);

음악을 끝까지 연주했으면 다시 처음부터 재생하도록 배열 index 를 체크하고

if(currentMelody >= melodySize)
        currentMelody = 0;

재생할 음의 재생 시간을 구합니다. tempo[] 배열에 각 음의 재생 시간이 기록되어 있는데, 8분 음표 4분 음표… 이런 단위로 기록되어 있습니다. 그래서 1초(1000 밀리초)를 tempo 값으로 나누면 재생 시간이 나옵니다.

// to calculate the note duration, take one second
    // divided by the note type.
    //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
    int noteDuration = 1000/tempo[currentMelody];

이제 tone() 함수를 이용해서 음을 재생합니다.

tone(melodyPin, melody[currentMelody], noteDuration);
    prevPlayTime = millis();
    playDuration = noteDuration * 1.30;

    currentMelody++;

음 재생이 끝날 때까지 sing() 함수가 다시 실행되지 않도록 prevPlayTime 값을 현재 시간으로 설정해줍니다. 그리고 playDuration 값을 재생시간의 1.3 배로 설정해줍니다. playDuration 값은 음 재생이 끝날 때까지 기다려야 하는 시간을 의미합니다. 실제 음 재생시간의 1.3배가 적당하다고 합니다.

마지막으로 배열의 index를 증가시켜 다음 음을 재생할 준비를 합니다.

이상의 스케치를 실행하면 슈퍼 마리오 배경음악을 버저로 재생할 수 있습니다. 위 소스코드는 loop() 함수안에서 다른 작업을 하더라도 영향을 받지 않도록 작성한 코드입니다. 따라서 소스코드를 복사해서 다른 프로젝트에 간단히 적용할 수 있습니다.

이 예제에는 하나의 음악만 사용했는데 배경음악으로 사용 가능한 데이터가 더 있습니다. 아래 코드를 추가해서 사용해보세요.

//Underworld melody
int underworld_melody[] = {
  NOTE_C4, NOTE_C5, NOTE_A3, NOTE_A4,
  NOTE_AS3, NOTE_AS4, 0,
  0,
  NOTE_C4, NOTE_C5, NOTE_A3, NOTE_A4,
  NOTE_AS3, NOTE_AS4, 0,
  0,
  NOTE_F3, NOTE_F4, NOTE_D3, NOTE_D4,
  NOTE_DS3, NOTE_DS4, 0,
  0,
  NOTE_F3, NOTE_F4, NOTE_D3, NOTE_D4,
  NOTE_DS3, NOTE_DS4, 0,
  0, NOTE_DS4, NOTE_CS4, NOTE_D4,
  NOTE_CS4, NOTE_DS4,
  NOTE_DS4, NOTE_GS3,
  NOTE_G3, NOTE_CS4,
  NOTE_C4, NOTE_FS4, NOTE_F4, NOTE_E3, NOTE_AS4, NOTE_A4,
  NOTE_GS4, NOTE_DS4, NOTE_B3,
  NOTE_AS3, NOTE_A3, NOTE_GS3,
  0, 0, 0
};
//Underwolrd tempo
int underworld_tempo[] = {
  12, 12, 12, 12,
  12, 12, 6,
  3,
  12, 12, 12, 12,
  12, 12, 6,
  3,
  12, 12, 12, 12,
  12, 12, 6,
  3,
  12, 12, 12, 12,
  12, 12, 6,
  6, 18, 18, 18,
  6, 6,
  6, 6,
  6, 6,
  18, 18, 18, 18, 18, 18,
  10, 10, 10,
  10, 10, 10,
  3, 3, 3
};

참고자료

• 아두이노 tone() 함수
• 아두이노 toneMelody
• 슈퍼마리오 음악 연주하기

아두이노에서 사용 가능한 시리얼, I2C, SPI 통신 분석 시리즈입니다. 시리즈 순서대로 읽으시길 추천합니다.

• 시리얼 통신 상세 분석
• SPI 통신 상세 분석
• I2C 통신 상세 분석

아래 SPI 관련 튜토리얼의 자료를 번역/수정 하였습니다.

• https://learn.sparkfun.com/tutorials/serial-peripheral-interface-spi

비동기식 시리얼 통신의 문제점

TX, RX 핀을 이용해서 동작하는 시리얼(Serial) 통신은 비동기식(asynchronous) 으로 동작합니다. 이 말은 통신을 하는 두 장치 사이에 데이터를 보내는 중인지 아닌지 알려주는 별도의 컨트롤러가 없다는 뜻이므로 두 장치는 끊임없이 상대방이 데이터를 보내는지 확인을 해야 합니다. 따라서 시리얼 통신을 사용하는 장치들은 1초를 몇 개의 간격로 나눠서 데이터를 보낼지(baud rate) 미리 약속해둬야 합니다. 이 간격을 정확하게 지키기 위해서는 통신에 참여하는 양쪽 장치가 같은 클럭(clock)을 사용해야 하는데, 만약 두 장치가 사용하는 클럭이 미세하게 틀리다면 문제가 발생할 수 있습니다.

참고!! 컴퓨터의 내부 동작은 모두 클럭(clock)으로부터 생성되는 신호에 동기화 되어 있습니다. 클럭은 컴퓨터에 부착된 main crystal 에 의해 생성됩니다. 아두이노도 마찬가지.

이 문제를 해결하기 위해서 비동기식 시리얼 통신은 매 1 byte 송신을 할 때마다 추가로 start/stop bit 를 추가해줍니다. 명확하게 데이터를 인식할 수 있도록 데이터의 시작과 끝을 표시할 뿐 아니라 클럭이 달라 sync 가 어긋나더라도 start bit를 보고 다시 맞춰줄 수 있습니다. 결과적으로 비동기식 시리얼 통신은 아래처럼 1byte 를 전송하게 됩니다.

이제 비동기식 시리얼 통신이 동작하는건 문제가 없지만 매 1 byte를 전송 할 때마다 start/stop bit 가 생성되고 sync를 다시 맞춰야 하니 오버헤드가 생깁니다. 그리고 송수신을 위해 복잡한 하드웨어 컨트롤러가 필요한 것이 단점입니다. 반면에 동기식 시리얼 통신은 이런 문제에서 자유롭습니다.

동기식 시리얼 통신과 송신

동기식 시리얼 통신은 데이터를 보낼 때 데이터가 전달된다고 알려주는 별도의 클럭(clock) 라인을 사용하는 방법입니다. 클럭 라인을 통신 참여자가 공유함으로써 데이터 라인으로 언제 데이터가 들어오는지 알 수 있도록 해주는 방법입니다. I2C, SPI(Serial Peripheral Interface) 통신이 대표적인 동기식 통신 방법입니다.

즉, 클럭 라인으로 들어오는 rising (low to high) 또는 falling (high to low) 신호를 인식해서 즉시 데이터 라인에서 값을 읽습니다.

따라서 비동기식 시리얼 통신처럼 통신에 참여하는 장치들이 통신 속도(baud rate)를 공유할 필요도 없고, 클럭을 동일하게 유지해야 할 필요도 없습니다. 그리고 하드웨어도 간단한 shift register 로 구현할 수 있어서 저렴합니다.

데이터 수신

데이터를 전달할 때는 앞서 설명한 방법을 사용하면 되는데 데이터를 수신할 때는 어떻게 해야하나? 하는 의문이 들 수 있습니다. 이 경우 약간 더 복잡한 방식을 사용합니다. 동기식 시리얼 통신 중 SPI(Serial Peripheral Interface) 통신의 경우는 아래와 같이 동작합니다.

SPI 통신은 오직 한 장치만 클럭 라인에 신호(CLK, SCK, ClocK)를 생성합니다. 클럭 신호를 생성하는 장치를 master 라고 하고, 나머지 통신에 참가한 장치들은 slave 라 부릅니다. SPI는 1:n 통신이 가능하므로 slave 는 1개 이상의 장치가 될 수 있습니다. 대부분의 경우 당신이 사용하는 아두이노(마이크로 컨트롤러)가 마스터가 됩니다.

데이터가 마스터에서 슬레이브로 전달될 때는 MOSI(Master Out / Slave In) 데이터 라인을 사용하며, 이 경우는 앞서 설명한 데이터 전송 방법을 사용합니다. 반대로 슬레이브에서 마스터로 데이터가 전송 될 때는 별도의 데이터 라인인 MISO(Master In / Slave Out) 를 사용합니다. 즉, 클럭(SCK), 데이터 전송(MOSI), 데이터 수신(MISO) 세 개의 라인이 통신에 사용됩니다.

마스터가 데이터를 수신할 때도(아두이노가 데이터를 받을 때) 마찬가지로 클럭 신호가 필요합니다. 그래서 마스터 장치는 클럭 신호를 생성할 때 미리 수신용 클럭 신호도 순서대로 생성합니다. MISO 라인으로 들어오는 데이터를 위한 신호를 미리 생성해주는 겁니다. 비동기식 시리얼 통신이 아무때고 데이터를 송수신 하는 것과는 전혀 다른다는걸 아실 수 있을겁니다.

이 방식은 꽤 비효율적으로 보일 수도 있지만 일반적인 센세와 통신할 때 그리 큰 문제가 되지 않습니다. 마스터에서 “read data” 라는 명령어를 전송하면 센서는 자신이 전송할 데이터의 크기를 보내주도록 만들면 됩니다. 그러면 이후 데이터 전체를 받기 위한 클럭 신호를 생성하면 됩니다.

슬레이브 장치 선택 (SS, Slave Select)

앞서 언급한 CLK, MOSI, MISO 라인 외에 추가해야 할 라인이 하나 더 있습니다. 바로 SS(Slave Select) 입니다.

SPI 통신은 여러개의 slave 장치가 하나의 마스터에 연결될 수 있다고 했습니다. 즉, SPI 에서 클럭(SCK), MOSI, MISO 라인은 모든 장치가 공유합니다. 따라서 마스터가 데이터를 보내줄 때 이 데이터가 어디로 가는 것인지 알려주는 방법이 필요합니다. SPI에서는 이 문제를 하드웨어적인 신호선(SS) 하나를 더 추가해서 해결합니다.

동작이 없을 때 이 신호선은 HIGH 상태를 유지하다가 통신이 필요할 때 LOW 로 바꿔줍니다.(active low) 그래서 SS 라인이 센서의 enable/reset 라인과 연결되어 데이터가 필요할 때만 알려주는 방법으로 사용되기도 합니다.

다수의 슬레이브 장치 연결

여러개의 슬레이브 장치를 연결하는 방법은 크게 두 가지가 있습니다.

첫 번째는 각 장치마다 하드웨어적인 신호선(SS)을 할당하는 방법입니다. 이 방법을 사용하면 특정 장치와 통신이 필요할 경우 해당되는 SS 라인을 LOW 로 바꿔주면 됩니다. 이 방법은 직관적이고 단순한 해결책이지만 슬레이브 장치의 수만큼 신호선(SS)이 필요합니다.

두 번째 방법은 MOSI, MISO 라인을 체인처럼 연결하고 SS 라인을 공유하는 방법입니다. 이렇게 연결하면 SS 라인으로 신호를 보내면 모든 슬레이브 장치들이 통신할 준비를 합니다. 그리고 마스터에서 전송한 데이터가 체인처럼 연결된 데이터 라인을 따라 모든 슬레이브 장치로 전달됩니다. 각 슬레이브 장치는 자신에게 전달된 데이터만 취사 선택해서 사용하고, 자신의 데이터가 아닌 경우 적절히 데이터를 변형해 다음 장치로 넘겨줄 수 있습니다.

이런 연결 방법은 Daisy-chained 라고 부르고 주로 마스터에서 슬레이브로 단 방향 데이터만 사용할 경우 유용합니다. RGB LED strip 같은 장치가 대표적인 예입니다. 데이터가 마스터에서 슬레이브로 단 방향으로만 흐를 경우 마스터의 데이터 수신 라인인 MISO 연결은 생략할 수 있습니다.

SPI 프로그래밍

아두이노를 사용할 경우 shiftIn(), shiftOut() 함수를 이용해서 직접 디지털 핀에 간단한 SPI 동작을 구현할 수 있습니다. 임의의 디지털 핀을 사용할 수 있지만 소프트웨어적으로 SPI 를 구현하기 때문에 다소 느릴 수 있습니다.

반면 아두이노가 제공하는 SPI 라이브러리를 사용할 경우 마이크로 컨트롤러가 가진 SPI 하드웨어를 사용할 수 있어 훨씬 빠르고 안정적입니다. 대신 정해진 SPI 핀만 사용 가능합니다.

• SPI 라이브러리 관련 정보 : http://arduino.cc/en/Reference/SPI

SPI 연결은 위에 예시한 표준 방법 외에도 변형된 연결 방법이 다수 있습니다. 센서나 모듈에 따라 그에 맞게 핀 연결을 해줘야 합니다.

참고자료

• https://learn.sparkfun.com/tutorials/serial-peripheral-interface-spi

.

이 문서는 시리얼, I2C, SPI  각각의 문서로 나뉘어진 문서 중 하나입니다. 시리즈 순서대로 읽으시길 권합니다.

• 시리얼 통신 상세 분석
• SPI 통신 상세 분석
• I2C 통신 상세 분석 <<<<<

I2C 통신 개요

I2C (Inter-Integrated Circuit, 또는 TWI – Two Wire Interface) 는 복수개의 슬레이브 장치가 복수개의 마스터 장치와 통신하기 위한 프로토콜입니다. 앞서 살펴본 SPI 와 마찬가지로 하나의 완성품을 구성하는 요소들 간의 근거리 통신을 위해 고안되었습니다.

시리얼 통신에서 살펴보았다시피 비동기식 시리얼 통신(이하 UART)은 클럭을 맞춰줘야 하고 데이터 라인으로 들어오는 신호를 항상 주시해야 하기 때문에 오버헤드가 있으며 하드웨어가 복잡해지는 단점이 있습니다. 결정적으로 UART 통신은 1:1 통신만 가능합니다.

반면 동기식 시리얼 통신인 SPI 는 클럭(CLK) 라인을 이용해 데이터 라인을 동기화 하므로 하드웨어 구조도 간단하고 1:N 통신이 가능합니다. 송신용 핀과 수신용 핀이 분리되어 있고, full-duplex(동시 송수신) 연결을 이용해 10만 비트의 전송 속도를 지원하기도 합니다. 하지만 SPI 통신은 통신에 필요한 핀이 많아지는 단점이 있습니다. 하나의 장치를 연결하는데 4개의 라인 (CLK, MOSI, MISO, SS)이 필요하고, 추가로 장치를 더할 때마다 라인이 하나씩 추가됩니다. 그리고 N:N 통신은 할 수 없습니다.

I2C 통신은 SPI 통신의 이런 단점들을 보완할 수 있는 동기식(synchronous) 시리얼 통신 방법입니다. UART 통신처럼 단 두 라인만 사용하고 1008 개의 슬레이브 장치를 지원합니다. 또한 N:N 통신도 지원이 가능합니다. (단 마스터 장치끼리 통신은 불가) 하드웨어 요구사항이 SPI 보다 복잡하긴 하지만 UART 통신보다는 간단합니다. 통신 속도면에서도 SPI 와 UART 통신의 중간쯤 됩니다.(10kHz/40kHz)

I2C 하드웨어

I2C 통신은 두 개의 라인 – SCL, SDA 를 사용합니다.

SCL 은 SPI 의 CLK 처럼 클럭 신호를 생성해서 전달하는 역할을 하고 SDA 는 실제 데이터가 전달되는 라인입니다. 클럭 신호는 반드시 마스터 장치가 생성하는데 슬레이브 장치가 데이터 전송을 지연하기 위해 클럭 신호를 만드는 경우도 있습니다. 이것을 clock stretching 이라고 합니다.

I2C 통신은 UART/SPI 통신과는 달리 I2C 하드웨어(bus driver) 장치가 “open drain” 속성을 가진다는 점입니다. 이 말은 I2C 통신을 사용하는 장치 하나가 데이터 전송을 위해 라인에 LOW 신호를 넣고 있으면 다른 장치들은 이걸 강제로 HIGH로 바꿀 수 없다는 의미입니다. I2C 통신의 두 라인 SDA, SCL 은 모두 풀업 저항(pull-up resistor)에 연결되어 있으므로 통신라인이 사용이 끝나면 자동으로 HIGH 상태로 복귀됩니다.

또한 풀업 저항은 동작 전압이 다른 장치들이 연결되어 통신하는데 발생하는 문제점들을 없애줍니다. 풀업 저항이 두 장치가 사용하는 전압보다 낮은 레벨로 유지시켜주기 때문에 별도의 level-shifting 회로가 필요치 않습니다. (두 장치의 전압차가 큰 경우는 I2C level shifter 가 필요함)

프로토콜

I2C 통신의 데이터 구조는 UART/SPI 보다 복잡합니다. UART/SPI 에서 문제가 되는 부분들을 소프트웨어적으로 처리하기 때문입니다.

기본 구조

I2C가 전송하는 메시지는 2개의 프레임 – 주소(address) 프레임과 데이터(data) 프레임으로 구분할 수 있습니다. 주소 프레임은 마스터가 전송하는 데이터가 어떤 슬레이브로 가는지 알려주기 위한 프레임입니다. 데이터 프레임은 실제 전송하려는 데이터가 담긴 프레임입니다.

통신 시작 조건

데이터 통신을 시작하기 위해서는 주소 프레임부터 전송해야 합니다. 이를 위해 마스터 장치는 SCL(클럭) 라인을 HIGH 상태로 두고, SDA(데이터) 라인을 LOW로 변경합니다. 이 신호는 모든 슬레이브 장치들에게 데이터를 전송할 준비가 되었다는 신호로 인식됩니다. 만약 회로에 마스터 장치가 여러개 붙어 있다면 먼저 SDA 라인을 LOW 로 잡는 이가 제어권을 갖습니다.

주소 프레임(address frame)

주소 프레임은 항상 모든 통신 데이터의 앞에 위치합니다. 데이터 라인으로 처음 수신되는 1byte 중 앞선 7 bit 데이터(MSB, most significant bit)가 I2C 주소를 나타냅니다. 그리고 마지막 1 bit 는 읽기(read, 1, 데이터 요청) 또는 쓰기(write, 0, 데이터 전송) 동작임을 표시합니다.

프레임의 9번째 bit 값은 NACK/ACK 비트입니다. 이 비트는 마스터가 전송한 주소 정보(8bit)에 해당하는 장치가 만들어줘야 하는 신호입니다.(즉, 해당하는 슬레이브 장치가 잠시 SDA 라인의 컨트롤 권한을 가짐) 마스터 장치는 이 신호를 보고 데이터가 전송이 성공적인지, 실패라면 앞으로 어떤 동작을 할지 판단해야 합니다. NACK/ACK 비트는 주소 프레임, 데이터 프레임의 끝에 항상 붙습니다.

데이터 프레임(data frame)

주소 프레임의 전송이 완료되면 이제 데이터 프레임의 전송을 시작합니다. 마스터 장치는 SCL 라인의 클럭 신호를 계속 생성하며 SDA 라인으로는 데이터가 오고갑니다. 이때 SDA 라인의 데이터 프레임은 read, write 상태를 나타내는 bit 값에 따라 마스터 또는 슬레이브가 사용합니다.

통신 종료 조건

모든 데이터 프레임이 전송되면 마스터 장치는 종료 신호를 만들어야 합니다. 종료 신호는 클럭 라인인 SCL 을 0->1(LOW to HIGH) 상태로 변경한 뒤, SCL 라인이 HIGH 인 상태에서 SDA 라인을 0->1 (LOW to HIGH)로 변경하면 됩니다. 따라서 반드시 모든 장치들은 반드시 SCL 라인이 HIGH 인 상태에서 SDA 라인의 상태를 변경해서는 안됩니다. 이런 동작은 잘못된 종료신호로 인식될 수 있기 때문입니다.

프로토콜 심화

아래 링크에서 10비트 주소 체계를 사용하는 경우, Repeated Start Condition을 사용하는 경우, Clock stretching 의 상세 정보를 보실 수 있습니다.

• https://learn.sparkfun.com/tutorials/i2c?_ga=1.30845375.146682820.1421741789

참고자료

• Sparkfun I2C tutorial
• Standards doc
• I2C primer

.

본 문서는 아두이노 개발환경(IDE)를 이용해서 ESP8266 모듈을 다루는 예제들을 포함하고 있습니다.

• ESP8266 – ARDUINO IDE 개발환경 설치
• ESP8266 – ARDUINO IDE 예제 (GPIO 제어)
• ESP8266 – ARDUINO IDE 예제 (WiFi 통신)
• ESP8266 – ARDUINO IDE 예제 (MQTT) <<<<<

IoT 시스템 구현을 한다면 한번쯤 고려하기 마련인 MQTT 프로토콜을 ESP8266에서 구현하는 예제입니다. 특히 아두이노 개발환경을 이용해서 MQTT 클라이언트를 구현하도록 하겠습니다.

이 문서에서는 MQTT 프로토콜의 상세 내용에 대해서는 다루지 않습니다. 아직 MQTT 가 익숙치 않으신 분은 아래 MQTT 를 상세히 다룬 링크를 참고하세요.

• MQTT 프로토콜 분석과 테스트

MQTT 통신 기본 예제

MQTT 프로토콜을 테스트하기 위해서는 MQTT 서버 역할을 하는 Broker 가 필요합니다. 가장 유명한 MQTT Broker 어플리케이션인 Mosquitto 를 PC 또는 라즈베리 파이에 설치해서 사용하시면 됩니다. 아래 링크에서 다운로드 받아 설치하세요.

• http://mosquitto.org/download/

MQTT 브로커가 설치되고 동작하는 상태라면 여기에 ESP8266 을 client 로 붙여 여러가지 테스트를 할 수 있습니다.

라이브러리 설치

ESP8266 모듈에 MQTT 기능을 구현하기 위해서는 해당 라이브러리가 필요합니다. 아두이노 개발환경에서 사용할 수 있도록 개발된 라이브러리가 여러 종류가 있는데 여기서는 PubSubClient 라이브러리를 사용하도록 하겠습니다. 일단 아두이노 개발환경을 실행하고 아래 순서대로 라이브러리를 설치하면 됩니다.

• Arduino IDE 실행 (ESP8266 플러그인이 설치된 v1.6.5 이상)
• 메뉴 –> sketch –> include library –> Manage Libraries
• PubSubClient 검색
• 클릭 후 최신 버전 설치

연결 방법

라이브러리 설치가 되면 이제 테스트를 위한 하드웨어 준비가 필요합니다. 여기서는 편의상 ESP8266 – NodeMCU v1.0 보드를 사용합니다. USB 연결만하면 PC에서 바로 소스코드 업로드 및 시리얼 통신 모니터링이 가능합니다.

그리고 전송/수신한 MQTT 메시지를 바로 볼 수 있도록 OLED 디스플레이를 추가했습니다. OLED 가 없다면 생략하고 NodeMCU 보드만 사용해도 테스트 하는데는 지장 없습니다.

NodeMCU 보드와 OLED 디스플레이는 아래와 같이 연결합니다.

• NodeMCU –> OLED
• VCC –> 3V
• GND –> G (GND)
• SDA –> D2 (GPIO4)
• SCL –> D1 (GPIO5)

소스 코드(스케치)

이 예제는 ESP8266 부팅 후 AP(공유기)에 접속하면 MQTT 브로커에 연결을 시도합니다. 그리고 MQTT 브로커에 연결되면 특정 토픽에 주기적으로 MQTT 메시지를 전송합니다. 해당 토픽으로 들어오는 메시지를 수신해서 OLED에 보여주기도 합니다. 소스코드는 아래 링크에서 다운로드 받으세요.

• ESP8266 Arduino IDE – MQTT 기본 예제

예제 소스는 AP(공유기) 아이디와 비밀번호, MQTT 설정 항목들이 임의로 작성되어 있습니다. 따라서 이 부분은 직접 자신의 환경에 맞게 수정한 후 사용해야 합니다.

//----- WiFi settings
const char *ssid = "your_ap_id";
const char *password = "your_ap_password";
const char* mqtt_server = "mqtt_url";
const char* mqtt_topic = "topic";
char* mqtt_message = "Hello world #%ld";

마지막 메시지에서 #%ld 부분은 수정하지 말고 남겨두세요.

소스코드는 아래 5개의 함수를 가지고 있습니다.

void setup() {}
void loop() {}
void callback(char* topic, byte* payload, unsigned int length) {}
void reconnect() {}
void drawText(int line, String message) {}

• setup() 함수는 시리얼 통신, OLED 초기화 작업을 하고 AP 접속과 MQTT 통신을 위한 초기화 작업을 합니다.
• loop() 함수는 MQTT 브로커에 연결되어 있는지 확인하고 접속이 끊어지면 재접속 합니다. 그리고 MQTT 브로커에 연결되었을 때 주기적으로 메시지를 전송합니다.
• callback() 함수는 MQTT 메시지를 수신했을 때 호출되는 콜백함수입니다. 여기서 수신한 메시지를 OLED에 표시합니다.
• reconnect() 함수는 MQTT 브로커에 연결하고 특정 토픽 subscribe(구독) 작업을 합니다. loop() 함수에서 주기적으로 호출합니다.
• drawText() 함수는 OLED에 메시지를 표시하기 위한 함수입니다.

그리 길지 않은 소스 코드입니다. 천천히 분석해 보시면 이후 간단한 MQTT 기능들은 쉽게 만드실 수 있을겁니다.

테스트

[메뉴 – 도구 – 보드] 에서 NodeMCU v1.0 보드를 선택한 뒤, 포트를 선택하고 업로드하면 됩니다. 업로드가 끝나면 아래 과정을 반복할 것입니다.

• AP 접속
• MQTT 서버 접속
• 사용자가 미리 지정한 토픽 subscribe(구독)
• 주기적으로 지정한 토픽에 메시지 전송
• 메시지를 수신할 경우 OLED에 표시

참고자료

여기서는 아두이노 개발환경을 이용해서 ESP8266 – MQTT 기능을 테스트 했습니다. 같은 기능을 ESP8266 – Sming framework 을 이용해서 구현할 수도 있습니다.

• http://www.hardcopyworld.com/gnuboard5/bbs/board.php?bo_table=lecture_esp&wr_id=40

구현에 사용된 PubSubClient 의 상세 내용을 아래 링크에서 보실 수 있습니다.

• http://pubsubclient.knolleary.net/

MMA7361L 은 freescale 에서 제작한 아날로그 3축 가속도 센서 입니다. 저전력으로 동작하며 signal conditioning, 1-pole low pass filter, 온도 보상, self test, 0G(자유낙하) 감지 기능을 지원합니다. G-Select 핀으로 2개의 감도 중 하나를 선택할 수 있으며 0G offset 과 감도는 공장 초기화 상태로 초기화 되어 있습니다. MMA7361L 모듈은 배터리 관리를 위해 Sleep Mode 를 지원합니다.

Features

• Low Voltage Operation: 2.2 V – 3.6 V
• High Sensitivity (800 mV/g @ 1.5g)
• Selectable Sensitivity (±1.5g, ±6g)
• Fast Turn On Time (0.5 ms Enable Response Time)
• Self Test for Freefall Detect Diagnosis
• 0g-Detect for Freefall Protection
• Signal Conditioning with Low Pass Filter
• Robust Design, High Shocks Survivability
• RoHS Compliant
• Environmentally Preferred Product
• Low Cost

Document

• MMA7361 library
• MMA7361 Schematic
• MMA7361L Datasheet

사용방법

MMA7361 모듈은 가속도 센서의 3축 측정값을 아날로그 출력으로 보내줍니다. 따라서 아두이노의 아날로그 입력 핀(A0~A5)을 이용해서 쉽게 측정값을 읽을 수 있습니다.

연결은 아래처럼 하면 됩니다.

Example code

샘플 코드는 아래와 같습니다. 여기서는 전용 라이브러리를 사용하므로 링크에서 라이브러리를 다운로드 받아 설치해야 합니다.

#include <AcceleroMMA7361.h>
AcceleroMMA7361 accelero;
int x;
int y;
int z;

void setup()
{
  Serial.begin(9600);
  accelero.begin(13, 12, 11, 10, A0, A1, A2);
  accelero.setARefVoltage(5); //sets the AREF voltage to 3.3V
  accelero.setSensitivity(LOW); //sets the sensitivity to +/-6G
  accelero.calibrate();
}

void loop()
{
  x = accelero.getXAccel();
  y = accelero.getYAccel();
  z = accelero.getZAccel();
  Serial.print("\nx: ");
  Serial.print(x);
  Serial.print(" \ty: ");
  Serial.print(y);
  Serial.print(" \tz: ");
  Serial.print(z);
  Serial.print("\tG*10^-2");
  delay(500); //make it readable
}

테스트

MMA7361 모듈을 평평한 곳에 놓고 아두이노에 샘플 코드를 올립니다. 시리얼 모니터를 열면 MMA7361 모듈은 보정작업을 한 뒤 x, y, z 축의 측정 값을 보내줍니다. 라이브러리를 이용해 아날로그 핀에서 이 값을 받아 출력하면 아래처럼 표시됩니다.

아래 이미지는 평평한 곳에 모듈을 놓았을 때 Z축 중력가속도가 약 100(1 G)인 경우의 출력값입니다. 반드시 모듈을 평평한 곳에 두고 보정 작업을 거쳐야 합니다.

참고자료

• http://www.geeetech.com/wiki/index.php/MMA7361_Triple_Axis_Accelerometer_Breakout

하드카피월드는 메이커를 위한 다양한 기술자료와 매뉴얼, 소스를 제공하는 커뮤니티입니다. 생활속에서 번뜩이는 아이디어들을 공유하고 실제 구현될 수 있도록 지원하는 것이 목표입니다.

이를 위해 하드카피월드에서 자체 진행한 프로젝트는 오픈소스로 제공됩니다. 오픈소스 라이센스(GPL, Apache) 라이센스내에서 소스이용에 제약이 없습니다.

홈페이지에 게시된 글을 퍼가셔도 상관 없습니다. 다만 저작자 표시(원본 출처)를 해주시고, 비상업적 목적으로 활용, 같은 라이선스를 유지하는 조건 내에 변경, 게시가 가능합니다.

# 하드카피월드 프로젝트

• 하드카피월드 프로젝트 게시판 바로가기
• 뇌파로 제어하는 RC 카 프로젝트
• 아두이노 웨어러블 DIY 프로젝트 (스마트 워치, 스마트 밴드)
• 와두이노(WArduino) : 아두이노를 이용한 웨어러블용 오픈 하드웨어 제작
• 모모토(MoMoTo) : 블루투스를 이용한 아트토이 프로젝트
• 게임 메이커 : 아두이노 DIY 게임기 제작 프로젝트
• 홈챗 : 텔레그램으로 제어하는 홈 오토메이션
• 1회용 컵을 재활용한 스마트 화분
• 음성인식 홈 컨트롤러
• 아두이노 초급 강좌, 중급 강좌, IoT 강좌
• 외 다수

# 하드카피월드 인터뷰 모음

• redusers.com 인터뷰
• 블로터닷넷 인터뷰
• 전자신문 인터뷰
• SeeedStudio 인터뷰

# 관련 기사

• [아시아 투데이] 스마트밴드, 원리 간단한데 내가 직접 만들어볼까
• [동아] 스마트 밴드·3D 가상현실 뷰어, 직접 만든다…‘웨어러블X 페어’ 열려
• [The Science Times] 글로벌 메이커운동 동향 포럼 열려
• [果壳精选] 메이커 페어 심천 2015 현장 소개 기사 (중문)
• [CSDN] 메이커 페어 심천 2015 참가팀 소개 기사 (중문)
• [ICT DIY 뉴스레터] 이달의 메이커 – 하드카피월드
• [SeeedStudio 뉴스레터] HardCopyWorld, A maker community from Korea

# 전시회, 페어, 해커톤

• [Creator Planet] 오픈소스 아두이노 웨어러블, 소개 페이지
• [웨어러블 X 페스티벌] 오픈소스 아두이노 스마트 워치 전시, 강연, 스마트 밴드 만들기 교육 프로그램
• [2014 Maker Faire Seoul] 오픈소스 아두이노 웨어러블
• 서울시 공공 IoT 해커톤
• [2015] 메이커 마켓 주관
• [2015 Maker Faire Shenzhen] 오픈소스 아두이노 웨어러블, 소셜벅, 아두이노 네트웍 게임패드
• [2015 Nabi Hackathon] H.E.ART BOT(Handcraft Electronic Art Bot)
• [2015 Maker Faire Seoul] 게임 메이커 : 아두이노 네트웍 게임기
• [2015 Nabi Hackathon] Makeable city – 모모토 프로젝트, 웨어러블 프로젝트
• [2016 Nexon Family Day] 부모님과 아이가 함께하는 DIY 게임기
• [2016 서울 상상력 발전소] 다시 만나는 세운상가 프로젝트

# 강연

• 웨어러블 X 페스티벌 : 아두이노 스마트 워치 개발 사례
• 2014 Maker Faire : 오픈소스 아두이노 웨어러블 강연
• 임베디드SW&웨어러블 스마트 디바이스 컨퍼런스 : 아두이노를 활용한 웨어러블 스마트와치 개발 사례
• 2015 제3회 Let’s MAKE 포럼 : (메이커 운동이 미치는 산업의 변화) ‘디지털 제작기기를 활용한 창업’
• 2015 벤처기업협회 Yes challenge 메이커톤 : Maker talk show 강연
• 2016.03 KAIST 초청 강연

# 저서

• Maker Pro 메이커 프로 : 에세이 기고
• 대화하는 사물을 만드는 아두이노 통신 프로젝트
• 아두이노 초급서 (집필중)

# 오프라인 강좌

• 아두이노 기초 강좌 – 경기콘텐츠코리아 랩 위키 팩처링 캠프 (종료)
• 창조경제 박람회 – 스마트 밴드 DIY 강좌 (종료)
• 웨어러블 X 페스티벌 : 스마트 밴드 DIY (종료)
• 블로터닷넷 아카데미 – Wearable DIY 워크샵
• 블로터닷넷 아카데미 – 블루투스(BLE) 활용 : 비컨, 웨어러블, 통신의 기초 및 실습
• 블로터닷넷 아카데미 – 아두이노 8비트 게임기 만들기
• 과천과학관 무한상상실 – 상상 메이커스 데이 : 게임 메이커
• 코오롱 베니트 – 오픈 하드웨어 기초와 활용 강좌
• 패스트캠퍼스 – IoT 비즈니스 CAMP – 오픈 하드웨어 파트
• 넥슨 – 아두이노를 이용한 게임기 제작과 응용작품 만들기

# 오픈 하드웨어 제작

• 웨어러블용 아두이노, 와두이노(WArduino) : 오픈하드웨어 제작 및 공유 사업

LED 하나를 켜기 위해서 아두이노 디지털 핀 하나를 사용합니다. 하지만 LED가 8개 라면? 디지털 핀 8개 사용하면 됩니다. 하지만 16개 혹은 그 이상이 된다면? 이처럼 사용해야 할 디지털 출력의 수가 많을 때 “시프트 레지스터(shift register)”를 사용하게 됩니다.

시프트 레지스터는 다른 이름으로 Serial to Parallel Converter 로 불립니다. 시리얼(직렬)로 입력되는 데이터를 패러럴(병렬)로 바꿔준다는 얘기입니다. 이걸 보기 편하게 이미지로 나타내면 아래와 같습니다.

시프트 레지스터에게 데이터가 전달된다고 알려주는 클럭(clock) 신호와 함께 8개의 핀 출력이 어떻게 되는지 알려주는 시리얼 데이터를 일렬로 보내줍니다. 첫 번째 핀만 on 시키고 싶다면 [1000 0000] 신호를 보내면 되겠죠. 그러면 시프트 레지스터는 8개의 신호를 받아 8개의 핀을 신호에 맞게 출력해줍니다. 이런 방식으로 사용하면 그림처럼 2 개의 핀으로 8개 혹은 그 이상의 핀을 제어할 수 있습니다. (실제로는 제어선 3개를 사용합니다.)

LED 출력 뿐 아니라 수십개의 버튼 입력을 받을 때도 시프트 레지스터를 사용할 수 있습니다. 버튼 입력을 받을 때는 동작이 반대로 되겠죠. 그래서 시프트 레지스터는 두 개로 나뉩니다. SIPO(Serial In Parallel Out) 방식과 PISO(Parallel In Serial Out) 방식입니다.

전자는 LED 8 개 혹은 그 이상의 출력을 한 번에 제어할 수 있고 74HC595 칩을 사용합니다.

후자는 버튼 8 개 이상의 입력을 받을 수 있고 74HC165 칩을 사용하면 됩니다.

먼저 74HC595 칩을 이용해서 LED 8개를 제어하는 예제부터 테스트 하겠습니다.

SIPO – 74HC595 핀 구조 및 동작

먼저 74HC595N 칩이 가진 16개의 핀이 어떤 핀인지부터 알아야 합니다.

• 1~7, 15 (Q0~Q7)
  출력을 제어하고 싶은 8개의 핀입니다. LED 를 제어하고 싶다면 Q0~Q7까지 순서대로 연결해야 합니다.
• 14 (DS, Data pin)
  클럭 신호에 맞춰 데이터가 전송되는 핀입니다.
• 13 (OE, Output Enable)
  출력 핀 전체를 한번에 on/off 시키고 싶을 때 사용합니다. 이 핀을 PWM 핀에 연결해주고 PWM 신호를 주면 LED 밝기 조절이 가능합니다. 이 핀은 active low 상태로 사용하기 때문에 굳이 사용치 않을 때는 아두이노 GND 핀에 연결해주면 됩니다.
• 12 (STcp, Storage(Latch) Register Clock pin)
  시프트 레지스터가 수신한 데이터를 래치 레지스터(Latch register, 핀 제어값 저장공간)에 저장하도록 해주는 신호선
• 11 (SHcp, Shift Register Clock pin)
  아두이노와 시프트 레지스터가 박자에 맞춰 데이터를 전송할 수 있도록 클럭 신호를 전송하는 핀입니다.
• 10 (MR, Master Re-clear)
  리셋핀, Active low 이므로 반대로 5V에 연결합니다.

11(SHcp) 핀에 의해 클럭 신호가 생성되면 이 신호에 맞춰 14(DS) 핀으로 8개의 데이터를 전송합니다. 즉, 클럭 신호가 HIGH 상태일 때 DS 핀의 신호도 HIGH 라면 1 이 전송된 것이고, 클럭 신호가 HIGH 일 때 DS 핀의 신호가 LOW 라면 0 이 전송된 것입니다.

이렇게 8개의 신호가 전달되면 시프트 레지스터는 수신한 값을 Storage(Latch) register 라는 저장공간에 넣습니다. 이후에는 Storage(Latch) register 에 저장된 값에 따라 8개의 Q0~Q7 출력이 변화하게 됩니다.

이때, Storage(Latch) register 값을 외부에서 변경한다는 신호도 보내줘야만 레지스터 값이 바뀝니다. 그래서 데이터를 전달하기 전에 12(STcp) – latch 핀을 LOW 상태로 바꿔주고 데이터 전송이 끝났을 때 HIGH 상태로 다시 돌려둡니다.

연결 방법

조금 복잡하지만 아래 순서로 연결합니다. 먼저 아두이노 5V, GND 핀을 브레드보드에 연결한 다음 74HC595 칩에 연결합니다.

• 16 (VCC) –> 5V
• 10 (MR) –> 5V
• 8 (GND) –> GND
• 13 (OE) –> GND

이제 3개의 데이터, 클럭, latch 클럭 핀을 아두이노의 디지털 핀 3개에 연결합니다. (변경 가능)

• 11 (SHcp, clock) –> D12
• 12 (STcp, latch clock) –> D8
• 14 (DS, data) –> D11

여기에 8개의 저항을 이용해서 Q0~ Q7 까지 LED를 연결해주면 됩니다.

(위 그림에서 12(STcp) – GND 사이의 1uF 커패시터는 생략해도 될듯?)

스케치

간단한 예제부터 테스트…

/*
Adafruit Arduino - Lesson 4. 8 LEDs and a Shift Register
*/
 
int latchPin = 8;      //Pin connected to ST_CP of 74HC595
int clockPin = 12;   //Pin connected to SH_CP of 74HC595
int dataPin = 11;    //Pin connected to DS of 74HC595
 
byte leds = 0;
 
void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(dataPin, OUTPUT);  
  pinMode(clockPin, OUTPUT);
}
 
void loop() {
  leds = 0;
  updateShiftRegister();
  delay(500);
  for (int i = 0; i < 8; i++)  {
    bitSet(leds, i);
    updateShiftRegister();
    delay(500);
  }
}
 
void updateShiftRegister() {
   digitalWrite(latchPin, LOW);
   shiftOut(dataPin, clockPin, LSBFIRST, leds);
   digitalWrite(latchPin, HIGH);
}

1 byte 크기의 변수인 leds 를 구성하는 비트대로 8개의 LED 를 on/off 합니다. 스케치에서 leds 값이 다른 방식으로 변경되도록 응용해서 사용해보세요.

스케치에서 가장 중요한 부분은 아래 코드입니다. 실제 시프트 레지스터를 제어하는 부분입니다.

void updateShiftRegister() {
   digitalWrite(latchPin, LOW);
   shiftOut(dataPin, clockPin, LSBFIRST, leds);
   digitalWrite(latchPin, HIGH);
}

먼저 데이터를 시프트 레지스터로 전송하기 전에 Storage register clock pin (latch pin) 의 상태를 LOW 로 바꿔줘야 합니다. 데이터 전송이 끝나면 다시 HIGH로 바꿉니다.

데이터를 전송할 때는 아두이노가 제공하는 shiftOut() 함수를 사용하면 됩니다. shiftOut() 함수는 4개의 값을 넣어줘야 하는데 순서대로 아래와 같은 의미입니다.

• dataPin : DS 핀 넘버
• clockPin : Clock 핀 넘버
• LSBFIRST : LSB(Least Significant Bit) 비트부터 전송. 즉, 1byte 데이터 중 가장 오른쪽의 데이터부터 전송한다는 의미입니다. MSBFIRST (Most Significant Bit) 을 사용해도 됩니다. 이때는 LED on/off 가 반대로 바뀌겠죠
• leds : 8개의 비트 상태값을 담은 1byte 데이터

스케치를 실행해보면 아래처럼 동작합니다.

여러개의 시프트 레지스터 연결

2개 이상의 시프트 레지스터를 연결해서 제어가능한 출력의 수를 늘릴 수 있습니다.

이때는 아래처럼 연결됩니다.

2 번째로 추가한 시프트 레지스터 칩도 첫 번째와 유사하게 연결하는데 데이터 전송과 관련된 아래 3 핀을 다르게 연결해주면 됩니다.

• Shift Register 1 –> Shift Register 2
• 11 (SHcp, clock) –> 11 (SHcp, clock)
• 12 (STcp, latch clock) –> 12 (STcp, latch clock)
• 9 (Q7”, serial out) –> 14 (DS, data)

이렇게 연결하면 여전히 3개의 핀만 아두이노에 연결되지만 16개의 LED를 제어할 수 있습니다. 16개의 LED를 제어할 때에는 아래처럼 latch pin 을 LOW 로 바꾼 후, 데이터를 1byte 씩 두 번 보내면 됩니다.

digitalWrite(latchPin, 0);
    shiftOut(dataPin, clockPin, 255);
    shiftOut(dataPin, clockPin, 255);
    digitalWrite(latchPin, 1);

라이브러리

shiftOut() 함수를 이용해 제어하기가 어려운 경우 혹은 7 segment 같은 장치를 좀 더 편하게 제어하고 싶은 경우 라이브러리를 이용하세요.

• 시프트 레지스터 라이브러리 (다중 제어 지원)
• 7 segment 제어용
• ShiftRegister74HC595 라이브러리

PISO – 74HC165 시프트 레지스터

SIPO 방식의 74HC595 와 거의 유사한 방식으로 사용이 가능합니다. 아래 링크를 참고하세요.

• https://learn.sparkfun.com/tutorials/shift-registers

참고자료

• ShiftRegister and 8 LEDs
• Arduino official shift out tutorial
• Arduino and shift register
• Arduino official shift in tutorial
• 74HC165 예제
• Shift register example

터치 센서를 직접 만들고 싶을 때 유용한 모듈, MPR121 터치센서 모듈입니다. 터치를 이용한 각종 인터페이스 장치를 만드는데 아주 유용합니다.

MPR121은 정전 용량 터치(Capacitive Touch Sensor) 센서 모듈입니다. Capacitive(Capacitance) 란 의미는 전하를 저장하는 물체라는 뜻입니다. 즉, 센서가 일정량의 전하를 저장하고 있다가 외부 접촉에 의해 이 값이 바뀔 경우 터치를 인식하는 원리입니다.

MPR121 터치센서 모듈은 한 모듈 당 최대 12개의 터치를 인식할 수 있습니다. 인식된 결과는 I2C 통신으로 읽어올 수 있으며, IRQ 인터럽트 핀을 지원하기 때문에 터치 상태가 바뀔 때 알려줄 수도 있습니다.

상세한 스펙은 아래 문서를 참고하세요.

• https://www.sparkfun.com/datasheets/Components/MPR121.pdf

연결 방법

아래처럼 I2C의 기본 연결 방법대로 연결하면 됩니다. IRQ 핀은 터치의 변화가 감지되었을 때 알려주는 인터럽트 핀입니다. 따라서 필요한 경우 IRQ 를 아두이노 우노 기준 D2 또는 D3 인터럽트 핀에 연결해서 사용해도 됩니다. loop() 반복함수를 빠르게 돌면서 터치 입력을 계속 체크하는 경우 인터럽트 핀(IRQ)은 사용하지 않아도 됩니다.

스케치

라이브러리 없이 사용도 가능한데.. 코드가 좀 복잡해집니다. 아래 링크에서 소스코드를 받아 사용하면 됩니다.

• http://bildr.org/2011/05/mpr121_arduino/

라이브러리는 아래 링크에서 받을 수 있습니다.

• https://github.com/adafruit/Adafruit_MPR121

라이브러리에는 MPR121test.ino 파일이 들어있습니다. 이 스케치를 열어보면 사용법을 알 수 있습니다.

#include <Wire.h>
#include "Adafruit_MPR121.h"

// You can have up to 4 on one i2c bus but one is enough for testing!
Adafruit_MPR121 cap = Adafruit_MPR121();

// Keeps track of the last pins touched
// so we know when buttons are 'released'
uint16_t lasttouched = 0;
uint16_t currtouched = 0;

void setup() {
  while (!Serial);        // needed to keep leonardo/micro from starting too fast!

  Serial.begin(9600);
  Serial.println("Adafruit MPR121 Capacitive Touch sensor test"); 
  
  // Default address is 0x5A, if tied to 3.3V its 0x5B
  // If tied to SDA its 0x5C and if SCL then 0x5D
  if (!cap.begin(0x5A)) {
    Serial.println("MPR121 not found, check wiring?");
    while (1);
  }
  Serial.println("MPR121 found!");
}

void loop() {
  // Get the currently touched pads
  currtouched = cap.touched();
  
  for (uint8_t i=0; i<12; i++) {
    // it if *is* touched and *wasnt* touched before, alert!
    if ((currtouched & _BV(i)) && !(lasttouched & _BV(i)) ) {
      Serial.print(i); Serial.println(" touched");
    }
    // if it *was* touched and now *isnt*, alert!
    if (!(currtouched & _BV(i)) && (lasttouched & _BV(i)) ) {
      Serial.print(i); Serial.println(" released");
    }
  }

  // reset our state
  lasttouched = currtouched;

  // comment out this line for detailed data from the sensor!
  return;
  
  // debugging info, what
  Serial.print("\t\t\t\t\t\t\t\t\t\t\t\t\t 0x"); Serial.println(cap.touched(), HEX);
  Serial.print("Filt: ");
  for (uint8_t i=0; i<12; i++) {
    Serial.print(cap.filteredData(i)); Serial.print("\t");
  }
  Serial.println();
  Serial.print("Base: ");
  for (uint8_t i=0; i<12; i++) {
    Serial.print(cap.baselineData(i)); Serial.print("\t");
  }
  Serial.println();
  
  // put a delay so it isn't overwhelming
  delay(100);
}

가장 중요한 부분은 I2C 통신을 이용해 현재 터치 값을 읽어오는 부분이겠죠. 아래 코드가 여기에 해당합니다.

currtouched = cap.touched();
  
  for (uint8_t i=0; i<12; i++) {
    // it if *is* touched and *wasnt* touched before, alert!
    if ((currtouched & _BV(i)) && !(lasttouched & _BV(i)) ) {
      Serial.print(i); Serial.println(" touched");
    }
    // if it *was* touched and now *isnt*, alert!
    if (!(currtouched & _BV(i)) && (lasttouched & _BV(i)) ) {
      Serial.print(i); Serial.println(" released");
    }
  }

여기서 currtouched, lasttouched 변수는 2바이트 정수형 변수입니다. 2바이트이기 때문에 16개의 비트를 저장할 수 있습니다. 즉, 이 변수에 12개의 터치 값의 변화가 0 또는 1로 기록됩니다.

만약 12개의 터치 모두 인식된 상태라면, 센서에서 읽어온 현재 터치값 currtouched 변수는 [0000 1111 1111 1111] 값을 가집니다. lasttouched 는 이전 터치값을 저장하는 변수입니다. 따라서 두 개의 변수 currtouched, lasttouched 를 이용하면 터치 인식 여부를 알 수 있습니다.

말이 좀 어려운데… 그냥 위 코드를 적당히 변형해서 사용하면 됩니다.

여러개의 MPR121 모듈 연결

MPR121 모듈을 추가해서 인식 가능한 터치의 수를 늘릴 수 있습니다. (최대 4개 모듈 연결 가능) 그러기 위해서는 MPR121 모듈의 I2C 주소를 모두 다르게 설정해줘야 합니다. MPR121 모듈은 I2C default address 값이 0x5A로 세팅되어 있습니다.

ADD(어드레스) 핀을  VSS, VDD, SDA, SCL 핀과 연결하면 I2C address 값이 0x5A, 0x5B, 0x5C, 0x5D 로 바뀝니다. 상세한 내용을 datasheet와 아래 링크들을 참고한 뒤 시도하세요.

• https://www.sparkfun.com/products/9695
• https://www.sparkfun.com/datasheets/Components/MPR121.pdf

게임회사(넥슨) 직원분들이 아두이노를 공부해서 만든 결과물들을 소개합니다. 넥슨 아두이노 포럼의 마지막 과제였던 개인 프로젝트의 결과물들 입니다. 업무로 바쁘신 와중에도 틈틈히 시간내어 완성해 주셨습니다.

아래 프로젝트들은 기본적인 동작이 가능한 수준까지 완료한 프로토타입 상태입니다. 패키징을 (전혀;;;) 하지 않은 상태이지만 포장만 잘 하면 어디 내놔도 손색이 없으리라 생각됩니다.

몬스터 볼

아두이노 강좌에 사용된 각종 모듈 – 온습도, 가속도/자이로, 온습도, GPS, 블루투스, 진동모터 등이 총동원된, 진정한 강좌 복습용 프로젝트(??) 몬스터 볼입니다.

아직 프로토타입이라 형태는 볼이 아니지만;;; 최종 패키징 후에는 주변 환경(위치, 온습도, 사용자 동작)을 측정해서 상황에 맞는 몬스터를 소환해줍니다. 그리고 소환된 몬스터와 간단한 (가위바위보) 게임을 할 수 있는 본격 온오프 믹스 프로젝트. 휴대폰 앱과 연동되어 동작합니다.

추억의 가위바위보 게임기

옛날 문방구 앞의 한 자리를 차지하던 가위바위보 게임기를 아두이노 구현했습니다. “응답하라 19xx” 스타일의 본격 킬링타임용 게임기 DIY 프로젝트. 아직 8×8 LED 매트릭스가 하나 도착을 안해서 완전한 형태의 사진은 못찍었네요;;

핑쿠핑쿠

단순하지만 꽤나 어렵고 중독성 있는 게임기. 버튼을 누르면 핑크색 LED 공을 앞으로 밀기 시작합니다. 공이 끝에 닿지 않게 타이밍 맞춰 버튼을 누르면 그 자리에 고정됩니다. 이런식으로 핑크색 공을 최대한 많이 쌓는 게임. 핑크색을 좋아하는 제작자의 따님께 헌정하는 게임기라 “핑쿠핑쿠”라고…

스마트 미러 + 타이머

실생활에 유용한 장치 하나. 요즘 핫한 DIY 주제 중 하나인 스마트 미러와 타이머. 평소 시간을 표시해주고 간단한 버튼 조작으로 타이머를 실행해서 보여줍니다. 양치할 때 좋을 듯. 3분이 얼만큼인지 대체 감이 안와서… 디스플레이는 생각보다 밝은걸 사용해야 잘보이더군요. 그래서 디스플레이 부분은 교체 예정.

뚜루뚜 룰렛

원형 RGB LED Strip을 이용해서 만든 디지털 룰렛 게임기 입니다. 아날로그 룰렛의 사운드에 맞춰 동작하는 LED와 흥을 돋우는 배경음악이 압권. 왜 뚜루뚜 룰렛인지는 영상을 보시면 알 수 있습니다.

소맥 제조기

최적의 소맥 비율에 맞춰 제조해주는 소맥 제조기. 폭탄주. 이제 간편하게 즐기세요?? 본격 성인인증 필수 19금 DIY. (제조 후 회오리 기능이 절실합니다??)

.

바쁜 업무 와중에도 시간내어 프로젝트를 완성해주신 직원분들께 이 자리를 빌어 다시 한 번 감사드립니다.

요즘 VR 핫하죠. 오큘러스, 기어 VR, 구글 카드보드 VR 같은 하드웨어 뿐 아니라 각종 컨텐츠까지… VR의 전성시대가 아닌가 싶습니다. 멀미나 VR 기기의 거추장스러움이 부담스럽기도 하지만, 적어도 VR이 사람들의 이목을 집중시키는데는 성공한 듯 합니다.

하지만 VR을 실제 체험해보면 아직도 사용자 인터페이스가 좀 불편합니다. 시선의 방향을 인식하고 NFC 또는 마그네틱을 버튼처럼 활용하는데 이것만으로는 컨텐츠내에서 다양한 액션을 하기엔 좀 모자랍니다. 그래서 별도의 컨트롤러를 팔기도 하지만 가격도 있고, 컨텐츠에 따라 컨트롤러가 지원하지 못하는 기능도 있습니다.

그래서 이참에 (시류에도 편승할 겸) VR 게임을 하나 만들어 봤습니다. 그리고 게임을 편리하게 즐길 수 있도록 컨트롤러도 함께 만들어 게임과 연동되도록 해봤습니다. 게임 제목은 “VR Defense Game – destroyer in the dark” 입니다. 이 게임은 우주 공간을 배경으로 모함을 공격해오는 적 우주선을 최대한 격추시키는 게임입니다.

이 게임은 구글 카드보드 VR을 지원합니다. 몇 천원이면 구글 카드보드 VR 패키지를 구매해서 안드로이드 폰을 이용해 체험해볼 수 있습니다. 그리고 컨트롤러는 아두이노와 버튼, 블루투스 모듈(HC-06)을 이용해 간단히 제작할 수 있습니다. 게임 제작에 사용된 소스는 모두 GitHub에 공개되어 있습니다. 직접 VR 컨텐츠를 제작해보고 싶으신 분, 블루투스 컨트롤러를 이용해 VR의 사용자 체험을 향상시키고 싶으신 분은 참고할만 할겁니다.

• GitHub 링크 : https://github.com/godstale/VR-Defense-Game

구글 카드보드 VR

개인적으로 VR 업계의 가장 큰 혁신은 구글 카드보드 VR이라 생각됩니다. 3천원~5천원 정도면 풀 패키지 구매해서 직접 조립이 가능하고 본인이 가진 안드로이드 폰을 이용해서 VR을 체험할 수 있으니까요. 골판지의 엉성함도 나름 매력이라면 매력입니다(?)

그래서 아예 처음부터 이 녀석 전용으로 게임을 만들고자 했습니다. 구글은 이를 위해 Google VR SDK for Android 를 제공하고 있습니다. Google VR SDK 에서는 렌즈 왜곡 보정, 3D 오디오, 헤드 트랙킹, 양안 렌더링, 사용자 인터랙션 등등 VR을 위한 기본 작업들을 처리해줍니다.

• https://developers.google.com/vr/android/

하지만 Google VR SDK 에서는 VR을 위한 기본 작업들을 해줄 뿐, 실제 3D 모델을 게임내에 구성하고 움직이는 작업은 프로그래머의 몫입니다. 이를 위해서는 임베디드 장치용 3D 그래픽 라이브러리인 OpenGL ES를 상당 수준으로 다룰 수 있어야 합니다.

또는 3D 컨텐츠 제작 플랫폼인 Unity를 이용할 수도 있습니다. Google VR SDK for Unity 도 구글에서 배포하기 때문에 연동이 가능합니다. 하지만 이것도 어렵기는 매 한가지 입니다. 괜히 사람들이 OpenGL 과 Unity 로 밥벌어 먹고 사는게 아닙니다…

Rajawali 3D engine

상업용 컨텐츠를 제작할 것이 아니라면 굳이 OpenGL이나 Unity를 배울 필요까지는 없다 싶어서 선택한 것이 Rajawali 3D engine 입니다. OpenGL ES 를 더 쓰기 편하게 만든 3D 라이브러리라고 보면 됩니다. Rajawali를 이용하면 골치아픈 3D 프로그래밍을 조금 더 쉽게 할 수 있도록 도와주기 때문에 선택했습니다.

뭐, Rajawali 라고해서 그리 쉬운건 아닙니다. 어느정도 안드로이드 프로그래밍에 경험이 있어야 써볼만 합니다. 그래도 Scene, Camera 및 3D object, Texture 들을 처리할 수 있는 기본 도구를 제공해주고 각종 애니매이션, 움직임을 컨트롤하기 쉽게 배려해뒀기 때문에 3D 프로그래밍 입문용으로 적절한 것 같습니다.

GitHub를 통해 배포되는 Rajawali 소스에는 다양한 예제들이 포함되어 있고 이중에는 VR 예제도 있습니다. 이번에 만든 게임도 VR 예제를 입맛에 맞게 대폭 수정해서 만들었습니다.

• https://github.com/Rajawali/Rajawali

구글 카드보드 제작

요즘은 구글 카드보드가 아니라도 휴대폰을 이용한 다양한 VR 기기가 판매되므로 적당한 것을 선택해서 만들면 됩니다. 전 구글 카드보드 2.0 으로 판매되는 약 4천원 정도의 패키지를 사서 만들었습니다.

부품이 대충 위 이미지 상태로 오는데 조립 난이도는 엄청 쉬움. 이마저도 귀찮은 분을 위해 아예 완성된 카드보드를 보내주는 곳도 있습니다…. 이 정도는 직접 하세요.

VR 컨트롤러 제작

게임 내에서 적 비행선을 격추하기위해 미사일 발사 버튼이 필요합니다. 보통 휴대폰을 이용한 VR 기기들은 이를 위해 NFC 태그나 자석을 이용해서 휴대폰이 인식할 수 있도록 합니다. 하지만 손을 항상 휴대폰 근처에 둬야해서 불편하기도 하고 빠른 인식이 잘 안되기도 합니다. 그래서 아두이노를 이용해서 VR 컨트롤러를 직접 제작했습니다.

엄청 단촐하죠. 아두이노 Nano, 버튼 2개, 블루투스(HC-06)를 이용해서 만든겁니다. 버튼1은 미사일 발사용, 버튼 2는 back 버튼입니다. 연결은 아래처럼 하면 됩니다.

아두이노 ==> 블루투스 (HC-06)

• 5V –> VCC
• GND –> GND
• D2 –> TX
• D3 –> RX

아두이노 ==> 버튼 1 (fire)

• D6 –> 버튼 다리 1
• GND –> 버튼 다리 2

아두이노 ==> 버튼 2 (cancel)

• D7 –> 버튼 다리 1
• GND –> 버튼 다리 2

구성은 단촐하지만 본연의 역할을 충실히 수행합니다. fire 버튼을 누르면 아스키 코드 ‘b’ 를 전송하고, cancel 버튼을 누르면 아스키 코드 ‘c’를 전송하는게 전부입니다. 그래서 아두이노 코드도 굉장히 단순합니다. 너무 빠르게 버튼 데이터가 전송되지 않도록 200ms 간격으로 시간을 체크하는 코드만 더해줬을 뿐입니다.

#include <SoftwareSerial.h>

SoftwareSerial BTSerial(2, 3);  // Bluetooth's TX, RX

int firePin = 6;
int cancelPin = 7;

int lastB1 = HIGH;
int lastB2 = HIGH;

unsigned long lastSendTime = 0;
unsigned long RESEND_THRESHOLD = 200;

void setup() {
  pinMode(firePin, INPUT_PULLUP);
  pinMode(cancelPin, INPUT_PULLUP);
  BTSerial.begin(9600);
}

void loop() {
  int curB1 = digitalRead(firePin);
  int curB2 = digitalRead(cancelPin);
  
  unsigned long curTime = millis();
  if(curTime > lastSendTime + RESEND_THRESHOLD) {
    if(curB1 == LOW) {
      BTSerial.write('b');
      lastSendTime = curTime;      
    } else if(curB2 == LOW) {
      BTSerial.write('c');
      lastSendTime = curTime;      
    }
  }
  
  lastB1 = curB1;
  lastB2 = curB2;
}

단순한 컨트롤러지만 이걸 확장하면 다양한 센서나 모터, 모듈을 VR과 연동할 수 있습니다.

안드로이드 프로그래밍

카드보드 조립하고 아두이노로 컨트롤러 만드는 것이야 재료만 준비되면 금방입니다. 하지만 VR 게임을 만드는 것은 차원이 다르네요;;; 블루투스 통신을 통해 컨트롤러로 부터 받은 버튼 데이터 처리하는 부분도 꽤 손이 가고… 어쨌든 Rajawali 3D engine 에서 제공하는 example 코드로부터 하나씩 구현해서 완성을 했습니다.

Rajawali 3D engine 을 이용해 VR 프로그래밍을 하는 방법에 관해서는 아래 링크에 연재글을 올릴 예정입니다. 안드로이드 스튜디오 개발환경에서 Rajawali 사용법과, 3D 물체들의 움직임 제어방법, 카메라 이동 및 시점 제어방법, 블루투스 통신을 이용한 컨트롤러 연동 방법을 다룰겁니다. 양이 좀 돼서 시간이 꽤 걸릴것 같긴 합니다만…

• http://www.hardcopyworld.com/gnuboard5/bbs/board.php?bo_table=tech_android

게임 진행

게임은 구글 플레이스토어에서 받을 수 있습니다. “VR Defense Game”으로 검색하면 됩니다.

• https://play.google.com/store/apps/details?id=com.hardcopy.vrdefense

게임을 시작하면 아래처럼 메인 화면이 나옵니다.

먼저 SETUP BLUETOOTH 버튼을 눌러 앞서 제작한 블루투스 컨트롤러와 페어링을 시켜줍니다. 페어링이 완료되면 우측에 connected 라고 뜰겁니다.

그리고 START GAME 버튼을 누르면…

주위를 둘러보면 위 이미지의 우주선이 보일겁니다. 우리가 보호해야할 모함입니다. 곧 주위에서 적 우주선들이 몰려오는데 미사일을 발사해서 우주선들을 격추해야 합니다. 미사일이 모함에 맞지 않게 주의하세요. (스코어 차감되고 모함 체력이 빠집니다.)

주위를 다시 둘러보면 적 모함(스타워즈의 destroyer)도 보입니다. 실제로는 굉장히 크게 렌더링 되어 있는데 멀리 있어서 그리 크게 안보입니다.

아군과 적 모함은 서로 미사일을 주고 받기도 하는데.. 실제 게임에 영향을 미치지는 않고.. 그냥 시각적 효과입니다;;; 적 모함에게 미사일 쏴도 꿈쩍도 않습니다.

아군 모함의 체력이 고갈되거나 cancel 버튼을 누르면 게임이 중단되고 메인 화면으로 나가게 됩니다.

현실감과 속도감을 높이기 위해 적 우주선이 꽤 빠르게 움직이도록 설정해둬서 게임이 어렵습니다. 너무 적 우주선 쫓아다니면 멀미납니다. 여유를 갖고 예측샷으로 떨구시길…

참고자료

• 게임에 사용된 오브젝트 렌더링 출처는 앱의 credit 화면에서 확인할 수 있습니다.
• 게임 소스는 GitHub에 공개되어 있습니다.
  • https://github.com/godstale/VR-Defense-Game
• VR 프로그래밍, 3D 프로그래밍에 관련된 자료는 아래 링크에 모아두었습니다.
  • http://www.hardcopyworld.com/gnuboard5/bbs/board.php?bo_table=lecture_tip&wr_id=160