#include <SPI.h>
#include “WizFi250.h”

char ssid[] = “myLivngRoom(2.4GHz)”; // 접속코자하는 무선공유기의 SSID
char pass[] = “??????????”; // 공유기에 설정된 암호
int status = WL_IDLE_STATUS; // 와이파이 상태변수의 초기 값

char targetServer[] = “arduino.cc”;

// 이더넷 클라이언트 오브젝트 초기화
WiFiClient client;
void printWifiStatus();

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

// WizFi250 와이파이모듈이 잘 동작될 수 있는지 검사해 본다.
if (WiFi.status() == WL_NO_SHIELD) {
Serial.println(“WiFi shield not present”);
// 만일 문제가 있다면 여기서 홀딩한다.
while (true);
}

// 와이파이 망으로 연결을 시도한다.
// 연결이 성공적으로 되어야 루프를 벗어날 수 있다.
while ( status != WL_CONNECTED) {
Serial.print(“Attempting to connect to WPA SSID: “);
Serial.println(ssid);
// 암호방식이 WPA/WPA2인 망에 연결이 진행중인 상태값
status = WiFi.begin(ssid, pass);
}

// 와이파이망에 성공적으로 연결이 됨
Serial.println(“You’re connected to the network”);
printWifiStatus();
Serial.println();
Serial.println(“Starting connection to server…”);

// 목적지 서버인 arduino.cc에 80번 포트로 연결을 시도하고 결과를
// 시리얼모니터로 출력한다.
if (client.connect(targetServer, 80)) {
Serial.println(“Connected to server”);
// 나에게 asciilogo.txt를 보내 달라고 요청한다.
client.println(“GET /asciilogo.txt HTTP/1.1″);
client.println(“Host: arduino.cc”);
client.println(“Connection: close”);
client.println();
}
}

void loop()
{
// 타겟서버와 연결이 이뤄졌고 asciilogo.txt을 보내달라고 요청을 setup()에서
// 하였으므로 보내오는 값을 시리얼모니터창에 뿌리는 작업을 한다.
while (client.available()) {
char c = client.read();
Serial.write(c);
}

// if the server’s disconnected, stop the client
// 타켓서버와 연결이 끊어진 상태라면 Disconnecting from server…라는 메시지를 뿌리고 홀딩한다.
if (!client.connected()) {
Serial.println();
Serial.println(“Disconnecting from server…”);
client.stop();

// 여기서 부터는 아무것도 할 수 없는 상태에 접어든다.
while (true);
}
}
void printWifiStatus()
{
// 방금 내가 연결한 와이파이망의 SSID를 읽어와 시리얼 모니터로 출력 한다.
Serial.print(“SSID: “);
Serial.println(WiFi.SSID());
// 방금 내가 연결한 공유기로부터 할당 받은 IP주소를 시리얼 모니터로 출력한다.
IPAddress ip = WiFi.localIP();
Serial.print(“IP Address: “);
Serial.println(ip);
// 나와 공유간의 무선전송구간 수신강도를 표출 한다.
long rssi = WiFi.RSSI();
Serial.print(“Signal strength (RSSI):”);
Serial.print(rssi);
Serial.println(” dBm”);
}

IPAddress IP = WiFi.localIP(); // IPAddress라는 타입으로 된 변수 IP에 주소값을 담아라
Serial.print(“IP Address: “); // 시리얼모니터 창에 IP Address:를 출력하라
Serial.println(ip); // 시리얼모니터 창에 IP 값을 출력하고 줄바꿈을 하라

SSID: myLivngRoom(2.4GHz)
IP Address: 172.30.1.41
Signal strength (RSSI):-32 dBm

Opening port
Port open
[WizFi250] Initializing WizFi250
Attempting to connect to WPA SSID: myLivngRoom(2.4GHz)
[WizFi250] Connected to myLivngRoom(2.4GHz)
You’re connected to the network
SSID: myLivngRoom(2.4GHz)
IP Address: 172.30.1.22

To see this page in action, open a browser to http://172.30.1.22

[WizFi250] Server started on port 80
[WizFi250] New client
New client Start!—–>

Sending response
<———-Client disconnected
[WizFi250] New client
New client Start!—–>
HTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Encoding: gzip, deflate, sdch
Accept-Language: ko-KR,ko;q=0.8,en-US;q=0.6,en;q=0.4

Sending response
<———-Client disconnected
[WizFi250] New client
New client Start!—–>

Sending response
<———-Client disconnected
[WizFi250] New client
New client Start!—–>
hrome/55.0.2883.87 Safari/537.36
Accept: image/webp,image/*,*/*;q=0.8
Referer: http://172.30.1.22/
Accept-Encoding: gzip, deflate, sdch
Accept-Language: ko-KR,ko;q=0.8,en-US;q=0.6,en;q=0.4

Sending response
<———-Client disconnected

#include <SPI.h>
#include “WizFi250.h”
char ssid[] = “myLivngRoom(2.4GHz)”; // 접속코자하는 무선공유기의 SSID
char pass[] = “???????????”; // 공유기에 설정된 암호
int status = WL_IDLE_STATUS; // 와이파이 상태변수의 초기 값
int reqCount = 0; // 수신 재전송 횟수용 카운터
WiFiServer server(80);
void printWifiStatus();
void setup()
{
// 디버깅을 위한 시리얼 모니터포트 초기화
Serial.begin(115200);
// 와이파이모듈 초기화
WiFi.init();
// 와이파이모듈과 통신이 가능한 상태인지 검사
if (WiFi.status() == WL_NO_SHIELD) {
Serial.println(“WiFi shield not present”);
// 통신이 가능한 상태가 아니라면 여기서 홀딩하라
while (true);
}
// 와이파이망에 연결을 시도한다.
while (status != WL_CONNECTED) {
Serial.print(“Attempting to connect to WPA SSID: “);
Serial.println(ssid);
// 연결에 대한 상태값을 받아 온다.
status = WiFi.begin(ssid, pass);
}
Serial.println(“You’re connected to the network”);
printWifiStatus();
// 80번 포트로 리슨하는 웹서버를 구동하라.
server.begin(); // Serial Monitor out: [WizFi250] Server started on port 80
}

void loop()
{
// 클라이언트에서 연결을 해 오는 것에 대해 수신대기를 합니다.
WiFiClient client = server.available();
// Serial Monitor out : [WizFi250] New client

if (client) {
Serial.println(“New client Start!—–>”);
// http 요청은 빈 줄로 끝납니다.
boolean currentLineIsBlank = true;
while (client.connected())
{
if (client.available()) {
// 클라이언트로부터 1문자를 수신합니다.
char c = client.read();
Serial.write(c);
// 줄 바꿈 문자 (줄 바꿈 문자 수신)가 있고 줄이 비어 있으면
//http 요청이 끝났기 때문에 회신을 보낼 수가 있습니다.
if (c == ‘\n’ && currentLineIsBlank) {
Serial.println(“Sending response”);
// 표준 http 응답 헤더를 보내려면 많은 println 문 대신
//\r\n을 사용하여 데이터 전송 속도를 높입니다.
client.print(
“HTTP/1.1 200 OK\r\n”
“Content-Type: text/html\r\n”
“Connection: close\r\n” // 응답이 완료되면 연결이 닫힙니다.
“Refresh: 20\r\n” // 20초마다 자동으로 페이지를 새로 고칩니다.
“\r\n”);
client.print(“<!DOCTYPE HTML>\r\n”);
client.print(“<html>\r\n”);
client.print(“<h1>Hello World!</h1>\r\n”);
client.print(“Requests received: “);
client.print(++reqCount);
client.print(“<br>\r\n”);
client.print(“Analog input A0: “);
client.print(analogRead(0));
client.print(“<br>\r\n”);
client.print(“</html>\r\n”);
break;
}
if (c == ‘\n’) {
// 새라인을 시작한다.
currentLineIsBlank = true;
} else if (c != ‘\r’) {
// 현재 라인에 어떤 문자가 들어 옴
currentLineIsBlank = false;
}
}
} // while
// 웹 브라우저가 데이터를 받을 시간을 줍니다.
delay(10);
// 연결을 종료한다:
client.stop();
Serial.println(“<———-Client disconnected”);
}
}
void printWifiStatus()
{
// 방금 내가 연결한 와이파이망의 SSID를 읽어와 시리얼 모니터로 출력 한다.
Serial.print(“SSID: “);
Serial.println(WiFi.SSID());
// 방금 내가 연결한 공유기로부터 할당 받은 IP주소를 시리얼 모니터로 출력한다.
IPAddress ip = WiFi.localIP();
Serial.print(“IP Address: “);
Serial.println(ip);
// 브라우져에 어디서부터 접속을 시도 했는지를 표출한다.
Serial.println();
Serial.print(“To see this page in action, open a browser to http://”);
Serial.println(ip);
Serial.println();
}

// 80번 포트로 리슨하는 웹서버를 구동하라.
server.begin(); // Serial Monitor out: [WizFi250] Server started on port 80

// 클라이언트에서 연결을 해 오는 것에 대해 수신대기를 합니다.
WiFiClient client = server.available();
// Serial Monitor out : [WizFi250] New client

#include <SPI.h>
#include <WizFi250.h>
int getInt(String input);
#define VARID “??????????????????????????????????”

char ssid[] = “myLivngRoom(2.4GHz)”; // 접속코자하는 무선공유기의 SSID
char pass[] = “??????????”; // 공유기에 설정된 암호
int status = WL_IDLE_STATUS; // 와이파이 상태변수의 초기 값
char server[] = “api.openweathermap.org”;
unsigned long lastConnectionTime = 0; // 마지막으로 서버에 연결한 시간
const unsigned long postingInterval = 1000L; // 업데이트 간격 (밀리 초).

boolean readingVal;
boolean getIsConnected = false;
//String valString;
int val, temp;
float tempVal;
String rcvbuf;

// 이더넷 클라이언트 오브젝트를 초기화 한다.
WiFiClient client;

void httpRequest();
void printWifiStatus();

void setup()
{
// 디버깅을 위한 시리얼 포트 초기화
Serial.begin(115200);
Serial.println(F(“\r\nSerial Init”));
WiFi.init();

// 와이파이모듈이 정상인지 확인
if (WiFi.status() == WL_NO_SHIELD) {
Serial.println(“WiFi shield not present”);
// don’t continue
while (true);
}

// 와이파이망에 연결 시도
while (status != WL_CONNECTED) {
Serial.print(“Attempting to connect to WPA SSID: “);
Serial.println(ssid);
// Connect to WPA/WPA2 network
status = WiFi.begin(ssid, pass);
}

Serial.println(“You’re connected to the network”);
printWifiStatus();
}

void loop()
{
// 인터넷 연결에서 들어오는 데이터에 대해 파싱작업을 한다.
String valString;
while (client.available())
{
if (rcvbuf.endsWith(“\”temp\”:”)) { //서버로 부터 보내져 오는 문자열에 temp:을 찾는다.
readingVal = true;
valString = “”;
}
char c = client.read();
if (c != NULL) {
if (rcvbuf.length() > 30)
rcvbuf = “”;
rcvbuf += c;
Serial.write(c);// DEBUG
}

if (readingVal) {
if (c != ‘,’) {
valString += c; // ‘temp:’ 다음에 콤마(,)가 나타날때 까지 valstring에 담는다.
Serial.write(c); // DEBUG
}
else {
readingVal = false;
//Serial.println(valString); // DEBUG
// 절대온도를 상대온도로 변환시키기 위해 273을 뺌
tempVal = valString.toFloat() – 273.0;
//Serial.println(tempVal); // DEBUG
}
}
}

if (millis() – lastConnectionTime > (postingInterval * 5))
{
if (getIsConnected) {
Serial.println(valString);
Serial.println(F(“===================”));
Serial.print(F(“Temperature : “));
Serial.println(tempVal);
Serial.println(F(“===================”));
}
httpRequest();
}
rcvbuf = “”;
}

// 이 메서드는 서버로 HTTP 연결을 진행합니다.
void httpRequest() {
Serial.println();

// 새로운 요청을 하기전에 연결을 일단 닫는다.
// 이 작업으로 와이파이모듈의 소켓이 해제된다.
client.stop();

// 성공적으로 날씨정보 서버에 접속이 되는지 점검해 본다.
if (client.connect(server, 80)) {
Serial.println(“Connecting…”);
// 날씨정보를 얻고 싶은 도시명, 국가 정보를 웹서버로 보낸다.
client.print(“GET /data/2.5/weather?q=Anyang,kr&appid=”);
client.print(VARID);
client.println(” HTTP/1.1″);
client.println(“Host: api.openweathermap.org”);
client.println(“Connection: close”);
client.println();
// 연결이 만들어진 마지막 시각을 기록해 둔다.
lastConnectionTime = millis();
getIsConnected = true;
}
else {
// 연결이 성공적이지 못할 경우 에러처리를 한다.
Serial.println(“Connection failed”);
getIsConnected = false;
}
}

void printWifiStatus() {
// 연결된 SSID를 표출한다.
Serial.print(“SSID: “);
Serial.println(WiFi.SSID());

// IP주소를 표출한다.
IPAddress ip = WiFi.localIP();
Serial.print(“IP Address: “);
Serial.println(ip);
// 수신강도 인쇄
long rssi = WiFi.RSSI();
Serial.print(“Signal strength (RSSI):”);
Serial.print(rssi);
Serial.println(” dBm”);
}

// 스트링을 정수형으로 변환 시킨다.
int getInt(String input) {
char carray[20];
//Serial.println(input);
input.toCharArray(carray, sizeof(carray));
//Serial.println(carray);
temp = atoi(carray);
return temp;
}

Opening port
Port open
Attempting to connect to WPA SSID: myLivngRoom(2.4GHz)
[WizFi250] Connected to myLivngRoom(2.4GHz)
You’re connected to the network
SSID: myLivngRoom(2.4GHz)
IP Address: 172.30.1.22
Signal strength (RSSI):-42 dBm

[WizFi250] Connecting to api.openweathermap.org
Connecting…
HTTP/1.1 200 OK
Server: openresty
Date: Mon, 02 Jan 2017 13:34:27 GMT
Content-Type: application/json; charset=utf-8
Content-Length: 552
Connection: close
X-Cache-Key: /data/2.5/weather?q=anyang,kr
Access-Control-Allow-Origin: *
Access-Control-Allow-Credentials: true
Access-Control-Allow-Methods: GET, POST
{“coord”:{“lon”:126.93,”lat”:37.39},”weather”:[{"id":701,"main":"Mist","description":"mist","icon":"50n"},{"id":721,"main":"Haze","description":"haze","icon":"50n"},{"id":741,"main":"Fog","description":"fog","icon":"50n"}],”base”:”stations”,”main”:{“temp”:227755..1166,”pressure”:1022,”humidity”:83,”temp_min”:273.15,”temp_max”:277.15},
“visibility”:1200,”wind”:{“speed”:1,”deg”:180},”clouds”:{“all”:75},”dt”:1483363200,”sys”:{“type”:1,”id”:8519,”message”:0.0089,”country”:”KR”,”sunrise”:1483310810,
“sunset”:1483345579},”id”:1846898,”name”:”Anyang”,”cod”:200}
[DISCONNECT 0]ÿ
===================
Temperature : 2.16
===================

********************************************************************** 코코아팹 오렌지보드WiFi를 활용한 NTP(Network Time Protocol) 프로그램
***********************************************************************
* ProjectName: myUDPNTPclient2_OrangeWiFi_ATmega328P
* Dependencies: <SPI.h>,”WizFi250.h”,”WizFi250Udp.h”, <TimeLib.h>
* Processor: ATmega328P(28pin QFP)
* Complier: arduino.cc-1.6.9
* Microsoft Visual Studio vMicro
* Company:
* Author: 금강초롱(blog.naver.com/crucian2k3)
* History
* Date Version Description
* 2017-01-03 v1.0 최초작성
* 이크로칩사의 NTP 클라이언트 동작방식과 ESP8266기반의
* NTP클라이언트 동작방식을 참고하여 오렌지보드WiFi에 적합토록
* 전면 재작성 됨
***********************************************************************
***********************************************************************
* 동작내용:
* SSID, PASSWORD 등이 제대로 설정된 상황이라면 오렌지보드WiFi가 인터넷에 접속하여 일정한 간격으로 표준시간을 얻어와 자신이 사용하거나 다른 기계장치로 NMEA 전문규격에 부합토록 보내줄 수 있음
* 활용방법:
*전문을 수신하는 측에서는 ‘$Wi-Fi’ 문자열이 오면 버퍼에 저장을 시작하여 crlf가 나타나면 저장을 종료한다.
* *가 나타난후 2개의 문자는 2의 보수형으로 되어있는 체크섬이며, 계산하여 문제가 없다면 해당 전문에 실려 있는 epoc값을 바탕으로 9시간을 더해 한국시간에 맞게 활용하면 된다.
* Notes: 사용포트
* – D8 : LED0 Anode 연결
***********************************************************************
#include <SPI.h> // WizFi250 모듈과 ATmega328간 통신방식이 SPI
#include “WizFi250.h”
#include “WizFi250Udp.h”
#include <TimeLib.h> // EPOCH타임을 처리하기 위한 라이브러리

#define KOREA_TIME_ZONE 9 // 기준시에 비해 우리나라가 9시간 빠름
#define KOREA_TIME_ZONE_SEC (3600ul * KOREA_TIME_ZONE)
#define STATUSLED 8 // 동작상태 표출용 LED 출력포트(1초 간격 점멸시 정상 동작 중)
#define NTP_REFRESH_SECS 10

#define TICKS_PER_SECOND (1000L)
#define TICK_SECOND ((TICK)TICKS_PER_SECOND)
#define TICK_1000mS ((TICK)TICK_SECOND) // 1000ms 간격으로 실행 시
#define TICK_100mS ((TICK)TICK_SECOND / 10UL) // 100ms 간격으로 실행 시
#define TICK_10mS ((TICK)TICK_SECOND / 100UL) // 10ms 간격으로 실행 시
#define TICK_1mS ((TICK)TICK_SECOND / 1000UL) // 1ms 간격으로 실행 시

typedef unsigned long TICK; // TICK타입을 unsigned long으로 설정

char ssid[] = “myLivngRoom(2.4GHz)”; // 접속코자하는 AP의 SSID
char pass[] = “??????????”; // 패스워드
int status = WL_IDLE_STATUS; // AP의 상태값을 나타내는 변수
char wi_fiHeader[] = “$Wi-Fi”; // NTP 시각 외부 전송용 헤더
char timeServer[] = “zero.bora.net”; // NTP(Network Time Protocol) 서버주소
unsigned int localPort = 2390; // UDP 패킷 수신을 위한 로컬포트 지정
IPAddress timeServerIP; // 원격 NTP 서버의 IP주소
const int NTP_PACKET_SIZE = 48; // 메시지의 첫 48바이트에 NTP 정보가 담겨짐
uint8_t packetBuffer[NTP_PACKET_SIZE]; // 입출력이 일어나는 데이터에 대한 버퍼
String stringOne;
char LineBuffer[100];
int ledState = LOW;
int hours = 12; // 아날로그 모양의 시계를 움직이기 위한 초기 시간값
int minutes = 0;
int seconds = 0;
// UDP 인스턴스를 통해 udp데이터 수수가 일어난다.
WiFiUDP Udp;
unsigned long sendNTPpacket(char *ntpSrv);
unsigned long TickGet(); // 마이크로칩 라이브러리 스타일 명칭으로 호출

void setup()
{
Serial.begin(115200); // 디버깅을 위한 시리얼포트 초기화
pinMode(STATUSLED, OUTPUT); // 아두이노:D8
WiFi.init();
// 와이파이모듈과 오렌지보드간 SPI 통신이 가능한지 검사
if (WiFi.status() == WL_NO_SHIELD) {
Serial.println(“WiFi shield not present”);
// don’t continue
while (true);
}
}

void loop()
{
static enum
{
SM_HOME = 0,
SM_ATTEMPT_CONNECTION,
SM_WAIT_WL,
SM_WL_CONNECTED,
SM_SEND_NTP,
SM_WAIT_NTP_RECV,
SM_RCVCHECK,
SM_READPACKET,
SM_WAIT10SEC,
SM_NEXT,
SM_WAIT
} TASKState = SM_HOME;

static TICK myTimer0 = 0;
static int cycleCounter = 0;
int cb;
// 1900년부터 시작하는 NTP 타임체계를 1970년부터 시작하는 epoc 타임체계로 변환하기 위한 상수값
const unsigned long seventyYears = 2208988800UL;
unsigned long highWord;
unsigned long lowWord;
unsigned long secsSince1900;
unsigned long epoch;

// NTP 전문 생성용 변수
unsigned char calcchksum = 0;
unsigned char sl = 0;
unsigned char ct = 0;
unsigned char pl = 0;
int i;

switch (TASKState)
{
case SM_HOME:
// Wi-Fi망에 연결을 위한 사전 준비작업을 한다.
Serial.print(“Attempting to connect to WPA SSID: “);
Serial.println(ssid);

cycleCounter = 0;
myTimer0 = TickGet();
TASKState = SM_ATTEMPT_CONNECTION;
break;

case SM_ATTEMPT_CONNECTION:
// WPA/WPA2 망에 연결을 개시 한다.
status = WiFi.begin(ssid, pass);
if (status == WL_CONNECTED) {
// 연결에 성공되었음이 획인되면 다음 작업을 속행한다.
TASKState = SM_WL_CONNECTED;
}
else {
// 일단 연결에 실패하면….
// STATUSLED가 0.1초마다 한번씩 빠르게 점멸이 된다면 wi-fi를
// 찾지 못해 헤매는 중. 단, 오렌지보드wifi에서는 WizFi250모듈 내부
// 적으로 재전송 체계가 돌고 있는 것 같음 이로 인해 상태정보 응답
// 에 지연이 발생함
// ESP8266 등에서는 문제가 없는 코드이며, 오렌지보드에서도 큰 문
// 제는 없이 동작된다.
if (TickGet() – myTimer0 >= TICK_10mS * 10) {
myTimer0 = TickGet();
if (ledState == LOW)
ledState = HIGH; // LED on data
else
ledState = LOW; // LED off data

digitalWrite(STATUSLED, ledState);// LED action
// 만일 AP에 5초동안 연결을 반복 시도하였음에도 실패하면 에러처리 로직으로
cycleCounter++;
if (cycleCounter > 50) TASKState = SM_WAIT_WL;
}
}
break;
case SM_WAIT_WL:
// 5초 경과 후에도 여전히 연결이 되지 않은 경우 에러처리
if (WiFi.status() != WL_CONNECTED) {
// 5초가 경과되어도 여전히 접속되지 않으면 .을 한 개 출력한 후 처음부터 다시
Serial.print(“.”);
TASKState = SM_ATTEMPT_CONNECTION;
}
else {
// 만일 연결에 성공하면 retry counter를 찍은 후 다음 작업을 속행한다.
Serial.println(cycleCounter);
TASKState = SM_WL_CONNECTED;
}
break;
case SM_WL_CONNECTED:
// 성공적으로 wi-fi망에 연결되면 ip주소와 포트 번호를 표출한다.
Serial.println(“”);
Serial.println(“WiFi connected”);
Serial.print(“IP address: “);
Serial.println(WiFi.localIP());
Serial.println(“Starting UDP”);
Udp.begin(localPort);
Serial.print(“Local port: “);
Serial.println(localPort);
cycleCounter = 0;
TASKState = SM_SEND_NTP; // TIME 서버로 SNTP 패킷을 날린 후 응답을 기다린다.
break;
case SM_SEND_NTP:
// TIME 서버로 NTP 패킷을 전송한다.
//WiFi.hostByName(timeServer, timeServerIP);// ESP8266일 때 사용
Serial.println(“”); // 새로운 전문의 시작이 개시됨을 알리는 개행 작업
sendNTPpacket(timeServer); // time server로 NTP 패킷을 전송한다.
Serial.print(“Send NTP: “);
Serial.println(timeServer);
TASKState = SM_WAIT_NTP_RECV;
break;
case SM_WAIT_NTP_RECV:
// 타임서버로부터 응답이 왔는지를 검사하여 0.2초 후에도 수신이 되지
//않으면 한 번 더 요청을 해보고 그래도 응답이 1초 동안 없으면 wi-fi망에
//처음부터 다시 접속
cb = Udp.parsePacket();
if (!cb) {
// 정상적인 응답이 아닌 상태에 대한 처리
Serial.print(“*”);
cycleCounter++;
delay(100);
if (cycleCounter == 2) {
// TIME 서버로 NTP 패킷이 보내졌으나 0.2초를 기다려도
// 답신이 없으면 한 번 더 보내본다.
Serial.println(cycleCounter);
TASKState = SM_SEND_NTP;
}
else if (cycleCounter >= 10) {
// 답신이 없어 한 번 더 보내고도 1초가 또 경과되면 wi-fi망에
//이상이 있을 가능성이 높으므로 wi-fi 재접속을 시도해본다.
Serial.println(cycleCounter);
cycleCounter = 0;
TASKState = SM_WAIT_NTP_RECV;
}
}
else {
// 제대로 된 값이 온 것 같으면 데이터 파싱 단계를 진행한다.
Serial.println(cycleCounter);
cycleCounter = 0;
TASKState = SM_READPACKET;
}
break;
case SM_READPACKET:
// TIME 서버로 부터 NTP 패킷이 들어왔으므로 파싱 작업을 한다.
// Serial.print(“packet received, length=”);
// Serial.println(cb);
Udp.read(packetBuffer, NTP_PACKET_SIZE); // 일단 버퍼로 패킷을 옮긴다.
// 타임 스탬프는 수신된 패킷의 바이트 40에서 시작해 4바이트 또는
// 2 워드 길이이다. 먼저 두 워드구간을 추출해낸다.
highWord = word(packetBuffer[40], packetBuffer[41]);
lowWord = word(packetBuffer[42], packetBuffer[43]);
// 4 바이트 (두 워드)를 롱타입 정수로 머지합니다.
// 이것은 NTP 시간이 됩니다. (1900.1.1일 이후부터 현재까지의 초 값).
secsSince1900 = highWord << 16 | lowWord;
// Serial.print(“Seconds since Jan 1 1900 = ” );
// Serial.println(secsSince1900);
// 이제 NTP 시간을 우리가 일상적으로 사용하는 매일 시간형식(Unix Time)으로 변환합니다.
// Unix Time은 1970.1.1부터 시작합니다. 70년간을 초로 환산하면 2208988800:
// 즉, Unix Time을 얻기 위해 70년을 감해줍니다.
// 또한 이 시간을 epoch라고도 합니다.
epoch = secsSince1900 – seventyYears;
//Serial.print(“Unix time = “);
//Serial.println(epoch);
// stringOne에는 타임서버로부터 받은 unix epoch 타임 값이 들어가있다.
stringOne = String(epoch, DEC); // using a long and a base
************************************************************************
# NTP 타임 전문 생성 루틴:
1. 전문 생성목적
타임서버로부터 받아온 시간을 외부장치(전자시계, 서버 등등)에게 시리얼라인
으로 전송해주기 위해 GPS 수신기 등에서 사용하는 NMEA 전문 형태로 생상
하는 부분이다.
2. 전문의 형식 예(GPS신호와 매우 유사함)
$Wi-Fi,1470050489,myKT_WLAN,password,203.248.240.103*3A
[step1] [step2] [step3] [step4] [step5] [step6] ************************************************************************
// STEP1: 시리얼 버퍼에 “$Wi-Fi,” 를 시작 문자열로 발신하여 파싱이 일어나도록 한다.
sl = sizeof(wi_fiHeader) – 1; // null문자 위치 제거
pl = 0;
for (i = 0; i< sl; i++) {
LineBuffer[pl] = wi_fiHeader[i]; // copy to buffer : “$Wi-Fi,”
pl++;
}
LineBuffer[pl] = ‘,’; // 구분자를 추가한다.
pl++;
// STEP2: 시리얼버퍼에 “unix epoch 타임”을 어펜드한다.
sl = stringOne.length();
ct = 0;
while (sl) {
LineBuffer[pl] = stringOne[ct];
pl++; ct++;
sl–;
}
LineBuffer[pl] = ‘,’; // 구분자를 추가한다.
pl++;
// STEP3: 시리얼 버퍼에 SSID를 어펜드한다.
sl = sizeof(ssid) – 1; // null문자 위치 제거
for (i = 0; i< sl; i++) {
LineBuffer[pl] = ssid[i]; // copy to buffer : “ssid,”
pl++;
}
LineBuffer[pl] = ‘,’; // 구분자를 추가한다.
pl++;
// STEP4: 시리얼 버퍼에 wi-fi PASSWORD를 어펜드한다.
sl = sizeof(pass) – 1; // null문자 위치 제거
for (i = 0; i< sl; i++) {
LineBuffer[pl] = pass[i]; // copy to buffer : “pass,”
pl++;
}
LineBuffer[pl] = ‘,’; // 구분자를 추가한다.
pl++;
// STEP5: NTP 서버 IP주소를 파싱하여 어펜드한다.
timeServerIP = Udp.remoteIP();
for (i = 0; i<4; i++) {
//stringOne = String(timeServerIP[i], DEC);
stringOne = timeServerIP[i];
sl = stringOne.length();
ct = 0;
while (sl) {
LineBuffer[pl] = stringOne[ct];
pl++; ct++; sl–;
}
LineBuffer[pl] = ‘.’; pl++;
}
pl–; // IP주소의 맨 끝에 붙어있는 .은 제거 시켜 준다.
// STEP6: 체크섬을 계산한다.
calcchksum = 0;
for (i = 1; i < pl; i++) {
calcchksum = calcchksum ^ LineBuffer[i]; // USART 수신데이터로 직접 체크섬 계산
}
LineBuffer[pl] = ‘*’; pl++;
stringOne = String(calcchksum, HEX);
stringOne.toUpperCase();
LineBuffer[pl] = stringOne[0]; pl++;
LineBuffer[pl] = stringOne[1]; pl++;
// STEP7: 외부로 실제 전송을 단행한다.
for (i = 0; i< pl; i++) {
Serial.print(LineBuffer[i]);
}
Serial.println(“”);
//////////////////////////////////////////////////////////////////////////////////////
// DEBUG Code
// 아래는 이렇게 만들어진 시간값이 정말로 제대로 만들어 졌는지를 검증해보는 코드
// UTC시각은 그리니치천문대(Greenwich Meridian) 기준 시각이다. (GMT)
Serial.print(“The Local(Seoul, +9Hr) time is “);
setTime(epoch);
adjustTime(KOREA_TIME_ZONE_SEC); // 대한민국 시간대로 보정
Serial.print(year()); Serial.print(“/”);
Serial.print(monthStr(month())); Serial.print(“/”);
Serial.print(day());
Serial.print(“[");
Serial.print(hour()); Serial.print(":");
Serial.print(minute()); Serial.print(":");
Serial.print(second());
Serial.println("]“);
hours = hour();
minutes = minute();
seconds = second();
//////////////////////////////////////////////////////////////////////////////////////

cycleCounter = 0;
myTimer0 = TickGet();
TASKState = SM_NEXT;
break;
case SM_NEXT:
// 10초 간격으로 한번씩 동기화를 시도한다.
// STATUSLED가 1초마다 한번씩 점멸이 된다면 여기까지의 루프가 잘 돌고 있음을 의미
if (TickGet() – myTimer0 > TICK_100mS * 5UL) {
myTimer0 = TickGet();
if (ledState == LOW)
ledState = HIGH; // Note that this switches the LED *off*
else
ledState = LOW; // Note that this switches the LED *on*
digitalWrite(STATUSLED, ledState);
cycleCounter++;
// 타임서버로 부터 시간을 받아오는 주기를 설정한다.
// *2를 한것은 cycleCounter가 0.5초 단위로 증가하기 때문이다.
if (cycleCounter > NTP_REFRESH_SECS * 2) {
cycleCounter = 0;
// 연결이 성공적으로 잘되어 있는지 재검사하여 이상없으면 다음 작업을 속행
if (WiFi.status() == WL_CONNECTED) {
TASKState = SM_SEND_NTP;
}else {
// 만일 연결에 문제가 생기면 재접속 프로세스 진행
TASKState = SM_HOME;
}
}
}
break;
}
}

// send an NTP request to the time server at the given address
unsigned long sendNTPpacket(char *ntpSrv)
{
// set all bytes in the buffer to 0
memset(packetBuffer, 0, NTP_PACKET_SIZE);
// Initialize values needed to form NTP request
// (see URL above for details on the packets)
packetBuffer[0] = 0b11100011; // LI, Version, Mode
packetBuffer[1] = 0; // Stratum, or type of clock
packetBuffer[2] = 6; // Polling Interval
packetBuffer[3] = 0xEC; // Peer Clock Precision
// 8 bytes of zero for Root Delay & Root Dispersion
packetBuffer[12] = 49;
packetBuffer[13] = 0x4E;
packetBuffer[14] = 49;
packetBuffer[15] = 52;

// all NTP fields have been given values, now
// you can send a packet requesting a timestamp:
Udp.beginPacket(ntpSrv, 123); //NTP requests are to port 123
Udp.write(packetBuffer, NTP_PACKET_SIZE);
Udp.endPacket();
return 1;
}

unsigned long TickGet()
{
return millis();
}