(cache) DSAS開発者の部屋:ネットワーク対応の光通知デバイスを自作してみる

2016年01月01日

ネットワーク対応の光通知デバイスを自作してみる

「blink(1)」のこと

コードネームのような製品名ですが、「blink(1)」は KickStarter 発のカスタマイズ可能な USB デバイスです。接続先の機器やネットワークから所定の情報を受けとると LED 光の色や明滅により人間への通知を行うもので、2012年に製品化され 2013年には IFTTT との連携機能を強化した blink(1) mk2 がリリースされています。

文字の情報は人間が意識的にそこに向き合わなければ伝わらず、音の情報は状況により場の環境を乱す可能性があります。一方、「光」による情報はそれが適度な輝度であれば他の何かを妨げることなく人間の視界へ届き自然に認識され得ます。そのことを応用した例は他にも見られますが、blink(1) もまた光の特性を活かした機器のひとつです。


www.kickstarter.com	gigazine.net	gigazine.net

※詳細なレポートが GIGAZINE 様の以下の一連の記事に掲載されています。

この blink(1)、なかなか楽しそうなので使ってみたいと思いました。ただ、日本国内には今のところ代理店がなく国外のマーケットから購入することになりますが、これが * 微妙に高価 * なのですね。

Buy blink(1) - blink1.thingm.com
- Blink(1) mk2 USD $30.00 - www.seeedstudio.com
Blink (1) mk2 - www.ebay.com
blink(1) mk2 紹介とunboxing - 「いずみはらあつし (id:AMANE)」様のブログ「自習室」より

そこで、一連の機能の中でもっとも興味のあるネットワーク連携部分を自作してみることにしました。どこかで何かがあったら知らせるというのはまさに IoT 向きのテーマであり、また、普段は主にバイプレイヤーである LED が一躍主役となるちょっと面白いケースでもあります。装置は「Wi-Fi 機能つきの小さなマイコン」としてこのところ何かと重宝している ESP8266 モジュールをメインに構成すれば手近な素材のみでも USB ポートへ直挿し可能なサイズに収めることが可能でしょう。装置へのメッセージング用のソリューションには今回 PubNub を選びました。

PubNub のこと / ESP8266 との関係

PubNub は Pub/Sub モデルのリアルタイムメッセージング機能を主軸とする BaaS です。 2010年のローンチ以来スマホや Web アプリ向けのプッシュ通知サービス等を展開、近年は IoT 方面にも注力しており対応言語・環境の広い有用なプラットフォームのひとつです。サポート対象は現在も拡大中、ちなみに無料枠もなかなかの太っ腹です。

Realtime Development Resources, Tutorials & SDKs for Realtime Apps - www.pubnub.com

（2015年12月現在 80超の言語・環境に対応ｰｰクリックで可読大表示）

Internet of Things | PubNub - www.pubnub.com

Pricing Plans - PubNub - www.pubnub.com

アプリにリアルタイムメッセージング機能を簡単に導入できるPubNubが$4.5Mを調達 (2012-03-22) - jp.techcrunch.com

mBaaSも活躍！ユニークなIoTが誕生する世界のハッカソン (2015-07-13) - iot.mb.cloud.nifty.com

また、GET リクエストベースの REST API セットが用意されており（HTTPS, HTTP）、これを利用すれば他のシステムやデバイスからも PubNub の所定の Channel へ柔軟にメッセージを送ることが可能です。

HTTP REST Push API | PubNub - www.pubnub.com

このように便宜の大きい PubNub ですが、この記事を書いている 2015年12月時点では実は肝心の ESP8266 がまだサポートされていません。でも幸い非公式のクライアントライブラリが公開されていることを知りました。本家の GitHub リポジトリにも fork されていることから非公式ながらも公認の位置づけのようです。

pubnub-esp8266 (forked from Kurt-E-Clothier/pubnub-esp8266) - github.com/pubnub
Basic IoT Publish/Subscribe Messaging for ESP8266 (By Kurt Clothier) - www.pubnub.com

上の記事のとおりこの非公式ライブラリは任意のタイミングでの双方向通信には対応していない（subscribe() 呼び出し後の受信完了前には publish() 不可）ものの、今回想定している装置はもっぱら受信側であるため特に支障はなさそうです。作者の Kurt Clothier さん自身が「can be adjusted for a particular need」と書いているようにライブラリコードは用途に応じ適宜手を加えて利用すれば良いでしょう。
なお、このライブラリは Espressif 社による純正の ESP8266 SDK 向けに記述されています。より扱いやすい Arduino IDE for ESP8266 環境でも利用できるように併せて手を加えることにしました。

試作の動作の様子（動画：1分11秒環境音・操作音あり）

下の動画は、作成した装置へ PubNub の Web コンソールからメッセージを送り動作を確認している様子です。各メッセージはそれぞれ一行の REST API 記述に置き換えることができます。

手元での現在の使途

手元ではこの試作を下記の要領で使用中。「光による通知」が想像以上に便利で実用的であることを実感しています。スマートさや表現性は blink(1) に及ばないものの必要になれば好きなようにいじれることが手作りの利点ですね。

黄点灯：明日の予報が雨の場合
（IFTTT レシピを利用）
　クリックで可読大表示
ありがちなテーマだが実際に使ってみると手放せなくなる。好天続きで何となく油断している折に不意に点灯を目にしたら直ちに予報をチェック。
青点滅：高齢者世帯の安否確認装置に反応があった場合
（Parse.com サーバサイドの Cloud Code を利用）
　クリックで可読大表示
人を検知すると最短 30分間隔で Parse.com へレポートを送出する自作装置を実家で稼働中。対向するサーバ側コードに試作への通知処理を追加。光れば安心、メールによる通知よりも即時性が高く煩雑感が小さい。
赤点滅：特定のユーザからのツイートがあった場合
（IFTTT レシピを利用）
　クリックで可読大表示
件数は少ないがいつも非常に有用な情報を提供してくれる某氏のツイートを見落とさないために。
緑点滅：所定のブログが更新された場合
（IFTTT レシピを利用）
　クリックで可読大表示
とりあえず昨年末「KLab Advent Calendar 2015」のチェック用に使ってみたらとても快適。
管理用 HTML フォーム

　クリックで可読大表示
PC・スマホの Web ブラウザから装置へメッセージを手早く簡単に送るために用意。　[ソース]

装置について

外観と構成

クリックで可読大表示

材料

ESP8266 モジュール　 CDP-ESP8266 - Cerevo　￥842（税別）
ブレッドボード　 EIC-15010 - スイッチサイエンス　￥216（税込）
ケーブル取付用ＵＳＢコネクタ（Ａタイプ　オス） - 秋月　￥70（税込）
低損失三端子レギュレーター　３．３Ｖ５００ｍＡ　ＴＡ４８Ｍ０３３Ｆ（Ｓ　Ｑ） - 秋月　￥100（税込）
※ノイズ除去用・電圧安定用のコンデンサ 2個が同梱
ＬＥＤ光拡散キャップ（３ｍｍ）　白　（２０個入） - 秋月　￥100（税込）
ハイパワー青色ＬＥＤ　３ｍｍ　ＯＳＵＢ３１３１Ｐ　１０個入 - 秋月　￥250（税込）
３ｍｍ　緑色ＬＥＤ　ＥＢＧ３４０２Ｓ　（２０個入） - 秋月　￥100（税込）
３ｍｍ黄色ＬＥＤ　５９０ｎｍ　ＯＳＹ５ＣＡ３１３１Ｐ（１０個入） - 秋月　￥200（税込）
赤色ＬＥＤ　３ｍｍ　ＯＳＤＲ３１３３Ａ　５００ｍｃｄ　３０度１００個入 - 秋月　￥350（税込）
カーボン抵抗・ジャンプワイヤ・タクトスイッチ・熱収縮チューブ
タッパ・輪ゴム・エアキャップ

メモ

blink(1) は PC など対応機器の機能を利用するが今回の装置はネットワーク専用であり通信機能を内蔵しているため USB AC アダプタでも使える
USB 端子は規格上両端の2本が 5V (500mA) OUT と GND
フルカラー LED ではなく赤・緑・青・黄の 4つの単色 LED を使用。LED 用の抵抗は現物の発色をみながら「赤 75Ω 緑 75Ω 青 470Ω 黄 390Ω」に
LED の表示は各色「点灯・点滅」の二種類で合計 8パターン。これは手元での実利用を想定し妥当と判断した数
（複数 LED の点滅時は明滅のタイミングが重ならないようプログラム側で管理）
輪ゴムは USB コネクタ外抜け防止用
エアキャップはタッパ蓋の下に中敷き。LED 光拡散、外観柔和化、USB コネクタとタクトスイッチの圧迫用
タッパ蓋の上からタクトスイッチを押すと装置がリセットされる。電源接続時と LED 消灯用に使う

プログラムについて

ESP8266 用 PubNub ライブラリ

前述のように現時点では PubNub は ESP8266 を正式にサポートしておらず Espressif 社純正 SDK 向けの非公式ライブラリが公開されているのみです。これに以下の要領で手を加えて使用しています。

Arduino IDE で利用できるように

publish() の完了通知用にコールバックを登録可能に

HTTPS 対応

以下にソースコードを掲載します。ライブラリ「pubnub-esp8266」はファイル一式をローカルの Arduino ライブラリフォルダ下の pubnub-esp8266/ 下へコピーして使います。

（キーワード "DSAS" 部分がオリジナルからの変更箇所）

pubnub.h - GitHub

/***************************************************************************
* 
* File              : pubnub.h
* Author			: Kurt E. Clothier
* Date				: June 17, 2015
* Modified			: June 25, 2015
*
* Description       : Pubnub header file
*
* Compiler			: Xtensa Tools - GCC
* Hardware			: ESP8266
*
* Preprocessor Info	: http://gcc.gnu.org/onlinedocs/gcc-2.95.3/cpp_1.html
* More Information	: http://www.pubnub.com/
*					: http://www.esp8266.com/
*
****************************************************************************/
//
// The original program is written by Kurt E. Clothier.
// https://github.com/Kurt-E-Clothier/pubnub-esp8266/tree/master/esp8266-hellworld-demo/pubnub
//
// revised by TANABE Makoto (portion of the "DSAS" identifier)
//
// - Corresponding to "Arduino IDE for ESP8266"
//   https://github.com/esp8266/Arduino/
//
// - Enable to specify the callback function for completion of pubnub_publish()
//
// - Corresponding to HTTPS
//
// 2015 KLab Inc.
//

#ifndef _PUBNUB_H_
#define _PUBNUB_H_

#define DSAS
/**************************************************************************
	Included Files
***************************************************************************/
#ifdef DSAS
#include <ESP8266WiFi.h>
#else
#include "esp8266.h"
#endif
#include "string.h"

#ifdef DSAS
#define USE_SSL
#define SSL_BUFFER_SIZE  8192

extern "C" {
#include "c_types.h"
#include "ip_addr.h"
#include "os_type.h"
#include "user_interface.h"
#include "osapi.h"
#include "espconn.h"
#include "mem.h"
}

#define IFA ICACHE_FLASH_ATTR

// Define to print debug statements over UART using DEBUG_PRINT()
//#define DEBUG_PRINT_	1

// Only prints lines for debugging purposes
#ifdef DEBUG_PRINT_
#	define DEBUG_PRINT(S)	os_printf S
//#	define DEBUG_PRINT	Serial.printf
#else
#	define DEBUG_PRINT
#endif

#define sprintf os_sprintf
#define espconn_send espconn_sent
#define espconn_secure_send espconn_secure_sent
#endif // DSAS

/**************************************************************************
	Definitions
***************************************************************************/
#define PUBNUB_ORIGIN	"pubsub.pubnub.com"
#if defined(DSAS) && defined(USE_SSL)
#define PUBNUB_DOMAIN	"https://pubsub.pubnub.com"
#define PUBNUB_ORIGIN_PORT	443
#else
#define PUBNUB_DOMAIN	"http://pubsub.pubnub.com"
#define PUBNUB_ORIGIN_PORT	80
#endif

#define PUBNUB_CHANNEL_MAXLEN	128
#define PUBNUB_BUF_MAXLEN		256
#define PUBNUB_REPLY_MAXLEN		512

#define PUBNUB_CTX_MAX	2

#define PUBNUB_TIMER_VALUE	100


/**************************************************************************
	Custom Types and Structures
***************************************************************************/

typedef void (*Pubnub_subscribeCB)(char *message);
#ifdef DSAS
typedef void (*Pubnub_publishCB)(char *message);
#endif

// Espconn connection type
typedef struct espconn Espconn;

// Pubnub Transaction States
enum pubnub_trans {
	PBTT_NONE,		// No Transactions at all
	PBTT_INIT_SUB,	// Initial subscribe to get timetoken
	PBTT_SUBSCRIBE,	// Subscribe Transaction
	PBTT_PUBLISH,	// Publish Transaction
	PBTT_LEAVE,		// Leave (channel(s)) transaction
};

// Pubnub States
enum pubnub_state {
	PS_IDLE,			// Line is Idle
	PS_WAIT_DNS,		// Waiting for DNS 
	PS_WAIT_CONNECT,	// Connected
	PS_WAIT_SEND,		// Waiting for message to send
	PS_WAIT_RECV,		// Waiting for message to be received
	PS_RECV,			//
};

// Pubnub Last Result Codes
enum pubnub_res {
    PNR_OK,					// Success - transaction finished successfully
    PNR_TIMEOUT,			// Time out before the request has completed
    PNR_IO_ERROR,			// Communication error (network or HTTP response format)
    PNR_HTTP_ERROR,			// HTTP error
    PNR_FORMAT_ERROR,		// Undexpected input in received JSON
    PNR_CANCELLED,			// Request cancelled by user
    PNR_STARTED,			// Transaction started, await the outcome via process message
    PNR_IN_PROGRESS,		// Transaction (already) ongoing, can't start a new trans
    PNR_RX_BUFF_NOT_EMPTY,	// Recv buffer (from last trans) not read, new subscription no allowed
    PNR_TX_BUFF_TOO_SMALL	// The buffer is too small, need to increease #PUBNUB_BUF_MAXLEN
};

// Pubnub Structure - holds all relevant keys and attriutes
typedef struct pubnub {
	const char *publish_key, *subscribe_key;
	const char *uuid, *auth;
	const char *subscribe_channel;
	char timetoken[64];
	
	enum pubnub_res last_result;	// Result of last Pubnub transaction
	enum pubnub_trans trans;		// transaction state
	enum pubnub_state state;		// pubnub state

	// These buffers hold information about http GET messages and replies
	char http_msgOut[PUBNUB_BUF_MAXLEN];
	char http_reply[PUBNUB_REPLY_MAXLEN];
	char http_msgIn[PUBNUB_REPLY_MAXLEN];
	unsigned http_len;

	// These buffers hold data from the last attpemted publish
	char publish_message[PUBNUB_BUF_MAXLEN];
	char publish_channel[PUBNUB_CHANNEL_MAXLEN];

	Pubnub_subscribeCB	subscribeCB;
#ifdef DSAS
	Pubnub_publishCB publishCB;
#endif
	
    /* These in-string offsets are used for yielding messages received
     * by subscribe - the beginning of last yielded message and total
     * length of message buffer, and the same for channels.
     */
    unsigned short msg_ofs, msg_end, chan_ofs, chan_end;
} pubnub_t, Pubnub;


/**************************************************************************
	PubNub Client API
***************************************************************************/

/** 
 * Creates a connection to Pubnub
 * This should be called when a network connection is established!
 */
void IFA pubnub_connect(void);


/** 
 * Initialize the PubNub Connection
 *
 * @param	*publish_key		publish key to use in this connection
 * @param	*subscribe_key		subscribe_key key to use in this connection
 */
void IFA pubnub_init(const char *publish_key, const char *subscribe_key);


/** 
 * Publish message on channel using Pubnub.
 * JSON type message should be used, Unicode characters are injected automatically...
 * Example:
 *	sprintf(buffer, "\"TEXT\"");
 *		-- OR --
 *	sprintf(buffer, "{\"TEXT\":[[\"TEXT\", \"%d\"]]}", variable);
 *		-- THEN --
 *	pubnub_publish(channel, buffer);
 *
 * @param	*channel		pubnub channel where message is published
 * @param	*message		message to be published
 * @return					<tt>true</tt> if no errors encountered
 */
#ifdef DSAS
bool IFA pubnub_publish(const char *channel, const char *message, Pubnub_publishCB pubCB);
#else
bool IFA pubnub_publish(const char *channel, const char *message);
#endif

/** 
 * Subscribe to a Pubnub channel
 *	- typedef void (*Pubnub_subscribeCB)(char *message);
 *
 * Due to the limitations of single-threading, this function
 *	must be called manually each time a subscribe is desired.
 *
 * The library can be altered to automatically handle the subscriptions,
 *	but you lose the ability to publish at will.
 *
 * @param	*channel			pubnub channel to listen on
 * @param	Pubnub_subscribeCB	callback for subscribe events
 *			
 * @return		<tt>true</tt> on successful subscribe
 */
bool IFA pubnub_subscribe(const char *channel, Pubnub_subscribeCB subCB);


/** 
 * Unsubscribe to a Pubnub channel
 *
 * @param	*channel		pubnub channel to stop listening on
 * @return					<tt>false</tt> if channel not found
 */
bool IFA pubnub_unsubscribe(const char *channel);


#endif	//_PUBNUB_H_

pubnub.cpp - GitHub

/***************************************************************************
* 
* File              : pubnub.c
* Author			: Kurt E. Clothier
* Date				: June 17, 2015
* Modified			: June 25, 2015
*
* Description       : Pubnub Library
*
* Compiler			: Xtensa Tools - GCC
* Hardware			: ESP8266
*
* More Information	: http://www.pubnub.com/
*					: http://www.esp8266.com/
*
****************************************************************************/
//
// The original program is written by Kurt E. Clothier.
// https://github.com/Kurt-E-Clothier/pubnub-esp8266/tree/master/esp8266-hellworld-demo/pubnub
//
// revised by TANABE Makoto (portion of the "DSAS" identifier)
//
// - Corresponding to "Arduino IDE for ESP8266"
//   https://github.com/esp8266/Arduino/
//
// - Enable to specify the callback function for completion of pubnub_publish()
//
// - Corresponding to HTTPS
//
// 2015 KLab Inc.
//

/**************************************************************************
	Included Files
***************************************************************************/
#include "pubnub.h"

/**************************************************************************
	Global Variables
***************************************************************************/
static Pubnub *pb;
static Espconn *pb_conn;
static volatile bool subscribed;
static volatile bool publishRequest;

/**************************************************************************
	Local Function Prototypes
***************************************************************************/
static void IFA resetTimetoken(void);
static int IFA find_string_start(char const *buf, int len);
static bool IFA split_array(char *buf);
static int IFA parse_subscribe_response(void);
static bool IFA pubnub_autoSubscribe(void);

// Network Callbacks
static void IFA pubnub_dnsFoundCB(const char *name, ip_addr_t *ip, void *arg);
static void IFA pubnub_conCB(void *arg);
static void IFA pubnub_disconCB(void *arg);
static void IFA pubnub_reconCB(void *arg, sint8 err);
static void IFA pubnub_recvCB(void *arg, char *data, unsigned short len);
static void IFA pubnub_sentCB(void *arg);
static void IFA pubnub_httpGet(const char *m);

#ifdef DSAS
static Espconn espconn;
static Pubnub pubnub;
#endif

/**************************************************************************
	Network Callback Functions
***************************************************************************/

/** 
 * Creates a connection to Pubnub
 * This should be called when a network connection is established!
 */
void IFA pubnub_connect(void)
{
#ifdef DSAS
	pb_conn = &espconn;
#else
	pb_conn = (Espconn *)os_zalloc(sizeof(Espconn)); 
#endif
	static ip_addr_t ip;
	DEBUG_PRINT(("Looking up Pubnub server...\n"));
	espconn_gethostbyname(pb_conn, PUBNUB_ORIGIN, &ip, pubnub_dnsFoundCB);
}

/** 
 * Callback : DNS Resolved
 *
 * @param	*name		resolved host name
 * @param	*ip			ip address resolved from hostname
 * @param	*arg		espconn connection type
 */
static void IFA pubnub_dnsFoundCB(const char *name, ip_addr_t *ip, void *arg)
{
	static esp_tcp tcp;

	// Make sure this actually worked...
	if (ip == NULL) {
		DEBUG_PRINT(("Nslookup failed :/ Trying again...\n\r"));
		//network_init();
	}

	// Make sure this is coming from Pubnub connection
	else if( 0 != strcmp(name, PUBNUB_ORIGIN) ) {
		DEBUG_PRINT(("DNS Error: Non-PubNub!\n\r"));
	}

	// Everything is OK, so setup connection	
	else {

		pb_conn = (struct espconn *)arg;
		DEBUG_PRINT(("Server found!\n\r"));

		// Espconn attributes
		pb_conn->type=ESPCONN_TCP;
		pb_conn->state=ESPCONN_NONE;
		pb_conn->proto.tcp=&tcp;
		pb_conn->proto.tcp->local_port=espconn_port();
		pb_conn->proto.tcp->remote_port = PUBNUB_ORIGIN_PORT;
		os_memcpy(pb_conn->proto.tcp->remote_ip, &ip->addr, 4);
		
		// Register Callbacks
		espconn_regist_connectcb(pb_conn, pubnub_conCB);
		espconn_regist_disconcb(pb_conn, pubnub_disconCB);
		espconn_regist_reconcb(pb_conn, pubnub_reconCB);
		espconn_regist_recvcb(pb_conn, pubnub_recvCB);
		espconn_regist_sentcb(pb_conn, pubnub_sentCB);
#if defined(DSAS) && defined(USE_SSL)
		espconn_secure_set_size(ESPCONN_CLIENT, 8192); 
		espconn_secure_connect(pb_conn);
#else
		espconn_connect(pb_conn);
#endif
		pb->state = PS_WAIT_CONNECT;
	}
}

/** 
 * Callback: Connection Established
 *
 * @param	*arg		espconn connection type
 */
static void IFA pubnub_conCB(void *arg)
{
	DEBUG_PRINT(("\n\rConnected to Pubnub\r\n"));
	pb->last_result = PNR_OK;
	pb->state = PS_WAIT_SEND;
	pubnub_httpGet("");
}

/** 
 * Callback: Disconnected
 *
 * @param	*arg		espconn connection type
 */
static void IFA pubnub_disconCB(void *arg)
{
	DEBUG_PRINT(("\n\rDisconnected or connection error!\n\r"));
	pb->state = PS_IDLE;
	pb->last_result = PNR_IO_ERROR;
	// Attemp to reconnect...
	pubnub_connect();
}

/** 
 * Callback: Reconnected
 *
 * @param	*arg		espconn connection type
 * @param	err			error
 */
static void IFA pubnub_reconCB(void *arg, sint8 err)
{
	DEBUG_PRINT(("\n\rReconnect\n\r"));
	pb->last_result = PNR_OK;
	pb->state = PS_WAIT_SEND;
	pubnub_httpGet("");
}

/** 
 * Callback: Data sent
 *
 * @param	*arg		espconn connection type
 */
static void IFA pubnub_sentCB(void *arg)
{
	DEBUG_PRINT(("Data Sent\n\r"));

	if(pb->state == PS_WAIT_SEND) {
		pb->state = PS_WAIT_RECV;
		DEBUG_PRINT(("Waiting for reply...\n\r"));
	}
}

/** 
 * Callback: Data received
 *
 * @param	*arg		espconn connection type
 * @param	*data		data received
 * @param	len			length of data received
 */
static void IFA pubnub_recvCB(void *arg, char *data, unsigned short len)
{
	DEBUG_PRINT(("Data Received:\n\r%s\n\r", data));
	pb->state = PS_IDLE;
	pb->last_result = PNR_OK;

	switch(pb->trans) {
	
		case PBTT_PUBLISH:
			pb->state = PS_IDLE;
			pb->last_result = PNR_OK;
#ifdef DSAS
			// User Callback Function
			pb->publishCB(pb->http_msgOut);
#endif
			break;

		case PBTT_INIT_SUB:
			memcpy(pb->http_reply, data, len);
			parse_subscribe_response();

			pb->last_result = PNR_OK;
			pb->state = PS_IDLE;

			// Subscribe again with valid timetoken
			pubnub_autoSubscribe();
			break;

		case PBTT_SUBSCRIBE:
			memcpy(pb->http_reply, data, len);
			parse_subscribe_response();

			pb->last_result =PNR_OK;
			pb->state = PS_IDLE;

			// User Callback Function
			pb->subscribeCB(pb->http_msgIn);
			break;

		case PBTT_NONE:
		case PBTT_LEAVE:
		default:
			break;
	}

	// Automatically republish last skipped message
	if(publishRequest)
#ifdef DSAS
		pubnub_publish(pb->publish_channel, pb->publish_message, pb->publishCB);
#else
		pubnub_publish(pb->publish_channel, pb->publish_message);
#endif
	// Uncomment the following to automatically subscribe to the channel!
	//else if (subscribed)
		//pubnub_autoSubscribe();
}

/** 
 * Issue HTTP GET Request
 */
static void IFA pubnub_httpGet(const char *m)
{
	char buf[PUBNUB_BUF_MAXLEN] = { 0, };			
	sprintf( buf, 
		"GET %s/%s HTTP/1.1\r\nHost: %s\r\nUser-Agent: PubNub-ESP8266\r\nConnection: Keep-Alive\r\n\r\n", 
		PUBNUB_DOMAIN, m, PUBNUB_ORIGIN);
	DEBUG_PRINT(("\nSent: %s\n", buf));
#ifdef DSAS
#ifdef USE_SSL
	espconn_secure_send(pb_conn, (uint8*)buf, strlen(buf));
#else
	espconn_send(pb_conn, (uint8*)buf, strlen(buf));
#endif
#else
	espconn_send(pb_conn, buf, strlen(buf));
#endif
}


/**************************************************************************
	PUBNUB API
***************************************************************************/

/** 
 * Initialize the PubNub Connection
 *
 * @param	*publish_key		publish key to use in this connection
 * @param	*subscribe_key		subscribe_key key to use in this connection
 */
void IFA pubnub_init(const char *publish_key, const char *subscribe_key)
{
	DEBUG_PRINT(("\n\nInitializing Pubnub\n"));
#ifdef DSAS
	pb = &pubnub;
#else
	pb = (Pubnub *)os_zalloc(sizeof(Pubnub)); 
#endif
	resetTimetoken();
	pb->publish_key = publish_key;
	pb->subscribe_key = subscribe_key;
	pb->subscribe_channel = NULL;
	pb->uuid = "ESP8266";
	pb->auth = NULL;
	pb->state = PS_WAIT_DNS;
	pb->last_result = PNR_IO_ERROR;
}

/** 
 * Publish message on channel using Pubnub.
 * JSON type message should be used, Unicode characters are injected automatically...
 * Example:
 *	sprintf(buffer, "\"TEXT\"");
 *		-- OR --
 *	sprintf(buffer, "{\"TEXT\":[[\"TEXT\", \"%d\"]]}", variable);
 *		-- THEN --
 *	pubnub_publish(channel, buffer);
 *
 * @param	*channel			pubnub channel where message is published
 * @param	*message			message to be published
 * @return						<tt>true</tt> if no errors encountered
 */
#ifdef DSAS
bool IFA pubnub_publish(const char *channel, const char *message, Pubnub_publishCB pubCB)
{
	pb->publishCB = pubCB;
#else
bool IFA pubnub_publish(const char *channel, const char *message)
{
#endif
	if(pb->state != PS_IDLE) {
		if (pb->trans == PBTT_SUBSCRIBE && pb->state == PS_WAIT_RECV) {
			DEBUG_PRINT(("\nWaiting on subscription(s)!\n"));
		}
		else {
			DEBUG_PRINT(("\nLine busy, Publish delayed...\n"));
		}
		publishRequest = true;
		sprintf(pb->publish_channel, "%s", channel);
		sprintf(pb->publish_message, "%s", message);
		return false;

	}

	publishRequest = false;

	pb->trans = PBTT_PUBLISH;
#ifdef DSAS
	pb->http_len = sprintf(pb->http_msgOut, "publish/%s/%s/0/%s/0/\"%s\"", 
								pb->publish_key, pb->subscribe_key, channel, message);
#else
	pb->http_len = sprintf(pb->http_msgOut, "publish/%s/%s/0/%s/0/", 
								pb->publish_key, pb->subscribe_key, channel);

	const char *pmessage = message;
	
	while(pmessage[0]) {
		// RFC 3986 Unreserved characters plus few safe reserved ones.
		size_t okspan = strspn(pmessage, 
			"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_.~" ",=:;@[]");
		if(okspan > 0) {
			if(okspan > sizeof(pb->http_msgOut)-1 - pb->http_len) {
				pb->http_len = 0;
				return false;
			}
			
			memcpy(pb->http_msgOut + pb->http_len, pmessage, okspan);
			pb->http_len += okspan;
			pb->http_msgOut[pb->http_len] = 0;
			pmessage += okspan;
		}
		
		if(pmessage[0]) {
			// %-encode a non-ok character. 
			char enc[4] = {'%',};
			enc[1] = "0123456789ABCDEF"[pmessage[0] / 16];
			enc[2] = "0123456789ABCDEF"[pmessage[0] % 16];
			if(3 > sizeof(pb->http_msgOut) - 1 - pb->http_len) {
				pb->http_len = 0;
				return false;
			}
			memcpy(pb->http_msgOut + pb->http_len, enc, 4);
			pb->http_len += 3;
			++pmessage;
		}
	}
#endif
	if(pb->last_result == PNR_OK) {
		pb->state = PS_WAIT_SEND;
		pubnub_httpGet(pb->http_msgOut);
	}
	else {
		DEBUG_PRINT(("PB Last Result Error!\n\r"));
		return false;
	}
	
	return true;
};

/** 
 * Automatically handle subsription
 *
 * @return			<tt>true</tt> if no errors encountered
 */
static bool IFA pubnub_autoSubscribe(void)
{
	if(pb->state != PS_IDLE) {
		return false;
	}

	// First, we have to get a valid timetoken
	if (pb->timetoken[1] == '\0')
		pb->trans = PBTT_INIT_SUB;
	else	
		pb->trans = PBTT_SUBSCRIBE;
	
	memset(pb->http_reply, 0, PUBNUB_REPLY_MAXLEN);	
	
	pb->http_len = sprintf(pb->http_msgOut, 
		"/subscribe/%s/%s/0/%s?" "%s%s" "%s%s%s" "&pnsdk=ESP8266%s%%2F%s",
		pb->subscribe_key, 
		pb->subscribe_channel, 
		pb->timetoken,
		pb->uuid ? "uuid=" : "", 
		pb->uuid ? pb->uuid : "",
		pb->uuid && pb->auth ? "&" : "",
		pb->uuid && pb->auth ? "auth=" : "", 
		pb->uuid && pb->auth ? pb->auth : "",
		"", "0.1");
	
	if(pb->last_result == PNR_OK) {
		pb->state = PS_WAIT_SEND;
		pubnub_httpGet(pb->http_msgOut);
	}
	else {
		DEBUG_PRINT(("PB Last Result Error!\n\r"));
		return false;
	}
	
	return true;
}

/** 
 * Subscribe to a Pubnub channel
 *	- typedef void (*Pubnub_subscribeCB)(char *message);
 *
 * @param	*channel			pubnub channel to listen on
 * @param	Pubnub_subscribeCB	callback for subscribe events
 *			
 * @return		<tt>true</tt> on successful subscribe
 */
bool IFA pubnub_subscribe(const char *channel, Pubnub_subscribeCB subCB)
{
	pb->subscribe_channel = channel;
	pb->subscribeCB = subCB;
	subscribed = true;
	return pubnub_autoSubscribe();
}

/** 
 * Unsubscribe to a Pubnub channel
 *
 * @param	*channel		pubnub channel to stop listening on
 * @return					<tt>false</tt> if channel not found
 */
bool IFA pubnub_unsubscribe(const char *channel)
{
	if(strcmp(channel, pb->subscribe_channel) == 0) {
		pb->subscribe_channel = NULL;
		pb->subscribeCB = NULL;
		subscribed = false;
		// should really issue a "leave"
		// DOMAIN/v2/presence/sub_key/demo/channel/my_channel/leave?uuid=MyUUID
		return true;
	}
	return false;
}


/**************************************************************************
	Local Utilities
***************************************************************************/

/**
 * Reset timetoken
 */
static void IFA resetTimetoken(void)
{
	pb->timetoken[0] = '0';
	pb->timetoken[1] = '\0';
}

/**
 * Find the beginning of a JSON string that comes 
 *		after comma and ends at @c &buf[len].
 *
 * @return position (index) of the found start or -1 on error.
 */
static int IFA find_string_start(char const *buf, int len)
{
    int i;
    for (i = len-1; i > 0; i--) {
        if (buf[i] == '"') {
            return (buf[i-1] == ',') ? i : -1;
		}
    }
    return -1;
}


/**
 * Split @p buf string containing a JSON array (with arbitrary
 *		contents) to multiple NUL-terminated C strings, in-place.
 */
static bool IFA split_array(char *buf)
{
    bool escaped = false;
    bool in_string = false;
    int bracket_level = 0;

    for (; *buf != '\0'; ++buf) {
        if (escaped) {
            escaped = false;
        } 
		else if ('"' == *buf) {
		    in_string = !in_string;
		}
		else if (in_string) {
			escaped = ('\\' == *buf);
			}
		else {
			switch (*buf) {
			case '[': case '{': bracket_level++; break;
			case ']': case '}': bracket_level--; break;
                // if at root, split! 
			case ',': if (bracket_level == 0) *buf = '\0'; break;
			default: break;
			}
		}
    }
    return !(escaped || in_string || (bracket_level > 0));
}

/**
 * Parse response from Subscribe call
 */
static int IFA parse_subscribe_response(void)
{
    char *reply = pb->http_reply;
    int replylen = strlen(reply);

    if (reply[replylen-1] != ']' && replylen > 2) {
        replylen -= 2;
    }
    if ((reply[replylen-1] != ']') || (reply[replylen-2] != '"')) {
        return -1;
    }

    // Extract the last argument.
    int i = find_string_start(reply, replylen-2);
    if (i < 0) {
        return -1;
    }

    reply[replylen - 2] = 0;

    // Now, the last argument may either be a timetoken or a channel list.
    if (reply[i-2] == '"') {
        int k;
        // It is a channel list, there is another string argument in front
        //		of us. Process the channel list ...
        pb->chan_ofs = i+1;
        pb->chan_end = replylen - 1;
        for (k = pb->chan_end - 1; k > pb->chan_ofs; --k) {
            if (reply[k] == ',') {
                reply[k] = 0;
	    }
	}

    // ... and look for timetoken again.
	reply[i-2] = 0;
        i = find_string_start(reply, i-2);
        if (i < 0) {
            return -1;
        }
    } 
    else {
        pb->chan_ofs = 0;
        pb->chan_end = 0;
    }

    // Now, i points at
    // [[1,2,3],"5678"]
    // [[1,2,3],"5678","a,b,c"]
    //          ^-- here

	//Extract message
	int j;
	for(j = 0; j < i; ++j) {
		if(reply[j] == '[') {
			if(reply[j+1] == '[') {
				// Found start of message
				j += 2;
				break;
			}
		}
	}
	memcpy(pb->http_msgIn, reply + j, (i - j - 2));
	pb->http_msgIn[(i-j-2)] = '\0';


    // Setup timetoken.
    if (replylen-2 - (i+1) >= sizeof pb->timetoken) {
        return -1;
    }
    strcpy(pb->timetoken, reply + i+1);
    reply[i-2] = 0; // terminate the [] message array (before the ]!)

    // Set up the message list - offset, length and NUL-characters splitting
    //		the messages.
    pb->msg_ofs = 2;
    pb->msg_end = i-2;

    return split_array(reply + pb->msg_ofs) ? 0 : -1;
}

Arduino スケッチ

アプリ側のコードです。Arduino の SimpleTimer ライブラリを併用しています。

LEDMessage.ino - GitHub

#include <pubnub.h>
#include <ESP8266WiFi.h>
#include <SimpleTimer.h>

#define MYSSID         "ssid"
#define PASS           "pass"
#define PUBNUB_CHANNEL "Channel-3lo░░░░░░"
#define PUBNUB_PUBKEY  "pub-c-1f22eae4░░░░░░░░░░░░░░░░░░░░░░░"
#define PUBNUB_SUBKEY  "sub-c-3afea402░░░░░░░░░░░░░░░░░░░░░░░"
#define MYID           "device01"

#define NUM_LED  4

#define R  0
#define G  1
#define B  2
#define Y  3

#define CMD_ON      1
#define CMD_OFF     0
#define CMD_BLINK  -1

static int8_t LEDpins[NUM_LED] = {4, 5, 12, 13};
static int8_t LEDcmd[NUM_LED];
static SimpleTimer timer;

void setup() {
  Serial.begin(9600);
  Serial.printf("setup");
#ifdef USE_SSL
  Serial.printf("(SSL)");
#endif

  for (int i = 0; i < NUM_LED; i++) {
    pinMode(LEDpins[i], OUTPUT);
  }
  cmdLED("blink");

  pubnub_init(PUBNUB_PUBKEY, PUBNUB_SUBKEY);

  // connect to AP
  WiFi.begin(MYSSID, PASS);
  while (WiFi.status() != WL_CONNECTED) {
    cmdLED("blink");
    delay(200);
    Serial.print(".");
  }
  Serial.println(WiFi.localIP());

  pubnub_connect();
  bool sts;
  do {
    cmdLED("blink");
    sts = pubnub_subscribe(PUBNUB_CHANNEL, subscribeCB);
    Serial.printf("pubnub_subscribe sts=%d\r\n", sts);
    delay(200);
  } while (!sts);

  cmdLED("off");
  setTimer();
}

void loop() {
  timer.run();
}

// callback function for pubnub_publish()
void publishCB(char *msg)
{
  Serial.printf("app: publishCB\r\n");
  // ready to receive the next message 
  pubnub_subscribe(PUBNUB_CHANNEL, subscribeCB);
}

// callback function for pubnub_subscribe()
void subscribeCB(char *msg)
{
  Serial.printf("app: subscribeCB data=[%s]\r\n", msg);
  // ignore self-sent messages
  if (strstr(msg, MYID) || strlen(msg) == 0) {
    pubnub_subscribe(PUBNUB_CHANNEL, subscribeCB);
  } else {
    // handle LED command
    handleMessage(msg);
    // send current status
    char buf[48];
    os_sprintf(buf, MYID ": R%d G%d B%d Y%d", LEDcmd[R], LEDcmd[G], LEDcmd[B], LEDcmd[Y]);
    bool sts = pubnub_publish(PUBNUB_CHANNEL, buf, publishCB);
    Serial.printf("pubnub_publish sts=%d\r\n", sts);
  }
}

static void setTimer()
{
  timer.setInterval(800, setLED);
}

static void setLED()
{
  boolean LEDsts[NUM_LED];
  int8_t blinking[NUM_LED];
  int8_t numBlink = 0;
  int8_t pin, cmd, b_cur = -1, b_next = -1;

  for (int i = 0; i < NUM_LED; i++) {
    pin = LEDpins[i];
    cmd = LEDcmd[i];
    LEDsts[i] = digitalRead(pin);
    if (cmd == CMD_BLINK) {
      if (LEDsts[i] == HIGH) {
        b_cur = i;
      }
      blinking[numBlink++] = i;
    } else if (cmd == CMD_OFF && LEDsts[i] == HIGH) {
      digitalWrite(pin, LOW);
    } else if (cmd == CMD_ON && LEDsts[i] == LOW) {
      digitalWrite(pin, HIGH);
    }
  }
  // for blinking
  if (numBlink > 0) {
    // not exist LED in lighting
    if (b_cur == -1) {
      b_next = blinking[0];
    }
    else {
      for (int i = 0; i < numBlink; i++) {
        if (blinking[i] == b_cur) {
          // turn off the current LED
          digitalWrite(LEDpins[blinking[i]], LOW);
          // determine the next LED to turn on
          if (numBlink == 1) {
            break;
          }
          if (i < numBlink - 1) {
            b_next = blinking[i + 1];
          } else {
            b_next = blinking[0];
          }
          break;
        }
      }
    }
    if (b_next != -1) {
      digitalWrite(LEDpins[b_next], HIGH);
    }
  }
}

static void handleMessage(char *msg)
{
  char *p, c;
  int8_t cmd;
  if ((p = strstr(msg, "on"))) {
    cmd = CMD_ON;
    c = *(p + 2);
  } else if ((p = strstr(msg, "off"))) {
    cmd = CMD_OFF;
    c = *(p + 3);
  } else if ((p = strstr(msg, "blink"))) {
    cmd = CMD_BLINK;
    c = *(p + 5);
  } else {
    return;
  }
  if (c == 'R') {
    LEDcmd[R] = cmd;
  } else if (c == 'G') {
    LEDcmd[G] = cmd;
  } else if (c == 'B') {
    LEDcmd[B] = cmd;
  } else if (c == 'Y') {
    LEDcmd[Y] = cmd;
  } else {
    memset(LEDcmd, cmd, sizeof(LEDcmd));
  }
}

static void cmdLED(char *cmd)
{
  handleMessage(cmd);
  setLED();
}

作るのは簡単、アイディア次第でとても便利に使えます。

(tanabe)

klab_gijutsu2 at 00:41│Comments(0)│TrackBack(0)│IoT | cloud

トラックバックURL

この記事にコメントする

名前:
メール:
URL:
	情報を記憶:	評価:	顔星

DSAS開発者の部屋