초코볼의 inside Tech

1. Arduino DIY

Arduino 및 테스트용 PCB 등을 무료로 나누어 주는 좋은 회사가 있습니다.

* Board Lab (Board Free)

- http://www.boardfree.kr/

버려지거나 중복되는 PCB 들을 무료로 나누어 주시는 것을 사이드업으로 해주고 계십니다. (고마운 분들)

혹시, 요청하실 분이 계시다면, 수량에 한계가 있으며 무료나눔이 회사의 본업이 아니다 보니, 최대한 조심해서 요청하세요.

보다 자세한 유념 사항은 사이트에 잘 기재되어 있으니, 꼼꼼히 읽어 주시길 바랍니다.

PCB 무료나눔을 통해, 부품공부나 SMD 실장에 대해 경험 할 수 있었습니다.

그 결과물로는 arduino 를 가지게 되는 것이죠. 지금까지 아래와 같은 과정이 있었습니다.

* Hardware | Arduino 를 DIY 해보자 - 1

- http://chocoball.tistory.com/entry/Hardware-Arduino-DIY-itself-1

* Hardware | Arduino 를 DIY 해보자 - 2

- http://chocoball.tistory.com/entry/Hardware-Arduino-DIY-itself-2

* Hardware | Arduino 를 DIY 해보자 - 3

- http://chocoball.tistory.com/entry/Hardware-Arduino-DIY-itself-3

Arduino Nano 도 작업하고 있습니다만, 과정중에 ATmega328P-AU 부트로더에 막혀 있습니다.

아마 AliExpress 에서 fake CPU 가 왔거나, 제가 처음에 fuse bit 을 잘못 해서 그런 것 같아요.

머리를 식힐 겸, 나눔 받은 BL-303 이라는 것을 작업해 보기로 합니다.

* 보드프리

BL-303.pdf

* Arduino

arduino-gemma-schematic.pdf

arduino-gemma-reference-design.zip

본 보드는, ATtiny85 를 CPU 로 사용하는 소형 arduino 입니다.

예전에 ATtiny85 를 이용하여 비슷한 arduino 계열인 Digispark 를 만들어 봤으므로, 그리 어렵지 않을 것이라 생각해서죠.

* Hardware | ATtiny85 를 사용해 보자 - 1

- https://chocoball.tistory.com/entry/Hardware-ATtiny85-1

* Hardware | ATtiny85 를 사용해 보자 - 2

- https://chocoball.tistory.com/entry/Hardware-ATtiny85-2

* Hardware | ATtiny85 개발 보드를 이용하여 Digispark 를 DIY 하기

- https://chocoball.tistory.com/entry/Hardware-Digispark-DIY-using-ATtiny85

2. Arduino Gemma

작업 할 BL-303 보드는 Arduino Gemma 라는 보드를 기본으로 만들어진 보드 입니다.

Arduino Gemma 는 Wearable IoT, 즉 의상이나 소형 IoT 컨트롤러 용으로 만들어진 arduino 입니다.

* ARDUINO GEMMA

- https://store.arduino.cc/usa/arduino-gemma

지금은 성능 좋고 소형화된 CPU 들이 많이 나와서, 단종 되었습니다.

참고로, 이 Arduino Gemma 를 업그레이드 시킨, 그렇지만 기본은 동일한 제품이 Adafruit 에서 Trinket 이라는 제품이 있습니다.

CPU 는 같은 ATtiny85 지만 pinout 을 늘여서, 더 많은 확장성을 가지게 한 제품 입니다.

Adafruit 는 3V out 버전과 5V out 버전 두 가지로 나뉘는데, 제가 받은 PCB 는 5V/3.3V 둘 다 지원합니다.

보드프리는 PCB 설계가 뛰어난 것 같습니다.

3. SMD capacitor 구입

다른 arduino DIY 하면서, 왠만한 부품은 모두 구입 했는데, 0805 SMD 용 1uF 캐패시터만 가지고 있지 않아, 구입합니다.

* 0805 SMD Ceramic Capacitor Assorted Kit 1pF~10uF 50values*50pcs=2500pcs Chip Ceramic Capacitor Samples kit

- https://www.aliexpress.com/item/2025088658.html

이왕 구입하는 김에, 다른 치수들도 함께 들어 있는 패키지로 구입했습니다.

1pF  / 1.5pF / 3pF  / 4.7pF /  5p  / 5.6pF / 6.8pF/ 8.2pF / 10pF

12pF / 18pF  / 20pF / 22pF  / 27pF / 30pF / 33pF

47pF / 56pF  / 68pF / 75pF  / 82pF

100pF(101) / 120pF(121) / 150pF(151) / 180pF(181) / 200pF(201)

220pF(221) / 330pF(331) / 390pF(391) / 470pF(471) / 560pF(561) / 680pF(681)

1nF(102) / 1.5nF(152) / 2.2nF(222) / 3.3nF(332) / 4.7nF(472) / 6.8nF(682) 

10nF(103) / 22nF(223) / 33nF(333) / 47nF(473) / 68nF(683) 

100nF(104) / 150nF(154) / 220nF(224) / 330nF(334) / 470nF(474) 

1uF(105) / 10uF(106)

참고로, 캐패시터 값 변환 공식을 여기에 올려 놓습니다. (Googling)

1 mF (millifarad, one thousandth (10−3) of a farad) = 1000 uF = 1000000 nF

1 uF (microfarad, one millionth (10−6) of a farad) = 0.000 001 F = 1000 nF = 1000000 pF

1 nF (nanofarad, one billionth (10−9) of a farad) = 0.001 uF = 1000 pF

1 pF (picofarad, one trillionth (10−12) of a farad)

도착샷은 예의.

단위가 자잘하게 나뉘는지라, 간략화한 표시로 구분하고 있습니다. 예를 들면 474 는 470nF. 

4. 납땜

Flux paste 를 올리기 전에, 필요한 부품을 도열 시켜 봅니다.

한땀 한땀 flux paste 를 올리고, SMD 부품들을 고정 시켜 놓습니다.

오븐에서 구워져 나오면 이쁘게 자리를 잡아 안착되었습니다.

정리가 필요한 부분은 인두기로 정리해 주면 됩니다. 부품 수가 적은지라 이번에는 따로 할게 없었네요.

Pin header 까지 납땜하면 끝.

USB 핀 쪽의 납땜 정리가 힘들었으나, 새로 구입한 T12-ILS 팁으로 깔끔하게 정리할 수 있었습니다.

작은 PCB 납땜은 필수적으로 극세사 납땜 tip 이 필요합니다.

5. Bootloader

Arduino 를 제작하는 데 있어서, 마무리 작업은 납땜 후, bootloader 를 입히는 작업 입니다.

Arduino Gemma 이지만, Adafruit 의 Trinket 의 bootloader 를 입힐 것이기에, 아래 Adafruit 사이트를 참고합니다.

동일한 ATtiny85 이므로, Digispark 의 bootloader 를 입혀도 될 것 같으나, 새롭게 Trinket 용으로 가 봅니다.

* Repairing bootloader

- https://learn.adafruit.com/introducing-trinket/repairing-bootloader

Trinket 의 pinout 정보는 위와 같습니다.

이전에 만들어 봤던 Arduino Duemilanove 를 이용하여 bootloader 를 입혀 봅니다.

-----------------------------
| Trinket     | Duemilanove |
-----------------------------
| VBAT+ (Vin) |      5V     |
|    GND      |     GND     |
|    RST      |     D10     |
|    PB0      |     D11     |
|    PB1      |     D12     |
|    PB2      |     D13     |
-----------------------------

Adafruit 사이트를 참고하여 Duemilanove 연결 합니다.

위의 사이트에서 bootloader 를 입혀주는 sketch 를 Arduino IDE 에서 Duemilanove 에 업로드 해 줍니다.

기록을 남기기 위해 여기에도 파일을 옮겨 놓습니다.

trinketloader_2015-06-09.zip

Duemilanove 에 sketch 를 업로드 하고 Serial Monitor 를 연 다음, "G" 를 입력하면 자동으로 bootloader 를 입혀 줍니다.

다른 arduino 들 처럼, IDE 의 "burn bootloader" 를 이용하는 것이 아니라서 생소하지만, 무사히 완료 되었습니다.

Bootloader 가 문제없이 올라가면, 아래 동영상 처럼, ready 상태임을 나타내는 LED 가 천천히 밝아졌다 어두워 졌다 합니다.

Sketch 를 업로드 할 때, USB 칩이 없으므로, 스위치를 눌러 주어, 강제로 ready 상태를 만들어 줄 때의 모습입니다.

6. Windows Driver

FTDI 나 ATmega16U2 처럼, USB 전용 chip 이 달려있지 않은 보드 이므로, 관련 driver 를 인스톨 해줘야 합니다.

그냥 꽂으면 아래와 같이 나옵니다. "알 수 없는 장치..."

최신 드라이버는 아래 링크에서 받습니다.

* adafruit/Adafruit_Windows_Drivers

- https://github.com/adafruit/Adafruit_Windows_Drivers/releases/tag/2.4.0.0

다운로드 받은 파일을 실행하여 드라이버를 인스톨 합니다.

저는 Trinket 만 필요하므로, "Trinket / Pro Trinket / Gemma (USBtinyISP)" 만을 선택해서 인스톨 했습니다.

드라이버가 인스톨 되고 나면, 아래처럼 "libusb-win32 devices" 라는 항목이 생기고, "USBtiny" 라고 기기를 인식합니다.

Windows OS 가 추가로 뭔가를 설치/설정 하기도 합니다.

7. Arduino IDE

납땜 > 부트로더 > Windows Driver 까지 왔으면, 그 다음은 Arduino IDE 설정 입니다.

File > Preferences > Additional Boards Manager URLs 에 아래 링크를 등록합니다.

이는 Board Manager 에 등록되어 선택할 수 있도록 하기 위함 입니다.

https://adafruit.github.io/arduino-board-index/package_adafruit_index.json

메뉴는 아래와 같습니다.

일전에 ESP8266 을 설치 했으니, 그 밑줄에다가 등록해 줍니다.

그러면 Board Manager 에서 Adafruit AVR Boards 를 등록할 수 있게 됩니다.

짜잔~! 이제 Board 메뉴에서 아래처럼 선택할 수 있게 됩니다.

Tools > Board > Adafruit Trinket (ATtiny85 @ 8MHz)

16MHz 를 사용해도 될 듯 한데, 내부 기본 oscillator 가 8MHz 라고 하니, 안전하게 8MHz 로 선택합니다.

16MHz 는 소프트웨어적으로 doubling 한다고 하는데, 아직 필요하지 않으니...

Programmer 는 "USBtinyISP" 를 선택합니다.

이는 여러번 이야기 되었듯이, USB chip 이 없기 때문입니다.

여기까지 오면, 관련된 설정은 이제 모두 끝났습니다.

이후는 Happy Coding 인거죠!

8. Blink

실제로 Trinket 화 된 Arduino Gemma 에게 일을 시켜 봅시다.

센서를 연결해서 확인해도 되지만, 가장 간단한 PCB 상의 LED 점멸을 시켜 보아요.

* Setting up with Arduino IDE

- https://learn.adafruit.com/introducing-trinket/setting-up-with-arduino-ide

소스는 위의 Adafruit 사이트 것을 그대로 사용했습니다.

/*
  Blink
  Turns on an LED on for one second, then off for one second, repeatedly.
 
  This example code is in the public domain.

  To upload to your Gemma or Trinket:
  1) Select the proper board from the Tools->Board Menu
  2) Select USBtinyISP from the Tools->Programmer
  3) Plug in the Gemma/Trinket, make sure you see the green LED lit
  4) For windows, install the USBtiny drivers
  5) Press the button on the Gemma/Trinket - verify you see
     the red LED pulse. This means it is ready to receive data
  6) Click the upload button above within 10 seconds
*/

int led = 1; // blink 'digital' pin 1 - AKA the built in red LED

// the setup routine runs once when you press reset:
void setup() {
  // initialize the digital pin as an output.
  pinMode(led, OUTPUT);
}

// the loop routine runs over and over again forever:
void loop() {
    digitalWrite(led, HIGH); 
    delay(1000);
    digitalWrite(led, LOW);
    delay(1000);
}

Sketch 주석에도 잘 설명이 되어 있듯이, 소스를 업로드 할 때에는 필히 스위치를 눌러서 ready 상태로 만들어야 한다고 나와 있습니다.

이게 타이밍을 맞춰야 해서, IDE > Trinket 에 밀어넣는 순간이, ready 10 초 안에 진행 될 수 있도록 해야 합니다.

성공하면, 위와 같이 다른 arduino 와는 다른 과정들을 보여 줍니다. 아무래도 USB chip 부재...

avrdude: Version 6.3-20171130
         Copyright (c) 2000-2005 Brian Dean, http://www.bdmicro.com/
         Copyright (c) 2007-2014 Joerg Wunsch

         System wide configuration file is "C:\Program Files (x86)\Arduino\hardware\tools\avr/etc/avrdude.conf"

         Using Port                    : usb
         Using Programmer              : usbtiny
avrdude: usbdev_open(): Found USBtinyISP, bus:device: bus-0:\\.\libusb0-0001--0x1781-0x0c9f
         AVR Part                      : ATtiny85
         Chip Erase delay              : 400000 us
         PAGEL                         : P00
         BS2                           : P00
         RESET disposition             : possible i/o
         RETRY pulse                   : SCK
         serial program mode           : yes
         parallel program mode         : yes
         Timeout                       : 200
         StabDelay                     : 100
         CmdexeDelay                   : 25
         SyncLoops                     : 32
         ByteDelay                     : 0
         PollIndex                     : 3
         PollValue                     : 0x53
         Memory Detail                 :

                                  Block Poll               Page                       Polled
           Memory Type Mode Delay Size  Indx Paged  Size   Size #Pages MinW  MaxW   ReadBack
           ----------- ---- ----- ----- ---- ------ ------ ---- ------ ----- ----- ---------
           eeprom        65    12     4    0 no        512    4      0  4000  4500 0xff 0xff
           flash         65     6    32    0 yes      8192   64    128 30000 30000 0xff 0xff
           signature      0     0     0    0 no          3    0      0     0     0 0x00 0x00
           lock           0     0     0    0 no          1    0      0  9000  9000 0x00 0x00
           lfuse          0     0     0    0 no          1    0      0  9000  9000 0x00 0x00
           hfuse          0     0     0    0 no          1    0      0  9000  9000 0x00 0x00
           efuse          0     0     0    0 no          1    0      0  9000  9000 0x00 0x00
           calibration    0     0     0    0 no          1    0      0     0     0 0x00 0x00

         Programmer Type : USBtiny
         Description     : USBtiny simple USB programmer, https://learn.adafruit.com/usbtinyisp
avrdude: programmer operation not supported

avrdude: Using SCK period of 10 usec
avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.00s

avrdude: Device signature = 0x1e930b (probably t85)
avrdude: NOTE: "flash" memory has been specified, an erase cycle will be performed
         To disable this feature, specify the -D option.
avrdude: erasing chip
avrdude: Using SCK period of 10 usec
avrdude: reading input file "C:\Users\chocoball\AppData\Local\Temp\arduino_build_87390/sketch_nov06a.ino.hex"
avrdude: writing flash (700 bytes):

Writing | ####avrdude: 5 retries during SPI command
#####avrdude: 7 retries during SPI command
####avrdude: 8 retries during SPI command
#####avrdude: 7 retries during SPI command
####avrdude: 7 retries during SPI command
#####avrdude: 8 retries during SPI command
####avrdude: 9 retries during SPI command
#####avrdude: 8 retries during SPI command
####avrdude: 8 retries during SPI command
#####avrdude: 8 retries during SPI command
##### | 100% 0.42s

avrdude: 700 bytes of flash written
avrdude: verifying flash memory against C:\Users\chocoball\AppData\Local\Temp\arduino_build_87390/sketch_nov06a.ino.hex:
avrdude: load data flash data from input file C:\Users\chocoball\AppData\Local\Temp\arduino_build_87390/sketch_nov06a.ino.hex:
avrdude: input file C:\Users\chocoball\AppData\Local\Temp\arduino_build_87390/sketch_nov06a.ino.hex contains 700 bytes
avrdude: reading on-chip flash data:

Reading | ################################################## | 100% 0.13s

avrdude: verifying ...
avrdude: 700 bytes of flash verified

avrdude done.  Thank you.

자세한 과정 log 는 위와 같습니다. 동영상으로도 올려 봅니다.

좀더 다른 sketch 는 다음 링크를 참고해 보세요.

* Programming with Arduino IDE

- https://learn.adafruit.com/introducing-trinket/programming-with-arduino-ide

Duemilanove 다음으로 성공한, 두 번째 arduino DIY 되겠습니다.

모두 Happy DIY!

1. 16 bit ADC

ADC 는 Analog to Digital Converter 의 약자로서, 입력받는 값에 대해 digital 로 표현해 줍니다.

Arduino 에는 이 ADC 가 장착되어 있어서 analog input 에 입력받은 신호에 대해 digital 로 leveling 을 해서 보여줍니다.

즉, analog 값을 digital 로 변환해서 보여주는 것이죠.

참고로, arduino nano 에는 10 bit ADC 가 장착되어 있어서 10 bit (0 ~ 1023) 값으로 표현해 줍니다.

다 좋은데, 민감한 sensor 를 다룰 때에는, 이 10 bit ADC 가 아쉬울 때가 있습니다.

좀더 정밀한 값을 들여다 보고 싶은데, 값과 값의 사이값을 알수가 없는거죠.

이 때 등장하는 것이 외부 ADC 모듈 입니다.

AliExpress 와 arduino 를 사랑하는 사람들의 blog 를 보니 ADS1115 라는 것을 많이 사용하는 군요.

ADS1115 는 Texas Instruments 사의 chip 을 사용한 16 bit ADC 입니다.

ads1115.pdf

- Resolution: 16 Bits

- Programmable Sample Rate: 8 to 860 Samples/Second

- Power Supply/Logic Levels: 2.0V to 5.5V

- Low Current Consumption: Continuous Mode: Only 150µA Single-Shot Mode: Auto Shut-Down

- Internal Low-Drift Voltage Reference

- Internal Oscillator

- Internal PGA: up to x16

- I2C Interface: 4-Pin-Selectable Addresses

- Four Single-Ended or 2 Differential Inputs

- Programmable Comparator

아래 link 의 제품이 적당해 보이네요. 구매합니다.

* I2C ADS1115 16 Bit ADC 4 channel Module with Programmable Gain Amplifier 2.0V to 5.5V for Arduino RPi

- https://www.aliexpress.com/item/32850495005.html

2. 도착

그간 업무로 정신 없었는데, 어느샌가 도착했습니다.

블로그 내용을 부풀리기 위해서라도 항상 도착샷을 올리는건 필수 입니다.

저렇코롬 생겼구요.

ALERT 와 ADDR 에 pinheader 는 남겨 놓고 납땜하기로 합니다. 그 덕에 2 pinheader 하나 득템.

그 이유는 이 밑에 설명.

3. Addressing

이 ADS1115 는 I2C 통신을 하는데, 하나의 arduino 와 4개까지 연결할 수 있다 보니, I2C 접근 주소가 겹치지 않게 할 수 있습니다.

방법은 ADDR pin 을 어디로 연결하느냐로 address 를 결정할 수 있습니다.

* Adafruit 4-Channel ADC Breakouts

- https://learn.adafruit.com/adafruit-4-channel-adc-breakouts

- 0x48 (1001000) ADR -> GND

- 0x49 (1001001) ADR -> VDD

- 0x4A (1001010) ADR -> SDA

- 0x4B (1001011) ADR -> SCL

회로를 꾸밀 때 마다, address 정의를 위한 연결을 해도 되지만, 귀찮겠죠?

또한, addressing 을 위해 I2C 용 핀이나, VCC 로 연결하면 왠지 껄끄럽습니다.

그래서 ground 로 연결하여, 기본 0x48 을 가지게 합니다.

또한, 아래 새다리님의 블로그를 보면, 이 연결을 가장 깔끔하게 처리하셨더군요. 따라쟁이는 바로 따라해 봅니다.

* 16비트, 4채널 ADC ADS1115 아두이노 Test

- https://m.blog.naver.com/twophase/220801664646

예전에 파손된 멀티탭 전원선에서 동선 한가닥을 짧게 잘라 내어 아래와 같이 납땜 해 주섰습니다.

캡톤 테이프로 혹시 모를 쇼트를 방지했구요.

i2cdetect 로 addressing 이 잘 되었나 확인해 봅니다.

     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- 48 -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --

흠흠. 잘 되었네요.

4. Layout

* Arduino ADS1115 Module Getting Started Tutorial

- http://henrysbench.capnfatz.com/henrys-bench/arduino-voltage-measurements/arduino-ads1115-module-getting-started-tutorial/

위의 tutorial 사이트에서 보면 ADS1115 를 활용하여, arduino 자체 3.3V 출력을 세밀하게 검증해 보는 소스가 있습니다.

따라쟁이는 당연 따라서 검증해 봅니다.

연결은 I2C 용 연결 2가닥과 VCC/GND 그리고, 입력용에 arduino 3.3V output 을 연결합니다.

 ADS1115 | Arduino Nano
------------------------
    VCC  |      5V
    GND  |      GND
    SCL  |      A5
    SDA  |      A4
    A0   |      3.3V
------------------------

그림으로 그려보면 다음과 같습니다.

5. Sketch

이미 관련한 library 가 나와 있기 때문에, library 를 설치합니다.

역시 God Adafruit. 없는게 없습니다.

ads1115 로 검색하면 나오지 않고, ads1x 로 검색해야 나옵니다.

이제 HENRY'S BENCH 에서 Henry 아저씨가 arduino 3.3V output 에 대해, ADS1115 를 검증해 놓은 소스를 사용해 봅니다.

#include "Wire.h"
#include "Adafruit_ADS1015.h"

Adafruit_ADS1115 ads(0x48);
float Voltage = 0.0;

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

void loop(void) {
	int16_t adc0;	// we read from the ADC, we have a sixteen bit integer as a result
	
	adc0 = ads.readADC_SingleEnded(0);
	Voltage = (adc0 * 0.1875)/1000;
	
	Serial.print("AIN0: ");
	Serial.print(adc0);
	Serial.print("\tVoltage: ");
	Serial.println(Voltage, 7);
		
	delay(1000);
}

이 소스에서 가장 중요한 것은 PGA (Programmable Gain Amplifier) 값 입니다.

이 ADS1115 의 default output 최대값이 6.144V 이므로, 이를 15 bit (16 bit 이지만, 부호를 표시하는 1 bit 를 빼면 15 bit 만 활용 가능) 인 32767 로 나누면, 출력 1 에 대해 0.1875mV 라는 계산이 나옵니다.

In the default mode, the setting is +/-6.144 volts.

Thus the value of 32767 would represent a value of 6.144 volts.

Dividing 6.144 volts by 32767 yields a scale factor of 0.1875 mV per bit.   This is a significant improvement over the Arduino ADC which resolution of approximately 5 mV per bit.  In fact, its about 26 times better!

위의 로직이 소스에 활용되었습니다.

6. 결과

지금까지 구성한 layout 과 위의 소스를 가지고 실행해 보면 다음과 같이 결과가 나옵니다.

3.3V 이지만, 미세하게 값이 변하고 있다는 것을 알 수 있습니다.

이게 USB 를 통해서 연결하지 않고 Power source 를 통해서 입력 받으면 좀더 정확하고 잘 변하지 않는 3.3V 를 얻을 수 있다고 해요.

7. 비교

Arduino nano 의 자체 3.3V 를 16 bit ADC 를 거치지 않은 채로, anlogRead (10 bit ADC) 를 하면 어떨까?

참고로 Arduino 의 AnalogReference 의 정의는 다음과 같습니다.

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

Arduino AVR Boards (Uno, Mega, Leonardo, etc.)

- DEFAULT: the default analog reference of 5 volts (on 5V Arduino boards) or 3.3 volts (on 3.3V Arduino boards)

- INTERNAL: an built-in reference, equal to 1.1 volts on the ATmega168 or ATmega328P and 2.56 volts on the ATmega32U4 and ATmega8 (not available on the Arduino Mega)

- INTERNAL1V1: a built-in 1.1V reference (Arduino Mega only)

- INTERNAL2V56: a built-in 2.56V reference (Arduino Mega only)

- EXTERNAL: the voltage applied to the AREF pin (0 to 5V only) is used as the reference.

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

AnalogReference(DEFAULT) 를 사용하여, 5V 기준으로 입력값을 leveling 하게 했으며,

arduino nano 에는 PGA 가 없으므로, 단순히 5V 를 10 bit ADC 해상도를 감안하여, 1024 로 나누어, 한 level 당, 0.0049 V 로 계산하도록 했습니다.

최종 소스는 다음과 같습니다.

#include "Wire.h"
#include "Adafruit_ADS1015.h"
 
Adafruit_ADS1115 ads(0x48);
float Voltage = 0.0;
float Voltage2 = 0.0;	// analogRead(A2)
 
void setup(void) {
    analogReference(DEFAULT);
    Serial.begin(9600);
    ads.begin();
}
 
void loop(void) {
    int16_t adc0;   // we read from the ADC, we have a sixteen bit integer as a result
     
    adc0 = ads.readADC_SingleEnded(0);
    Voltage = (adc0 * 0.1875)/1000;
     
    Serial.print("AIN0: ");
    Serial.print(adc0);
    Serial.print("\tVoltage: ");
    Serial.print(Voltage, 7);

	// analogRead(A2) start
    int16_t adc2;
    adc2 = analogRead(A2);
    Voltage2 = (adc2 * 0.0049);
    
    Serial.print("\tAIN2: ");
    Serial.print(adc2);
    Serial.print("\tVoltage2: ");
    Serial.println(Voltage2, 7);
    // analogRead(A2) end
         
    delay(1000);
}

결과값은 이렇게 나왔네요. 많이 부정확 합니다.

그 원인으로는,

- 5V reference 전압이 USB 를 통해 공급받으며, USB 전원은 불안하게 공급받습니다.

- PGA 가 없이, 단순히 5V reference 전압을 10 bit 로 나눈 값을 기준값으로 정했습니다.

- 16 bit 하고는 비교도 안되는 10 bit 해상도 차이가 납니다.

ADS1115 16 bit ADC 를 이용한 센서값 입력은 보다 정확한 값을 보장해 주네요.

향후 자주 사용해야 겠습니다.

이 글은 전편 2개가 있습니다.

* Hardware | Digitial Compass - HMC5883L 사용기 - 1

- https://chocoball.tistory.com/entry/Hardware-Digital-Compass-HMC5883L-1

* Hardware | Digital Compass - HMC5883L 사용기 - 2

- https://chocoball.tistory.com/entry/Hardware-Digital-Compass-HMC5883L-2

1. Why calibration?

이 HMC5883L 이나, 기타 digital compass 는 영점조정이 필요합니다.

Calibration 을 하기 전은 정확성에 있어서 사용할 수 있는 물건이 아니라고도 할 정도 입니다.

또한 지구상에서 내가 어디에 있느냐에 따라 자력의 방향과 세기가 달라지므로, 공장에서 만들어 졌던 들,

이 영점 조정은 꼭 필요하게 된다는 이야기가 됩니다.

현재 위치하고 있는 지리적 장소에 따라 변하는 자력을 계산해 주는 사이트도 있습니다.

* NCEI Geomagnetic Calculators

- https://www.ngdc.noaa.gov/geomag/calculators/magcalc.shtml

2. Yury Matselenak

아래 그림처럼 직각 육면체 (박스) 를 이용하여 영점 조정한 사람이 있습니다.

* Advanced hard and soft iron magnetometer calibration for dummies

- https://diydrones.com/profiles/blogs/advanced-hard-and-soft-iron-magnetometer-calibration-for-dummies

영점 조절을 위한 arduino code, Visual Studio 2010 C# 을 이용한 검증 어플 및 계산 어플까지 all set 를 혼자 만드신 분이죠.

위의 블로그에서 가져온 소스를 여기에 올려 놓습니다.

- MagMaster.rar

위의 압축파일에 모든게 들어 있습니다만,

한가지 아쉬운 것은, 2014년에 만들어진 코드라, 최신 Arduino IDE 에서는 제대로 동작하지 않습니다.

동작만 한다면, 이 분이 안내하고 만들어진 프로그램을 사용하여 영점 조정이 가능하나, 그러지 못했네요.

시간이 생기면 소스를 분석하고, geomagnetic 에 대해 공부하여 소스 개선을 좀 해주고 싶으나, 현재 그럴 여유는 없습니다.

Yuri 아저씨의 방식을 잠깐 설명해 보면, HMC5883L 센서는, PCB에 프린팅 된 XYZ 축의 모양에 따라 다음과 같은 축을 가집니다.

이 센서를 가지고 다음과 같이, 북쪽을 0도로 정하고 3차원 공간에서 XYZ 값을 가져오면, 틀어진 중심점을 알 수 있으니,

측정시에 그 틀어진 만큼을 빼주거나 더해주면 된다는 이론 입니다.

모두 12가지를 측정하여, 그 값들을 가지고 틀어진 중심점을 구하는 방식 입니다.

3. Sequential Quadratic Programming

측정된 값을 가지고 SQP (Sequential Quadratic Programming) 을 통해 최적의 영점을 잡아주는 방식도 있습니다.

(보다 기술적인 것은 잘 모름)

본 방식은, 아래 블로그에서 소개되었습니다.

* 電子コンパスHMC5883Lのキャリブレーションに挑戦

- http://tomoto335.hatenablog.com/entry/arduino/HMC5883L

결과적으로 SQP 를 실행해야 하는데, 이를 Octave (상용 MatLab 의 GNU 버전) 을 통해서 답을 구할 수 있다고 하네요.

Yuri 아저씨 방식이 안되니, 이 방식으로 진행해 봅니다.

4. Octave

SQP 계산을 위해, 일단 Octave 를 설치해 봅니다.

* GNU Octave

- https://www.gnu.org/software/octave/

사용하는 OS 에 맞게 다운로드 하구요.

인스톨 실행파일을 실행 시킵니다.

나에게 맞게 설정하구요.

저는 바탕화면이 지저분하게 되는게 싫어서 "Install for all users" 만 선택했습니다.

BLAS library 는 뭔지 모르니 그냥 OpenBLAS 로 놔뒀습니다.

Windows 10을 새로 깔았더니만 JRE 가 없네요. Octave 는 JRE 가 필요하다 합니다. 깔아 줍니다.

자 이제 다음으로 넘어갑니다.

5. 연결

우선 arduino 와 HML5883L 을 다음과 같이 연결합니다.

 HMC5883L | Arduino Nano
-------------------------
    VCC   |      5V
    GND   |      GND
    SCL   |      A5
    SDA   |      A4
-------------------------

그리고 I2CScanner / I2Cdetect 를 이요하여 address 0x1E 를 통해서 잘 인식 되었는지 확인합니다.

     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
00:          -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- 1e --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --

Hardware 준비는 끝났으니, arduino source 준비로 넘어갑니다.

6. 값을 입력받자

HMC5883L 을 구동시켜 주는 몇 가지 Library 들을 확인해 봤는데, Adafruit 에서 만든 Unified library 가 가장 짱인 것 같습니다.

OS 를 싹 밀었더니만 예전 library 가 다 날라갔네요. 깔끔하게 다시 설치해 줍니다.

바로 실행하면, Octave 에서 계산을 방해하는 문자들이 들어가니 아래와 같이 단순한게 XYZ 값만 입력받게 합니다.

#include "Wire.h"
#include "Adafruit_Sensor.h"
#include "Adafruit_HMC5883_U.h"

/* Assign a unique ID to this sensor at the same time */
Adafruit_HMC5883_Unified mag = Adafruit_HMC5883_Unified(12345);


void setup(void) 
{
  Serial.begin(9600);
  
  /* Initialise the sensor */
  if(!mag.begin())
  {
    /* There was a problem detecting the HMC5883 ... check your connections */
    Serial.println("Ooops, no HMC5883 detected ... Check your wiring!");
    while(1);
  }
  
}

void loop(void) 
{
  /* Get a new sensor event */ 
  sensors_event_t event; 
  mag.getEvent(&event);
 
  /* Display the results (magnetic vector values are in micro-Tesla (uT)) */
  Serial.print(event.magnetic.x); Serial.print(",");
  Serial.print(event.magnetic.y); Serial.print(",");
  Serial.println(event.magnetic.z);
}

그러면 다음과 같은 결과들을 얻을 수 있습니다.

...
-21.82,-9.36,-41.94
-16.45,-8.73,-47.24
-16.45,-8.73,-47.24
-16.45,-8.73,-47.24
-9.64,-6.91,-51.43
-9.64,-6.91,-51.43
-9.64,-6.91,-51.43
-3.55,-4.00,-53.27
-3.55,-4.00,-53.27
-3.55,-4.00,-53.27
2.55,-1.27,-54.18
...

Serial Monitor 의 값들을 카피하여 txt 파일로 하나 만들어 놓습니다. 이게 Octave 에서 사용될 소스 값입니다.

참고로 Yuri 아저씨가 만들어 주신 MagMaster 프로그램 중에, MagViewer 라는게 있습니다.

실행시키면, 입력받을 Serial Port 를 물어보는데, arduino 와 연결된 port 를 지정하면 값들을 읽어와서 3차원 공간에 뿌려 줍니다.

훗, 확실히 틀어져 있군요.

동영상으로도 올려 봅니다. Graph Fetish 인지라, 이런거 보면 사족을 못 씁니다.

마우스로 요리조리 움직일 수 있어서 3차원 공간에서 어떻게 값들이 찍히는지 실시간으로 알 수 있습니다.

7. 영접을 찾아 보자

이제 Octave 에서 SQP 를 시켜 볼 차례 입니다.

Serial Monitor 에서 받은 값들을 파일로 만든 다음, Octave 내에서 아래 command 를 실행 시킵니다.

global points
points = csvread("HMC5883L_org_uncal.txt");
scatter3(points(:,1), points(:,2), points(:,3));

느낌이 예전 GNU Plot 을 사용하는 것이랑 매우 비슷하네요. Command 도 비슷하고.

짜잔~! 3차원으로 찍힌 그림을 그려줍니다. 이는 아까 MegViewer 로 본 모습이기도 합니다.

값들이 모두 입력 되었으니, 틀어진 값을 찾기 위해 SQP 해 봅니다.

function retval = sphere_errors(p, x)
  retval = sqrt( (p(:,1).-x(1)).^2+(p(:,2).-x(2)).^2+(p(:,3).-x(3)).^2).-x(4)
endfunction

function retval = sphere_error(x)
  global points
  retval = sum(sphere_errors(points, x).^2)
endfunction

x0 = [mean(points(:,1)), mean(points(:,2)), mean(points(:,3)), 100]

result = sqp(x0, @sphere_error)

그러면 한참만에 아래 값들이 도출됩니다. 모든 값들에 대해 mash 형태로 계산을 하다 보니, 꽤 시간이 걸립니다.

계산에 의하면, 중심점은 (12.1, -5.9, -7.2) 반경 47.85 라고 나옵니다.

이 값들이 지금까지 찾았던 영점값 되겠습니다.

8. 영접값 적용하여 확인

이제 다시 arduino source 로 돌아와, 위에서 구한 값들을 입력받는 source 에 반영해 줍니다.

중심점이 벗어나 있으니, 그만큼 가감해서, 입력 받을 때, 자동으로 계산되게 해주면 됩니다.

MegViewer 를 통해 어떻게 변했나 확인해 볼까요?

오호이~. 적용이 되어서 둥그런 원 모양과 중심축에 붙어서 값들이 표현되었습니다.

이게 calibration 의 힘이란 말인가... (대박)

9. Further More

사실 저는 이 결과가 썩 마음에 들지 않습니다.

일단, 값을 입력받는 방식 차제를 아래 그림들 처럼 고정된 상태에서 선의 걸리적 거림 없이,

6면체의 각 면과 같이 회전하면서 값들을 받아야, 입력값을 신뢰할 수 있을 것 같았습니다.

* Arduino GY-273 HMC5883L Magnetometer Compass Tutorial

- http://henrysbench.capnfatz.com/henrys-bench/arduino-sensors-and-input/arduino-gy-273-hmc5883l-magnetometer-compass-tutorial/

위와 같이 하려면, 아래 장치 처럼, 무선모듈을 추가해야 하고, 배터리로 구동시켜야 합니다.

* Tutorial: How to calibrate a compass (and accelerometer) with Arduino

- https://thecavepearlproject.org/2015/05/22/calibrating-any-compass-or-accelerometer-for-arduino/

저는 이렇게 연결하고 윙윙 휘둘렀습니다.

그래서 몇 개씩 값이 튀기도 하고...

혹시... 혹시 나중에 기회가 되면, 그땐 위의 전문가들 처럼 해보고 싶네요.

이 글은, 아래 포스트에서 예고 했듯이, RFID / NFC 를 arduino 를 이용하여 tag를 인식시켜 보는 글 입니다.

* Book | 훤히 보이는 RFID/USN - Get to know RFID/USN

- https://chocoball.tistory.com/entry/Book-Get-to-know-RFID-USN

1. 대응 가능한 chip

RFID / NFC 를 읽을 수 있는 chip 중에 PN532 가 FeliCa 도 인식할 수 있으며, 대중적으로 구입 가능하다는 것을 알게 되었습니다. (범용)

* RFID Selection Guide - Adafruit Industries

- https://cdn-shop.adafruit.com/datasheets/rfid+guide.pdf

- rfid+guide.pdf

PN5xx 시리즈 중에서 시중에서 구입 가능한, 그리고 xx 부분의 숫자가 큰 것으로는 PN532 가 있더군요.

가장 우수한 chip 으로는 PN544 입니다만, 관련 breakout 은 5만원 이상이었습니다.

저렴하게 AliExpress 에서 골라서 구입합니다.

* 1Set GREATZT PN532 NFC RFID Wireless Module V3 User Kits Reader Writer Mode IC S50 Card PCB Attenna I2C IIC SPI HSU For Arduino

- https://www.aliexpress.com/item/1Set-GREATZT-PN532-NFC-RFID-Wireless-Module-V3-User-Kits-Reader-Writer-Mode-IC-S50-Card/32859551116.html

- User manual : PN532_Manual_V3.pdf

[Features]

1. Gilt PCB and Small dimension and easy to embed into your project

2. Support I2C, SPI and HSU (High Speed UART), Change between those modes

3. Support RFID reading and writing

  1) SupportP2P communication with peers

  2) Support NFC with Android phone

4. Typical Operating Distance have been updated to 5cm~7cm reading distance

5. Work in NFC Mode or RFID reader/writer Mode

6. RFID reader/writer supports:

  1) 1k, 4k, Ultralight, and DesFire cards

  2) ISO/IEC 14443-4 cards such as CD97BX, CD light, Desfire, P5CN072 (SMX)

  3) Innovision Jewel cards such as IRT5001 card

  4) FeliCa cards such as RCS_860 and RCS_854

7. Plug and play, for compatible

8. Built in PCB Antenna, with 4cm~6cm communication distance

9. On-board level shifter, Standard 5V TTL for I2C and UART, 3.3V TTL SPI

10. Work as RFID reader/writer

11. Work as 1443-A card or a virtual card

12. Exchange data with other NFC devices such as smartphone

[Package Included]

1 x1PCS*PN532 NFC RFID Module

1x 2.54mm spacing 4pin Cable

1xMifare One S50 White Card

1xMifare One S50 Key Card

1x12P bended male pins

사양을 보면 FeliCa 도 읽을 수 있다고 되어 있습니다.

FeliCa 는 일본 지하철 / 국철에서 사용할 수 있는 Suica / PASMO 카드에 사용된 기술입니다.

마침 일본에서 사용했던 Suica / Pasmo 카드를 가지고 있으니, FeliCa 대응 가능한 이 breakout 을 이용할 수 있겠네요.

다만, fake 제품은 읽을 수 없다고 합니다. (나중에 안 사실)

AliExpress 에서 구매할 수 있는 저가품이다 보니, 아마 불가능할 것 같다는 느낌은 듭니다.

2. 도착

배송에 한달정도 소요되었습니다.

구성품은 다음과 같습니다.

Tag 종류가 둥그런 것과 카드형식, 두가지가 들어 있네요.

Breakout 보드의 확대 사진입니다.

뒷면입니다. I2C 용 pin head 와 SPI 용이 따로 구분되어 있습니다.

Arduino 와 연결하기 위해서 pin head 들을 납땜 했습니다.

납땜 팁이 오래 쓰면서 산화되어 버려 이제는 납볼이 잘 생성되지 않았지만, 어떻게든 이쁘게 된것 같네요.

3. Library 설치

이 보드에 관한 제작 / 판매하는 사이트를 따라가다 보면 Seeed Studio 라는 회사가 떠오릅니다.

관련한 source 들은 아래 GitHub 에서 공유되어 있습니다.

* elechouse/PN532

- https://github.com/elechouse/PN532

위의 사이트에서 설명되어 있기론, 아래 두 파일을 Arduino libraries 폴더에 압축을 풀어서 copy 하라고 합니다.

결국 위의 GitHub 의 파일과, 추가로 Don 이라는 사람이 만든 NDEF 파일을 Arduino > libraries 에 설치하면 준비는 끝납니다.

- PN532-PN532_HSU.zip

- NDEF-master.zip

위에서 시키는 대로 하면, PN532 directory 가 많아지므로, 구분을 위해 prefix "elechouse" 를 붙여서 아래처럼 저장했어요.

다른 source 로는, 가장 유명한 adafruit 에서 나온 PN532 library 를 설치하면 됩니다.

* adafruit/Adafruit-PN532

- https://github.com/adafruit/Adafruit-PN532

위에서 파일을 다운로드 받아 libraries 에 copy 해도 되고, 아래처럼 Library Manager 를 이용하여 install 해도 됩니다.

다만, adafruit 소스에는 HSU (High Speed UART) 연결방식이 지원되지 않습니다.

그러니 HSU 를 사용하고 싶으면, 처음에 소개된 elechouse source 가 필요합니다.

4. I2C 연결

이제 소스를 올리고 RFID 인식을 시켜 봅니다.

Arduino 와 연결 방식은 I2C / SPI / HSU 가 있으니, 먼저 가장 단순한 I2C 를 이용해 봅니다.

아래처럼 DIP switch 를 I2C 방식으로 변경합니다.

문제 없이 I2C 통신이 이루어 지는지 I2C detect 소스로 확인해 봅니다.

방법은 예전에 올렸던 아래 포스트에서 확인해 보세요.

* Hardware | Gyroscope GY-521 MPU-6050 을 사용해 보자

- https://chocoball.tistory.com/entry/Hardware-Gyroscope-GY521-MPU6050

PN532 breakout 의 측정된 주소로 "0x24" 가 나왔네요.

연결은 다음과 같이 합니다.

   PN531  | Arduino Nano
-------------------------
    VCC   |     5V
    GND   |     GND
    SDA   |     A4
    SDL   |     A5
-------------------------

연결 layout 은 다음과 같습니다.

구매한 breakout 보드와 동일한 fritzing 파트를 찾을 수 없어서 adafruit 에서 나온 것을 사용하였습니다.

여타 I2C 연결이 그러하듯 동일합니다.

아래 sample source 를 arduino 에 로드합니다. iso14443a_uid 가 처음 시작하기에 가장 평범한 소스라고 하네요.

File > Examples > elechouse_PN532 > iso14443a_uid

Serial Monitor 에서 확인하면 다음과 같이 인식합니다!

위의 소스의 단점은 준비 상태로 되는 것과 카드를 태킹하면 인식에 시간이 좀 걸린다는 것 입니다.

실생활에 전혀 사용할 수 없는 수준이네요.

그럼 이번에는 Adafruit 의 동일한 소스를 사용해 봅니다.

File > Examples > Adafruit PN532 > iso14443a_uid

adafruit 소스는 먼저번 소스와는 다르게, IRQ 와 RESET (RSTO) 를 추가로 연결하는 부분이 존재합니다.

// If using the breakout or shield with I2C, define just the pins connected
// to the IRQ and reset lines.  Use the values below (2, 3) for the shield!
#define PN532_IRQ   (2)
#define PN532_RESET (3)  // Not connected by default on the NFC Shield

// Uncomment just _one_ line below depending on how your breakout or shield
// is connected to the Arduino:

// Use this line for a breakout with a SPI connection:
//Adafruit_PN532 nfc(PN532_SCK, PN532_MISO, PN532_MOSI, PN532_SS);

// Use this line for a breakout with a hardware SPI connection.  Note that
// the PN532 SCK, MOSI, and MISO pins need to be connected to the Arduino's
// hardware SPI SCK, MOSI, and MISO pins.  On an Arduino Uno these are
// SCK = 13, MOSI = 11, MISO = 12.  The SS line can be any digital IO pin.
//Adafruit_PN532 nfc(PN532_SS);

// Or use this line for a breakout or shield with an I2C connection:
Adafruit_PN532 nfc(PN532_IRQ, PN532_RESET);

위의 소스의 일부분에서 보여주는 것 처럼 SPI 부분을 주석처리 하고, I2C 부분을 활성화 시킵니다.

두개의 pin 연결이 아래처럼 추가되었습니다.

   PN531  | Arduino Nano
-------------------------
    VCC   |     5V
    GND   |     GND
    SDA   |     A4
    SDL   |     A5
    IRQ   |     D2
   RSTO   |     D3
-------------------------

결과는 인식률과 인식 속도가 엄청 빨라졌습니다.

결국 IRQ / RESET 핀이 준비상태 및 인식 처리를 추가로 담당한다는 것을 예상할 수 있습니다.

Serial Monitor 결과는 다음과 같습니다.

참고로 위의 소스로 신용카드 (버스카드) 를 인식 시키면 "Mifare Classic" 으로 읽어보라고 메시지가 뜹니다.

File > Examples > Adafruid PN532 > readMifareClassic 을 로드 시켜 봅니다.

뭔가 정보를 더 많이 뿌려줌과 동시에, "Mifare Classic" 이라고 이야기 해 줍니다.

조금 벗어난 이야기 이지만,

RFID / NFC 분야도 존재하는 규격이 많아서 chip 제조사로서는 골치가 아플 듯 합니다.

이것도 결국 기술 로열티와 표준 제정 이권싸움의 결과겠죠.

Thunderbolt 도, 결국은 Thunderbolt 3 = USB Type-C 로 통합되듯, 언젠가 RFID / NFC 도 통합이 되었으면 좋겠습니다.

5. SPI 연결

이제 SPI 연결을 시도해 봅니다. 역시 많은 데이터 교환은 I2C 보다는 SPI 방식입니다.

먼저, Software SPI 연결법 입니다.

   PN531  | Arduino Nano
-------------------------
    VCC   |     5V
    GND   |     GND
    SCK   |     D2
    MISO  |     D5
    MOSI  |     D3
    SS    |     D4
-------------------------

소스는 adafruit 의 것을 이용해 봅니다. (elechouse 것도 상관 없슴)

File > Examples > Adafruit PN532 > readMifare

이미 소스에서 SCK / MOSI / SS / MISO 의 pin 번호를 정희해 놨으므로, 그에 맞게 arduino 와 연결해 줍니다.

TIMEOUT! 이 뜨긴 합니다만, 결과는 아래와 같이 잘 나옵니다.

아무래도 Software SPI 여서 그런 듯 합니다.

역시 SPI 는 Hardware SPI 죠. Hardware SPI 법으로 구동해 봅니다.

   PN531  | Arduino Nano
-------------------------
    VCC   |     5V
    GND   |     GND
    SCK   |     D13
    MISO  |     D12
    MOSI  |     D11
    SS    |     D4
-------------------------

SS pin 은 어느 digital IO pin 이나 상관 없습니다.

이미 PN532_SS 를 4 번 pin 으로 정의해 놨으니, 그 pin 을 그대로 사용합니다.

나머지 pin 들은 각각의 arduino 에 맞게 연결하면 됩니다.

참고로 arduino nano 는 위의 주석에 설명되어 있는 것처럼 SCK = 13, MOSI = 11, MISO = 12 로 맞추면 됩니다.

이는 아래 그림처럼 실제 nano 의 pin out 과 동일합니다.

결과는 다음과 같이 나옵니다. TIMEOUT! 도 없고 인식도 가장 빠른것 같아요.

동영상도 올려 봅니다.

6. FeliCa 인식

FeliCa 가 된다고 하니, electhouse 소스의 FeliCa_Card_Read 를 실행해 봅니다.

File > Examples > elechouse_PN532 > FeliCa_Card_Read

실망스럽게도 PASMO 는 인식되지 않았습니다.

당연하게도 Mifare (ISO14443A) 카드들에게는 전혀 반응하지 않았구요.

단, 희한하게도 일본에서 사용했던 Times (한국의 SOCAR 같은 서비스) 카드는 이 소스로 읽혔습니다.

FeliCa 도 여러 종류가 있는 듯 합니다.

아쉽게도 지하철에 사용되는 FeliCa 인, 일본의 PASMO 와 싱가포르의 EZ-Link 는 어떤 소스에도 읽히지 않았습니다.

7. High Speed UART 연결

특이하게 HSU 라는 연결 방법을 제공합니다. 이는 High Speed UART 의 약자.

이 HSU 는 Hardware Serial (Serial1) 을 바탕으로 소스가 만들어졌습니다.

다만, 위의 표에서 보이듯이, Hardware Serial 를 사용하는 지라, 일부 arduino 에서는 Serial Monitor 를 열어서 확인할 수 없게 됩니다.

Arduino Nano 도 Hardware Serial 은 USB 통신에 점유되어 있어서 "Serial1" 을 사용할 수 없었습니다.

하늘이 무너져도 솟아날 구멍은 있다던가요, 가지고있는 arduino micro 에서는 사용 가능했습니다.

그럼 아래 source 를 arduino micro 에 업로드 해봅니다.

File > Examples > electhouse_PN532 > iso14443a_uid

PN532_HSU 쪽을 활성화면서 "Serial1" 을 사용하게 합니다.

Arudino micro 와의 pin 연결은 다음과 같습니다.

   PN531  | Arduino Micro
--------------------------
    VCC   |     5V
    GND   |     GND
    SDA   |     RX
    SDL   |     TX
--------------------------

잊지 말아야 할 것은, DIP switch 를 HSU 으로 설정해 둬야 합니다.

Arduino micro 의 RX / TX 와 연결하여 HSU 인겁니다.

오오오오! 느낌적으로 SPI 보다 더 빠른 듯 합니다. 이게 가장 빠르네요.

결과는 이렇게 보이구요.

동영상도 올려 봅니다.

그럼 arduino nano 처럼 Hardware Serial 여유가 없는 arduino 는 안되는거냐!

찾아보니 방법을 GitHub 의 설명에서 친절하게 알려주고 있었습니다.

아래 소스처럼 "SoftwareSerial.h" 를 이용하여 구현이 가능합니다.

우선 바로 아래는 Hardware Serial 로 구현된 부분을...

#include "PN532_HSU.h"
#include "PN532.h"

PN532_HSU pn532hsu(Serial1);
PN532 nfc(pn532hsu);

void setup(void)
{
	nfc.begin();
	//...
}

아래처럼 SoftwareSerial.h 를 추가하고 관련된 pin 을 정의해 주면 됩니다.

뭐, 관련된 함수를 "PN532_SWHSU.h" 에서 구현해 줘서 가능한 것이지만 말입니다.

#include "SoftwareSerial.h"
#include "PN532_SWHSU.h"
#include "PN532.h"

SoftwareSerial SWSerial( 10, 11 ); // RX, TX

PN532_SWHSU pn532swhsu( SWSerial );
PN532 nfc( pn532swhsu );

void setup(void)
{
	nfc.begin();
	//...
}

최종적으로 Hardware Serial 관련 부분을 주석처리 하고, SoftwareSerial 을 활성화 하는 코드를 추가하면 됩니다.

Pin 연결은 위에서 정의한 D10 과 D11 에 각각 연결하면 됩니다.

참고로, SDA 는 TX 이고, SDL 은 RX 이므로, SDA(TX) <--> D10 (RX), SDL(RX) <--> D11(TX) 가 됩니다.

   PN531  | Arduino Nano
-------------------------
    VCC   |     5V
    GND   |     GND
    SDA   |     D10
    SDL   |     D11
-------------------------

잘 구동합니다만, 뭔가 타이밍이 맞지 않은지 authentication fail 이 뜹니다.

소스코드에서 수정해야 할 부분이 있는듯 보입니다만, 확인이 어느정도 되었으니 패스.

8. 확인한 RFID / NFC 카드들

마지막으로, 본 포스트에서 확인용으로 사용된 카드들을 소개합니다.

위는 PN532 breakout board 를 구입하면 기본으로 딸려오는 tag 들 입니다. 하나는 원형, 하나는 카드 모양입니다.

위는 싱가포르 출장때 구입해서 사용했던 지하철 패스카드 입니다. 충전식이죠.

아쉽지만, 구입한 PN532 가 짝퉁이라서 못 읽는 것인지 모든 소스와 연결 방법에서 읽기를 실패했습니다.

마찬가지 FeliCa 인식에서 실패한 일본 PASMO 입니다. 일본에서 거주할때 신세를 졌었죠.

저의 회사 출입 카드 입니다. 5년전에 찍은 거라 얼굴이 지금보다 젊어 보이네요. ㅠㅠ

버스카드 겸용인 신용카드 입니다. Mifare Classic 입니다. 잘 읽힙니다.

전용 어플을 이용하면 RFID 정보도 덮어 씌기가 될 듯 한데, 이번에는 도전하지 않았습니다.

유일하게 읽힌 FeliCa 카드 입니다!

다른 소스에서는 전혀 읽히지 않았고, FeliCa Read 소스에서만 유일하게 읽힌 놈입니다.

일본에서 자가용을 운용할 여유가 안되어서, 잘 빌려서 타고 다녔습니다. (SOCAR 같은 서비스)

9. FIN

역시 아쉬운 점은 지하철용 FeliCa 를 읽을 수 없었다는 점 입니다.

뿌듯한건 모든 인터페이스 - HSU, Software HSU, I2C, I2C with RST, Hardware SPI, Software SPI - 모두를 확인해 봤다는 점 입니다.

기회가 되면, 아래 스샷처럼 NXP 에서 나온 어플을 가지고 완벽하게 debugging 을 해보고 싶습니다.

다만, PN544 breakout 보드가 5만원 이상이라는 것 때문에, 일단 여기서 멈춥니다.

조만간 AliExpress 에서 주문한 RFID reader 와 tag 가 도착하기 전에 RFID 에 조금이라도 알고 싶어서 이 책을 도서관에서 빌렸습니다.

ETRI 관련된 박사님들이 각자 잘 아시는 영역의 글을 모아 만든 RFID/USN 관련된 서적입니다.

아래는 목차입니다.

이 책은 8분이 공동으로 저술한 책 입니다.

1. 책 정보

* 시리즈 : ETRI easy IT 의 6번째 책

* 제목 : 훤히 보이는 RFID/USN

* 발행 : 초판 2008년 6월 25일

* 지은이 : 표철식, 박상준, 김기일, 김동균, 이문규, 김관중, 김선진, 서정해

* 펴낸곳 : 전자신문사

* ISBN 978-89-92885-05-8 03560

* 값 : 20,000원

꼭 알아야 할것은, 이 책이 발간된 해가 2008 년도 라는 부분입니다.

지금은 NFC 나 RFID 가 일상생황에 많이 쓰이고 있어서, 독자에게 별다른 감흥을 못주는 책이 될 수 있습니다.

또한 일본에서는 이미 NFC 기능의 Suica 를 2001년부터 시험 운용하고 있었다는 점을 보면, 2008년에 이 책이 나온것도 조금 늦은 감이 없지않아 있습니다.

2. 용어

알아둬야 할 용어는 당연히 다음과 같겠습니다.

* RFID : Radio Frequency Identification

- https://en.wikipedia.org/wiki/Radio-frequency_identification

* USN : Ubiquitous Sensor Network

- T23010000040001PDFE.pdf

* NFC : Near Field Communication

- https://en.wikipedia.org/wiki/Near-field_communication

지금에 와서는 USN 은 IoT 의 일부가 되겠네요.

요즘은 USN 이라고 이야기 하면 알아듣는 사람은 거의 없을꺼예요.

이 출판물이 나왔던 2008년에 ITU 에서 발간한 문서에서 USN 이라는 용어가 쓰였습니다.

또한 비슷한 것끼리는 RFID 와 NFC가 있습니다만, 개발된 흔적에 따라 쓰임이 조금 다릅니다.

아래 website 에서 잘 설명되어 있네요.

* RFID vs. NFC: What’s the Difference?

- https://blog.atlasrfidstore.com/rfid-vs-nfc

infographic 으로 된 그림이 있어서 여기에 개제해 봅니다.

iPhone 끼리 근거리 통신을 통하여 사진을 전송받는 기술이 NFC 였군요.

3. 원리

긴 이야기를 짧게 해본다면 다음과 같습니다.

- 전자기파를 reader 에서 쏴주면, tag 코일에서 발생하는 유도전류를 통해 생성된 전기

- 그 전기를 이용하여 tag ID 를 reader 에 부하변조를 통하여 정보 전달

- 변조 방식은 ASK, FSK, PSK 등을 사용

5. chip 선택

이미 완성된 기술이기 때문에 그만큼 규격도 다양하게 나왔습니다.

그 규격에 따라 사용되는 tag chip 과 reader 종류가 많습니다.

사실 규격이라고 하기보단, 필요에 따라 발전시킨 버전들이라고 봐야겠죠.

마침 "RFID Selection Guide" 라는 PDF 를 인터넷에서 발견해서 여기에 링크를 걸어 봅니다.

* RFID Selection Guide

- rfid+guide.pdf

위에서 보이는 PN532 가 마켓에서 쉽게 구할 수 있고, NFC 및 RFID 양쪽에 대응하면서 그럭저럭 쓸만한 대상으로 보입니다.

인터넷에서 찾아보면 RFID 만 되고, 상용 NFC 가 안되는 것들도 있거든요.

SONY 가 개발한 FeliCa (Suica) 및 iPhone 의 FeliCa 대응 NFC 도 될 듯도 하니,

AliExpress 에서 도착하면 따로 글을 작성해 보겠습니다.

FIN

책 이야기는 별로 하지 않고, RFID 와 NFC 에 대해서 조사해본 이야기가 주가 되었네요.

이 책의 아쉬운 부분은, 이미 한창 발전해버린 RFID 가 주제이다 보니, 지금의 2019 년에 읽기에는 조금 old 한 느낌입니다.

또 하나를 더 들자면, 저자가 8명이나 관여하다 보니 서로 겹치는 내용이 다뤄져 있어, 읽는데 지겹습니다. (사공이 많음)

어떤 챕터는 너무 기본 기술에 치중되어 있고, 다른 챕터는 활용성에만 치중되어 있어서, 이게 기술서적인지 마케팅 서적인지 혼란스러운 부분도 있습니다.

다만 일관성이 없다보니, 전반적으로 "응~ 그렇구나" 정도로 넓은 범위로 지식을 얻기에는 좋은 책이네요. (궂이 들자면...)

1. MAX31865

K-Type 온도 센서를 arduino 와 연결하여 측정하는 MAX31855 은 아래 포스팅에서 가지고 놀아 봤습니다.

* Hardware | MAX31855 + K-type 온도센서 조합

- http://chocoball.tistory.com/entry/Hardware-MAX31855-Ktype

그 외의 온도센서에 대해서는 아래 포스트들을 참고해보세요.

* Hardware | AM2322 Temperature & Humidity Sensor

- http://chocoball.tistory.com/entry/Hardware-AM2322-Temperature-Humidity-Sensor

* Hardware | Arduino 비접촉 온도센서 GY-906 MLX90614

- http://chocoball.tistory.com/entry/HardwareArduinoMLX90614

* Hardware | Arduino BMP280 고도/온도/기압 센서

- http://chocoball.tistory.com/entry/HardwareArduinoBMP280

* Hardware | BME280 sensor

- http://chocoball.tistory.com/entry/HardwareBME280

* Hardware | DS18B20 온도센서

- http://chocoball.tistory.com/entry/Hardware-DS18B20-temperature-sensor

여기서 주의할 점은, MAX31865은 MAX31855와 제일 마지막 앞번의 digit 차이 입니다.

주문시 주의해야 합니다.

* MAX31865 : PT100 / PT1000 용

* MAX31855 : K-type 용

2. MAX31865 구입

AliExpress 에서 검색하면 아래의 링크가 가장 많이 구입한걸로 나옵니다.

바로 주문 넣습니다.

* MAX31865 SPI PT100/PT1000 RTD-to-Digital Converter Board Temperature Thermocouple Sensor Amplifier Module For Arduino 3.3V/5V

- https://ko.aliexpress.com/item/MAX31865-PT100-PT1000-RTD-to-Digital-Converter-Board-Temperature-Thermocouple-Sensor-Amplifier-BModule-For-Arduino/32777498066.html

3. 도착

다른 센서들보다는 조금 높은 가격입니다.

그러나 업자는 항상 1 USD 미만으로 보내주십니다. :-)

포장은 일반적인 간단한 포장입니다.

Adafruit 제품과 거의 동일하게 만들었습니다.

Chip 을 확대해 봤습니다.

Taiwan 에서 생산된 M31865 라고 인쇄되어 있습니다.

Pin array 와 terminal 을 납땜해 줍니다.

Rref 의 저항은 431 = 430 ohm 입니다.

4. Thermocouple K-Type 구매하기

MAX31865 를 구입하면서, 거의 동시에 온도 센서도 주문에 넣습니다.

* Thermocouple K-Type Thermocouple Thermometer Probe WRNT-03 200mm*1000mm

- https://ko.aliexpress.com/item/Thermocouple-K-Type-Thermocouple-Thermometer-Probe-WRNT-03-200mm-1000mm/32615649856.html

분명히 K-Type 이라고 적혀 있습니다.

Probe 형이라 길이가 깁니다. 포장도 큼지막 합니다.

뽁뽁이로 잘 쌓여서 도착했습니다.

음? CU50?

이미 MAX31855 글에서도 CU50 에 대해서 적었습니다.

MAX31865 / MAX31855 의 개념이 없었고, K-Type / PT100 / PT1000 개념도 없이 처음 질렀던 온도계 센서 입니다.

더욱 헷갈리게 된 것은, K-Type 이라고 주문한게 CU50 이 도착해, 처음 한동안은 뭐가 문제인지 몰랐습니다.

그 뒤에 센서 및 coverter chip 종류가 다르다는걸 알았죠.

* CU50 / WRNT-03 spec.

- K1118591875.pdf

뭘 모르면 알때까지 삽질해야 하는 것은 인생의 진리 입니다.

5. PT100 구입하기

MAX31865 는 PT100 / PT1000 용 analog to digital converter 입니다.

PT1000 은 예민하면서 실험실용으로 사용되고 있어서, PT100 을 선택합니다.

* MYLB-0-400C PT100 Type 5mm x 50mm Temperature Controller Thermocouple Probe 2 Meters

- https://ko.aliexpress.com/item/MYLB-0-400C-PT100-Type-5mm-x-50mm-Temperature-Controller-Thermocouple-Probe-2-Meters/32746546570.html

점점 진실에 접근하는 느낌이 듭니다.

도착.

포장 문제 없슴.

선은 3 wire 센서 이군요.

흠흠.

색이 다른 터미널끼리는 거의 100 ohm 의 차이를 보입니다.

이는 PT100 의 일반적인 현상이며, 더운 여름에 측정하다 보니 저항값이 조금 높습니다.

이 저항값의 변화를 가지고 온도를 측정하는 것입니다.

동일 선끼리는 거의 0 ohm 입니다.

6. Pinout / Layout

Pinout 에 대해서는 아래 Adafruit 의 링크를 참조해 보세요.

* Adafruit MAX31865 RTD PT100 or PT1000 Amplifier

- https://learn.adafruit.com/adafruit-max31865-rtd-pt100-amplifier/pinouts

 MAX31865  | Arduino Micro
---------------------------
    Vin    |      3.3V
    GND    |      GND
    CLK    |      D13
    SDO    |      D12
    SDI    |      D11
    CS     |      D10
---------------------------

Layout 입니다.

7. sketch

레퍼런스 소스를 이용해서 기본적인 동작 확인에 들어갑니다.

우선 Library Manager 에서 max31865 를 검색해서 install 해줍니다.

인스톨이 완료되면, "File > Examples > Adafruit MAX31865 library > max31865" 을 선택하여 소스를 로딩합니다.

아래는 sketch 입니다.

/*************************************************** 
  This is a library for the Adafruit PT100/P1000 RTD Sensor w/MAX31865

  Designed specifically to work with the Adafruit RTD Sensor
  ----> https://www.adafruit.com/products/3328

  This sensor uses SPI to communicate, 4 pins are required to  
  interface
  Adafruit invests time and resources providing this open source code, 
  please support Adafruit and open-source hardware by purchasing 
  products from Adafruit!

  Written by Limor Fried/Ladyada for Adafruit Industries.  
  BSD license, all text above must be included in any redistribution
 ****************************************************/

#include 

// Use software SPI: CS, DI, DO, CLK
Adafruit_MAX31865 max = Adafruit_MAX31865(10, 11, 12, 13);
// use hardware SPI, just pass in the CS pin
//Adafruit_MAX31865 max = Adafruit_MAX31865(10);

// The value of the Rref resistor. Use 430.0 for PT100 and 4300.0 for PT1000
#define RREF      430.0
// The 'nominal' 0-degrees-C resistance of the sensor
// 100.0 for PT100, 1000.0 for PT1000
#define RNOMINAL  100.0

void setup() {
  Serial.begin(115200);
  Serial.println("Adafruit MAX31865 PT100 Sensor Test!");

  max.begin(MAX31865_3WIRE);  // set to 2WIRE or 4WIRE as necessary
}


void loop() {
  uint16_t rtd = max.readRTD();

  Serial.print("RTD value: "); Serial.println(rtd);
  float ratio = rtd;
  ratio /= 32768;
  Serial.print("Ratio = "); Serial.println(ratio,8);
  Serial.print("Resistance = "); Serial.println(RREF*ratio,8);
  Serial.print("Temperature = "); Serial.println(max.temperature(RNOMINAL, RREF));

  // Check and print any faults
  uint8_t fault = max.readFault();
  if (fault) {
    Serial.print("Fault 0x"); Serial.println(fault, HEX);
    if (fault & MAX31865_FAULT_HIGHTHRESH) {
      Serial.println("RTD High Threshold"); 
    }
    if (fault & MAX31865_FAULT_LOWTHRESH) {
      Serial.println("RTD Low Threshold"); 
    }
    if (fault & MAX31865_FAULT_REFINLOW) {
      Serial.println("REFIN- > 0.85 x Bias"); 
    }
    if (fault & MAX31865_FAULT_REFINHIGH) {
      Serial.println("REFIN- < 0.85 x Bias - FORCE- open"); 
    }
    if (fault & MAX31865_FAULT_RTDINLOW) {
      Serial.println("RTDIN- < 0.85 x Bias - FORCE- open"); 
    }
    if (fault & MAX31865_FAULT_OVUV) {
      Serial.println("Under/Over voltage"); 
    }
    max.clearFault();
  }
  Serial.println();
  delay(1000);
}

결과는 아래와 같습니다.

뭔가 많이 이상하군요... 뭐가 문제일까...

8. Jumper !!!

그렇습니다.

Adafruit 의 점퍼 설정을 대충 읽은 결과 입니다.

위의 글에 나와 있듯이, 미세하게 연결된 24 부분의 선을 잘라줘야 합니다.

시키는 대로 했으나 제대로 되지 않았습니다.

처음에는 CU50 으로 삽질하면서 2 wire 설정으로 납땜 했다가, 납 지워줬다가, 3 wire 설정으로 다시 납땜 했다가,

기판이 지저분해진 상태이고, 자주 인두로 지져서 기판 상태가 엉망으로 되면서 고장난게 분명하다는 결론에 도달했습니다.

(모두 합하면 10시간동안 삽질함)

9. 재구매

breakout 보드값이 비싸지만, 모든걸 다 해본 뒤라 새로운 converter 를 구입하기로 합니다.

이번에는 색이 다른것으로 구입합니다.

배송료 합하면 거의 6천원이군요... ㅠ.ㅠ

* 31865 MAX31865 RTD platinum resistance temperature detector module PT100 to PT1000

- https://www.aliexpress.com/item/31865-MAX31865-RTD-platinum-resistance-temperature-detector-module-PT100-to-PT1000/32814557294.html

잘 도착했습니다. 얼른 시험해보고 싶습니다.

점퍼 사시의 간극이 커서 잘 납땜해야 합니다.

Rref 저항은 430 ohm 으로 동일하며, 2 4 사이에 미세하게 연결되어 있는것도 확인했습니다.

커터로 잘 그어서 절단해 줍니다.

두둥!

잘 연결하고 확인해 봅니다.

Aㅏ.....

그렇습니다. 여러 삽질을 하는 동안, 기존 breakout 기판이 고장난 것이었습니다.

그간 삽질하면서 학습한 내용을 토대로 잘 jumper 도 납땜하고, 자를껀 자르고 연결하니 한방에 성공합니다.

애증의 MAX31865 와 PT100 센서 입니다.

찬물 / 상온 물 / 뜨거운 물을 가지고 확인한 동영상 입니다.

calibration 이 필요해 보이지만, 그딴거는 나중에 기회되면 하겠습니다.

여기까지 오는것만 해도 힘들었습니다.

그래프화 시킨 그림입니다.

동작에 무리 없어 보입니다.

FIN

제가 가지고 있는 온도센서 및 converter breakout 보드는 다 확인해 봤네요.

CU50 만 빼고... 이놈은 어떻게 해야 할까요.

1. 또 온도센서야?

지금까지 시험해본 온도센서들 입니다. 5개나 있네요.

* Hardware | AM2322 Temperature & Humidity Sensor

- http://chocoball.tistory.com/entry/Hardware-AM2322-Temperature-Humidity-Sensor

* Hardware | Arduino 비접촉 온도센서 GY-906 MLX90614

- http://chocoball.tistory.com/entry/HardwareArduinoMLX90614

* Hardware | Arduino BMP280 고도/온도/기압 센서

- http://chocoball.tistory.com/entry/HardwareArduinoBMP280

* Hardware | BME280 sensor

- http://chocoball.tistory.com/entry/HardwareBME280

* Hardware | DS18B20 온도센서

- http://chocoball.tistory.com/entry/Hardware-DS18B20-temperature-sensor

네 그렇습니다.

온도 센서에는 기존에 확인했던 위의 센서들 말고, 준비하고 있는게 아래 3가지가 있습니다.

- K-type

- PT100 / PT100

- Cu50

이 포스트에서는 K-Type 에 대해 알아보려 합니다.

2. K-type

이번에는 K-type 온도센서 이므로, 해당의 제품을 구매합니다.

* Thermocouple K-Type Thermocouple Thermometer Probe WRNT-03 200mm*1000mm

- https://www.aliexpress.com/item/Thermocouple-K-Type-Thermocouple-Thermometer-Probe-WRNT-03-200mm-1000mm/32615649856.html

일반적으로 Thermocouple K-type 은 선이 두가닥인데, 도착한 놈은 세가닥 입니다.

거기에 더해서 "Cu50" 이라는 라벨도 붙어 있습니다...

분명 난, K-Type 을 보고 주문한건데 말입니다.

사양서도 확인해 보면 WRNT-03 이라서 Probe type 의 thermocouple 이라고 생각했습니다만, 도착한건 그냥 Cu50 인듯 합니다..

세가닥 단자들 사이는 55 Ohm / 0 Ohm 의 차이를 보입니다.

100 Ohm 정도면 PT100 인데, 55 Ohm 이면 좀 애매하네요.

확실히 잘 사용되지 않는 Cu50 이 맞는 듯 합니다.

이놈은 이놈 나름대로 사용될 수 있는 방법을 찾아봐야겠습니다.

음?

테스터기로 측정하고 있을 때 눈에 들어오는 테스터용 온도 probe !!!

위 사진의 오른쪽 다발로 보이는 것이 테스터용 온도 센서 입니다.

혹시나? 하고 메뉴얼을 찾아 보니 "K-type" 이라고 적혀 있네요!

우연히 K-Type 온도센서를 구할 수 있게 되었습니다.

역시 K-Type 은 단자가 2개인게 확실합니다.

3. MAX31855

보통 온도 센서들은 아날로그 값으로 표현하므로, digital 로 변환해주는 converter 가 필요합니다.

K-Type 온도센서용으로는 MAX31855 라고 하는군요.

Arduino 용 K-Type 모듈인 MAX31855 를 구입합니다.

* MAX31855 MAX6675 SPI Type K Thermocouple Temperature Sensor Board Module For Arduino

- https://ko.aliexpress.com/item/MAX31855-K-Type-Thermocouple-Breakout-Board-Temperature-200C-to-1350-Celsius-for-Arduino/32746337946.html

아래는 도착 사진 입니다.

친절하게 알아서 사용하라는 중국 생산자의 배려 입니다.

기록을 위해 뒷면도 찰칵.

4. sketch

Arduino IDE 에서 Library Manger 를 열고 max 라는 키워드로 검색하면, MAX31855 가 나옵니다.

인스톨 하세요.

패키지 인스톨 후, "File > Examples > Adafruit MAX31855 library > serialthermocouple" 을 선택합니다.

Sketch 는 다음과 같아요.

/*************************************************** 
  This is an example for the Adafruit Thermocouple Sensor w/MAX31855K

  Designed specifically to work with the Adafruit Thermocouple Sensor
  ----> https://www.adafruit.com/products/269

  These displays use SPI to communicate, 3 pins are required to  
  interface
  Adafruit invests time and resources providing this open source code, 
  please support Adafruit and open-source hardware by purchasing 
  products from Adafruit!

  Written by Limor Fried/Ladyada for Adafruit Industries.  
  BSD license, all text above must be included in any redistribution
 ****************************************************/

#include "SPI.h"
#include "Adafruit_MAX31855.h"

// Default connection is using software SPI, but comment and uncomment one of
// the two examples below to switch between software SPI and hardware SPI:

// Example creating a thermocouple instance with software SPI on any three
// digital IO pins.
#define MAXDO   3
#define MAXCS   4
#define MAXCLK  5

// initialize the Thermocouple
Adafruit_MAX31855 thermocouple(MAXCLK, MAXCS, MAXDO);

// Example creating a thermocouple instance with hardware SPI
// on a given CS pin.
//#define MAXCS   10
//Adafruit_MAX31855 thermocouple(MAXCS);

void setup() {
  while (!Serial); // wait for Serial on Leonardo/Zero, etc
  
  Serial.begin(9600);
  
  Serial.println("MAX31855 test");
  // wait for MAX chip to stabilize
  delay(500);
}

void loop() {
  // basic readout test, just print the current temp
   Serial.print("Internal Temp = ");
   Serial.println(thermocouple.readInternal());

   double c = thermocouple.readCelsius();
   if (isnan(c)) {
     Serial.println("Something wrong with thermocouple!");
   } else {
     Serial.print("C = "); 
     Serial.println(c);
   }
   //Serial.print("F = ");
   //Serial.println(thermocouple.readFarenheit());
 
   delay(1000);
}

음? 정상적으로 동작하지 않는군요.

혹시 몰라 MAX31855 의 전 버전인 MAX6675 라이브러리를 설치하고 sketch 를 실행시켜 봅니다.

음... 안되는군요.

뭐가 문제일까요?

5. 중국 공장의 나쁜 버릇

폭풍 검색을 해도 문제를 해결한 케이스를 볼 수 없다가,

우연히 Youtube 의 댓글에서 힌트를 찾았습니다.

MAX6675 와 MAX31855 breakout 보드의 차이점은 1번과 2번 pin 이 연결되어 있느냐 없느냐의 차이라고 합니다.

제가 구입한 MAX31855 breakout 보드의 1번과 2번을 보니 붙어 있네요.

위는 MAX6675 의 breakout board 의 layout 입니다.

1번과 2번이 연결되어 있네요.

MAX31855 의 breakout board 의 1번 / 2번 pin 은 서로 붙어있지 않습니다.

Adafruit 의 정식 판매용 MAX31855 breakout board 도 1번 / 2번 pin 도 떨어져 있습니다.

위의 사진은 중국 AliExpress 제품의 소개 사진입니다.

Chip 은 MAX31855 지만, breakout board 는 전압 regulator 도 없는 MAX6675 용 breakout board 와 비슷합니다.

즉, 중국 업자들은 기존 MAX6675 breakout board 에,

스펙이 비슷한 MAX31855 chip 을 얹은게 아닌가 하는게 internet 친구들의 예상입니다.

MAX31855 는 minus 온도까지 측정할 수 있는 등 upgrade 되었으나,

MAX6675 breakout board 를 사용하면서 기능 확장도 안되고, pinout spec. 에 맞지 않게 된거죠.

쉽게 말하면,

upgrade 제품이니까 맞겠지 하고 MAX6675 breakout board 에 MAX31855 를 얹으면서 정상작동하지 않는 것이였습니다.

(이거 팔아도 되는거야? 구매한 다른사람들은 어떻게 사용한거지?)

결국 위의 사진처럼 1번/2번 pin 사이의 연결을 완전히 긁어 내어 단락시키니 정상 작동하였습니다.

아놔....

6. K-Type +/- 단자 사이에 capacitor

해결점을 찾아서 정상 작동까지는 왔으나,

값이 널을 뛰어 안정적으로 측정하지 못했습니다.

위에서 보듯이 많은 사람들이 단자에 capacitor 를 사용했더랬습니다.

* Hardware | AliExpress 에서 Ceramic Condenser 를 구입해 보자

- http://chocoball.tistory.com/entry/Hardware-AliExpress-Ceramic-Condenser-buying

뭘 하려면 여러가지가 구비되어야 하는군요.

다행이 ceramic capacitor (condenser) 가 있었습니다.

사용된 것은 10nF = 0.01uF 입니다.

7. Pinout / Layout

Pinout 은 다음과 같습니다.

 MAX31855  | Arduino Micro
---------------------------
    Vin    |      5V
    GND    |      GND
    DO     |      D3
    CS     |      D4
    CLK    |      D5
---------------------------

구성도는 다음과 같습니다.

8. 결과

이제서야 제대로 측정이 되었습니다.

chip 자체적으로 Internal Temp 를 측정 가능한게 신시합니다.

여름 저녁이라 거실 실내 온도가 31도군요.

올해는 더워도 너무 덥습니다. 1994년도 5월에 입대하고 기초훈련 받던 때가 생각나네요.

그때도 이만큼 더웠던것 같습니다. 유격훈련 한번 하고 나면 동기들이 탈진해서 쓰러지곤 했더랬습니다.

우리 기수, 다른 중대 훈련병 중에 행군중 탈진으로 죽은 전우가 있어,

저의 다음 기수부터는 행군을 생략했다는 이야기를 들었습니다.

저의 행군 중에도, 옆에서 쓰러진 동기는 흰자위를 보이며 땅바닥에서 경련을 일으킬 정도로 극한의 날씨였습니다.

위는 K-type thermocouple 에 라이터 불로 온도를 높혔을 때를 동영상으로 찍어 봤습니다.

EXCEL 의 그래프 작업으로 internal / sensor 의 온도변화를 그래프로 표현해 봤습니다.

흠흠, 잘 변화를 감지했군요.

FIN

제대로 함정을 밟았지만, 잘 헤쳐나온것 같습니다.

Breakout board 는 되도록 reference (Adafruit / Sparkfun) 과 잘 비교해 본 다음, 문제가 없어보이면 구입하는게 좋을것 같습니다.

이 글은 전편이 있습니다. 먼저 다음 link 를 꼭 읽고 오세요.

* Safecast bGeigie Nano 를 조립해 보자 - 1

- http://chocoball.tistory.com/entry/Hardware-Safecast-bGeigie-Nano-1

1. Mainboard

bGeigie Nano 의 중추인 mainboard 입니다.

보드 버전은 1.1r5a 입니다.

조립 메뉴얼이 초기 버전을 기준으로 제작되어 있다 보니, 나름 최신 보드와 맞지 않는 부분들이 있습니다.

대략 예상하면서 메뉴얼을 따라가면 그리 큰 문제는 없습니다.

모든 실장 위치에 금도금이 되어 있어서 납이 잘 붙게 되어 있습니다.

잘 만들어진 보드라고 생각합니다.

2. 부품과 아크릴 지지대

부품은 따로 포장되어 있습니다.

제가 받은 제품의 고유 번호는 2981 되겠습니다.

기판을 보호하고 모양을 만들어주는 아크릴 지지대와 logging 을 위한 micro SD + adapater,

그리고 GM tube 를 보호해 주는 철망이 보입니다.

3. 저항 납땜하기

이제 본격적으로 작업을 시작합니다.

저항을 하나씩 검수해 가며 납땝합니다.

예전에 만들어 놓은 Transistor Tester 를 이용했습니다.

* Transistor Tester

- http://chocoball.tistory.com/entry/Hardware-Transistor-Tester

10kΩ 짜리를 측정해 봅니다. 대략 오차범위 이내 입니다. 납땜해 줍니다.

1kΩ 짜리를 측정해 봅니다. 대략 오차범위 이내 입니다. 납땜해 줍니다.

4.5kΩ 짜리를 측정해 봅니다. 대략 오차범위 이내 입니다. 납땜해 줍니다.

겨우 4개 저항을 납땜했지만 뿌듯합니다. 기념샷 찍어줍니다.

계속 측정하고 땜질하고 반복합니다.

궁금해졌습니다. 왜 예전 방식인 "탄소 피막 저항" 일까?

온도변화에 약하며 정확도가 떨어지는 제품을 썼을까?

"메탈 피막 저항" 은 정확하며 온도변화에도 강한데 말입니다.

저항에 대해서는 아래 link 를 읽어보세요. 저도 처음에는 구분을 못했답니다.

- http://chocoball.tistory.com/entry/Hardware-buying-resistors

집에 굴러다니는 메탈 피막 저항을 측정해 보는 것으로 궁금함은 더해가지만,

일단 접어두고 나중에 community 에 물어봐야겠습니다.

4. 콘덴서 납땜하기

저항 다음에는 콘덴서를 납땜해 줍니다.

총 3개가 있습니다. 100nF 이라고 합니다.

정말 소중하게 한땀한땀 납땜하였습니다.

뒷면의 리드로 모드 잘라주었습니다. 깔끔하게 잘 했다고 자화자찬을 해 봅니다.

5. 그 외 부품 납땜하기

저항과 콘덴서로 손이 어느정도 익었으니, 속도를 좀 내어 봅니다.

트랜지스터 1개와 스위치류, LED 등을 납땜해 갑니다.

C1815 라는 제품이지만 잘 모릅니다.

측정해 보면 NPN 트랜지스터 입니다. 납땜해 줍니다.

토클 스위치입니다. 일본에서 제조된 제품이네요.

사진으로는 크지만 앙증맞게 생겼습니다. 금속으로 된 스위치로 딸깍거리며 동작시키는 것이 은근 재미 있습니다.

무슨 용도의 스위치 인지는 모르겠습니다.

조이스틱처럼 누르기도 되고 상하좌우 움직일 수 있습니다. 메뉴 설정등에 사용될 듯 합니다.

밑면입니다.

스피커 입니다. 제품 마무리가 잘 되어 있습니다.

다이오드 입니다. 열에 약하니 최대한 짧게 열을 가하여 납땜합니다.

전원 스위치 입니다.

전류가 흐르는 곳이니 납을 많이 먹여 납땜합니다.

딥스위치 입니다. 납땜합니다.

Alerting 과 Counting 을 하는 LED 입니다.

제품 버전에 따라 빨간색 대신 파란색도 있었던것 같습니다.

조립하는 사람에 따라 빨간색을 counting 으로 사용하는 사람도 있고 여러가지 입니다.

저는 Alerting 에는 빨간색, Counting 에는 흰색을 선택해서 납땜하였습니다.

LED 는 이런 값을 보여주는군요.

Transistor Tester 로 측정시 불이 들어왔다 나갔다 하는 모습이 신기하여 동영상으로도 찍어 봤습니다.

아마도 측정시에 여러가지 패턴으로 전류/전압을 가해보고 결과를 도출하는 것 같습니다.

자잘한 부품을 모두 납땜한 모양입니다. 여기까지 하고 좀 쉬었습니다. 한 2주일.

6. OLED

가장 눈에 띄는 OLED 를 작업합니다.

뽁뽁이 포장지를 잘 뜯습니다.

저 위의 구멍에 납땜을 하면 됩니다.

제품 정식 명칭은 Adafruit 사의 SSD1306 1.3" 128x64 OLED 입니다.

집에 다른 OLED 두개를 더 가지고 있어서 잠깐 비교 놀이를 해봅니다.

* Adafruit SSD1306 128x64 1.3" monochrome OLED 를 사용해보자

- http://chocoball.tistory.com/entry/Hardware-Adafruit-SSD1306-128x64-13inch-monochrome-OLED

기판 밑부분에 지지대를 납땜하고 볼트로 고정해 줍니다.

OLED 를 납땜한 소켓에 삽입하고 너트로 지지대 기둥에 고정해 줍니다.

설명서에는 휘지 않도록 너트를 위아래로 설치하라고 되어 있으나, 지지대 볼트 길이가 짧아서 절대 불가능 합니다.

그냥 위에만 너트로 고정해 줍니다. 너무 조이면 장력이 생기니 적당하게 조여줍니다.

7. GPS module

Adafruit 의 Ultimate GPS Breakout v3 제품입니다.

66개의 channel 을 받을 수 있다고 하네요. Wow!

뒷면은 GPS 정보를 저장하여 다시 reboot 될 때 GPS 를 빨리 연동되게 하기 위한 battery 고정부가 있습니다.

3.3V ~ 5V 까지 인가할 수 있습니다. 5V 도 견디지만 3.3V 로 동작시키면 좋겠죠?

이렇게 분리되어 있는 것을 아래와 같이 납땜해 주었습니다.

고정하는 부분이니 납을 많이 먹여 주었습니다.

GPS 가 올 자리는 여기가 되겠습니다.

지지대를 세우고 mainboard 와 연결되는 부분에 pin 을 납땜해 줍니다.

고정 기둥에 올려 놓고 너트로 조이면 이렇게 됩니다.

점점 모양을 갖춰 가네요.

8. OpenLog

측정한 data 를 micro SD 에 저장하는 부분입니다.

제품은 SparkFun 사의 OpenLog DEV-13712 입니다.

Arduino 와 친숙한 ATmega 칩이 달려 있습니다.

뒷면은 micro SD 를 삽입할 수 있게 되어 있습니다.

한번 넣으면 딸깍 하면서 고정이 되고, 다시한번 누르면 튀어나오는 방식입니다.

위치할 자리는 여기 입니다.

예전 버전에는 바로 아래 부분에 GM tube 와 연결하는 pin 납땜자리가 있어 쉴딩을 해줘야 했지만,

버전업이 되면서 GM tube 연결 땜 자리는, 그 밑으로 위치하는 레이아웃으로 바뀌었습니다.

이왕 본 김에 GM tube 와 연결되는 pin 을 납땜해 줍니다.

9. Arduino FIO

이제 두뇌에 해당하는 Arduino FIO 를 작업합니다.

DEV-10116 이라고 되어 있네요.

LED가 반짝반짝 하는 윗부분이 밑으로 가야 하는지라 좀 아쉽습니다.

밑부분이지만 위로 가는 부분입니다.

위치는 여기가 되겠네요.

납땜할 자리가 가장 많습니다.

일단 mainboard 에 모든 다리에 pin 을 넣고 납땜해야 하고, 그다음 male pin 들을 Arduino FIO 에 납땜하여 다리를 만들어 줘야 합니다.

향후 firmware upgrade 를 위해 FTDI 인터페이스에도 납땜을 해 줍니다.

실제로 이런 모양이라고 합니다.

* Using a L-shaped plug and soldered low-profile sockets to program a Fio

- https://www.arduino.cc/en/Main/ArduinoBoardFioProgramming

나중에 software 가 version up 되면 도전해 보겠습니다.

마침 FTDI breakout 보드도 있네요 :-)

* FTDI Serial Adapter 를 사용해 보자

- http://chocoball.tistory.com/entry/Hardware-FTDI-FT232RL-using

지금까지의 모든 부붐을 올려 봤습니다. 호오오오!

10. Bluetooth module

micro SD 카드에 logging 을 하지만,

스마트폰으로 실시간 측정치를 확인하거나, 로그를 인터넷으로 바로 보내고 싶으면 Bluetooth 모듈이 필요합니다.

제품은 seeed 사의 BLEBee v2 입니다.

- https://www.seeedstudio.com/BLEBee-v2.0.0-p-2461.html

따로 사려면 34.5 USD 하는군요.

AliExpress 에서 파는 XBEE 의 bluetooth 모듈과 호환이 되는지 많이 궁금합니다.

- https://ko.aliexpress.com/item/Free-shipping-bluetooth-wireless-module-bluetooth-slave-HC-06-red-for-arduino/2046081268.html

기회가 되면 한번 실험해 보겠습니다.

Bluegiga BLE113-A-M256K 라는 모듈을 이용해서 만들었다고 합니다.

오리지날은 MiKro Labs 라고 합니다.

하지만 이미 website 는 가동되지 않고 있네요. ( www.mikro-labs.com )

Arduino FIO 의 밑단 부분에 세모로 선이 그어있는 부분에 꽂습니다.

11. 시험 가동

GM tube 를 제외하고 모든 부품이 실장되었습니다.

GM tube 를 연결하기 전에 납땜이 정상인지를 확인하고,

추가 작업을 진행하기 전에 수정사항이 있는지를 보기 위해 battery 를 연결하고 시험 가동을 해 봅니다.

동봉된 battery 는 1200mAh Li-Ion Polymer 입니다.

두근두근....

한번에 성공입니다!!!

사실 실패하면 다른 방도는 없었습니다.

역시 납땜시는 열을 최대한 짧게 가하고 완료하는게 정말 중요하네요. 오로지 이거 하나만 지키면서 납땜하였습니다.

오랜 동안 납땜에 투자한 시간이 보상받는 순간입니다.

12. Geiger Mueller Tube

방사능 측정용 센서는 pancake 형태인 센서 입니다.

* LND 7317

- http://www.lndinc.com/products/geiger-mueller-tubes/7317/

특장점으로는 엄청 예민하다는 것과, alpha / beta / gamma 모두를 잡아낼 수 있다는 것입니다.

일반적으로 한가지나 두가지만 잡아낼 수 있는 센서와는 격을 달리합니다.

그래서 낱개 구매는 130 ~ 200 USD 정도 한다고 합니다.

bGeigie Nano kit 가격의 1/3 에 해당합니다. 그만큼 조심해서 다뤄야 합니다.

GM tube 의 표면이 찟기지 않게 하기 위해 철망을 붙여줘야 합니다.

여성들의 메니큐어 코팅제로 붙이면 나중에 메니큐어 제거재로 쉽게 분리 가능하다 하니, 준비합니다.

살살 제품을 꺼냅니다. 아주 얇은 피막으로 되어 있다고 씌여 있습니다.

뒷면이 위로 오게 뒤집어져 있습니다. 앞쪽은 얇은 피막이니까요.

only USA 에서만 생산되고 있습니다.

들어보면 꽤 무겁습니다. 무식한 작은 후라이팬처럼 생겼습니다.

앞면입니다. 찟어지지 않도록 살살...

다른 작업으로 진행하기 전에 얼른 금속망을 앞면에 붙여줍니다.

1분 이상 지긋이 누르라고 설명서에 나와 있으니, 지긋하게 눌러서 고정되게 합니다.

13. GM tube 연결

GM tube 와 고전압 회로와 연결하는 보드를 조립합니다.

보드에 선을 납땜해야 하는데, 극성이 선의 배열과 다릅니다.

이쁘게 납땜할 수 있도록 핀을 이용하여 선을 동그랗게 말아줍니다.

미리 투명 수축 튜브도 끼워 넣어 줍니다.

납땜을 이쁘게 하고, 수축튜브를 잘 씌운 다음, 열을 가하여 수축, 고정되게 합니다.

14. Case 고무에 동그랗게 구멍 뚫기

Pelican 1010 case 의 안쪽 뒷면은 고무로 기기를 안정되게 고정될 수 있도록 쿠션이 있습니다.

여기를 GM tube 가 돌출될 수 있도록 구멍을 뚫어야 합니다.

보드에 LND 7317 과 연결하고 아크릴에 고정시켜 봅니다.

이제야 고지가 눈앞에 보이네요.

케이스 뒷면에 센서가 돌출될 수 있도록 동그랗게 구멍을 뚫어 줍니다.

신기하게도 250ml 주스캔 윗부분과 크기가 똑같습니다. 주스캔을 이용하여 그림을 그린 다음 커터로 잘라주면 됩니다.

짜잔~!

FIN

이로써 모든 조립 작업이 완료되었습니다.

계획하고 구입하고 조립하기 까지, 장장 6년(계획)하고 3개월(실조립) 이 걸렸습니다.

왜 구동 모습이 없냐구요?

실제 구동 모습은 따로 글을 만들어서 차근차근 기록하겠습니다.

여기까지만 해도 진이 다 빠졌습니다.

1. OLED display

지금가지 AliExpress 에서 쉽게 구할 수 있는 0.95 ~ 0.96 inch 짜리 OLED display 를 가지고 놀았습니다.

* SSD1306 128x64 0.96" monochrome OLED

- http://chocoball.tistory.com/entry/Hardware-SSD1306-128x64-monochrome-OLED

* SSD1331 96x64 0.95" full color OLED

- http://chocoball.tistory.com/entry/Hardware-SSD1331-96x64-full-color-OLED

추가로 지금 만들고 있는, "Safecast bGeigie Nano" 의 구성품을 보니, 마침 "Adafruit SSD1306 128x64 1.3inch" 가 달려있네요?!

* Hardware | Safecast bGeigie Nano 를 조립해 보자 - 1

- http://chocoball.tistory.com/entry/Hardware-Safecast-bGeigie-Nano-1

이왕 OLED 를 가지고 놀기 시작한거, 끝가지 해보자 하고 구동시켜 봅니다.

조립 전에 제품이 정상작동 하는지도 보고싶구요.

Adafruit 는 거의 레퍼런스급 제품이고, AliExpress 을 통한 짝퉁 중국산이 아닌 제품으로 구동시켜 보는 것은 거의 처음인것 같습니다.

2. 외형

1.3" 다 보니, 지금까지의 0.95" / 0.96" 보다 확실히 큰 것을 느낄 수 있습니다.

뒷면입니다.

프린팅 된것도 선명하고, I2C로 사용시에는 SJ1 / SJ2 를 쇼트시키라고 표현도 되어 있습니다.

"5V READY" 라고 하네요. 자체 레귤레이터가 달려 있습니다.

단, 저는 기기에 무리를 주기 싫기 때문에 무조건 "3.3V" 로 구동시켜 보겠습니다.

그간 테스트 했던 OLED 와의 비교샷 입니다.

화면도 클 뿐만 아니라, pin 갯수도 많습니다.

SPI 대응도 되고 I2C 대응도 모두 될 수 있게 만들어져 있기 때문인것 같아요.

3.Layout

Pin 배열은 아래 link 를 참고하였습니다. (Adafruit 제조사 사이트)

- https://learn.adafruit.com/monochrome-oled-breakouts/wiring-1-dot-3-128x64

   Adafruit  |   Arduino
   SSD1306   |   Nano
----------------------------
     Data    |     D9
     Clk     |     D10
     SA0(DC) |     D11
     Rst     |     D13
     CS      |     D12
     3v3     |
     Vin     |     3.3V
     GND     |     GND
----------------------------

실제 배선 모양입니다.

4.Sketch

소스는 Arduino IDE 에서,

아래처럼 "File > Examples > Adafruit SDD1306 > ssd1306_128x64_spi" 를 선택하면 됩니다.

원본 소스는 다음과 같습니다.

5. 구동

실제 구동한 동영상 입니다.

소스 코드와 제품 자체가 모두 Adafruit 가 만든 것이니 당연 잘 됩니다.

거기에 Arduino 진영과 Adafruit 가 협력하여 만든 Arduino Micro 까지 구비하여 구동해 봤습니다. (완전체)

당연 잘 돌아 갑니다.

이제 3형제 다 모여서 구동시켜 봅니다.

확실히 Adafruit 제품의 구동 속도가 제일 빠릅니다.

소스 및 pin 배열을 Hardware SPI 로 변경하고 동작시키면 더 빠르겠지요?

FIN

이제 OLED는 거의 다 사용해 본것 같네.

1. 상태 표시

Arduino 를 하다 보면, 표시창을 이용하여 상태를 알고 싶어 집니다.

PC로 말할것 같으면 모니터 같은 것이죠.

반짝반짝 빛나는 LED 도 좋지만, 쿨한 작은 모니터도 좋습니다.

AliExpress 에서 뒤져본 결과, 이런 적은 display 가 있네요!

2. 주문

AliExpress 는 무료 배송이 감사합니다.

- https://ko.aliexpress.com/item/1pcs-0-96-blue-0-96-inch-OLED-module-New-128X64-OLED-LCD-LED-Display-Module/32643950109.html

3. 도착

재미 있는 것은, 전원 pin 이름이 보통 "VCC" 인데, "VDD" 로 써져 있으며, "SCL" 을 "SCK" 로 써 있는 부분입니다.

아루래도 라이센스 부분을 피해가기 위해서 그런게 아닐까 합니다만, 사용하는데 지장은 없습니다.

드라이버 칩은 뒤에 가려져서 보이지 않는것 같습니다.

Full color OLED 와의 비교샷 입니다.

Full color OLED 의 자세한 이야기는 아래 link 를 참고해 주세요.

- http://chocoball.tistory.com/entry/Hardware-SSD1331-96x64-full-color-OLED

SSD1306 의 datasheet 입니다.

- SSD1306.pdf

세로는 확실히 monochrome 이 짧은게 보입니다만, 가로는 같아 보입니다.

확실히 full color OLED 의 보드가 복잡합니다.

4. Layout

빵판에서 Arduino 와 연결은 다음과 같이 하면 됩니다.

    SSD1306  | Arduino Nano
----------------------------
     GND     |     GND
     VDD     |     3.3V
     SCK     |     A5
     SDA     |     A4
----------------------------

아래는 실제 회로 구성입니다.

5. I2C vs. SPI

항상 궁금했던 것은 arduino 와의 interface 에서 I2C 와 SPI 의 차이가 궁금했습니다.

특히 OLED 디바이스는 이 두가지로 극명하게 갈립니다.

SPI 는 비싼 편이고, pin 수가 많습니다.

바로 느낌이 SPI 아 좋아 보이죠? 속도면에서는 그렇습니다.

다만, 동시에 연결은 I2C 가 좋다고 하네요.

아래 link 들에서 참고하였습니다.

- http://luma-oled.readthedocs.io/en/latest/hardware.html

- https://www.youtube.com/watch?v=vECfvdBLHI0

6. I2C detect

본 OLED device 가 어떤 I2C 어드레스를 갖는지 궁금할 땐, "i2cdetect" 라는 sketch 를 사용하여 확인 가능합니다.

#include "Wire.h"
#include "i2cdetect.h"

void setup() {
	Wire.begin();
	Serial.begin(9600);
	Serial.println("i2cdetect example\n");
	Serial.print("Scanning address range 0x03-0x77\n\n");
}

void loop() {
	i2cdetect(); // default range from 0x03 to 0x77
	delay(2000);
}

결과는 "0x3c" 가 나옵니다.

향후, sketch 의 소스를 보고 해당 값들이 잘 들어갔는지 확인할 수 있습니다.

7. Adafruit Sketch

OLED 의 동작을 확인할 수 있는 sample sketch 는 여러개가 있습니다.

유명한 것은 Adafruit 와 U8g 입니다.

우선 Adafruit 를 이용해 봅니다.

아래 link 에서 library 등을 다운로드 받아 arduino 폴더에 설치합니다.

- https://learn.adafruit.com/monochrome-oled-breakouts/arduino-library-and-examples

참고로 제품이 128x64 이므로, "ssd1306_128x64_i2c" 를 선택하면 동작하지 않습니다.

i2c 의 다른 셈플인 "ssd1306_128x32_i2c" 를 선택해야지만 정상으로 동작합니다.

제품 사이즈도 128x64 가 아니라 128x32 가 아닌가라는 생각도 해 봅니다.

Sketch source 는 다음과 같습니다.

아래는 동작 동영상 입니다.

화려한 내용을 보여줍니다. OLED 를 사용한다는 것이 실감납니다.

8. U8g Sketch

그 다음으로 유명한 U8g library 를 사용해 봅니다.

아래 link 를 참고하였습니다.

- https://github.com/olikraus/u8glib/

주의할 점은, 범용 library 로 작성되어 있어서,

테스트할 device 의 정확한 방식을 정해줘야 합니다.

아래 스샷처럼 정확하게 선택해 줍니다.

다른 I2C 도 있지만, Fast I2C 를 선택하면 가장 빠른 퍼포먼스를 보여줍니다.

Sketch source 는 다음과 같습니다.

/*

  GraphicsTest.pde
  
  >>> Before compiling: Please remove comment from the constructor of the 
  >>> connected graphics display (see below).
  
  Universal 8bit Graphics Library, https://github.com/olikraus/u8glib/
  
  Copyright (c) 2012, olikraus@gmail.com
  All rights reserved.

  Redistribution and use in source and binary forms, with or without modification, 
  are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this list 
    of conditions and the following disclaimer.
    
  * Redistributions in binary form must reproduce the above copyright notice, this 
    list of conditions and the following disclaimer in the documentation and/or other 
    materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
  CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  


*/


#include "U8glib.h"

// setup u8g object, please remove comment from one of the following constructor calls
// IMPORTANT NOTE: The following list is incomplete. The complete list of supported 
// devices with all constructor calls is here: https://github.com/olikraus/u8glib/wiki/device
//U8GLIB_NHD27OLED_BW u8g(13, 11, 10, 9);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_NHD27OLED_2X_BW u8g(13, 11, 10, 9);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_NHD27OLED_GR u8g(13, 11, 10, 9);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_NHD27OLED_2X_GR u8g(13, 11, 10, 9);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_NHD31OLED_BW u8g(13, 11, 10, 9);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_NHD31OLED_2X_BW u8g(13, 11, 10, 9);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_NHD31OLED_GR u8g(13, 11, 10, 9);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_NHD31OLED_2X_GR u8g(13, 11, 10, 9);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_DOGS102 u8g(13, 11, 10, 9, 8);		// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_DOGM132 u8g(13, 11, 10, 9);		// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_DOGM128 u8g(13, 11, 10, 9);		// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_DOGM128_2X u8g(13, 11, 10, 9);		// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_ST7920_128X64_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16);   // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16
//U8GLIB_ST7920_128X64_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16);   // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16
//U8GLIB_ST7920_128X64_1X u8g(18, 16, 17);	// SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17
//U8GLIB_ST7920_128X64_4X u8g(18, 16, 17);	// SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17
//U8GLIB_ST7920_192X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16);   // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16
//U8GLIB_ST7920_192X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16);   // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16
//U8GLIB_ST7920_192X32_1X u8g(18, 16, 17);	// SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17
//U8GLIB_ST7920_192X32_4X u8g(18, 16, 17);	// SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17
//U8GLIB_ST7920_192X32_1X u8g(13, 11, 10);	// SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10
//U8GLIB_ST7920_192X32_4X u8g(10);		// SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10, HW SPI
//U8GLIB_ST7920_202X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16);   // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16
//U8GLIB_ST7920_202X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16);   // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16
//U8GLIB_ST7920_202X32_1X u8g(18, 16, 17);	// SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17
//U8GLIB_ST7920_202X32_4X u8g(18, 16, 17);	// SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17
//U8GLIB_LM6059 u8g(13, 11, 10, 9);		// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_LM6063 u8g(13, 11, 10, 9);		// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_DOGXL160_BW u8g(10, 9);		// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_DOGXL160_GR u8g(13, 11, 10, 9);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_DOGXL160_2X_BW u8g(13, 11, 10, 9);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_DOGXL160_2X_GR u8g(13, 11, 10, 9);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_PCD8544 u8g(13, 11, 10, 9, 8);		// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8
//U8GLIB_PCF8812 u8g(13, 11, 10, 9, 8);		// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8
//U8GLIB_KS0108_128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); 		// 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs1=14, cs2=15,di=17,rw=16
//U8GLIB_LC7981_160X80 u8g(8, 9, 10, 11, 4, 5, 6, 7,  18, 14, 15, 17, 16); 	// 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16
//U8GLIB_LC7981_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7,  18, 14, 15, 17, 16); 	// 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16
//U8GLIB_LC7981_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7,  18, 14, 15, 17, 16); 	// 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16
//U8GLIB_ILI9325D_320x240 u8g(18,17,19,U8G_PIN_NONE,16 );  			// 8Bit Com: D0..D7: 0,1,2,3,4,5,6,7 en=wr=18, cs=17, rs=19, rd=U8G_PIN_NONE, reset = 16
//U8GLIB_SBN1661_122X32 u8g(8,9,10,11,4,5,6,7,14,15, 17, U8G_PIN_NONE, 16); 	// 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 cs1=14, cs2=15,di=17,rw=16,reset = 16
//U8GLIB_SSD1306_128X64 u8g(13, 11, 10, 9);	// SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_SSD1306_128X64 u8g(4, 5, 6, 7);	// SW SPI Com: SCK = 4, MOSI = 5, CS = 6, A0 = 7 (new white HalTec OLED)
//U8GLIB_SSD1306_128X64 u8g(10, 9);		// HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are  SCK = 13 and MOSI = 11)
//U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE|U8G_I2C_OPT_DEV_0);	// I2C / TWI 
U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_DEV_0|U8G_I2C_OPT_NO_ACK|U8G_I2C_OPT_FAST);	// Fast I2C / TWI 
//U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NO_ACK);	// Display which does not send AC
//U8GLIB_SSD1306_ADAFRUIT_128X64 u8g(13, 11, 10, 9);	// SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_SSD1306_ADAFRUIT_128X64 u8g(10, 9);		// HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are  SCK = 13 and MOSI = 11)
//U8GLIB_SSD1306_128X32 u8g(13, 11, 10, 9);	// SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_SSD1306_128X32 u8g(10, 9);             // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are  SCK = 13 and MOSI = 11)
//U8GLIB_SSD1306_128X32 u8g(U8G_I2C_OPT_NONE);	// I2C / TWI 
//U8GLIB_SSD1306_64X48 u8g(13, 11, 10, 9);	// SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_SSD1306_64X48 u8g(10, 9);             // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are  SCK = 13 and MOSI = 11)
//U8GLIB_SSD1306_64X48 u8g(U8G_I2C_OPT_NONE);	// I2C / TWI 
//U8GLIB_SH1106_128X64 u8g(13, 11, 10, 9);	// SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_SH1106_128X64 u8g(4, 5, 6, 7);	// SW SPI Com: SCK = 4, MOSI = 5, CS = 6, A0 = 7 (new blue HalTec OLED)
//U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_NONE);	// I2C / TWI 
//U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_DEV_0|U8G_I2C_OPT_FAST);	// Dev 0, Fast I2C / TWI
//U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_NO_ACK);	// Display which does not send ACK
//U8GLIB_SSD1309_128X64 u8g(13, 11, 10, 9);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_SSD1327_96X96_GR u8g(U8G_I2C_OPT_NONE);	// I2C
//U8GLIB_SSD1327_96X96_2X_GR u8g(U8G_I2C_OPT_NONE);	// I2C
//U8GLIB_UC1611_DOGM240 u8g(U8G_I2C_OPT_NONE);	// I2C
//U8GLIB_UC1611_DOGM240 u8g(13, 11, 10, 9);	// SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_UC1611_DOGM240 u8g(10, 9);		// HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are  SCK = 13 and MOSI = 11)
//U8GLIB_UC1611_DOGM240 u8g(10, 9);		// HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are  SCK = 13 and MOSI = 11)
//U8GLIB_UC1611_DOGM240 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 3, 17, 16);   // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=3, di/a0=17,rw=16
//U8GLIB_UC1611_DOGXL240 u8g(U8G_I2C_OPT_NONE);	// I2C
//U8GLIB_UC1611_DOGXL240 u8g(13, 11, 10, 9);	// SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_UC1611_DOGXL240 u8g(10, 9);		// HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are  SCK = 13 and MOSI = 11)
//U8GLIB_UC1611_DOGXL240 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 3, 17, 16);   // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=3, di/a0=17,rw=16
//U8GLIB_NHD_C12864 u8g(13, 11, 10, 9, 8);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8
//U8GLIB_NHD_C12832 u8g(13, 11, 10, 9, 8);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8
//U8GLIB_LD7032_60x32 u8g(13, 11, 10, 9, 8);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8
//U8GLIB_LD7032_60x32 u8g(11, 12, 9, 10, 8);	// SPI Com: SCK = 11, MOSI = 12, CS = 9, A0 = 10, RST = 8  (SW SPI Nano Board)
//U8GLIB_UC1608_240X64 u8g(13, 11, 10, 9, 8);	// SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8
//U8GLIB_UC1608_240X64_2X u8g(13, 11, 10, 9, 8);	// SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8
//U8GLIB_UC1608_240X64 u8g(10, 9, 8);	// HW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8
//U8GLIB_UC1608_240X64_2X u8g(10, 9, 8);	// HW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8
//U8GLIB_UC1608_240X u8g(13, 11, 10, 9, 8);	// SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8
//U8GLIB_UC1608_240X64_2X u8g(13, 11, 10, 9, 8);	// SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8
//U8GLIB_UC1608_240X64 u8g(10, 9, 8);	// HW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8
//U8GLIB_UC1608_240X64_2X u8g(10, 9, 8);	// HW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8
//U8GLIB_T6963_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16
//U8GLIB_T6963_128X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16
//U8GLIB_T6963_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16
//U8GLIB_T6963_128X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16
//U8GLIB_HT1632_24X16 u8g(3, 2, 4);		// WR = 3, DATA = 2, CS = 4
//U8GLIB_SSD1351_128X128_332 u8g(13, 11, 8, 9, 7); // Arduino UNO: SW SPI Com: SCK = 13, MOSI = 11, CS = 8, A0 = 9, RESET = 7 (http://electronics.ilsoft.co.uk/ArduinoShield.aspx)
//U8GLIB_SSD1351_128X128_332 u8g(76, 75, 8, 9, 7); // Arduino DUE: SW SPI Com: SCK = 13, MOSI = 11, CS = 8, A0 = 9, RESET = 7 (http://electronics.ilsoft.co.uk/ArduinoShield.aspx)
//U8GLIB_SSD1351_128X128_332 u8g(8, 9, 7); // Arduino: HW SPI Com: SCK = 13, MOSI = 11, CS = 8, A0 = 9, RESET = 7 (http://electronics.ilsoft.co.uk/ArduinoShield.aspx)
//U8GLIB_SSD1351_128X128_HICOLOR u8g(76, 75, 8, 9, 7); // Arduino DUE, SW SPI Com: SCK = 76, MOSI = 75, CS = 8, A0 = 9, RESET = 7 (http://electronics.ilsoft.co.uk/ArduinoShield.aspx)
//U8GLIB_SSD1351_128X128_HICOLOR u8g(8, 9, 7); // Arduino, HW SPI Com: SCK = 76, MOSI = 75, CS = 8, A0 = 9, RESET = 7 (http://electronics.ilsoft.co.uk/ArduinoShield.aspx)
//U8GLIB_SSD1351_128X128GH_332 u8g(8, 9, 7); // Arduino, HW SPI Com: SCK = 76, MOSI = 75, CS = 8, A0 = 9, RESET = 7 (Freetronics OLED)
//U8GLIB_SSD1351_128X128GH_HICOLOR u8g(8, 9, 7); // Arduino, HW SPI Com: SCK = 76, MOSI = 75, CS = 8, A0 = 9, RESET = 7 (Freetronics OLED)

void u8g_prepare(void) {
  u8g.setFont(u8g_font_6x10);
  u8g.setFontRefHeightExtendedText();
  u8g.setDefaultForegroundColor();
  u8g.setFontPosTop();
}

void u8g_box_frame(uint8_t a) {
  u8g.drawStr( 0, 0, "drawBox");
  u8g.drawBox(5,10,20,10);
  u8g.drawBox(10+a,15,30,7);
  u8g.drawStr( 0, 30, "drawFrame");
  u8g.drawFrame(5,10+30,20,10);
  u8g.drawFrame(10+a,15+30,30,7);
}

void u8g_disc_circle(uint8_t a) {
  u8g.drawStr( 0, 0, "drawDisc");
  u8g.drawDisc(10,18,9);
  u8g.drawDisc(24+a,16,7);
  u8g.drawStr( 0, 30, "drawCircle");
  u8g.drawCircle(10,18+30,9);
  u8g.drawCircle(24+a,16+30,7);
}

void u8g_r_frame(uint8_t a) {
  u8g.drawStr( 0, 0, "drawRFrame/Box");
  u8g.drawRFrame(5, 10,40,30, a+1);
  u8g.drawRBox(50, 10,25,40, a+1);
}

void u8g_string(uint8_t a) {
  u8g.drawStr(30+a,31, " 0");
  u8g.drawStr90(30,31+a, " 90");
  u8g.drawStr180(30-a,31, " 180");
  u8g.drawStr270(30,31-a, " 270");
}

void u8g_line(uint8_t a) {
  u8g.drawStr( 0, 0, "drawLine");
  u8g.drawLine(7+a, 10, 40, 55);
  u8g.drawLine(7+a*2, 10, 60, 55);
  u8g.drawLine(7+a*3, 10, 80, 55);
  u8g.drawLine(7+a*4, 10, 100, 55);
}

void u8g_triangle(uint8_t a) {
  uint16_t offset = a;
  u8g.drawStr( 0, 0, "drawTriangle");
  u8g.drawTriangle(14,7, 45,30, 10,40);
  u8g.drawTriangle(14+offset,7-offset, 45+offset,30-offset, 57+offset,10-offset);
  u8g.drawTriangle(57+offset*2,10, 45+offset*2,30, 86+offset*2,53);
  u8g.drawTriangle(10+offset,40+offset, 45+offset,30+offset, 86+offset,53+offset);
}

void u8g_ascii_1() {
  char s[2] = " ";
  uint8_t x, y;
  u8g.drawStr( 0, 0, "ASCII page 1");
  for( y = 0; y < 6; y++ ) {
    for( x = 0; x < 16; x++ ) {
      s[0] = y*16 + x + 32;
      u8g.drawStr(x*7, y*10+10, s);
    }
  }
}

void u8g_ascii_2() {
  char s[2] = " ";
  uint8_t x, y;
  u8g.drawStr( 0, 0, "ASCII page 2");
  for( y = 0; y < 6; y++ ) {
    for( x = 0; x < 16; x++ ) {
      s[0] = y*16 + x + 160;
      u8g.drawStr(x*7, y*10+10, s);
    }
  }
}

void u8g_extra_page(uint8_t a)
{
  if ( u8g.getMode() == U8G_MODE_HICOLOR || u8g.getMode() == U8G_MODE_R3G3B2) {
    /* draw background (area is 128x128) */
    u8g_uint_t r, g, b;
    b = a << 5;
    for( g = 0; g < 64; g++ )
    {
      for( r = 0; r < 64; r++ )
      {
	u8g.setRGB(r<<2, g<<2, b );
	u8g.drawPixel(g, r);
      }
    }
    u8g.setRGB(255,255,255);
    u8g.drawStr( 66, 0, "Color Page");
  }
  else if ( u8g.getMode() == U8G_MODE_GRAY2BIT )
  {
    u8g.drawStr( 66, 0, "Gray Level");
    u8g.setColorIndex(1);
    u8g.drawBox(0, 4, 64, 32);    
    u8g.drawBox(70, 20, 4, 12);
    u8g.setColorIndex(2);
    u8g.drawBox(0+1*a, 4+1*a, 64-2*a, 32-2*a);
    u8g.drawBox(74, 20, 4, 12);
    u8g.setColorIndex(3);
    u8g.drawBox(0+2*a, 4+2*a, 64-4*a, 32-4*a);
    u8g.drawBox(78, 20, 4, 12);
  }
  else
  {
    u8g.drawStr( 0, 12, "setScale2x2");
    u8g.setScale2x2();
    u8g.drawStr( 0, 6+a, "setScale2x2");
    u8g.undoScale();
  }
}


uint8_t draw_state = 0;

void draw(void) {
  u8g_prepare();
  switch(draw_state >> 3) {
    case 0: u8g_box_frame(draw_state&7); break;
    case 1: u8g_disc_circle(draw_state&7); break;
    case 2: u8g_r_frame(draw_state&7); break;
    case 3: u8g_string(draw_state&7); break;
    case 4: u8g_line(draw_state&7); break;
    case 5: u8g_triangle(draw_state&7); break;
    case 6: u8g_ascii_1(); break;
    case 7: u8g_ascii_2(); break;
    case 8: u8g_extra_page(draw_state&7); break;
  }
}

void setup(void) {

  // flip screen, if required
  //u8g.setRot180();

#if defined(ARDUINO)
  pinMode(13, OUTPUT);           
  digitalWrite(13, HIGH);  
#endif
}

void loop(void) {
  
  // picture loop  
  u8g.firstPage();  
  do {
    draw();
  } while( u8g.nextPage() );
  
  // increase the state
  draw_state++;
  if ( draw_state >= 9*8 )
    draw_state = 0;
  
  // rebuild the picture after some delay
  //delay(150);

}

가장 빠르지만, 아래처럼 arduino 의 빨간 led 가 미친듯이 점멸합니다.

아마 process 를 많이 사용하는 듯 합니다.

U8g library 에 "Rotation" 셈플도 있어서 확인해 봤습니다.

글씨도 세로로 바로 회전할 수 있는게 신기합니다.

Sketch 는 다음과 같습니다.

/*

  Rotation.pde
  
  Example code for RotXXX functions.
  
  >>> Before compiling: Please remove comment from the constructor of the 
  >>> connected graphics display (see below).
  
  Universal 8bit Graphics Library, https://github.com/olikraus/u8glib/
  
  Copyright (c) 2012, olikraus@gmail.com
  All rights reserved.

  Redistribution and use in source and binary forms, with or without modification, 
  are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this list 
    of conditions and the following disclaimer.
    
  * Redistributions in binary form must reproduce the above copyright notice, this 
    list of conditions and the following disclaimer in the documentation and/or other 
    materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
  CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  
  
*/


#include "U8glib.h"

// setup u8g object, please remove comment from one of the following constructor calls
// IMPORTANT NOTE: The following list is incomplete. The complete list of supported 
// devices with all constructor calls is here: https://github.com/olikraus/u8glib/wiki/device
//U8GLIB_NHD27OLED_BW u8g(13, 11, 10, 9);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_NHD27OLED_2X_BW u8g(13, 11, 10, 9);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_NHD27OLED_GR u8g(13, 11, 10, 9);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_NHD27OLED_2X_GR u8g(13, 11, 10, 9);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_NHD31OLED_BW u8g(13, 11, 10, 9);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_NHD31OLED_2X_BW u8g(13, 11, 10, 9);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_NHD31OLED_GR u8g(13, 11, 10, 9);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_NHD31OLED_2X_GR u8g(13, 11, 10, 9);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_DOGS102 u8g(13, 11, 10, 9, 8);		// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_DOGM132 u8g(13, 11, 10, 9);		// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_DOGM128 u8g(13, 11, 10, 9);		// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_DOGM128_2X u8g(13, 11, 10, 9);		// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_ST7920_128X64_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16);   // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16
//U8GLIB_ST7920_128X64_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16);   // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16
//U8GLIB_ST7920_128X64_1X u8g(18, 16, 17);	// SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17
//U8GLIB_ST7920_128X64_4X u8g(18, 16, 17);	// SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17
//U8GLIB_ST7920_192X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16);   // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16
//U8GLIB_ST7920_192X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16);   // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16
//U8GLIB_ST7920_192X32_1X u8g(18, 16, 17);	// SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17
//U8GLIB_ST7920_192X32_4X u8g(18, 16, 17);	// SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17
//U8GLIB_ST7920_192X32_1X u8g(13, 11, 10);	// SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10
//U8GLIB_ST7920_192X32_4X u8g(10);		// SPI Com: SCK = en = 13, MOSI = rw = 11, CS = di = 10, HW SPI
//U8GLIB_ST7920_202X32_1X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16);   // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16
//U8GLIB_ST7920_202X32_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 17, 16);   // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16
//U8GLIB_ST7920_202X32_1X u8g(18, 16, 17);	// SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17
//U8GLIB_ST7920_202X32_4X u8g(18, 16, 17);	// SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17
//U8GLIB_LM6059 u8g(13, 11, 10, 9);		// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_LM6063 u8g(13, 11, 10, 9);		// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_DOGXL160_BW u8g(10, 9);		// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_DOGXL160_GR u8g(13, 11, 10, 9);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_DOGXL160_2X_BW u8g(13, 11, 10, 9);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_DOGXL160_2X_GR u8g(13, 11, 10, 9);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_PCD8544 u8g(13, 11, 10, 9, 8);		// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8
//U8GLIB_PCF8812 u8g(13, 11, 10, 9, 8);		// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, Reset = 8
//U8GLIB_KS0108_128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 14, 15, 17, 16); 		// 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs1=14, cs2=15,di=17,rw=16
//U8GLIB_LC7981_160X80 u8g(8, 9, 10, 11, 4, 5, 6, 7,  18, 14, 15, 17, 16); 	// 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16
//U8GLIB_LC7981_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7,  18, 14, 15, 17, 16); 	// 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16
//U8GLIB_LC7981_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7,  18, 14, 15, 17, 16); 	// 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=14 ,di=15,rw=17, reset = 16
//U8GLIB_ILI9325D_320x240 u8g(18,17,19,U8G_PIN_NONE,16 );  			// 8Bit Com: D0..D7: 0,1,2,3,4,5,6,7 en=wr=18, cs=17, rs=19, rd=U8G_PIN_NONE, reset = 16
//U8GLIB_SBN1661_122X32 u8g(8,9,10,11,4,5,6,7,14,15, 17, U8G_PIN_NONE, 16); 	// 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 cs1=14, cs2=15,di=17,rw=16,reset = 16
//U8GLIB_SSD1306_128X64 u8g(13, 11, 10, 9);	// SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_SSD1306_128X64 u8g(4, 5, 6, 7);	// SW SPI Com: SCK = 4, MOSI = 5, CS = 6, A0 = 7 (new white HalTec OLED)
//U8GLIB_SSD1306_128X64 u8g(10, 9);		// HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are  SCK = 13 and MOSI = 11)
//U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NONE|U8G_I2C_OPT_DEV_0);	// I2C / TWI 
U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_DEV_0|U8G_I2C_OPT_NO_ACK|U8G_I2C_OPT_FAST);	// Fast I2C / TWI 
//U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NO_ACK);	// Display which does not send AC
//U8GLIB_SSD1306_ADAFRUIT_128X64 u8g(13, 11, 10, 9);	// SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_SSD1306_ADAFRUIT_128X64 u8g(10, 9);		// HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are  SCK = 13 and MOSI = 11)
//U8GLIB_SSD1306_128X32 u8g(13, 11, 10, 9);	// SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_SSD1306_128X32 u8g(10, 9);             // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are  SCK = 13 and MOSI = 11)
//U8GLIB_SSD1306_128X32 u8g(U8G_I2C_OPT_NONE);	// I2C / TWI 
//U8GLIB_SSD1306_64X48 u8g(13, 11, 10, 9);	// SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_SSD1306_64X48 u8g(10, 9);             // HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are  SCK = 13 and MOSI = 11)
//U8GLIB_SSD1306_64X48 u8g(U8G_I2C_OPT_NONE);	// I2C / TWI 
//U8GLIB_SH1106_128X64 u8g(13, 11, 10, 9);	// SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_SH1106_128X64 u8g(4, 5, 6, 7);	// SW SPI Com: SCK = 4, MOSI = 5, CS = 6, A0 = 7 (new blue HalTec OLED)
//U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_NONE);	// I2C / TWI 
//U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_DEV_0|U8G_I2C_OPT_FAST);	// Dev 0, Fast I2C / TWI
//U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_NO_ACK);	// Display which does not send ACK
//U8GLIB_SSD1309_128X64 u8g(13, 11, 10, 9);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_SSD1327_96X96_GR u8g(U8G_I2C_OPT_NONE);	// I2C
//U8GLIB_SSD1327_96X96_2X_GR u8g(U8G_I2C_OPT_NONE);	// I2C
//U8GLIB_UC1611_DOGM240 u8g(U8G_I2C_OPT_NONE);	// I2C
//U8GLIB_UC1611_DOGM240 u8g(13, 11, 10, 9);	// SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_UC1611_DOGM240 u8g(10, 9);		// HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are  SCK = 13 and MOSI = 11)
//U8GLIB_UC1611_DOGM240 u8g(10, 9);		// HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are  SCK = 13 and MOSI = 11)
//U8GLIB_UC1611_DOGM240 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 3, 17, 16);   // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=3, di/a0=17,rw=16
//U8GLIB_UC1611_DOGXL240 u8g(U8G_I2C_OPT_NONE);	// I2C
//U8GLIB_UC1611_DOGXL240 u8g(13, 11, 10, 9);	// SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9
//U8GLIB_UC1611_DOGXL240 u8g(10, 9);		// HW SPI Com: CS = 10, A0 = 9 (Hardware Pins are  SCK = 13 and MOSI = 11)
//U8GLIB_UC1611_DOGXL240 u8g(8, 9, 10, 11, 4, 5, 6, 7, 18, 3, 17, 16);   // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, cs=3, di/a0=17,rw=16
//U8GLIB_NHD_C12864 u8g(13, 11, 10, 9, 8);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8
//U8GLIB_NHD_C12832 u8g(13, 11, 10, 9, 8);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8
//U8GLIB_LD7032_60x32 u8g(13, 11, 10, 9, 8);	// SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8
//U8GLIB_LD7032_60x32 u8g(11, 12, 9, 10, 8);	// SPI Com: SCK = 11, MOSI = 12, CS = 9, A0 = 10, RST = 8  (SW SPI Nano Board)
//U8GLIB_UC1608_240X64 u8g(13, 11, 10, 9, 8);	// SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8
//U8GLIB_UC1608_240X64_2X u8g(13, 11, 10, 9, 8);	// SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8
//U8GLIB_UC1608_240X64 u8g(10, 9, 8);	// HW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8
//U8GLIB_UC1608_240X64_2X u8g(10, 9, 8);	// HW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8
//U8GLIB_UC1608_240X u8g(13, 11, 10, 9, 8);	// SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8
//U8GLIB_UC1608_240X64_2X u8g(13, 11, 10, 9, 8);	// SW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8
//U8GLIB_UC1608_240X64 u8g(10, 9, 8);	// HW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8
//U8GLIB_UC1608_240X64_2X u8g(10, 9, 8);	// HW SPI Com: SCK = 13, MOSI = 11, CS = 10, A0 = 9, RST = 8
//U8GLIB_T6963_240X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16
//U8GLIB_T6963_128X128 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16
//U8GLIB_T6963_240X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16
//U8GLIB_T6963_128X64 u8g(8, 9, 10, 11, 4, 5, 6, 7, 14, 15, 17, 18, 16); // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7, cs=14, a0=15, wr=17, rd=18, reset=16
//U8GLIB_HT1632_24X16 u8g(3, 2, 4);		// WR = 3, DATA = 2, CS = 4
//U8GLIB_SSD1351_128X128_332 u8g(13, 11, 8, 9, 7); // Arduino UNO: SW SPI Com: SCK = 13, MOSI = 11, CS = 8, A0 = 9, RESET = 7 (http://electronics.ilsoft.co.uk/ArduinoShield.aspx)
//U8GLIB_SSD1351_128X128_332 u8g(76, 75, 8, 9, 7); // Arduino DUE: SW SPI Com: SCK = 13, MOSI = 11, CS = 8, A0 = 9, RESET = 7 (http://electronics.ilsoft.co.uk/ArduinoShield.aspx)
//U8GLIB_SSD1351_128X128_332 u8g(8, 9, 7); // Arduino: HW SPI Com: SCK = 13, MOSI = 11, CS = 8, A0 = 9, RESET = 7 (http://electronics.ilsoft.co.uk/ArduinoShield.aspx)
//U8GLIB_SSD1351_128X128_HICOLOR u8g(76, 75, 8, 9, 7); // Arduino DUE, SW SPI Com: SCK = 76, MOSI = 75, CS = 8, A0 = 9, RESET = 7 (http://electronics.ilsoft.co.uk/ArduinoShield.aspx)
//U8GLIB_SSD1351_128X128_HICOLOR u8g(8, 9, 7); // Arduino, HW SPI Com: SCK = 76, MOSI = 75, CS = 8, A0 = 9, RESET = 7 (http://electronics.ilsoft.co.uk/ArduinoShield.aspx)
//U8GLIB_SSD1351_128X128GH_332 u8g(8, 9, 7); // Arduino, HW SPI Com: SCK = 76, MOSI = 75, CS = 8, A0 = 9, RESET = 7 (Freetronics OLED)
//U8GLIB_SSD1351_128X128GH_HICOLOR u8g(8, 9, 7); // Arduino, HW SPI Com: SCK = 76, MOSI = 75, CS = 8, A0 = 9, RESET = 7 (Freetronics OLED)

uint8_t offset = 0;

void draw(void) {
  // graphic commands to redraw the complete screen should be placed here  
  u8g.setFont(u8g_font_unifont);
  u8g.drawStr( 0+0, 20+0, "Hello!");
  u8g.drawStr( 0+2, 20+16, "Hello!");
  
  u8g.drawBox(0, 0, 3, 3);
  u8g.drawBox(u8g.getWidth()-6, 0, 6, 6);
  u8g.drawBox(u8g.getWidth()-9, u8g.getHeight()-9, 9, 9);
  u8g.drawBox(0, u8g.getHeight()-12, 12, 12);  
}

void setup(void) {
}


void rotate(void) {
  static  uint8_t dir = 0;
  static  unsigned long next_rotation = 0;
  
  if ( next_rotation < millis() )
  {
    switch(dir) {
      case 0: u8g.undoRotation(); break;
      case 1: u8g.setRot90(); break;
      case 2: u8g.setRot180(); break;
      case 3: u8g.setRot270(); offset = ( offset + 1 ) & 0x0f; break;
    }
    
    dir++;
    dir &= 3;
    next_rotation = millis();
    next_rotation += 1000;
  }
}

void loop(void) {
  // screen rotation 
  rotate();
  
  // picture loop
  u8g.firstPage();  
  do {
    draw();
  } while( u8g.nextPage() );
  
  // rebuild the picture after some delay
  delay(100);
}

동작 동영상은 다음과 같습니다.

9. U8g2 Sketch

U8g 를 작성하신 분이, 더이상 U8g를 업그래이드 하지 않고 U8g2 를 개발하셨습니다.

- https://github.com/olikraus/u8g2/

여기서도 마찬가지로,

보유하고 있는 device 를 로딩할 수 있도록 찾고 comment out 해줍니다.

Sketch 는 다음과 같습니다.

/*

  GraphicsTest.ino

  Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)

  Copyright (c) 2016, olikraus@gmail.com
  All rights reserved.

  Redistribution and use in source and binary forms, with or without modification, 
  are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this list 
    of conditions and the following disclaimer.
    
  * Redistributions in binary form must reproduce the above copyright notice, this 
    list of conditions and the following disclaimer in the documentation and/or other 
    materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
  CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  

*/

#include "Arduino.h"
#include "U8g2lib.h"

#ifdef U8X8_HAVE_HW_SPI
#include "SPI.h"
#endif
#ifdef U8X8_HAVE_HW_I2C
#include "Wire.h"
#endif


/*
  U8glib Example Overview:
    Frame Buffer Examples: clearBuffer/sendBuffer. Fast, but may not work with all Arduino boards because of RAM consumption
    Page Buffer Examples: firstPage/nextPage. Less RAM usage, should work with all Arduino boards.
    U8x8 Text Only Example: No RAM usage, direct communication with display controller. No graphics, 8x8 Text only.
    
*/

// Please UNCOMMENT one of the contructor lines below
// U8g2 Contructor List (Frame Buffer)
// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
//U8G2_SSD1306_128X64_NONAME_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6);	// Arduboy (Production, Kickstarter Edition)
//U8G2_SSD1306_128X64_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // All Boards without Reset of the Display
//U8G2_SSD1306_128X64_NONAME_F_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_F_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_VCOMH0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SH1106_128X64_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1106_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1106_128X64_VCOMH0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SSD1306_128X32_UNIVISION_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather M0 Basic Proto + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);  // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_64X48_ER_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.66" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
//U8G2_SSD1306_64X32_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
//U8G2_SSD1306_96X16_ER_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.69" OLED
//U8G2_SSD1322_NHD_256X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_256X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1325_NHD_128X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_SSD1325_NHD_128X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	
//U8G2_SSD1327_SEEED_96X96_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_SEEED_96X96_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1329_128X96_NONAME_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME0_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME0_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_LD7032_60X32_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 9, /* dc=*/ 10, /* reset=*/ 8);	// SW SPI Nano Board
//U8G2_LD7032_60X32_F_4W_SW_I2C u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* reset=*/ U8X8_PIN_NONE);	// NOT TESTED!
//U8G2_UC1701_EA_DOGS102_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1701_EA_DOGS102_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_PCD8544_84X48_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Nokia 5110 Display
//U8G2_PCD8544_84X48_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 		// Nokia 5110 Display
//U8G2_PCF8812_96X65_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Could be also PCF8814
//U8G2_PCF8812_96X65_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Could be also PCF8814
//U8G2_KS0108_128X64_F u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ U8X8_PIN_NONE, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_KS0108_ERM19264_F u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ 16, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_ST7920_192X32_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_192X32_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18 /* A4 */, /*cs=*/ U8X8_PIN_NONE, /*dc/rs=*/ 17 /* A3 */, /*reset=*/ 15 /* A1 */);	// Remember to set R/W to 0 
//U8G2_ST7920_128X64_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_F_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_F_HW_SPI u8g2(U8G2_R0, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM132_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_EA_DOGM132_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_ZOLEN_128X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ZOLEN_128X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LM6059_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Adafruit ST7565 GLCD
//U8G2_ST7565_LM6059_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Adafruit ST7565 GLCD
//U8G2_ST7565_ERC12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_PI_132X64_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_PI_132X64_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_NT7534_TG12864R_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_NT7534_TG12864R_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7588_JLX12864_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 5);  
//U8G2_ST7588_JLX12864_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ 5);
//U8G2_IST3020_ERC19264_F_6800 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 28, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect WR pin with GND
//U8G2_IST3020_ERC19264_F_8080 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 29, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect RD pin with 3.3V
//U8G2_IST3020_ERC19264_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_LC7981_160X80_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_160X160_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X128_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_SED1520_122X32_F u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*dc=*/ A0, /*e1=*/ A3, /*e2=*/ A2, /* reset=*/  A4); 	// Set R/W to low!
//U8G2_T6963_240X128_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_256X64_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_SED1330_240X128_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FG with GND
//U8G2_SED1330_240X128_F_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // A0 is dc pin!
//U8G2_RA8835_NHD_240X128_F_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_RA8835_NHD_240X128_F_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_UC1604_JLX19264_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1604_JLX19264_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_UC1608_ERC24064_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_ERC240120_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1608_240X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1610_EA_DOGXL160_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1610_EA_DOGXL160_F_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1611_EA_DOGM240_F_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGM240 Test Board
//U8G2_UC1611_EA_DOGM240_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // Due, SW SPI, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_F_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // Due, SW SPI, DOGXL240 Test Board
//U8G2_SSD1606_172X72_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// eInk/ePaper Display
//U8G2_SSD1607_200X200_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// eInk/ePaper Display
//U8G2_IL3820_296X128_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// WaveShare 2.9 inch eInk/ePaper Display, enable 16 bit mode for this display!

// End of constructor list


void u8g2_prepare(void) {
  u8g2.setFont(u8g2_font_6x10_tf);
  u8g2.setFontRefHeightExtendedText();
  u8g2.setDrawColor(1);
  u8g2.setFontPosTop();
  u8g2.setFontDirection(0);
}

void u8g2_box_frame(uint8_t a) {
  u8g2.drawStr( 0, 0, "drawBox");
  u8g2.drawBox(5,10,20,10);
  u8g2.drawBox(10+a,15,30,7);
  u8g2.drawStr( 0, 30, "drawFrame");
  u8g2.drawFrame(5,10+30,20,10);
  u8g2.drawFrame(10+a,15+30,30,7);
}

void u8g2_disc_circle(uint8_t a) {
  u8g2.drawStr( 0, 0, "drawDisc");
  u8g2.drawDisc(10,18,9);
  u8g2.drawDisc(24+a,16,7);
  u8g2.drawStr( 0, 30, "drawCircle");
  u8g2.drawCircle(10,18+30,9);
  u8g2.drawCircle(24+a,16+30,7);
}

void u8g2_r_frame(uint8_t a) {
  u8g2.drawStr( 0, 0, "drawRFrame/Box");
  u8g2.drawRFrame(5, 10,40,30, a+1);
  u8g2.drawRBox(50, 10,25,40, a+1);
}

void u8g2_string(uint8_t a) {
  u8g2.setFontDirection(0);
  u8g2.drawStr(30+a,31, " 0");
  u8g2.setFontDirection(1);
  u8g2.drawStr(30,31+a, " 90");
  u8g2.setFontDirection(2);
  u8g2.drawStr(30-a,31, " 180");
  u8g2.setFontDirection(3);
  u8g2.drawStr(30,31-a, " 270");
}

void u8g2_line(uint8_t a) {
  u8g2.drawStr( 0, 0, "drawLine");
  u8g2.drawLine(7+a, 10, 40, 55);
  u8g2.drawLine(7+a*2, 10, 60, 55);
  u8g2.drawLine(7+a*3, 10, 80, 55);
  u8g2.drawLine(7+a*4, 10, 100, 55);
}

void u8g2_triangle(uint8_t a) {
  uint16_t offset = a;
  u8g2.drawStr( 0, 0, "drawTriangle");
  u8g2.drawTriangle(14,7, 45,30, 10,40);
  u8g2.drawTriangle(14+offset,7-offset, 45+offset,30-offset, 57+offset,10-offset);
  u8g2.drawTriangle(57+offset*2,10, 45+offset*2,30, 86+offset*2,53);
  u8g2.drawTriangle(10+offset,40+offset, 45+offset,30+offset, 86+offset,53+offset);
}

void u8g2_ascii_1() {
  char s[2] = " ";
  uint8_t x, y;
  u8g2.drawStr( 0, 0, "ASCII page 1");
  for( y = 0; y < 6; y++ ) {
    for( x = 0; x < 16; x++ ) {
      s[0] = y*16 + x + 32;
      u8g2.drawStr(x*7, y*10+10, s);
    }
  }
}

void u8g2_ascii_2() {
  char s[2] = " ";
  uint8_t x, y;
  u8g2.drawStr( 0, 0, "ASCII page 2");
  for( y = 0; y < 6; y++ ) {
    for( x = 0; x < 16; x++ ) {
      s[0] = y*16 + x + 160;
      u8g2.drawStr(x*7, y*10+10, s);
    }
  }
}

void u8g2_extra_page(uint8_t a)
{
  u8g2.drawStr( 0, 0, "Unicode");
  u8g2.setFont(u8g2_font_unifont_t_symbols);
  u8g2.setFontPosTop();
  u8g2.drawUTF8(0, 24, "☀ ☁");
  switch(a) {
    case 0:
    case 1:
    case 2:
    case 3:
      u8g2.drawUTF8(a*3, 36, "☂");
      break;
    case 4:
    case 5:
    case 6:
    case 7:
      u8g2.drawUTF8(a*3, 36, "☔");
      break;
  }
}

#define cross_width 24
#define cross_height 24
static const unsigned char cross_bits[] U8X8_PROGMEM  = {
  0x00, 0x18, 0x00, 0x00, 0x24, 0x00, 0x00, 0x24, 0x00, 0x00, 0x42, 0x00, 
  0x00, 0x42, 0x00, 0x00, 0x42, 0x00, 0x00, 0x81, 0x00, 0x00, 0x81, 0x00, 
  0xC0, 0x00, 0x03, 0x38, 0x3C, 0x1C, 0x06, 0x42, 0x60, 0x01, 0x42, 0x80, 
  0x01, 0x42, 0x80, 0x06, 0x42, 0x60, 0x38, 0x3C, 0x1C, 0xC0, 0x00, 0x03, 
  0x00, 0x81, 0x00, 0x00, 0x81, 0x00, 0x00, 0x42, 0x00, 0x00, 0x42, 0x00, 
  0x00, 0x42, 0x00, 0x00, 0x24, 0x00, 0x00, 0x24, 0x00, 0x00, 0x18, 0x00, };

#define cross_fill_width 24
#define cross_fill_height 24
static const unsigned char cross_fill_bits[] U8X8_PROGMEM  = {
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x18, 0x64, 0x00, 0x26, 
  0x84, 0x00, 0x21, 0x08, 0x81, 0x10, 0x08, 0x42, 0x10, 0x10, 0x3C, 0x08, 
  0x20, 0x00, 0x04, 0x40, 0x00, 0x02, 0x80, 0x00, 0x01, 0x80, 0x18, 0x01, 
  0x80, 0x18, 0x01, 0x80, 0x00, 0x01, 0x40, 0x00, 0x02, 0x20, 0x00, 0x04, 
  0x10, 0x3C, 0x08, 0x08, 0x42, 0x10, 0x08, 0x81, 0x10, 0x84, 0x00, 0x21, 
  0x64, 0x00, 0x26, 0x18, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, };

#define cross_block_width 14
#define cross_block_height 14
static const unsigned char cross_block_bits[] U8X8_PROGMEM  = {
  0xFF, 0x3F, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 
  0xC1, 0x20, 0xC1, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 0x01, 0x20, 
  0x01, 0x20, 0xFF, 0x3F, };

void u8g2_bitmap_overlay(uint8_t a) {
  uint8_t frame_size = 28;

  u8g2.drawStr(0, 0, "Bitmap overlay");

  u8g2.drawStr(0, frame_size + 12, "Solid / transparent");
  u8g2.setBitmapMode(false /* solid */);
  u8g2.drawFrame(0, 10, frame_size, frame_size);
  u8g2.drawXBMP(2, 12, cross_width, cross_height, cross_bits);
  if(a & 4)
    u8g2.drawXBMP(7, 17, cross_block_width, cross_block_height, cross_block_bits);

  u8g2.setBitmapMode(true /* transparent*/);
  u8g2.drawFrame(frame_size + 5, 10, frame_size, frame_size);
  u8g2.drawXBMP(frame_size + 7, 12, cross_width, cross_height, cross_bits);
  if(a & 4)
    u8g2.drawXBMP(frame_size + 12, 17, cross_block_width, cross_block_height, cross_block_bits);
}

void u8g2_bitmap_modes(uint8_t transparent) {
  const uint8_t frame_size = 24;

  u8g2.drawBox(0, frame_size * 0.5, frame_size * 5, frame_size);
  u8g2.drawStr(frame_size * 0.5, 50, "Black");
  u8g2.drawStr(frame_size * 2, 50, "White");
  u8g2.drawStr(frame_size * 3.5, 50, "XOR");
  
  if(!transparent) {
    u8g2.setBitmapMode(false /* solid */);
    u8g2.drawStr(0, 0, "Solid bitmap");
  } else {
    u8g2.setBitmapMode(true /* transparent*/);
    u8g2.drawStr(0, 0, "Transparent bitmap");
  }
  u8g2.setDrawColor(0);// Black
  u8g2.drawXBMP(frame_size * 0.5, 24, cross_width, cross_height, cross_bits);
  u8g2.setDrawColor(1); // White
  u8g2.drawXBMP(frame_size * 2, 24, cross_width, cross_height, cross_bits);
  u8g2.setDrawColor(2); // XOR
  u8g2.drawXBMP(frame_size * 3.5, 24, cross_width, cross_height, cross_bits);
}

uint8_t draw_state = 0;

void draw(void) {
  u8g2_prepare();
  switch(draw_state >> 3) {
    case 0: u8g2_box_frame(draw_state&7); break;
    case 1: u8g2_disc_circle(draw_state&7); break;
    case 2: u8g2_r_frame(draw_state&7); break;
    case 3: u8g2_string(draw_state&7); break;
    case 4: u8g2_line(draw_state&7); break;
    case 5: u8g2_triangle(draw_state&7); break;
    case 6: u8g2_ascii_1(); break;
    case 7: u8g2_ascii_2(); break;
    case 8: u8g2_extra_page(draw_state&7); break;
    case 9: u8g2_bitmap_modes(0); break;
    case 10: u8g2_bitmap_modes(1); break;
    case 11: u8g2_bitmap_overlay(draw_state&7); break;
  }
}


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

void loop(void) {
  // picture loop  
  u8g2.clearBuffer();
  draw();
  u8g2.sendBuffer();
  
  // increase the state
  draw_state++;
  if ( draw_state >= 12*8 )
    draw_state = 0;

  // deley between each page
  delay(100);

}

속도는 U8g 의 Fast I2C 정도는 아니지만,

그리 느린 속도는 아니면서 arduino 의 led 는 점멸하지 않습니다.

10. Reference

위에서 열거되지 않은 부분은, 주로 아래 link 들을 참고하였습니다.

- https://forum.arduino.cc/index.php?topic=403234.0

- https://github.com/squix78/esp8266-oled-ssd1306

- http://www.instructables.com/id/Monochrome-096-i2c-OLED-display-with-arduino-SSD13/

FIN

역시 사람은 오감으로 느껴야지만 이해가 갑니다.