while (!Serial) ;

===============================================
Example sketch for CurieIMU library for Intel(R) Curie(TM) devices.
Copyright (c) 2015 Intel Corporation. All rights reserved.

Based on I2C device class (I2Cdev) demonstration Arduino sketch for MPU6050
class by Jeff Rowberg: https://github.com/jrowberg/i2cdevlib

===============================================
I2Cdev device library code is placed under the MIT license
Copyright (c) 2011 Jeff Rowberg

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the “Software”), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
===============================================

Genuino 101 CurieIMU Orientation Visualiser
Hardware Required:
* Arduino/Genuino 101

Modified Nov 2015
by Helena Bisby <support@arduino.cc>
This example code is in the public domain

http://arduino.cc/en/Tutorial/Genuino101CurieIMUOrientationVisualiser

*/

#include <CurieIMU.h>
#include <MadgwickAHRS.h>

Madgwick filter; // Madgwick 객체를 생성해 냅니다.
int ax, ay, az;
int gx, gy, gz;
float yaw;
float pitch;
float roll;
int factor = 800; // 감도 조절을 위해 자이로스코프의 원래 값을 나눠준다.
// 시리얼 보레이트를 올리면 이 값도 변경시킨다.

int calibrateOffsets = 1; // 캘리브레이션을 할지 말지 설정

void setup() {
Serial.begin(9600); // 시리얼 통신 초기화

CurieIMU.begin(); // 장치 초기화

if (calibrateOffsets == 1) {
//자이로와 가속도센서의 오프셋을 설정하는 기능
Serial.println(“Internal sensor offsets BEFORE calibration…”);
Serial.print(CurieIMU.getAccelerometerOffset(X_AXIS)); Serial.print(“\t”);
Serial.print(CurieIMU.getAccelerometerOffset(Y_AXIS)); Serial.print(“\t”);
Serial.print(CurieIMU.getAccelerometerOffset(Z_AXIS)); Serial.print(“\t”);
Serial.print(CurieIMU.getGyroOffset(X_AXIS)); Serial.print(“\t”);
Serial.print(CurieIMU.getGyroOffset(Y_AXIS)); Serial.print(“\t”);
Serial.print(CurieIMU.getGyroOffset(Z_AXIS)); Serial.print(“\t”);
Serial.println(“”);

// To manually configure offset compensation values, use the following methods instead of the autoCalibrate…() methods below
// CurieIMU.setGyroOffset(X_AXIS, 220);
// CurieIMU.setGyroOffset(Y_AXIS, 76);
// CurieIMU.setGyroOffset(Z_AXIS, -85);
// CurieIMU.setAccelerometerOffset(X_AXIS, -76);
// CurieIMU.setAccelerometerOffset(Y_AXIS, -235);
// CurieIMU.setAccelerometerOffset(Z_AXIS, 168);

// 올바로 오프셋이 설정되기 위해서는 제누이노보드가 수평으로 유지되어 있어야 한다.
Serial.print(“Starting Gyroscope calibration…”);
CurieIMU.autoCalibrateGyroOffset();
Serial.println(“ Done”);
Serial.print(“Starting Acceleration calibration…”);
CurieIMU.autoCalibrateAccelerometerOffset(X_AXIS, 0);
CurieIMU.autoCalibrateAccelerometerOffset(Y_AXIS, 0);
CurieIMU.autoCalibrateAccelerometerOffset(Z_AXIS, 1);
Serial.println(“ Done”);

Serial.println(“Internal sensor offsets AFTER calibration…”);
Serial.print(CurieIMU.getAccelerometerOffset(X_AXIS)); Serial.print(“\t”);
Serial.print(CurieIMU.getAccelerometerOffset(Y_AXIS)); Serial.print(“\t”);
Serial.print(CurieIMU.getAccelerometerOffset(Z_AXIS)); Serial.print(“\t”);
Serial.print(CurieIMU.getAccelerometerOffset(X_AXIS)); Serial.print(“\t”);
Serial.print(CurieIMU.getAccelerometerOffset(Y_AXIS)); Serial.print(“\t”);
Serial.print(CurieIMU.getAccelerometerOffset(Z_AXIS)); Serial.print(“\t”);
Serial.println(“”);
}
}

void loop() {
// 가속도와 자이로센서로부터 원시데이터를 읽어 온다.
CurieIMU.readMotionSensor(ax, ay, az, gx, gy, gz);

// MagdwickAHRS.h 함수를 통해 쿼터니언을 계산하여 가져온다.
filter.updateIMU(gx / factor, gy / factor, gz / factor, ax, ay, az);

// 쿼터니언으로부터 yaw, roll, pitch를 계산해낸다.
yaw = filter.getYaw();
roll = filter.getRoll();
pitch = filter.getPitch();

// print gyro and accel values for debugging only, comment out when running Processing
/*
Serial.print(ax); Serial.print(“\t”);
Serial.print(ay); Serial.print(“\t”);
Serial.print(az); Serial.print(“\t”);
Serial.print(gx); Serial.print(“\t”);
Serial.print(gy); Serial.print(“\t”);
Serial.print(gz); Serial.print(“\t”);
Serial.println(“”);
*/

if (Serial.available() > 0) {
int val = Serial.read();
if (val == ‘s’) { // 시리얼 포트로 “s”라는 문자가 오는지 체크. 즉 프로세싱코드에서 보내야함
Serial.print(yaw);
Serial.print(“,”); // 콤마가 구분자로 사용된다.
Serial.print(pitch);
Serial.print(“,”); // 콤마가 구분자로 사용된다.
Serial.println(roll);
}
}
}

import processing.serial.*;
Serial myPort;

int newLine = 13; // new line character in ASCII
float yaw;
float pitch;
float roll;
String message;
String [] ypr = new String [3];

void setup()
{
size(600, 500, P3D);

/*자신의 제누이노보드의 통신속도와 PC의 포트번호를 참조하여 설정한다.*/
//myPort = new Serial(this, Serial.list()[0], 9600); // if you have only ONE COM port active
myPort = new Serial(this, “COM51″, 9600); // if you know the 101 COM port

textSize(16); // set text size
textMode(SHAPE); // set text mode to shape
}

void draw()
{
serialEvent(); // read and parse incoming serial message
background(255); // set background to white

translate(width/2, height/2); // set position to centre

pushMatrix(); // begin object

rotateX(pitch); // RotateX pitch value
rotateY(-yaw); // yaw
rotateZ(-roll); // roll

drawArduino(); // function to draw rough Arduino shape

popMatrix(); // end of object

// Print values to console
print(pitch);
print(“\t”);
print(roll);
print(“\t”);
print(-yaw);
println(“\t”);

myPort.write(“s”); // “s”를 제누이노 보드로 보내 다음 문자를 받아 들인다.
}

void serialEvent()
{
message = myPort.readStringUntil(newLine); // read from port until new line (ASCII code 13)
if (message != null) {
ypr = split(message, “,”); // split message by commas and store in String array
yaw = float(ypr[0]); // convert to float yaw
pitch = float(ypr[1]); // convert to float pitch
roll = float(ypr[2]); // convert to float roll
}
}

void drawArduino() {
/* function contains shape(s) that are rotated with the IMU */
stroke(0, 90, 90); // set outline colour to darker teal
fill(0, 130, 130); // set fill colour to lighter teal
box(300, 10, 200); // draw Arduino board base shape

stroke(0); // set outline colour to black
fill(80); // set fill colour to dark grey

translate(60, -10, 90); // set position to edge of Arduino box
box(170, 20, 10); // draw pin header as box

translate(-20, 0, -180); // set position to other edge of Arduino box
box(210, 20, 10); // draw other pin header as box
}

출처 : https://www.arduino.cc/en/Tutorial/Genuino101CurieIMUOrientationVisualiser

===============================================
Example sketch for CurieIMU library for Intel(R) Curie(TM) devices.
Copyright (c) 2015 Intel Corporation. All rights reserved.
Based on I2C device class (I2Cdev) demonstration Arduino sketch for MPU6050
class by Jeff Rowberg: https://github.com/jrowberg/i2cdevlib
===============================================
I2Cdev device library code is placed under the MIT license
Copyright (c) 2011 Jeff Rowberg

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
===============================================

#include “CurieIMU.h”
int ax, ay, az; // accelerometer values
int gx, gy, gz; // gyrometer values

const int ledPin = 13; // activity LED pin
boolean blinkState = false; // state of the LED

int calibrateOffsets = 1; // int to determine whether calibration takes place or not

void setup() {
Serial.begin(9600); // initialize Serial communication
while (!Serial); // wait for the serial port to open

// initialize device
Serial.println(“Initializing IMU device…”);
CurieIMU.begin();

// verify connection
Serial.println(“Testing device connections…”);
if (CurieIMU.begin()) {
Serial.println(“CurieIMU connection successful”);
} else {
Serial.println(“CurieIMU connection failed”);
}

// use the code below to calibrate accel/gyro offset values
if (calibrateOffsets == 1) {
Serial.println(“Internal sensor offsets BEFORE calibration…”);
Serial.print(CurieIMU.getAccelerometerOffset(X_AXIS));
Serial.print(“\t”); // -76
Serial.print(CurieIMU.getAccelerometerOffset(Y_AXIS));
Serial.print(“\t”); // -235
Serial.print(CurieIMU.getAccelerometerOffset(Z_AXIS));
Serial.print(“\t”); // 168
Serial.print(CurieIMU.getGyroOffset(X_AXIS));
Serial.print(“\t”); // 0
Serial.print(CurieIMU.getGyroOffset(Y_AXIS));
Serial.print(“\t”); // 0
Serial.println(CurieIMU.getGyroOffset(Z_AXIS));

// To manually configure offset compensation values,
// use the following methods instead of the autoCalibrate…() methods below
//CurieIMU.setAccelerometerOffset(X_AXIS,495.3);
//CurieIMU.setAccelerometerOffset(Y_AXIS,-15.6);
//CurieIMU.setAccelerometerOffset(Z_AXIS,491.4);
//CurieIMU.setGyroOffset(X_AXIS,7.869);
//CurieIMU.setGyroOffset(Y_AXIS,-0.061);
//CurieIMU.setGyroOffset(Z_AXIS,15.494);

Serial.println(“About to calibrate. Make sure your board is stable and upright”);
delay(5000);

// The board must be resting in a horizontal position for
// the following calibration procedure to work correctly!
Serial.print(“Starting Gyroscope calibration and enabling offset compensation…”);
CurieIMU.autoCalibrateGyroOffset();
Serial.println(” Done”);

Serial.print(“Starting Acceleration calibration and enabling offset compensation…”);
CurieIMU.autoCalibrateAccelerometerOffset(X_AXIS, 0);
CurieIMU.autoCalibrateAccelerometerOffset(Y_AXIS, 0);
CurieIMU.autoCalibrateAccelerometerOffset(Z_AXIS, 1);
Serial.println(” Done”);
Serial.println(“Internal sensor offsets AFTER calibration…”);
Serial.print(CurieIMU.getAccelerometerOffset(X_AXIS));
Serial.print(“\t”); // -76
Serial.print(CurieIMU.getAccelerometerOffset(Y_AXIS));
Serial.print(“\t”); // -2359
Serial.print(CurieIMU.getAccelerometerOffset(Z_AXIS));
Serial.print(“\t”); // 1688
Serial.print(CurieIMU.getGyroOffset(X_AXIS));
Serial.print(“\t”); // 0
Serial.print(CurieIMU.getGyroOffset(Y_AXIS));
Serial.print(“\t”); // 0
Serial.println(CurieIMU.getGyroOffset(Z_AXIS));
}

// configure Arduino LED for activity indicator
pinMode(ledPin, OUTPUT);
}

void loop() {
// read raw accel/gyro measurements from device
CurieIMU.readMotionSensor(ax, ay, az, gx, gy, gz);

// these methods (and a few others) are also available

//CurieIMU.readAcceleration(ax, ay, az);
//CurieIMU.readRotation(gx, gy, gz);

//ax = CurieIMU.readAccelerometer(X_AXIS);
//ay = CurieIMU.readAccelerometer(Y_AXIS);
//az = CurieIMU.readAccelerometer(Z_AXIS);
//gx = CurieIMU.readGyro(X_AXIS);
//gy = CurieIMU.readGyro(Y_AXIS);
//gz = CurieIMU.readGyro(Z_AXIS);

// display tab-separated accel/gyro x/y/z values
// Serial.print(“a/g:\t”);
Serial.print(ax);
Serial.print(“\t”);
Serial.print(ay);
Serial.print(“\t”);
Serial.print(az);
Serial.print(“\t”);
Serial.print(gx);
Serial.print(“\t”);
Serial.print(gy);
Serial.print(“\t”);
Serial.println(gz);

// blink LED to indicate activity
blinkState = !blinkState;
digitalWrite(ledPin, blinkState);
}

/*
* Copyright (c) 2016 Intel Corporation. All rights reserved.
* See the bottom of this file for the license terms.
*/

#include <CurieBLE.h>

const int ledPin = 13; // 보드상에 있는 LED를 사용하기위해 설정
BLEPeripheral blePeripheral; // 블루투스 패리퍼럴 인스턴스를 생성한다.

BLEService ledService(“19B10000-E8F2-537E-4F6C-D104768A1214″); // 서비스를 생성한다.

// switch characteristic 를 원격장치에서 읽고 쓸 수 있도록 생성한다.
BLECharCharacteristic switchChar(“19B10001-E8F2-537E-4F6C-D104768A1214″, BLERead | BLEWrite);

void setup() {
Serial.begin(9600);
pinMode(ledPin, OUTPUT); // LED포트(pin 13)를 출력으로 설정

// 주변장치에게 광고할 제누이노101보드의 블루투스 이름
// 즉, 이 이름이 스마트폰 등에서 확인이 된다.
blePeripheral.setLocalName(“LEDCB”);

// UUID를 설정한다.
blePeripheral.setAdvertisedServiceUuid(ledService.uuid());

// 서비스와 특성 정보를 추가시킨다.
blePeripheral.addAttribute(ledService);
blePeripheral.addAttribute(switchChar);

// 주변장치를 연결하거나 끊기 위한 이벤트 핸들러를 할당 한다.
blePeripheral.setEventHandler(BLEConnected, blePeripheralConnectHandler);
blePeripheral.setEventHandler(BLEDisconnected, blePeripheralDisconnectHandler);

// 특성제어를 위한 이벤트 핸들러를 할당한다.
switchChar.setEventHandler(BLEWritten, switchCharacteristicWritten);

// 특성정보를 초기화 한다.
switchChar.setValue(0);

// 서비스를 광고한다. 즉, 다른 기기에서 이제부터 이 서비스를 탐지(탐색) 할 수 있다.
blePeripheral.begin();
Serial.println((“Bluetooth device active, waiting for connections…”));
}

void loop() {
// 주변장치로부터 반응을 지속적으로 폴링한다.
blePeripheral.poll();
}

// 접속이벤트 처리용 핸들러
void blePeripheralConnectHandler(BLECentral& central) {
// central connected event handler
Serial.print(“Connected event, central: “);
Serial.println(central.address());
}

// 접속끊김 이벤트 처리용 핸들러
void blePeripheralDisconnectHandler(BLECentral& central) {
// central disconnected event handler
Serial.print(“Disconnected event, central: “);
Serial.println(central.address());
}

// 실제로 LED를 제어하는 부분으로 switchChar.value()값을 읽어 LED 점멸을 제어한다.
void switchCharacteristicWritten(BLECentral& central, BLECharacteristic& characteristic) {
// central wrote new value to characteristic, update LED
Serial.print(“Characteristic event, written: “);

if (switchChar.value()) {
Serial.println(“LED on”);
digitalWrite(ledPin, HIGH);
} else {
Serial.println(“LED off”);
digitalWrite(ledPin, LOW);
}
}

/*
Copyright (c) 2016 Intel Corporation. All rights reserved.

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/

출처 : https://www.arduino.cc/en/Tutorial/Genuino101CurieBLECallbackLED

/* Copyright (c) 2015 Intel Corporation. All rights reserved.

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/

/*
This sketch example partially implements the standard Bluetooth Low-Energy Heart Rate service.
For more information: https://developer.bluetooth.org/gatt/services/Pages/ServicesHome.aspx
*/

#include <CurieBLE.h>

BLEPeripheral blePeripheral; // BLE Peripheral Device (the board you’re programming)
BLEService heartRateService(“180D”); // BLE Heart Rate Service

// BLE Heart Rate Measurement Characteristic”
BLECharacteristic heartRateChar(“2A37″, // standard 16-bit characteristic UUID
BLERead | BLENotify, 2); // remote clients will be able to get notifications if this characteristic changes

// the characteristic is 2 bytes long as the first field needs to be “Flags” as per BLE specifications
// https://developer.bluetooth.org/gatt/characteristics/Pages/CharacteristicViewer.aspx?
// u=org.bluetooth.characteristic.heart_rate_measurement.xml

int oldHeartRate = 0; // last heart rate reading from analog input
long previousMillis = 0; // last time the heart rate was checked, in ms

void setup() {
Serial.begin(9600); // initialize serial communication
pinMode(13, OUTPUT); // initialize the LED on pin 13 to indicate when a central is connected

/* Set a local name for the BLE device
This name will appear in advertising packets
and can be used by remote devices to identify this BLE device
The name can be changed but maybe be truncated based on space left in advertisement packet */
blePeripheral.setLocalName(“HeartRateSketch”);
blePeripheral.setAdvertisedServiceUuid(heartRateService.uuid()); // add the service UUID
blePeripheral.addAttribute(heartRateService); // Add the BLE Heart Rate service
blePeripheral.addAttribute(heartRateChar); // add the Heart Rate Measurement characteristic

/* Now activate the BLE device. It will start continuously transmitting BLE
advertising packets and will be visible to remote BLE central devices
until it receives a new connection */
blePeripheral.begin();
Serial.println(“Bluetooth device active, waiting for connections…”);
}

void loop() {
// listen for BLE peripherals to connect:
BLECentral central = blePeripheral.central();

// if a central is connected to peripheral:
if (central) {
Serial.print(“Connected to central: “);
// print the central’s MAC address:
Serial.println(central.address());
// turn on the LED to indicate the connection:
digitalWrite(13, HIGH);
// check the heart rate measurement every 200ms
// as long as the central is still connected:
while (central.connected()) {
long currentMillis = millis();
// if 200ms have passed, check the heart rate measurement:
if (currentMillis – previousMillis >= 200) {
previousMillis = currentMillis;
updateHeartRate();
}
}
// when the central disconnects, turn off the LED:
digitalWrite(13, LOW);
Serial.print(“Disconnected from central: “);
Serial.println(central.address());
}
}

void updateHeartRate() {
/* Read the current voltage level on the A0 analog input pin.
This is used here to simulate the heart rate’s measurement.
*/
int heartRateMeasurement = analogRead(A0);
int heartRate = map(heartRateMeasurement, 0, 1023, 0, 100);
if (heartRate != oldHeartRate) { // if the heart rate has changed
Serial.print(“Heart Rate is now: “); // print it
Serial.println(heartRate);
//const unsigned char heartRateCharArray[2] = { 0, (char)heartRate };
const unsigned char heartRateCharArray[2] = { 0, (unsigned char)heartRate };
heartRateChar.setValue(heartRateCharArray, 2); // and update the heart rate measurement characteristic
oldHeartRate = heartRate; // save the level for next comparison
}
}

/*
* Eddystone URL for Arduino/Genuino 101.
*
* This is an Intel Curie Eddystone-compatible Sketch
* (https://github.com/google/eddystone).
*
* The Eddystone BLE protocol is used by the Physical Web(tm) project
* (https://github.com/google/physical-web).
* The Physical Web project is about BLE beacons that broadcast URLs
* so your users don’t have to download an app just to interact with
* your device.
*
* Note: this version doesn’t support Eddystone Config mode.
* To change the URL, you need to modify MY_URL and reload the Arduino.
*
* Parts required:
* Arduino/Genuino 101. This Sketch runs only on Curie-based devices.
* No other hardware is required.
*
* To Use:
* – Setup your CurieBLE libraries to support Eddystone.
* Doing this may be a little complicated until the Eddystone support
* is added to the CurieBLE library. Until then…
* There are two ways to do that:
* 1) Pull code from https://github.com/bneedhamia/corelibs-arduino101/tree/support-eddystone-url
* or
* 2) Replace CurieBLE/BLEPeripheral.* and CurieBLE/keywords.txt
* with a modified version that supports Eddystone Advertising packets.
* See https://github.com/bneedhamia/CurieBLEServiceData
* once that’s done…
* – Set MY_URL to the url for the beacon you wish to broadcast.
* – Download this Sketch to an Arduino/Genuino 101.
* – Download a Physical Web app to your phone.
* For example, Google’s Physical Web Android app is at
* https://play.google.com/store/apps/details?id=physical_web.org.physicalweb
*
* Copyright (c) 2016 Bradford Needham, North Plains, Oregon, USA
* @bneedhamia, https://www.needhamia.com
* Licensed under the Apache 2.0 License, a copy of which
* should have been included with this software.
*/

/*
* Note: as of this writing, the documentation of the CurieBLE library
* is the library source, at (on Linux)
* ~/.arduino15/packages/Intel/hardware/arc32/1.0.4/libraries/CurieBle/src
*
* Version 1.0.4 of CurieBle doesn’t support Eddystone-format
* BLE Advertising packets, for 2 reasons:
* – It uses the BLE code for Incomplete Service UUID list
* instead of Complete Service UUID list code required by Eddystone.
* – It doesn’t support Service Data, which is required by Eddystone.
*
* Note: the name of the Curie BLE library changed between 1.0.4 and
* the latest (as of March 10, 2016) version:
* In 1.0.4, the name is CurieBle.h; in later versions, it’s CurieBLE.h
*/

#include <CurieBLE.h> // BHN-Modified Curie-specific BLE Library

/*
* Pinout:
* PIN_BLINK = digital Output. The normal Arduino 101 LED.
* If everything is working, the LED blinks.
* If instead there is a startup error, the LED is solid.
*/
const int PIN_BLINK = 13; // Pin 13 is the on-board LED

/*
* The (unencoded) URL to put into the
* Eddystone-URL beacon frame.
*
* NOTE: the encoded length must be under 18 bytes long.
* See initEddystoneUrlFrame().
*
* NOTE: This Sketch supports only lower-case URLs.
* See initEddystoneUrlFrame().
*/
const char* MY_URL = “http://www.devicemart.co.kr/”;

/*
* The reported Tx Power value to put into the Eddystone-URL beacon frame.
*
* From the Eddystone-URL Protocol specification
* (https://github.com/google/eddystone/blob/master/eddystone-url/README.md#tx-power-level)
* “the best way to determine the precise value
* to put into this field is to measure the actual output
* of your beacon from 1 meter away and then add 41dBm to that.
* 41dBm is the signal loss that occurs over 1 meter.”
*
* I used the Nordic nRF Master Control Panel Android app
* (https://play.google.com/store/apps/details?id=no.nordicsemi.android.mcp&hl=en)
* to measure the beacon power at 1 meter.
*/
const int8_t TX_POWER_DBM = (-70 + 41);

/*
* Maximum number of bytes in an Eddystone-URL frame.
* The Eddystone-URL frame contains
* the frame type, Tx Power, Url Prefix, and up to 17 bytes of Url.
* (The spec isn’t completely clear. That might be 18 rather than 17.)
*/
const uint8_t MAX_URL_FRAME_LENGTH = 1 + 1 + 1 + 17;

/*
* Eddystone-URL frame type
*/
const uint8_t FRAME_TYPE_EDDYSTONE_URL = 0×10;

/*
* Eddystone-URL url prefix types
* representing the starting characters of the URL.
* 0×00 = http://www.
* 0×01 = https://www.
* 0×02 = http://
* 0×03 = https://
*/
const uint8_t URL_PREFIX_HTTP_WWW_DOT = 0×00;
const uint8_t URL_PREFIX_HTTPS_WWW_DOT = 0×01;
const uint8_t URL_PREFIX_HTTP_COLON_SLASH_SLASH = 0×02;
const uint8_t URL_PREFIX_HTTPS_COLON_SLASH_SLASH = 0×03;

/*
* eddyService = Our BLE Eddystone Service.
* See https://developer.bluetooth.org/gatt/services/Pages/ServicesHome.aspx
* and https://github.com/google/eddystone/blob/master/protocol-specification.md
* NOTE: as of this writing, Eddystone doesn’t seem to be part of the Standard BLE Services list.
*
*/
BLEService eddyService(“FEAA”);

BLEPeripheral ble; // Root of our BLE Peripheral (server) capability

<중략>