blog.snoworca.com

IntelliJ Community Edition (무료버전) 에서 tomcat 연동하기

snoworca — Mon, 10 Apr 2023 09:48:44 +0900

교육용으로 만든 자료를 정리한 것이다.

IntelliJ Community Edition 은 무료지만, JAVA EE 지원이 되지 않습니다.

하지만, Smart Tomcat 이라는 플러그인을 설치하면 간단한 서블릿 웹 앱 프로젝트에 한해서 실행 및 디버깅을 진행할 수 있습니다.

(1) Gradle 프로젝트 생성

Gradle 프로젝트로 새 프로젝트를 생성합니다.

(2) Smart Tomcat 플러그인 설치

상단 메뉴 File => Settings 에 들어가서 좌측 탭의 Plugins 를 선택합니다. 그 뒤에 Smart Tomcat 을 검색하여 설치합니다.

(3) build.gradle 편집

build.gradle 파일 상단에 (repositories 블럭 밑) 아래와 같이 입력해줍니다.

sourceSets {
def webappDir = file('src/main/webapp')
main {
java {
srcDirs 'src/main/java'
}
resources {
srcDirs webappDir
}
}
doLast {
main.resources.srcDirs*.mkdirs()
new File(webappDir, 'WEB-INF').mkdirs()
new File(webappDir, 'META-INF').mkdirs()
}
}

dependencies 블럭에 다음과 같이 Servlet 의존성을 추가해줍니다..

dependencies {

compileOnly group: 'javax.servlet', name: 'javax.servlet-api', version: '3.1.0'

그 뒤로 gradle task 중에 clean 을 더블클릭하여 실행하면 자동으로 웹 앱 경로가 생성됩니다.

(4) 예제코드 작성

테스트할 수 있는 예제파일도 두 개 만들어봅니다.

src/main/webapp 경로 밑에 index.jsp 를 추가하고, 아무 패키지 경로 밑에 HelloServlet 클래스를 하나 추가하였습니다.

각각의 코드는 다음과 같습니다.

index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html lang="ko">
<head>
<meta http-equiv="Content-type" content="text/html; charset=utf-8">
<title>Hello</title>
</head>
<body>
<h1>Hello World!</h1>
</body>
</html>

HelloServlet.java

package org.example;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

@WebServlet("/hello")
public class HelloServlet extends HttpServlet {

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {

PrintWriter printWriter = resp.getWriter();
printWriter.println("<html><body><h1>Hello, World!</h1></body></html>");

}
}

(5) Smart Tomcat 설정

상단 메뉴에서 Run => Edit Configurations... 를 선택합니다. 창이 뜨면 + 버튼을 눌러 "Smart Tomcat" 을 선택합니다.

아래 스크린샷은 이미 tomcat 경로가 설정되어 있는 상태입니다. 하지만, 최초로 이 창을 띄웠다면 Tomcat Server 의 위치를 먼저 지정해야합니다. Tomcat 9 버전의 zip 파일을 다운로드 받아 ( https://dlcdn.apache.org/tomcat/tomcat-9/v9.0.73/bin/apache-tomcat-9.0.73.zip ) 압축을 해제하고 그 위치를 지정합니다.

이후 다른 설정은 위 (3) 번 과정이 제대로 진행 되었다면 자동으로 입력된 상태로 나타납니다.
Name을 원하는 값으로 변경하세요.

OK 버튼을 누르면 설정이 저장되고 창이 닫힙니다.

(6) 디버깅 모드로 실행

벌레모양 아이콘 클릭

웹 브라우저에서 서블릿에 접속한 모습

디버깅까지 잘 되는 것이 확인되지만, 코드를 저장하면 자동으로 반영되는 핫 디폴로이는 자동으로 되지 않습니다.

하지만, 단축키 Ctrl+Shift+F9 를 눌러 현재 작성중인 코드에 대한 핫 디폴로이를 진행할 수 있습니다.

감사합니다.

구형 공기 청정기 IOT 기기로 개조

snoworca — Mon, 11 Apr 2022 13:03:39 +0900

(사진 출처: https://www.blueair.com/ 블루에어 공식 페이지)

내가 일하는 사무실에서 약 5년간 공기 청정을 담당하다가 얼마 전 집으로 오게 된 구형 공기청정기 블루에어 Pure211. 이 녀석을 구글 홈에 붙여서 음성으로 컨트롤하거나 원하는 시간에 꺼지거나 켜지게 할 수 있도록 인터넷을 연결해 보았다.

1. 기기 분석 - 개조 가능한지 살펴보기

첫 번째 할 일은 공기청정기를 분해해서 개조가 가능한지 살펴보는 것이다. 내가 생각했던 제일 좋은 개조 방법은 스위치 케이블을 ESP8266(아두이노를 탑재한) 에 연결하고, 다시 아두이노에서 공기청정기로 스위치 신호를 보내는 방법이다. 그렇게 되려면 구조가 간단해야 하는데...

스위치와 연결된 케이블

기판을 분해해서 스위치 쪽 케이블 커넥터를 살펴보니 친절하게 설명까지 되어있다 ㅠ_ㅠd 5V 와 GND, 그리고 아마도 스위치 신호를 받아오는 KEY 를 따서 쓰면 될 것 같다.

KEY 와 GND 의 저항값

KEY가 버튼에서 나온 신호가 맞는지 확실히 확인하기 위해서 기기에 전원이 들어온 상태에서 KEY 와 GND를 쇼트시켜봤다. 이어서 공기청정기 팬이 동작하는 것을 확인하였다. 케이블이 연결된 상태에서 KEY 와 전원(5V)의 저항 값도 찍어보았다. 연결된 상태에서 찍었기 때문에 6.71K옴이 나왔지만, 실제로는 10K 옴이다. 어쨌든 이것으로 풀업(pull up) 스위치를 사용한다는 것을 확인하였다.

2. 개조 시작 - 하드웨어

우선 기기에 ESP8266을 연결하고(ESP32 를 사용하고 싶지만, 집에 여분의 ESP8266 부품들이 많다...) 릴레이를 붙여서 스위치 신호를 보내고, 외부에 달린 스위치는 ESP8266에 붙이는 것이 계획이다. ESP8266에 아두이노 코드를 올려서 MQTT로 서버에 상태를 전송하거나 명령을 받을 수 있도록한다. 그리고, 기기 상태를 알려줄 수 있는 스피커를 붙여서 소리를 통하여 인터넷, 서버 연결과 설정, 모드 진입 상태를 알려줄 수 있도록 한다.

필요한 라인 가져오기

이제 5V, GND, KEY 케이블을 따서 연장선을 붙였다. 겨우 이 세 가닥의 라인을 이용해서 인터넷으로 공기청정기를 제어할 수 있다니.... ㅠ_ㅠ 잠시 기쁨의 눈물을 흘려보았다.

컨트롤러 모듈

컨트롤러를 만들 때 사용한 부품은 다음과 같다.

- NodeMCU v1.0 (ESP8266)

- 3.3v 옵토 커플러 릴레이

- 스피커

- 터미널 블록과 기타 부품류

회로도를 그려보면 아래와 같다.

회로도

버튼이 5V 를 사용하고 ESP8266 은 3.3v 를 사용하기 때문에 버튼 신호를 받기 위해서 10K, 20K 저항을 이용여 전압을 낮춰줘야한다.

2. 소프트웨어

우선 지난번에 구현한 Web 설정 마법사 라이브러리를 활용한다. 최초 기동하거나, 버튼을 10초 이상 눌렀을 경우 스마트폰으로 연결하여 WiFi 와 Mqtt 서버 주소를 설정할 수 있다. 그뿐만 아니라, WiFi 혹은 Mqtt 서버와의 연결에 장애가 생길 경우 자동으로 재접속을 시도하는 기능도 제공한다.

ESP8266 에 웹 설정 마법사 붙이기 (dev.re.kr)

ESP8266 에 웹 설정 마법사 붙이기

가끔씩 필요에 의해서 만드는 IOT 기기 프로젝트를 진행하면 제일 고민스럽고 귀찮은 것 중에 하나가 WiFi 연결과 서버 연결 설정을 만드는 부분이다. 이 프로젝트를 완성하기 전에는 소스코드 내

dev.re.kr

이 공기 청정기의 풍속 조절 방법은 매우 단순한데, 버튼을 한 번 누르면 1단, 그다음 누르면 2단, 그리고 3단 마지막으로 전원이 꺼진다. 버튼 조작 사이사이에 아주 약간의 딜레이가 있으며, 5초 이상 누르고 있으면 필터 교체 알람(LED 붉은색 교체) 기능이 꺼진다. 따라서 온라인 조작 프로토콜도 매우 단순하게 만들 수 있다. 다만, 현재 풍속에서 목표 풍속으로 만들기 위해서 약간의 시간이 필요할 수 있으니 이것을 감안하여 만들어야 할 것이다. (예를 들어 현재 2단 상태에서 1단 상태로 만들기 위해서 릴레이를 "3단->전원 끄기->1단" 순으로 총 3번 동작 시켜야한다.) 그래서 목표 풍속을 담는 변수를 하나 만들고 현재 풍속을 담는 변수를 만들었다. 현재 풍속이 목표 풍속과 같아질때까지 +1 을 반복한다. 상태가 바뀔 때마다 상태 이벤트를 MQTT로 전송한다.

다음으로 고민해야 할 사항은 서버와 통신할 때 사용할 데이터 포맷인데, JSON 으로 처리하려고 했다가 단순 Key:Value 만 전달하면 되는데 JSON을 쓰는 것은 좀 오버인 것 같아서 쿼리 스트링을 사용하기로 하였다. 쿼리 스트링을 처리하기 위하여 그냥 아주 간단하고 비효율적인 링크드 맵과 동적 버퍼를 구현하였다. 또 데이터를 쿼리 스트링 포맷으로 내보내거나 파싱 할 수 있는 기능도 구현하였다. 대충 만든 탐색 방법이 거슬리지만 귀찮아서 여기까지...

이렇게 구현된 코드는 이곳에 올려뒀다.

ice3x2/IOTForBlueAirPure: Converted "BlueAir Pure XXX" into an IOT device.... (github.com)

GitHub - ice3x2/IOTForBlueAirPure: Converted "BlueAir Pure XXX" into an IOT device....

Converted "BlueAir Pure XXX" into an IOT device.... - GitHub - ice3x2/IOTForBlueAirPure: Converted "BlueAir Pure XXX" into an IOT device....

github.com

MQTT 로 전달되는 데이터 프로토콜은 다음과 같다.

명령 (publish)

풍속 변경
- Topic: [디바이스 키]/qstate
- Value: cmd=mode&tm=[목표 풍속 0-3]
차일드 락
- Topic: [디바이스 키]/qstate
- Value: cmd=childLock&cl=[끄기,켜기 0,1]
산토끼 재생(아들을 위한 이스터에그)
- Topic: [디바이스 키]/qstate
- Value: cmd=tp_stk_bp

이벤트 (subscribe)

heartbeat - 5초간격
- Topic: [디바이스 키]/heartbeat
- Value: cmd=hb&t=[디바이스 동작시간(분)]
상태 이벤트
- 상태가 바뀔때 전송
- Topic: [디바이스 키]/state
- Value: cmd=state&tm=[목표 풍속 0-3]&cm=[현재 풍속 0-3]&cl=[차일드락 0,1]&fr=[필터 리셋 모드 0,1] &v=[버전]&ip=[ip 주소]

3. 실사용

MQTT 명령어를 전송하여 테스트 하는 모습.

https://youtu.be/XkLjeYqjWbU

이제 본격적으로 사용하기 위해서 구글 홈에 붙여보았다.

https://youtu.be/fEDPs0-THl0

ESP8266, ESP32 에 웹 설정 마법사 붙이기

snoworca — Tue, 22 Mar 2022 12:54:25 +0900

가끔씩 필요에 의해서 만드는 IOT 기기 프로젝트를 진행하면 제일 고민스럽고 귀찮은 것 중에 하나가

WiFi 연결과 서버 연결 설정을 만드는 부분이다. 이 프로젝트를 완성하기 전에는 소스코드 내에 하드코딩으로 무선 AP 의 SSID와 패스워드를 삽입해 버리거나 웹 서버를 동작시켜서 GET 파라미터 값으로 SSID 와 패스워드 그리고 mqtt 서버 주소를 입력하는 방법을 사용해왔다. 하지만, 최종 연결 상태를 확인하거나 추가 옵션을 붙이기가 만만치 않고, 중구난방으로 생겨나는 자작 IOT 기기들의 설정 방법들이 일관되지 않아서 유지 보수가 어렵다는 단점이 있었다.

그래서 일관된 방법으로 설정값을 넣기 위한 웹 설정 마법사 모듈을 단순하게 만들어봤다.

소스코드 및 사용방법: https://github.com/ice3x2/ESP-Web-Configuration-Wizard

GitHub - ice3x2/ESP-Web-Configuration-Wizard: This is a wizard tool that allows you to configure the ESP8266, ESP32 WiFi connect

This is a wizard tool that allows you to configure the ESP8266, ESP32 WiFi connection, NTP, MQTT, and Options via web. - GitHub - ice3x2/ESP-Web-Configuration-Wizard: This is a wizard tool that all...

github.com

최초 connect() 함수를 호출하였을 때, 또는 startConfigurationMode() 함수를 직접 호출하였을 때 동작한다.
주요 기능으로 WiFi AP 의 SSID 와 패스워드를 설정하고, 시간을 동기화하기 위한 NTP 서버, MQTT 접속 정보를 설정할 수 있다. 또 커스텀 옵션을 추가할 수 있으며, 옵션 값 체크를 할 수 있는 API를 제공한다.

코드도 대충 만들고, 설정하는 과정에서 중요하지 않은 버그도 조금 있지만 그럭저럭 잘 동작한다.

그래도 연결이 끊어질 경우 다시 동작하도록 하는 로직 덕분에 한 번 연결되면 안정적으로 커넥션을 유지한다.

C# 에서 ms office 문서 PDF 로 변환하기

snoworca — Mon, 24 Jan 2022 13:42:35 +0900

참조 추가 => COM 에서 다음 항목들을 추가한다.

이후 아래의 코드를 사용하면 끝.

다만, 보안 문제가 있는 형식은 예외를 발생시키는데 이를 강제로 열 수 있는 방법을 찾아야한다.

 public static void WordToPDF(string docPath, string exportPath)
        {
            Microsoft.Office.Interop.Word.Document wordDocument;
            Microsoft.Office.Interop.Word.Application appWord = new Microsoft.Office.Interop.Word.Application();
            // 경로, 파일 변환 대화상자 표시 안 함, 읽기 전용으로 열기
            wordDocument = appWord.Documents.Open(docPath, true, true);
            wordDocument.ExportAsFixedFormat(exportPath, Microsoft.Office.Interop.Word.WdExportFormat.wdExportFormatPDF);
            wordDocument.Close(false);
            appWord.Quit();
        }


        public static void ExcelToPDF(string xlsPath, string exportPath)
        {
            Microsoft.Office.Interop.Excel.Application appExcel = new Microsoft.Office.Interop.Excel.Application();
            appExcel.Visible = false;
            Microsoft.Office.Interop.Excel.Workbook workbook;
            workbook = appExcel.Workbooks.Open(xlsPath, Type.Missing, true);
            workbook.ExportAsFixedFormat(Microsoft.Office.Interop.Excel.XlFixedFormatType.xlTypePDF, exportPath, Microsoft.Office.Interop.Excel.XlFixedFormatQuality.xlQualityStandard, true, true, Type.Missing, Type.Missing, false, Type.Missing);
            workbook.Close(false);
            appExcel.Quit();
        }


        public static void PPTToPDF(string pptPath, string exportPath)
        {
            Microsoft.Office.Interop.PowerPoint.Application appPPT = new Microsoft.Office.Interop.PowerPoint.Application();
            Microsoft.Office.Interop.PowerPoint.Presentation presentation = appPPT.Presentations.Open(pptPath, Microsoft.Office.Core.MsoTriState.msoTrue,
                                                                                          Microsoft.Office.Core.MsoTriState.msoTrue,
                                                                                          Microsoft.Office.Core.MsoTriState.msoFalse);

            presentation.ExportAsFixedFormat(exportPath, Microsoft.Office.Interop.PowerPoint.PpFixedFormatType.ppFixedFormatTypePDF,
            Microsoft.Office.Interop.PowerPoint.PpFixedFormatIntent.ppFixedFormatIntentPrint,
            Microsoft.Office.Core.MsoTriState.msoFalse, Microsoft.Office.Interop.PowerPoint.PpPrintHandoutOrder.ppPrintHandoutVerticalFirst,
            Microsoft.Office.Interop.PowerPoint.PpPrintOutputType.ppPrintOutputSlides, Microsoft.Office.Core.MsoTriState.msoFalse, null,
            Microsoft.Office.Interop.PowerPoint.PpPrintRangeType.ppPrintAll, string.Empty, true, true, true, true, false, Type.Missing);

            presentation.Close();
            appPPT.Quit();
        }

간단한 IOT 무드등 만들기

snoworca — Tue, 12 Nov 2019 01:09:21 +0900

예젠에 회사 블로그에 올렸던 글...

준비물

1. NodeMCU v2

WIFI 기능이 탑재된 가성비 좋은 마이크로 컨트롤러 보드입니다.

2. USB 와이어 LED

오픈마켓 등에서 'USB 와이어 LED' 로 검색하여 구입 가능합니다.

3. 브레드보드와 점퍼 케이블

납땜 없이 전자 회로를 구성하고 테스트 할 수 있습니다.

4. NPN 트렌지스터 - 2N2222

NodeMCU v2 소개

NodeMCU v2 에는 중국 에스프레시프 시스템사에서 개발된 wifi 기능이 탑재된 MCU, ESP8266-12E 모듈이 탑재되었습니다. 이 기기의 스펙을 간략하게 적어보면 다음과 같습니다.

- 802.11 b/g/n 프로토콜

- Wi-Fi Direct (P2P), soft-AP

- TCP/IP 프로토콜

- 80Mhz 클럭 스피드를 갖는 저전력 32bit CPU 통합.

- 3.3v 전원으로 동작. (입력전원 5-12v)

- 디지털 입출력핀(GPIO)

- UART, SPI, I2C 프로토콜 지원

- 64Kbyte SRAM

- 4MB 플래시 메모리

아두이노 부트로더를 올리고 C/C++ 를 이용하여 편하게 개발할 수 있으며 가격도 5000원 정도로 참 저렴합니다. ESP8266-12E 는 시리얼 통신 방식 중에 하나인 UART로 프로그램을 올리거나 디버깅 할 수 있지만, UART 와 USB 통신을 변환하는 CP2012 드라이버 칩을 탑재하고 있습니다. 전원부는 AMS1117 를 이용하여 5v에서 12v까지의 전압을 갖는 전원을 3.3v으로 변환하여 공급해줍니다. 하지만, 3.3v를 이용하는 탓에 5v를 사용하는 센서나 기타 개발 보드 등의 기기와 맞물려 사용할 때는 스위치 회로를 구성해야 합니다.

아래 그림은 NodeMCU v2 의 핀과 역할에 대한 맵 입니다. 주로 사용하게 될 디지털 입출력(GPIO) 핀은 출력(OUTPUT)모드에서 HIGH 상태와 LOW 상태를 가질 수 있습니다. HIGH 상태에서는 해당 핀에 3.3v의 전압을 갖는 전류가 흐르게 되지만, LOW 상태에서는 전류가 흐르지 않습니다. GPIO 핀에는 각각의 번호가 있습니다. 아두이노 IDE 를 이용하여 코딩할 때, 이 핀 번호를 지정하여 직접 제어할 수 있습니다.

Step1. 아두이노 IDE 기본 설정

NodeMCU 에서 아두이노를 사용하기 위해서는 다음과 같은 기본 설정 과정을 거쳐야 합니다.

(1) https://www.arduino.cc/ 페이지에 접속후 Software -> Downloads 페이지에 들어가 아두이노 IDE 최신 버전을 다운로드 받습니다. Windows10 운영체제인 경우 스토어에서 아두이노 최신 버전을 받을 수 있습니다.

(2) 아두이노 IDE 를 실행한 뒤 상단 메뉴의 파일 -> 환경설정 에 들어갑니다. 그 뒤 아래 그림처럼 '추가적인 보드 매니저 URLs' 에 주소 https://arduino.esp8266.com/stable/package_esp8266com_index.json 를 추가하고 확인 버튼을 누릅니다.

(3) 상단메뉴 툴 -> 보드 -> 보 매니저...(가장 상단) 에 들어갑니다. 아래 그림처럼 보드 매니저 창이 뜨는 것을 확인할 수 있습니다. 검색창에 'esp8266' 를 입력하고 나온 'esp8266 by ESP8266 Community' 패키지를 설치합니다.

(3) 마지막으로 보드 설정을 해줍니다. 여기서는 NodeMCU v2 를 사용할 것이기 때문에 아래와 같이 설정해 줍니다.

Step2. 웹서버 만들기

상단 메뉴의 '툴 -> 보드' 에서 NodeMCU 1.0 을 선택하면 '파일 -> 예제' 메뉴에 ESP8266WebServer 라는 항목이 생깁니다. 예제를 통하여 간단한 웹서버를 바로 만들어볼수도 있습니다. 여기서는 IOT 무드등을 컨트롤하기 위한 웹 서버를 만들어보려고 합니다.

우선 간단한 HTTP API 를 호출할 수 있도록 구현해 보았습니다.

표 : HTTP API 정의

패스	파라미터	반환값	설명
/state	없음	{"isOn" : true \| false, "brightness" : 1-100 }	상태 값(전원, 밝기)을 가져온다.
/onoff	isOn=[true \| false]		전원을 끄거나 켠다.
/brightness	value=[1-100]		밝기를 조절한다.

코드: API 서버

#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>

#ifndef STASSID
#define STASSID "공유기 이름"
#define STAPSK  "패스워드"
#endif

const char *_ssid = STASSID;
const char *_password = STAPSK;

ESP8266WebServer _server(80);

// on/off 상태
bool _isOn = false; 
// 밝기 
int _brightness = 100;


void setup(void) {
  // 시리얼 통신 속도(baud rate) 설정.
  Serial.begin(115200);

  // WIFI 동작모드. 
  // WIFI_STA, WIFI_AP, WIFI_AP_STA 모드 중에 하나를 사용할 수 있습니다.
  WiFi.mode(WIFI_STA);
  
  // 연결할 WIFI AP의 ssid 값과 패스워드를 설정합니다.
  WiFi.begin(_ssid, _password);
  Serial.println("");

  // WIFI AP에 연결될 때까지 기다립니다.
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  

  Serial.println("");
  Serial.print("Connected to ");
  Serial.println(_ssid);
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());

  // 상태 확인 API path 및 함수 설정
  _server.on("/state", onRequestState);
  
  // LED램프 on/off API path 및 함수 설정
  _server.on("/onoff", onRequestOnOff);
  
  // 밝기조절 API path 및 함수 설정
  _server.on("/brightness", onRequestBrightness);

  // 404 에러 페이지
  _server.onNotFound(onNotFound);
  
  _server.begin();
  Serial.println("HTTP _server started");
}


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

// 현재 상태 값을 JSON 형태로 반환합니다.
void onRequestState() {
   String result = String("{\"isOn\":") + (_isOn ? "true": "false");
          result += String(",\"brightness\":") + _brightness + "}";

   _server.sendHeader("Access-Control-Allow-Origin", "*");
   _server.send(200, "application/json",result); 
}


void onRequestOnOff() {
   // 파라미터 'isOn'의 값을 가져옵니다.
   _isOn = String("true") == _server.arg("isOn");
   setOnOff();
   onRequestState();
}

void onRequestBrightness() {
   // 파라미터 'value' 의 값을 가져옵니다.
   // 이 값을 1 부터 100까지의 값을 가질 수 있도록 합니다.
   int value = (String("") + _server.arg("value")).toInt();
   if(value < 1) value = 1;
   else if(value > 100) value = 100;
   _brightness = value;
   setBright();
   onRequestState();
}



void setOnOff() {
  // 추후 구현을 위하여 비워놓습니다.
}

void setBright() {
  // 추후 구현을 위하여 비워놓습니다.
}


void onNotFound() {
 
  String message = "404 File Not Found\n\n";
  message += "URI: ";
  message += _server.uri();
  message += "\nMethod: ";
  message += (_server.method() == HTTP_GET) ? "GET" : "POST";
  message += "\nArguments: ";
  message += _server.args();
  message += "\n";
  
  for (uint8_t i = 0; i < _server.args(); i++) {
    message += " " + _server.argName(i) + ": " + _server.arg(i) + "\n";
  }

  _server.send(404, "text/plain", message);
}

이 코드를 NodeMCU 에 업로드하기 위하여 USB 5 pin 케이블을 아래 사진과 같이 연결하고 아두이노 IDE 상단 메뉴의 '툴 -> 포트' 에서 새로 추가된 포트를 선택합니다. 그 다음 '스케치 -> 업로드' 를 선택하여 기기에 코드를 올릴 수 있습니다.

위 코드를 자세히 보면 setup() 함수와 loop() 함수가 있는 것을 발견할 수 있습니다. 이 두개의 함수는 아두이노 생명주기를 담당합니다. setup() 이벤트 함수 내부에서 디지털 입출력 핀 및 라이브러리를 초기화 할 수 있으며, 최초 한 번반 실행됩니다. 그 이후 loop() 이벤트 함수가 무한 연속으로 호출됩니다.

아두이노 디버깅은 주로 시리얼 통신(UART)과 아두이노 IDE 에 포함된 시리얼 모니터를 통하여 할 수 있습니다. 시리얼 모니터 창은 상단 메뉴의 '툴 -> 시리얼 모니터' 를 선택하여 띄울 수 있습니다. 시리얼 통신을 사용하기 위해서는 setup() 함수 내부에서 Serial.begin(int) 를 호출하여 초기화 시켜줘야 합니다. Serial.begin(int) 함수의 인자값으로 시리얼 통신 속도(baud rate)를 줘야하며, 시리얼 모니터 우측 하단에서 동일한 값으로(아래 이미지 빨간 밑줄) 맞춰줘야 내용이 제대로 출력됩니다.

방금 올렸던 API 서버 코드가 제대로 동작하는지 확인하기 위하여 시리얼 모니터를 띄워보았습니다.

192.168.10.39 라는 ip 주소를 할당받았음을 알 수 있습니다. 웹 서버를 만들어 기기를 컨트롤 하는 방식은, 조만간 소개할 MQTT 활용법에 비하여 여러가지 불편한점들이 많습니다. 특히 무선 AP 에 접속한 이후 DHCP 를 통하여 동적 ip 주소를 받는 경우 매번 이렇게 시리얼 모니터를 통하여 할당받은 ip 주소를 확인해야 합니다. 가능하다면, 공유기 등의 DHCP 장비 환경 설정에서 접속된 NodeMCU 기기의 맥 어드레스에 특정 ip 를 고정 할당하도록 설정해 놓는 것이 좋습니다.

아래 코드를 wifi 연결 완료 부분 뒤에 추가하면 시리얼 모니터를 통하여 맥 어드레스도 확인할 수 있습니다.

Serial.print("MAC: ");
Serial.println(WiFi.macAddress());

시리얼 모니터로 알아낸 ip 주소로 각각의 API 를 호출해 보았습니다.

모두 정상 동작하는 것을 확인할 수 있습니다.

위 API 를 UI 를 통하여 호출할 수 있도록 간단한 웹 페이지를 만들어 보았습니다.

NodeMCU v2 의 ESP8266-12E 는 플래시 메모리가 4Mbyte 로 다른 아두이노 기기들에 비해 적은 편은 아니지만, 그래도 복잡하고 화려한 웹 페이지를 넣기에는 한계가 있습니다. 따라서 웹 페이지 코드를 아래처럼 간단하게 구성 하였습니다.

코드 : index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, user-scalable=no">
    <title>Simple Mood Lamp</title>
    <link rel="stylesheet" type="text/css" href="./index.css" />
</head>
<body>
    <div class="out-box">
        <div class="content">

            <div>
           <input type="button" value="" id="onoff-button" onclick="onClickOnOffButton()">
            </div>
            <div class="brightness-content">
                    <div class="float-parent">
                        <div class="float-left">
                                <input type="range" min="1" max="100" value="0" 
                                     id="brightness-slider" oninput="onInputSlider()"
                                      onchange="onChangeBrightness()">
                        </div>
                        <div class="float-left" id="brightness-value"/>
                    </div>
            </div>
        </div>
    </div>
</body>
<script  src="https://code.jquery.com/jquery-3.4.1.min.js" 
         integrity="sha256-CSXorXvZcTkaix6Yvo6HppcZGetbYMGWSFlBw8HfCJo="  
         crossorigin="anonymous"></script>
<script src="index.js"></script>
</html>

코드 : index.js

html body {
    padding: 0;
    margin: 0;
    width: 100%;
    height: 100%;

}
.out-box {
    display: table;
    position: fixed;
    width: 100%;
    height: 100%;

}
.content {
    display: table-cell;
    vertical-align: middle;
    text-align: center;
    width: 100%;
}


.brightness-content {
    display: inline-block;
    margin-top: 20px;
}

.float-left {
    float: left
}

.float-parent {
    height: 30px;
    width: 100%;
    text-align: center;
    float: none;
}

#brightness-slider {
    width: 200px;
}

#onoff-button {
    background-color: gray; /* Green */
    border: none;
    color: white;
    width: 150px;
    height: 45px;
    display: inline-block;
    font-size: 20px;
}

코드 : index.css

var _brightnessSliderEle = null;
var _brightnessValueEle = null;
var _buttonEle = null;
var _state = null;


$(document).ready(function() {
    init();
    onState();
});

function init() {
    _brightnessSliderEle = $('#brightness-slider');
    _brightnessValueEle = $('#brightness-value');
    _buttonEle = $('#onoff-button');

}

function onState() {
    $.get("http://192.168.10.39/state").done(function (data)  {
        setState(data);
    }).fail(function (err) {

    });
}

function setState(state) {
    _state = state;
    setBrightness(state.brightness);
    setOnOff(state.isOn);
}

function onClickOnOffButton() {
    _state.isOn = !_state.isOn;
    var param = {isOn : _state.isOn };
    $.post("http://192.168.10.39/onoff",param ).done(function (data)  {
        setState(data);
    }).fail(function (err) {

    });
}

function onChangeBrightness() {
    _state.brightness = _brightnessSliderEle.val();
    var param = {value : _state.brightness};
    $.post("http://192.168.10.39/brightness",param ).done(function (data)  {
        setState(data);
    }).fail(function (err) {

    });
}

function onInputSlider() {
    _brightnessValueEle.text(_brightnessSliderEle.val() + "%");
}

function setBrightness(value) {
    _brightnessValueEle.text(value + "%");
    _brightnessSliderEle.val(value);
}

function setOnOff(isOn) {
    if(isOn === true) {
        _buttonEle.val("ON");
        _buttonEle.css("background-color","#4CAF50")
    } else {
        _buttonEle.val("OFF");
        _buttonEle.css("background-color","#f54b42")
    }
}

위 세개의 웹 소스 코드를 압축하여 API 서버 코드 상단에 다음과 같이 추가합니다.

#define INDEX_CSS "html body{padding:0;margin:0;width:100%;height:100%}.out-box{display:table;position:fixed;width:....
#define INDEX_JS "var _brightnessSliderEle=null,_brightnessValueEle=null,_buttonEle=null,_state=null;function init(....
#define INDEX_HTML "<!DOCTYPE html><html lang='en'><head><meta charset='UTF-8'><meta name='viewport' content='widt ....

그리고, 아래와 같이 코드를 추가하여 루트 경로로 접속할 때 웹페이지를 출력할 수 있도록 합니다.

setup() {

// ... 중략 ... 

_server.on("/", onRequestIndexHTML);
_server.on("/index.css", onRequestIndexCSS);
_server.on("/index.js", onRequestIndexJS);

// ...
}


void onRequestIndexHTML() {
  _server.send(200, "text/html ",INDEX_HTML); 
}

void onRequestIndexJS() {
  _server.send(200, "application/javascript ",INDEX_JS); 
}

void onRequestIndexCSS() {
  _server.send(200, "text/css",INDEX_CSS); 
}

아직 LED 조명은 붙이지 않았지만, 웹페이지로 제어할 수 있도록 구현 하였습니다.

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

예제 다운로드 :

Step3. LED 조명 제어하기

와이어 LED 조명에 전원을 연결한 모습입니다. USB 의 5v 로 동작하지만 상당히 밝은편 입니다.

니퍼를 이용하여 와이어 LED 조명의 USB 전원 케이블을 끊고, 내부에 있는 구리 케이블을 꺼내서 가늘게 말았습니다. 브레드보드 구멍에 넣기 위해서 끝을 뾰족하게 만들어야 합니다.

브레드 보드에 NodeMCU 를 붙이고 점퍼 케이블을 이용하여 회로를 구성해줍니다.

위 사진에 나온 회로를 fritzing 을 이용하여 그려보면 아래와 같습니다. LED 전구는 와이어 조명을 나타냅니다.

이 프로젝트에서 사용되는 NPN 트렌지스터는 2N2222 를 사용하였습니다. NPN 트랜지스터를 사용하는 이유는 다음과 같습니다. 와이어 조명은 5v 사용시 300mA 전류를 소비하지만 NodeMCU 의 입출력 핀은 3.3v 에 고작 12mA 으로 동작합니다. 따라서 스위치 역할을 해주는 NPN 트렌지스터를 사용하는 것 입니다. 즉, 낮은 전압과 전류로 높은 전압과 전류를 사용하는 기기를 컨트롤 하기 위함입니다.

디지털 회로에서 NPN 트렌지스터의 역할은 아래 그림과 같이 전류가 흐를 수 있도록 스위칭해주는 것 입니다. collector, emitter, base 핀의 위치는 종류와 제조사마다 다르므로 사용하기 전에 데이터 시트를 확인해야 합니다. 제가 사용한 2N2222 NPN 트렌지스터는 평평한쪽 기준으로 왼쪽부터 collector, base, emitter 입니다. (참고 - NPN 트랜지스터의 과열과 파손을 방지하기 위하여 Base 에 저항을 연결해야 합니다. 이 예제에서 사용한 2N2222 는 Base 와 Emitter 간의 전위차가 0.65v 이상을 넘어가면 안됩니다. 하지만, Base 단에 저항을 연결하면 LED 조명의 밝기가 어두워지므로 트랜지스터가 과열되는 것을 감안하고 이런 회로를 구성 하였습니다. 현재 회로대로 구성하고 확인해보니 0.7v 가 나옵니다. )

위 회도로에서 보이는 것과 같이 트렌지스터의 Base 를 NodeMCU 의 'D1' 핀에 연결 하였습니다. 'D1' 핀은 5 라는 번호를 갖고 있습니다. 아주 간단한 입출력 테스트 위하여 아두이노 IDE 의 기본 예제인 Blink 를 열어봅니다. 상단 메뉴에서 '파일 -> 예제 -> Basics -> Blink' 순서대로 들어가서 예제를 불러올 수 있습니다.

기본 예제에서 LED 번호만 우리가 연결한 5번 디지털 출력핀으로 변경합니다.

void setup() {
  // 5번 디지털 핀 출력 모드로 초기화.
  pinMode(5, OUTPUT);
}

void loop() {
  digitalWrite(5, HIGH); // LED 조명 켜기 
  delay(1000);           // 1000ms 딜레이       
  digitalWrite(5, LOW);  // LED 조명 끄기
  delay(1000);           // 1000ms 딜레이 
}

이 코드를 업로드하여 실행하면 1초 간격으로 LED 조명이 깜빡이는 것을 볼 수 있습니다.

다음으로 밝기 조절과 관련된 테스트입니다. 우선 설명에 앞서 관련 코드를 올리고 테스트부터 해보도록 하겠습니다.

void setup() {
  // 5번 디지털 핀 출력 모드로 초기화
  pinMode(5, OUTPUT);
}

void loop() {
  // 밝아졌다 어두워졌다를 반복하게 합니다. 
  // 0 : 꺼짐, 1023 : 가장 밝게. 
  for(int i = 1; i < 1024; ++i) {
    analogWrite(5, i);
    delay(1);
  }
  for(int i = 1023; i > 0; --i) {
    analogWrite(5, i);
    delay(1);
  }
}

아래 영상은 위 코드를 올려서 실행한 모습입니다.

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

이런 밝기 조절은 analogWrite() 함수를 이용하여 할 수 있습니다.

digitalWrite() 함수는 단지 끄고 켜는 것 (HIGH, LOW) 밖에 할 수 없습니다. 하지만, analogWirte() 는 0에서 1023 까지의 총 1024 단계를 입력할 수 있습니다. (NodeMCU (ESP8266-12E) 는 1024 단계가 기본 값이지만, 다른 아두이노 기기들은 기본 255단계를 갖고 있습니다.) 이 값의 의미는 PWM 제어에 필요한 주파수를 입력하는 것 입니다.

PWM 제어란, 간단히 비유해서 스위치에 연결된 전구가 하나 있다고 가정했을 때, 1초에 스위치를 500 번 정도 아주 빠르게 껐다켰다 반복하면 사람 눈에는 깜빡이는 것처럼 보이지는 않겠지만 스위치를 계속 켜놓고 있는 상태보다는 어둡게 보일 것 입니다. 1초에 500번에서 60번 정도로 줄인다면 더 어둡게 보이겠죠.

이런 PWM 제어는 NodeMCU 의 모든 디지털 출력 핀에서 사용 가능한 것은 아닙니다.

(D1) GPIO 5, (D2) GPIO 4, (D3) GPIO 0, (D4) GPIO 2, (D5) GPIO 14, (D6) GPIO 12, (D7) GPIO 13, (D8) GPIO 15, (RX) GPIO 3, (TX) GPIO 1 핀에서만 사용 가능합니다.

Step4. 웹으로 LED 제어하기

드디어 Step2 에서 만들었던 조명 제어에 필요한 웹 API 서버에 실제로 조명을 제어하는 코드를 붙여보겠습니다.

우선 Step2 에서 가장 마지막으로 수정한 코드에 비어있는 setBright() 함수와 setOnOff() 함수 내부를 아래와 같이 채워줍니다.

void setOnOff() {
  if(!_isOn) {
    digitalWrite(_ledControlPin, LOW);
  } else {
    setBright();
  }
  
}

void setBright() {
  if(!_isOn) return;
  // 1 에서 100사이의 값을 100에서 1024 사이의 값으로 치환
  int value = map(_brightness, 1,100, 100,1024);
  analogWrite(_ledControlPin, value);
}

이제 완성된 코드를 올려봅시다.

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

크리스마스 트리에도 응용해 보았습니다.

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

마치며

ESP8266 를 사용하는 가성비 좋은 마이크로 컨트롤러 보드와 아두이노를 이용하여 아주 간단한 IOT 무드등을 만들어 봤습니다. 아주 기본적인 예제로 구현한 탓에 아쉬운점이 있습니다. 우선, 기기를 서버로 구현하였기 때문에 IP 주소를 알아내어 접속해야 하고, 공유기를 사용한다면 외부망에서도 접근 가능하도록 포트를 개방해줘야할 것 입니다. 만약 조명에 스위치를 달아준다면, 웹 페이지와 동기화도 쉽지 않으며 보안에도 취약할 수 있습니다. 만약 본격적으로 IOT 기기를 만들어야 한다면 MQTT를 활용하는 것이 더 나은 방법입니다. 그럼에도 이번 포스팅은 이렇게 간단한 방법으로도 IOT 기기를 만들 수 있다는 것을 소개하는데 의의를 두고 작성 하였습니다. 만약 앞으로 기회가 된다면 MQTT를 이용하여 구현하는 방법에 대하여 다루겠습니다.

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

[이클립스] 4K 해상도에서 아이콘이 작게 나오는 문제 해결

snoworca — Sun, 30 Jun 2019 23:27:56 +0900

27인치 4K 해상도의 모니터로 이클립스를 열었을 때 조금 당황스러웠었다.

눈을 모니터에 가까이 가져가야 보일 정도의 작은 아이콘과 패키지 익스플로어의 깨알 같은 폰트들이 보였기 때문이다.

이런 경우 eclipse 디렉토리에 있는 eclipse.ini 파일을 열어서 가장 마지막 줄에 아래의 옵션을 추가해주면 된다.

-Dswt.enable.autoScale=true
-Dswt.autoScale=200
-Dswt.autoScale.method=nearest

카자흐스탄 침블락 스노보드 원정기 (2)

snoworca — Wed, 14 Mar 2018 13:58:26 +0900

둘째날이 밝았습니다.

이 날은 전 날 내린 눈이 많이 쌓여서 눈사태 위험이 있었기 때문에 스키장 측에서 눈 폭파 작업후 2시간 늦게 오픈을 한다는 통지를 해왔다고 합니다.

덕분에 잠을 더 자고 천천히 출발할 수 있었습니다.

베이스 위에 올라가니 산 위에 걸려있던 구름은 더 아래쪽으로 내려가고 (도시는 흐렸습니다) 쨍한 하늘 아래 장엄한 산봉우리와 가슴 설레게 하는 광활한 슬로프가 눈에 들어왔습니다.

심장터질뻔...

2860m 중간 정상에 올라왔습니다.

중간 정상 슬로프 모습. 토요일 오전이었는데도 불구하고 사람 없는 넓은 슬로프가 너무 마음에 들었습니다.

정설은 되었지만 아직 파우더 설질을 유지하고 있어서 라이딩하기에도 좋았었어요.

저 멀리 산보다 낮게 깔린 구름이 보이네요. 구름 아래에는 알마티 시내가 감춰져 있습니다.

타는중1.

타는중2.

서로의 자세를 봐주고 설명하고 있는 중입니다.

정상에서는 이러고 놀았습니다....

오전에 2번 라이딩을하고 밥 먹으러 갑니다.

어제 그 식당에 또 갔습니다.

오리엔탈 느낌이 맘에 드네요.

하지만, 직물로 되어있는 좌석 소파가 젖은 보드복 바지 때문에 눅눅해지는 문제가 있었습니다.

보드복 자켓을 벗어서 깔고 앉아야만 했습니다.

자리에 앉을 때 보이는 경관.

너무 아름답습니다.

샤슬릭의 양고기는 걍렬한 향을 풍겨서 콜라를 찾게 만드네요.

우리나라에서 먹는 양꼬치는 좋아하지만, 이 곳의 양고기는 적응하기가 쉽지 않습니다.

밥을 다 먹으니 3200m 의 최고 정상도 오픈 하였습니다.

최정상에 가기 위해서는 중간 정상에서부터 곤돌라나 리프트를 타고 더 올라가야 합니다.

곤돌라 밖으로 보이는 최정상 중앙 슬로프의 경사는 그렇게 심하지 않은 것 같습니다.

체감상 폭이 넓고 펜스가 없는 용평 리조트의 골드 환타스틱 느낌입니다.

3200m 정상입니다.

정설된 곳은 슬로프고 그렇지 않은 곳은 그냥 눈밭입니다.

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

일행 중에 한 분이 저곳에 들어가자고 제안합니다. 하하하..

보기보다 경사가 꽤 됩니다. 저런 파우더에서 한 번 넘어지면 다시 일어나기가 쉽지 않습니다.

무엇보다 이곳은 해발 3200m 고산지대라 조금만 움직여도 숨이 가쁘게 올라옵니다.

게다가 제 데크로 저런 곳에 들어간다면...

무서웠지만 과감하게 도전!!

결국 이렇게 되는군요.

너무 숨이 차고 힘이 빠지고 눈앞이 노래져서 그냥 넘어졌습니다.

이게 바로 말로만 듣던 고산병 아닌가 합니다.

우리 일행들도 엄청 고생하고 있습니다.

앞에서도 계속 뒹굴고 있습니다.

저는 숨이 너무 가쁘게 차올라서 벌러덩 누워버렸습니다.

결국 안되겠다 싶어서 데크를 들고 걸어서 내려가는 것을 시도하였는데...

한 발을 내디디니 발이 쑥~~~ 빠지더군요... ㅡ , ㅡa 허리까지 눈에 묻혔습니다.

걸국 데크 위에서 누워서 스켈레톤 썰매처럼 내려오다가 결국 다른 일행 한 분이 구조해 줬습니다....

모두 지쳐있는중...

하지만 다들 파우더의 맛(?)을 알아버렸습니다.

이제부터 파우더만 찾으러 다닙니다...

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

그래도 아직 익숙하지 않은 파우더와 범프 구간.

파우더에서 넘어질 때는 이렇게 벌러덩~ 해야 재미있습니다.

넘어져도 전혀 충격이 없어요.

기절중...

여기 누워있는 이 분은 다음 시즌에는 꼭 파우더 데크를 지르리라 굳게 마음먹었습니다. ㅎㅎㅎ

단체샷

조금 구석에 있는 슬로프 간다면 사람이 아무도 없고 이렇게 놀기 좋습니다.

참, 오후 보딩은 대략 3시 50분까지 즐겼습니다.

여행사에서 일정을 정할 때, 첫째 날은 4시, 둘째 날부터 4시 30분까지 주차장에 모여서 하산하는 것으로 스케줄을 잡았습니다.

곤돌라를 타고 주차장까지 내려오는 시간이 짧지 않기 때문에 대략 30~40분 전까지 라이딩을 마쳐야 합니다.

라이딩을 더 즐기고 싶은 사람은 더 즐기다가 주차장에서 따로 택시를 잡고 내려올 수 있도록 배려(?)해줍니다. (버스는 시간되면 그냥 가버립니다)

알마티에서 택시 잡는 법은 좀 재미있습니다.

길을 가다가 인도 밖으로 손을 흔들면 달리던 차들 중에 한 대가 멈추는데, 운전자에게 목적지를 말하고 가격을 흥정하고 탑승하면 된다고 합니다.

실제로 알마티 시내에서 남녀 불문하고 택시 잡는 관경을 많이 봤는데, 이렇게 하여도 위험하지 않은가 봅니다.

이제 호텔로 돌아와서 씻고 도시 관광 겸 밥을 먹으러 나갈 준비를 합니다.

우리가 묵고 있는 호텔입니다.

뭔가 익숙하네요 ㅎㅎ

오래된 차들이 많은 편인데, 대우에서 생산된 자동차들도 많이 보였습니다.

알마티의 신호등이 없는 횡단보도를 건널 때는 길을 달리던 모든 차들이 급브레이크를 밟으며 멈추는 모습이 인상 깊었습니다.

우람하고 개성없는 느낌을 주는 동구권 느낌의 건물들.

하지만, 길가의 사람들도 동구권 느낌이라... 남녀 할 거 없이 모두 키가 엄청 컸습니다.

카자스흐탄의 타임스퀘어(?)인 Dostyk 플라자 입니다.

굉장히 깔끔하고 좋습니다.

젊은 사람들이 많이 찾는 공간 같더군요.

쇼핑몰 외관을 못 찍어서 구글에서 퍼온 사진을 가져왔습니다.

이 곳에서 지역에서 유명한 쌀국수집을 갔습니다.

용이 천장에 매달려 있는 인테리어와 디제이가 열심히 일하고 있던 홀이 인상적이었습니다.

한국에서 매우 흔하게 먹는 배트남 음식이지만.....

이렇게 부드럽고 맛있는 고기가 많이 들어간 나시고랭은 처음 먹어보는 것 같습니다.

정작 밥은 별로...

쌀국수는 면발 빼고는 다 괜찮았습니다.

역시 고기가 많이 들어가있네요.

고기를 엄청 좋아한다면, 카자흐스탄 강추입니다.

메뉴 하나에 한국돈으로 대략 5~6천원 정도 했었습니다.

밥을 다 먹은다음 알마티의 이마트(?) 를 구경하기로 합니다.

역시 사진을 못 찍어서... 구글에서 퍼왔습니다.

카자흐스탄의 물가1. (한국돈으로 약 840원)

카자흐의 물가2. (5L 생수 약 680원)

보드카코너.

다양한 치즈들.

숙소에서 다 함께 보드카 한 잔 하며 멋진 하루를 마무리합니다 ㅎㅎ

다음 편에서 계속...

카자흐스탄 침블락 스노보드 원정기(1)

snoworca — Tue, 13 Mar 2018 14:36:57 +0900

저는 규모는 크지는 않지만, 나름 복지가 괜찮은 회사에 다니고 있습니다.

직원들을 위한 복지중에 하나가 1년에 한 번씩 해외 워크샵을 보내주는 것이며,

사내 직원들과 팀을 짜서 원하는 장소로 갈 수 있습니다.

여행지에서 신나게 먹고 마시며 즐길수도 있고,

함께 3박 4일 이상씩 붙어 다니기 때문에 업무에 관련된 이야기를 심도 있게 나눌 수 있는 시간이기도 합니다.

더 좋은 점은 결혼한 분들은 3년에 한 번씩 부부 동반으로 다녀올 수 있도록 비용을 지원해 줍니다.

사내 동료 직원들 중에 저와 같이 스노보드를 즐기는 분들과 함께 팀을 짜서 카자흐스탄 알마티에 있는 침블락 (Symbulak) 스키장을 을 다녀오게 되었습니다.

결론부터 이야기 하면 강추입니다.

끝내주는 경치와 3월 초에도 즐길 수 있는 최고의 설질, 국내에서 즐기기 어려운 건설 파우더를 느낄 수 있습니다.

이곳은 스키 관광 전문 여행사를 통하여 갔으며 대체로 만족스러웠습니다.

3월 1일 한 시에 에어 아스타나 항송 KC910 편을 탑승 하였습니다.

인천공항에서 알마티 공항까지 약 7시간 거리입니다.

갈 때는 핸드크림, 귀마게, 칫솔 세트, 안대, 슬리퍼 세트를 주머니에 담아서 나눠줍니다.

안대에 적힌 문구가 인상적이네요.

기내식. 나름 먹을만 하네요.

재미있는 것은 음료수로 보드카를 선택할 수 있다는 것입니다. (무려 벨루가가 나옵니다.)

역시 러시아 인접 국가답네요.

거의 도착. 정말 지루한 비행입니다.

크지 않은 규모의 카자흐스탄 공항에 도착하여 정신없이 환전하고 바로 버스로 호텔까지 이동하였습니다.

공항에는 가이드님이 계셔서 편리하게 안내를 받을 수 있었습니다.

3인실을 주문했더니... 이렇게 큰 방이 왔네요.

단점은 너무 건조하다는 것입니다. 알마티라는 도시 자체가 굉장히 건조한 것 같아요.

그래도 건조함 덕분에 눈에 젖은 옷들과 장비를 말리기에 제격이었습니다.

호텔 석식에서 나온 벨루가 보드카. 이 곳에서는 대략 1만 9천원 밖에 안 합니다.

맛이 깔끔한 것이 좋아요.

대충 호텔 석식을 먹고 내일을 기대하며 바로 곯아떨어졌네요.

아침에 마신 500ml 짜리 에너지 드링크... 몬스터보다 훨씬 강한 것 같았습니다. 역시 이쪽 동네는 에너지 드링크도 클라스가 다르네요.

호텔 조식을 마친 뒤에 이렇게 생긴 버스를 타고 출발합니다.

제가 간 날은 대략 36명 정도가 왔었던 것 같은데, 버스 짐칸이 꽤 커서 그 많은 스키와 보드 장비가 다 들어갑니다.

버스 내부는 좌석간 의 간격이 넓지도 않고 매연이 안으로 들어와서 매우 불편했지만, 이동시간이 길지 않아서 참을만 했습니다.

(내부로 들어오는 매연은... 3000m 가 넘는 침블락 정상에서 생길 수 있는 고산병 적응훈련이라 생각하고 참았습니다... ㅡ , , ㅡ)

이 날은 눈이 꽤 많이 왔어요.

차창 밖을 찍은 모습.

버스를 타고 1593m 의 곤돌라 탑승장까지 이동합니다. 그리고 곤돌라로 30분간 2260m 의 스키장 베이스로 이동하게 됩니다.

위로 올라갈수록 눈도 더 많이 오고 시야도 안 좋아지네요.

나란히 찍은 보드 장비들...

가장 긴 데크가 저의 장비입니다.

이날은 일반 라운드 데크로 가져올걸.. 후회했었습니다.

스키장 지도.

날씨탓에 Close 된 곳이 많았지만, 슬로프에 올라가보니 눈도 많고 펜스도 없어서 어디가 슬로프고 어디가 산인지 구분하기 힘들더군요.

그냥 대략 다 Open 같은 Close라고 보면 됩니다. ㅡ , ㅡa

리프트는 멈춰있어도 그냥 다른 슬로프로 장비 들고 걸어서 올라가는 사람들도 많이 있었습니다.

생애 처음으로 가본 고산지대라 처음에는 초보자 슬로프에서 적응 훈련(?)을 진행하였습니다.

가이드님이 처음부터 올라가면 고산병 때문에 힘들 수 있다며 적응 훈련을 추천해 주시더군요.

하지만 T바가 익숙하지 않은 분들은 계속 넘어지는 굴욕을 당했습니다.

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ

오늘 안에 못탈듯...

평소에 스케이팅(바인딩 한쪽발만 착용)을 많이 해보지 않은 분들은 타기 힘들 것 같아요...

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

접니다...

허벅지 안쪽보다 허리나 엉덩이에 끼고 올라가면 편하게 올라갈 수 있습니다.

내려가기 전에 한 컷.

내려와서 한 컷.

3월에 즐길 수 있는 밀가루 같은 설질이 참 마음에 듭니다.

이제는 곤돌라를 타고 중간 정상으로 올라가보기로 합니다.

침블락 스키장은 중간 정상이 있고, 가장 높은 곳에 있는 정상이 있습니다.

각각 2860m 와 3200m 쯤에 위치하고 있는데, 이 날은 기상 상황이 안 좋아서 중간 정상만 오픈 하였습니다.

이렇게 눈이 많이 쌓인 것을 본 것은 오랜만이라 뒹굴기만 해도 즐겁더라고요.

하지만, 다음날 이 많은 눈들이 우리들의 숨통을 조여오게 되는 사건이 발생합니다.

어쨌든 첫 날은 정상에서 정말 신나게 놀았던 것 같습니다.

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

하지만 정상에서 즐거운 시간을 보낸 것을 비웃기라도 하듯 안개는 점점 짙어졌고, 마치 산에 구름이 걸린 것 같았네요.

마치 우유 속에 들어온 것 같았는데, 시간이 지날수록 가시거리가 짧아졌습니다.

처음에는 이정도였는데...

두 번째 내려올땐느 이정도...

가장 젊은 일행도 결국 이렇게 기절해 버렸습니다.

더는 위험하다고 판단하여 베이스에 있는 식당으로 돌진 하였습니다.

식당 분위기.

오리엔탈한 인테리어의 넓은 식당입니다.

다행히도 영어가 되는 식당 직원이 있어서 제대로 주문할 수 있었습니다.

위에서부터 아메리카노 크림 파스타,

볼로네제 파스타,

그리고 스테이크 x3

추가로 콜라 5잔과 샤슬릭 1개 주문 하였는데 우리나라 돈으로 대략 5만원정도 나온 것 같았네요.

카자흐스탄 물가는 매우 저렴하지만 스키장 식당은 역시..ㅎㅎㅎ

단, 카자흐스탄의 스테이크는 대부분 드라이에이징을 한 것이기 때문에 퍽퍽하긴해도 질기지 않고 고소합니다.

저는 웻에이징 고기를 좋아하지만, 카자흐의 드라이에이징 고기는 또 다른 맛이더군요.

이렇게 스키장에 있는 식당의 스테이크도 나쁘지 않았던 것 같았습니다.

단지... 파스타는 엄청 짜요... 진짜 짜요.

(나중에 슬로프의 눈을 먹게 됩니다.)

건조한 기후의 카자스흐탄은 소를 잡자마자 피를 빼지 않고 바로 드라이에이징을 한다고 하네요.

꼬치에서 고기를 빼내는 장인의 손길...

샤슬릭은 맛이 괜찮긴한데, 양고기는 우리나라에서 먹는 양꼬치보다 향이 10배쯤 강한 것 같았습니다.

식사를 마친뒤에 다시 라이딩 시작!!

쉬는중.

타는중1.

타는중2.

뛰는중

-----------------------

이제 라이딩을 마치고 숙소로 들어왔습니다.

호텔에서 샤워하고 저녁 먹으러 갈 준비를 하는데.... 샴푸에서 염색약 냄새 같은 것이 나더라고요.

바디워시 냄새도 별로 맘에 들지 않았습니다.

그래서 우리에게 익숙한 용평 리조트 그린피아 콘도에서 가져온 비누를 챙겨왔습니다 :-)

이제야 익숙한 기분으로 씻을 수 있게 되었네요.

밥 먹으러 나가기 전에 가이드님께 받은 현지 유심입니다.

충전된 유심을 10달러에 현지 가이드에게 구매 했었는데, 호텔 와이파이보다 빠르고 좋았습니다.

pooq 이나 옥수수로 스트리밍 방송을 봐도 끊기지도 않고 데이터도 충분했던 것 같아요.

다만 유심 품질(?)에 문제가 있었던 것인지 첫날에는 원활하게 사용할 수 없었네요.

첫날 갔던 식당은 Line Brew라는 이름의 알마티 수제 맥주 & 스테이크 맛집이었습니다.

기억에 남을만큼 괜찮은 맛이었던 것 같습니다.

신청자에 한해서 예약을 한 뒤에 가이드와 함께 단체로 이동하였습니다.

지금까지 신경쓰지 못했던 호텔 앞 분위기.

알마티의 많은 횡단 보도에는 신호등이 없었지만, 사람이 건너려고 하면 앞에서 달리던 모든 차가 알아서 멈추더라고요.

참 좋은 문화인 것 같습니다.

알마티 도심 건물들. 카자흐스탄도 옛 소비에트 연방에 속해 있어서 그런지 동구권 양식(?)의 느낌을 주는 그런 건물들이 많았습니다.

이 날은 불금인지라 길이 많이 막혀서 도시 관광은 내일로 기약하였습니다.

알마티 스테이크 맛집 분위기. 전체적인 모습을 못 찍어서 매우 아쉽네요.

사실 오래된 성채의 지하실같은 분위기라 전체적인 분위기를 찍기도 어려웠습니다.

내년에 또 간다면 동영상을 찍어야겠습니다.

메뉴판 모습입니다.

미디엄에도 핏기가 보이네요.

스테이크.

수제맥주.

고소한 맛이 일품입니다.

스톤 스테이크.

이렇게 생긴 돌판에...

이런 생고기를 올려서 구워 먹습니다.

정신없이 먹느라 사진은 못 찍었습니다.

5명이서 수제 맥주와 최고급 스테이크들을 배터지게 먹었는데 고작 한국돈으로 13만원밖에 안 나왔네요.

우리에게는 저렴한 물가라서 관광하기 좋은 것 같습니다.

다음 편에서 계속...

HTTP 주소를 URL 인코딩하기.

snoworca — Thu, 31 Aug 2017 11:06:44 +0900

JAVA 에서 특정 URL 경로로 데이터를 가져오기 위하여 URL Encoding 을 해야할 때 여간 귀찮은 것이 아니다.

그래서 아래처럼 URLEncoder 클래스를 수정한 BorwerURLEncoder 를 만들었다.

사용법은 URLEncoder 와 동일하며, 마치 브라우저 창에서 URL 주소를 입력해 놓은 것처럼 출력되도록 하였다.

BrowserURLEncoder.java

import java.io.CharArrayWriter;
import java.io.UnsupportedEncodingException;
import java.net.URL;
import java.nio.charset.Charset;
import java.nio.charset.IllegalCharsetNameException;
import java.nio.charset.UnsupportedCharsetException;
import java.util.BitSet;

public class BrowserURLEncoder {

	static BitSet dontNeedEncoding;
	static final int caseDiff = ('a' - 'A');
	static String dfltEncName = "utf-8";
	
	static {
		dontNeedEncoding = new BitSet(256);
		int i;
		for (i = 'a'; i <= 'z'; i++) {
			dontNeedEncoding.set(i);
		}
		for (i = 'A'; i <= 'Z'; i++) {
			dontNeedEncoding.set(i);
		}
		for (i = '0'; i <= '9'; i++) {
			dontNeedEncoding.set(i);
		}
		
		dontNeedEncoding.set('#');
		dontNeedEncoding.set('?');
		dontNeedEncoding.set(':');
		dontNeedEncoding.set('@');
		
		dontNeedEncoding.set('-');
		dontNeedEncoding.set('_');
		dontNeedEncoding.set('.');
		dontNeedEncoding.set('*');
		dontNeedEncoding.set('!');
		dontNeedEncoding.set('$');
		dontNeedEncoding.set('&');
		dontNeedEncoding.set('(');
		dontNeedEncoding.set(')');
		dontNeedEncoding.set('/');
		dontNeedEncoding.set('*');
		dontNeedEncoding.set('+');
		dontNeedEncoding.set(',');
		dontNeedEncoding.set(';');
		dontNeedEncoding.set('=');

	}

	
	public static String encode(String url) {
		return encode(url, dfltEncName);
	}

	public static String encode(String urlString, String encoding) {
		try {
			URL url = new URL(urlString);
			StringBuilder urlStrBuilder = new StringBuilder();
			int port = url.getPort();
			String path = url.getPath();
			String query = url.getQuery();
			urlStrBuilder.append(url.getProtocol())
							.append("://")
							.append(url.getHost())
							.append(port > 0 ? ":" + port : "");
			
			if (path != null && !path.isEmpty()) {
				path = encodeString(path, encoding);
				urlStrBuilder.append(path);
			}
			if (query != null && !query.isEmpty()) {
				query = encodeString(query, encoding);
				urlStrBuilder.append("?").append(query);
			}
			return urlStrBuilder.toString();
		} catch (Exception e) {
			return urlString;
		}
	}

	private static String encodeString(String s, String enc) throws UnsupportedEncodingException {
		boolean needToChange = false;
		StringBuffer out = new StringBuffer(s.length());
		Charset charset;
		CharArrayWriter charArrayWriter = new CharArrayWriter();
		if (enc == null)
			throw new NullPointerException("charsetName");
		try {
			charset = Charset.forName(enc);
		} catch (IllegalCharsetNameException e) {
			throw new UnsupportedEncodingException(enc);
		} catch (UnsupportedCharsetException e) {
			throw new UnsupportedEncodingException(enc);
		}

		for (int i = 0; i < s.length();) {
			int c = (int) s.charAt(i);
			if (dontNeedEncoding.get(c)) {
				out.append((char) c);
				i++;
			} else {
				do {
					charArrayWriter.write(c);
					if (c >= 0xD800 && c <= 0xDBFF) {
						if ((i + 1) < s.length()) {
							int d = (int) s.charAt(i + 1);
							if (d >= 0xDC00 && d <= 0xDFFF) {
								charArrayWriter.write(d);
								i++;
							}
						}
					}
					i++;
				} while (i < s.length() && !dontNeedEncoding.get((c = (int) s.charAt(i))));

				charArrayWriter.flush();
				String str = new String(charArrayWriter.toCharArray());
				byte[] ba = str.getBytes(charset);
				for (int j = 0; j < ba.length; j++) {
					out.append('%');
					char ch = Character.forDigit((ba[j] >> 4) & 0xF, 16);
					if (Character.isLetter(ch)) {
						ch -= caseDiff;
					}
					out.append(ch);
					ch = Character.forDigit(ba[j] & 0xF, 16);
					if (Character.isLetter(ch)) {
						ch -= caseDiff;
					}
					out.append(ch);
				}
				charArrayWriter.reset();
				needToChange = true;
			}
		}
		return (needToChange ? out.toString() : s);
	}

}

각 OS별 PS 명령어를 사용하여 모든 프로세스 정보 확인.

snoworca — Fri, 3 Feb 2017 09:21:21 +0900

1. 리눅스(데비안, 우분투, 레드헷, CentOS 등등)

$ ps -ef

2. AIX .

리눅스와 동일한다.

$ ps -ef

3. Solaris

$ /usr/ucb/ps auwxw

4. HP-UX

$ ps -efx

5. BSD

$ ps auxwww

6. Windows

$ WMIC path win32_process get Processid,Commandline

Nexus 6p 액정 디스플레이 자가 수리기

snoworca — Tue, 18 Oct 2016 01:15:17 +0900

대략 두어 달 전..

자전거에 나의 Nexus 6P 를 매달고 빠른 속도로 내리막을 내지르다가 갑자기 튀어나온 요철에 급브레이크를 잡게 되었다.

덕분에 넥서스 6p 는 관성에 의해 총알처럼 튀어나갔고 아스팔트 바닥에 서너 바퀴 구른 뒤에 아래 사진과 같은 꼴을 하게 되었다.

다행히도 화면도 잘 나오고 기능 만큼은 정상적으로 동작하지만, 친구나 회사 사람이나 누구나 할 것 없이 모두 이렇게 한마디씩 했다.

"핸드폰은 언제 바꿀거에요?"

아직 바꾼지 1년도 안 되었는데... ㅜ_ㅜ

수리점을 찾았으나 나의 Nexus 6p 꼬락서니를 보고 고개를 절레절레 흔드는 분이 있는가 하면,

정말로 휴대폰을 바꿀까 고민하게 만드는 많은 수리비용 덕분에 부품을 직접 구입하여 자가 수리하기로 하였다.

이왕이면 배터리도 새것으로 교체하는 것으로...

알리 익스프레스를 통하여 구입한 액정+터치 모듈.

조금 허접하긴 하지만 일회용으로 쓸 수 있는 분해 도구도 함께 포함된다.

가격은 배송비 포함하여 70.30$ 들었다.

도착하는데 30일 가까이 걸렸다.

그리고, 이 녀석에게는 사소한 문제가 있었으니..

새 제품이 아닌 듯했다.

떼어낸 접착제 흔적과 써멀 페이스트 흔적, 그리고 기분 나쁜 얼룩을 보니

온전한 제품을 각개격파하여 판매하는 것이 아닐까 하는 의구심이 생긴다.

아마도 액정을 제외한 다른 모듈에 불량이 생긴 제품을 각개 격파하여 파는 것은 아닐까?

내가 구입했던 디스플레이 모듈 판매 페이지의 상품평에는 별 다섯 개 만점과

구매자들이 직접 입력한 좋은 평가들이 많았으니 한 번 믿고 써보도록 한다.

그리고, 알리에서 17.0$ 주고 구입한 프레임...

응?

원래 들어있어야 하는 부품은 찾아볼 수 없고 같은 부품이 두 개 들어있다.

ㅠ_ㅠ

결국, 프레임 아래쪽 덮개는 이미 있던 것을 재활용해야만 했다.

마지막으로...

문제의 배터리...

가격은 대략 11$밖에 안 하지만,

배송일이 중국 국경절과 겹치고, 오는 중간에 소포가 분실되는 바람에 도착하는데 70일 넘게 걸렸다. 핳핳....

(분실된 제품은 판매자가 다시 보내줬다.)

70일 넘는 시간 동안 나는

요 상태로 갖고 다녀야만 했다.

이제 본격적인 준비가 다 끝나고 추가로 사용한 공구 및 재료를 나열하면

일자 드라이버

니퍼

열풍기

핀셋

써멀 그리스 (MX-4)

이렇게 되겠다.

열풍기가 필요한 이유는 Nexus 6p 에 접착제와 양면 테잎이 너무 많이 들어가기 때문이다.

덕문에 수리 난이도가 꽤 높다.

분해 방법은 일단 아래 주소를 참고하였다.

https://gigglehd.com/zbxe/13487642

첫 번째 단계는 뒷 판 아래쪽에 있는 덮개를 제거하는 일이다.

아래 사진처럼 열풍기로 가열하여 접착 성분을 녹인 뒤에 제거한다.

위 사진처럼 일자 드라이버를 틈새 사이로 쑤셔 넣어 떼는 것보다

접착 성분을 녹인 뒤에 강력한 초록 테이프로 붙여서 떼는 것이 훨씬 좋을 것 같다.

상단 덮개를 제거한다.

생각보다 깔끔하게 떨어지지 않기 때문에 산산조각내어 떼어내는 장면인데,

이렇게 뗄 경우, 사방팔방에 유리 조각이 튈 수 있다.

특히 미세한 파편이 눈에 들어가지 않도록 보호경을 껴야 한다.

상단 덮개가 모두 제거된 모습.

덮개를 모두 제거한 뒤에 보이는 나사를 모두 제거한다.

그 다음 단계로 위 사진과 같이 주어진 공구를 통하여 액정과 프레임을 분리해야 하는데,

큰 문제가 있었다.

바닥에 떨어질 때 충격 때문에 위 사진처럼 프레임이 찌그러지는 바람에

간단한 방법으로는 디스플레이 모듈이 쉽게 분리되지 않는다는 것이다.

결국, 특단의 조치를 내리게 되었다.

니퍼를 이용하여 프레임의 찌그러진 부분을 벌려주는 방법을 사용한다!!

이제 디스플레이 모듈과 프레임을 분리하기만 하면 된다.

분리된 프레임 안쪽

분리된 디스플레이 모듈 안쪽.

아이폰의 유니바디와 유사한 구조를 갖고 있는 것을 확인할 수 있다.

메인보드 좌측 하단에 있는 커넥터 덮개의 나사를 풀고 제거한다.

커넥터 세 개를 조심스럽게 모두 제거한다.

하단 기판의 커넥터를 제거한다.

아....

https://gigglehd.com/zbxe/13487642 <--- 요기 있는 사진은 배터리가 참 쉽게 분리 되던데..

내 것은 초강력 접착제로 딱 달라 붙여서 쉽게 제거되지 않는다.

안 쓰는 신용카드를 마구 쑤셔 넣어서 배터리를 접착제로부터 분리하려고 하니 배터리가 ㄴ 모양으로 휘어 버린다.

이러다 결국 초록 연기를 뿜으며 터지는 것 아닌지 노심초사했지만, 배터리가 직각이 되도록 꺾여도 아무 일도 발생하지 않았다.

넥 6p 는 제조 공정에서 장인정신으로 접착제를 정성스럽게 바른 것 같다.

분리된 배터리. 심하게 휘었지만, 손으로 핀 것이 저 모양이다.

전원 모듈의 나사를 모두 풀어주고 제거한다.

전원 모듈을 제거한 상태에서 스피커 박스를 분리해야 하는데...

스피커 박스의 단자(빨간 동그라미) 초 강력 접착제로 찰싹 붙어있다. ㅠ_ㅠ

힘으로 빼다가는 단자의 회로를 끊어먹을 수 있으니 열풍기로 충분히 가열하여 접착 성분을 녹인 뒤에

핀셋으로 조심스럽게 스피커박스와 단자를 뽑는다.

진짜 겁나 힘들었다.

그리고 스피커 박스 단자의 접착 성분이 다시 굳기 전에, 새로운 디스플레이 모듈의 같은 위치에 옮긴다.

스피커 박스와 마찬가지로 우측에 있는 진동 모터도 새 디스플레이 모듈로 옮긴다.

고무로 되어있는 빨간색 부속도 바로 옮겨준다.

마지막으로 전원 모듈 기판을 얹고 안테나 케이블 한쪽을 다시 연결한다.(흰색, 아래쪽에 보이는 케이블)

이때, 잠깐 편의를 위하여 나사 하나를 임시로 조여준다.

조립 도중에 전원 모듈이 계속 떨어지는 것을 방지하기 위함이다.

메인 보드의 전면 카메라, 3.5파이 이어마이크 단자의 금속 덮개를 제거한다.

(1) 이 3.5파이 단자이며, (2) 가 전면 카메라 모듈이다.

회로가 끊어지지 않도록 신경써서 커넥터를 제거한다.

분리된 3.5 파이 단자와 전면 카메라.

이 녀석들도 접착제(양면테잎) 이 발라져 있는데 매우 엉성하게 발라져 있어서 툭 건드니 바로 빠져버렸다.

모든 커넥터를 제거하고 메인 보드를 분리한다.

분홍색 부분은 방열을 위한 써멀 페이스트이며, 어차피 한 번 떼진 것은 다시 붙여도 효과가 떨어지기 때문에,

키친타올로 잘 닦아 내었다.

분리된 메인보드의 자태.

커넥터의 금속 덮개 (1) 와 전원, 볼륨 버튼 모듈을 기존의 디스플레이 모듈에서 새 디스플레이 모듈로 옮겼다.

버튼 모듈의 회로가 단선 되어있는 것을 발견하였다. ㅠ_ㅠ

위 과정에서 니퍼로 프레임을 무리하게 피는 과정에서 충격이 가해진 것으로 판단된다.

결국 이 부품만 따로 주문하였고 10일 뒤에 다시 받아볼 수 있었다.

새로 받은 버튼 모듈

새 버튼 모듈을 새로운 디스플레이 모듈에 붙이고,

기존의 써멀 페이스트를 깨끗이 닦아내었다.

기존의 써멀 페이스트가 있던 부분에 성능 좋은(하지만, 집에 굴러다니던..) 써멀 그리스를 도포하였다.

조립은 분해의 역순...

일단 각 커넥터의 금속 덮개를 닫기 전에 전원을 넣고 잘 동작하는지 테스트 하였다.

이상 무.

액정 -> 상,하단 스피커 -> 전면 카메라 -> 3.5 파이 이어마이크 단자 -> 진동 모터 순으로 테스트 하고

모든 모듈이 정상 동작하는 것을 확인하였다.

음...

평소에 넥서스 6p 를 사용하면서 느낀 것인데, 앞면과 저 부분에 많은 열이 발생한다.

열이 밖으로 잘 빠져나갈 수 있도록 써멀 그리스를 임의로 도포하였다.

이제 프레임을 닫아주고, 덮게를 부착한다.

오공본드를 사용하여 하단 덮게를 닫았다.

액정 테스트. 아무 이상 없는 것을 확인하였다.

자투리 부품.

- 끝 -

엔진 오일 교체와 과다 주입 해결 삽질기.

snoworca — Sun, 9 Oct 2016 02:56:06 +0900

지금으로부터 3개월 전에 들여온 나의 애마 올뉴 말리부 1.5T의 주행 거리가 벌써 5000Km 가까이 되었다.

나의 애마는 다른 사람 손에 맡기는 것보다 사랑 넘치는 손길로 직접 관리해주는 것이 좋을 것 같아서 직접 엔진 오일을 교체하기로 한다.

우선 엔진 오일 교체 방법에 대하여 동영상 강좌도 보고 글도 빡쎄게 읽은 다음에 부공 모터스 셀프 정비소에 직접 방문하였다.

이곳에서 리프트를 사용할 수 있으며 이용 비용은 한 시간에 1만 원으로 나쁘지 않다.

내 손으로 엔진 오일을 직접 교환하는 첫 경험이라 긴장감이 올라왔지만 표정만은 마치 이미 전문가인 것처럼 여유로운 미소를 보이며 띄우며 미심쩍은 눈길을 보내는 직원들이 내미는 서류에 싸인하였다. 그 다음 본격적인 작업을 시작할 수 있었다.

먼저 엔진 아랫쪽의 드레인 볼트를 찾아서 풀어준다. 자가 정비하기 전에 여러 경험담을 들어보니 지인 중에 어떤 분은 저 볼트가 되게 안 풀려서 하이킥을 공구 손잡이에 꽂으셨다는 분이 있었다. 하지만 나의 뉴 말리부는 생각보다 쉽게 풀렸다.

어느 정도 풀다보면 진한 다크 초콜릿 색을 띠고 있는 오일이 틈새 사이로 벌컥벌컥 쏟아지는데, 마치 아래 짤방과 같다.

엔진오일이 오렌주 쥬스처럼 나온다.

이 작업 중에 폐 엔진 오일에 손에 다 묻을 수도 있으므로 반드시 비닐장갑을 먼저 착용하는 것이 좋다.

엔진 오일이 구멍을 통하여 다 빠졌다면 이제 오일 필터를 교환할 차례이다.

이 녀석을 돌려서 뺄 때도 엔진 오일이 벌컥~ 쏟아지므로 주의하는 것이 좋다.

이제 드레인 볼트를 적당히 조인 다음 엔진오일 주입구를 열고 오일을 부어주면 된다.

엔진 오일은 쉐보레 정품을 사용하였는데, 품질은 그럭저럭 괜찮은 편이라고 한다.

하지만...

쉐보레 커뮤니티에서 어떤 작자가 뉴 말리부의 엔진 오일이 4.7리터 들어간다는 게시물을 올렸고,

그 것을 그대로 믿고 귀찮으니 더 조사도 안 한채 4.7리터 이상을 넣어버렸다.

엔진 오일을 다 교체하고 출발하는 순간 뒤에서 누가 차를 잡아채는 느낌이 들었다. 기존에는 엑셀을 밟으면 우앙~~ 하는 소리와 함께 괜찮은 가속력을 보여줬지만 엔진 오일을 과다 주입하고 나서는 우웅~ 하는 낮게 깔리는 소리와 2천 알피엠 이상 올라가는 것도 힘겨워 하는 듯 했다. 고속 주행시 많이 조용해진 것 같아서 훨씬 좋았지만 이러다 영원히 조용해 지는 것 아닐까 하는 걱정에 과다 주입된 엔진 오일 빼기를 시도하였다.

처음에는 약국에서 파는 60ml 용량의 주사기와 실리콘 호스를 이용하였지만, 엔진 오일 과다 주입 실수에 대하여 크게 반성하고 후회하게 만드는 힘과 시간이 필요하였다. 저 얇은 실리콘 호스를 넣고 주사기를 잡아 당기면 물처럼 쭉~~ 빨려 올라올 줄 알았건만, 엔진 오일의 점도 때문에 피스톤과 씨름을 해야 될 정도였다. 결국 주사기와 실리콘 호스는 아깝지만 버렸다.

두 번째로 샴푸 뚜껑을 이용하는 방법을 사용하였다.

총비용은 5,500원으로 동네 다이소 같은 곳에서 재료를 구입하였다. 저 실리콘 튜브는 어항에 사용되는 호스다.

호스를 펌프의 파이프 안쪽으로 넣으면 사용하는 도중에 압력이 새버릴 수도 있으므로 호스를 벌려서 펌프 파이프에 넣은 다음 순간 접착제를 붙이고 테이프로 칭칭 감았다.

그리고 엔진오일 게이지를 뽑고 그 자리에 호스를 쭉쭉~ 넣으면 된다. 이 과정이 좀 어려운 점이 있는데, 호스 끝을 엔진오일에 닿도록 해야 한다. 너무 많이 넣어도 안 된다. 만약 호스의 끝이 엔진 오일에 닿지 않는다면 펌프질을 할 때 공기만 빨아들이게 된다 .아마도 그 이유는 아래 그림과 같지 않을까 생각된다.

물론 100% 나의 상상이다. 갈색 부분이 엔진오일이다.

어쨌든 한 번에 안 되어서 여러 번 삽질해야만 했다.

결국, 아래 동영상처럼 샴푸 뚜껑 펌프를 이용하여 엔진 오일을 쭉쭉~ 뽑을 수 있게 되었다.

엔진 오일을 뽑기 전에는 엔진 오일 게이지에 대략 분홍색 화살표가 있는 부분까지 엔진 오일이 찼었는데,

뽑고 나서 빨간색 화살표 위치 쯤으로 줄어들었다.

이 것을 보면 얼마나 많은 엔진 오일이 과다 주입되어있는지 감을 잡을 수 있다.

1리터를 넘게 뽑았다. 이 오일은 다음 엔진오일 교체할 때 정비소에 버릴 것이다.

정비소에서는 폐 오일을 모아서 수거 업자에게 판매하며, 최종적으로 폐유를 재가공 하여 벙커C유로 탄생시킨다고 한다.

JAVA 에서 javascript (ECMA script) 실행하기.

snoworca — Mon, 23 May 2016 11:20:18 +0900

JAVA6 부터 자바 스크립트 엔진을 기본적으로 지원한다.

(ps, 안드로이드에서는 자바 스크립트 엔진이 직접 포함되지 않는다. 그렇기 때문에 RhinoScriptEngine 프로젝트를 직접 적용해야 한다. https://github.com/mozilla/rhino)

JAVA8 미만은 RhinoScriptEngine 을 사용하며, 8 버전에서는 NashornScriptEngine 을 사용한다.

하지만 사용방법은 동일하다.

물론 각 브라우저에서 사용할 수 있는 자바 스크립트 API 는 제공되지 않는다.

아래 예제는 콘솔을 통하여 두 수를 입력 받아 각각 함수와 객체를 이용하여 덧셈을 하고 그 결과 값을 출력해 주는 코드다.

test.js :

function calc() {

	try {
   	    console.print("첫 번째 값 : ");
  	    var param1 = console.readInt();
  	    console.print("두 번째 값 : ");
 	    var param2 = console.readInt();
	} catch(e) {
            console.println("32 바이트 정수를 입력해 주세요.");
	    e.printStackTrace();
	    return;
	}

	var result = sum(param1, param2);

	var calc = Calculator.newInstance();


	console.print("결과 (function 이용) : ");
	console.println(param1 + " + " +  param2 + " = " + sum(param1, param2));
	console.print("결과 (object 이용) : ");
	console.println(param1 + " + " +  param2 + " = " + calc.sum(param1, param2));



	function sum(val1, val2) {
	   return val1 + val2;
	}

}


calc();

위 자바 스크립트 코드를 보면 생소한 API 들이 보일 것이다.

아래 자바 코드 예제에서 보면 객체를 자바 스크립트의 객체 이름을 자바의 객체와 맵핑을 시켜놓았다는 것을 알 수 있을 것이다. 자바 객체의 내부 메소드도 함께 맵핑된다.

즉, 자바 스크립트 API 를 입맛대로 만들어서 적재적소에 사용할 수 있다.

물론 떨어지는 성능은 감안해야 한다.

Preview:

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.Scanner;

import javax.script.Bindings;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
import javax.script.SimpleBindings;

public class ScriptTest {

	public static void main(String[] args) throws ScriptException, FileNotFoundException {

		File js = new File("./test.js");
		FileReader JsfileReader = new FileReader(js);
		
		ScriptEngineManager manager = new ScriptEngineManager();
		ScriptEngine engine = manager.getEngineByName("js");
		
		
		Bindings bindings = new SimpleBindings();
		bindings.put("console", new Console());
		bindings.put("Calculator", new Calculator());
		
		engine.eval(JsfileReader, bindings);

	}
	
	public static class Calculator {
		public int sum(int val1, int val2) {
			return val1 + val2;
		}
		
		public Calculator newInstance() {
			return new Calculator();
		}
	}
	
	public static class Console {
		public int readInt() {
			Scanner scanner = new Scanner(System.in);
			String line =  scanner.nextLine();
			return Integer.parseInt(line);
		}
		
		public void print(String line) {
			System.out.print(line);
		}
		
		public void println(String line) {
			System.out.println(line);
		}
	}
	

}

결과는 아래와 같다.

첫 번째 값 : 123

두 번째 값 : 456

결과 (function 이용) : 123 + 456 = 579

결과 (object 이용) : 123 + 456 = 579

스트링 엔코딩 변환 - euc-kr <---> utf-8

snoworca — Mon, 7 Mar 2016 02:05:51 +0900

세 줄 요약.

1. JAVA 의 String 클래스는 유니코드로 처리되는 char 의 배열 이외에 어떠한 인코딩 정보를 갖고 있지 않는다.

2. String.getByte('인코딩명') 을 사용하여 인코딩 할 수 있으며, new String(byte[], "인코딩명") 을 사용하여 디코딩 할 수 있다/.

3. EUC-KR 에서 UTF-8 으로 바꾸기 위해서는 EUC-KR ---> java.lang.String ----> UTF-8 과 같은 방식으로 변환 할 수 있다.

~~기본적으로 자바의 String 클래스는~~ ~~2 byte 크기의 유니코드를 사용하여 문자열을 처리하는 Character 배열을 감싸고 있는 형태이다.~~

https://docs.oracle.com/javase/8/docs/api/java/lang/Character.html 참고.

JDK 1.8 의 String 클래스의 코드를 보면 아래와 같이...

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];
    /** Cache the hash code for the string */
    private int hash; // Default to 0
    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = -6849794470754667710L;

    /**
     * Class String is special cased within the Serialization Stream Protocol.
     *
     * A String instance is written into an ObjectOutputStream according to
     * <a href="{@docRoot}/../platform/serialization/spec/output.html">
     * Object Serialization Specification, Section 6.2, "Stream Elements"</a>
     */
    private static final ObjectStreamField[] serialPersistentFields =
        new ObjectStreamField[0];

달랑 네 개의 필드를 확인할 수 있는데, 여기에 문자열 관련된 값이 저장되는 것은 value[] 가 유일하다.

String 클래스의 getBytes() 메소드를 사용하여 String 을 다른 인코딩으로 변환할 수 있으며, 이 것은 즉 2byte 의 유니코드가 다른 인코딩으로 변환되어 반환되는 것이다.

getBytes() 사용시 아무런 인자값을 넣지 않고 호출한다면, 그리고 JVM 실행 옵션으로 인코딩을 정의하지 않았다면 ( 예 : -Dsun.jnu.encoding=UTF-8 -Dfile.encoding=UTF-8) 시스템 기본 인코딩으로 변환되어 나올 것이다. 만약 윈도우에서 아무런 옵션 없이 JVM 을 실행하여 String 에 대하여 getBytes() 를 호출한다면 MS949 로 인코딩된 byte 배열이 튀어나올 것이다. (윈도우에서 돌아가는 JVM은 기본적으로 MS949 를 사용하기 때문이다.) 이렇게 아무런 인자값 없이 getBytes() 를 호출한다면 내부적으로 JVM 기본 인코딩을 정보를 가져오는 getProperty("file.encoding") 을 호출하여 얻은 결과 값으로 시스템 인코딩 값으로 인코딩 한다. 그렇기 때문에 String 으로부터 자신이 원하는 인코딩 바이트 배열을 얻기 위해서는 아래 예제처럼 인자값으로 인코딩명을 넣어줘야 한다.

Unicode String --> euc-kr :

// String 을 euc-kr 인코딩으로 변환하여 반환.
String helloString = "안녕하세요?";
byte[] euckrStrBuffer = helloString.getBytes("euc-kr");

위 구현은 내부적으로 String 을 인코드 혹은 디코드 해주는 StringCoding 클래스의 encode 라는 이름의 static 메소드를 이용한다.

하지만, StringCoding 클래스는 protected 클래스기 때문에 직접적으로 사용할 수 없다.

하지만 String.getBytes("euc-kr") 메소드를 쓰는 방법 이외에도 같이 nio 의 Charset 을 이용하여 String 을 euc-kr 로 변환할 수 있다.

Unicode String --> euc-kr (nio.charset 사용) :

Charset euckrCharset = Charset.forName("euc-kr");
ByteBuffer byteBuffer = euckrCharset.encode(helloString);
byte[] euckrStringBuffer = new byte[byteBuffer.remaining()];
byteBuffer.get(euckrStringBuffer);

다음으로 인코딩된 문자열의 바이트 배열을 다시 String 으로 만드는 방법이다.

euc-kr --> Unicode String :

String helloString = "안녕하세요"; 
byte[] euckrStringBuffer  = helloString.getBytes(Charset.forName("euc-kr"));
// euc-kr 로 변환된 byte 문자열을 다시 유니코드 String 으로 변환.
// String 생성자의 
// 첫 번째 인자로 문자열 byte 배열을  넣어주고, 
// 두 번째 인자로 byte 배열의 인코딩 값을 넣어준다.
String decodedHelloString = new String(euckrStringBuffer, "euc-kr");

이 것 또한 마찬가지로 nio 의 Charset 를 이용하여 디코드 할 수 있다.

euc-kr --> Unicode String (nio.charset 사용) :

Charset euckrCharset = Charset.forName("euc-kr");
CharBuffer charBuffer = euckrCharset.decode(ByteBuffer.wrap(euckrStringBuffer));
String decodedHelloString = charBuffer.toString();

System.out.Println 를 찍어보면 값이 정상적으로 변환된 것을 확인할 수 있다.

그렇다면, euc-kr 을 utf-8 로 변환시키거나 또는 반대로 변환시키고 싶을 때는 어떻게 해야 하는가?

답은 도중에 String 으로 변환하는 과정을 한 번 거치면 된다.

EUC-KR ---> UTF-8 :

String helloString = "안녕하세요. ㄱㄴㄷㄹㅁㅂㅆㅢ 놟쐛씗쀍";
System.out.println("Source : " + helloString);

// String 을 euc-kr 로 인코딩.
byte[] euckrStringBuffer = helloString.getBytes(Charset.forName("euc-kr"));
System.out.println();

System.out.println("euc-kr - length : " + euckrStringBuffer.length);
String decodedFromEucKr = new String(euckrStringBuffer, "euc-kr");
System.out.println("String from euc-kr : " + decodedFromEucKr);

// String 을 utf-8 로 인코딩.
byte[] utf8StringBuffer = decodedFromEucKr.getBytes("utf-8");

System.out.println();
System.out.println("utf-8 - length : " + utf8StringBuffer.length);
String decodedFromUtf8 = new String(utf8StringBuffer, "utf-8");
System.out.println("String from utf-8 : " + decodedFromUtf8);

즉 위 코드는

euc-kr ---> JAVA String 객체(유니코드) ---> utf-8

과 같은 과정으로 인코딩 변환이 되는 것이다.

하지만, 아래 결과를 살펴보면...

결과:

Source : 안녕하세요. ㄱㄴㄷㄹㅁㅂㅆㅢ 놟쐛씗쀍

euc-kr - length : 33
String from euc-kr : 안녕하세요. ㄱㄴㄷㄹㅁㅂㅆㅢ ????

utf-8 - length : 46
String from utf-8 : 안녕하세요. ㄱㄴㄷㄹㅁㅂㅆㅢ ????

깨지는 글자가 발생하게 된다.

이유는 완성형인 euc-kr 이 '놟쐛씗쀍' 과 같은 문자를 지원하지 못하기 때문에 문자열 '안녕하세요. ㄱㄴㄷㄹㅁㅂㅆㅢ 놟쐛씗쀍' 를 인코딩 할 경우 지원하지 못 하는 문자에 대한 손실이 일어나게 되는 것이다.

Nexus5 액정 저렴하게 자가 수리하기.

snoworca — Sun, 20 Dec 2015 23:48:52 +0900

넥서스5 액정을 교체해 보겠다.

우선 부품을 구해야 하는데, 해외 직구로 구매하였다.

알리 익스프레스에서 구매하였는데, 주의할 점은 반드시 터치와 LCD 가 함께 붙어있는 모듈을 사야한다.

접착제로 터치와 LCD 가 붙어있기 때문에 따로 분리하기가 매우 어렵다.

가격은 32달러부터 40달러까지 하는 것 같은데, 나는 33.99 달러에 구입하였다.

넥서스5 의 깨진 액정.

알리 익스프레스에서 구매한지 보름만에 도착하였다.

꼼꼼한 포장상태.

테이프를 뜯고 뚜껑을 열자 분해 조립에 필요한 간단한 도구 몇 개가 들어있다.

모든 구성물을 꺼낸 상태. 가장 왼쪽에 보이는 녀석은 하드 글라스 형태의 액정 보호필름. 나름 저렴한 가격에 풍부한 구성을 갖추고 있다.

왼쪽은 액정 깨진 넥서스5. 오른쪽은 교체될 터치 액정 패널.

액정 수리 킷에 포함되어있는 도구 외에 핀셋과 다이소표 미니 일자 드라이버를 함께 준비하였다.

우선 주걱을 이용하여 틈을 벌려나가는 방식으로 뒷 뚜껑을 분리한다.

이제 곳곳에 보이는 나사들을 풀어줘야 한다.

나사를 모두 푼 상태에서 상단 보드와 하단 보드를 덮고있는 덮게를 제거한다.

빨간색 점선 동그라미 부분의 커넥터를 조심스럽게 제거하고 상단 메인보드를 분리한다.

커넥터를 제거할 때 주의할 점은 절대 케이블을 붙잡고 뽑으면 안 된다.
케이블이 단선이 될 수 있으므로 커넥터를 잡고 조심스레 뽑아야 한다.

두 번째로 주의할 점은 유심을 먼저 뽑아야 한다.

나는 실수로 유심을 뽑지 않고 메인보드 제거를 시도해서 꽤 고생을 했다.

완전히 분리된 메인보드. 실수로 제거하지 않은 유심이 그대로 남아있다.

이제, 하단 보드를 분해할 차례. 먼제 터치 패널과 연결되어있는 커넥터를 제거해준다.

하단 보드를 조심스럽게 제거하였다. 우측 부분이 양면 테잎으로 붙어있기 때문에 조심스럽게 분리하였다.

후면 카메라 모듈을 분리해준다. 역시 양면 테잎으로 부착되어 있다.

이어폰 단자 모듈과 전면 카메라 모듈을 분리하였다.

수화기용 이어 스피커와 그 것을 받치고 있던 플라스틱 조각을 분리한다.

플라스틱 조각과 이어 스피커 모듈을 결합해 준다.

(금속 단자가 눌리지 않게 주의한다. 만약 금속 단자가 눌렸다면 살짝 펴준다.)

모든 모듈을 분리한 상태. 이제 조립은 분해의 역순으로...

아래쪽에 보이는 것은 기존의 깨진 패널, 위쪽이 새로 구입한 패널이다.

새로 구입한 패널에는 전원 버튼과 볼륨 버튼이 포함되어 있지 않기 때문에 스위치를 분리해야 한다.

기존 패널에서 분리한 전원 스위치와 불륨 조절용 스위치 조각.

조립의 첫 번째 과정으로 미리 발라져 있는 양면 테잎의 보호 필름을 제거한다. 흰색 또는 파란색 반투명 필름으로 되어있다.

모든 양면 테잎 보호용 필름을 제거하고, 후면 카메라, 이어 스피커, 이어폰 단자, 전면 카메라를 방향에 맞게 잘 부착해준다.

(위 사진에서 보이는 이어 스피커 모듈은 실수로 플라스틱 조각을 빼고 부착한 상태다.;;; )

하단도 마찬가지로 양면테이프 보호용 필름을 제거하고 터치 패널용 커넥터를 부착한다.

하단 보드를 위치에 맞게 잘 올려놓고 커넥터를 연결한다.

이제 배터리를 부착한다.

메인보드를 올려놓기 전에 전원 스위치와 볼륨 스위치를 새 터치 패널에 끼운다.

전원 스위치는 위 빨간 동그라미처럼 스위치에 달려있는 고리에 맞춰서 잘 끼워야 한다.

상단 메인보드를 올려놓고 분리되었던 커넥터를 모두 연결해준다.

상단 플라스틱 덮게를 덮고 나사를 조여준다.

하단 덮게를 덮고 나사를 조여준 다음 뒷 뚜껑을 닫고 손가락으로 꾹꾹 눌러준다.

이제 전원을 켜고 액정, 진동, 이어 스피커, 스피커, 이어폰 단자, 후면 카메라, 전면 카메라가 잘 동작하는지 확인한다.

물론 잘 동작할 것이다.

이제 마지막으로 사은품(?) 으로 들어있는 액정 보호지를 부착해준다. 하드 글라스 형태라서 붙이는 것이 쉽지 않다. 본인은 이 것을 붙이는 것이 가장 어려웠다;;;

[JAVA] 간단한 일회성 JSON 데이터를 만들기 귀찮을 때...

snoworca — Thu, 3 Dec 2015 09:56:38 +0900

API 서버를 개발하다보면 아래와 같이 간단한 JSON 타입을 Response 값으로 반환해야 하는 경우가 종종 생긴다.

{ 
         "success" : true,
         "id" : 1024,

         "items" : [0,7,9,12],
         "status": {
                  "method"  :  "get",
                  "code"   :     202
         }
}

만약 위 값이 일회성이라고 가정할 때, GSON 같은 도구를 사용하기 위하여 객체로 만들거나 스트링을 사용해서 이어 붙이기에는 구현하기가 복잡하거나 귀찮아 지는 경우가 종종 발생한다.

그래서 이런 귀찮은 작업들을 간단하게 줄여주는 코드를 만들었고, 공유한다.

JsonMaker.java 파일을 만들고 아래 주소에 있는 코드를 붙여넣기 하여 사용할 수 있다.

https://gist.github.com/ice3x2/0e73d96c5c6724116f5f

이 것을 활용한다면, 위 JSON 타입을 간단하게 만들 수 있다.

String jsonValue = JsonMaker.put("success", true).put("id", 1024)
			  .openArray("items").next(0).next(7).next(9).next(12).closeArray()
			  .openObject("status")
			            .put("method", "get")
	   	   		  .put("code", 202)
			  .closeObject().toString();

단, 주의사항은(단점) toString() 을 호출하는 순간 내부적으로 생성된 JSON 데이터 리스트가 모두 초기화 되어버린다.

이렇게 한 이유는 메모리 누수를 방지하기 위해서인데, 더 좋은 방법을 고민해보고 개선된 버전이 생기면 업데이트 하겠다.

짭두이노 USB to serial 드라이버 CH340g, CH341 설치하기.

snoworca — Mon, 23 Nov 2015 00:51:30 +0900

값비싼? FTDI 가 달려있는 아두이노나 짭두이노에 대한 설치 자료를 인터넷 검색을 통하여 쉽게 찾아볼 수 있지만, 최근 온라인 쇼핑몰에 심심치 않게 등장하는 초 저가형 짭두이노는 CH340 라는 USB 시리얼 변환 드라이브를 사용한다.

(요즘 알리 익스프레스에 접속하면 자동으로 한글로 번역되어 나오는데, 차라리 영어가 낫다...)

특히 아두이노 나노와 호환되는 초 저렴한 짭두이노를 많이 찾아볼 수 있는데,

이 블로그 포스팅을 작성하고 있는 15.11.23 기준으로 가장 싼 녀석이 1.75 달러다.

현재 환율로 따져보면 초코파이 한박스보다 싼 가격으로 아두이노를 구입할 수 있다.

이렇게 다른 짭두이노보다 가격이 저렴한 이유는 FTDI 와 같은 비싼 드라이버 대신 CH340 (ch340g, ch341) 이라는 듣보잡 시리얼 변환 드라이버를 쓰고 있어서라고 판단된다. (물론 시리얼 변환 드라이버가 없는 mini 호환 버전이 가장 저렴하다. 최저가 1.4 달러.)

하지만, 불량률이 높기 때문에 한 번에 여러개를 사는 것을 추천한다.

그리고 제품 수령 후에는 반드시 전압과 동작 테스트를 해봐야 한다.

아직까지는 쓰다가 고장나는 경우는 없었지만, 처음부터 인식이 잘 안된다거나 전압이 불안정한 경우가 있다.

주변으로부터 짭두이노의 인식 불량과 쇼트 문제로 센서를 태워먹은 사례~~(너죽고 나살자)~~에 대한 이야기를 들었다.

실제로 한 번에 5개를 샀는데, 그 중에 5v output 단자에서 3.5~4v 사이를 왔다갔다 하는 전압을 출력하고 3.3v 단자에서 4v 정도를 출력하는 폭탄같은 녀석이 있었다. 미련없이 바로 쓰레기통에 넣어버렸다. ㅡ , ㅡ;;

어쨌든 윈도우에서 짭두이노를 이용하기 위해서 아래의 드라이버를 다운로드 받는다.

CH341SER.zip

또는 다른 OS 의 드라이버는 아래 주소의 공식 지원 사이트에서 다운로드 받을 수 있다.

http://www.wch.cn/download/CH341SER_ZIP.html

MAC 버전은 다운로드 받아서 설치하고 터미널에서 sudo nvram boot-args="kext-dev-mode=1" 를 입력하면 인식이 된다.

하지만 엘 카피텐 이상부터는 잘 인식이 안 되는 것 같다.

리눅스 같은 경우는 소스코드를 직접 빌드하여 사용해야 하는데 우분투에서 사용하려다 포기했다. ㅡ , ㅡa

역시 가장 잘 되는 것은 윈도우다.

설치 및 적용 방법은 아래와 같다.

첫 번째로 드라이버를 다운로드 받아서 압축을 푼다.

만약 자신이 쓰고있는 윈도우가 64비트 버전이라면 DRVSETUP64 폴더에 있는 DRVSETUP64.EXE 파일을 밖으로 복사하고 실행한다.

만약 32비트라면 그냥 SETUP.exe 파일을 실행한다.

자신의 윈도우가 몇 비트인지 모를때는 그냥 64비트처럼 둘 다 복사하고, DRVSETUP64.EXE 부터 실행시켜 본다. 만약 32비트라면 DRVSETUP64.EXE 는 실행되지 않을 것이다.

인스톨 버튼을 누른다.

파일이 드라이버 폴더에 복사되는 것으로 보인다.

이제 짭두이노를 PC 에 연결한다.

그리고 바탕화면의 내 컴퓨터에서 오른쪽 버튼을 누르고 '속성' 으로 들어가서 '장치 관리자' 에 들어간다.

그럼 아래와 같이 PC 에 연결된 드라이버 리스트가 뜨는데, 포트 (COM & LPT) 트리 내부에 USB-SERIAL CH340(COM 포트번호) 가 존재하는지 확인하자. 만약 아래 이미지와 같이 보이지 않는다면...

1. 컴퓨터를 재시작하거나,

2. Mini USB 케이블이 불량인지 확인하거나 (의외로 잘 고장난다.)

3. 다른 짭두이노를 연결해본다.

위와 같은 순서대로 확인해 본다.

위 그림에서 짭두이노와 연결될 포트 번호를 확인한 뒤에 아두이노 IDE 의 상단 메뉴의 '툴(도구)->포트' 에서 방금 확인한 포트 번호로 설정해 보자. Arduino Nano 호환 보드를 사용했으니 보드 항목도 이와 같도록 맞춰준다.

정품 아두이노와 다르게 시리얼 변환 드라이버의 거북이 같은 속도 덕분에 업로드 도중에 간혹 잘 되고 있는지 궁금할 때가 있는데, 그럴 경우는 '환경설정' 에서 '다음 동작중 자세한 출력 보이기:' 항목의 '업로드' 체크 박스를 선택해 주면 되겠다.

JAVA 텍스트 파일의 Encoding 정보 가져오기 + String Encoding 변환하기.

snoworca — Wed, 18 Nov 2015 15:06:15 +0900

이클립스로 작성된 다양한 프로젝트들을 의존하는 프로젝트를 생성하는 경우 인코딩 문제로 당황스러울 때가 종종 있다.

만약 여러개의 프로젝트내의 소스 파일들이 각각 다른 인코딩으로 저장되었을 경우 이 것을 한 번에 utf-8 로 바꾸는 방법에 대하여 알아볼 것이다.

1. 텍스트 파일 (혹은 java 파일) 의 인코딩 정보 가져오기

Text 파일 혹은 Java 소스 파일의 인코딩을 확인하는 방법은 여러가지가 있지만 가장 정확하면서 간단한 방법은 바로 juniversalchardet (https://code.google.com/p/juniversalchardet/) 라이브러리를 사용하는 것이다. (무식한? 방법으로는 파일을 읽어서 테스트 하려는 인코딩의 스트링으로 변환하고 character 배열을 받아 0xfffd 문자를 찾는 방법이 있다.)

우선 라이브러리를 다운 받아서 프로젝트에 포함시킨다.

Maven Repository 주소는 아래와 같다. (or 이 곳에서 라이브러리를 다운로드 받을 수 있다.)

http://www.mvnrepository.com/artifact/com.googlecode.juniversalchardet/juniversalchardet/1.0.3

아래 코드는 juniversalchardet 프로젝트 페이지 메인에 나온 샘플 코드를 그대로 옮겨온 것이다.

이렇게 간단한 방법으로 텍스트 파일의 인코딩 정보를 바로 가져올 수 있다.

샘플 코드:

import org.mozilla.universalchardet.UniversalDetector;

public class TestDetector {
  public static void main(String[] args) throws java.io.IOException {
    byte[] buf = new byte[4096];
    String fileName = args[0];
    java.io.FileInputStream fis = new java.io.FileInputStream(fileName);

    UniversalDetector detector = new UniversalDetector(null);

    int nread;
    while ((nread = fis.read(buf)) > 0 && !detector.isDone()) {
      detector.handleData(buf, 0, nread);
    }
    detector.dataEnd();

    String encoding = detector.getDetectedCharset();
    if (encoding != null) {
      System.out.println("Detected encoding = " + encoding);
    } else {
      System.out.println("No encoding detected.");
    }

    detector.reset();
  }
}

2. String 의 인코딩 바꾸기

아래 코드는 "헬로월드!" 라는 문자열을 EUC-KR 로 인코딩하여 출력한다음 다시 UTF-8 로 디코딩하여 출력하는 예제이다.

java.nio 의 Charset 을 통하여 문자열을 인코딩 및 디코딩할 수 있다.

// UTF-8.
String str = new String("헬로월드!");

Charset eucKRCharset = Charset.forName("EUC-KR");
CharBuffer sourceBuffer = CharBuffer.wrap(str.toCharArray());
ByteBuffer resultByteBuffer = eucKRCharset.encode(sourceBuffer);
byte[] resultBytes =  resultByteBuffer.array();
// EUC-KR 의 String 을 생성할 때, 두번째 인자값으로 인코딩 정보를 넣어준다.
System.out.println(new String(resultBytes, eucKRCharset));
// 만약 인코딩 정보를 넣지 않는다면 에러 스트링이(�, 0xfffd) 이 출력될 것이다. 
System.out.println(new String(resultBytes));

// 원래의 UTF-8 로 디코딩.
CharBuffer charBuffer = eucKRCharset.decode(ByteBuffer.wrap(resultBytes));
System.out.println(charBuffer.toString());

3. 응용 - workspace 내의 모든 자바 소스 파일을 UTF-8 로 바꾸기

public static void main(String[] args) throws IOException {
	// 프로젝트 폴더 경로
	decodingProjectSources(new File("/home/name/worksapce"));
}

public static  void decodingProjectSources(File file) throws IOException {
	// 자바 파일만 UTF-8로 디코딩
	if(file.isFile() && file.getName().matches("^.*\\.((?i)JAVA)$")) {
		String encoding =  readEncoding(file);
		if(encoding != null && !encoding.equals("UTF-8")) {
			decodingFile(file, encoding);
		}
	} else if(file.isDirectory()) {
		File[] list = file.listFiles();
		for(File childFile : list) {
			decodingProjectSources(childFile);
		}
	}
}

public static void decodingFile(File file, String encoding) throws IOException {
	Charset charset = Charset.forName(encoding);
	FileInputStream fis = new FileInputStream(file);
	ByteOutputStream fbs = new ByteOutputStream();
	
	byte[] buffer = new byte[4096];
	int n = 0;
	while((n = fis.read(buffer, 0, buffer.length)) > 0) {
		fbs.write(buffer, 0, n);
	}
	CharBuffer charBuffer = charset.decode(ByteBuffer.wrap(fbs.getBytes()));
	BufferedWriter bw = new BufferedWriter(new FileWriter(file));
	bw.append(charBuffer);
	bw.close();
}

public static String readEncoding(File file) throws IOException {
	byte[] buf = new byte[4096];
	java.io.FileInputStream fis = new java.io.FileInputStream(file);
	UniversalDetector detector = new UniversalDetector(null);
	int nread;
	while ((nread = fis.read(buf)) > 0 && !detector.isDone()) {
		detector.handleData(buf, 0, nread);
	}
	detector.dataEnd();
	String encoding = detector.getDetectedCharset();
	detector.reset();
	buf = null;
	fis.close();
	return encoding == null?"UTF-8":encoding;
}

무선 인터넷으로 제어하는 가습기 개발기

snoworca — Thu, 24 Sep 2015 13:55:57 +0900

프로젝트 코드 및 회로도는 아래 주소에서 확인하세요.

https://github.com/ice3x2/Wifi_Humidifier

아두이노를 취미로 시작한지 1년이 지났다. 그 이후로 수집벽이 생겼는데, 센서나 부품을 쓰지도 않으면서 알리 익스프레스를 통하여 모으는 일이다

덕분에 책상 위에 온갖 센서들이 굴러다닌다. 초창기에 구입한 ESP8266 ESP-1 도 그 중에 하나인데, 사놓고 사용하지를 않아 아까워서 이번 프로젝트에 사용하게 되었다. 단, ESP8266은 80Mhz 와 메모리 32kbyte 의 뛰어난 성능을 갖고 있는데, 그 자체로 IOT 플랫폼으로 사용할 수 있다. 하지만 ESP-1은 최신 버전인 ESP-12 와 다르게 사용할 수 있는 GPIO 포트가 얼마 되지 않고 아날로그 입력을 받도록 처리하는 것도 귀찮아서 그냥 알리익스프레스에서 1달러에 구입한 Mini 또는 nano 와 호환되는 짭두이노를 연결 하였는데, 생각해보니 벤츠 SLS 에 마티즈 엔진을 얹고 달리게 하는 것과 비슷하다. ㅡ , ㅡa

1. 삽질의 시작.

요새 날씨가 건조하니 비염이 심해지기 시작했다. 그래서 아래와 같이 가습기를 구입하였다. 위x프 에서 구입한 보만 미니 가습기인데, 번들로 페트병 하나가 들어있는 것이 인상적이다.

(이 글을 작성한 시점에서는) 백수에 시간부자라 소일거리로 가습기 리뷰를 블로그에 올릴 생각으로 사진을 찍어봤다. 그리고 저 작고 앙증맞은 것이 어떻게 동작 하는지에 대한 궁금증이 생겼다. 그래서 한 번 분해해 봤다.

(밑 뚜껑을 따버린 모습.)

내부는 간단해 보인다. 아무래도 전원부를 24v 정전압 아답터로 사용하기 때문인 것 같다. 배선은 예상외로 깔끔한 모습을 보여준다. 중국 공장에서 생산 되었어도 독일 회사 브랜드를 달고 출시되어서 그런지 깔끔해 보인다. 좀 더 자세히 뜯어보면, 초음파 진동자를 구동시키기 위한 주파수를 발생 시키는 메인보드가 보이며 여기여 연결된 24v 팬과 토글 스위치를 겸비한 분부량 조절기인 1.5k옴 가변 저항이 있다. 분무량 조절기의 노브를 잡고 돌리는 느낌이 중저가형 음향기기에 달려있는 조절 노브를 돌릴 때의 느낌과 비슷하다. 그리고 물 경고등과 전원등이 연결되어 있는데 Red-Green LED 로 되어있다. 마지막으로 수위 센서가 연결되어 있다. 수위 센서라고 해서 별거 없고 그냥 막대기에 물에 떠다니는 플라스틱을 끼운 형태인데, 물이 없으면 플라스틱이 막대기를 타고 아래쪽으로 내려와 스위치를 건듦으로써 on 이 되는 원리이다.

이 가습기는 쓸만한 디자인에 비하여 가격이 저렴하지만, 철저하게 아날로그다. 덕분에 자면서 가습기를 틀고 아침에 일어나보면 방 안이 눅눅해져 있고 가끔 분무량 조절 노브를 가장 작게 줄여도 항상 최대치로 돌아가는 팬 소리 때문에 잠을 잘 때 거슬린다. 그래서 이 녀석의 구조도 대충 알겠다 한 번 개조해보기로 하는데...

2. 부품 쑤셔 넣기.

* 제목 그대로 쑤셔 넣었다.

우선 아래와 같이 이번 프로젝트에 사용될 부품을 준비하였다.

첫 번째로 아두이노가 필요하다. 사진상의 아두이노는 공개하지 않은 다른 프로젝트에서 사용된 것을 적출한 것으로 케이블이 제거되지 못한 상태다.

두 번째로 WIFI 모듈인 ESP8266 이 필요한데, 사실 위에서 언급한대로 아두이노로 ESP8266 을 제어한다는 것은 오늘 운전면허증 받은 사람이 페라리를 운전하는 것과 비슷해서 굉장히 비효율적이다. ESP8266 이 저렴하기도 하지만 성능까지도 좋고 Lua 나 아두이노 부트로더를 올릴 수 있어 최근 메이커들 사이에서 새로운 IOT 플랫폼으로 주목받고 있다. 하지만 초창기 버전인 ESP-1 은 GPIO 포트가 부족하기도 하고 아날로그 제어도 해야 하므로 그냥 아두이노로 제어하도록 한다.

그리고 중요한 작업이 하나 있는데, 초기 상태의 ESP8266 은 깡통과 같다. 펌웨어가 올라가 있지만 꽤 구형 버전으로 올라가 있다.

그러므로 반드시 펌웨어를 최신 버전으로 올려줘야 한다. 이 프로젝트에서는 AT 커맨드를 사용하기 위한 AT 펌웨어 v0.9.2.2 버전을 사용하였다.

펌웨어 설치 방법은 네이버 카페 아두이노 스토리 에서 쉽게 찾아볼 수 있으며, 하드카피 월드 에서도 살펴볼 수 있다.

그 밖에 ESP8266 만을 위한 해외 포럼도 있다!! (http://www.esp8266.com/)

baud rate 는 9600으로 설정해야 한다. 디버깅을 위하여 RX,TX 핀을 희생하고 SoftwareSerial 을 사용하도록 하였으며 때문에 9600으로 설정한 것이다. 9600이면 초당 1.17 Kbyte 전송률을 갖고 있는데, 1메가 전송하려면 대략 14분하고 5초 걸린다. -_-ㅎㅎㅎ. 문제는 이것은 시리얼 통신의 속도지 WIFI 자체의 속도가 아니라는 것이다. 결국 통신 프로토콜을 잘못 짠다면 버퍼 오버플로우가 생길 것이다. 그 때문에 만약 큰 데이터를 주고받는다면 ESP8266 모듈의 ESP-12 버전을 사용하여 SPI 통신을 사용하도록 하는 것이 현명한 선택일지도 모르겠다.

세 번째로 BLE 모듈인 HM-10 을 사용하기로 하였으나, 귀찮아서 제거하였다. 사실 이 녀석을 이용하여 스마트폰으로 무선 AP 와 서버 등을 설정하려고 하였으나 너무 귀찮았다. 그래서 버튼을 달고 5초 이상 누르고 있으면 WIFI 모듈이 무선 AP 모드로 동작하고 여기에 접속하여 설정할 수 있도록 하였다.

그리고 온습도 센서인 DHT22 를 사용하는데, 이거 비추다. 생각보다 정확하지 않다. ㅠ_ㅠ 조만간 GY-21 로 바꿔서 테스트해볼 생각이다.

AMS 1117 3.3v 는 esp8266 에 3.3v 를 공급하는 데 필요한데, 타입별로 input, output, gnd 핀 위치가 다르니 주의하도록 한다.

그 밖에 24v 750mA에서 안전하게 사용할 수 있는 NPN 트랜지스터와 (본인은 이전에 만든 프로젝트에서 적출한 TIP 120을 사용하였다.) DC to DC Step-down 모듈과 7805 이 필요하다. 24v를 바로 7805로 방열판 없이 연결할 경우 아마 터질지도 모른다. (진짜로 소리 나면서 깨진다) ESP8266 은 생각보다 에너지 소비량이 많다. 대략 알기로는 250mA 정도 된다고 들었다. 그렇기 때문에 전원부가 중요하다. 이 프로젝트에서는 이곳 에서 구매한 모듈을 사용하였는데, 가격도 2,000원 밖에 안 하고 크기도 소형이다. 이 DC to DC 컨버터에 달린 가변저항을 조절하여 6.5v 로 정확하게 맞춰주고 나서 7805를 연결하면 안정적으로 전원을 공급받을 수 있다. 7805 를 부착한 이유는 혹시 모를 사고로 24v가 아두이노에 입력되는 일이 없도록 하기 위해서다. 만약 5v 정전압 컨버터가 있다면 7805 없이 그것을 이용하는 것이 효율적인 측면에서 훨씬 좋을 것이다.

아래는 직접 그려본 회로 배선도이다. 최근에 시간이 많아서 이런 잉여로운 짓을 할 수 있었다.

부품과 회로에 대한 더 자세한 설명은 배선도 아래에 있는 Github 에 공개하였으니 참고바란다.

자 이제 이 많은 부품을 어떻게 가습기 안에 쑤셔 넣어볼까...

이 문제로 꽤 많이 고민했던 것 같다.

우선 모든 부품을 케이블로 연결하여 가습기 안에 넣어보려고 하였다.

위와같이 아두이노에 ESP8266 을 케이블을 연결 하였다...

전원 모듈도 절연 효과를 위하여 방열 테이프로 감싸서 케이블로 연결하였다. 사진상에는 안 보이지만 7805 도 부착하였다.

하지만, 이렇게 케이블로 연결해서 쑤셔 넣어보려고 해도 잘 들어가지 않았다. 무엇보다 공기 흐름을 방해하지 말아야 하는데, 부품과 케이블이 늘어날수록 공기 통로는 좁아지게 되어 결국 분무량도 떨어진다. ㅠㅠ

버틸수 없다...

그래서 결국 가습기 외벽에 구멍을 뚫어서 컨트롤과 신호, 5v 전원 케이블을 뽑아내도록 하였다. 결국 내부에 남는 것은 TIP120 두 개와 5v 전원부이다. 그리고, 전원 LED 와 수위 경고 LED의 각 + 부분에 케이블을 연결한다.

이렇게 구멍을 뚫어서 케이블을 빼준다.

배선 완료. 조만간 3D 프린터로 케이스를 뽑아 씌운다음에 깔끔하게 부착할 계획이다.

3. Software

우선 가습기를 제어하기 위한 서버 프레임워크로 Node.js 를 택했다. 자바 스크립트를 이용하였기 때문에 개발하기도 쉬웠고 라즈베리 파이 위에서도 그럭저럭 괜찮은 성능으로 잘 돌아간다. 또한 npm 모듈로 제공되는 forever 를 이용하면 백그라운드에서 깔끔하게 돌아가기 때문에 가습기 제어용 서버 개발, 운영하는 데는 이보다 좋은 선택이 있을수가 없다. 그리고 웹 서버 프레임워크로 Express 를 사용하였다. 처음에는 TCP 프로토콜을 직접 제어하여 가습기와 커넥션을 유지하도록 하였는데, 개발 중간에 모두 HTTP 프로토콜로 변경시켜 버렸다. 원래 처음에는 모바일 앱을 만들고 서버에서 데이터를 중계하는 방식으로 개발할 계획이었다. 그런데, 생각해보니 이렇게 하면 PC에서 제어하지 못하고 귀찮게 스마트폰 꺼내서 앱 실행 시키고 로딩이 끝날 때 까지 기다렸다가 버튼 몇 개 누르고 다시 앱을 닫아야 한다니.... 이건 통신 거리가 무한대인 블루투스와 다름 없다고 판단하여 웹페이지로 제어 콘솔을 만들기로 하였다. 또, 통신 프로토콜도 HTTP 로 통합시켜 버렸다.

로그 수집을 위한 DB 는 SQL 쿼리문 날리기도 귀찮고 ORM 사용하기에는 이런 미니 프로젝트에서는 오버 테크놀러지고, 몽고DB 같은 사용하기 편하지만, 사용 용도에 비해서 무거운 DB 는 일단 배제하였다. 파일로 직접 저장하자니 그것도 귀찮았다. npm 사이트를 뒤져보니 simple-node-db 라는 나름 쓸만한 녀석을 발견하게 되었다. 성능이나 뭐 그런 것은 안 바라고 오르지 간단하고 개발하기 편리 하다는 이유로 선택하였는데, 뭔가 느린감은 없지않았다. 조금은 구리지만 그래도 데이터는 잘 들어가니 걱정 없다. DB 테이블을 분, 시간, 날짜, 월, 년 단위로 만들어서 평균치를 구하여 저장하려고 계획하였는데 이 것도 귀찮아져서 무조건 분 단위로 저장하도록 하였다. 아니, 귀찮다기 보다는 어차피 내가 쓰려고 대강 만드는 것이고 여러 사람들이 이용하는 서비스가 아니므로 구조가 복잡해질수록 개발 시간을 비롯한 여러 자원이 낭비되기 때문이다.

웹 프런트 프레임워크는 Angular.js 와 Angular Material을 사용하였다. 원래 모바일 개발을 주로 해와서 MVVM 패턴을 위한 Angular.js 의 복잡한 구조도 그럭저럭 이해할 수 있었지만, 웹 개발을 많이 하시는 분들은 항상 학습 곡선이 크다고 말씀하신다. 나한테는 가장 빨리 개발하기 쉬운(그리고 대충해도 잘 나오는) 웹 프레임워크가 Angular.js 기 때문에 이 것을 선택하였다. (사실 angular material 에서 제공하는 다양한 UI 컴포넌트를 척척 붙여서 빠르게 개발하기 위하여 선탁한 것이다.)

(이미지 출처 : http://nathanleclaire.com/blog/2014/01/04/5-smooth-angularjs-application-tips/)

마지막으로 문제의 아두이노와 ESP8266. 진짜 개고생 했다. 무엇 때문에 고생을 했냐면, 첫 번째로 ESP8266 의 AT+COMMAND (명령어) 의 Response 값이 일관되지 못 하고 제대로 된 문서도 없다. 예를 들어 어떤 상황에서 에러가 발생하면 \r\nERROR 이라고 출력되는데 어떤 상황에서는 \nError 이라고 출력된다.

또, 소프트웨어 시리얼을 이용하기 때문에 많은 데이터를 주고받으면 버퍼 오버플로우가 발생하고 깨진 데이터들이 들어온다. UART 방식이 타이밍을 이용하여 데이터를 주고 받는 원시적인(?) 방식인 데 비하여 TCP 는 굉장히 세련되었기 때문에 엄청난 비효율이 아닐 수 없다. 그러므로 다음에도 이와 비슷한 프로젝트를 진행한다면 아두이노 연결 없이 ESP8266 을 기반으로 하여 프로젝트를 진행할 것이다. ㅠㅠ

진짜 심각한 문제는, Node.js + Express 서버와 ESP8266 을 이용하여 HTTP 프로토콜에서 Connection 값을 close로 하여 데이터를 주고받을 때 발생한다. 뭐, Keep-Alive 는 구현하기 빡쎄서 그냥 무조건 close로 하기로 했다.ㅎㅎ 어쨌든 이렇게 했을 때, Get 으로 요청하여 성공했을 때 연결이 바로 끊어져야 한다. 하지만 종종 연결이 끊어지지 않는 괴현상이 생긴다.

이런 괴현상이 발생할 때, 서버와 연결을 시도하면 busy s... 라는 메시지가 출력되면서 그 뒤로는 어떤 명령어를 날려도 busy s... 메시지를 출력하는 고집 불통을 보여주는데, 해외 포럼의 어떤 분은 NPN 트랜지스터를 전원에 연결하여 busy s... 가 등장하면 하드웨어적으로 리셋시켜 버리는 방법을 제시하고 있다. (헐...) 이게 서버 문제인지 ESP 모듈의 펌웨어 문제인지 아직 파악 못 하였다.

이런 현상이 간혹 발생하긴 하지만 한 번 발생한다면 전원 케이블을 뽑았다 다시 껴야 한다. 이렇게 된다면 24시간 동작하며 온습도 자료를 수집하고, 일정 습도를 유지할 수 있도록 도와줘야 하는 가습기 에겐 치명적인 상황이다. 그냥 예전에 17달러 주고 구입한 CC3000 (아두이노 WIFI 쉴드) 을 사용할까 하다가, 불현듯이 좋은 아이디어가 떠올랐다. 그 것은 Get으로 요청한 상황에서 response가 왔을 때, Unlink 메시지가 일정 시간 이상 안 온다면(timeout 상황) AT+RST 명령어를 날려서 모듈을 리셋시켜 버리고 재접속하는 것이다. 그럼 모듈이 리셋이 되면서 마지막으로 연결 되었던 공유기에 자동으로 접속 시도하게 된다. 단, timeout 이 발생하여 임의로 리셋을하고 공유기에 재접속하는 시간까지 다 합쳐서 약 4~5초 정도 손해를 보게 된다.

이런 상황마다 중요한 것이 사용자에게 현재 동작 상태를 알려주는 것이다. 예를 들면 서버 접속 에러, 공유기 접속 에러, 인증에러 등을 알려줘야 한다. 그래서 이런 동작 상태를 LED 깜빡임 간격으로 알릴 수 있도록 하였다. 그러기 위해서는 HTTP 통신을 비동기인 듯 동기 같은 비동기로 처리하도록 해야 했다. 이것이 가능하도록 (대충)만든 HTTP 라이브러는 2kbyte 메모리 공간 중에서 대략 483byte를 잡아먹게 되었다. ㅎㄷㄷ (앞으로 최적화를 통하여 줄어들 수 있다. 물론 늘어날 수도 있다. ㅎㅎ)

github : https://github.com/ice3x2/Wifi_Humidifier

Arduino IDE 1.6.x 버전을 이용하여 간단하게 Attiny85 부트로더 굽기.

snoworca — Thu, 6 Aug 2015 03:00:39 +0900

이전에 아두이노 IDE 1.0.x 버전 기준으로 Attiny85 부트로더 굽는 법과 삽질 경험에 대하여 포스팅(http://www.dev.re.kr/59) 했었는데, 아두이노 IDE 1.6.4 버전 이상과 그 안에 포함된 개개선된 ISP 코드 덕분에 이제는 부트로더 굽는 것이 더 쉬워졌다.

콘덴서나 저항을 reset 버튼 사이에 연결하거나 수정된 ISP 를 따로 구해서 사용할 필요가 없어졌다.

이번 시간에는 1.6.x 버전을 이용하여 간단하게 부트로더를 굽는 방법에 대하여 언급할까 한다.

이 포스팅은 Arduino UNO 기준으로 되어있다.

1. Attiny85 라이브러리 설치하기.

먼저 환경설정 메뉴에 들어가면 아래와 같은 화면이 나오는데, Additional Boards Manager URLs 의 텍스트 박스에 다음과 같은 주소를 적는다. (그림에서 빨간 화살표가 가르키는 곳)

https://raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager/package_damellis_attiny_index.json

(아두이노 IDE 1.6.4 로 버전업 하면서 굉장히 편하고 재미있는 기능을 넣은 것 같다.)

이렇게 입력하게 된다면 https://github.com/damellis/attiny/tree/ide-1.6.x-boards-manager 에 있는 파일을 다운로드 받아 보드 매니져에서 볼 수 있게 된다.

두 번째 단계로 상단 메뉴에서 '도구' -> '보드' -> Boards Manager 를 선택한다. 그럼 아래 스샷과 같은 창이 하나 뜨는데, 검색창에 attiny 를 입력하거나 스크롤을 아래로 내리다보면 attiny 항목을 볼 수 있다.

(설치하기 전에 David A. mellis 에게 감사하는 마음을...)

항목을 선택하면 인스톨 버튼이 나온다. 인스톨 버튼을 누르기 전에 콤보박스에서 최신 버전으로 선택 되어 있는지 확인하자.

인스톨이 완료되면 상단 메뉴에서 도구 -> 보드 항목을 살펴보면 가장 아래쪽에 Attiny 가 추가된 것을 확인할 수 있다.

2. 기존의 아두이노에 ISP 굽기.

USB 로 동작하는 ISP 가 없는이상 기존의 아두이노에 ISP 를 올려서 Attiny 에 부트로더를 굽거나 프로그램을 올릴수밖에 없다. 그러기 위해서 ISP를 기존의 아두이노 위에 올려야한다.

상단 메뉴에서 파일 -> 예제 -> ArduinoISP 를 선택한 다음 자신의 아두이노 위에 올려보자.

물론 상단 메뉴의 도구 에서 선택해야 하는 보드와 포트는 기존에 갖고 있던 아두이노를 선택해야 한다.

3. 아두이노와 Attiny85 간의 연결.

<기존 아두이노 IDE 1.0.x 를 이용하여 부트로더를 굽는 방법에 대하여 설명한 포스팅(http://www.dev.re.kr/59)에서 가져온 이미지이다. 수정하기 귀찮으므로 그대로 가져왔다. 이번에 설명하는 아두이노 IDE 1.6.x 이상에서는 아두이노의 9번핀과 Attiny85 의 pin 3 을 연결할 필요는 없다. pin 번호는 아래 그림 참고>

(Pin0 은 D0 , Pin2 는 D1 이다.)

이해를 돕기 위하여 좀 더 자세히 설명하면,

다음 표와 같다. (9번핀 연결할 필요 없음)

ATtiny Reset	------------------	Arduino 10
~~ATtiny Pin3~~	-----------------	~~Arduino 9~~
ATtiny GND	------------------	Arduino GND

ATtiny VCC	--------------------	Arduino 5v
ATtiny Pin2	--------------------	Arduino 13
ATtiny Pin1	--------------------	Arduino 12
ATtiny Pin0	--------------------	Arduino 11

4. 부트로더 굽기

상단 메뉴에서

도구 -> 보드 -> Attiny 선택.

도구 -> 프로세서 -> Attiny85

도구 -> Clock -> 8 Mhz (internal)

도구 -> 프로그래머 -> Arduino as ISP

를 선택한다.

만약 Clock 을 1 Mhz (internal) 로 선택한다면 최소 1.8v 이상의 저전압에서 사용할 수 있다.

그리고 가장 하단의 부트로더 굽기를 선택하면....

부트로더가 생각보다 빠른 속도로 구워진다.

5. 테스트

잘 되는지 테스트하기 위하여 LED 를 하나 연결해 보고 PWM 으로 깜빡이도록 해보았다.

Attiny85 의 PWM 제어 핀은 0 번과 1번이다.

전원을 5V 를 공급해준다. 그리고 테스트 코드를 입력한다.

Attiny85 Test:

#define LED_PIN 0

bool gIncreaseMode = false;
byte gLedValue = 0;

void setup() {
}

void loop() {
  analogWrite(LED_PIN, gLedValue);
  gLedValue += (gIncreaseMode)?-1:1;
  
  if(gLedValue == 255) {
    gIncreaseMode = true;
  } else if(gLedValue == 0) {
    gIncreaseMode = false;   
    delay(100);              
  }
  delay(3);              
  
}

아래는 결과 영상.

Attiny85 에 프로그램을 올릴 때 마다 빵판에 케이블을 꼈다 뺐다 하기 귀찮아서 아래와 같이 프로그래머 보드를 대충 만들었다.

아래 영상의 LED 도 pin 0 번과 연결되어 있다.

DHT22 를 활용한 온도, 습도계 만들기::인터넷으로 온도와 습도, 불쾌지수를 확인하기.

snoworca — Sun, 2 Aug 2015 23:35:35 +0900

1. DHT22 와 라이브러리 구하기

내가 자주 이용하는 알리 익스프레스에서 3달러 라는 저렴한 가격에 판매되고 있다. 국내 쇼핑몰에서도 많이 판매되고 있다.

github 에 공개된 오픈소스 라이브러리를 다운 받아서 압축을 풀고 아두이노 프로젝트 폴더 내의 라이브러리 폴더에 붙여 넣는다.

DHT22 라이브러리 : https://github.com/nethoncho/Arduino-DHT22

예제코드 : https://github.com/nethoncho/Arduino-DHT22/blob/master/examples/Serial/Serial.ino

예제코드를 보면 매우 간단한 사용법을 확인할 수 있다.

예제코드 실행 결과. 2초에 한 번씩 온도와 습도를 불러온다.

2. DHT22 를 활용한 인터넷 온도/습도계 프로젝트.

웹 브라우저상에서 비동기 방식(ajax)으로 2초에 한 번씩 온도 습도와 불쾌지수를 받아온다. 이를 실시간으로 확인할 수 있으며 불쾌지수에 따라서 위 스샷과 같이 배경 색이 바뀐다. 참고로 위 스샷은 불쾌지수별로 배경색이 바뀌는 것을 테스트하기 위하여 임의의 값을 넣어본 것이다.

아래는 테스트 영상.

중간에 더러운(?) 소리는 DHT22 온 습도 센서에 입김을 불어넣는 소리다.

입김으로 인하여 올라간 습도와 온도 때문에 불쾌지수가 올라가게 되고 따라서 배경색도 바뀌게 된다.

만약 데이터 읽기 실패한 경우 에러 화면을 보여주게 된다. (timeout 5초 내에 데이터를 가져오지 못 한경우.)

물론 이 상태에서 데이터를 정상적으로 읽게 된다면 원래의 모습으로 돌아온다.

우선 온도와 습도, 그리고 불쾌지수를 받아올 데이터 타입 정의가 필요하다.

{"temp":"31.2°C", "hr":"80.1%", "di":84.85}

위 JSON 데이터에서 temp 는 온도, hr 은 습도를 의미하고 실수형 데이터를 갖고 있는 di 는 불쾌지수를 나타낸다.

두 번째로 html 코드를 작성한다. css 파일과 js 파일을 나누어 작성하였다.

HTML:

<!doctype html>
<html>
<head>
    <title>TMP22</title>
    <meta http-equiv='X-UA-Compatible' content='IE=Edge'/>
    <meta charset='UTF-8'>
    <meta http-equiv='Pragma' content='no-cache'>
    <meta HTTP-EQUIV='Expires' CONTENT='-1'>
    <!--모바일 브라우저 호환-->
    <meta name="viewport" content="width=device-width, user-scalable=no">
    <!--모바일 크롬을 위한 테마 컬라--> 
    <meta name="theme-color" content="#333333">
    <!--iOS 사파리를 위한 상태바 컬러-->
    <meta name="apple-mobile-web-app-status-bar-style" content="#333333">

    <script src='https://code.jquery.com/jquery-2.1.4.min.js' type='text/javascript'></script>

<script src='/js' type='text/javascript'></script>
    <link href='http://fonts.googleapis.com/css?family=Righteous' rel='stylesheet' type='text/css'>
    <link href='/css' rel='stylesheet' type='text/css'>
    
</head>

<body>
<div class="container">
    <div class="outer">
        <div class="inner">
            <div class="block">
                <h1 id='temp'>??.? °C</h1>
                <h1 id='hr'>??.? %</h1>
                <h2 id='di'>NaN</h2>
            </div>
        </div>
    </div>
</div>

</body>

</html>

Jquery 라이브러리와 구글 폰트 사이트에서 가져온 Righteous 폰트를 사용한다.

Javascript:

    var diMap = [{
        min : 86,
        backColor: '#F44336',
        blockColor: '#C62828',
    },{
        min : 83,
        backColor: '#FF5722',
        blockColor: '#BF360C',
    },{
        min : 80,
        backColor: '#FF9800',
        blockColor: '#E65100',
    },{
        min : 75,
        backColor: '#FFAB00',
        blockColor: '#FF6F00',
    },{
        min : 70,
        backColor: '#009688',
        blockColor: '#004D40',
    },{
        min : 0,
        backColor: '#03A9F4',
        blockColor: '#01579B',
    }];

    /**
     * 불쾌지수별로 색을 바꾼다.
     * @param di 불쾌지수 값.
     */
    function setColorByDI(di) {
        for(i in diMap) {
            if(diMap[i].min <= di) {
                $('body').css('background-color',diMap[i].backColor);
                $('.block').css('background-color',diMap[i].blockColor);
                return;
            }
        }
    }

    function setColorOnError() {
        $('body').css('background-color','#ffffff');
        $('.block').css('background-color','#000000');
    }

    /**
     * 2초에 한 번씩 서버로부터 온도, 습도, 불쾌지수 데이터를 받아온다.
     */
    function loadData(){
        $.ajax({
            url: '/data',
            dataType: 'json',
            timeout: 5000,
            success: function (data) {
                $('#temp').text(data.temp);
                $('#hr').text(data.hr);
                $('#di').text(data.di);
                setColorByDI(data.di);
            },
            error: function(xhr,status,error) {
                $('#di').text('ERROR');
                setColorOnError();
            }
        });
        setTimeout(loadData,2000);
    }
    loadData();
    setTimeout(loadData,2000);

Javascript 코드는 편한 Ajax 를 이용하기 위하여 Jquery 라이브리를 활용한다.

CSS:

html, body { font-family: 'Righteous', cursive; }
html, body {margin: 0; width: 100%; height: 100%; overflow: hidden }
h1 { font-size: 5em;margin: 0;text-align: center}
h2 { font-size: 3em;margin: 0;text-align: center}
.container {
    width: 100%;
    height: 100%;
}
div.container .outer {
    display: table;
    width: 100%;
    height: 100%;
}
div.outer .inner {
    display: table-cell;
    vertical-align: middle;
    text-align: center;
}
div.inner .block {
    position: relative;
    display: inline-block;
    color: white;
    padding: 1em;
    background: black;
}

폰트를 이쁜 폰트로 설정하였다.

아두이노 코드를 작성하기 전에 먼저 이더넷 모듈과 라이브러리를 준비해야 한다.

이 예제에서는 ENC28J60 이더넷 모듈을 이용하였고, 이 것에 대한 활용 방법을 다룬 포스팅은 http://www.dev.re.kr/79 에서 확인할 수 있다.

그리고 이 예제를 수행하기 위하여 ENC28J60 모듈 라이브러리의 EtherCard.cpp 파일을 수정해야 한다.

버퍼에 문자열을 기록하는 emit_p 함수가 지정된 크기의 소수점 자리수 출력을 지원하지 않기 때문이다.

기존의 Ethercard 라이브러리를 수정된 라이브러리 : https://github.com/ice3x2/ethercard 로 교체하거나,

또는 EtherCard.cpp 파일을 열어서

#define FLOATEMIT

이 부분에 되어있는 주석을 지우고,

void BufferFiller::emit_p(PGM_P fmt, ...)

함수 내부의 case 'T': 에서 break; 까지의 부분을 찾아서 삭제한 아래의 코드로 교체한다.

case 'T':
    defaultPa = 3;
    c = pgm_read_byte(fmt);
    if(c != 0 && c == '.') {
        c = pgm_read_byte(++fmt);
        if(c != 0 && c >= '0' && c <= '9') {
            fmt++;
            defaultPa = c - '0';
        } else {
            defaultPa = 0;
        }
    }
    dtostrf(va_arg(ap, double), 10, defaultPa, (char*)ptr );
break;

이렇게 한다면 이제 DHT22 으로 부터 출력되는 데이터를 소수점 첫 번째 자리수까지 끊어서 출력할 수 있다.

이제 아두이노 코드를 작성해야 하는데, 그 전에 HTML 과 CSS 와 Javascript 를 압축 해야 한다.

HTML 과 CSS 는 http://www.willpeavy.com/minifier/ 이 곳에서 사이즈를 줄일 수 있고,

Javascript 는 http://jscompress.com/ 이 곳에서 사이즈를 줄일 수 있다.

아두이노 코드:

#include <EtherCard.h>
#include <DHT22.h>
#include <string>
#define DHT22_PIN 2
#define CS_PIN 8
#define READ_DHT_DELAY 2000
#define HOST_NAME "TMP22"

#define BUFFER_SIZE 1280


float calcDiscomfortIndex(float temp, float humi);
void readDHT();

char valueStr[6];

static uint8_t macAddr[6] = { 0x54,0x55,0x58,0x1a,0x3c,0x56}; 

byte Ethernet::buffer[BUFFER_SIZE];
BufferFiller bufFiller;

DHT22 dht22(DHT22_PIN);

float temperature = 0.00f; // 온도 
float humidity = 0.00f; // 습도
float di = 0.00f;  // 불쾌지수
long lastReadDHT = 0; // 마지막으로 DHT22 로부터 값을 읽은 시간 (ms)

// CSS 코드를 버퍼에 기록한다.
word writeCss() {
  bufFiller = ether.tcpOffset();
  bufFiller.emit_p(PSTR("HTTP/1.0 200 OK\r\nContent-Type: text/css\r\nPragma: no-cache\r\n\r\n"));
  bufFiller.emit_p(PSTR("html, body{font-family: 'Righteous', cursive;margin: 0; width: 100%; height: 100%; overflow: hidden}h1{font-size: 5em;margin: 0;text-align: center}h2{font-size: 3em;margin: 0;text-align: center}.container{width: 100%; height: 100%;}div.container .outer{display: table; width: 100%; height: 100%;}div.outer .inner{display: table-cell; vertical-align: middle; text-align: center;}div.inner .block{position: relative; display: inline-block; color: white; padding: 1em; background: black;}"));
  return bufFiller.position();
}

word writeFail() {
  bufFiller = ether.tcpOffset();
  bufFiller.emit_p(PSTR("HTTP/1.0 401 Unauthorized\r\nContent-Type: text/html\r\n\r\n<h1>401 Unauthorized</h1>"));
  return bufFiller.position();
}

// 자바스크립트 코드를 버퍼에 기록한다.
word writeJS() {
  bufFiller = ether.tcpOffset();
  bufFiller.emit_p(PSTR("HTTP/1.0 200 OK\r\nContent-Type: application/javascript\r\nPragma: no-cache\r\n\r\n"));
  bufFiller.emit_p(PSTR("var diMap=[{min:86,backColor:'#F44336',blockColor:'#C62828',},{min:83,backColor:'#FF5722',blockColor:'#BF360C',},{min:80,backColor:'#FF9800',blockColor:'#E65100',},{min:75,backColor:'#FFAB00',blockColor:'#FF6F00',},{min:70,backColor:'#009688',blockColor:'#004D40',},{min:0,backColor:'#03A9F4',blockColor:'#01579B',}];function setColorByDI(di){for(i in diMap){if(diMap[i].min<=di){$$('body').css('background-color',diMap[i].backColor);$$('.block').css('background-color',diMap[i].blockColor);return}}}function setColorOnError(){$$('body').css('background-color','#ffffff');$$('.block').css('background-color','#000000')}function loadData(){$$.ajax({url:'/data',dataType:'json',timeout:5000,success:function(data){$$('#temp').text(data.temp);$$('#hr').text(data.hr);$$('#di').text(data.di);setColorByDI(data.di)},error:function(xhr,status,error){$$('#di').text('ERROR');setColorOnError()}});setTimeout(loadData,2000)}loadData();setTimeout(loadData,2000);"));
  return bufFiller.position();
}

// html 코드를 버퍼에 기록한다.
uint16_t writeHtml() {
  bufFiller = ether.tcpOffset();
  bufFiller.emit_p(PSTR("HTTP/1.0 200 OK\r\nContent-Type: text/html\r\nPragma: no-cache\r\n\r\n"));
  bufFiller.emit_p(PSTR("<!doctype html><html><head><meta name='theme-color' content='#333333'><meta name='apple-mobile-web-app-status-bar-style' content='#333333'><meta name='viewport' content='width=device-width, user-scalable=no'><meta http-equiv='X-UA-Compatible' content='IE=Edge'/> <meta charset='UTF-8'> <meta http-equiv='Pragma' content='no-cache'> <meta HTTP-EQUIV='Expires' CONTENT='-1'> <script src='https://code.jquery.com/jquery-2.1.4.min.js' type='text/javascript'></script> <link href='http://fonts.googleapis.com/css?family=Righteous' rel='stylesheet' type='text/css'> <link href='/css' rel='stylesheet' type='text/css'> <script src='/js' type='text/javascript'></script></head><body><div class='container'> <div class='outer'> <div class='inner'> <div class='block'> <h1 id='temp'>??.? °C</h1> <h1 id='hr'>??.? %</h1> <h2 id='di'>NaN</h2> </div></div></div></div></body></html>"));  
  return bufFiller.position();
}

// 온습도, 불쾌지수 값을 JSON 형태로 버퍼에 기록한다. 
word writeJson() {
  bufFiller = ether.tcpOffset();
  bufFiller.emit_p(PSTR("HTTP/1.0 200 OK\r\nContent-Type: application/json\r\nPragma: no-cache\r\n\r\n"));
  bufFiller.emit_p(PSTR("{\"temp\":\"$T.1°C\",\"hr\":\"$T.1%\",\"di\":$T.1}"),temperature, humidity, di);
  return bufFiller.position();
}


void setup(){
  // 이더넷 초기화 
  ether.begin(sizeof Ethernet::buffer, macAddr,CS_PIN);
  // DHCP 초기화.
  while(!ether.dhcpSetup(HOST_NAME,true));
}
 
void loop(){
  word pos = ether.packetLoop(ether.packetReceive());
  readDHT();
  if(pos) {
      ether.httpServerReplyAck(); 
      char* data = (char *) Ethernet::buffer + pos;
      // Data 요청,  
      if(strncmp("GET /data ", data, 10) == 0) {
         ether.httpServerReply_with_flags(writeJson(),TCP_FLAGS_ACK_V|TCP_FLAGS_FIN_V);
      }
      // CSS 요청
      else if(strncmp("GET /css ", data, 9) == 0) {
         ether.httpServerReply_with_flags(writeCss(),TCP_FLAGS_ACK_V|TCP_FLAGS_FIN_V);
      }
      // Javsscript 요청
      else if(strncmp("GET /js ", data, 8) == 0) {
         ether.httpServerReply_with_flags(writeJS(),TCP_FLAGS_ACK_V|TCP_FLAGS_FIN_V);
      }
      else if(strncmp("GET / ", data, 6) == 0) {
         ether.httpServerReply_with_flags(writeHtml(),TCP_FLAGS_ACK_V|TCP_FLAGS_FIN_V);
      } 
      else {
        ether.httpServerReply_with_flags(writeFail(),TCP_FLAGS_ACK_V|TCP_FLAGS_FIN_V);
      }
  }  

}

// DHT22 로부터 값을 읽어온다. 
// 값은 2초 간격으로 읽어온다.
void readDHT() {
    if(millis() - lastReadDHT > READ_DHT_DELAY) {
        lastReadDHT = millis();
        DHT22_ERROR_t errorCode;
        errorCode = dht22.readData();
        switch(errorCode)
        {
            case DHT_ERROR_NONE:
            case DHT_ERROR_CHECKSUM:
              temperature = dht22.getTemperatureC();
              humidity = dht22.getHumidity();
              di = calcDiscomfortIndex(temperature,humidity);
              break;
        }
    }
}

// 온도와 습도를 입력받아 불쾌지수를 계산하여 반환한다.
// 불쾌지수에 대한 계산법은 http://www.kma.go.kr/HELP/basic/help_01_05.jsp 이 곳에서 확인하였다.
float calcDiscomfortIndex(float temp, float humi) {
    return (1.8f*temp)-(0.55*(1-humi/100.0f)*(1.8f*temp-26))+32;
}

ENC28J60 이더넷 모듈을 이용하여 아두이노를 웹 서버로 활용하기::인터넷 건반 만들어 소리 재생하기

snoworca — Sun, 2 Aug 2015 03:49:52 +0900

이번 포스팅에서는 ENC28J60 를 이용하여 아두이노를 웹서버로 만들어 보겠다.

아두이노 모델중에 가장 많이 사용되는 UNO 에 탑재된 ATmega328의 2kbyte 라는 개미 코딱지 같은 메모리를 활용하여 그럴싸한 html 문서를 보여주는 웹 서버를 만드는 것은 쉽지 않은 일이다. 응용 소프트웨어 서버로 사용하기에는 조악한 성능을 갖고 있다. 그 때문에, 아두이노를 웹 서버로 사용하게 된다면 센서를 통하여 데이터를 수집하고 REST로 값을 전달해 주는 기능이나 물리적 장치 제어를 위한 컨트롤러 이상으로 확장하기는 어려울 것이다 . 하지만 이번 포스팅에서는 아두이노를 웹서버로 만들어 재미있는 것들을 만들어보고자 한다. (조만간 안 귀찮을 때 WIFI 사용도 같이 다뤄보고자 한다. )

1. 이더넷 모듈 구하기.

아두이노 UNO R3 기준으로 설명하겠다. 첫 번째로 점프 케이블을 구하고 두 번째로 가장 중요한 ENC28J60이 탑재된 이더넷 모듈을 구해야 한다. 사실 아두이노 공식 이더넷 쉴드는 W5100 라는 칩을 사용하지만 ENC28J60 에 비하여 가격이 비싸다. 당장 국내 온라인 쇼핑몰만 찾아봐도 ENC28J60 이더넷 모듈은 1만 3천원 안쪽으로 구입할 수 있지만 W5100 이더넷 모듈은 이 것보다 배 이상 비싸다. 성능 차이는 있을지 모르겠지만, 초 극 저사양 마이크로 컨트롤러 에서는 ENC28J60만 되어도 충분하지 않을까...;;;

알리익스프레스에서 enc28j60 으로 검색하면 정말로 저 가격에 살 수 있다. 참고로 본인은 할인 행사 덕분에 2달러에 구입했다. ㅡ , ㅡd 대신 도착하는데 보름 이상 걸린다. 국내 유명 전자 부품 쇼핑몰 엘xx츠 에서도 1만 3천원 안쪽으로 구입할 수 있으며 재고도 있는듯.

2. 연결하기

SPI 통신을 사용하기 때문에 점퍼 케이블을 이용하여 다음과 같이 연결해야 한다.

이더넷 모듈 핀	아두이노 핀
전원	5v or 3.3v (모듈에 따라서)
GND	GND
SCK	13
SO	12
SI	11
CS	8

(CS 핀은 아무곳에나 연결해도 상관 없다. 코드상으로 이더넷을 초기화 하는 과정에서 CS 핀을 변경할 수 있기 때문이다.)

3. 라이브러리 구하기, 예제 돌려보기

이 곳 (https://github.com/jcw/ethercard) 에 접속하여 라이브러리를 다운로드 받고 압축을 풀어 아두이노 프로젝트 폴더 내의 라이브러리 폴더에 폴더채로 이동시킨다. 폴더명은 적절하게 수정하자. 또는 아두이노 IDE 의 스케치 -> 라이브러리 가져오기 메뉴를 활용하는 방법도 있다. (시간이 흘러 이 포스팅에서 언급하는 이더넷 라이브러리 버전과 최신 버전의 API 가 일치하지 않을 수 있으므로 포스팅 작성 시점에서 fork 하였다. fork된 git 프로젝트의 링크 : https://github.com/ice3x2/ethercard)

아두이노 IDE 를 실행하면 ethercard 라이브러리가 추가된 것을 확인할 수 있다. 이 라이브러리에 포함된 예제를 살펴보면 재미있고 유용한 예제들이 많다. 그 중에 rbbb_server 라는 예제를 살펴보겠다.

rbbb_server 를 선택하면 아주 짧고 간단한 코드가 등장하는데, 사용하기 편하도록 몇 가지만 수정해보겠다.

setup() 함수를 살펴보면 아래와 같이 구현이 되어있다.

void setup () {
  if (ether.begin(sizeof Ethernet::buffer, mymac) == 0)
       Serial.println(F("Failed to access Ethernet controller"));
       ether.staticSetup(myip);
}

간단히 설명하자면, 이더넷을 버퍼와 mac 어드레스를 이용하여 초기화하고, 고정된 아이피 주소를 할당하도록 하는 코드이다. 하지만 이 코드는 불편하다. 이유는, 공유기의 설정에 들어가서 mac 주소 찾아서 할당해줘야 하기 때문이다. 요즘은 대부분 누구나 이더넷 케이블 연결하기만 하면 동적으로 주소 할당해주는 DHCP 기능이 지원되는 공유기를 갖고 있다. 그러므로 DHCP 기능을 사용하여 ip 주소를 자동으로 받아 오도록 하는 것이 편할 것이다.

DHCP를 이용하기 위하여 아래와 같이 수정해준다.

#define CS_PIN 8
#define HOST_NAME "arduino"
// ... 중략
void setup () {
    Serial.begin(57600);
    if (ether.begin(sizeof Ethernet::buffer, mymac,CS_PIN) == 0)
    Serial.println(F("Failed to access Ethernet controller"));
    while(!ether.dhcpSetup(HOST_NAME, true));
    Serial.println("Connected");
    ether.printIp("IP: ", ether.myip);
    ether.printIp("Netmask: ", ether.netmask);
    ether.printIp("Gateway IP: ", ether.gwip);
    ether.printIp("DNS IP: ", ether.dnsip);
}

변경된 코드에서는 CS_PIN 번호를 추가하였다. ethercard 라이브러리 내에서 CS PIN 은 기본으로 8번으로 되어있지만, ether.begin 함수의 마지막 인자값으로 임의의 CS pin 번호를 넣어줄 수 있다.

두 번째로 정적으로 ip 를 할당하는 staticSetup 함수를 지우고 dhcp 를 통하여 ip 를 할당받을 수 있는 dhcpSetup 함수를 넣었는데, 제대로 설정될 때 까지 무한 반복되도록 하였다.

이제 코드를 아두이노에 업데이트 하고 인터넷 케이블을 연결한 다음에 도구->시리얼 모니터를 열어서 baud rate 를 57600 으로 설정하면 다음과 같은 메세지를 확인할 수 있다.

ip 주소가 192.168.0.49 로 자동 할당되었다.

공유기 설정 화면에서도 지정한 host name 으로 하여 ip 주소가 자동을 할당된 것을 확인할 수 있다.

이 주소로 접속하면 위 스샷 이미지와 같이 아두이노의 구동 시간을 보여주며 연속으로 refresh 하는 것을 볼 수 있다.

3. 인터넷 웹 브라우저로 연주하는 건반

이 예제를 이용하여 좀 더 재미있는 것을 만들어 보겠다.

원래는 브라우저로 LED 밝기를 조절하는 것을 만들어 보려고 했지만, 너무 식상해서간단한 건반으로 바꾸었다.

아래는 동작 영상이다. (동영상의 볼륨을 올려주세요.)

첫 번째로 준비물을 챙긴다.

우선 ENC28J60 모듈과 스피커를 준비한다.

스피커는 아무 것이나 상관 없는데, 극성만 잘 구분해서 + 단자를 아두이노의 핀 6번에 연결하면 된다.

두 번째로 아래와 같은 화면이 나오게끔 html 을 코딩한다.

위 스샷에 나오는 색이 들어있는 상자 하나는 각 음계를 재생하는 버튼이다. 예를들어 빨간색은 C4 주황색은 D4, 노란색은 E4 ... 보라색은 B4 를 나타낸다.

각각의 상자를 눌러서 각 음계로 해당하는 링크로 이동할 수 있도록 만들어야 한다.

<!DOCTYPE html>
<html lang='en'>
<head>
    <meta charset='UTF-8'>
    <meta name='viewport' content='width=device-width, user-scalable=no'>
    <style type="text/css">
        div { width: 14.28%;height: 100%; display: inline-block;}
        body {width: 100%;height: 100%;margin: 0;position: absolute; overflow: hidden;font-size: 0px;
            letter-spacing: 0px;
            word-spacing: 0px;}
    </style>
</head>
<body>
<a href="/0"><div style="background: red"></div></a>
<a href="/1"><div style="background: orange"></div></a>
<a href="/2"><div style="background: yellow"></div></a>
<a href="/3"><div style="background: green"></div></a>
<a href="/4"><div style="background: blue"></div></a>
<a href="/5"><div style="background: midnightblue"></div></a>
<a href="/6"><div style="background: darkviolet"></div></a>
</div>
</body>
</html>

각 음계에 해당하는 상자에는 /0 부터 /6 까지 링크가 걸려있으며 이 버튼을 누를 경우 해당 페이지로 이동하게 된다.

이제 이 html 코드를 아두이노로 옮겨야 한다. 그냥 옮기면 사이즈도 크고 복잡하므로 https://kangax.github.io/html-minifier/ 를 이용하여 코드를 한 줄로 만들어 버린다. 아마 다음과 같이 나올 것이다.

<!DOCTYPE html><html lang=en><head><meta charset=UTF-8><meta name=viewport content='width=device-width,user-scalable=no'><style type=text/css>div{width:14.28%;height:100%;display:inline-block}body{width:100%;height:100%;margin:0;position:absolute;overflow:hidden;font-size:0;letter-spacing:0;word-spacing:0}</style><body><a href=/0><div style=background:red></div></a> <a href=/1><div style=background:orange></div></a> <a href=/2><div style=background:#ff0></div></a> <a href=/3><div style=background:green></div></a> <a href=/4><div style=background:#00f></div></a> <a href=/5><div style=background:#191970></div></a> <a href=/6><div style=background:#9400d3></div></a>

주의해야 할 사항은 큰 따옴표를 작은 따음표로 바꿔줘야 한다.

이제 아두이노에 들어갈 코드를 살펴보자.

#include <EtherCard.h>

#define CS_PIN 8
#define SPEAKER_PIN 6
#define HOST_NAME "keyboard"

// 각 음계에 해당하는 값. CDEFGAB -> 도레미파솔라시
// 이 값은 아두이노 IDE의 파일->예제->Digital->toneKeyboard 에서 확인 가능.
#define NOTE_C4  262
#define NOTE_D4  294
#define NOTE_E4  330
#define NOTE_F4  349
#define NOTE_G4  392
#define NOTE_A4  440
#define NOTE_B4  494

unsigned int note[] = {NOTE_C4, NOTE_D4,NOTE_E4, NOTE_F4, NOTE_G4,NOTE_A4, NOTE_B4};

// MAC 어드레스
static byte mymac[] = { 0x74,0x69,0x69,0x2D,0x30,0x31 };
byte Ethernet::buffer[860];
BufferFiller bfill;

void setup () {
    Serial.begin(57600);
    if (ether.begin(sizeof Ethernet::buffer, mymac,CS_PIN) == 0)
        Serial.println(F("Failed to access Ethernet controller"));
    // HDCP 가 설정될 때 까지 대기한다.
    while(!ether.dhcpSetup(HOST_NAME, true));
    Serial.println("Connected");
    ether.printIp("IP: ", ether.myip);
    ether.printIp("Netmask: ", ether.netmask);
    ether.printIp("Gateway IP: ", ether.gwip);
    ether.printIp("DNS IP: ", ether.dnsip);
}

// HTML 을 버퍼에 기록한다.
static word writeHtml() {
    bfill = ether.tcpOffset();
    //  https://kangax.github.io/html-minifier/ 를 통하여 압축한 html 코드
    bfill.emit_p(PSTR("<!DOCTYPE html><html lang=en><head><meta charset=UTF-8><meta name=viewport content='width=device-width,user-scalable=no'><style type=text/css>div{width:14.28%;height:100%;display:inline-block}body{width:100%;height:100%;margin:0;position:absolute;overflow:hidden;font-size:0;letter-spacing:0;word-spacing:0}</style><body><a href=/0><div style=background:red></div></a> <a href=/1><div style=background:orange></div></a> <a href=/2><div style=background:#ff0></div></a> <a href=/3><div style=background:green></div></a> <a href=/4><div style=background:#00f></div></a> <a href=/5><div style=background:#191970></div></a> <a href=/6><div style=background:#9400d3></div></a>"));
    return bfill.position();
}

word writeFail() {
    bfill = ether.tcpOffset();
    bfill.emit_p(PSTR("HTTP/1.0 401 Unauthorized\r\nContent-Type: text/html\r\n\r\n<h1>401 Unauthorized</h1>"));
    return bfill.position();
}

void loop () {
    // 패킷이 들어올 때 까지 루프.
    word pos = ether.packetLoop(ether.packetReceive());
    if(pos) {
        ether.httpServerReplyAck();
        // 데이터를 가져온다.
        char* data = (char *) Ethernet::buffer + pos;

        for(int i = 0; i < 7; ++i) {
            String str = "GET /" + String(i);
            str += ' ';
            Serial.println(str.c_str());
            // 이 부분에 대하여 밑에서 설명하겠다.
            if(strncmp(str.c_str(), data, str.length()) == 0) {
                // 재생중인 소리 종료
                noTone(SPEAKER_PIN);
                // 500ms 동안 소리를 재생한다.
                // 비동기식으로 동작한다.
                tone(SPEAKER_PIN, note[i],500);
                ether.httpServerReply_with_flags(writeHtml(),TCP_FLAGS_ACK_V|TCP_FLAGS_FIN_V);
                return;
            }
        }
        // 이 부분에 대하여 밑에서 설명하겠다.
        if(strncmp("GET / ", data, 6) == 0) {
            ether.httpServerReply_with_flags(writeHtml(),TCP_FLAGS_ACK_V|TCP_FLAGS_FIN_V);
        }
        // 정의된 path 값으로 접속하지 않았을 경우 에러 메세지 전송.
        else {
            ether.httpServerReply_with_flags(writeFail(),TCP_FLAGS_ACK_V|TCP_FLAGS_FIN_V);
        }
    }
}

위 코드에서 중요한 부분이 있는데, 바로 path 값을 분류하는 것이다.

웹 브라우저를 통하여 http 프로토콜로 서버로 요청할 때 들어오는 데이터는 다음과 같다.

GET /0 HTTP/1.1
Host: 192.168.0.49
Connection: keep-alive
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_4) AppleWebKit/537.36 (KHTML, like Gecko) Safari/537.36
Referer: http://192.168.0.49/0
Accept-Encoding: gzip, deflate, sdch
Accept-Language: ko-KR,ko;q=0.8,en-US;q=0.6,en;q=0.4

이 중에서 우리가 눈여겨 보아야 할 것은 첫 번째 줄이다.

첫 번째 줄의 첫 번째 블럭을 보면 GET 방식으로 접속 한다는 것을 알려주고 있고, 두 번째 블럭은 paht 값을 알려주고 있다.

이 path 값을 이용하여 통신할 수 있는 것이다.

HTTP 프로토콜 파싱 모듈을 만들거나 라이브러리를 이용한다면 완벽한 REST 서버도 구현할 수 있을 것이다.

어쨌든 이 번은 간단한 예제이므로, 이 것을 다음과 같이 처리하였다.

if(strncmp("GET / ", data, 6) == 0) {            
   ether.httpServerReply_with_flags(writeHtml(),TCP_FLAGS_ACK_V|TCP_FLAGS_FIN_V);
}

path 값을 검사하기 위해서 strncmp 를 이용하였는데, 첫 번째 인자는 비교할 문자열이고 두 번째 인자는 대상 문자열이다. 세 번째 인자는 비교할 길이다. (주로 첫 번째 인자로 들어간 문자열의 길이를 입력한다.) 즉, data 배열에 담긴 문자열의 시작 위치에서 6번째 까지 문자를 검사하고 이 것이 "GET / " 과 일치하는지 확인하는 과정이다. paht 값이 일치 한다면 ctrncmp 함수는 0을 반환한다.

ether.httpServerReply_with_flags(writeHtml(),TCP_FLAGS_ACK_V|TCP_FLAGS_FIN_V);

이 라인에서는 http 데이터를 반환하고 TCP ack 값을 날리고 연결을 닫아준다.(TCP_FLAGS_ACK_V|TCP_FLAGS_FIN_V)

확인결과 안타깝게도 소켓을 여려개 생성하고 커넥션을 관리하는 것이 힘들기 때문에 연결을 즉시 닫아주는 것이 좋을 것 같다.

만약 데이터를 여러번 나누어 보내고 싶을 때는 multipacket 예제를 살펴보자.

이제 주소값을 이용하여 소리를 재생하는 부분을 살펴보자.

for(int i = 0; i < 7; ++i) {
    String str = "GET /" + String(i);
    str += ' ';
    Serial.println(str.c_str());
    // 이 부분에 대하여 밑에서 설명하겠다.
    if(strncmp(str.c_str(), data, str.length()) == 0) {
        // 재생중인 소리 종료
        noTone(SPEAKER_PIN);
        // 500ms 동안 소리를 재생한다.
        // 비동기식으로 동작한다.
        tone(SPEAKER_PIN, note[i],500);
        ether.httpServerReply_with_flags(writeHtml(),TCP_FLAGS_ACK_V|TCP_FLAGS_FIN_V);
        return;
    }
}

이 부분은 귀찮은 관계로 다소 비효율적으로 처리하였는데, 오히려 이해하기는 쉬울 것이다.

이 코드는 클라이언트(웹브라우저) 를 통하여 들어온 http 헤더 값의 첫 번째 줄을 총 7번 검사한다.

path 값들도 /0 /1 ... /5 /6 까지 총 7번 검사한다.

만약 path 값이 일치할 경우 현재 재생하고 있는 소리를 종료하고 해상 path 값에 해당하는 소리를 500ms 동안 재생한다.

[Tip] View 으로로부터 Bitmap 가져오기 :: getDrawingCache 를 호출했을 때 발생하는 문제 해결.

snoworca — Fri, 8 May 2015 19:31:41 +0900

// SDK 22 기준.
view.setDrawingCacheEnabled(true);
// 임의로 measure 와 layout 을 호출한다.
//view.measure(View.MeasureSpec.makeMeasureSpec(parent.getWidth(), View.MeasureSpec.EXACTLY),
//                View.MeasureSpec.makeMeasureSpec(parent.getHeight(), View.MeasureSpec.EXACTLY));
view.measure(View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED),
                    View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED));
view.layout(0, 0, view.getMeasuredWidth(), view.getMeasuredHeight());

// 알파값을 갖는다면 어떤 옵션을 줘도 ARGB_8888 (32비트) 비트맵으로 반환되며,
// 알파값을 갖지 않는다면 어떤 옵션을 줘도 RGB_565 (16비트) 의 비트맵으로 반환한다 (;;;)
// 게다가 호출하는 즉시 캐쉬 비트맵이 recycle 된다.
//view.setDrawingCacheQuality(View.DRAWING_CACHE_QUALITY_AUTO);
Bitmap cache = view.getDrawingCache(true);
if(cache != null) {
    Bitmap cachedBitmap = Bitmap.createBitmap(cache);
}
view.setDrawingCacheEnabled(false);

보통은 위와 같은 방법으로 호출하면 View 의 bitmap 캐쉬를 무사히 가져올 수 있다.

하지만 이 방법을 사용했을 때, setDrawingCacheQuality 옵션을 LOW 로 줘도 ARGB_8888또는 RGB_565 이 반환된다.

View 의 getDrawingCache 내부에 퀄리티 관련 옵션값을 처리하는 부분에 다음과 같은 주석이 있다.

// Never pick ARGB_4444 because it looks awful

그래도 ARGB_4444 를 사용하고 싶다면 다음과 같이 처리하면 된다.

Bitmap bitmap = Bitmap.createBitmap(view.getWidth(), view.getHeight(), Bitmap.Config.ARGB_4444);
Canvas canvas = new Canvas(bitmap);
canvas.translate(view.getScrollX(), view.getScaleY());
canvas.drawARGB(0, 0, 0, 0);
view.draw(canvas);

테스트 진행시 Private 메소드 호출하기.

snoworca — Wed, 29 Apr 2015 14:13:34 +0900

TDD 코드를 작성하는데, Private 메소드는 아주 귀찮은 존재입니다.

잠시 public 으로 바꿔서 테스트 하거나 또는 리플렉션을 사용하여 실행 시키는 방법등이 있는데, 여러가지로 피곤함을 가중시켜요.

그러나 이런 문제를 해결하기 위한 PowerMock 과 같은 도구가 있습니다!!

https://code.google.com/p/powermock/

하지만, Android 테스트에서 Robolectric 과 Mockito 를 사용하는데, 여기다가 PowerMock 까지 붙이면 Exception 을 뿜으며 문제가 생기네요.

(혹시 문제 해결책을 아시는 분 있으면 알려주십쇼..ㅠㅠ)

어쨌든 위와 같은 문제를 해결 하느라 약간의 삽질을 하다가, 허접하게 나마 아래와 같이 좀 더 편하게 private 메소드를 실행시킬 수 있는 코드를 짜봤는데요,

이 것을 이용하면 private 메소드에 대하여 그럭저럭 테스트는 진행할 수 있습니다.

다만, 아직 null 인자값을 받을 수 없고, 가변 인자값도 사용할 수 없습니다.

이 문제가 개선되는 대로 업데이트 할 것입니다.

invoke.zip

사용 방법.

// 인자값이 없는 static 메소드.
// 메소드의 반환 값이 없을 경우 null 을 반환.
Object 반환값 = invokeStatic(클래스.class, "메소드명");
// 인자값이 있는 static 메소드.
Object 반환값 = invokeStatic(클래스.class, "메소드명", 인자값1, 인자값2... );

// 인자값이 없는 메소드.
Object 반환값 = invoke(객체, "메소드명");
// 인자값이 있는 메소드
Object 반환값 = invoke(객체, "메소드명", 인자값1, 인자값2... );

Guava 사용 요약 슬라이드.

snoworca — Fri, 17 Apr 2015 02:55:26 +0900

이 슬라이드를 보고 암이 치료되었습니다...

위 슬라이드 내용을 아래와 같이 정리해 봤다.

Base :: Objects.equal(), Objects.hashCode(),

MoreObjectes.toStringHelper(), ComparisonChain.compare()

public class Employee implements  Comparable{
    public String name;
    public Integer age;
    public Job job;

    @Override
    public boolean equals(Object o) {
        if(!(o instanceof  Employee)) return false;
        Employee that = (Employee)o;
        return Objects.equal(name, that.name) &&
                Objects.equal(age, that.age) &&
                job == that.job;
    }

    @Override
    public int hashCode() {
        return Objects.hashCode(name, age, job);
    }

    @Override
    public String toString() {
        return MoreObjects.toStringHelper(this).
                add("name", name).
                add("age", age).
                add("job", job).
                toString();
    }


    @Override
    public int compareTo(Employee another) {
        return ComparisonChain.start()
                .compare(this.name, another.name, 
                                Ordering.natural().nullsLast())
                .compare(this.age, another.age, 
                                Ordering.natural().nullsLast())
                .compare(this.job, another.job, 
                                Ordering.natural().nullsLast())
                .result();
    }
}

Base :: Preconditions.checkNotNull()

public class Mail {
    String title;
    String body;

    public Mail(String title, String body) {
        this.title = Preconditions.checkNotNull(title, "title must not be null");
        this.body = Preconditions.checkNotNull(body, "body must not be null");
        Preconditions.checkArgument(body.matches("<[^>]*>"), "Cannot insert tags in body."  );
        Preconditions.checkArgument(title.matches("<[^>]*>"), "Cannot insert tags in title"  );
    }
}


// java.lang.NullPointerException: title must not be null 발생.
Mail mailA = new Mail(null, null);

// java.lang.IllegalArgumentException: Cannot insert tags in body. 발생.
Mail mailB = new Mail("ha ha!","hi <div> hello </div> " );

더 많은 정보 : http://stackoverflow.com/questions/3128120/what-is-the-proper-error-message-to-supply-to-google-guavas-preconditions-met

Base :: MoreObjects.firstNonNull()

public String getPackageName() {
    // 기존
    //String packageName = getPackageName();
    //return (packageName != null)?packageName:"UNKNOWN";

    // 개선
    return MoreObjects.firstNonNull(getPackageName(), "UNKNOWN");
}

Base :: Joiner

List<String> heroes = Lists.newArrayList("Kick-Ass", "Iron Man", null, "Chuck Norris");
String names = Joiner.on(", ").join(heroes);
// NullPointerException 발생!!

List<String> heroes = Lists.newArrayList("Kick-Ass", "Iron Man", null, "Chuck Norris");
String names = Joiner.on(", ").skipNulls().join(heroes);
// "Kick-Ass, Iron Man, Chuck Norris"

List<String> heroes = Lists.newArrayList("Kick-Ass", "Iron Man", null, "Chuck Norris");
String names = Joiner.on(", ").useForNull("Invisible Man").join(heroes);
// prints "Kick-Ass, Iron Man, Invisible Man, Chuck Norris"

Map<Integer, String> map = new HashMap<Integer, String>();
map.put(1, "Chuck Norris");
map.put(2, "Iron Man");
map.put(3, "Kick-Ass");
String ranks = Joiner.on('\n').withKeyValueSeparator(" -> ").join(map);

System.out.println(ranks);

/**
Prints:
1 -> Chuck Norris
2 -> Iron Man
3 -> Kick-Ass
*/

정리중...

ActivityLifecycleCallbacks 를 이용하여 실행중인 Activity 상태와 객체 가져오기.

snoworca — Thu, 9 Apr 2015 05:24:09 +0900

Application 클래스 내부 메소드인 registerActivityLifecycleCallbacks(ActivityLifecycleCallbacks) 를 이용해야 한다.

이 메소드의 인자값으로 ActivityLifecycleCallbacks 를 상속받아 구현한 클래스의 인스턴스를 넣어준다.

또는 다른 Activity 나 Service 내부에서

getApplication(). registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks { ... })

와 같이 호출해 주는 방법도 있다.

registerActivityLifecycleCallbacks 을 더이상 사용하지 않을때는 unregisterActivityLifecycleCallbacks(ActivityLifecycleCallbacks) 를 이용하여 이벤트 등록을 해지시켜 줘야 한다.

registerActivityLifecycleCallbacks 는 Activity 의 라이프 사이클별로 발생하는 이벤트에 대한 콜백을 제공한다.

즉, 어떤 Activity의 라이프 사이클 이벤트 메소드(onCreate, onDestroy, onResume, onPause, onStart, onStop 등) 가 호출되는 순간 때 외부에서 ActivityLifecycleCallbacks 를 사용하여 발생하는 이벤트와 대상 Activity 객체를 가져올 수 있다.

사용시 주의할 점은 Activity 를 상속받아 구현된 당신의 액티비티 클래스에서 오버라이드된 이벤트 메소드가 끝나는 순간에 ActivityLifecycleCallbacks 의 이벤트가 호출되지 않을 수 있다. 좀 더 자세히 설명하기 위해서 아래 코드를 첨부한다.

(말도 안 되는 코드지만, 이해를 돕기 위하여 이렇게 작성하였다.)

<MainActivity.java>

class MainActivity extends Activity {

public ListView mTextView;

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

mTextView = (ListView)findViewById(R.id.textView);

}

...

< ExActivityLifecycleCallbacks.java>

class ExActivityLifecycleCallbacks implements ActivityLifecycleCallbacks {

public void onActivityCreated(Activity activity, Bundle savedInstanceState) {

ListView textView = ((MainActivity)actvitiy). mTextView

// 이 곳에서 null 포인터 예외 발생.

textView.setText("Hello World!");

}

...

이와 같이 에러가 발생하는 이유는 ActivityLifecycleCallbacks 의 onActivityCreated 가 실제로 호출되는 시점이 상속받은 액티비티의 onCreate 메소드에서 super.onCreate(savedInstanceState); 를 호출하는 순간이기 때문이다. 즉, ActivityLifecycleCallbacks 의 이벤트 메소드의 호출은 부모 Activity 클래스의 각 라이프 싸이클 관련 이벤트 메소드 내부에서 간접적으로 이루어지기 때문이다. 이 것에 대한 자세한 내용은 아래에서 다루겠다.

ActivityLifecycleCallbacks 의 메소드 이름을 보면 한 눈에 딱 들어오는 것이 쓰기에도 편하다.

api 레벨 14 (iCS) 이상에서 사용할 수 있다.

public class TestApplication extends Application {

    @Override
    public void onCreate() {
        super.onCreate();
        registerActivityLifecycleCallbacks(mActivityLifecycleCallbacks);
    }

    ActivityLifecycleCallbacks mActivityLifecycleCallbacks =

             new ActivityLifecycleCallbacks() {
        @Override
        public void onActivityCreated(Activity activity, Bundle savedInstanceState){
        }

        @Override
        public void onActivityStarted(Activity activity) {
        }

        @Override
        public void onActivityResumed(Activity activity) {
        }

        @Override
        public void onActivityPaused(Activity activity) {
        }

        @Override
        public void onActivityStopped(Activity activity) {
        }

        @Override
        public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
        }

        @Override
        public void onActivityDestroyed(Activity activity) {
        }
    };
}

하지만, 뭔가 되게... 찝찝한 것이 있다. 구글 개발자 사이트에서 ActivityLifecycleCallbacks 의 페이지를 찾아서 들어가보면 설명이 전혀 없는 것을 볼 수 있기 때문이다.

(이 문서 페이지에 대하여 마지막으로 확인을 한 것은 이 포스팅을 작성한 시점과 동일한 15년 03월이다.

이 문서에 대한 첫 확인은1년전에 했었다.

지금까지는 변한 것이 없지만 앞으로는 개선될 수 있다.)

여담이지만, 그동안 구글 api 와 문서에 뒤통수 맞은 것이 한 두번이 아니다. 다행히 요즘은 많이 괜찮아 졌지만 오래전 안드로이드에서 버전별로 미묘하게 다르게 동작하는 AsyncTask 때문에 개삽질한 경험과, Fragment 의 파편화, 기기별로 미묘하게 동작이 다른 onTouch 이벤트 등...

(경험상 AsyncTask 파편화 처리가 최고 정점이었다. 결국 호환 클래스를 구현하여 해결하였지만 그 이후로 AsyncTask 는 두번다시 사용하지 않는다. ㅡ , , ㅡa )

그렇기 때문에 문서에 설명조차 없는 ActivityLifecycleCallbacks 사용이 조금 망설여 지는 것도 사실이다.

그러나 테스트 결과는 우려와는 다르게 정상적으로 동작하는 것을 확인 하였다.

Application.java 내부에서 ActivityLifecycleCallbacks이 사용되는 과정은 다음과 같다.

우선 registerActivityLifecycleCallbacks 를 통하여 등록된 ActivityLifecycleCallbacks 인스턴스의 메소드들은 Application 클래스의

dispatchActivityCreated, dispatchActivityStarted, dispatchActivity...

등의 메소드에서 호출된다.

참고로 이 메소드들은 2011년 7월에 추가된 것 같다. (https://github.com/android/platform_frameworks_base/blob/3bdbf644d61f46b531838558fabbd5b990fc4913/core/java/android/app/Application.java)

이 메소드들이 호출되는 장소는 Activity 클래스의 각 라이프 사이클 관련 이벤트 메소드다.

예를들어 Application dispatchActivityCreated 는 아래 코드와 같이 Activity 의 onCreate 이벤트 메소드에서 호출된다.

( Activity.java )

protected void onCreate(@Nullable Bundle savedInstanceState) {

// 나머지 코드는 생략.

getApplication().dispatchActivityCreated(this, savedInstanceState);

}

API 문서에 설명이 없는 것은 조금 당황스럽지만, 안심하고 사용해도 될 것 같다.

Android, NDK 를 활용한 클라이언트 앱 위변조 간단하게 방지하기.

snoworca — Wed, 8 Apr 2015 18:45:08 +0900

사실 앱 위변조 방지는 프로가드만 잘 적용하면 어느정도 방지할 수 있다. 하지만, 클라이언트 앱을 역컴파일 한다면 서버 API 가 노출되는 것을 쉽게 막을수도 없는일이다.

사실 이 문제에 대하여 당장 떠오르는 해결책은 NDK 를 사용하여 서버와 통신하는 것이다. 하지만 서버의 모든 API 호출을 C/C++ 로 구현하기에는 시간적 인적 비용이 부족한 많은 프로젝트에서는 거의 불가능에 가깝지 않을까 생각한다.

그래서 시간이 없는 상황에서는 다음과 같이 간단한 방법을 이용할 것을 권장한다.

코드상에서 서명 값을 가져와서 서버와 첫 접속시 이 값을 보내준다. 서버에는 앱의 서명 값이 이미 저장되어 있으며 이 것을 클라이언트로부터 받은 서명값과 비교하여 위변조된 앱인지 검출하는 것이다. 즉, 앱 빌드시 다른 인증서로 서명한 것들은 위변조로 판별하는 원리이다.

만약 위변조된 앱으로 접속했을 경우 앱에서는 경고창을 띄워주고 세션을 유지하지 않도록 해준다.

서명 값을 가져와 서버로 보내는 과정만큼은 NDK 로 구현하여 서버 API 를 노출하지 않도록 만들어야 하며, 서버로 보내는 서명 값을 공격자가 알 수 없는 값으로 변환하거나 암호화 하는 것이 더 좋을 것이다. 서명 값(인증서 지문, 이 포스팅에서는 서명 값으로 표시하겠다.) 은 APK 파일 내부의 META-INF/CERT.RSA 를 통하여 가져올 수 있기 때문이다.

너무나 당연한 이야기지만 주의할 점은 HTTP 를 사용할 경우 반드시 SSL 을 적용해야 한다. HTTPS 가 아닌 HTTP 는 공격자가 루팅된 폰이나 VPN 을 사용하여 손쉽게 패킷 전송 내용을 훔쳐볼 수 있기 때문이다.

이 것의 구현에 필요한 관련 포스팅은 아래와 같다.

NDK 에서 HTTP 통신 이용하기 : http://www.dev.re.kr/67

NDK 에서 서명 값 가져오기 : http://www.dev.re.kr/72

안드로이드 아닌 자바 코드상에서 서명 값 가져오기 : http://www.dev.re.kr/70

* 여담으로 얼마 전 같이 (동료로) 일했던 분이 앱 위변조 방지에 대한 요구사항을 위하여 서버의 API 를 직접 호출하는 부분을 C/C++ 로 짜고 빌드 하느라 삽질하고 있다는 이야기를 들었다. 시간 + 인력 빵빵한 프로젝트에서는 가능하겠지만 동시에 프로젝트 세 개를 진행하던 그분은 여러 사정 때문에 어쩔 수 없이 한 땀 한 땀 코딩하며 저녁도 못 먹고 매일매일 야근 릴레이를 펼치고 있다. 만약 그 프로젝트에서 누군가가 이런 어렵지 않은 방법을 알고 있었다면 그 분은 매일매일 지치는 야근을 피하지 않았을까 싶다.

NDK 를 이용하여 Signaiture (서명) 값 가져오기.

snoworca — Wed, 8 Apr 2015 18:40:55 +0900

앱의 위변조를 방지하기 위하여 서명 값을 가져와서 서버에 미리 등록된 값과 비교하는 과정이 필요하다.

하지만, 안드로이드 Java 코드상으로 제공되는 API 를 활용하는 것은 안전하지 못하다.

(안드로이드 자바 코드상에서 서명 값 가져오기 : http://www.dev.re.kr/70)

그렇기 때문에 JNI 를 활용해야 한다. context 를 인자값으로 받아서 jni 에서 제공되는 리플렉션을 사용하여 SHA1 으로 변환된 서명 값을 가져오는 코드를 첨부한다.

주의할 점은 아래 코드는 C++ 로 작성되었기 때문에 C 에서 사용하려면 약간의 수정이 필요하다.

이를테면

env->GetObjectClass(context);

를 C로 표현 하려면 

(*env)->GetObjectClass(env, context);

로 변환해야 한다.

스크롤바 때문에 코드를 보기 불편할 수 있으므로 파일도 추가한다.

getSignaiture.txt

// Context 를 인자값을 받아서 Signature 의 값을 얻는다.
char* getSignaiture(JNIEnv *env, jobject context) {
          jstring packageName;
          jobject packageManagerObj;
          jobject packageInfoObj;
          jclass contextClass =  env->GetObjectClass( context);
               jmethodID getPackageNameMid = env->GetMethodID( contextClass, "getPackageName", "()Ljava/lang/String;");
               jmethodID getPackageManager =  env->GetMethodID( contextClass, "getPackageManager", "()Landroid/content/pm/PackageManager;");

          jclass packageManagerClass = env->FindClass("android/content/pm/PackageManager");
               jmethodID getPackageInfo = env->GetMethodID( packageManagerClass, "getPackageInfo", "(Ljava/lang/String;I)Landroid/content/pm/PackageInfo;");

          jclass packageInfoClass = env->FindClass("android/content/pm/PackageInfo");
               jfieldID signaturesFid = env->GetFieldID( packageInfoClass, "signatures", "[Landroid/content/pm/Signature;");

          jclass signatureClass = env->FindClass("android/content/pm/Signature");
               jmethodID signatureToByteArrayMid = env->GetMethodID( signatureClass, "toByteArray", "()[B");

          jclass messageDigestClass = env->FindClass("java/security/MessageDigest");
               jmethodID messageDigestUpdateMid = env->GetMethodID( messageDigestClass, "update", "([B)V");
               jmethodID getMessageDigestInstanceMid  = env->GetStaticMethodID( messageDigestClass, "getInstance", "(Ljava/lang/String;)Ljava/security/MessageDigest;");
               jmethodID digestMid = env->GetMethodID( messageDigestClass,"digest", "()[B");

          jclass base64Class = env->FindClass("android/util/Base64");
               jmethodID encodeToStringMid = env->GetStaticMethodID( base64Class,"encodeToString", "([BI)Ljava/lang/String;");

          packageName =  (jstring)env->CallObjectMethod( context, getPackageNameMid);

          packageManagerObj = env->CallObjectMethod(context, getPackageManager);
          // PackageManager.GET_SIGNATURES = 0x40
          packageInfoObj = env->CallObjectMethod( packageManagerObj,getPackageInfo, packageName, 0x40);
          jobjectArray signatures = (jobjectArray)env->GetObjectField( packageInfoObj, signaturesFid);
          //int signatureLength =  env->GetArrayLength(signatures);
          jobject signatureObj = env->GetObjectArrayElement(signatures, 0);
          jobject messageDigestObj  = env->CallStaticObjectMethod(messageDigestClass, getMessageDigestInstanceMid, env->NewStringUTF("SHA1"));
          env->CallVoidMethod(messageDigestObj, messageDigestUpdateMid, env->CallObjectMethod( signatureObj,signatureToByteArrayMid));

          // Base64.DEFAULT = 0 그렇기 때문에 맨 마지막 인자값은 0이다.
          jstring signatureHash = (jstring)env->CallStaticObjectMethod( base64Class, encodeToStringMid,env->CallObjectMethod( messageDigestObj, digestMid, signatureObj), 0);

          return (char*)env->GetStringUTFChars(signatureHash,0);
}

안드로이드 APK 서명에 대하여 + java 코드상에서 APK 파일로부터 인증서 정보 가져오기.

snoworca — Wed, 25 Mar 2015 06:20:36 +0900

우선 안드로이드 APK 파일은 JAR 와 호환되는 형태로 되어있다. 즉, 코드를 빌드를 하여 나오는 APK 파일은 zip 포맷과 유사한 jar 와도 비슷하다. 특히 서명에 대한 방식은 JAR 와 APK 와 매우 비슷하다. 실제로 서명을 사용해 빌드된 APK 파일 확장명을 zip 으로 변경하고 압축을 풀어보면 META-INF 디렉토리 내부에 이와 관련한 파일이 생성된 것을 볼 수 있다.

이 파일은 MANIFEST.MF, CERT.SF, CERT.RSA 파일이다.

MANIFEST.MF 파일은 텍스트로 되어있으며 META-INF 디렉토리 내부의 파일을 제외한 APK 패키지 내부 모든 파일(Entry)에 대한 리스트를 보여준다. 각 리스트의 항목에는 파일 경로와 각 파일의 SHA1 해쉬 값(파일을 읽어서 만든다.)을 Base64 로 인코딩 하여 나타내고 있다.

CERT.SF 도 마찬가지로 텍스트로 되어있으며, MANIFEST.MF 파일과 구조가 비슷하다. 다만 MANIFEST.MF 에 등록된 각 파일에 대한 해쉬 값은 개인키(APK 빌드할 때 사용되는 인증서, 패스워드와 관련되어 있다고 생각하면 된다) 를 이용하여 SHA1 RSA 로 암호화 한 뒤에 Base64 로 인코딩 되어 있다. 또, MANIFEST.MF 파일 자체의 위변조를 막기 위하여 MANIFEST.MF 파일의 값도 포함되어 있다. 개인키로 암호화된 값들은 공개키로 복호화할 수 있다.

CERT.RSA 는 공개키 인증서이며 소유자, 발행자, 일련번호, 유효기간, 인증서 지문, 알고리즘등이 표시되어 있다. keeytool 을 이용하여 값을 확인할 수 있다.

안드로이드 APK 패키지 파일의 서명은 기존 JAVA 에서 제공하는 JAR 파일의 서명과 동일한 방식을 사용한다. 마찬가지로 APK 파일 설치시 JAVA 에서 기본적으로 제공하는 jar 서명 검증 관련 API 를 이용하여 APK 의 무결성을 확인한다. 실제 예를 들자면 Android 내부의 PackageParser 클래스에서도 JarFile 클래스를 이용하여 APK 파일을 열고 내부의 Entry(파일) 리스트를 받아와서 InputStream 을 통하여 파일을 읽는다. 이 과정에서 내부적으로 JarVerifier 클래스가 서명 정보를 확인한다. 서명 정보를 확인할 때, CERT.SF 내부의 암호화된 값들을 공개키를 이용하여 복호화 하고 MANIFEST.MF 의 파일 해쉬 값들과 비교한다. 또, 실제 파일의 SHA1 값들과 MANIFEST.MF 내부의 값들이 일치하는지 검사한다.(순서는 확인하지 못 하였다.)

이런 과정 덕분에 안드로이드 앱은 빌드시에 사용되는 인증서가 있지 않는한 위변조된 APK 파일은 원본과 구분될 수 있다. 즉, 원본 앱을 업데이트 하는 방식으로 위변조 APK 를 설치할 수 없다. (물론 인증서를 탈취하면 이야기가 달라진다.) 그렇다고 해서 악의적으로 위변조된 APK 파일에 대한 위협이 사라지는 것은 아니다. 만약 원본과 거의 비슷한 모양새로 만들어 빌드하고 다른 인증서로 배포하면 사용자 입장에서는 속아 넘어가서 설치하고 스미싱을 당하거나, 서버와 통신하는 클라이언트 앱의 경우 서버 공격에 대한 빌미를 줄 수 있다.

앱이 위변조 되었는지 확인하기 위하여 불가피하게 서버와의 통신이 필요하다. (이 내용은 지금 포스팅과 시리즈로 엮어서 다음 포스팅에서 다루겠다.) 서버로 APK 파일에 대한 고유 키 값을 보내줘야할 때, 인증서 정보(인증서 지문) 만큼 확실한 값은 없다.

우선 APK 파일을 압축을 풀면 나오는 META_INF/CERT.RSA 파일에 대한 인증 정보를 확인하는 방법은 다음과 같다.

keytool -printcert -file CERT.RSA

이 명령어를 실행하면 인증서 정보(인증서 지문, Certificate Fingerprint)를 얻을 수 있다.

안드로이드 코드상에서 얻는 방법은 다음과 같다.

Context context = getApplicationContext();
PackageManager pm = context.getPackageManager();
String packageName = context.getPackageName();
String cert = null;
try {
    PackageInfo packageInfo = packageInfo = pm.getPackageInfo(packageName, PackageManager.GET_SIGNATURES);
    Signature certSignature =  packageInfo.signatures[0];
    MessageDigest msgDigest = MessageDigest.getInstance("SHA1");
    msgDigest.update(certSignature.toByteArray());
    cert = Base64.encodeToString(msgDigest.digest(), Base64.DEFAULT);
} catch (PackageManager.NameNotFoundException e) {
    e.printStackTrace();
} catch (NoSuchAlgorithmException e) {
    e.printStackTrace();
}

위 코드에서 cert 변수에 이 앱을 빌드할 때 사용된 인증서의 정보 값이 들어간다. 이 값과 APK 파일의 CERT.RSA 파일로부터 'keytool -printcert -file CERT.RSA' 으로 얻은 값을 Base64 로 인코딩 하여 비교하면 동일함을 알 수 있다. 물론 해쉬 알고리즘을 SHA-256 또는 MD5 를 이용하여 요약해도 마찬가지다.

하지만, 서버나 외부에서 APK 파일의 인증서 정보 값을 얻을 때는 안드로이드 내부에서 얻는 코드를 이용할 수 없다.

그래서 다음과 같은 클래스를 만들어 보았다. APK 파일의 인증을 검증하는 과정도 포함되어 있으며 잘못된 인증 값을 갖고 있을 경우 예외를 발생시킨다.

테스트 완료 하였으며, 아마도 안드로이드 내부에서 다른 APK 파일 인증 정보를 읽어오는 것도 가능할 것이다.

(코드가 다소 길다. 읽기 쉽도록 소스 파일도 함께 첨부한다. )

APKCertExtractor.java

APKCertExtractor:

import java.io.IOException;
import java.io.InputStream;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.cert.Certificate;
import java.security.cert.CertificateEncodingException;
import java.util.Enumeration;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

import javax.xml.bind.DatatypeConverter;

import kr.re.dev.server.APKCertExtractor.APKCertExtractionException.ErrType;



/**
 * APKCertExtractor
 * 
 * - APK 파일내의 인증 정보를 SHA1, base64 로 만들어 반환한다.
 * - APK 파일의 유효성을 검사한다. 
 * - 2개 이상의 서명을 사용하는 APK 파일에 대하여 사용할 수 없다. 
 *   하지만, Play store 에서도 2개 이상의 서명을 갖고 있는 APK 를 허용하지 않는다.  
 *     
 * ::사용법
 *   - APKCertExtractor.execute(apk 파일 경로);
 *   - 인증 검증 실패시 APKCertExtractionException 예외 발생.
 *   
 * http://dev.re.kr
 */
public class APKCertExtractor {
	
	public static void main(String[] args) {
		String cert = "";
		try {
			cert = APKCertExtractor.execute( "test.apk");
		} catch (APKCertExtractionException e) {
			e.printStackTrace();
			cert = e.getMessage();
		}
		System.out.println(cert);
	}
	

	/**
	 * 인증서 지문을 반환한다. 
	 * @param apkFilePath APK 파일의 경로. 
	 * @return
	 * @throws APKCertExtractionException
	 */
	@SuppressWarnings("resource")
	public static String execute(String apkFilePath) throws APKCertExtractionException {
				
		try {
			// JarFile 클래스는 java.util.zip.ZipFile 를 상속받아 구현되었다.
			// jar 파일에 대한 설명은 다음 블로그 페이지에 자세히 소개되어 있다. 
			// http//www.yunsobi.com/blog/62
			// 이 클래스는 jar(zip) 의 엔트리(파일 정보) 및 파일을 읽기 위하여 사용된다.
			JarFile jarFile = new JarFile(apkFilePath);
			// APK 파일 내의 AndroidManifest.xml 의 엔트리와 인증 정보를 읽어온다.  
			JarEntry manifestEntry = jarFile.getJarEntry("AndroidManifest.xml");
			if(manifestEntry == null) 
				throw APKCertExtractionException.newInstance(ErrType.WrongAPKFormat, apkFilePath, null);
			
			Certificate[] certs = loadCertificates(jarFile, manifestEntry);
			if(certs == null || certs.length == 0) 
				throw APKCertExtractionException.newInstance(ErrType.WrongCert, manifestEntry.getName(), null);
			
			Certificate cert= certs[0];

			// APK 파일 내의 모든 엔트리의 인증을 검증한다.  
			verifCertificates(jarFile, cert);
			
			// 바이트 배열 타입의 인증 정보를 SHA1 Base64로 변환.
			String hash;
			try {
				hash = certToSHA1(cert);
			} catch (CertificateEncodingException e) {
				e.printStackTrace();
				// 인증서에 문제 있을 때 발생. 
				throw APKCertExtractionException.newInstance(ErrType.WrongCert, apkFilePath, e);
			}
			return hash;
			
		} 
		// 파일 경로등에 문제 있을 때 발생한다. 
		catch (IOException e) {
			throw APKCertExtractionException.newInstance(ErrType.ReadFail, apkFilePath, e);
		}
		 
	}
		
	/**
	 * APK 내부 파일의 인증을 확인한다.
	 * @param jarFile
	 * @param cert
	 */
	private static void verifCertificates(JarFile jarFile,Certificate cert) throws APKCertExtractionException {
		Enumeration<JarEntry> entries = jarFile.entries();
		
		while (entries.hasMoreElements()) {
			JarEntry jarEntry = (JarEntry) entries.nextElement();
			// 서명되지 않는 디렉토리인 META-INF 는 건너뛴다. 
			if (jarEntry.isDirectory() || jarEntry.getName().startsWith("META-INF/") || jarEntry.getName().contains(".DS_Store")) {
				continue;
			}			
			Certificate[] certs = null;
			certs = loadCertificates(jarFile, jarEntry);
			if(certs == null || certs.length == 0) 
				throw APKCertExtractionException.newInstance(ErrType.WrongCert, jarEntry.getName(), null);
			Certificate localCert = certs[0];
			// 인증 정보가 없는(서명이 되지 않은) 파일 발견. 
			// APK 압축을 풀고 임의의 파일을 넣거나 제거하여 다시 APK 파일로 압축했을 때 발생한다. 
			if (localCert == null) {				
				try { jarFile.close();} 
				catch (IOException e) { e.printStackTrace(); }
				throw APKCertExtractionException.newInstance(ErrType.ForgeryAPK, jarEntry.getName(), null);
			}  
			// 인증 정보가 서로 다른 엔트리 발견. 
			// 물론 설치는 안 되겠지만, 위변조 시도되는 앱으로 의심된다. 
			else if (!cert.equals(localCert)) { 
				try { jarFile.close();} 
				catch (IOException e) { e.printStackTrace(); }
				throw APKCertExtractionException.newInstance(ErrType.ForgeryAPK, jarEntry.getName(), null);
			}
		}
	}
	 
	 /**
	  * Certificates 객체를 반환한다.
	 * @throws APKCertExtractionException 
	  */
	private static java.security.cert.Certificate[] loadCertificates(JarFile jarFile, JarEntry jarEntry) throws APKCertExtractionException { 
		if(jarEntry == null || jarFile == null) return null;
		try {
			// JarEntry 로부터 Certificate 객체를 얻기 위해서는 JarEntry 를 검증하기 위하여 끝까지 다 읽어야 한다.
			// 이 과정에서 내부적으로 JarVerifier 클래스를 통하여 인증에 대한 검증이 이뤄어진다.
			byte[] buffer = new byte[1024];
			InputStream is = jarFile.getInputStream(jarEntry);
			 
			try {
				while (is.read(buffer, 0, buffer.length) != -1) {}
			// 테스트 결과 MATA-INF 폴더의 파일 내에 해당 엔트리의 인증값들은 있지만, 
			// 실제 파일이 존재하지 않을 경우 아래 예외가 발생한다.
			// 역시 위변조된 앱일 가능성이 크다. 
			// 물론 이 경우도 일반적인 안드로이드 폰에서는 설치조차 되지 않는다.
			} catch(SecurityException e) {
				throw APKCertExtractionException.newInstance(ErrType.ForgeryAPK, jarEntry.getName(), e);
			}
			is.close();
			buffer = null;
			return (java.security.cert.Certificate[])jarEntry.getCertificates();			
		} catch (IOException e) {
			System.err.println("Exception reading " + jarEntry.getName() + " in "
					+ jarFile.getName() + " " + e);
		}
		
		return null;
	}

	/**
	 * 서명 깂을 SHA1 해쉬로 변경하여 Base64 로 만든 String 값으로 반환한다. 
	 * @param cert
	 * @return
	 * @throws CertificateEncodingException 
	 */
	private static String certToSHA1(Certificate cert) throws CertificateEncodingException {
		byte[] certWith = null;
		// X509 인증 정보를 ASN.1 DER 구조의 byte 배열로 반환한다. 
		certWith = cert.getEncoded();
		MessageDigest md = null;
		try {
			// 인증 정보를 SHA1 해쉬로 변경. 
			md = MessageDigest.getInstance("SHA1");
			md.update(certWith);
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
		return DatatypeConverter.printBase64Binary(md.digest());

	}

	/**
	 * 인증서 추출 예외상황.
	 * @author ice3x2
	 */
	public static class APKCertExtractionException extends Exception {
		private static final long serialVersionUID = 6796836839897143903L;
		private ErrType mError;
		protected static APKCertExtractionException newInstance(ErrType errType, String path, Throwable throwable) {
			String message = ErrType.toMessage(errType) + " (" + path + ")";
			APKCertExtractionException apkCertExtractionException = 	
					(throwable == null)?new APKCertExtractionException(message):new APKCertExtractionException(message, throwable);
			apkCertExtractionException.mError = errType;
			return apkCertExtractionException;
		}
		
		private APKCertExtractionException(String message, Throwable throwable) {
			super(message, throwable);
		}
		private  APKCertExtractionException(String message) {
			super(message);
		}
		/**
		 * 에러 타입을 반환한다.
		 * @return
		 */
		public ErrType getError() {
			return mError;
		}
		public static enum ErrType {
			/**
			 * 잘못된 APK 파일 포맷.
			 */
			WrongAPKFormat("Wrong APK file format."),
			/**
			 * APK 파일을 읽을 수 없음. 
			 */
			ReadFail("APK file read failed."),
			/**
			 * 잘못된 인증서. 파일에 대한 인증 정보가 존재하지 않는다.
			 */
			WrongCert("Wrong certificate. Certificate verified failed."),
			/**
			 * 위변조가 의심되는 APK. 인증 정보 검증에 문제가 있다.
			 */
			ForgeryAPK("Wrong certificate. This package is suspected with forgery apk.");
			private String message;
			private ErrType(String value) {
				message = value;
			}
			protected static String toMessage(ErrType errType) {
				return errType.message;
			}
		}
	}
}

안드로이드 바이너리 XML 의 구조.

snoworca — Mon, 23 Mar 2015 00:12:46 +0900

APK 파일의 압축을 풀면 classes.dex 파일과 그리고 String 과 drawable 과 같은 리소스 맵핑 정보를 담고 있는 resources.arsc 파일등과 AndroidManifest.xml 파일 외에 res 폴더 내에 여러 XML 파일등이 존재한다. 하지만 이 XML 파일은 우리가 흔히 아는 형식으로 되어있지 않다.

왜 APK 파일 내부에 있는 AndroidManifast.xml 을 비롯한 XML 파일들은 우리가 알고 있는 XML 형식이 아닌걸까? 아마도 공간을 정약하고 런타임 환경에서 빨리 리소스 정보를 읽어들일 수 있도록 바이너리 타입으로 만들었을 것이다.

안드로이드에서 사용하는 바이너리 타입의 XML 포맷에 대하여 아래 사이트에서 자세하게 설명하고 있다.

https://justanapplication.wordpress.com/category/android/android-binary-xml/

위의 링크를 타고 들어가서 언급되는 내용을 보면 알겠지만, 안드로이드 바이너리 XML 의 구조는 잘 들여다보면 이해하기 쉽고 단순한 구조로 되어있다.

위 그림에서 나온 구조를 정리해 보자면...

1. Header

- 2byte. xml 바이너리의 사이즈를 담고 있다.

2. StringPool

- 0x08 위치부터 시작한다.

- XML 내부의 String 값들에 대한 배열을 갖고 있다. 외부에서 이 String 배열의 인덱스 값을 참고하여 접근한다.

3. XMLResouceMap

- 리소스 맵에 대한 정보를 갖고 있다.

4. Namespace - EndNamesapce

- Start 와 end 타입으로 분류된다.

- Start 와 End 사이에 있는 Element 들은 자식 노드(Element)가 된다.

5.Element

- 엘리먼트. 내부에 Attribute 에 대한 배열을 갖고 있다.
- NameSpace 와 마찬가지로 Start 와 End 타입으로 분류되고 그 사이에는 자식 노드(Element)가 들어간다.

와 같은 구조로 간단하게 되어있다.

중요한 점은 Namespace 와 Element 에 대한 Chunk 는 Start 와 End 값을 갖고 있으며 그 사이에 들어가는 값들은 자식 노드가 된다.

또, 각 data 들의 String 값은 integer 타입으로 되어 있는데, StringPool 내부의 String 배열에 대한 인덱스 값을 나타내기 때문이다. 즉 StringPool 의 배열로부터 인덱스 값을 이용하여 실제 String 데이터를 찾을 수 있다.

구조를 좀 더 확실하게 이해하기 위하여

https://justanapplication.wordpress.com/category/android/android-binary-xml/

에 나온 설명을 이용하여 파서를 만들어 보았다.

코드 주소 : https://github.com/ice3x2/AndroidXMLReader

퍼포먼스는 전~~~혀 고려하지 않고, 그냥 구조를 확인하기 위하여 코드만 작성했는데 정신차려보니 파서가 완성되어 있었다. ㅡ , , ㅡ;;

애초에 실제 구조만 확인하려고 만든 것이기 때문에 테스트 케이스 같은 것은 안중에도 없었다. 혹시나 버그가 있을지도 모르니 참고하기 바란다... (물론 앞으로 계속 개선하여 좀 쓸만한 모듈로 만들 생각이다;;)

어쨌든 이 코드는 안드로이드 APK 내부의 바이너리 타입 XML 구조를 확인하는데 여러분들께 큰 도움이 될 것 이다.

이 것을 이용하여 JAVA 코드 상에서 APK 내부의 AndroidManifest.XML 내용을 읽어오는 방법은 다음과 같다.

AndroidXML androidXML = AndroidXMLReader.readAndroidManifest("test.apk");
			Element rootElement =  androidXML.getRootElement();
			
String packageName = rootElement.findAttribute("package")[0].getValue();
String versionName = rootElement.findAttribute("versionName")[0].getValue();
String versionCode = rootElement.findAttribute("versionCode")[0].getValue();
Element[] userPermissions = rootElement.findElements("uses-permission");
			
System.out.println("Package : " + packageName);
System.out.println("Version name : " + versionName);
System.out.println("Version code : " + versionCode);
System.out.println("uses-permission");
for(Element element : userPermissions) {
	Attribute attribute = element.getAttribute(0);
	System.out.println("\t" + attribute.getName() + " : " + attribute.getValue());
}

이 시리즈의 다음 포스팅에선 resources.arsc 의 내부 구조와 파싱 방법에 대하여 알아보겠다.

Android NDK, JNI 내부에서 HTTP 통신 사용하기.

snoworca — Fri, 20 Mar 2015 01:11:54 +0900

지난 포스팅 :

- 안드로이드 스튜디오에서 NDK 로 C++ 빌드하기 (Hello World 예제)

이번시간에는 NDK 를 이용하여 HTTP 통신하는 법을 알아보겠다.

C/C++ 에서 HTTP 를 통신하기 위한 가장 흔한(?) 방법은 curl 을 사용하는 것이다.

그러기 위해서 curl 라이브러리를 android 에서 동작 하도록 컴파일 해야 하는데, 이는 삽질을 동반한 작업들을 해야만 한다.

그래서 이미 빌드된 정적 라이브러리를 사용하는 효율적이고 빠른 방법에 대하여 알아보겠다.

우선 android 용으로 각각의 CPU 별로 깔끔하게 빌드된 정적 라이브러리(.a) 파일을 구해야 한다.

빌드된 curl 을 구하기 위하여 github 와 구글을 한참 검색해 보다가 문득 cocos2d-x 에서 curl 을 사용하던 것을 떠올렸다.

그리하여 cocos2d-x 의 최신버전 패키지를 다운 받고, 아주 이쁘게 빌드된 정적 라이브러리를 얻는데 성공 하였다.

그 과정은 다음과 같다.

- cocos2d-x 다운로드. http://www.cocos2d-x.org/download

- 압축을 풀고 external/curl/prebuilt/android 폴더에 있는 디렉토리와 external/curl/include 에 있는 파일들을 한 곳에 모은다.

- external/curl/prebuilt/ 의 Android.mk 파일의 내용을 현재 프로잭트의 경로에 맞게 수정하여 프로젝트 jni 폴더의 Android.mk 에 복사한다.

주의! 현재까지는 cocos2d-x 내부에서 armeabi, armeabi-v7a, x86, 이 세가지만 빌드되어 있다. 만약 x86_64 옵션을 사용하여 NDK 를 빌드한다면 오류가 발생한다. 너무 당연한 이야기지만 64 비트 호환 CPU 를 쓰는 안드로이드 디바이스 에서도 x86 이나 armeabi 옵션만 주고 빌드한 라이브러리 파일도 모두 읽을 수 있으니 안심하자.

여기까지가 cocos2d-x 에서 미리 빌드된 curl 정적 라이브러리를 얻는 과정이다. 이렇게만 써 놓으면 다소 복잡해 보일 수 있으니 이제부터 예제와 함께 설명하겠다.

1. 우선 cocos2d-x 에서 가져온 미리 빌드된 curl 정적 라이브러리와 헤더를 압축한 아래의 파일을 다운로드 받는다.

curl.zip

(위 아이콘을 클릭하여 다운받는다,)

2. jni 폴더 내부에 curl 폴더를 만들고 그 안에 방금 다운 받은 파일을 압축 풀어서 붙여넣는다.

3. Android.mk 파일 상단에 다음과 같은 라인을 추가한다.

LOCAL_PATH := $(call my-dir)                

# --------------- crypto ---------------
include $(CLEAR_VARS)
LOCAL_MODULE := crypto
LOCAL_MODULE_FILENAME := crypto
LOCAL_SRC_FILES := curl/$(TARGET_ARCH_ABI)/libcrypto.a
LOCAL_EXPORT_LDLIBS := -lz
include $(PREBUILT_STATIC_LIBRARY)

# --------------- ssl ---------------
LOCAL_MODULE := ssl
LOCAL_MODULE_FILENAME := ssl
LOCAL_SRC_FILES := curl/$(TARGET_ARCH_ABI)/libssl.a
include $(PREBUILT_STATIC_LIBRARY)

# --------------- libcurl ---------------
include $(CLEAR_VARS)
LOCAL_MODULE := curl
LOCAL_MODULE_FILENAME := curl
LOCAL_SRC_FILES := curl/$(TARGET_ARCH_ABI)/libcurl.a
LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/curl/include
LOCAL_STATIC_LIBRARIES += ssl
LOCAL_STATIC_LIBRARIES += crypto
include $(PREBUILT_STATIC_LIBRARY)

# --------------- your options ---------------

# ...

LOCAL_STATIC_LIBRARIES := curl

# ...

3. 마지막으로 curl 을 사용하려는 C/C++ 소스파일에 #include <curl/curl.h> 으로 include 해주면 된다.

http 통신을 하기 위한 libcurl 의 사용법은 예제 페이지(http://curl.haxx.se/libcurl/c/example.html)를 참고하거나, 구글링으로 쉽게 찾을 수 있다. (이 것은 시간이 나면 따로 정리하겠다.)

아래는 http 통신 예제 코드이며, 예제 프로젝트를 다운받으면 직접 실행해 볼 수 있다.

#include <curl/curl.h>
#include <iostream>

// Curl 의 Response 처리.
size_t responseWriter(char *data, size_t length, size_t bytes, std::string *writerData) {
	if (writerData == NULL)
		return 0;
	long size = length * bytes;
	writerData->append(data,size);
	return size;
}

JNIEXPORT jstring JNICALL Java_kr_re_dev_NdkHttpExample_MainActivity_getHTML(JNIEnv *env, jobject obj, jstring url) {
    CURL *curl;
    CURLcode res;
    std::string response;
    const char *addr = env->GetStringUTFChars(url, 0);
    curl = curl_easy_init();
    if(curl) {
        curl_easy_setopt(curl, CURLOPT_URL, addr);

        // 웹서버에서 모바일 접속으로 인식할 수 있도록 임의의 User Agent 값을 넣었다.
        curl_easy_setopt(curl, CURLOPT_USERAGENT,
        "Mozilla/5.0 (Linux; Android 4.4.2; Nexus 5 Build/KOT49H) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/32.0.1700.99 Mobile Safari/537.36");

        // SSL 관련 옵션.
        // 3번째 인자값이 0일 경우 인증서 진위 여부에 상관 없이 접속. 기본값 1.
        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
        // 3번째 인자 값이 0일 경우 인증서 이름에 상관없이 접속. 기본값 2.
        curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);

        // redirecte 사용.
        curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);

        // post 전송시 사용.
        //curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "name=daniel&project=curl");

        // response 의 response 를 처리하는 함수 설정.
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, responseWriter);
        // 세 번째 인자에는 responseWriter 함수로 처리될 response 객체의 레퍼런스가 들어간다.
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);

        res = curl_easy_perform(curl);
        // 실패할 경우 메세지 출력.
        if(res != CURLE_OK) {
            response = curl_easy_strerror(res);
        }
        curl_easy_cleanup(curl);
    }
    return env->NewStringUTF(response.c_str());
}

참고용 예제 프로젝트.

NDKHttpExample.zip

안드로이드 스튜디오에서 NDK 로 C++ 빌드하기 (Hello World 예제)

snoworca — Thu, 19 Mar 2015 11:30:14 +0900

아래 내용은 mac 기준으로 작성 되었습니다.

1. 안드로이드 개발자 사이트에서 NDK 를 받아야 하지만, STL 과 Boost 를 사용하기 위해서 별도의 작업을 더 해야한다.

하지만, CrystaX 를 사용하면 쉽게 적용할 수 있다. 아래 사이트에서 최신 버전의 CrystaX 를 다운받고 압축을 푼다.

용량이 큰 것으로 받는다. 압축을 풀면 5GB 가 넘는다...

https://www.crystax.net/en/download

2. 프로젝트를 생성한다.

3. 프로젝트의 app/src/main 폴더 안에 jni 폴더를 생성한다.

4. 아래 과정은 최초 한 번만 진행하면 된다.

(아래 내용은 http://blog.burt.pe.kr/ 에서 참고하였습니다.)

- javah 설정하기.

(1) AndroidStudio -> Preferences 에서 External Tools 를 검색.

(2) External Tools 메뉴 좌측 하단의 + 버튼을 누른다. Edit Tool 다이얼로그 창이 출력된다.

(3) 모든 체크 박스를 체크하고, 각 입력창에 다음과 같이 적는다.

Name : javah Group : NDK

Description : javah

(모든 체크박스 체크)

Program : /usr/bin/javah (javah 의 실행 경로를 넣는다.)

Parameters : -classpath $Classpath$ -v -jni $FileClass$

Working directory : $SourcepathEntry$/../jni

OK 버튼 클릭.

- ndk-build 설정하기. 마찬가지로 위 과정의 (1)(2)(3) 번을 반복하고, 출력되는 Edit Tool 다이얼로그 창에 다음과 같이 적는다.

Name : ndk-build Group : NDK

Description : ndk-build

(모든 체크박스 체크)

Program : (1번 과정에서 받은 crystax 의 경로)/ndk-build

Parameters : (공란)

Working directory : $ProjectFileDir$/app/src/main

OK 버튼 클릭.

ndk-build 는 AndroidStudio -> Preferences 의 keymap 에서 단축키를 설정하면 편하게 사용할 수 있다.

- 위와 똑같은 방법으로 ndk-build clean 을 만들어 준다.

Name 항목을 ndk-build clean , Parameters 항목에 clean 을 추가해 주고 나머지는 위 ndk-build 설정과 동일하게 입력.

Name : ndk-build clean Group : NDK

Description : ndk-build clean

(모든 체크박스 체크)

Program : (1번 과정에서 받은 crystax 의 경로)/ndk-build

Parameters : clean

Working directory : $ProjectFileDir$/app/src/main

OK 버튼 클릭.

5. 다음과 같은 클래스를 생성한다.

HelloNDK.java :

public class HelloNDK {
    static {
        System.loadLibrary("hello");
    }
    public native String getHelloNDKString();
}

안드로이드 자바코드에서 NDK 라이브러리 사용을 위하여 build.gradle 파일을 다음과 같이 편집한다.

HelloNDK 클래스에 System.loadLibrary 메소드를 통하여 입력한 모듈 이름을 moduleName 에 동일하게 입력해야 한다.

build.gradle:

android {
    //...생략

    defaultConfig {
       //...생략
        ndk {
            moduleName "hello"
        }

        sourceSets.main {
            jni.srcDirs = [] 
            jniLibs.srcDir 'src/main/libs'
        }

    }

clean 또는 cmd + F9 (윈도우에서는 control + F9) 를 통하여 빌드한다.

6. 앞의 4번의 과정을 정상적으로 진행하였다면 HelloNDK 클래스를 선택하고 마우스 오른쪽 버튼을 눌렀을 때 아래와 같이 나온다.

(아래 스샷에서는 ndk-build clean 항목이 실수에 의해서 빠져있다. 참고바람) 메뉴 박스에서 NDK->javah 를 선택한다.

Run 콘솔 창에 다음과 같은 결과가 출력된다.

만약 5번 과정에서 빌드를 하지 않았다면 에러가 출력될 것이다.

src/main/jni 폴더에 JNI 인터페이스 파일이 생성된 것을 확인할 수 있다.

7. jni 폴더에 HelloNDK.cpp , Android.mk, Application.mk 파일을 만들어 준다.

9. HelloNDK.cpp 파일을 다음과 같이 편집 한다.

javah 를 통하여 자동으로 생성되었던 kr_re_dev_hellondk_HellpNDK.h 파일을 include 하고,

그 곳에 정의된 함수를 구현한다.

JNIEnv 클래스에 대한 설명은 다음 포스팅에서 자세히 다루겠다.

HelloNDK.cpp:

#include "kr_re_dev_hellondk_HelloNDK.h"

JNIEXPORT jstring JNICALL Java_kr_re_dev_hellondk_HelloNDK_getHelloNDKString
(JNIEnv *env, jobject obj) {

     jstring str =  (*env).NewStringUTF("Hello World!!!");
     return str;
}

9. Android.mk 파일을 다음과 같이 편집.

LOCAL_SRC_FILES 변수를 통하여 컴파일될 파일의 경로를 정해준다.

Android.mk:

LOCAL_PATH := $(call my-dir) # 현재 파일의 설정된 경로. include $(CLEAR_VARS) # LOCAL 관련 변수를 clear LOCAL_MODULE := hello # 모듈 이름, 생성되는 파일 이름을 결정. LOCAL_CFLAGS += -std=c++14 # 컴파일 플래그. 여기서는 c++14 사용. LOCAL_SRC_FILES := HelloNDK.cpp # 컴파일 되는 파일 리스트. include $(BUILD_SHARED_LIBRARY) # 동적 라이브러리로 사용. # 현재 사용하지 않는 것들은 주석처리. #LOCAL_CPP_EXTENSION := .cpp # c++ 소스의 확장자 정의, 기본 cpp. # 임의 변경 가능 #LOCAL_C_INCLUDES := # 헤더 파일의 include 경로. #LOCAL_LDLIBS := # 연결하고자 하는 링크 옵션 #LOCAL_STATIC_LIBRARIES # 링크할 정적 라이브러리 #LOCAL_SHARED_LIBRARIES # 링크할 정적 라이브러리 #include $(BUILD_STATIC_LIBRARY) # 정적 라이브러리로 사용

Application.mk:


# 모듈 이름.

APP_MODULES := hello

# 플랫폼 설정

# ANDROID_PLATFORM := android-9

# all 로 설정하면 안드로이드에서 사용되는 모든 종류의 cpu 로 빌드.

# 앱과 디바이스 특성별로 설정해 주는 것이 좋다. 

APP_ABI := all #arm64-v8a armeabi armeabi-v7a mips x86 x86_64

10. 이제 NDK 파일을 빌드한다. 앞서 4번 항목에서 정의한 ndk-build 기능에 단축키를 정의해 놓으면 필요한 순간마다 편리하게 빌드할 수 있다.

정상적으로 빌드 되었을 때 콘솔에 출력되는 결과는 다음과 같다.

또한 /src/main/libs 경로에 각 cpu 타입별로 빌드된 동적 라이브러리가 생성된다.

c++14 로 빌드할 경우 gnu stl 라이브러리가 기본적으로 포함되는데 용량이 1.1Mb 로 후덜덜 하다. (boost까지 추가한다면.... )

그렇기 때문에 실제 배포시 Application.mk 파일에서 안드로이드 디바이스에서 주로 사용되는 CPU로 빌드하도록 설정하여 용량을 줄이자.

특별한 기능 없다면 아래와 같이

APP_ABI := armeabi-v7a

만 사용 하거나, x86 애뮬레이터 사용시 자신의 PC 환경에 따라서 x86 이나 x86_64 를 추가할 수 있다.

11. 이제 빌드된 NDK 라이브러리인 hello 모듈을 사용해보자.

지금까지의 여러 단계의 설정 방법에 비하여 사용방법은 매우 간단하다.

native 로 선언되고 c++ 함수와 연결된 메소드만 호출해주면 된다.

지금까지 만든 NDK 모듈의 동작 여부를 간단하게 확인하기 위하여 Activity 클래스의 onCreate 이벤트 메소드에 다음과 같은 코드를 추가하였다. getHelloNDKString 으로 부터 가져온 스트링 값을 토스트로 출력하도록 하였다.

  @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Context context = getApplicationContext();
        HelloNDK helloNDK = new HelloNDK();
        Toast.makeText(context, helloNDK.getHelloNDKString(), Toast.LENGTH_LONG).show();
    }

결과

맥미니 쿨러 직접 교체하기.

snoworca — Mon, 16 Feb 2015 12:01:59 +0900

컴퓨터를 거의 24시간 내내 틀어놓고 살아가는데, 얼마 전부터 조용하던 팬이 공사장 중장비와 닮은 소리를 내기 시작했다. 낮에는 그러려니 하고 소리를 참을 수 있었지만, 밤에는 무시무시한 쿨러 소음 덕분에 좀처럼 잠을 이룰 수 없었다. 슬립 모드로 해놓아도 이따금 돌아가는 쿨러 소리에 잠을 깰때가 많았고, 결국 잠들기 전에 컴퓨터를 끄고 아침에 일어나서 다시 켜야 하는 귀찮은 작업을 반복하다가 결국 수리를 맡기려다 생각보다 비싼 비용에 질겁하여 직접 수리를 하기로 하였다.

우선 맥미니용 쿨러를 구해야 하는데, 국내에서 구하기란 쉽지 않고 역시 우리의 '알리 익스프레스' 를 이용하기로 했다. 배송은 운이 좋아 2주밖에 안 걸렸다.

이 정도면 칭찬해줘도 괜찮을듯한 가격이다. (주의할 점은 너무 싸거나 판매자 등급이 낮으면 짭퉁이나 불량을 판매하는 것일 수도 있으니 주의할 것!! 비상식적으로 싼 물건은 피하자.)

바다 건너 2주만에 도착한 쿨러.

맥 미니 뚜껑을 열어보았다.

저 빨간색 동그라미가 되어 있는 나사만 제거하면 된다.

우선 나사를 제거하기 전에 고무 캡을 빼야 한다.

연두색 동그라미 부분의 나사는 제거할 필요 없다.

이 부분은 나사로 완전히 고정된 것이 아니라 고무링으로만 쉽게 빠지지 않게만 되어 있는데,

아마도 진동 방지를 위하여 이렇게 하지 않았을까 하는 생각이 든다.

특이하게도 별 모양의 렌치를 사용하여 나사를 풀 수 있도록 하였다.

별 모양의 렌치는 없으므로 롱노우즈 플라이어를 이용하여 나사를 풀었다.

머리 부분을 있는 힘껏 잡은 다음에 돌리면 쉽게 풀린다. 단, 너무 힘을 줘서 실수로 주변 부품을 망가뜨리지 않도록 주의하자.

(롱노우즈 플라이어가 없으면 니퍼나 비슷한 것도 괜찮다.)

이렇게 나사 두 개를 제거하고 나머지 풀지 않은 나사 부분에 힘을 살짝 줘서 쿨러를 위로 들면 빠진다.

케이블을 제거한다.

그냥 위로 들면 쑥~ 빠진다.

케이블 연결도 마찬가지로 방향과 모양 맞춰서 위로 넣으면 들어간다.

쿨러가 완전히 제거된 모습.

그동안 쌓인 먼지들을 깔끔하게 제거하였다.

새 쿨러로 교체한 모습. 조립은 분해의 역순으로 하면 된다.

먼저 케이블을 결합한다. 커넥터는 방향과 모양을 맞춰서 그냥 위에서 누르면 들어간다.

(이 과정에서 혹시 조립 도중에 케이블이 빠질까 봐 마스킹 테잎을 작게 잘라서 커넥터 위에 붙였다. 쿨러 우측 상단에 흰색 종이 같이 보이는 부분.)

그리고 쿨러를 제 위치에 놓아야 하는데 위 사진의 연두색 동그라미 친 부분에 튀어나온 나사 머리에 구멍을 잘 맞춰서 끼운다. 마지막으로 나사를 꽉 조여주고 나사를 풀어주기 전에 제거했었던 고무캡을 다시 끼워주면 완료!

이제 전원을 넣어주고 쿨러가 돌아가는 것을 확인해 보자.

쿨러를 교체하고나서 아무 소리도 안 나길래 불안한 마음에 Macs Fan Control 이라는 앱을 이용하여 현재 RPM 을 확인해 보았다. 2000~3000RPM 대에서는 마치 쿨러가 고장난 것 처럼 아무 소리가 나지 않다가 임의로 5500RPM 으로 올려주면 이제야 좀 시끄러운 소리가 났다.

소음도 잡고 돈도 굳고 대만족.

프루사 멘델 i3 3D 프린터 구입, 조립기.

snoworca — Mon, 17 Nov 2014 15:16:59 +0900

알리 익스프레스에서 3D 프린터를 구매하였다.

처음에는 옥션에서 판매하는 프린터봇을 구매하려고 했는데, 아무래도 수리를 하거나 업그레이드를 위한 파트를 교체하는 데 어려움이 있을 것 같고 인쇄물 크기가 만족스럽지 않아서 이런 험난한 길- 푸르사 멘델 조립-을 선택하게 되었다.

우선 제품의 신뢰성을 검증하기 위하여 상품평을 찾아보는데, 여러 나라에서 구매한 사용자들이 꽤 많은 피드백을 남겨 놓았고 그 것들을 종합해보면 다음과 같았다.

- 배송 빠르다.

- 베어링이 뻑뻑하다.

- 안 맞는 부폼이 조금 있다.

- 같이 제공되는 조립 설명 동영상은 중국어다. 하지만 보면서 쉽게 따라 할 수 있다.

- 그래도 좋다.

전반적인 상품 피드백을 보면 프린터 조립에 어느 정도 수준 이상의 난이도가 필요하다는 것을 알 수 있었지만, 전반적으로 평이 좋으므로 의심 없이 구매하였다.

배송은 Fedex 를 통해서 이루어졌는데, 물품 구입후 5일만에 받을 수 있었다.

하지만 세금이...

아... 앙대....

결국 우리돈으로 총 47만 5천원정도를 쓰게 되었다.

Fedex 를 통하여 회사로 배달시킨 3D 프린터. 무게는 대략 15kg 되는 것 같았다. 회사는 강남에 있고 집은 광명에 있는데, 이것을 들고 오기 위하여 계단이 많은 지하철 대신 2시간 동안 버스를 타고 왔다.

박사를 개봉한모습. 나름 완충재가 잘 되어있다.

좌측의 두 개의 박스에 PLA 필라멘트가 들어있다.

번들 PLA 필라멘트.

내 기준에서 가장 촌스러운 색 두 개로 잘 골라줬다.ㅎㅎㅎ

첫 번째 부품 박스 개봉!!

많은 부품들을 접한 순간 나도 모르게 '헉!'하는 나지막한 탄성이 입 밖으로 새어나왔다.

배송하는 과정에서 이 무거운 것이 이리저리 굴러다닌 듯하다.

그래도 완충재의 두께가 빵빵한 편이라서 다친 부품은 없었다.

첫 번째 부품박스를 꺼내면 두 번째 부품 박스가 등장한다.

이것을 열면 이렇게 에어캡으로 포장되어있는 볼트 너트와 함께 육각렌치와 같은 공구류 등이 등장한다.

가장 아래 부품박스에는 아크릴 프레임 부품과 히트베드, 그리고 히트베드 위에 올려서 사용하는 유리판이 들어있다. 참고로 저 히트베드는 온도가 그다지 높이 올라가지 않는다. 온도를 최대로 올렸을 때 70도에서 80도 사이를 왔다 갔다 한다.아크릴 파트들은 조립 시 분홍색으로 된 반투명 보호지를 뜯어야 하므로 불편하다. (심지어 히트베드에 케이블을 연결할 때는 납땜질을 해야 한다.)

같이 들어있는 조립 공구들.

육각렌치가 가장 많이 쓰이며 줄자는 거의 쓰이지 않는다.

핀셋은 인쇄하는 과정에서 많이 쓰인다.

이제, 동봉된 DVD 의 동영상 자료와 PDF 파일과 그림 등을 보며 조립을 시작하는데, 동영상과 Repretier Host 설정 관련 메뉴얼만 중국어로 되어있다. 그나마 동영상은 보고 따라만 하면 되기 때문에 언어가 중국어라도 이해하는 데는 문제없다. 다만, Y 축(히트베드가 올라는 곳) 에 벨트를 연결하는 것에 대한 설명과 일부 순서가 바뀌었는데 이는 PDF로 되어있는 조립 설명서를 참고하면 된다.

조립 첫째 날. 퇴근 후 밥을 먹으면 취침시간까지 남은 시간은 거의 3시간밖에 없으므로 조립 진도가 매우 더디었다.

아크릴 부품은 이런 식으로 연결한다. 나름대로 튼튼해 보인다.

X좌표 우측을 담당하는 부품이다. Z 축 이동을 위한 볼 베어링이 포함되어 있는데, 레일 역할을 하는 쇠막대기가 들어간다. 이 녀석은 뽑기 운이 상당히 필요한 놈으로 본인 같은 경우에는 레일(쇠막대기) 를 베어링의 구멍에 끼우는 과정에서 3개의 볼이 빠져버렸다. ㅡ , ㅡa 게다가 많이 뻑뻑해서 기름칠을 여러번 해줘야만 했다.

조립 둘째 날. Z 축을 담당하는 모터를 달고, Y 축이 완성되었다. 그리고 노즐이 달린 모듈이 완성되었다.

노즐 모듈에서 부품 나사 구멍이 조금 어긋나는 곳이 한 곳 있어서 고생 좀 했다. 힘으로 해결했다가 아크릴이 뒤틀리는 것을 보고 억지로 끼워맞춘 나사를 제거해 버리고 나머지 구멍의 나사들을 육각렌치로 있는 힘껏 조여서 안정적으로 고정시켰다. 참, 나사를 유각렌치로 있는 힘껏 조이면 렌치가 들어가는 육각형 모양의 홈이 원으로 바뀐다;;;

그리고, 위 사진에서 Z 축의 모터가 잘못 연결 되었는데, (나중에 다시 연결하였다.) 모터 한쪽은 역방향 모터(케이블 색상 배치가 다르다.) 를 연결 해야 한다.

조립 세째날. 이제 어느정도 3D 프린터의 모습을 갖추기 시작했다.

다만...

Z축 레일 봉을 볼트 너트와 육각렌치로 고정하는데 힘을 너무주면 위 사진과 같이 아크릴이 부러져 버린다. ㅡ,ㅡ;

그렇다고 살살 조이면 구리스가 잘 발라져 있는 레일 봉이 불완전하게 고정된다. 결국 부러진 곳과 위태위태하게 고정된 Z축 레일 봉을 글루건으로 붙여버렸다.

이제 마지막으로 제어 모듈을 연결할 차례다.

제어 모듈은 atmega2560 을 사용한다. Z 축 모터 두 개중에 한 개는 외부 드라이버 모듈을 통하여 연결해야 한다. 참고로 설명서에는 이미 테스트가 끝난상태니, + 와 - 를 잘못 연결해서 망가지면 소비자 책임이라 한다.(돈 내고 메인보드 바꿔야 한다.)

크고 아름다운 LCD 모듈. 여기에는 SD 카드 사용률과 히트베드와 노즐의 온도, 현재 작업등이 표시된다.

껍데기 없이 케이블 두 개에 대롱대롱 매달려 있는 형태기 때문에 나중에 케이스나 거치대를 따로 뽑아서 붙이는 것이 좋을 것 같다.

380W 파워 서플라이 연결 단자.

전선의 피복을 벗겨서 이 곳에 연결해야 한다. - 같이 동봉된 DVD 내의 설명서에 연결 방법이 잘 나와 있다 -

폭탄 같은 전기세를 생각하면 좀 어질어질.

연결중.

복잡한 케이블을 정리할 수 있는 도구들도 같이 제공된다.

마지막으로 Home 위치를 인식하기 위한 스위치를 붙임으로써 조립을 완료하였다.

케이블 연결을 완료한 뒤에 Repetier Host 를 설치한 모습. 아쉽게도 MAC 버전은 최신 업데이트가 안 된다. 윈도우와 리눅스 버전만 제대로 제공되는 듯. ㅠ_ㅠ

다 완성된 상태에서 PC 와 연결후 Home 위치를 맞추는 과정.

첫 번째로 thingiverse.com 에서 다운받은 핸드폰 거치대를 뽑고 있다.

하지만, 서포트를 설정하지 않았다.

결국....

서포트 기능을 사용하지 않고 인쇄를 시도하다 위 사진과 같이 망했다.

혹시나 했는데, 역시나...

두 번째로 아이패드 거치대를 뽑아보았다. (바닥에는 마스킹테잎 + 양면테잎 신공을 사용하여 PLA 출력물이 잘 고정될 수 있도록 하였다.)

무려 3시간 30분이 걸렸다.

아직은 문제가 많지만, 점점 만족스러워지고 있다.

도 3D 프린터의 최대 단점 중에 하나가 후처리가 번거롭다는 점이다. 이 결과물도 마찬가지로 지저분한 부분을 정리해주고 서포트를 제거한 다음 사포로 문질러야 한다.

아래 사진은 가장 최근에 뽑은 네스프레소 디스펜서.

총 6시간이 걸렸다.

비교적 깔끔하게 출력된 것 같으나 정리해야 될 부분이 많이 보인다.

정리가 끝난 뒤에 회사 사무실 탕비실에 바로 설치해 보았다.

3D 프린터 Prusa i3 를 사용하기 전에는 정교한 결과물에 대한 기대감이 높았는데, 출력 시간도 매우 오래 걸리고 인쇄 속도를 조금만이라도 빠르게 한다면 출력물의 질을 장담할 수 없다.(시간이 많다면 높은 퀄리티의 결과물을 기대할 수 있다.) 그리고 가장 귀찮은 후처리가 문제다. 하지만 직접 모델링을 할 수 있다는 전제하에

3D 프린터를 잘 이용한다면 세상에 없는 어떤 것을 만들 수 있지 않을까?

추가 :

내용물을 뽑기 전에 Slic3R 에서 레이어의 높이를 0.25 로 조정하고 인쇄속도를 조금 낮춰보았다. 또, Z 축의 기준 위치(Home) 을 정할 때, 노즐이 베드에 최대한 가까이 붙게 하였다.

결과는...

바닥까지 정말 깔끔하게 잘 나왔다. 느림의 미학이란 바로 이런 것인가보다...;;;

[API] 안드로이드 디렉토리와 파일 모니터링(감시) 를 위한 FileObserver.

snoworca — Wed, 29 Oct 2014 19:21:47 +0900

FileObserver

안드로이드에서 제공하는 파일 모니터링을 위한 API 인 FileObserver 에 대하여 알아보겠다.

FileObserver 는 안드로이드 내부에 접근할 수 있는 각각의 파일과 디렉토리의 접근이나 변경에 대한 이벤트를 비동기적으로 받아올 수 있다.

이 클래스는 리눅스 커널에서 제공하는 파일 감시 모듈인 inotify (클릭시 위키로 이동) 의 네이티브 API 들을 JNI 를 통해서 호출한다. FileObserver 를 사용하면 내부적으로 쓰레드 하나가 (static 으로)생성된다.

우선 기본 사용법에 대하여 알아보자.

(참고 페이지 - 안드로이드 레퍼런스 : http://developer.android.com/reference/android/os/FileObserver.html)

기본 사용법:

/**
  * FileObserver 는 추상 클래스로 선언되어 있으므로 반드시 상속받아 사용해야 한다.
  */
FileObserver fileObserver = new FileObserver(/* 감시할 디렉토리 또는 파일 경로, 예 :

                                                                   Environment.getExternalStorageDirectory().getAbsolutePath()*/) {
	@Override
	public void onEvent(int event, String path) {
		// event 값. 아래서 다루겠습니다.
		// path : 이 fileObserver 에 등록된 Path 와 관계있는 파일 또는 폴더의 path 값.  
		// 예를 들어 특정 디렉토리를 감시하는 경우에서
                //  그 내부의 파일 또는 디렉토리가 변경되었을때 path 값이 온다. 
		// 이 FileObserver에 등록된 파일에 대한 이벤트가 발생하였을 때, null 을 반환한다. 
              // 즉, 이 곳에 등록된 path 에대한 이벤트가 발생했을 때 path 값이 null 로 반환.   
    }
};
/**
 * 이 메소드를 호출하면 파일 또는 디렉토리 감시를 시작하며 이벤트를 받는다.
 * 만약 이미 감시중이거나 파일 또는 디렉토리가 존재하지 않을경우 이 메소드 호출은 무효가 된다.
 */
fileObserver.startWatching();
		
/**
 * 파일 또는 디렉토리의 감시를 종료하고 이벤트를 받고 싶지 않을 때, 다음 메소드를 호출한다.
 * fileObserver.stopWatching(); 
 */

FileObserver 를 사용하면서 주의해야 할 점은, FileObserver 가 GC 가 된다면 모든 파일 감시 이벤트를 보내는 것을 종료한다. 이벤트 수신을 보장받게 하려면 반드시 FileObserver 를 항상 살아있도록 만들어야 한다.

FileObserver 로 받을 수 있는 이벤트 타입들은 다음과 같다. - 이 값들은 onEvent() 메소드의 인자값으로 받는다 -

Constants
int	ACCESS	파일로 부터 데이터를 읽었을 때 발생하는 이벤트 타입.
int	ALL_EVENTS	모든 이벤트 타입이 포함되어 있다. 모든 이벤트 타입은 각각 2진수의 각 자리수 하나씩을 차지하고 있고, ALL_EVENTS 는 마스크 역할을 한다. 예를들어 FileObserver 를 생성할 때, 두 번째 인자값으로 이벤트 타입 값을 넣어서 원하는 이벤트만 받을 수 있도록 필터링을 할 수 있는데, 이때 ATTRIB 이벤트를 제외한 모든 이벤트를 받고 싶다면 new FileObserver("path", ALL_EVENTS ^ ATTRIB) 와 같이 사용할 수 있다.
int	ATTRIB	메타 데이터(permissions, owner, timestamp)가 변경되었을 때 발생하는 이벤트 타입.
int	CLOSE_NOWRITE	읽기 전용으로 열려있는 특정 파일 또는 디렉트로리를 닫았을 때 발생하는 이벤트 타입.
int	CLOSE_WRITE	쓰기 모드로 열려있는 특정 파일 또는 디렉토리를 닫았을 때 발생하는 이벤트 타입.
int	CREATE	FileObserver 으로 디렉토리를 감시할 때, 디렉토리 내부 파일 또는 서브디렉토리가 생성되었을때 발생하는 이벤트 타입.
int	DELETE	감시되고 있는 디렉토리 내부에서 파일 또는 디렉토리가 삭제 되었을때 발생하는 이벤트 타입.
int	DELETE_SELF	감시되고 있는 디렉토리 또는 파일이 삭제 되었을때 발생하는 이벤트 타입. 이 이벤트가 발생하면 대상 파일이나 디렉토리에 대한 감시는 종료된다.
int	MODIFY	파일이 감시되고 있을경우, 파일에 데이터가 쓰여질때 발생하는 이벤트 타입.
int	MOVED_FROM	감시되고 있는 디렉토리 내부로부터 파일 또는 디렉토리가 이동했을때 발생. (물론 이름이 변경되어도 발생한다.)
int	MOVED_TO	감시되고 있는 디렉토리 내부로 파일 또는 디렉토리가 이동했을때 발생. (마찬가지로 이름이 변경되어도 발생한다.)
int	MOVE_SELF	감시되고 있는 디렉토리 또는 파일이 이동했을때 발생하는 이벤트 타입. 이 이벤트가 발생하여도 대상 파일에 대한 감시는 종료되지 않는다.
int	OPEN	파일 또는 디렉토리가 열렸을때 발생한다.

만약 특정 디렉토리를 감시하고 있는 상태에서는 그 내부 자식들의 파일 또는 디렉토리가 변경 되었을때만 이벤트가 발생한다. 즉, 감시 대상이 되는 디렉토리 내부의 어떤 디렉토리의 자식 디렉토리 상태가 변경되었을때는 이벤트가 발생하지 않는다.

이렇게 구구절절 설명하는 것 보다 한 번 돌려보고 눈으로 직접 확인해 보는 것이 최고다. 그래서 아래와 같은 예제 코드를 마련해 놓았다.

이 코드는 접근 가능한 영역의 모든 파일 또는 폴더를 대상으로 FileObserver 를 생성하여 감시할 수 있도록 하였으며 이벤트를 로그로 출력하도록 하였다.

MainActivity.java:

public class MainActivity extends Activity {
		
	public static final ArrayList<TestFileObserver> sListFileObserver = new ArrayList<TestFileObserver>();
	
	static class TestFileObserver extends FileObserver {
		private String mPath;
		
		int[] eventValue = new int[] {FileObserver.ACCESS, FileObserver.ALL_EVENTS, FileObserver.ATTRIB, FileObserver.CLOSE_NOWRITE,FileObserver.CLOSE_WRITE, FileObserver.CREATE,
				FileObserver.DELETE, FileObserver.DELETE_SELF,FileObserver.MODIFY,FileObserver.MOVED_FROM,FileObserver.MOVED_TO, FileObserver.MOVE_SELF,FileObserver.OPEN};
		String[] eventName = new String[] {"ACCESS", "ALL_EVENTS", "ATTRIB", "CLOSE_NOWRITE", "CLOSE_WRITE", "CREATE",
				"DELETE", "DELETE_SELF" , "MODIFY" , "MOVED_FROM" ,"MOVED_TO", "MOVE_SELF","OPEN"};
		
		
		public TestFileObserver(String path) {
			super(path);
			mPath = path;
			sListFileObserver.add(this);
		}
		
		public TestFileObserver(String path, int mask) {
			super(path, mask);
			mPath = path;
			sListFileObserver.add(this);
		}
		
		@Override
		public void onEvent(int event, String path) {
			StringBuilder strEvents = new StringBuilder();
			strEvents.append("Event : ").append('(').append(event).append(')');
			for(int i = 0; i < eventValue.length; ++i) {
				if((eventValue[i] & event) == eventValue[i]) {
					strEvents.append(eventName[i]);
					strEvents.append(',');
				}
			}
			if((event & FileObserver.DELETE_SELF) == FileObserver.DELETE_SELF) {
				sListFileObserver.remove(this);
			}
			strEvents.append("\tPath : ").append(path).append('(').append(mPath).append(')');
			Log.i("TestFileObserverTestFileObserver",strEvents.toString());
		}
	}
	
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		monitorAllFiles(Environment.getExternalStorageDirectory());
	}
	
	private void monitorAllFiles(File root) {
		File[] files = root.listFiles();
		for(File file : files) {
			TestFileObserver fileObserver = new TestFileObserver(file.getAbsolutePath());
			fileObserver.startWatching();
			if(file.isDirectory()) monitorAllFiles(file);
		}
	}
}

이 코드를 실행하기 위하여 AndroidManifest.xml 파일 상단에 다음과 같은 권한을 추가해야 한다.

   <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>

아두이노 남아있는 메모리 (메모리 사용량) 확인하기 - 메모리 공포에서 벗어나자.

snoworca — Tue, 14 Oct 2014 10:40:15 +0900

아두이노 에서 사용하는 마이크로 컨트롤러는 작은 양의 RAM 공간을 갖고 있습니다. 아두이노 우노 에서 사용하는 ATmega328 계열은 고작2Kbyte 의 공간을 갖고 있으며 기본적으로 200에서 300byte 정도의 메모리가 소비되는 것을 볼 수 있었습니다.

스케치 코드를 짜면서 무분별한 변수 선언이나 지나친 메모리 할당은 아두이노 스케치가 오동작 할 수 있는 상황을 야기시킬 수 있기 때문에 코딩중 고심하게 만드는 부분중에 하나입니다. 심지어 메모리 누수(Memory leak) 버그가 발생하면 코딱지 만한 메모리 공간은 쓰레기로 가득 찰 것입니다.

다행히도 아두이노에 남아있는 메모리 사용량을 실시간으로 체크할 수 있는 방법이 존재합니다. 그리고 그것을 라이브러리로 쓰기 편하게 만들어 주신 분도 있습니다. 우선 마음속으로 라이브러리 제작자분에게 '감사합니다' 를 한 번 외친후에 아래 링크에서 라이브러리 파일을 다운받아 아두이노 툴에 추가시켜줍니다.

https://github.com/maniacbug/MemoryFree

사용방법은 무지 간단한데, 라이브러리 include (#include <MemoryFree.h>) 한 다음으로 loop() 내에서 freeMemory() 호출 하면 그 결과값을 통하여 현재 남아있는 메모리 사용량을 Kbyte 단위로 알 수 있습니다.

저는 라이브러리에 포함된 예제 코드에 아주 간단한 리스트를 만들고 노드를 계속 추가하면서 메모리 사용량을 살펴보는 코드를 작성해 보았습니다. 만약 노드를 추가하다가 남아있는 메모리가 얼마 없다면 리스트를 전부 제거시켜줍니다.

MemoryFreeTest.ino::

#include <MemoryFree.h>

void setup()

{
    Serial.begin(115200);
}

class Node

{
  public :
    // 다음 경로. 
    Node* next;
    // 메모리 사용을 지켜보기 위하여 100byte 의 배열 생성. 
    byte buf[100];
};
// 시작 경로. 이 것은 제거되지 않는다.
Node* beginNode = new Node();
Node* topNode = beginNode;

void loop()

{
      Serial.print("freeMemory()=");
      Serial.println(freeMemory());
      delay(1000);
      /* 남아있는 메모리가 500byte 이상이면
        노드를 생성하여 추가.*/
      if(freeMemory() > 500)

     {
          addNode();
     }

     else

     {
         /*모든 노드를 제거하여 메모리 공간을 
            확보한다.*/
          clearNode();
      }
}

void addNode()

{
    topNode->next = new Node();  
    topNode = topNode->next;
}

void clearNode()

{
    Node* itor = beginNode->next;
    while(itor)

    {
        Node* next = itor->next;
        delete itor;
        itor = next;
    }
    topNode = beginNode;
    Serial.println("Clear!");
}

결과::

좀 더 테스트 하면서 정확성을 확인해 봐야겠지만, 일단은 위와 같이 잘 동작합니다.

만약 메모리 릭이 발생했을때의 상황도 재현해 보았습니다.

방법은 위 코드에서 Node 클래스의 buf 배열의 사이즈를 500으로 늘려서 한 번에 504 바이트씩 할당 하도록 하고, clear 하는 부분은 제거하였습니다.

그 결과는 아래와 같습니다.

마치 수치 상으로는 메모리 공간이 없으면 더이상 할당이 안 되는 것처럼 보이지만, 사실 내부적으로 무슨 일이 일어나고 있는지도 모릅니다. 저도 아직까지는 정확히는 확인할 길이 없어서 확인을 안 했지만 혹시나 아두이노의 메모리를 실시간으로 들여다 볼 수 있는 방법이 있으면 이 포스팅을 업데이트 하겠습니다.

Attiny85 에 아두이노 부트로더 올리기 + 삽질기.

snoworca — Tue, 7 Oct 2014 03:13:44 +0900

우선 해외 사이트 중에 Attiny85 에 아두이노를 올리는 것에 대해 자세히 나와있는 아주 좋은 포스팅이 하나 있다.

http://highlowtech.org/?p=1695

하지만, 이 포스팅을 보고 순서대로 따라해 보았지만 동작하지 않았다.

대략 원인은 위 포스팅에 나와있는 아두이노 우노 R2 에서는 잘 올라가지만 직접 테스트 해본 아두이노 우노 R3 에서는 문제가 발생하는 것으로 예상하고 있다. 물론 아두이노 (호환)나노, 아두이노 (호환)미니 에서도 동작하지 않았다.

위에 링크로 올린 http://highlowtech.org/?p=1695 에서는 아주 간단한 방법으로 부트로더도 올리고 Blink 예제도 올리고 있지만, 앞서 언급한대로 잘 되지 않으므로 정공법으로 부트로더를 올리고 스케치 프로그램을 올리는 방법에 대하여 설명하겠다.

(이 포스팅은 아두이노 IDE 버전 1.0.x 기준입니다. 아두이노 IDE 버전 1.6.4 이상 쓰시는 분들은 http://www.dev.re.kr/81 이 주소로 이동 바랍니다.)

첫 번째로 라이브러리 설치 방법에 대하여 소개하겠다.

이 부분은 매우 간단하다.

1. 우선 Attiny85, 84, 44 를 지원하는 라이브러리를 다운받아야 한다.

라이브러리는 이 곳에서 받을 수 있다.

https://github.com/damellis/attiny/

아두이노 IDE 1.6.x 버전은 아래 링크에서 받아야 한다.

https://github.com/damellis/attiny/tree/ide-1.6.x/attiny/avr

또는 아래 링크를 클릭하여 압축된 master 브런치 파일을 바로 받을 수 있다.

https://github.com/damellis/attiny/archive/master.zip

아두이노 IDE 1.6.x 버전 이상

https://github.com/damellis/attiny/archive/ide-1.6.x.zip

그냥 위 링크를 선택하여 받으면 된다.

2. 두 번째로 받은 라이브러리 파일 압축을 풀고 그 내부에 있는 attiny 폴더를 아두이노 툴의 hardware 폴더에 옮긴다.

만약 윈도우의 경우 hardware 폴더는 다음과 같은 경로에 있다.

아래 스크린 샷은 hardware 폴더 내에 attiny 폴더를 이동시킨 것 까지 보여주고 있다.

맥의 경우 아래처럼 실행 파일에서 마우스 커서를 대고 오른쪽 버튼을 누른다음 패키지 내용 보기를 선택한다.

파인더가 열리면서 내부를 들여다 볼 수 있다.

그럼 윈도우와 마찬가지로 hardware 경로에 접근하여 그 곳에 attiny 폴더를 이동시키도록하자.

아두이노 IDE 1.6.x 버전은 경로가 조금 다른데, Contents -> Java -> hardware 폴더에 attiny 폴더를 붙여넣으면 된다.

이제 아두이노 툴(IDE) 를 재시작 시키고 상단 메뉴의 도구(tools)->보드(board) 에 들어가면 ATtiny 가 지원되는 것을 볼 수 있다.

여담이지만, Attiny85 는 펌웨어를 올릴 수 있는 프로그램 메모리를 8kbyte 를 지원하고 Attiny44 는 4kbyte 를 지원한다. 참고로 Attiny 에 올라가는 부트로더의 크기는 대략 2kbyte 정도다.ㅎㄷㄷ

아두이노 IDE 1.6.x 버전에서는 보드 : Attiny 를 선택,

프로세서 : Attiny85 선택,

Clock : 8Mhz (internal) 을 선택한다.

이제부터가 중요하다.

ATmega328 에 부트로더를 올려본 경험이 있는 분들은 쉬울 것이다.

먼저 여러분이 갖고 있는 아두이노에 ArduinoISP 를 올려야 한다.

아래 그림과 같이 파일->예제->ArduinoISP 를 선택하여 나온 코드를 아두이노에 업로드 한다.

그리고 나서 도구->프로그래머->Arduino as ISP 를 선택한다.

이 과정은 PC 로부터 시리얼 통신으로 명령을 받은 아두이노가 다른 장치로 프로그램을 올릴수(ISP, In-System Programing ) 있도록 해주는 과정이다. 방금 아두이노 위에 올린 ArduinoISP 는 일종의 릴레이를 하게 된다. 물론 USB ISP 장치가 있으면 이런 삽질 할 필요 없이, 도구 -> 프로그래머 -> USBtinyISP 를 선택하고 바로 부트로더를 구우면 된다.

다만 그게 없으면 이렇게 번거로운 과정을 해야 하는데, 더 안습한 사실은 Attiny85 는 시리얼 통신을 지원하지 않으니 그것을 통하여 프로그램을 올릴수도 없다. USB ISP 장치가 없다면 오로지 다른 아두이노를 거쳐서 프로그램을 업로드 해야한다.

물론 USB ISP 장치도 우리의 알리익스프레스에서 단돈 5천원 미만에 팔고 있다.

(http://www.aliexpress.com/wholesale?SearchText=USB+ISP&catId=0&initiative_id=SB_20141006100947)

이제 다음 과정으로 넘어가겠다. ISP 를 통하여 ATtiny 에 부트로더를 올리기 위하여 다음과 같이 선을 연결한다.

1) 아두이노 우노 R2 이하에서는 아래 링크의 페이지에 나와있는 방법대로 연결한다.

(R2, R3 구분방법은 링크 사이트의 그림과 아래 2)의 그림 에서 Reset 버튼 위치 확인)

Reset 포트와 GND 포트 사이에 10uF 콘덴서를 연결하는 것이 포인트다.

콘덴서의 '-' 가 표시된 줄무늬 쪽이 GND다.

http://highlowtech.org/?p=1706

2) 아두이노 우노 R3 이상.

(Pin0 은 D0 , Pin2 는 D1 이다.)

이해를 돕기 위하여 좀 더 자세히 설명하면,

다음 표와 같다.

ATtiny Reset	--------------	Arduino 10
ATtiny Pin3	--------------	Arduino 9
ATtiny GND	---------------	Arduino GND

ATtiny VCC	--------------------	Arduino 5v
ATtiny Pin2	--------------------	Arduino 13
ATtiny Pin1	--------------------	Arduino 12
ATtiny Pin0	--------------------	Arduino 11

선 연결이 완료되면 ArduinoISP 가 올라간 아두이노 보드가 PC 에 연결된 상태에서 상단 메뉴의 '도구 -> 시리얼 모니터' 를 선택하면 나오는 창에서 우측 하단의 baud rate 를 '19200baud' 로 변경한다. 만약 상단 메뉴의 '도구' 에서 시리얼 모니터가 비활성화 되어있다면 아두이노와 연결이 제대로 되지 않은 것이다.

그 다음은, 상단 메뉴의 '도구 -> 보드' 에서 자신이 갖고 있는 ATtiny 를 선택한다. 실제로 올려보면서 처음에는 안전하게 ATtiny 1Mhz 를 선택한다. (이 과정이 성공한 이후에는 같은 방법으로 ATiny 8Mhz 도 올려보자.)

그리고 '도구 -> 부트로더 굽기' 를 선택한다.

하지만, 에러가 날 것이다. (에러가 나지 않는다면 축하한다. 부트로더가 올라간 것이다.)

필자는 국내 온라인 전자 부품 쇼핑몰에서 가장 구하기 쉬운 ATtiny85-20pu 를 구입했는데, 이 것이 이전 버전들과 호환이 안 되어서 그런지 몰라도 아래 그림과 같이 에러가 난다. (아래는 삽질하는 과정에서 Baud Rate 를 일부러 57600으로 바꿔본 스샷이다.)

이 것의 해결책을 찾으러 여러군데를 뒤져보고 http://electronics.stackexchange.com/questions/64978/attiny2313-refuses-to-be-programmed-after-setting-cpu-clock-to-500khz/65183#65183 이 페이지에서 해답을 찾았다.

그리고 아래 링크에 있는 어떤 아주 고마운 분께서 수정한 ArduinoISP 코드를 다시 아두이노에 올린다.

https://github.com/sylvandb/ArduinoISP/blob/7e5359a44baccac956d8623d3d8629f4a48efe79/ArduinoISP/ArduinoISP.ino

다시 도구 -> 보드 에서 자신이 갖고 있는 ATtiny 를 선택한 뒤에 도구 -> 부트로더 굽기 를 실행하며 이제 잘 올라갈 것이다.

이제 실제로 테스트 해보기 위해 Blink 예제를 올려볼 것이다.

우선 방금 올린 수정된 ArduinoISP 으로 부트로더를 무사히 올릴 수 있었지만, 스케치 프로그램은 올릴 수 없으므로 다시 메뉴에서 파일->예제->ArduinoISP 를 선택하고 아두이노에 업데이트한다.

이미 구성한 회로에 다음과 같이 LED 와 저항을 붙여준다.

파일->예제->01.Basics->Blink 를 선택한다. 파일이 열리면 13번 포트로 설정되어 있는 부분을 모두 0 으로 고쳐준다.

마지막으로 업로드를 실행하면 PC---> 아두이노 (ISP) ---> ATtiny85 과정을 거쳐서 프로그램이 업로드가 될 것이다.

아래는 ATtiny85 에서 실행하는 Blink 예제 구동영상이다.

PWM 도 테스트 해보았다.

[JAVA:병렬 프로그래밍 - 3] Exchanger 사용하기.

snoworca — Mon, 6 Oct 2014 13:53:16 +0900

Exchanger 는 뜻 그대로 쓰레드상에서 두 개의 인스턴스를 교환해주는 역할을 한다. 만약 한쪽의 쓰레드에서만 교환 메소드를 호출한다면 다른쪽에서 교환 메소드를 호출하기 전까지 대기하고 있는데.

이 클래스는 java 의 gc 와 같은 동작에서 사용할 수 있다.

예를 들어 설명하면 다음과 같다. (이해를 돕기 위하여 '요청' 이라는 표현을 사용하였다. 정확히는 교환 대상이 되는 인스턴스 값을 인자로 하는 교환 메소드 호출이다.)

1. 데이터를 '스택에 쌓는 쓰레드' 와, '스택을 비우는 쓰레드' 가 있다. 이 두 개의 쓰레드에는 각각의 '스택' 이 있다.

2. 데이터를 '스택에 쌓는 쓰레드' 는 계속해서 데이터를 자신의 '스택' 에 추가한다. 이 동작을 반복하다 스택이 가득차면 '스택' 교환을 요청하고 3번 과정이 끝날 때 까지 모든 동작을 대기한다. 즉, 다른쪽에서도 교환 요청이 일어날 때까지 대기하는 것이다.

3. '스택을 비우는 쓰레드' 에서 스택을 모두 비운다. 스택을 모두 비우면 가득찬 스택을 가져오기 위하여 데이터를 '스택에 쌓는 쓰레드' 의 '스택'과 교환 요청을 한다.

4. 한 쌍의 '스택' 에 대하여 교환 요청이 이루어졌으므로 '스택에 쌓는 쓰레드' 의 가득찬 '스택'은 '스택을 비우는 쓰레드' 로 이동하여 가득찬 '스택'을 비울 수 있도록 한다. 또, '스택을 비우는 쓰레드' 의 비어있는 '스택'은 '스택에 쌓는 쓰레드' 로 이동하여 비어있는 '스택' 에 데이터를 다시 쌓을 수 있도록 한다. 그리고 1번 과정을 반복한다.

이를 예제코드로 표현하면 아래와 같다.

예제코드:

/**
 * 스택의 최대 크기.
 */
public final static int STACK_CAPACITY  = 8;
private Exchanger<LinkedList<Integer>> mExchanger = new Exchanger<LinkedList<Integer>>();

class PushLoop implements Runnable {
	
	/** int 값을 넣는데 사용하는 스택. */
	LinkedList<Integer> integerStack = new LinkedList<Integer>();
	
	/** 키 입력을 받는다. */
	private Scanner keyScanner = new Scanner(System.in);
	public void run() {
		while(!Thread.interrupted()) {
			try {
				// 스택의 최대 크기를 넘기지 않는 범위내에서 입력받은 값들을 스택에 넣는다.
				while(integerStack.size() < STACK_CAPACITY) {
					int value = keyScanner.nextInt();
					integerStack.addLast(value);
				}
				// 스택이 가득차면 메세지를 출력하고, 비어있는 스택(integerStack)과 교환한다.
				// 만약 교환될(비어있는) 스택이 없다면 대기한다.
				System.out.println("PushLoop : Full Stack.");
				integerStack = mExchanger.exchange(integerStack);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

class EmptyLoop implements Runnable {
	/**
	 * 값을 비우는 스택.
	 */
	LinkedList<Integer> integerStack = new LinkedList<Integer>();
	public void run() {
		while(!Thread.interrupted()) {
			try {
				// 스택내에 값이 비어있지 않으면 계속 비운다.
				while(!integerStack.isEmpty()) {
					int value = integerStack.removeLast();
					System.out.println(value);
				}
				// 스택이 비어지면 메세지를 출력하고, 가득찬 스택(integerStack)과 교환한다.
				// 만약 교환될(가득찬) 스택이 없다면 대기한다.
				System.out.println("EmptyLoop : Empty Stack.");
				integerStack = mExchanger.exchange(integerStack);
			} catch (InterruptedException e) { 
				e.printStackTrace();
			}
		}
	}
}

public void runThread() {
	new Thread(new PushLoop()).start();
	new Thread(new EmptyLoop()).start();
}

위 예제 코드에서 runThread() 를 호출하면 값을 입력 받아서 stack 에 쌓는 쓰레드와 동시에 비우는 쓰레드가 작동한다. 결과는 다음과 같다.

실행 결과(초록색 폰트가 입력된 값이다.):

EmptyLoop : Empty Stack.
100
200
300
400
500
600
700
800
PushLoop : Full Stack.
800
700
600
500
400
300
200
100
EmptyLoop : Empty Stack.

WS2812B 사용하기 예제.

snoworca — Mon, 6 Oct 2014 01:46:58 +0900

이전 포스팅 '저렴한 RGB LED(WS2812B) 구임/사용기' 라는 포스팅에서 WS2812B 에 대하여 잠깐 소개한적이 있다. 간단한 사용 방법에 대하여 소개를 하지 않아서 본격적으로 사용법에 대하여 소개를 하려고 한다.

우선 구입은 Aliexpress 와 같은 해외 사이트를 추천한다. 글을 올린 시간 기준으로 100개에 약 18달러정도 한다.

(http://www.aliexpress.com/premium/WS2812B-100pcs-Heatsink.html?ltype=wholesale&d=y&origin=y&SearchText=WS2812B+100pcs+Heatsink&isPremium=y&initiative_id=SB_20141005041503&isViewCP=y&catId=)

뿐만 아니라 LED 매트릭스와 스트립도 검색하면 싼 값에 구입할 수 있다. WS2812B는 복잡한 배선과 코딩하기 어려운 일반적인 RGB LED 의 좋은 대안이 될 수 있다.

WS2812B 는 사실 Adafruit 의 Neopixel 에도 사용되는데 이는 Neopixel 의 라이브러리를 그대로 이용해도 사용 가능하다. (옵션 변경을 통하여 WS2811 도 가능하다, 아래 예제코드 참고.)

(Neopixel)

우선 Neopixel 라이브러리 프로젝트(https://github.com/adafruit/Adafruit_NeoPixel) 를 library 폴더에 다운받아 Arduino 툴에 라이브러리로 추가한다. (스케치 -> 라이브러리 가져오기 -> add Library 를 선택한 뒤에 NeoPixel 라이브러리 폴더 선택) Neopixel 라이브러리 라이센스가 GPLv3 인 것에 유의하자. (사용/수정시 GPLv3 로 소스 배포, 상업적 사용 불가)

우선 예제를 한 번 실행시켜보자. 상단 메뉴의 '파일 -> 예제 -> Neopixel -> Simple' 을 열면 간단한 사용 예제를 볼 수 있다. 만약 예제가 안 나온다면 아두이노툴을 재시작 하자.

이 곳에서 여러분이 연결한 WS2812B 의 개수를 NUMPIXELS 에 설정하고 PIN 에 연결되는 디지털 핀을 설정할 수 있다.

WS2812B 와 아두이노의 연결 회로는 다음과 같이 매우 간단하다.

자, 이제 아까 불러온 예제 파일을 조금 수정하여 Serial 콘솔을 통하여 읽어온 값을 기반으로 선택한 LED 의 색을 바꾸는 간단한 프로젝트를 만들어 보겠다.

우선 WS2812B 10개를 다음과 같이 연결해 보았다.

그리고 다음과 같은 코드를 작성여 아두이노로 업로드 하였다.

예제코드:

#include <Adafruit_NeoPixel.h>

// 컨트롤 핀
#define PIN            6

// WS2812B 의 연결된 개수
#define NUMPIXELS      10
#define READ_BUFFER_SIZE 6

// 만약 WS2811 를 사용할 경우 NEO_KHZ800 을 NEO_KHZ400 으로 변경해야 한다.
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

int R = 0, G = 0, B = 0, selectNum;
char buffer[READ_BUFFER_SIZE]; 

int readNumber();

void setup() {
  pixels.begin(); // This initializes the NeoPixel library.
  Serial.begin(9600);
}


void loop() {

  // 핀 번호 입력.
  Serial.print("Select LED(0~");
  Serial.print(NUMPIXELS - 1);
  Serial.print(") : ");
  // Serial 에 값이 들어올 때 까지 대기하는 동안 지속적으로 업데이트 해준다.
  while(!Serial.available()) pixels.show();
  // 값을 입력 받는다.
  selectNum = readNumber();


  Serial.print("R(0~255) : ");   
  while(!Serial.available())  pixels.show();
  R = readNumber();

  Serial.print("G(0~255) : ");   
  while(!Serial.available())   pixels.show();
  G = readNumber();
  

  Serial.print("B(0~255) : ");   
  while(!Serial.available())  pixels.show();
  B = readNumber();

 pixels.setPixelColor(selectNum, pixels.Color(R,G,B));
 pixels.show();  
}

// String 으로 입력받은 숫자를 integer 형태로 변환하여 반환한다.
int readNumber() 
{
  int index = 0, number = 0;
  while(Serial.available())  
  {
      delay(5);
      buffer[index++] = Serial.read();
      buffer[index] = '\0';         
      if(index + 1 == READ_BUFFER_SIZE) 
      {
        break;
      }      
  } 
  Serial.flush(); 
  number = atoi(buffer);  
  Serial.println(number);
  return number;
}

결과 :

시리얼 콘솔을 통하여 LED 의 번호를 설정하고 RGB 값을 설정한다.

색상을 설정한 LED 는 이렇게 불이 들어온다.

CRC16-CITT - 아두이노에 올리기 위한 C 코드.

snoworca — Sun, 5 Oct 2014 14:47:46 +0900

우선 CRC 와 CRC CITT 에 대한 설명은 아래 두 사이트에서 볼 수 있다.

CRC(cyclic redundancy check) 에 관한 설명, 위키 링크(클릭)

CRC16-CITT 에 대한 설명과 코드 페이지 링크(클릭)

보통 구글링을 하면 나오는 CRC 코드는 CRC 값 계산을 위한 테이블을 미리 생성하거나 코드에 포함시키기 때문에 아두이노에 올리기에 부담스럽다. 아두이노 UNO 의 메모리 크기는 달랑 2Kbyte 밖에 안 되는데 CRC 값 계산을 위한 테이블은 이론상 512byte 씩이나 되기 때문이다. (실제로는 좀 더 작은 크기를 점유하고 있다.)

SRAM을 직접 연결하거나 메모리 쉴드를 달면 조금 나아지겠지만, 일단 그냥 올리기에는 부담스러운 것이 사실이다. 그래서 인터넷 이곳 저곳에서 긁어온 코드를 조금 느리더라도 아래 코드처럼 직접 계산하도록 하였다. (추후에 시간이 되면 좀 더 빠르게 개선해봐야겠다.)

CRC16 CITT:

// CRC16-CITT Polynomial
#define POLY	0x1021

//아래 주석을 해제하면, 미리 정의된 CRC Table 을 사용한다.
//#define USE_CRC_TABLE 
const unsigned short crc16Table[256]= {
	0x0000,0x1021,0x2042,0x3063,0x4084,0x50a5,0x60c6,0x70e7,
	0x8108,0x9129,0xa14a,0xb16b,0xc18c,0xd1ad,0xe1ce,0xf1ef,
	0x1231,0x0210,0x3273,0x2252,0x52b5,0x4294,0x72f7,0x62d6,
	0x9339,0x8318,0xb37b,0xa35a,0xd3bd,0xc39c,0xf3ff,0xe3de,
	0x2462,0x3443,0x0420,0x1401,0x64e6,0x74c7,0x44a4,0x5485,
	0xa56a,0xb54b,0x8528,0x9509,0xe5ee,0xf5cf,0xc5ac,0xd58d,
	0x3653,0x2672,0x1611,0x0630,0x76d7,0x66f6,0x5695,0x46b4,
	0xb75b,0xa77a,0x9719,0x8738,0xf7df,0xe7fe,0xd79d,0xc7bc,
	0x48c4,0x58e5,0x6886,0x78a7,0x0840,0x1861,0x2802,0x3823,
	0xc9cc,0xd9ed,0xe98e,0xf9af,0x8948,0x9969,0xa90a,0xb92b,
	0x5af5,0x4ad4,0x7ab7,0x6a96,0x1a71,0x0a50,0x3a33,0x2a12,
	0xdbfd,0xcbdc,0xfbbf,0xeb9e,0x9b79,0x8b58,0xbb3b,0xab1a,
	0x6ca6,0x7c87,0x4ce4,0x5cc5,0x2c22,0x3c03,0x0c60,0x1c41,
	0xedae,0xfd8f,0xcdec,0xddcd,0xad2a,0xbd0b,0x8d68,0x9d49,
	0x7e97,0x6eb6,0x5ed5,0x4ef4,0x3e13,0x2e32,0x1e51,0x0e70,
	0xff9f,0xefbe,0xdfdd,0xcffc,0xbf1b,0xaf3a,0x9f59,0x8f78,
	0x9188,0x81a9,0xb1ca,0xa1eb,0xd10c,0xc12d,0xf14e,0xe16f,
	0x1080,0x00a1,0x30c2,0x20e3,0x5004,0x4025,0x7046,0x6067,
	0x83b9,0x9398,0xa3fb,0xb3da,0xc33d,0xd31c,0xe37f,0xf35e,
	0x02b1,0x1290,0x22f3,0x32d2,0x4235,0x5214,0x6277,0x7256,
	0xb5ea,0xa5cb,0x95a8,0x8589,0xf56e,0xe54f,0xd52c,0xc50d,
	0x34e2,0x24c3,0x14a0,0x0481,0x7466,0x6447,0x5424,0x4405,
	0xa7db,0xb7fa,0x8799,0x97b8,0xe75f,0xf77e,0xc71d,0xd73c,
	0x26d3,0x36f2,0x0691,0x16b0,0x6657,0x7676,0x4615,0x5634,
	0xd94c,0xc96d,0xf90e,0xe92f,0x99c8,0x89e9,0xb98a,0xa9ab,
	0x5844,0x4865,0x7806,0x6827,0x18c0,0x08e1,0x3882,0x28a3,
	0xcb7d,0xdb5c,0xeb3f,0xfb1e,0x8bf9,0x9bd8,0xabbb,0xbb9a,
	0x4a75,0x5a54,0x6a37,0x7a16,0x0af1,0x1ad0,0x2ab3,0x3a92,
	0xfd2e,0xed0f,0xdd6c,0xcd4d,0xbdaa,0xad8b,0x9de8,0x8dc9,
	0x7c26,0x6c07,0x5c64,0x4c45,0x3ca2,0x2c83,0x1ce0,0x0cc1,
	0xef1f,0xff3e,0xcf5d,0xdf7c,0xaf9b,0xbfba,0x8fd9,0x9ff8,
	0x6e17,0x7e36,0x4e55,0x5e74,0x2e93,0x3eb2,0x0ed1,0x1ef0
};
  
/**
* CRC Table 의 값을 계산하여 가져온다.
*  만약 USE_CRC_TABLE 이 #define 으로 정의되어 있다면 
* 미리 생성된 CRC 테이블에서 값을 즉시 가져온다.
 * @param index CRC Table 의 인덱스.
 * @return 값.
 */
unsigned short getCRCTableEle(unsigned short index)
{
    #ifdef USE_CRC_TABLE
       return crc16Table[index];
    #else
       unsigned short tableEle  = ((unsigned short)index<<8);
       for(char i=0; i<8; i++)
       tableEle =  (tableEle & 0x8000L)?(tableEle << 1) ^ POLY:(tableEle << 1);
       return tableEle;
    #endif
}

/**
 * 버퍼를 입력 받아 CRC 값을 생성한다.
 * @param buf 버퍼
 * @param len 버퍼의 길이
 * @return CRC 값.
 */
unsigned short genCRC(unsigned char *buf, int len)
{
    unsigned short crc = 0;
    for(int counter = 0; counter < len; counter++)
        crc = (crc<<8) ^ getCRCTableEle(((crc>>8) ^ *buf++)&0x00FF);
    return crc;
}

문득 이 방법이 CRC 테이블을 사용하는 것에 비하여 성능이 어느정도 떨어지는지 조금 궁금하여 아래 테스트 코드를 추가하여 간략하게 테스트를 해보았다.

CRC16 성능 테스트 (Arduino):

void updateCRC(unsigned short *updateCRC, unsigned char value)
{
    (*updateCRC) = (*updateCRC<<8) ^ getCRCTableEle(((*updateCRC>>8) ^ value)&0x00FF);
}

/**
 * 0을 반환하면 값이 정상이다.
 */
unsigned short error(unsigned short acceptedCRC,unsigned short checkCRC) 
{
    updateCRC(&checkCRC, (acceptedCRC & 0xFF00) >> 8);
    updateCRC(&checkCRC, acceptedCRC & 0x00FF);
    return checkCRC;
}

long total = 0, count = 0, startMs = 0, endMs = 0;
unsigned char	sendPayload[BUFFER_SIZE];
unsigned char	receivedPayload[BUFFER_SIZE];
void setup() {                
  Serial.begin(9600);
}
void loop() {
    srand(analogRead(0));
    // 랜덤한 값을 넣는다
    for(int i = 0; i < BUFFER_SIZE; ++i) {
        sendPayload[i] = ((unsigned char)rand() % 0xff);
    }
    unsigned short sendCRC, receivedCRC;
    sendCRC = genCRC(sendPayload, BUFFER_SIZE);
    for(int i = 0; i < BUFFER_SIZE; ++i) 
        receivedPayload[i] = sendPayload[i];
    // 값을 랜덤하게 다르게 한다.
    if(sendPayload[0] % 2 == 0) 
        receivedPayload[rand() % BUFFER_SIZE] = ((unsigned char)rand() % 0xff); 
    startMs = millis();
    receivedCRC = genCRC(receivedPayload, BUFFER_SIZE);    
    endMs = millis() - startMs;
    ++count;
    total += endMs;
    unsigned short errorCode = error(sendCRC, receivedCRC);
    // if(count == 1000) 을 제거하면 값들이 출력되는 것을 볼 수 있다.
    if(count == 1000) {
      Serial.print("\nBuffer length  : ");
      Serial.println(BUFFER_SIZE);
      Serial.print("Latency average : ");
      Serial.println( ((double)total / (double)count),5);
      Serial.print("Last send CRC : 0x");
      Serial.println((const char*)String(sendCRC,HEX).c_str());
      Serial.print("Last received CRC : 0x");
      Serial.println((const char*)String(receivedCRC,HEX).c_str());
      Serial.print("Last received CRC error : ");
      Serial.println((const char*)((errorCode == 0)?"OK":(String("error - 0x") + String(errorCode,HEX))).c_str());
    } 
}

CRC 값을 생성하는 함수에 32, 64, 128, 256, 512 바이트 버퍼 값을 넣어서 실행 시간을 확인하도록 하였다.

하지만, 이 테스트 방법에는 두 가지의 큰 문제점이 있다.

첫 번째로 32byte 부터 64byte 크기의 버퍼를 넣었을 때, CRC 생성 함수 실행 시간이 0ms 가 나올수도 있고 1ms 가 나올수도 있다는 것이다. 아두이노에서 micro 나 nano 시간을 구하기도 어렵다. 그래서 genCRC 함수를 1000번 실행시켜서 그 평균을 구하도록 하였다(...) genCRC 함수 호출이 1ms 미만으로 이루어지는 경우가 많다면 평균 시간이 점점 낮아질 것이다.

두 번째 문제는 결과의 정확도와 신뢰성이다. 이 것을 위해서 CRC 테이블의 모든 값을 훑는 테스트를 하는 것이 가장 좋지만, 대충 성능을 비교하도록 하는 것이기 때문에 간단하게 테스트를 돌려 보았다.

결과는 아래와 같다.

A 는 미리 생성된 CRC 테이블을 사용하지 않은 것이고,

B 는 미리 생성된 CRC 테이블을 사용한 것이다.

A의 바이너리 스케치 사이즈 : 7,478 바이트 (최대 32,256 바이트)

B 의 바이너리 스케치 사이즈 : 7,880 바이트 (최대 32,256 바이트)

402byte 차이가 난다.

예상대로 성능차이가 꽤 많이 생긴다.

하지만 CRC 테이블을 사용하면 그만큼의 메모리를 점유한다는 것도 잊지 말자.

[TIP] Activity 활성화 및 비활성화.

snoworca — Mon, 15 Sep 2014 16:06:06 +0900

우선 AndroidManifest.xml 에서 액티비티를 설정할 때, 속성값으로 액티비티 활성화/비활성화 값을 줄 수 있다. 만약 액티비티 비활성화를 한다면, Context 내의 startActivity 메소드를 이용하여 비활성화 된 액티비티를 호출시 앱은 ActivityNotFoundException 을 발생시키고 크래쉬가 발생하게 된다. 또 런처에서 실행시키기 위하여 <activity> 내부의 설정 앨리먼트 <intent-filter> 로 <action android:name="android.intent.action.MAIN"/> 과 <category android:name="android.intent.category.LAUNCHER"/> 옵션을 지정해줬다고 해도 런처내에 액티비티의 아이콘이 표시되지 않는다.

그리고, 이 것을 Manifest 파일에서만이 아닌 코드상에서도 PackageManager 의 setComponentEnabledSetting 으로 제어할 수 있다.

사용법은 무지 간단한데, 만약 Activity 내부에서 호출한다면 다음과 같은 코드를 사용하면 된다.

액티비티 비활성화:

PackageManager pm = getPackageManager();
pm.setComponentEnabledSetting(new ComponentName(getApplicationContext(), HiddenActivity.class), 
						 PackageManager.COMPONENT_ENABLED_STATE_DISABLED, 0);

만약 두 번째 인자를 COMPONENT_ENABLED_STATE_ENABLED 로 준다면 비활성화된 액티비티는 다시 활성화가 된다.

세 번째 인자를 0으로 준다면 이 설정이 종료된 시점에서 액티비티가 강제 종료되게 되는데, 만약 이 인자값을 PackageManager.DONT_KILL_APP 를 주게 된다면 앱은 종료되지 않은 상태로 설정값만 바뀌게 된다. 다만 어떻게 동작할지 모르니 주의하여 사용하여야 한다. (안드로이드 API 레퍼런스 바로가기 링크) 또 한가지 주의할 점은, 만약 setComponentEnabledSetting 메소드의 세 번째 인자값을 0으로 줬을 때 이 메소드의 호출이 종료되는 시점에 앱이 종료된다는 것이다.

이 메소드를 통하여 설정한 액티비티의 활성화/비활성화 속성은 저장되어, 앱을 강제종료하거나 재부팅을 하여도 계속 유지된다.

다음 예제를 통하여 어떻게 동작하는지 한 번 살펴보자.

우선 액티비티를 두 개를 만들고, 액티비티에 서로 다른 아이콘을 붙여놓았다.

좌측의 아이콘 이름은 ic_launcher_1

우측의 아이콘 이름은 ic_launcher_2

AndroidManifest.xml:

... 생략

        <activity android:name="MainActivity"
            android:icon="@drawable/ic_launcher_1">
            <intent-filter >
                <action android:name="android.intent.action.MAIN"/>
                <category android:name="android.intent.category.LAUNCHER"/>
            </intent-filter>
        </activity>
        
        <activity android:name="HiddenActivity"
            android:icon="@drawable/ic_launcher_2"
            android:label="Hidden"
            android:enabled="false">
            <intent-filter >
                <action android:name="android.intent.action.MAIN"/>
                <category android:name="android.intent.category.LAUNCHER"/>
            </intent-filter>
        </activity>

HiddenActivity.java:

public class HiddenActivity extends MainActivity{
}

MainActivity.java:

public class MainActivity extends Activity {
	
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		// 프레임 레이아웃을 만들고, 
		// 여기에 버튼을 하나 생성한다.
		// 그리고 프레임 레이아웃을 Context View 로 정의한다.
		FrameLayout layout = new FrameLayout(getApplicationContext());
		Button buttonHiddenActivityEnable = new Button(this);
		buttonHiddenActivityEnable.setText(isThisHiddenActivity()?"Disable this Activity":"Enable HiddenActivity");
		FrameLayout.LayoutParams params = new FrameLayout.LayoutParams(FrameLayout.LayoutParams.WRAP_CONTENT, FrameLayout.LayoutParams.WRAP_CONTENT);
		params.gravity = Gravity.CENTER;
		buttonHiddenActivityEnable.setLayoutParams(params);
		layout.addView(buttonHiddenActivityEnable);
		buttonHiddenActivityEnable.setOnClickListener(mOnClickListener);
		setContentView(layout);
		setTitle((isThisHiddenActivity()?"Hidden Activity":"Main Activity"));
	}
	
	private OnClickListener mOnClickListener = new OnClickListener() {
		@Override
		public void onClick(View v) {
			finish();
			PackageManager pm = getPackageManager();
			pm.setComponentEnabledSetting(new ComponentName(getApplicationContext(), HiddenActivity.class), 
			(isThisHiddenActivity()?PackageManager.COMPONENT_ENABLED_STATE_DISABLED:PackageManager.COMPONENT_ENABLED_STATE_ENABLED), 0);
		}
	};
	
	private boolean isThisHiddenActivity() {
		return this instanceof HiddenActivity;
	}
}

좀 귀찮아서 하나의 액티비티에 구현 코드를 몰아넣었다. 어쨌든 액티비티는 두개다.

이 코드를 실행하면 액티비티 실행 아이콘이 하나만 존재한다.

매니페스트 파일에서 android:enable 값을 false 로 준 HiddenActivity 는 런처에 아이콘조차 표시되지 않는다.

만약 앱을 실행시켜서 다음 스샷에 있는 버튼을 누른다면 앱이 완전히 종료되고, HiddenActivity 를 띄울수 있는 아이콘이 표시된다.

이 버튼은 누르면 앱이 종료되고, HiddenActivity 를 띄울 수 있게 된다.

이제 HiddenActivity 를 띄워서 버튼을 누르면 다시 HiddenActivity 는 disabled 되고 버튼은 감춰진다.

(다시 enable 하기전 까지는 사용할 수 없게 된다.)

[JAVA:병렬 프로그래밍 - 2] CyclicBarrier 사용하기.

snoworca — Tue, 2 Sep 2014 11:13:30 +0900

CyclicBarrier 를 사용하면 동시에 실행되는 쓰레드 내부 원하는 지점에서 대기를 걸어주고 모든 쓰레드가 대기 상태에 들어갔을때, 대기를 풀어주는 동작을 할 수 있다.

예를들어 설명하면 N 개의 쓰레드가 돌고 있다고 가정하고 CyclicBarrier 를 생성할 때 인자값으로 N 을 준다. 각각의 쓰레드 내에서 CyclicBarrier 의 await() 를 호출하고 호출 횟수가 N번에 도달했을 때, N개의 모든 쓰레드의 대기 상태가 해제된다.

아래 그림 참고. 설명이 조금 애매한데, 그냥 대충 보고 눈치것 이해하는 것이 좋다.

CyclicBarrier를 활용한 예제코드:

public class main {
	 
	private final static int THREADS = 5; 
	private static CyclicBarrier  cyclicBarrier = new CyclicBarrier(THREADS); 
	
	public static class RandomSleepRunnable implements Runnable {
		private int id = 0;
		private static Random random = new Random(System.currentTimeMillis());
		
		public RandomSleepRunnable(int id) {
			this.id = id;
		}
	
		@Override
		public void run() {
			System.out.println("Thread(" + id + ") : Start.");
			// 1000ms 에서 2000ms 사이의 딜레이 값을 랜덤하게 생성.
			int delay = random.nextInt(1001) + 1000;
			try {
				System.out.println("Thread(" + id + ") : Sleep " + delay + "ms");
				// 랜덤하게 주어진 값을 이용하여 딜레이를 준다.
				Thread.sleep(delay);
				System.out.println("Thread(" + id + ") : End Sleep");
				
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			try {
				// 대기. cyclicBarrier 를 생성할 때, 인자값으로 준 count 개수만큼
				// await를 호출한다면 모든 쓰레드의 wait 상태가 종료된다.  
				cyclicBarrier.await();
			} catch (InterruptedException e) {
				e.printStackTrace();
			} catch (BrokenBarrierException e) {
				e.printStackTrace();
			}
			System.out.println("Thread(" + id + ") : End.");
		}
	}
	
	public static void main(String[] args) {
		// 쓰레드를 10개 생성.
		for(int i = 0; i < THREADS; ++i) {
			new Thread(new RandomSleepRunnable(i)).start();
		}
	}
}

결과:

Thread(0) : Start.
Thread(2) : Start.
Thread(2) : Sleep 1128ms
Thread(0) : Sleep 1205ms
Thread(1) : Start.
Thread(1) : Sleep 1968ms
Thread(4) : Start.
Thread(3) : Start.
Thread(4) : Sleep 1834ms
Thread(3) : Sleep 1020ms
Thread(3) : End Sleep
Thread(2) : End Sleep
Thread(0) : End Sleep
Thread(4) : End Sleep
Thread(1) : End Sleep
Thread(1) : End.
Thread(3) : End.
Thread(4) : End.
Thread(0) : End.
Thread(2) : End.

[JAVA:병렬 프로그래밍 - 1] CountDownLatch 사용하기.

snoworca — Tue, 19 Aug 2014 13:41:13 +0900

만약 백그라운드에서 실행되고 있는 싱글 쓰레드가 종료되기를 기다리는 코드를 작성해야 한다면 당장 Thread 클래스의 join() 메소드 부터 떠올리게 될 것이다. 아래와 같이 말이다.

간단한 join() 사용예:

Thread thread = new Thread() {
	@Override
	public void run() {
		System.out.println("start trhead.");
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("end trhead.");
	}
};
thread.start();
try {
	// 스레드가 끝날때 까지 대기한다.
	thread.join();
} catch (InterruptedException e) {
	e.printStackTrace();
}
System.out.println("Thread terminated.");

하지만, 멀티 쓰레드에서 모든 동작이 끝나기를 기다려야 하는 상황이라면 join 을 사용하기 조금 난감하다. 이럴 땐 CountDownLatch 를 사용하면 참 편리하다. (안드로이드 API 설명 페이지로 링크합니다. 이 곳이 오라클 페이지보다 보기 좋아서;; http://developer.android.com/reference/java/util/concurrent/CountDownLatch.html )

CountDownLatch 는 생성할 때 1 이상의 카운트를 인자값으로 받는다. 그리고 특정 메소드 내부에서 await() 메소드로 대기 상태를 만들어주고 CountDownLatch 를 생성할 때 설정한 count 가 0이 되기만들 기다렸다가 0이 되는 순간 대기 상태를 해제한다. 원리는 아래 그림과 같다.

예제코드를 살펴보면 아래와 같다.

CountDownLatch 를 활용한 예제코드:

public class main {
	
	private final static int THREADS = 10; 
	private static CountDownLatch lacth = new CountDownLatch(THREADS);
	
	public static class RandomSleepRunnable implements Runnable {
		private int id = 0;
		private static Random random = new Random(System.currentTimeMillis());
		
		public RandomSleepRunnable(int id) {
			this.id = id;
		}
		
		@Override
		public void run() {
			System.out.println("Thread(" + id + ") : Start.");
			// 1000ms 에서 2000ms 사이의 딜레이 값을 랜덤하게 생성.
			int delay = random.nextInt(1001) + 1000;
			try {
				System.out.println("Thread(" + id + ") : Sleep " + delay + "ms");
				Thread.sleep(delay);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("Thread(" + id + ") : End.");
			// lacth 의 카운터에서 -1. 
			lacth.countDown();
		}
	}
	
	public static void main(String[] args) {
		// 쓰레드를 10개 생성.
		for(int i = 0; i < THREADS; ++i) {
			new Thread(new RandomSleepRunnable(i)).start();
		}
		
		try {
			// lacth 의 카운트가 0이 될 때 까지 대기한다.
			lacth.await();
			// 아래와 같이 TimeOut 을 설정할 수 있다.
			// 아래의 경우는, 만약 2000ms 동안 latch 의 카운트가 0 되지 않는다면
			// wait 상태를 해제하고 다음 동작으로 넘어간다.
			//lacth.await(2000, TimeUnit.MILLISECONDS);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("All threads terminated.");
	}
}

결과:

Thread(1) : Start.
Thread(1) : Sleep 1267ms
Thread(2) : Start.
Thread(0) : Start.
Thread(0) : Sleep 1168ms
Thread(2) : Sleep 1085ms
Thread(5) : Start.
Thread(4) : Start.
Thread(4) : Sleep 1573ms
Thread(5) : Sleep 1868ms
Thread(3) : Start.
Thread(3) : Sleep 1552ms
Thread(6) : Start.
Thread(6) : Sleep 1869ms
Thread(7) : Start.
Thread(8) : Start.
Thread(7) : Sleep 1001ms
Thread(8) : Sleep 1636ms
Thread(9) : Start.
Thread(9) : Sleep 1573ms
Thread(7) : End.
Thread(2) : End.
Thread(0) : End.
Thread(1) : End.
Thread(3) : End.
Thread(4) : End.
Thread(9) : End.
Thread(8) : End.
Thread(5) : End.
Thread(6) : End.
All threads terminated.

매우 간단하고 사용하기도 편리하다.

아두이노에서 OLED 제어하기.

snoworca — Tue, 19 Aug 2014 10:17:47 +0900

이전에 알리 익스프레스에서 구입한 OLED 사용기(http://dev.re.kr/47)에서 OLED 제어에 대하여 간략하게 올린적이 있습니다만 그것보다 더 편리한 u8glib 사용에 대하여 정리해 보도록 하겠습니다. 좀 더 자세한 튜토리얼과 레퍼런스는 이 곳 https://code.google.com/p/u8glib/wiki/u8glib?tm=6 페이지 에서 확인 할 수 있습니다.

우선 제어하려고 하는 OLED 가 SPI 로 통신하는지 I2C 로 통신하는지부터 알아야 하며, 내장 컨트롤러에 대한 정보도 알아야 한다. OLED 를 판매하는 인터넷 쇼핑몰 페이지의 상세 정보나 데이터시트를 참고하거나, 모델명으로 구글링해보면 OLED 컨트롤러에 대한 정보를 얻을 수 있다.

지금 테스트 해보려는 OLED 는 아래 사진과 같이 두 가지 종류이며 모두 알리 익스프레스에서 구매하였다. 아래 왼쪽 사진의 것은 I2C 를 이용하여 통신을 하고 SSD1306 컨트롤러를 사용하며 128x64 의 해상도를 갖고 있고, 오른쪽 사진의 것은 0.5" 에 SPI 를 이용하여 통신을 하고 LD7032 컨트롤러를 사용하며 60x32 의 해상도를 사용하고 있다.

http://www.aliexpress.com/item/0-5-inch-OLED-display-shield-for-Arduino-OCELL/1944014364.html

http://www.aliexpress.com/item/White-0-96-I2C-IIC-Serial-128X64-OLED-LCD-LED-Display-Module-for-Arduino-51-Series/1669363955.html

(판매가 종료되면 링크가 잘릴수도 있습니다.)

연결 방법은 다음과 같다.

I2C 의 경우 -

OLED - 아두이노(UNO 기준)

VCC - 5v 혹은 3.3v

GND - GND 단자.

SCL - A5

SDA - A4

와 같은 순서로 연결하고,

SPI 일 경우는

OLED - 아두이노(UNO 기준)

VCC - 3.3v (OLED 종류에 따라 혹은 5v)

GND - GND 단자.

SCK (Clock) - 13

MOSI (Data in) - 11

CS (Chip select) - 10 또는 다른 임의의 포트.

A0 - 9 또는 다른 임의의 포트.

Reset - 임의의 포트.

와 같은 순서로 연결한다.

이제 OLED 를 u8glib 라는 라이브러리에 포함되어 있는 간단한 예제 코드를 돌려보도록 하겠다.

우선 https://code.google.com/p/u8glib/ 으로 들어가서 메인 페이지 중간쯤에 있는 U8glib for Arduino 라는 글씨 오른쪽에 있는 다운로드 버튼을 눌러 라이브러리 파일을 다운 받는다.

다운로드가 완료되면 압축을 풀어서 아두이노 라이브러리 폴더 내부에 압축을 푼 라이브러리 파일이 들어있는 폴더를 통째로 아두이노의 라이브러리 폴더로 복사하고 아두이노툴 상단 메뉴에서 스케치 -> 라이브러리 가져오기 -> Add Library 를 통하여 방금 아두이도 라이브러리 폴더 내에 복사한 U8glib 라이브러리의 폴더를 선택하여 추가한다.

그리고 라이브러이와 같이 포함된 예제 코드(파일 -> 예제 를 통하여 불러올 수 있음) 중에 HelloWorld를 한 번 실행시켜보자.

아마 컴파일시에 error 가 떨어질 것이다. 포함된 예제 코드에서는 u8g 라는 변수가 선언되지 않았기 때문이다.

sketch_aug19a:133: error: 'u8g' was not declared in this scope

(위와 같은 에러가 발생한다.)

예제 코드에서 u8g 라는 변수의 메소드(함수)등을 통하여 OLED 를 제어하는 것을 확인할 수 있다.

이 변수를 선언하기 위하여 아래와 같이 조금 번거롭지만 중요한 과정이 필요하다.

우선 다음 페이지에서 https://code.google.com/p/u8glib/wiki/device 제어 하려는 OLED 의 컨트롤러 이름과 해상도를 이용하여 거기에 맞는 생성자를 찾아야 한다.

예를 들어 위에 OLED 사진중에 왼쪽에 있는 기기의 컨트롤러는 SSD1306 이며, 128x64 해상도, 그리고 I2C 를 사용하므로 디바이스 이름은 u8g_dev_ssd1306_128x64_i2c 가 되고 따라서 생성자는 U8GLIB_SSD1306_128X64(U8G_I2C_OPT_NONE) 가 된다.

그리고 표의 가장 우측 부분에 나와있는 아두이노의 지원 여부에 대하여 확인 해야한다.

(위 표를 통하여 드라이버 컨트롤러 이름과 해상도를 통하여 지원되는 OLED 기기와 생성자를 확인해야 한다. )

U8GLIB_SSD1306_128X64(U8G_I2C_OPT_NONE)

이제 생성자를 알았으니 예제 코드 윗 부분 전역 변수 선언부에

U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE);

를 추가시켜 주면 된다. 그리고 예제를 실행 시키면 아래 사진처럼 잘 동작하는 것을 볼 수 있다.

위 OLED 사진의 오른쪽에 있는 기기는 LD7032 컨트롤러와 SPI 를 사용하고 60x32 픽셀을 사용하며 기본(하드웨어) SPI포트를 사용하므로 아래와 같은 생성자를 사용하면 된다.

U8GLIB_LD7032_60x32(cs, a0 [, reset])

이 생성자에 첫 번째 인자값은 SPI 로 통신하는 OLED 에 연결한 cs 의 포트 번호를 입력하면 되고, 두 번째 인자로 a0 에 연결한 포트 번호, 세 번째 인자로 reset 에 연결한 포트 번호를 입력하면 된다. reset은 옵션이다. 사용하는 환경에 따라서 넣지 않아도 된다.

만약 점퍼 케이블을 이용하여 OLED 의 cs 단자를 아두이노의 10 포트에, a0 을 9번 포트에, 그리고 reset 을 2번 포트에 연결할 경우 다음과 같이 사용하여 변수를 생성할 수 있다.

U8GLIB_LD7032_60x32 u8g(10, 9 , 2);

마찬가지로 위의 코드를 전역변수 선언부에 추가한다.

업로드 하면 예제 코드가 정상적으로 실행되는 것을 확인할 수 있다.

만약 여러분이 이 포스팅에서 언급한 OLED 와 다른 기기를 갖고 있어도 컨트롤러 이름과 해상도등 몇 가지 사양을 알고 있다면, 이 곳 https://code.google.com/p/u8glib/wiki/device 에서 지원 디바이스 목록을 확인한 뒤에 제공되는 생성자를 이용하여 언제든지 활용할 수 있다.

아래는 테스트 영상. u8glib 에 들어있는 예제 코드 일부를 돌려본 영상이다.

초점이 잘 안 맞는다;;

아두이노에서 PWM 제어와 NPN 트랜지스터를 이용한 LED 밝기 및 모터 속도 조절.

snoworca — Sun, 10 Aug 2014 12:52:47 +0900

3V 를 소비하는 LED 가 있다고 가정해 보자. 이 LED 의 밝기를 제어하기 위하여 전압을 변경할 수 있지만, 좀 더 간단한 방법으로 아두이노의 PWM 제어 기능을 이용하여 밝기를 조절할 수 있다. 만약 LED 에 전류를 1초간 공급했다가 다시 1초동안 끊고 또 다시 1초간 공급하는 과정을 반복한다면 우리 눈에는 LED 가 깜빡거리는 것으로 보인다. 하지만, 0.1 초 간격으로 신호를 끊고 다시 연결하고를 반복한다면 우리눈에는 LED 밝기가 원래 밝기에 비해 좀 어둡게 출력되는 것으로 보일 것이다. 이런 신호 폭을 조절하여 LED 의 밝기를 제어할 수 있다.

PWM 제어에 대한 자세한 설명 :

http://www.hanbit.co.kr/network/view.html?bi_id=1087

아두이노 우노에서는 3,5,6,9,10,11 포트에서 이 PWM 제어를 사용할 수 있으며, 포트 번호 옆에 물결 (~) 모양이 인쇄되어 있어 PWM 사용 가능한 포트임을 알려주고 있다. 이 포트를 이용하여 PWM 제어를 사용하기 위해서는 analogWrite(핀번호, 0~255 값) 함수를 사용해야 한다.

우선 PWM 으로 높은 전압이나 전류 제어를 위하여 NPN 트랜지스터가 필요하다.

(이 소자를 이용한다면 아두이노의 신호로 5v를 초과하는 높은 전압을 제어할 수 있다. )

사실 LED 같은 경우에는 NPN 트랜지스터가 없어도 충분히 쓸 수 있지만 모터는 반드시 사용해야 한다. 아두이노의 디지털 신호의 전류는 고작 40mA 밖에 내지 못 하기 때문이다.

디지털 회로에서 NPN 트랜지스터의 역할은 아래 그림과 같이 전류가 흐를 수 있도록 스위칭을 해준다.

(반대로 PNP 트랜지스터는 전류가 흐르고 있을 때, Base 에 신호가 들어가면 스위치가 떨어진다.)

만약 위 그림에서 아두이노의 디지털 포트에 연결된 Base 에 전류가 흐르게 되면 스위치는 닫히게 된다.

(Collector 와 Base 와 Emitter 의 위치는 각 소자의 데이터 시트를 참고.) 여기서 주의할 점은 아두이노의 디지털 포트와 Base 사이에 저항을 달아야 한다는 것이다.

아래 회로에서는 2N2222 를 사용하였다, 또 전압이나 전류의 특성에 따라서 TIP120 과 같은 다른 소자를 사용할 수 있다.

위 그림에 있는 아두이노는 USB연결등 몇 가지를 제외하면 아두이노 uno 와 스펙이 거의 같은 아두이노 나노의 호환 보드이다.

아두이노 VCC 5v ------------------------------ LED +

아두이노 GND -------------------------------- 2N2222 pin 3. (emitter)

아두이노 6 번 포트 ------ 2.2KOhm --------- 2N2222 pin1 (base)

LED- ---------------------- 680Ohm----------- 2N2222 pin 2 (collector)

680Ohm 은 LED 특성에 맞춰서 사용한 것이다.

Code:

#define CTR_PIN 6

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


void loop(){
  for(int i = 0; i<180; i++){
    // 점차 밝아졌다 낮아졌다를 반복하도록 한다.
    int val = (int)map((int)((sin(DEG_TO_RAD * i) * 1000.0f)), 0, 1000,0,255); 
    analogWrite(CTR_PIN, val);
    delay(5);
  }
}

이 코드에서는 PWM 의 제어 범위인 0~255 를 사용하지 않고, 0~128을 사용하였다. 128이상부터 255까지는 값이 차이가 무의미할 정도로 밝기가 비슷하므로 최대 값으로 128으로 주게 되었다.

결과:

아래 예제에서는 블루투스와 안드로이드폰을 이용하여 밝기를 제어해 보는 것을 구현해 보았다.

우선 아두이노의 코드이다. 소프트웨어시리얼로부터 0부타 255 까지의 값을 받아 PWM 포트로 출력해주는 코드이다.

Code:

#include <SoftwareSerial.h>

#define RX_PIN 3 
#define TX_PIN 2 

#define LED_PIN 13 
#define PWM_PIN 6 

SoftwareSerial swSerial(RX_PIN, TX_PIN); // 첫 번째 인자 : RX, 두 번째 인자 TX

uint8_t data;

void setup() {
  swSerial.begin(9600);
 pinMode(PWM_PIN, OUTPUT);
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_PIN, LOW);
  // 데이터가 들어올때 까지 대기.
  while(!swSerial.available());
  digitalWrite(LED_PIN, HIGH);
  while(swSerial.available()) {
    data = swSerial.read();
    analogWrite(PWM_PIN, data / 5);
    delay(1);
  }   

}

data 는 0부터 255까지 받을 수 있는데, 일부러 5를 나누어 줬다. 낮은 값에서 값이 빛이 변할때는 변화가 커 보이고, 높은 값에서는 값의 변화에 따라 빛의 밝기가 별 차이가 없어보이기 때문이다.

Android Project:

https://github.com/ice3x2/HC-06_Arduino_Echo/tree/SlideControl

이전에 만들었던 블루투스 에코 예제를 수정하였다.

결과:

Tip120 을 활용하여 PC 용 쿨링팬을 컨트롤.

아래 쿨링팬은 12v 로 동작하며 2N2222 대신 좀 더 높은 전압(max 60v) 과 높은 전류(max 8A) 를 스위칭 할 수 있는 ~~그리고 비싼~~ TIP120 을 이용하여 다음과 같은 회로를 구성하였다. 물론 2N2222 나 기타 다른 NPN 트랜지스터를 사용하여도 상관 없다.

(간혹 PWM 제어가 되지 않는 쿨링팬이 있다. 실제 예로 여러번 테스트 결과 싸구려 쿨러는 제어가 잘 되지만, 쿨러마스터 터빈 마스터는 제어가 안 된다.)

12v 아답터 + ---------------------------------- 12v PC Fan +

GND -------------------------------------------- Tip120 pin 3. (emitter)

아두이노 6 번 포트 ------ 2.2KOhm --------- Tip120 pin1 (base)

12v PC Fan - ----------------------------------- Tip120 pin 2 (collector)

그 외의 블루투스 연결과 아두이노 코드와 안드로이드용 프로젝트는 위에서 소개한 것을 그대로 적용하면 된다.

안드로이드에서 현재 Task 에 있는 Activity 인스턴스 가져오기.

snoworca — Sun, 13 Jul 2014 18:03:23 +0900

우선 가장 간단한 방법으로는 ActivityManager 를 사용하는 방법이다. 그러나 이 것으로 현재 메모리상에 생성된 Activity 의 객체들을 가져올수도 없고 매니페스트에 퍼미션도 줘야 하는데 영 찜찜하다.

다른 개발자들은 동적으로 ActivityStack 에 있는 액티비티의 인스턴스를 어떻게 가져오나 궁금하여 스택 오버플로우를 찾아봤는데, 많은 개발자들이 Application 클래스를 상속받아 이 곳에 Activity를 관리하는 별도의 리스트를 만들어 사용하고 있었다.

하지만 프로젝트마다 이렇게 구현하면 여간 귀찮은 것이 아니라서, 그냥 각 Task 내의 Activity 의 래퍼런스들을 담고있는 리스트를 갖고 있는 싱글톤 객체를 이용하여 ActivityStack 을 구현해 보았다.

우선 코드는 다음과 같다.

ActivityStack.java 코드 보기

ActivityStack.java 코드 감추기

package kr.re.Dev.ActivityStack;

import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import android.annotation.SuppressLint;
import android.app.Activity;
import android.util.Log;

/**
 * ActivityStack
 * Dev.re.kr
 * @author ice3x2@gmail.com
 */
public class ActivityStack {

	private static int sLastActivityNumber = 0;
	private static ActivityStack mThis;
	private ArrayList<ActivityRef> mActivityAliveList;
	 
	/**
	 * Activity 등록 정보.
	 * @author ice3x2
	 */
	private class ActivityRef {
		WeakReference<Activity> ref = new WeakReference<Activity>(null);
		boolean isResume = false;
		String aliveID = "";
		int taskID = 0;
	
	}

	
	private ActivityStack() {
		mActivityAliveList = new ArrayList<ActivityRef>();
	}
	
// public :
	
	/**
	 * ActivityStack 의 싱글 인스턴스를 가져온다. 
	 * @return ActivityStack 의 인스턴스.
	 */
	public static ActivityStack getInstance() {
		if(mThis == null) {
			mThis = new ActivityStack();
		}
		return mThis;
	}
	
	/**
	 * 현재 프로세스 상에 존재하는 Task 의 ID 값들을 가져온다. 이 것은 Activity 내의 getTaskId 메소드로 얻을 수 있는 값과 일치한다. 
	 * @return TaskID TaskID 들의 리스트.
	 */
	public Integer[] getAliveTaskIDs() {
		cleanGarbageActivities();
		cleanGarbageActivities();
		Set<Integer> taskSet = new HashSet<Integer>();
		for(ActivityRef ref : mActivityAliveList) {
			taskSet.add(ref.taskID);
		}
		 Integer[] aliveTaskIds =  taskSet.toArray(new Integer[0]);
		return aliveTaskIds;
	}
	
	/**
	 * 특정 Activity 가 BaseActivity 로 있는 Task 의 ID 값들을 가져온다.
	 * @param baseActivityClass BaseActivity 가 되는 Activity 의 클래스 정보.
	 * @return TaskID 들의 리스트.
	 */
	public Integer[] getAliveTaskIDByBaseActvity(Class<?> baseActivityClass) {
		cleanGarbageActivities();
		ArrayList<ActivityRef> subList = subList(baseActivityClass);
		Set<Integer> taskSet = new HashSet<Integer>();
		for(ActivityRef ref : subList) {
			taskSet.add(ref.taskID);
		}
		 Integer[] aliveTaskIds =  taskSet.toArray(new Integer[0]);
		return aliveTaskIds;
	}
	
	/**
	 * 특정 Task 상에 있는 Activity 들의 AliveID 값들을 가져온다.<br/>
	 * AliveID 값은 [임의의 식별 번호]:[Class name of Activity] 로 되어 있다. <br/>
	 * 배열 내의 순서는 stack 그대로라고 볼 수 있다.
	 * 모든 Activity가 ActivityStack 를 사용할 경우 0 번 인덱스에 있는 Activity 는 base activity 이고, 가장 마지막에 있는 Activity 는 top Activity 가 된다.    
	 * @param taskID Task 의 id. Activity 의 getTaskId() 메소드를 이용하거나 ActivityManager 를 이용하여 가져온 task 값 입력. 
	 * @return AliveID : 현재 ActivityStack 내에서 관리되는 각 Activity 들의 ID 값. 
	 */
	public String[] getAliveIDsInTask(int taskID) {
		cleanGarbageActivities();
		ArrayList<ActivityRef> subList = subList(taskID);
		String[] aliveIDs = new String[size()];
		for(int i = 0, n = subList.size(); i < n; ++i) {
			aliveIDs[i] =  subList.get(i).aliveID;
		}
		return aliveIDs;
	}
	
	
	/**
	 * 모든 Task 에 존재하는 Activity 들의 AliveID 값들을 가져온다.<br/>
	 * AliveID 값은 [임의의 식별 번호]:[Class name of Activity] 로 되어 있다. <br/>
	 * 배열 내의 순서는 액티비티가 생성되고 종료된 순서와 일치한다. 만약 프로세스 내에 Task 가 하나만 존재한다면, 실제 안드로이드 내부에서 관리되는 Activity stack 과 일치한다.
	 * 가장 먼저 생성된 Activity 는 0 번 인덱스에 위치하게 되고 가장 마지막에 생성된 Activity 는 가장 마지막 인덱스에 위치하게 된다.    
	 * @return AliveID : 현재 ActivityStack 내에서 관리되는 각 Activity 들의 ID 값.
	 */
	public String[] getAliveIDs() {
		cleanGarbageActivities();
		String[] aliveIDs = new String[size()];
		for(int i = 0, n = size(); i < n; ++i) {
			aliveIDs[i] =  mActivityAliveList.get(i).aliveID;
		}
		return aliveIDs;
	}
	
	/**
	 * AliveID 를 가져온다.
	 * @param activity 만약 ActivityStack 에 등록된 Activity가 아니라면 빈 문자열을 반환한다.
	 */
	public String getAliveID(Activity activity) {
		ActivityRef ref = getActivityRef(activity);
		if(ref != null) return ref.aliveID;
		else return "";
	}
	
		
	/**
	 * 특정 Task 상에 있는 Activity 중에 스택의 가장 위에 있는 (예를 들자면 화면에 보여지는) Activity instance 를 가져온다.
	 * @param taskID Task 의 id. Activity 의 getTaskId() 메소드를 이용하거나 ActivityManager 를 이용하여 가져온 task 값 입력.
	 * @return Activity instance
	 */
	public Activity getTopActivityInTask(int taskID) {
		cleanGarbageActivities();
		ArrayList<ActivityRef> subList = subList(taskID);
		int size =  subList.size(); 
		if(size > 0) {
			return subList.get(size - 1).ref.get();
		}
		return null;
	}
	
	/**
	 * 특정 Task 상에 있는 Activity 중에 스택의 가장 아래에 있는 Activity 의 instance 를 가져온다.
	 * @return Activity instance
	 */
	public Activity getBaseActivityInTask(int taskID) {
		cleanGarbageActivities();
		ArrayList<ActivityRef> subList = subList(taskID);
		if(subList.size() > 0) {
			return subList.get(0).ref.get();
		}
		return null;
	
	}
	
	/**
	 *  Activity 를 가져온다.
	 * @param AliveID - getAliveIDsInTask() 또는 getAliveIDs() 을 통하여 가져온 Activity 의 getAliveID 값을 넣는다. 
	 * @return Activity instance
	 */
	public Activity getActivity(String aliveID) {
		cleanGarbageActivities();
		return getActivityRef(aliveID).ref.get();
	}
	
	/**
	 * ActivityStack에 등록된 모든 Activity 들이 현재 살아있는지 체크한다.  	
	 * @return 만약 false 를 리턴한다면 실행되고 있는 (등록된) Activity 는 하나도 없는 것이다.  
	 */
	public boolean isRunning() {
		return size() > 0;
	}
	
	/**
	 * 특정 Task 내의 Activit 가 현재 살아있는지 체크한다.
	 * @param task Task 의 id. Activity 의 getTaskId() 메소드를 이용하거나 ActivityManager 를 이용하여 가져온 task 값 입력.
	 * @return 만약 false 를 리턴한다면 Task 내부에 실행되고 있는 (등록된) Activity 는 하나도 없는 것이다.
	 */
	public boolean isTaskRunning(int task) {
		cleanGarbageActivities();
		return subList(task).size() > 0;
	}
	
	/**
	 * 특정 Task 내의 ActivityStack 의 크기를 가져온다.
	 * @param task Task 의 id. Activity 의 getTaskId() 메소드를 이용하거나 ActivityManager 를 이용하여 가져온 task 값 입력.
	 * @return ActivityStack 의 크기. 0을 반환할 경우 Task가 없거나 실행되고 있는 Activity 가 아직 없는 것이다. 
	 */ 
	public int sizeInTask(int task) {
		cleanGarbageActivities();
		return subList(task).size();
	}
	
	
	/**
	 * ActivityStack 의 크기를 가져온다. 즉, 모든 등록된 Activity 의 개수를 가져오는 것이다. 
	 * @return ActivityStack 의 크기. 0을 반환할 경우 Task가 없거나 실행되고 있는 Activity 가 아직 없는 것이다. 
	 */
	public int size() {
		cleanGarbageActivities();
		return mActivityAliveList.size();
	}
	
	/**
	 * Foreground 상태인가? - 등록된 액티비티중 하나라도 화면에 가장 위에 보여지는 경우. 	
	 * @return false 일 경우 background 상태. 다른 프로세스의 액티비티등에 의해서 일부만 가려져도 false 리턴. resume 상태인 activity 가 있다면 true.
	 */
	public boolean isForeground() {
		Activity activity = getForegroundActivity();
		return activity != null;
	}
	
	/**
	 *  특정 Task 가 Foreground 상태인가? - 등록된 액티비티중 하나라도 화면에 가장 위에 보여지는 경우.
	 *  @param task Task 의 id. Activity 의 getTaskId() 메소드를 이용하거나 ActivityManager 를 이용하여 가져온 task 값 입력.
	 *  @return false 일 경우 background 상태. 다른 프로세스의 액티비티등에 의해서 일부만 가려져도 false 리턴. resume 상태인 activity 가 있다면 true.
	 */
	public boolean isForeground(int taskId) {
		Activity activity = getForegroundActivity();
		return activity != null && activity.getTaskId() == taskId;
	}
	
	/**
	 * Foreground 상태. 즉 화면에 출력되는 Activity 의 instance 를 가져온다.
	 * @return 만약 background 상태라면 null 을 리턴한다. 
	 */
	public Activity getForegroundActivity() {
		cleanGarbageActivities();
		ActivityRef ref = getResumeActivityRef();
		if(ref != null && ref.ref != null) return ref.ref.get();
		return null;
	}
	
	/**
	 * resume 상태. 반드시 Activity 내부의 onResume() 에서 호출해야 한다.
	 * @param activity 대상 activity 
	 * @return 대상 Activity 가 등록되어 있지 않았다면 false. false 를 리턴하는 경우는 setCreateState 메소드를 이용하여 activity 를 등록하지 않았거나 destroy 된 activity 일 경우.
	 */
	public boolean regOnResumeState(Activity activity) {
		cleanGarbageActivities();
		ActivityRef ref = getActivityRef(activity);
		if(ref != null) {
			ref.isResume = true;
			return true;
		}
		return false;
	}

	/**
	 * pause 상태. 반드시 Activity 내부의 onPause() 에서 호출해야 한다.
	 * @param activity 대상 activity 
	 * @return 대상 Activity 가 등록되어 있지 않았다면 false. false 를 리턴하는 경우는 setCreateState 메소드를 이용하여 activity 를 등록하지 않았거나 destroy 된 activity 일 경우.
	 */
	public boolean regOnPauseState(Activity activity) {
		cleanGarbageActivities();
		ActivityRef ref = getActivityRef(activity);
		if(ref != null) {
			ref.isResume = false;
			return true;
		}
		return false; 
	}
	
	/**
	 * Activity 가 생성되어 시작되는 상태. 반드시 Activity 내부의 onCreate() 에서 호출해야한다. 이 메소드를 호출하면 ActivityStack 에 인자값으로 들어간 activity 가 등록된다. 
	 * @param activity 대상 activity 
	 * @return 대상 Activity 가 등록되어 있지 않았다면 false. false 를 리턴하는 경우는 setCreateState 메소드를 이용하여 activity 를 등록하지 않았거나 destroy 된 activity 일 경우.
	 */
	public final void  regOnCreateState(Activity activity) {
		cleanGarbageActivities();
		addActivityRef(activity);
	}
	
	/**
	 * Activity 가 제거되는 상태. 반드시 Activity 내부의 onDestroy() 에서 호출해야한다. 이 메소드를 호출하면 ActivityStack 에 인자값으로 들어간 activity 가 삭제된다. 
	 * @param activity 대상 activity 
	 * @return 대상 Activity 가 등록되어 있지 않았다면 false. false 를 리턴하는 경우는 setCreateState 메소드를 이용하여 activity 를 등록하지 않았거나 destroy 된 activity 일 경우.
	 */
	public final boolean regOnDestroyState(Activity activity) {
 		return removeActivityRef(activity);
		
	}
	
	
	/**
	 * 예:) [{"taskId":1,activityStack:["0:com.test.activity","1:com.test.activity"...,]},
	 * 	    {"taskId":2,activityStack:["10:com.test.activity","11:com.test.activity"...,]},]  
	 */
	public String toString() {
		cleanGarbageActivities();
		StringBuilder strBuilder = new StringBuilder();
		strBuilder.append("[");
		Integer[] taskIDs  =  getAliveTaskIDs();
		for(Integer taskID : taskIDs) {
			strBuilder.append("{\"taskId\":").append(taskID).append(",\"activityStack\":[");
			ArrayList<ActivityRef> subList = subList(taskID);
			for(ActivityRef ref : subList) {
				strBuilder.append("\"").append(ref.aliveID).append("\",");
			}
			strBuilder.append("]},");
		}
		strBuilder.append("]");
		return strBuilder.toString();
		
		
	}	
	
	
// private : 
	
	private ActivityRef createActivityRef(Activity activity) {
		ActivityRef activityRef = new ActivityRef();
		activityRef.ref = new WeakReference<Activity>(activity);
		activityRef.aliveID =  makeAliveID(activity);
		activityRef.taskID =  activity.getTaskId();
		return activityRef;
	}
	
	
	
	private String makeAliveID(Activity activity) {
		return sLastActivityNumber++ + ":" + activity.getClass().getName();
	}
	
	
	private void addActivityRef(Activity activity) {
		ActivityRef activityRef = createActivityRef(activity);
		mActivityAliveList.add(activityRef);
	}
	
	private boolean removeActivityRef(Activity activity) {
		Iterator<ActivityRef> iter =  mActivityAliveList.iterator();
		while(iter.hasNext()) {
			ActivityRef iterItem = iter.next();
			Activity itemActivity = iterItem.ref.get();
			if(iterItem.ref.get() != null && activity == itemActivity) {
				iter.remove();
				return true;
			}
		}
		return false;
	}
	
	private ActivityRef getActivityRef(Activity activity) {
		Iterator<ActivityRef> iter =  mActivityAliveList.iterator();
		while(iter.hasNext()) {
			ActivityRef iterItem = iter.next();
			Activity activityItem =  iterItem.ref.get();
			if(activityItem != null && activityItem == activity) return iterItem;
		}
		return null;
	}
	
	private ActivityRef getActivityRef(String aliveID) {
		Iterator<ActivityRef> iter =  mActivityAliveList.iterator();
		while(iter.hasNext()) {
			ActivityRef iterItem = iter.next();
			if(iterItem.aliveID.equals(aliveID)) return iterItem;
		}
		return null;
	}
	
	private ActivityRef getResumeActivityRef() {
		Iterator<ActivityRef> iter =  mActivityAliveList.iterator();
		while(iter.hasNext()) {
			ActivityRef iterItem = iter.next();
			Activity activityItem =  iterItem.ref.get();
			if(activityItem != null && iterItem.isResume) return iterItem;
		}
		return null;
	}
	
	
	private ArrayList<ActivityRef> subList(int taskID) {
		ArrayList<ActivityRef> subList = new ArrayList<ActivityRef>();
		Iterator<ActivityRef> iter =  mActivityAliveList.iterator();
		while(iter.hasNext()) {
			ActivityRef iterItem = iter.next();
			if(iterItem.taskID == taskID) subList.add(iterItem);
		}
		return subList;
	}
	
	
	private ArrayList<ActivityRef> subList(Class<?> activityClass) {
		ArrayList<ActivityRef> subList = new ArrayList<ActivityRef>();
		Iterator<ActivityRef> iter =  mActivityAliveList.iterator();
		while(iter.hasNext()) {
			ActivityRef iterItem = iter.next();
			if(iterItem.ref.get() != null && iterItem.ref.get().getClass().equals(activityClass)) subList.add(iterItem);
		}
		return subList;
	}
	
	@SuppressLint("NewApi")
	private void cleanGarbageActivities() {
		Iterator<ActivityRef> iter =  mActivityAliveList.iterator();
		while(iter.hasNext()) {
			ActivityRef iterItem = iter.next();
			if(iterItem.ref.get() == null || 
					(android.os.Build.VERSION.SDK_INT >= 17 && iterItem.ref.get().isDestroyed()))    {
				iter.remove();
				Log.i("remove", "destroyed : " + iterItem.aliveID);
			}
		}
	}
	
}

StackActivity.java 코드 보기

이 곳에서 최신 코드를 보거나 다운로드 받을 수 있다.

https://github.com/ice3x2/ActivityStack_ice3x2

사용법은 ItemActivity 를 사용 하려는 Activity 에서 상속받아 사용하거나, StackActivity 코드처럼 ActivityStack 클래스의 메소드를 호출하여 사용하면 된다. 다만, 각 이벤트 메소드에 맞는 ActivityStack 의 메소드 호출을 실수로 빠뜨리거나 잘못 호출하면 메모리 누수가 일어날 수도 있으니 주의하자.

만약 아래 그림(?) 처럼 두 개의 Task 가 있고 이 곳에 Activity 가 실행되고 있다고 가정한다.

각 박스의 윗 부분은 Application 의 패키지 명을 타나내고 밑은 Activity 이름을 나타낸다. 그리고 com.xx.xx 패키지의 ActivityC 가 화면에 보여지는 상태다. (onResume 이 호출된 상태)

(Foreground)

TaskID:13 | com.xx.xx | com.xx.xx | com.xx.xx |

| ActivityA | ActivityB | ActivityC |

우선 아까도 언급했지만, 사용하려는 대상 Activity 에서는 StackActivity 를 상속받거나 onCreate, onDestroy, onResume, onPause 에서 ActivityStack 의 각 메소드들을 호출해야 한다. (StackActivity 내부 코드 참고)

- com.xx.xx 패키지의 앱 내부에서 같은 패키지의 Activity 가 실행되고 있는 TaskID 들 가져오기.

ActivityStack activityStack =  ActivityStack.getInstance(); 
Integer[] taskIds = activityStack.getAliveTaskIDs();

- 결과 : [12,13]

- 현재 화면에 보여지고 있는 Activity 인스턴스 가져오기

ActivityStack activityStack =  ActivityStack.getInstance(); 
Activity foregroundActivity = activityStack.getForegroundActivity();

- 결과 : task ID 12 에 올라간 ActivityC 의 인스턴스를 가져온다.

- 현재 어플리케이션이 실행중인지 알아보기

ActivityStack activityStack =  ActivityStack.getInstance(); 
boolean isRun = activityStack.isRunning();

- 결과 : true

나머지 사용법은 ActivityStack.java 파일의 주석을 참고하자.

마지막으로, 이 방법은 좋지 않은 방법이다. 잘못 사용하면 어떤 결과를 초래할지 모르고 메모리 누수의 위험도 있다. 게다가 이름만 ActivityStack 이다. 실제 Task 위에 있는 액티비티 스택과 혼동하면 안 된다.

Service 내부에서 유지보수 하기 귀찮은 Broadcastreceiver 와 ActivityManager 를 쓰지 않고 액티비티가 살았는지 죽었는지, 또는 Foreground 인지 확인할때와 Task 상에 쌓여있는 Activity 들을 정리할 때, 유용하게 사용할 수 있지만 그 외의 경우에는 조심해서 사용하자. 만약에 Activity 가 Background 에 있는 상태에서 Fragment 를 붙이거나 Dialog 를 띄운다면 Runtime Exception 이 발생하기 때문이다.

FTDI 사용하여 업로드시 avrdude: stk500_recv(): programmer is not responding 가 뜰때. - 아두이노 미니, 서드파티 아두이노 에서.

snoworca — Sun, 13 Jul 2014 16:52:28 +0900

우선 아래 포스팅은 근본적인 해결책이 아니다.

본인 같은 경우에는 드라이버 및 OS 업데이트를 통하여 이 문제를 해결하였다.

맥을 사용하고 OS는 매버릭스를 사용하는 환경에서 이와 같은 문제가 발생한다. (어쩌면 윈도우에서도 발생할지 모르겠다.) 구글링을 해보니 아두이노판 스텍 오버플로우에서 쉽게 찾을 수 있었다.

먼저 이게 드라이버의 문제인지 뭐가 잘못된건지 잘 모르겠지만 FTDI 드라이버를 아두이노에 연결하여 컴파일된 코드를 올리면 다음과 같은 에러가 발생한다. (물론 드라이버는 최신 상태로 업데이트 하였다. 간혹 잘 되는 경우도 있다. ㅡ, ㅡ;;)

아주 열받는 상황이다.

조금 귀찮은 트릭을 사용하여 이 문제를 해결할 수 있다.

우선 상단 메뉴에서 Arduino->환경 설정 을 열어서 다음과 같은 창을 띄운다.

그리고 다음 동작중 자세한 출력 보이기 메뉴에서 업로드 체크 박스에 체크 하고 확인 버튼을 누른다.

그리고 업로드를 실행하여 아래 출력창을 보면...

역시 마찬가지 결과다...

위 스샷에서 보면 Overriding Baud Rete : 57600 이라고 표시된 줄이 중간쯤에 보인다.

이 줄이 출력되자마자 잽싸게 리셋 버튼을 눌러야 한다.

이 상태에서 바로 리셋버튼!! (연타하면 안 된다;;)

그럼 위 스샷처럼 데이터들이 줄줄줄 올라가는 것이 보이고 나서 정상적으로 업로드가 완료된다.

참, 불편하다.

업로드되는 로그를 보기 싫으면 환경 설정에서 다시 꺼도 되는데, Overriding Baud Rete : 57600 가 뜨는 시간을 계산하여 타이밍에 맞춰서 리셋 버튼을 눌러줘야 한다.

아두이노와 호환되는 저렴한 OLED 모듈 사용기.

snoworca — Sun, 13 Jul 2014 16:30:03 +0900

u8glib 라이브러리를 활용한 좀 더 쉬운 OLED 사용법은 http://www.dev.re.kr/51 에 포스팅 해 놓았습니다.

바로 이전 포스팅에 이어서 이번에도 알리 익스프레스에서 구매했다.

6.66$ 나름대로 저렴한 가격이다.

I2C 를 사용한다고 하는데, 이 통신 방법에 대해서는 다음 위키 페이지에서 요약된 정보를 확인할 수 있다.

http://ko.wikipedia.org/wiki/I%C2%B2C

앞 모습. 보호 필름이 발라져 있다.

뒷 모습. 핀헤더 아래를 보면 Address Select 라고 써져있는 부분이 보인다. 이 부분을 자세히 보자.

주소가 0x78 으로 표시되어 있는데, 각 디바이스마다 고유의 주소 값을 갖고 있고, 이 것을 선택하여 여러대의 I2C 기기를 컨트롤 할 수 있다고한다.

배선은 VCC(5V) 와 GND 를 각각 맞는 곳에 연결하고 Arduino uno 기준으로 (ATMega328) SDA 는 A4 에 SCL 은 A5 에 연결한다.

이 제품의 스펙을 보면 SSD1306 이라는 LCD 드라이버 칩을 사용하는 것을 알 수 있다. 데이터 시트를 보고 구현 하려다 뭔가 복잡함에 멘붕먹고 라이브러리를 찾아보았다. 관련 라이브러리는 GPL 라이센스로 Git Hub 에 MultiLCD 라는 이름으로 올라가 있다.

https://github.com/stanleyhuangyc/MultiLCD

이 OLED 모듈을 사용하기 위해서는 MicoroLCD 폴더에 있는 파일들이 필요하며 그 내부에 있는 examples 폴더에서 예제 파일을 통하여 동작을 확인해 볼 수 있다. 그리고 주소값을 입력해줘야 하는 중요한 작업이 필요한데, SSD1306.h 파일에서 위에서 세 번째 정도에 있는 #define SSD1306_I2C_ADDRESS 0x3C 부분을 #define SSD1306_I2C_ADDRESS 0x78 로 수정해 준다. 만약 주소가 0x78 이 아니라 다른 주소로 되어있을 경우에는 그 것으로 수정하면 된다. (바로 위 사진 참고.)

이제 예제를 돌려보면 다음과 같이 텍스트와 이미지가 출력되는 것을 확인할 수 있다.

저렴한 RGB LED (WS2812B) 구입/사용기.

snoworca — Sun, 13 Jul 2014 15:56:53 +0900

(WS2812B 사용법및 예제 소스는 다음 포스팅 http://www.dev.re.kr/57 에서 확인할 수 있습니다.)

뭐를 만드려고 하는데, RGB LED 개 열 개 정도 필요하게 되었다. 좋은 대안은 컨트롤하기 편한 Adafruit 에서 만든 NeoPixel 이 되겠다. 이 녀석은 디지털 출력 포트 하나로 여러 모듈을 동시에 컨트롤 할 수 있다는 것이 가장 큰 장점이다. 하지만, 좀비싸다. ㅠㅠ

알리 익스프레스를 뒤져본 결과 NeoPixel 에 들어가는 WS2812B가 올라간 모듈을 아주 싼 가격에 팔고 있었다.

100개에 17.99달러!!

나는 10개만 필요하기 때문에 불량품이 있을 것을 감안하여 20개를 구입하였다. 무료 배송을 선택하고 2주 하고 5일 뒤에 상품이 왔다.

이런식으로 붙어있긴 하지만, 각 모듈과 모듈 사이에 회로가 연결되어 있는 것은 아니다. 하나씩 뜯어서 사용할 수 있다.

뒷 모습. 땜질을 아주 잘 해야 한다. 인두가 흰색 부분을 스치기만 해도 검게 타버린다.

플럭스가 없으면 납이 잘 달라붙지도 않는다.

동전과의 크기 비교. 정말 작다.

사용법은 GitHub 에 있는 NeoPixel 용 라이브러리를 사용하면 된다. (https://github.com/adafruit/Adafruit_NeoPixel) 그 밖에 여러 사람들이 WS2812B 을 사용할 수 있는 아두이노용 라이브러리를 커밋하고 있으니 참고하자.

위 영상은 https://github.com/adafruit/Adafruit_NeoPixel 의 예제 코드를 실행한 영상이다.

예제 코드에서 LED개수를 3개로 수정해줘야 한다.

아두이노 프로 미니 호환 구입기에서 소개한 모듈에 WS2812B 과 배터리를 연결한 모습.

(P.s : 왕초보자라면 NeoPixel 을 추천한다. 땜하기도 어렵고 내구성이 조금 떨어지는 편이다.)

(WS2812B 예제 : http://www.dev.re.kr/57 )

알리 익스프레스로 구입한 호환 아두이노 프로 미니.

snoworca — Sun, 13 Jul 2014 15:12:34 +0900

약 한 달 전에 알리 익스프레스라는 곳을 알게 되었다. 이전에는 국내에서 구하기 힘든 물건들은 이베이나 아아존 구매대행 사이트나 배송대행 업체를 이용하여 직구하기도 하였는데, 수수료와 배송비의 압박으로 부터 자유롭지 못 했다. 하지만 중국판 아마존인 알리 익스프레스는 달랐다. 중국 소포를 이용한 무료 배송을 해주는 상점이 많고, 제품들도 무척 저렴했다. - 당연히 구매 절차는 매우 간단하다. VISA 카드등 해외 결제가 가능한 체크카드나 신용 카드만 있으면 된다. - 물론 가품이나 문제가 있는 제품도 많아서 마치 확률 높은 도박을 해야한다는 단점이 있다. 인터넷을 뒤져보면 풍부한 구매 후기등이 있는데, 많은 수가 사기를 당하거나 문제있는 제품을 구매했다고한다. - 아마도 물건 구매에 실패한 사람들이 속상한 심정을 토로하며 후기를 올렸을 것이다. - 그래서 항상 구매 보호 마크가 있거나 피드백등을 잘 보고 구입할 물건을 선택해야한다. 다행히도 내가 구입하려고 하는 여러 전자 부품들은 중국에서 생산되는 경우가 많아서 상품도 많고 가격도 저렴하고 피드백도 좋다. 그 중에 첫 번째로 구매한 아두이노 프로 미니 호환 제품에 대하여 소개할까 한다.

우선 위 스샷과 같이 Arduino pro mini 로 검색하면 다양한 제품들이 쏟아져 나오는데, 주로 모듈만 묶음으로 팔거나 시리얼 통신용 USB 변환 모듈과 같이 파는 경우가 있다. 국내에서 구매하면 각 모듈당 1만원이 넘는 가격을 지불해야 하는데 이 곳에서는 자체 생산하여 파는지 너무나 저렴하다.

나는 이미 FTDI 가상 시리얼 드라이버 모듈을 갖고있기 때문에 위 스샷에서 가장 첫 번째 제품을 구매하였다. 아두이노 프로 미니 호환 모듈 10개에 21.47$ 라는 내 눈을 의심하게 만드는 가격에 판매가 되고 있다. 10으로 나눠보면 모듈 하나당 2.147$ 이라는 가격인데, 대략 우리나라 돈으로 대략 2,200원 밖에 안 한다. 술 한 번 안 마신다 생각하고 과감히 배송 옵션에 EMS (15$) 을 선택하였다. 보통 China post mail 을 선택하면 배송료가 싸거나 무료인 대신에 2~3주 걸리고 물건을 분실할 수 있는 반면에 돈을 지불하고 EMS 같은 서비스를 이용하면 주문한지 3~6일만에 물건을 받을 수 있다. 나도 3일만에 물건을 받을 수 있었다.

테이프가 엄청 꼼꼼하게 발라져 있어서 뜯는데 고생좀 했다.

이렇게 10개가 들어있다.

정전기 방지 봉투에 핀헤더와 모듈이 나누어져 담겨있다.

납땜을 이용하여 핀헤더를 모듈에 붙어야 한다.

납땜을하여 핀헤더 연결을 완료한 모습.

아날로그 포트에 사용되는 핀헤더는 제공되지 않는데,

브레드 보드에 사용하기에는 없는 편이 더 낫다.

FTDI 모듈에 연결하여 Blink 예제를 올려본 모습이다.

부품은 괜찮은 것을 썼는지등에 대하여, 또 10개 제품중에서 혹시나 불량품이 있지 않을까하는 의구심이 드는 것도 사실이지만 일단 상품 페이지의 피드백을 보면 여러 나라의 구매자들이 별점 다섯개를 쿨하게 날리는 것을 보고 안심하고 현재 진행하는 프로젝트에 적용하기로 하였다.