Toggleアニメーション実装の構造に関する考察

See the Pen YVLaQX by nakanishi (@nakanishi) on CodePen.

スライドメニュー等、アニメーション後の状態が2つしかないものの実装を考えてみる。状態=stateがいくつあるのかということは重要だと思う。メニューの表示/非表示、アコーディオンパネルの伸/縮。これらのように2つしかstateがないもの=トグルタイプを考える。

どのような要素で構成されているか

整理して考えてみると、トグルタイプのアニメーションの実装は、以下の4つの要素から構成されている。

  1. ユーザー操作の検知(例:clickイベントの取得)
  2. stateによる条件分岐とstateの変更(例:isOpenによる判定)
  3. DOMの操作・アニメーション(velociy.jsによるアニメーション等)
  4. DOM操作をトリガーするためのイベントの発行とリスン(例:$(window).triggerHandler(“customEvent”,()=>{}))

以上4つの操作は、実行される時系列に従って並べると以下のようになる。

ユーザー操作を検知(例:clickイベントの取得)
stateによって分岐(例:isOpenによる判定)
イベントのトリガー(例:$(window).triggerHandler(“customEvent”,()=>{}))
イベントのリスナー(例:$(window).on(“customEvent”,()=>{}))
DOM操作(velociy.jsによるアニメーション等)
stateの変更(例:isOpenの変更)

「イベントのトリガー」は、なくても実装は出来る。しかし次のように4つの要素を、以下のように2つにわけるとデバグが簡単になる。その理由は後半で検証する。

“Toggleアニメーション実装の構造に関する考察” の続きを読む

飲み屋であった人が自然言語処理やってるといってたのでオススメのチュートリアルを聞いてみた

よく行く飲み屋にいた人が自然言語処理を仕事でやられているというので、オススメのチュートリアルを伺った。ちょっとやってみる。

色々手を出して、どれもものになっていないのだが、これはあくまで趣味なので問題ない。いろんな小説の頭の方だけ読んだっていいじゃないか。

↓チュートリアル

https://radimrehurek.com/gensim/tutorial.html

Pythonは自分で覚えるように。Gensimというライブラリかなんかをインストールしておくように。でイントロダクションを読むようにと。

It is assumed that the reader is familiar with the Python language, has installed gensim and read the introduction.

とりあえずIntroを読む。

Gensim is a free Python library designed to automatically extract semantic topics from documents, as efficiently (computer-wise) and painlessly (human-wise) as possible.

Gensimは無料のPythonライブラリで、文章から機械的にsemantic topic=多分、意味、もしくは主題を、抽出します。コンピューターの側にとって処理効率がよく、人間にとって苦痛の少ないものになっています。

Gensim is designed to process raw, unstructured digital texts (“plain text”). The algorithms in gensim, such as Latent Semantic Analysis, Latent Dirichlet Allocation and Random Projections discover semantic structure of documents by examining statistical co-occurrence patterns of the words within a corpus of training documents. These algorithms are unsupervised, which means no human input is necessary – you only need a corpus of plain text documents.

Gensimは人間が書いたそのままの、構造化されていないデジタル・テキストを処理します。Gensimのアルゴリズムは…

Once these statistical patterns are found, any plain text documents can be succinctly expressed in the new, semantic representation and queried for topical similarity against other documents.

わ、わからん。とりあえずPytonをインストールする。ラズパイとかでも使うことになるのでよい機会。

↓これを読んでインストールする

http://qiita.com/icoxfog417/items/e8f97a6acad07903b5b0

まずはpyenvを入れる。これはnodebrewみたいなpythonのバージョン管理ツールのようだ。

$ brew install pyenv

その後インストールするわけですが、

なんかエラーが出るので↓をみて対処。

pyenv: 対処法→Python環境のBUILD FAILED – “zipimport.ZipImportError: can’t decompress data; zlib not available”

具体的にはxocodeを入れる。

xcodeselect install

でpyenv install -lsでインストール可能なバージョン一覧から新しいやつを選択して、

pyenv install 3.6.1

でインストールできた。

あとは↓をみてバージョンを指定する。

http://qiita.com/mogom625/items/b1b673f530a05ec6b423

virtualenvをインストールする: pip install virtualenv

これは特定のディレクトリ直下に開発環境を整備するためのもののようだ。node.jsと対比すると、これを使うことでパッケージをローカルにインストールしてそのパッケージを実行するといったnodeだと当たり前の開発環境が実現できる。npm install XXX -D とかってローカルインストールしていくような開発方法が取れる。

↓でnode.jsのpackage.jsonにあたる、インストールしているパッケージの一覧を書き出しできる。他の開発者と環境を整えたければ、このファイルを読み込んでもらえば良い。

pip freeze > requirementx.txt

実行には XX.pi というファイルを作ってそこにかいて、python XX.piで実行できる。例えばprint (“test”)と test.piに書いて、python test.piで実行すると、ターミナルにtestと表示される。

ウェブストームでうまく.piが表示できなかったので調べたらpycharmというIDEがあったのでダウンロードしてみる。Webstormとだいたい同じなので良さげ。Webstormにはpython用のプラグインはない模様。

そしてみんなだいすき www.codecademy のpythonコースで書き方の雰囲気をつかむ。

以下プロジェクトの進め方。

# プロジェクトのフォルダを作成
mkdir myproject 
cd myproject

# 1.仮想環境の作成 venvはフォルダ名でここにプロジェクト用の環境が用意される
virtualenv venv 

# 2.仮想環境を有効化し、pipで必要なモジュールをインストール
# Windowsの場合、venv/Scripts/activate.bat なお、Gitのシェルを利用すると同じようにsourceでできる
# 仮想環境のactivateを行わないと、グローバルにインストールされるので注意 なお、無効化はdeactivate

source venv/bin/activate

pip install xxxx
# pip freezeで作成した一覧(requirements.txt)からインストールする場合は以下
pip install -r requirements.txt

# 3.実行する
python xxx.py

変数名

Pythonでは以下のような変数名は使えない

  • $は使えない。同じく_以外の記号は使えない。
  • 4number 冒頭は数字ではいけない
  • many-people 「-」は使えない。使える記号は_のみ。

変数名は、大文字小文字を区別して認識するので、manyPeople ManyPeople manypeople等々はすべて異なる変数名である。

 

raspberry pi 3 に nodebrew を入れて node のバージョンを管理する。node-redも入れる。

せいごさんに色々教えていただきながら、raspberry pi で IoT に参入し、居酒屋ハッカソンで笑いを取りたいなと作業しています。昨日はラズパイにnodeのバージョン管理ツールであるnodebrewが普通に入ることを教えてもらったのでやってみました。

まずなぜnodebrewを入れる必要があるかというと、根本的にはNode-REDを使うためです。Node-REDはnode.jsのnpmなので、動かすためにはnode.jsか必要になります。

では、なぜnode.jsを普通にインストールするのではなくて、nodebrewというnodeのバージョン管理ツールを入れる必要があるかというと、node.jsはバージョンによって差異が大きく、また更新も早いので、いくつかのバージョンを使い分けなくてはいけないシーンが出てくるからです。これは、フロントエンドの開発においてnpmを使ってタスク処理をさせている方には馴染みのある知識だと思います。具体的には、nodeのバージョン以上に、npmのバージョンが大きく、npm2でインストールしたnpmは、npm3でインストールすることを前提に動いているnodeでは全く機能しません。他にも細々とバージョンによってトラブルが起きるので、バージョンを管理し、開発者間で基本的には同じバージョンのnodeを使う必要があります。そのためにnodebrewが必要になります。

また、ラズパイのraspbianという標準的なOSには最初から、node.jsがインストールされていますが、このnode.jsのバージョンはかなり昔のものなので、基本的にはサポートしておらず、バージョンアップするようにかかれています。http://nodered.org/docs/hardware/raspberrypi ですのでnodebrewを使わない人も、この指示に従ってnode.jsとNode-REDのバージョンをあげましょう。

問題は、上の指示は基本的に最初からラズパイに入っているnodeとNode-REDのバージョンを、まとめてあげるものであって、今回のようにnodeを自分で入れて、npmとしてnode-redをインストールするときにどうすればいいのかが書かれていないように思われます。

とはいえ、nodeのバージョンを管理しないのは不便だと思うのでnodebrewを入れる方向を選びました。さしあたってnode-REDは動きますし、nodeの管理もmacでやっている時と同じようにできるようになりました。問題は、上のドキュメントで言及されているラズパイのGPIO関係のNode-RED用ノードが入っているのか、動くのか、ということだけです。これはまだ検証していません。ラズパイのGPIO出力端子が、メスだということを予想しておらず、家にケーブルがなかったからです。アードゥイーノユーザーの方は注意してください。

さてインストールしていきます。nodebrewの公式ドキュメントに書いてある通りに、まずはインストール。

$ curl -L git.io/nodebrew | perl – setup

次にパスを通すわけですが、.bashrcに書くと書いてありますが、何かと.bash_profileに書いた方が良いらしく、なぜなのかは私にはわかりませんが、そうします。

そして、vimというエディターで編集するのは、操作方法がいつも使っているwebstormとは全く異なり使えません。なので、nanoエディターを使います。最初から入っています。

$ nano ~/.bash_profile

でナノエディターでバッシュを開いて編集します。以下のものを追加します。初めての人は多分何もないと思います。で、保存。ナノエディターの下の方に保存のコマンドとかありますので、それみてやります。

export PATH=$HOME/.nodebrew/current/bin:$PATH

これでnodebrewをnodebrewコマンドで使えるようになったはずです。では

nodebrew help

とnordebrewのコマンドを叩きます。ちゃんと入って入れば、ヘルプが出ます。うまくパスが通っていないと、パスを指定しろと言われます。

次にnordebrewを介してnode.jsをインストールします。

nodebrew install-binary stable

これで、ノードの安定バージョンがインストールされます。他にもバージョンを指定する方法や、最新を入れる方法等、コマンドあるのでマニュアルをみてください。

インストールしたあとに、

nodebrew use バージョン名

で、使うものを指定して、初めてnodeコマンドが有効になります

ローカルにインストールしたノードの一覧は 

nodebrew ls

で確認できます。

そのあとはnpmを使ってNode-REDをインストールします

npm install -g node-red

インストールできたので、実行

node-red

そしてらブラウザでlocalhost:1880にアクセスしてエディターを開きます。

できました!

GPIOが使えるかどうかチェックしたら、また記事を書きます。

Node-REDの基本的なノード:MQTT,JSON,Websocket,TCP等

Node-RED: Lecture 3 – Basic nodes and flows

In this lecture you will get to see a few of the more commonly used nodes and build on some of the things you learnt in previous lectures. You’ll start off with a series of examples based around the popular MQTT protocol that shows how to wire together a set of basic but very useful message processing nodes. Then you’ll briefly look at other ways to get messages into and out of your flows using protocols such as TCP, UDP and websockets.

このレクチャーでは、いくつか一般的に使われるノードの紹介と、既に以前のレクチャーで紹介したものの詳細については触れていなかったものを再度取り上げます。まずはよく知られたMQTTプロトコルに基づいたサンプルから始めていきます。これによって、基本的な、しかしとても便利なメッセージ処理をするノードを、どのようにつなげていいかがわかるはずです。次に、メッセージを取り込んだり出力するための他の方法として、TCPやUDPやwebsocketといったプロトコルの扱い方もとりあげます。

At the end of this lecture you will have a better understanding of some of the basic nodes used in Node-Red flows. You will also have seen how easy it is to build sophisticated processing flows that take real-world events, process them and generate responses that use popular Internet protocols to communicate the results outside of your flow.

このレクチャーが終わる頃には、Node-REDフローに用いられる基本的なノードの理解ができることでしょう。また洗練された処理のためのフローが、如何に簡単につくれるかということも理解できるはずです。現実世界のイベントを取得して、それを処理し、返答を生成して、インターネット上の一般的なプロトコルを用いて、フローの外の世界と通信します。

We use a cloud hosted version of Node-RED for these lectures called FRED. Sign up for a free account at FRED. Examples in the early lectures will work with other installations of Node-RED, later lectures use nodes you will need to install yourself if you don’t use FRED.

例によってFREDを使っていきます。

Examples

Example 3.1 Receiving JSON via an MQTT message

Example 3.2 Using the switch node to handle a JSON object

Example 3.3 Using a change node to change or manipulate a message payload

Example 3.4 Using the rbe (report by exception) node

Example 3.5 Scaling input with the range node

Example 3.6 Using an mqtt output node to test the flow

Example 3.7 Using Websockets with Node-RED

Example 3.8 Sending TCP requests.

例3.1 MQTTメッセージを介してJSONを受け取る

Example 3.1 Receiving JSON via an MQTT message

The following series of examples builds on the mqtt node, which provides a convenient way to take input from an MQTT broker. For those not familiar with MQTT, it is an example of a publish/subscribe system (usually shortened to pub/sub system) which lets sensors publish updates that all delivered to client subscribed to that sensor. MQTT uses a topic model allowing publishers (eg sensors) to create topics and publish data to the topics Equally, others can subscribe to a topic and will receive asynchronous notification of data posted to the topic.

これから続く一連のサンプルは、MQTTノードを構築していきます。MQTTノードはMQTTブローカーからの入力を簡単に取得する方法を提供します。MQTTについてあまり馴染みのない人のために説明をすると(訳注:次の日本語の記事がわかりやすかったので参照)、これはpublish /subscribeシステムを持ち、sensorたちに更新をpublishさせ、そのsensorをsubscribeしているクライアントに、その情報を届ける仕組みです。MQTTはトピックモデルによって運用され、パブリッシャー(sensor)にトピックをたて、トピックをpublishし、パブリッシャー以外はそのトピックをsubscribeして、そのトピックへポストされたデータを非同期に受け取ります。(訳注:ちょっと翻訳変ですけど、pulishとかtopicとかはもうそのまま用語を理解したほうが早いと思うので、そのままで)

Pub/Sub systems are a great way to connect loosely coupled distributed systems and they map well to typical IoT patterns where devices or things generate events that you want to share. The MQTT protocol, apart from being asynchronous, is also lightweight and doesn’t have as high an overhead as HTTP; which for resource-constrained devices is often an important advantage. MQTT was originally developed in the late 1990s and has been used in a variety of IoT settings. MQTT became an OASIS standard in 2014 and is a standard part of many IoT toolboxes. MQTT actually stands for Message Queueing Telemetry Transport.

Pub/Subシステムは、ゆるく連結した分散型のシステムをつなぐためにとてもいい方法です。またこのシステムは典型的なIoTで用いられるパターンにマッチしていて、デバイスやThingsがイベントを生成し、それを他のデバイスやThingsと共有するような場合に向いています。MQTTプロトコルは、非同期であることを除けば、軽量で、HTTPよりも負荷が低いです。これは、リソースが限られたデバイスにとっては、重要な利点です。MTQQは元々1990年代後半に開発され、それ以来様々なIoTにおいて使われてきました。MQTTはOASISとして2014年に標準化され、IoTで使用される規格としては標準的なものとなっています。MQTTはMessage Queueing Telemetry Transportの略記です。

To use the mqtt node, you need to have access to a broker. There are a number of free MQTT servers running, for example http://test.mosquitto.org/, or the one that will be used in this lecture, www.hivemq.com. Using the broker address and the topic, you can configure the mqtt input node to subscribe on that topic, causing it to generate a new message whenever new data is published on that topic. The message will contain information on the published data, including the data itself in msg.payload and the MQTT broker topic in msg.topic.

MQTTノードを使うためには、Brokerにアクセスする必要があります。フリーのMQTTサーバーがいくつもあり、たとえばhttp://test.mosquitto.org/や、このレクチャーで使うwww.hivemq.comなどがあります。Brokerアドレスと、topicを使うことで、MQTTインプットノードを、そのトピックをサブスクライブし、そのトピックでpublishがされた際に、新しいメッセージを生成させることにしましょう。そのmessageはpublishされたデータに関する情報を含み、データはmsg.playloadに、MQTTブローカーのtopicはmsg.topicに含まれています。

To get you started with the mqtt node, you’ll be using the free mqqt broker hivemq – which is available via (http://www.hivemq.com/showcase/public-mqtt-broker/). Of course you can use any MQTT broker, including your own, if you have installed one.

MQTTノードを使うために、MQTTブローカーであるhivemqを使います。もちろん他のどのMQTTブローカーを使うこともできます。例えば自分でインストールしたサーバーを使うこともできます。

First, drag and drop an mqtt input node and configure it for the broker. Don’t forget to configure the topic to something unique, in the case of this example we are using noderedlecture/sensor but you should use your own unique topic, i.e. <your name here>/sensor

まずはいつも通りMQTTインプットノードをドラッグ・アンド・ドロップでは位置して、設定画面からborkerのための情報を入力しましょう。大事なことは他の人とかぶらないtopic名を設定することです。例えばこの例ではnoderedlecture/sensorというトピックたて使用していますが、あなたはそれとは違う名前のトピックを建てるようにしてください。例えば 自分の名前/sensorとか、ですね。

(訳注:よくわからないが、とにかくトピックと、サーバーだけ同じにしておけば、受信できる模様。ポートとかクライアントIDは異なっていても受信できる。)

Figure 3.1 Configuring the mqtt node with broker address and topic

 

There are many ways you can send mqtt messages to hivemq. You can use their websockets client showcase (http://www.hivemq.com/demos/websocket-client/), the mqtt dashboard (http://www.mqtt-dashboard.com/dashboard) or your own library. You’ll be using their websocket client in this example, so navigate to that page and connect to the broker. You will publish a JSON encoded string to the topic you configured to see both the use of the mqtt node and the json node.

MQTTメッセージをhivemqに送る方法はたくさんあります。上の2つのリンクは、公式が提供しているものでこれを使うこともできますし、自分でライブラリをつくってもいいでしょう。このサンプルでは、上記のリンクのうち、最初のもの、WebSokcetクライアントをつかっていくことにします。

Figure 3.2 Sending an MQTT message (publishing) using the HiveMQ client page.

Since you are sending a JSON string, you will need to parse the message that the mqtt node generates when it receives the MQTT message. To do that, you’ll need to drag and drop a json node and connect it to the mqtt node’s output.

ここではJSON形式の文字列を送っているので、MQTTノードが受け取って、そして生成したメッセージをパースする必要があります。そのためにJSONノードを配置し、MQTTノードのアウトプットをこれに入力します。

Node-RED’s json node is a sort of convenience function, in that it parses the incoming message and tries to convert it to/from JSON. So if you send it a JSON string, it will convert it to a JavaScript object, and vice versa.

Node-REDのJSONノードは、JSONを変換してJSオブジェクトに変換してくれますし、またその反対もできます。

If you wire up the usual debug node to the json node and deploy, then use the HiveMQ dashboard to send the JSON string {“analyze”:false, “value”:10} as shown in Fig 3.2. You will see it printing in the debug tab (Fig 3.3).

結線して、debugノードをつかってみましょう。ディプロイした後にHiveMQダッシュボードを使ってJSON文字列を送りましょう。するとdebug窓で確認できます。

 

Figure 3.3 Receiving and parsing an MQTT message sent as a JSON string

If you look closely at the output, you can see that the msg.payload contains an object, which itself has two fields, analyze and value, each with their own values. As you saw in lecture 2, you can access these fields via msg.payload.analyze and msg.payload.value. Let’s take a look at a node that can do that.

Outputの内容をより詳細にみてみると、msg.payloadはオブジェクトをもっていることがわかります。そのオブジェクトは、2つのフィールドを持ち、1つはanalyzeでもう一つはvalueで、それぞれそのフィールドに対応する値を持っています。レクチャー2でみたように、これらのフィールドにmsg.payload.analyzeでアクセスすることができます。やってみましょう。

You can find the node-red description of this flow at:

https://raw.githubusercontent.com/SenseTecnic/nrguideflows/master/lesson3/3-1_mqqtmessages.json

例3.2 スイッチノードを使って、JSONオブジェクトを扱う

Example 3.2 Using the switch node to handle a JSON object

One of the nice features of having a JSON object is that you can easily act on its properties. A useful node for this is the switch node. Its role is to ‘switch’ or route messages depending on the incoming message properties.  For example, you can check the msg.payload.analyze property and, depending on its value (true/false), decide to route a message to one of the switch node’s outputs.

JSONオブジェクトをもちいる利点の一つは、そのプロパティに簡単にアクセスできることです。そのために便利なのは、Switchノードです。このノードは、入力されたメッセージのプロパティの値によって、スイッチングし、その経路にメッセージを送ります。例えば、msg.payload.analyzeプロパティをチェックして、その値によって(tureかfalse)switchノードのいずれかのアウトプットにメッセージを送ります。

Drag a switch node and double-click on it. Configure it to evaluate the property “msg.payload.analyze”. If true, send the message to the first output; if false, send it to the second output as shown in in Fig 3.4.

switchノードをいつも通りドラッグ・アンド・ドロップして配置して、ダブルクリックして設定画面に入りましょう。そしてmsg.payload.analyzeプロパティを評価するように設定します。もしこの値がtrueであれば1st Outputに出力します。falseだった場合には、2nd Outputから出力します。

Figure 3.4 Configuring the switch node to route based on a message property

Now you can connect two debug nodes as shown in Fig 3.5 – when you set up multiple outputs for a node, they are numbered from the top, so output 1 is the top output and output 2 is at the bottom in  Fig. 3.5.

次の図では2つのdebugノードにswitchノードのアウトプットをつなぎました。switchノードに複数のアウトプットを設定した場合には、上から順番にアウトプットの番号がつけられます。ですからFig.3.5ではoutput1が一番上にあって、その下にあるのがoutput2です。

 

Figure 3.5 Connecting a switch node to two debug nodes

If you now go back to the HiveMQ input page and send the MQTT message {“analyze”:true, “value”:6}, you will see that the first (top) output is activated and the incoming messages is routed, or ‘switched’, to output 1. If you send the original message {“analyze”:false, “value”:10}, the switch node will activate output 2 and the original debug node will fire. Hovering the pointer over the debug message will show which debug node is printing out the message as shown in Fig. 3.6.

さきほど作成したHiveMQを受け取るフローを少し修正してSwitchノードを使ってみましょう。MQTTメッセージの内容が{“analyze”:true, “value”:6}の場合には、1st Outputが有効になり、ここに入力されたメッセージが出力されます。反対に、{“analyze”:false, “value”:10}を送った場合にはOutput2が有効になり、下のデバグノードがメッセージを受け取ります。デバグ窓でデバグメッセージにマウスを重ねると、どのデバグノードがメッセージを出力されたかを示してくれます。

Figure 3.6 Confirming the operation of the switch node

As you can see, this provides you with a built-in Node-RED node that allows you to quickly determine the contents of incoming messages and direct the message through to different parts of the flow depending on the input.

このノードを使えば、入力されたメッセージの値に基づいて、フローの異なる場所へメッセージを流していくことができます。

You can find the node-red description of this flow at:

https://raw.githubusercontent.com/SenseTecnic/nrguideflows/master/lesson3/3-2_switchnode.json

例3.3 Chageノードを使って、メッセージを変更する。もしくは単にメッセージを扱う。

Example 3.3 Using a change node to change or manipulate a message payload

Another useful node is the change node, which will allow you to change a message payload or add new properties. You can use this node to affect the properties in a message, either by changing existing ones, deleting them or adding new properties.

どんどん便利なノードを紹介していきましょう。今回はChangeノードです。これをつかえばmessageのpayloadを変更したり、新しいプロパティを追加することができます。既にあるプロパティを変更したり、削除したり、加えたりすることができます。

In this example, you’ll continue with your MQTT theme and see how, now that you have successfully ‘switched’ the message flow based on the incoming MQTT message, you can add a new message property msg.payload.note.

次の例はさきほどから使用しているMQTTフローをそのまま使用、追加していきます。これは入力されたメッセージによってスイッチするものでしたが、さらにこれに新しいmessageプロパティであるmsg.payload.noteを追加することにしましょう。

First, let’s drag and drop a change node and connect it to the second output of the switch node (Fig 3.7). As you will remember, this is the output that fires when msg.payload.analyze is set to false.

Changeノードをドラッグ・アンド・ドロップして追加し、switchノードの2nd Outputに接続してください。このアウトプットには、msg.payload.analyzeがfalseのときにだけ、メッセージが届きますね。

Figure 3.7 Adding in a change node to set a new message property.

 

Now configure it to set the property msg.payload.note to “this is not being analyzed” as shown in Fig 3.8.

では設定していきましょう。msg.payload.noteプロパティを“this is not being analyzed”に設定します

 

Figure 3.8 Using a change node to add a new message property

 

When you receive a message that the switch node sends on the 2nd output, it will be modified to contain a “note” element with the string “this is not being analyzed”. If you deploy and test the flow by sending the MQTT message from HiveMQ, you’ll see the output as shown in Fig 3.9.

メッセージを受け取ってその内容がswitchノードのoutput2に出力されるものであれば、メッセージは変更されて、noteエレメントを持ち、内容が“this is not being analyzed”という文字列のものが追加されます。

 

Figure 3.9 The result of switching and then changing the message

 

You can find the node-red description of this flow at:

https://raw.githubusercontent.com/SenseTecnic/nrguideflows/master/lesson3/3-3_changenode.json

例3.4 rbe (report by exception-例外報告?)を使う

Example 3.4 Using the rbe (report by exception) node

In this example, you’ll continue your message analysis theme and add nodes to the part of the flow that is used when you determine that the flow should be analyzed. You’ll be using the rbe (report by exception) node which only passes on data if it has changed. You can set it to examine a message payload and either block until a message changes (rbe mode) or when a messages changes by a specified amount (deadband mode). In rbe mode, it works on numbers and strings. In deadband mode, it works on numbers only and uses the configured deadband as a + or – ‘band’, so that the incoming value can fluctuate within a range before it fires.

次の例でも引き続き、さきほどのものを使っていきます。今回追加するのはRBEノードで、これを使うことで値が変更されたときだけ、メッセージを通すことができます。messageのpayloadを検査して、メッセージが変更されるまでブロックしたり(rbaモード)、メッセージの変更が特定の範囲の間にだけ機能するようにすることができます。(deadbandモード) rbaモードでは、数字に対しても文字列に対しても動作します。deadbandモードにおいては、数字にたいして動作し、その値の範囲設定は、最後に発火したときの値から、どれくらいの範囲なのかで指定することができます。

You’ll start by adding in another change node which you’ll connect to output 1 of the switch node. You’ll then connect an rbe node to the switch node as shown in Fig 3.10.

下の図のようにつないでください。

Let’s connect a change node, and an rbe node like this. To remind us that this output deals with the flag “analyze”, add a comment node and write “Analyze = true”. Comments are useful when writing complex flows.

コメントノードを使うと、複雑なものに対して説明がつけられるので便利です。

Figure 3.10 Adding an rbe node to check if our input data has changed by more than 20%

Edit the change node to set the msg.payload to msg.payload.value. This will set the output of this node to the value found in the msg.payload.value element of the input received (Fig 3.11).

changeノードを変更して、msg.payloadに対してmsg.payload.valueを与えるようにしましょう。こうすることで、このノードのoutputを、インプットから受け取ったmsg.payload.valueの値に変更することになります。

Figure 3.11 Using a change node to set payload

Since you want to determine if this value has changed by 20% or more, you’ll need to double-click on the rbe node and configure it to block unless the value changes by more than 20%.

値の変化が20%以上のときにだけ反応するように設定しましょう。20%以上の変更がない場合には、ブロックする、という設定にします。

Fig 3.12 Setting the rbe node to check msg.payload.value

To test the flow, deploy this flow and then return to the HiveMQ page and send a series of messages. Firstly, you’ll need to set the analyze value to true so that the switch node sends through a message on output 1. If you use the original message value of 6, this will fail to pass the rbe node. If you then send a second message of value 10, the rbe node will evaluate the difference between 6 and 10, see it is greater than 20%, and send on a message to the final debug node which will print on the debug pane as shown in Fig 3.13.

ではHiveMQのページにいってメッセージを送り、このフローをテストしてみましょう。まず最初に、送るメッセージのanalyzeプロパティの値をtrueにし、スイッチノードがOutput1にスイッチするようにしましょう。最初にvalue:6をおくると、rbeノードを通りません。次に、value:10を送ると、rbeノードは先程の6と今回の10の差を比較して、それが20%以上あれば、debugノードへと値を送ります。そしてその値がdebug窓に表示されます。

Fig 3.13 Confirming that 10 is more than 20% larger than 6 using an rbe node.

 

You can find the node-red description of this flow at:

https://raw.githubusercontent.com/SenseTecnic/nrguideflows/master/lesson3/3-4_rbenode.json

例3.5 インプットを特定の範囲にスケーリングするnode

Example 3.5 Scaling input with the range node

When dealing with real world input from sensors and other devices, an ability to scale input data is often required. Node-RED provides the scale node to support this and allows you to scale (linearly) an input value. Let’s assume you want to scale your value (originally in the range 0-10) to a range (0-255) when you aren’t doing any analysis. This means we are dealing with the lower part of the flow fired when the switch node evaluates the Analyze property as false.

実世界の入力を、例えばセンサーといったデバイスから受け取って処理する場合には、インプットされたデータをスケーリングする機能はよく必要になります。Node-REDはscaleノードを提供し、これをサポートしています。仮に0〜10の値を0から255の値にしたいが、自分ではわざわざ分析をしたくはない、という状況があるとしましょう。今回は、analyzeプロパティがfalseの時に発火する、フローの下側の部分を扱います。

To do this, select the change node you configured above (set msg.payload) and copy it with ctrl+c, then ctrl+v. Attach a range node as shown in Fig 3.14.

次のように変更してください。コピペコマンドも普通に使えます。

 

 

Figure 3.14 Scaling input values using the range node.

Double-click on it, and configure it to map the input from 0-10 to 0-255 as shown in Fig 3.15.

Rangeノードをダブルクリックして編集していきましょう。inputを0-10の範囲を0-255に対応するようにアウトプットします。

The scale node has three options set by the action field. The default will scale according to the mapping given but will happily scale values outside the given ranges, using the same mapping. Scale and limit to target range means that the result will never be outside the range specified within the result range. A third option, Scale and wrap within the target range means that the result will essentially be a “modulo-style” wrap-around within the result range.

スケールノードには3つのオプションがあります。デフォルトでは、与えられたマッピング範囲によってスケーリングをするのですが、その際に、与えられた範囲外の値も同じように処理をします。Scale and limit to target rangeは同じようにスケーリングをするのですが、その出力結果は、result rangeからは決して外れません。3つめのScale and wrap within the target rangeは、数学の「割り算の余り」スタイルで、result レンジの中で折り返します。

Then return to the HiveMQ test page and post {“analyze”:false, “value”:10} as a new MQTT message to the same topic.

ではHiveMQのテストページにいって、 {“analyze”:false, “value”:10}と新しいメッセージを、さきほどと同じトピックにポストしましょう。

Figure 3.15 Setting the scaling ranges for input and output of the scale node

If you return to your Node-RED window, you will see that the debug node associated with the lower part of the flow has fired, showing that the msg.payload.value property that you set as 10 when you published it to MQTT, has been scaled up 255 as shown in Fig 3.16.

ではNode-REDウィンドウに戻って、フローの下側と関連付けられたdebugノードが発火し、msg.payload.valueプロパティが示されていますね。MQTTで10の値をパブリッシュしたわけですが、これがスケーリングされて255という値になっています。

Figure 3.16 Final scaled output when analysis is turned off

 

You can find the node-red description of this flow at:

https://raw.githubusercontent.com/SenseTecnic/nrguideflows/master/lesson3/3-5_rangenode.json

MQTTアウトプットノードを使って、フローをテストする

Example 3.6 Using an mqtt output node to test the flow

As an alternative to using the HiveMQ test page to publish on the MQTT topic, we can configure an mqtt output node. This is the mirror of the mqtt input node and allows you to configure an MQTT service and the topic you are publishing on. You can then send the node messages with the exact same JSON string we’ve been sending via the HiveMQ test page.

HiveMQのテストページを使ってMQTTトピックを発行する以外に、MQTTアウトプットノードを使う方法もあります。これはMQTTインプットノードとついになるもので、MQTTサービスを使う設定をし、そこで発行するトピックの設定もします。これによって今までHiveMQテストページで送信してきたようなJSON文字列のメッセージを送信することができます。

To try that, drag and drop three inject nodes and an mqtt output node as shown in Fig 3.17, and configure and wire up as shown

やってみましょう。

Figure 3.17 using an mqtt node to publish on the noderedlecture/sensor topic

You can now test the flow you created to analyze the MQTT message directly from the workspace by clicking on the three inject nodes in sequence. The first will exercise the part of the flow handling the case when analysis is turned off; the 2nd two messages will cause the path with the rbe node to be exercised.

インジェクトノードの左側のボタンをおしてMQTTメッセージを送信し、テストしてみましょう。

You can find the node-red description of this flow at:

https://raw.githubusercontent.com/SenseTecnic/nrguideflows/master/lesson3/3-6_mqqtout.json

訳注:細かい設定方法が書いてなかったので、自分が設定したものを画像でのせます。

まずはinjectノードで文字列をフローに挿入します。Json形式で記録。

次にMQTT アウトノードの設定です。サーバーを先程受信していたものと同じにしました。トピックも。

MQTTインプットは、アウトプットと同じにします。当然トピックも同じにします。

例3.7 ウェブソケットをNode-REDで使う

上手く行かなかったので、パス。

Example 3.7 Using Websockets with Node-RED

Websockets are another useful communication capability that is built into Node-RED via the the websocket node. Websockets provide a duplex TCP connection and were designed to allow web browsers and servers to maintain a ‘backchannel’ that could be used to augment traditional HTTP interactions, allowing servers to update web pages without the client making a new pull request.

Websocketも便利なコミュニケーションのために使える機能で、Node-REDではwebsocketノードを使って実装できます。Websocketは双方向通信可能なTCP接続で、ウェブブラウザとサーバが?

The websocket node comes in two flavours, input and output, allowing you to listen for incoming data (input) or to send (output) on a websocket. The output version is designed to check to see if the output payload originated at a websocket in a node, in which case it responds to the original sender. Otherwise it will broadcast the payload to all connected websockets.

Websocketノードは、inputとoutputの二種類があり、ウェブソケットの入力をまったり、送信したりすることができます。Outputのほうは、?

In addition, both input and output websocket nodes can be configured as either server or client – in server mode they ‘listen on’ a URL, and in client mode they connect to a specified IP address.

To see how the websocket nodes work, you’ll use a public websockets echo server which runs on the public site: (https://www.websocket.org/echo.html).

Drag an inject, websocket in, websocket out and a debug node onto the workspace and connect them as shown in figure 3.18.

Figure 3.18 using websockets to communicate with a Node-RED flow

Configure the inject node to send a string payload of “Hello There” (Fig 3.19)

Figure 3.19 Configuring an inject node to send on a websocket

Configure the websocket nodes to connect to wss://echo.websocket.org as shown in Fig 3.20.

Figure 3.20 Configuring the websocket to send to a public echo server. Do the same for the websocket out node.

Deploy. When you click on the inject node you will see the message printed out as shown in Fig 3.21

 

Figure 3.21 Output from a websocket listening for incoming data

 

You can find the node-red description of this flow at:

https://raw.githubusercontent.com/SenseTecnic/nrguideflows/master/lesson3/3-7_websockets.json

Example 3.8 Sending TCP requests.

TCP 接続をする。読めばわかる!

This example shows you how to send TCP requests using the tcp node. In this case you will make an HTTP request following the specifications in (http://tools.ietf.org/html/rfc2616#section-5.1.2).

This example shows the use of the tcp node. It could equally be configured with the udp or http nodes in a similar manner.

 

To get started, let’s connect an inject, function, tcp request, and debug nodes as shown in Fig 3.22.

Figure 3.22 building a TCP request and sending on a tcp output node

Edit the first function node to add a function that sets the string “GET / HTTP/1.1\r\n\r\nHost: www.google.com” as payload as shown in Fig 3.23.

This string is a standard HTTP request, indicating it is a GET request, the protocol is HTTP 1.1 and the host is www.google.com. The \r\n\r\n is two return/newline pairs which is required in the HTTP protocol.

Figure 3.23 Building a TCP request in a function node

Configure the tcp request node to connect to the www.google.com server, on port 80. Configure it to close the connection after 1 second (1000 ms) as shown in Fig 3.24.

Figure 3.24 Configuring the end-point for a TCP request

The tcp request node response is a buffer and needs to be parsed. Configure the second function node to parse the tcp request node response as shown in Fig 3.25

Figure 3.25. A function node to parse a response buffer into a string

If you deploy the flow and click on inject, you will make a request to Google and will get a TCP response. The debug node will print the response as a string as shown in Fig 3.26.

Figure 3.26 Printing out the response to a well formed HTTP request sent over a TCP connection.

Some of you may be wondering why you need to use a function node to build the HTTP request that we sent over TCP. Why not just use the inject node to input the string? The reason is that the inject node ‘escapes’ the string it uses, causing the return/newline you inserted to be removed. This in turn confuses the receiving server (Google) into not returning a response as it waits for the missing return/newlines. So instead, you build the string in a function node. This is one of those ‘gotchas’ that trips up even experienced Node-RED programmers, so always read the info pane for nodes to make sure you understand any limitations or constraints.

 

You can find the node-red description of this flow at:

https://raw.githubusercontent.com/SenseTecnic/nrguideflows/master/lesson3/3-8_tcp.json

Summary

In this lecture you have seen a series of small examples that use a number of the processing and communication nodes that are available in Node-RED. As you have seen, it is both easy and fast to wire together basic flows that take real-world input, carry out some processing, such as simple data analysis, and return results.

In these examples, you have done little or no coding, but still have been able to build quite complex programs – this is the power of Node-RED.

The next lecture is a quick summary of the basic set of nodes that are available in both vanilla Node-RED as well as the extended set that the FRED service provides. You can read through the lecture to understand the default capabilities, or you can treat the lecture as a reference and use it to look up examples of each node as used in this lecture series

最初のフローを作る。Node-REDレクチャー2

Node-RED: Lecture 2 – Building your first flows

This lecture will introduce you to the Node-RED visual tool and get you started building your first flow. You’ll learn how to create simple flows, use debug nodes to track messages through the flows and how to use the function node to write simple JavaScript code that tailors the node to your specific needs.

このレクチャーでは、視覚的なNode-REDのツールを使って、最初のフローを組み立てます。シンプルなフローを作成する方法を習得し、debug ノードを使ってフロウの中のメッセージを追跡し、function ノードを使ってシンプルな JavaScript コードを書き自分の希望にあったノードに調整していきます。

To get you started, you’ll be using a free cloud service that provides you with a preconfigured Node-RED setup and a wide range of built-in nodes. Later lectures will explain how to set-up Node-RED for yourself on devices such as a Raspberry PI.

はじめるにあたって、前もって設定され広い範囲のnodeが組み込まれたNode-REDを提供する無料のクラウドサービスを使用していきます。のちのレクチャーではNode-REDをラズパイ等の自分のデバイスにセットアップする方法も紹介します。

At the end of this lecture you’ll be able to create your own simple flows, you’ll know your way around the Node-RED UI and you’ll be familiar with some of the basic built-in nodes that Node-RED offers.

このレクチャーの最後には、シンプルなフローを自分で作成できるようになり、Node-REDのUIや、Node-REDに組み込まれた基本的なノードについて理解できるようになります。

FRED フロント・エンド・フォー・Node-RED

FRED – Front end for Node-RED

FRED is a cloud service that we’ve created that allows you to sign up and use Node-RED without the hassle of downloading and installing on a device such as a PI. It makes it easy to get started with Node-RED by managing an instance of Node-RED for you, keeping the instance up to date with the latest code releases and applying bug fixes or patches. Also included is a set of extra Nodes that are contributed by the community, which add to the standard basic set you get when you install Node-RED yourself. However, FRED is just a wrapper for Node-RED, so anything you write in FRED will work on a Node-RED instance running on a Pi or a Beagleboard.

FRED はクラウドサービスで、私達が開発したものです。これはサインアップするだけですぐにNode-REDを使うことができるもので、ダウンロードしたりラズパイといったデバイスにインストールする手間がありません。なのでNode-REDを簡単に始めることができ、自分のNode-REDインスタンスを管理でき、インスタンスを最新のコードにアップデートし続けてくれ、バグフィックスのパッチも当てられています。またコミュニティーによって開発されたノードも追加されており、これはNode-REDにふくまれるベーシックなものとは別のものです。とはいえFREDはNode-REDのラッパーなので、FREDで書いたものは全て、ラズパイやBeagleboardで走るNode-REDの中でも同様に動きます。

To begin our examples, make sure you have created your own Node-RED instance in the cloud by signing up for a free account at http://fred.sensetecnic.com.

作例をスタートするために、自分のNode-REDインスタンスを、クラウドサービス内で立ち上げてください。サインアップし、フリーアカウントを取得しましょう。

After registering, make sure to activate your account via your email. You will not be able to log in until you validate your account.

登録した後に、Eメールによるアクティベイトが必要です。アカウントを証明するまではログインできません。

Node-REDのUIについて

The Node-RED UI

Once you have logged in to your FRED account, you’ll see the standard Node-RED UI which consists of three main panes, as shown in Fig 2.1

まずFREDにログインすると、一般的なNode-RED UIが立ち上がります。これは3つの中心的なパネルから構成されています。

Screen Shot 2015-10-22 at 4.53.21 PM.png

Figure 2.1 The Node-RED UI  – showing the node palette (left), flow canvas (centre) and output pane (right)

(左)ノードパレット、(中)フロー・キャンバス、(右) アウトプット窓

The main pane is the flow creation workspace in the middle. This is where you drag and drop nodes and connect them with wires. Along the top of the workspace pane is a set of tabs. Each tab opens a previously created workspace and shows any flows created using that workspace.

メインの窓は、フローを作成するためのワークスペースで、中央に配置されています。ここにノードをドラッグ・アンド・ドロップし、そしてワイヤーで結線していきます。ワークスペースの上部には、タブがあります。それぞれのタブは、以前に作成されたワークスペースを示しています。

On the left is the node pane that contains all the built-in nodes that your instance of Node-RED supports. In the example above, you are seeing the FRED node set which contains a large selection that has been added to the basic set that comes with Node-RED. In later lectures you will learn about these nodes and use them to develop new flows. As you can see, nodes are grouped into categories. Opening up a category shows the individual nodes.

左側には、ノードが全て配置されているノード窓があります。上記の例では、Node-REDに最初から組み込まれているものに加えて、FREDノードが追加されているのがわかります。レクチャーを通して、これらのノードを使ってフローを作る方法を学んでいきます。ご覧の通り、ノードはカテゴリー分けされています。カテゴリーをクリックして開くことで、その中に含まれているノードを見えるようにしてみましょう。

On the right-hand side is the output pane that can be toggled between the info and debug tabs. When info is selected, documentation for the selected node is shown there.  When debug is selected, it will display the output of debug nodes, errors and warnings.

右手には、アウトプット窓があります。info と debugタブを切り替えられます。infoタブが選択されているときには、選択されているnodeのドキュメントがそこに表示されます。debug タブが選択されているときには、debug ノードのアウトプットが示され、エラーやワーニングを通知します。

Above these three main panes is the usual toolbar, and on the right-hand side are three widgets, a deploy button, a user info icon and a pulldown menu for admin and control. You’ll look in more detail at the pulldown later in these lectures. The user info icon allows you to return to the FRED front page with links to tutorials, your account information, status and other information as well as to log out of the FRED service.

これら3つのメイン窓の上には、ツールバーがあります。ツールバーの右側には3つのウィジェットがあります。デプロイボタン、ユーザーインフォのアイコンと、adminとコントロールのためのプルダウンメニューです。プルダウンメニューの中身については、このあとのレクチャーで取り上げます。ユーザーインフォアイコンは、FREDのフロントページに戻ることができます。そこにはチュートリアルへのリンクがあったり、自分のアカウントの情報があったり、ステータスや、ログアウトするための画面、その他様々な情報があります。

The Deploy button is used when a flow has been constructed and causes the flow to be deployed onto the Node-RED system and executed. You’ll be introduced to the details of what’s actually happening under the covers in lecture 5 and beyond. For now just treat the Deploy button as the way to get your flow running.

Deployボタンは、フローが完成し、フローをNode-REDシステム上にデプロイし、実行する際に使用します。詳細についてはレクチャー5以降で説明します。今のところはデプロイボタンは、作成したフローを実行するために使用することになります。

 Node-REDのノードとメッセージの概略

A quick tour of Node-RED nodes and messages

As you saw in lecture 1, Node-RED allows you to wire together nodes to create flows which carry out your programming task. Messages pass between nodes, moving from input nodes through processing nodes to output nodes. Let’s take a brief look at nodes, flows and messages.

レクチャー1で見てきたように、Node-REDはノードをつなげ、フローを作り、プログラミングによってタスクを処理します。メッセージはノード間で渡され、Inputノードからプロセシングノードを通り、outputノードに到着します。ノード、フロー、メッセージについてさっと見ていきましょう。

There are three main  types of nodes:

主要な3つのノードがあります。

  1. Input Nodes (e.g. inject) Inputノード(injectノードなど)
  2. Output Nodes (e.g. debug) outputノード(debubノードなど)
  3. Processing Nodes (e.g. function) Processingノード(functionノードなど)

basic-fred-intro-02

Figure 2.2 The main types of nodes: input, output and processing

Input nodes allow you to input data into a Node-RED application or “flow”. They have at least one output endpoint represented by the small grey square only on their right side. You use input nodes to connect data from other services, for example the  Twitter, Google, serial, websockets or tcp nodes, or to manually input data into a flow using the inject node.

Inputノードは、データをNode-REDアプリケーション、つまりフローに入力させることができます。これらは、少なくとも1つ以上のoutputエンドポイントを持ちます。outputエンドポイントは、小さな灰色の四角で表され、右側に配置されています。Inputノードを使うことで、外部サービスのデータと接続することができます。例えばTwitter, Google, Serial, websocket, tcp といったものと接続することができます。ほかにも手動でデータをInputするためにも使うことができます。その場合にはinjectノードを使用します。

Output nodes allow you to send data outside of a Node-RED flow. They have a single input endpoint on their left side. You use output nodes to send data to other services, for example via Twitter, tcp, serial or email nodes, or to use the debug node to output to the debug pane.

Output ノードはNode-RED flowの外にデータを送ることができます。Inputエンドポイントが左側に一つあります。Outputノードを使ってデータを他のサービスに送ったり、例えばTwitter, Google, Serial, websocket, tcp といったものと接続することができます。他にもデバグノードを使って、Outputをデバグ窓に表示することもできます。

Processing nodes allow you to process data. They have an input endpoint and one or more output endpoints. They allow you to transform the data type (e.g. json, csv, xml) nodes, use the data to trigger a message (e.g. trigger, delay) nodes and to write custom code that uses the data received (e.g. function node).

Processingノードは、データを処理することができます。1つのinputエンドポイントと、1つ以上のOutputエンドポイントを持ちます。例えばデータのタイプを変えるノードや(json,csv,xmlノードなど)、データをトリガーにしてメッセージを送るノードや(trigger,delayノード)、受け取ったデータをもとに自由な処理をかけるノードもあります(functionノード)

Note that some nodes, like the inject and debug messages, have a button that allows you to actuate a node (in the case of the inject node) or to enable and disable a node (in the case of the debug node).

ノードの中には、例えばinjectノードやdebugメッセージノードのように、ボタンを持ち、ノードをacuateさせたり(injectノードのように)、enable もしくはdisableにできるもの(debugノードのように)があります。

Flows consist of multiple nodes wired together, with output tabs linked to input tabs of the next node in the flow. Messages flow along the nodes carrying data from node to node.

flowは複数の接続されたノードからなり、各ノードのアウトプットは次のノードのインプットに接続されます。メッセージは、このノードの中を伝わっていきます。

Node-RED nodes consume input messages and produce output messages. Messages are JavaScript objects that contain at least a “payload” parameter, like this:

Node-REDはInputメッセージを受け、Outputメッセージを作成します。メッセージはJavaScriptオブジェクトで、少なくともpayloadパラメーターを持っている必要があります。次のように。

Listing 2.1 A basic Node-RED message structure

msg = {
payload:”message payload”
};

Nodes consume and produce messages, usually using msg.payload as the main placeholder for the data they consume and produce. However, messages can be extended to contain other parameters. For example, to set the topic of a message and add a new parameter, location, you could create a new msg object as shown in listing 2.2.

ノードはメッセージを受け取り、メッセージを生成します。大抵の場合はmsg.playloadがメッセージのやりとりにおける、メインのプレースホルダーとして用いられます。もちろんmsg.playload以外のメッセージをもたせることもできます。例えば、メッセージのトピックと、ロケーションを、新しい値として設定することもできます。

Listing 2.2 A more complex Node-RED message structure

  1. msg = {
  2.   payload:”message payload”,
  3.   topic:”error”,
  4.   location:”somewhere in space and time”
  5. };

Let’s use this knowledge to create your first flow.

学んだ知識を使って、最初のフローを作っていきましょう。

最初のフローを作ろう「ハローワールド」

Example 2.1 Building your first flow: Hello World

Let’s go ahead and start building your first flow so that you can see how simple it is to use the Node-RED UI to build and deploy a flow.

さあ最初のフローを作ることにしましょう。これを通して、Node-RED UIを使ってビルドとディプロイが簡単にできることが理解できるでしょう。

Let’s start with the easiest flow possible, a node to inject some information into the flow, wired to a debug node to see the output from the flow as a debug message. Once you have that running, you’ll build it up to the full Hello World flow.

さあ、なるべく簡単なフローにしました。injectノードを使って情報をフローに取り込み、debugノードにそれを繋いで、メッセージのアウトプットをデバグメッセージとして確認します。これが動けば、最初のハローワールド・フローを完成させたことになります。

Since this is the first time you’ll be shown how to actually build a flow, let’s start slowly and explain each step with a screen-shot. Once you’ve created your first flow and seen how easy it is, you’ll mostly be shown a single picture of the final flow rather than all the screenshots.

実際のフローを作る手順を説明するのは初めてなので、ゆっくりと各ステップをスクリーンショットを使って説明していきますね。最初のフローが完成した頃には、この作業がとても簡単だとわかることでしょう。

Let’s start with the simplest Node, the comment Node. You’ll find this in the function section of the node palette. Drag and drop a comment node onto the flow workspace as shown in Fig 2.3.

まずはcommentノードです。functionセクションの中にこのノードはあります。ドラッグ&ドロップをして。フローワークスペースに配置しましょう。

Screen Shot 2015-07-31 at 2.03.20 PM.png

 

Figure 2.3: Using a comment node is a great way to add visible comments into flows

 

Once you’ve done that, take a look at the info pane on the right (remember to switch to info if the debug tab is selected). You’ll see a little info on the node, including the node name, a unique ID, and a properties field with a description of the node. For the comment node there’s not much to say; however, more sophisticated nodes have a lot more info.

配置したら、右側にあるinfo窓をみてください。(info窓とdebug窓は切替可能のですので、info窓を選択するのを忘れないでください) するとノードにかんする情報を確認スルことができます。ノードの名前や、ユニークID、説明付きのproperties fieldがあります。commentのノードにはとりわけ説明すべきことはありませんが、より高機能なノードに関しては、より多くの情報を確認することができます。

Double-click on the comment node, and you’ll see a configuration window (Fig 2.4) You can give the comment node a name and add detailed text if you like.

コメントノードをダブルクリックすると設定画面が出ます。コメントノードに名前をつけたり、詳しいテキストを加えることができます。

Screen Shot 2015-07-31 at 12.16.33 PM.png

Figure 2.4 Give the comment a name and add any info you want in the text box

 

Ok, now let’s add the first node that actually does something, an inject node. The inject node is used to generate input into a flow and is one of the first nodes in the node palette under input. If you drag and drop an inject node onto the flow workspace, and then look at the info tab, you’ll see the documentation for the inject node. Note that the name of the node on the workspace changes from inject to timestamp, because the default behaviour for the node is to inject a timestamp – the current time in milliseconds since January 1, 1970.

次は実際に何かをするノードを追加してみましょう。今回はinjectノードです。injectノードは、インプットをフローに加えます。これはインプットカテゴリーにあります。injectノードをドラッグ&ドロップをして配置し、インフォタブを見てみましょう。このノードに関する説明があります。配置するとノードの名前がinjectからtimestampに変わったことにお気づきでしょうか。これはこのノードのデフォルトの挙動が、timestampを挿入する機能になっているからです。この機能は、現在の時間を1970年1月1日から数えた秒数で出力します。

Screen Shot 2015-07-31 at 12.03.59 PM.png

Fig 2.5 The inject node allows you to insert events as messages, defaulting to a timestamp

You’ll also notice that the inject node (now named timestamp) has a blue dot top right and a grey square centre right. The blue dot indicates that the node hasn’t been deployed since it was last changed; the grey square is the output point for the node. This is where you attach ‘wires’ that route output message from the inject node to the next node in the flow.

またinjectノードは(いまのところtimestampという名前が付けられていますが)青いドットが右上についており、灰色の四角が右側中央にあります。青いドットはノードが変更された後に、まだデプロイされていないことを示しています。灰色の四角はノードのOutputポイントです。これをつかってinjectノードのアウトプットメッセージを次のノードに渡すために、このポイントを使って接続していきます。

To get a sense for the inject node and the whole flow deployment process, let’s add a debug node to see what happens, wire them together and then deploy the flow and test it.

injectノードを理解するために、そしてフロー開発全体の理解をするために、デバグノードを追加し、デバグノードを使って何が起きているのか確認してみましょう。それらをつなぎ、デプロイし、フローをテストします。

Start by dragging a debug node from the node palette to the workspace. Again you can look at the info for the node.

debugノードをドラッグ・アンド・ドロップします。

Then you’ll wire the two nodes together. To do that, click on the grey output point for the inject node and, holding the mouse button down, drag towards the debug node. An orange wire appears, which you can then attach to the grey input point on the debug node.

そうしたら次に、2つのノードをつなぎましょう。そのためには、injectノードの灰色のOutputポイントをクリックして、マウスを押しっぱなしにしながら、デバグのノードに向かって進めていきます。オレンジのワイヤーが現れるので、デバグのノードの灰色のInputノードにつなげましょう。

Screen Shot 2015-07-31 at 12.40.55 PM.png

Figure 2.6 Wiring an inject node to a debug node

 

This is the simplest flow possible and will send the current timestamp to the debug node for display in the debug pane. Let’s try it!

これが一番簡単なフローで、これは現在の時間をデバグノードにおくり、デバグ窓にそれを表示するフローです。やってみましょう!

Click the deploy button in the Node-RED window (top right). You’ll see a pop-up saying the flow has been successfully deployed. You will also notice that the blue dots on the nodes disappear, indicating there are no undeployed changes.

Node-REDウィンドウの右上にあるディプロイボタンを押しましょう。するとフローがデプロイに成功したメッセージがポップアップで表示されるはずです。また青いドットが消え、変更が全てデプロイしたことを示します。

Now, before you try the flow, make sure the the debug tab is selected on the right pane. Then click on the left tab on the inject node and look at what appears in the debug pane.

デバグタブをまず開きます。そして

Screen Shot 2015-07-31 at 12.48.44 PM.png

Figure 2.7 Debug output from your first flow – the time when you clicked the inject node.

 

As you can see, the inject node, when clicked, generates a timestamp (number of milliseconds since January 1, 1970), which is converted to a message and sent along the output wire, which is delivered to the debug node as an input message. The debug node’s default behaviour is to show any message it receives, which it does in the debug pane on the right.

インジェクトノードをクリックすると、タイムスタンプが作成され、それがメッセージに変換され、Outputワイヤーを通して送信されます。それはdebugノードに運ばれ、inputメッセージとして入力されます。debugノードのデフォルトの挙動は、受け取ったメッセージを右側のdebug窓に示します。

Congratulations, you created and deployed your first flow!

おめでとうございます。最初のフローを作成し、デプロイできましたね!

Let’s now augment it a little to see what else we can do with this simple flow. Firstly, we’ll edit the inject node to deliver a text message rather than a timestamp. To do that, select the inject node in the flow and double-click it. You’ll see a configuration window like the one in Fig 2.8.

すこし追加の作業をして、このシンプルなフローでどんなことができるのか、より理解してみましょう。まずinjectノードを編集して、テキストメッセージを送るようにしてみましょう。そのためには、インジェクトノードを選択して、ダブルクリックします。すると設定画面が開きます。

Screen Shot 2015-07-31 at 12.54.29 PM.png

Figure 2.8 Editing an inject node to send text instead of a timestamp

 

In the payload field, select string instead of timestamp and then type any string you like into the blank field below the payload field. As is traditional, let’s start with “Hello World – from my first NR flow!”

playload fieldにおいて、stringを選んで、好きな文字列をplayload fieldの空欄に入力しましょう。伝統に則り、ハロー・ワールドと入力することにしましょう。

Once you’ve made the change, click ok to save the changes and take a look at the flow. You’ll see the blue dot has appeared on the inject node (which has also returned to being called inject rather than timestamp) to indicate that you have undeployed changes. Click the deploy button again to resolve that and then go ahead and click the tab on the inject node. If you look at the debug output you’ll see that instead of a timestamp, your text has been delivered as a message to the debug node, which displays it as usual.

この変更をして保存します。すると青いドットがinjectノードにあるのがみえます。これは変更がディプロイされていないことを示しています。では再度deployボタンを押して、ディプロイし、injectノードをクリックしましょう。するとあなたが入力したテキストがメッセージとしてデバグノードに送信され、それがいつも通りdebugノードに表示されます。

Screen Shot 2015-07-31 at 1.01.40 PM.png

Figure 2.9 Sending a text message rather than a timestamp

 

As you can see, it’s very easy to wire up some simple nodes and get data to pass through your flow as messages. At this stage, you’ll probably be wondering a little about the messages that are flowing between nodes. The debug node can be used to examine them in more detail.

ご覧の通り、簡単に、ノードをつないでデータを取得して、フロー中へ渡すことができました。この段階では、フローの中を移動するメッセージの内容について疑問がまだあると思います。デバグノードをつかって、メッセージの詳細を精査することもできます。

All messages in Node-RED have three default properties: the payload, which we are seeing above, a message topic, which is a user-defined string describing what the message is about (its topic, if you will) and an internal identifier. You can actually see this information if you edit the debug node configuration. Let’s do that and look at the output (Fig 2.10)

Node-REDのメッセージは全て、3つのデフォルトのプロパティを持っています。payloadは既にみてきました。message topicはメッセージが何についてのものなのかを、ユーザーが指定できる文字列です。そしてinternal identifierです。これらの情報はdebugノードの設定外面で変更を加えると、確認することができます。↓debugノードの設定画面で、outputをcomplete msg objectに変更する。

Screen Shot 2015-08-06 at 11.15.08 AM.png

 

Figure 2.10: setting the debug node to show the internals of a message

 

Select the debug node, double click and change the node output field to “Complete msg object”. If you then save this, deploy again and click the inject node, you will see in the debug pane a JSON structure that contains 3 fields: a “topic” which is currently blank, a “payload” which contains the string you set in the inject node and an internal ID field “_msgid”. Generally the internal message ID field isn’t used. However, both the topic and payload are used extensively when developing flows. You’ll see more of that later in the lecture series.

debugノードを選択して、ダブルクリックをしてノードのoutputフィールドを”complete msg object”に変更してください。これをセーブしてディプロイして、injectノードをクリックすると、debug窓にJSON構造のデータを確認することができます。これには3つのfiledがあります。topicは現在は空白で、”payload”にはあなたがinjectノードで指定した任意の文字列が、そしてinternal IDフィールド”_msgid”です。基本的にはinternal message IDは使いません。しかし、topicとpayloadはどちらともよく使われます。これらについてはこのシリーズでまた取り上げます。

These fields are extensible, so you can define new message properties, for example, msg.location, which could be used to add the latitude and longitude values for the source of the message. Let’s take a look at that in the next example flow.

これらのfieldは拡張可能です。ですから新しいmessage propatyを設定し、例えばmsg.location等を設定し、位置情報をメッセージに付加することができます。次のサンプルを通して、これをみていきいましょう。

You can find the node-red description of this flow at:

https://github.com/SenseTecnic/nrguideflows/blob/master/lesson2/2-1-firstflow.json

例2.2 天気アラート

Example 2.2 A second flow: weather alerts

In this example, which is similar to the one introduced in lecture 1, you’ll monitor the weather in your hometown and send yourself a tweet when the weather looks like it’s going to be good. You’ll use a built-in weather node – openweathermap – that retrieves the weather from openweathermap.org for the location you set it for. A simple function node will be used to check for ‘clear weather’ and a Twitter node will be used to send yourself a tweet when the weather looks good.

この例は、レクチャー1で紹介したものと同じもので、あなたの街の天気をモニターして、天気が良くなりそうになったら、ツイートをします。ここでは最初から組み込まれている天気用のノードである、openweathermapを使用することができます。これはopenweathermap.orgからあなたが設定したエリアの情報を取得するノードです。そしてシンプルなファンクションノードを使って、快晴かどうかを判断して、Twitterノードを使ってあなたにTweetを送ります。

First you will need to get an API key at OpenWeatherMap. OpenWeatherMap offers a great service that provides detailed weather information for worldwide locations. Visit http://openweathermap.org/appid and follow the instructions as shown in the screenshots below.

まずはOpenWeatherMapでAPI Key を取得しましょう。OpenWeatherMapは詳細な天気情報を提供してくれる、素晴らしいサービスで、世界中の場所に対応しています。http://openweathermap.org/appidにアクセスして、指示にしたがいましょう。

 

 

You will need to sign up for an OpenWeatherAccount as shown below:

まずはサインアップする必要があります。

After signing up you will be redirected to your Home page where you will be able to access or re-generate your API Key. It should look something like this:

サインアップしたあとは、自分の設定ページでAPIキーを作成しましょう。

Now, let’s use that API key to build a weather alerts flow. Drag and drop a weather node from the left pane onto the workspace, as shown in Figure 2.11.

ではこのAPIキーを使って天気アラートを作っていきます。weatherノードをドラッグ・アンド・ドロップしましょう。(訳注:ないけども!!なくない???しょうがないので、macにnode-redをnpmでインストールして、openweatherノードもnpmでインストールしました。さしあたってグローバルにインストールすれば良い模様。)

Figure 2.11. Drag and drop a weather node onto a blank workspace

 

If you select the info pane on the right, you can see a description of the openweathermap node with detailed information on how to configure and use it. Some interesting things to note:

選択して詳細窓を見ると、説明を見ることができます。

  • It has a full JSON structure as its msg.payload, with quite a lot of weather detail, all presented as name:value pairs, e.g. wind speed and tempc
  • JSON構造のmsg.payloadを持ち、これには膨大な天気情報が記されています。全ては名前:値のペアになっていて、名前には例えばwind speedとかtempc等があります。
  • The node defines 3 new message properties, msg.location, msg.time and msg.data. As mentioned above, you are free to add properties to messages, and the openweathermap node has added these new properties to carry extra information associated with the message.
  • ノードは新たに3つのmessage propertyを設定しています。msg.location, msg.time, msg.dataの3つです。既に解説したように、自由にmessageへプロパティを追加することができます。openweathermapノードは、これらの新しいプロパティを追加し、メッセージへさらなる情報を関連付けて運ぶのです。

Let’s configure the node and look at the actual data structure it generates after it has queried your local weather. Start by double-clicking on the node and fill out the form with your location. Type your city and country in the fields. Add the API key you obtained from http://openweathermap.org/appid and click on “Ok” as shown in Fig. 2.12.

 

 

Figure 2.12. Set your city and country in the configuration form, use the API key you obtained in the step above.

 

Then drag and drop a debug node and wire it to the openweathermap node. Click on “Deploy” to see that the payload object from the openweathermap node in the debug pane.

ディプロイしてplayloadオブジェクトの中身をデバグ窓でみてみましょう。

Listing 2.3 The message payload for the openweathermap node is a JSON structure describing weather conditions, temperature, wind, cloud cover and sunrise times.

このなかには色々な情報がJSON形式で含まれていることがわかります。

  1. {
  2.   “weather”: “Clear”,
  3.   “detail”: “sky is clear”,
  4.   “tempk”: 295.104,
  5.   “tempc”: 21.903999999999996,
  6.   “humidity”: 53,
  7.   “maxtemp”: 295.104,
  8.   “mintemp”: 295.104,
  9.   “windspeed”: 2.22,
  10.   “winddirection”: 273.007,
  11.   “location”: “Vancouver”,
  12.   “sunrise”: 1432038196,
  13.   “sunset”: 1432094081,
  14.   “clouds”: 8,
  15.   “description”: “Vancouver weather(49.25,-123.12) is Clear (sky is clear).”
  16. }

As you can see, the node delivers quite a lot of information about your local weather, all as the usual name:value pairs. For this example, you want to use the “weather” field which you’re going to test to see if it’s reported as “Clear”. If it’s “Clear” you’ll then send a tweet.

ご覧の通り、nodeはかなり大量のローカル天気情報を運搬し、それぞれの情報は一般的なname:value のペアで管理されています。例えば、その中からweatherフィールドに含まれる情報を使って、それが「clear 快晴」かどうかを判断するテストに使うことができます。もし快晴であればツイートするような機能を作ってみましょう。

To program that logic, you’ll use a function node. You saw one of these in lecture 1, but without the details. Let’s see how they are used by dragging one onto the flow workspace and double clicking it to open up the node editor.

このロジックをプログラミングするためにはfunctionノードを使うことができます。これは既にレクチャー1でみたものですが、詳細についてはまだ説明していませんでした。あらためてどのように使うのかみていきましょう。まずドラッグ・アンド・ドロップでワークスペースに配置し、ダブルクリックをして設定画面を開きましょう。

Figure 2.13. Add a function node and wire it to the openweathermap node.

Now double-click on the function node and type/copy this (Note if you use copy/paste – make sure you paste as plain text, wordpress sometimes inserts odd characters)

次の文字列をコピペしてください。

Listing 2.4 Function node “If Clear Weather”

  1. if (msg.payload.weather === “Clear”) {
  2.     msg.payload = “Clear skies ahead today!”
  3.     return msg;
  4. }
  5. return null;

Figure 2.14. Edit the function node adding the JavaScript shown in listing 2.4

Looking at Listing 2.4, you can see that this will parse the incoming message payload for the weather parameter and compare it to the string “Clear” (line 1). If it is equal, it will rewrite the message payload with your own string “Clear skies ahead today!” (line 2). Otherwise it will return a null message (line 5). This last bit is important because in Node-RED nodes ignore null messages.

このプログラムは、入力されたmessageのpayloadをパースして、weatherパラメータを取得し、これを文字列”Clear”と比較しています。これが等しければ、messageのpayloadを書き直して、“Clear skies ahead today!”とします。そうでなければ、nullメッセージを返します。この最後の短い行は大切で、なぜならNode-REDはnullメッセージを無視するからです。

You can do all sorts of things now, for example wire this message to an email node, or a pushbullet node. For this tutorial we will use the Twitter output node. Drag  a Twitter node onto the workspace, double-click and and fill out your Twitter account credentials as shown in Fig 2.15.

さあここまでくれば、どんなこともできますよ。例えば、メッセージをEmailノードにつなげたり、pushbulletノードにつなげたりできます。このチュートリアルでは、Twitter Outputノードを使うことにします。Twitterノードをドラッグして、設定画面からTwitterアカウントの情報を入力しましょう。

Figure 2.15. Set your Twitter account credentials into the node configuration

Once you’ve set up these credentials, Node-RED stores them and you can reuse them when you create another Twitter node in future flows.

一度認証してしまえば、それは記録され、あとで使いまわすことができます。

Once you’ve wired up the flow, you can hit the deploy button and then watch your Twitter account to see the new tweet every time the weather is reported as clear.

ではワイヤーでつないで、ディプロイしましょう。

Click on “Deploy”:

Figure 2.16. The full weather flow sending tweets if the weather report mentions clear skies.

Other useful UI features

One of the most useful features of the Node-RED UI is the ability to copy and paste nodes and even full flows using the standard cut’n’paste clipboard. Node-RED flows are simply coded as JSON strings and can be exported from a workspace, and imported into a workspace using the Node-RED pulldown menu in the top right of the Node-RED window.

Node-RED UIの中で一番便利な機能は、ノードをコピペする機能で、一般的なコピペコマンドで実行することができます。これを用いて、フロー全体をコピペすることもできます。Node-REDフローは、シンプルなJSON文字列でできているので、ワークスペースにあるフローを書き出したり、ワークスペースへ読み込んだりすることができます。Node-REDのプルダウンメニューから実行します。

Rather than building the flows in this example, or in fact anywhere in this lecture series, by hand yourself, you can simply copy them from our website and paste them into a workspace. After that all you need to do is configure them correctly, e.g. with credentials, and deploy them.

自分で全てを作る代わりに、私達のサイトからコピペーをして、いくつかの設定項目を理解し、変更するだけで、じつはすんでしまいます。

Let’s quickly show you how to do that.

どのようにやるのか、みていきましょう。

Click on the link for this example which is at the end of the example below and look for the JSON code. Copy it to the clipboard using the usual CTL C or copy item in the edit menu.

このサンプル解説の一番下にあるリンクから、このサンプルのJSONコードを取得して、一般的なコントロール+Cコマンドなどでコピーしてください。

Using the pulldown menu in the top right of the Node-RED window, select Import->Clipboard as shown in Fig 2.17

つぎに、Node-REDの右上にあるプルダウンメニューから、Import→クリップボードを選択します。

Screen Shot 2015-08-15 at 12.55.58 PM.png

Figure 2.17 Selecting the Import from Clipboard menu item in Node-RED

 

You will see a popup with an input field (Fig 2.18). Paste your clipboard into the input window and click OK.

するとインプットフィールドがポップアップで表示されますので、今コピーしてきた情報をペーストし、OKをおしましょう。

Screen Shot 2015-08-15 at 12.56.27 PM.png

Figure 2.18 Pasting a flow into the import window of Node-RED

 

The new flow will appear in the current workspace and can be moved to a location and dropped. Once it’s in place, you can configure it as you would a flow you created yourself and deploy it.

すると、新しいフローがワークスペースに登場するはずです。一度読み込んでしまえば、あとは自分が好きなように修正をして、ディプロイをして使うことができます。

You can find the node-red description of this flow at:

https://github.com/SenseTecnic/nrguideflows/blob/master/lesson2/2-2_weatheralerts.json

Summary

In this lecture you have created your first flows and seen how to wire together a set of basic nodes to achieve quite complex tasks. We’ve skipped over a few of the underlying details in order to get you going quickly, and we’ll return to those in lectures 3 and 4. However, so far you’ve seen how to use the Node-RED visual flow builder, the basic classes of input, output and processing nodes. You were given a brief overview of messages and how to use the function node to write your own JavaScript code to do simple processing on messages within a flow. In the next lecture, you’ll take a more in-depth look at the programming model of Node-RED and get a better understanding of the main programming elements and nodes and how to craft more complex flows using a variety of nodes.

このレクチャーでは、最初のフローを作る方法を紹介しました。その中で基本的なノードをワイヤーでつないで、複雑なタスクを実行する方法がわかってもらえたと思います。まずは概念を理解してもらうために、いくつか複雑なことは飛ばしましたが、これについてはレクチャー3か4で扱います。とはいえ、Node-REDの視覚的なエディタ、input、output、functionノードの使い方がわかったはずです。またメッセージがどんなものなのかもわかり、functionノードを使って自分でJavaScriptを書いて、シンプルにノードフローを流れるメッセージを処理する方法も学習しました。次のレクチャーでは、より踏み込んでNode-REDのプログラミングモデルを学習していきます。それによって主要なプログラミングに用いる要素の一層の理解と、より多様性のあるノードを使って複雑なフローを構築する方法についても学んでいくことになります。

Node-RED イントロダクション

Node-RED: Lecture 1 – A brief introduction to Node-RED

Node-RED: Lecture 1 – A brief introduction to Node-RED

This lecture will introduce you to some examples of Node-RED, both to give you a sense of its capabilities and to introduce its basic concepts. We’ll also discuss the history of Node-RED and its origins to give you an idea of what Node-RED is good for and of what types of tasks are best left to a more traditional programming language and environments.

このレクチャーでは Node-RED を用いた作例を紹介し、Node-RED でどのようなことができるか、またその基本概念についてもお伝えします。Node-RED の歴史と起源についても触れ、それによって Node-RED がどのようなタスクに向いていて、またどのようなタスクについては古典的なプログラミング言語で処理したほうがいいのか、ということについても考えていきます。

Node-RED is a powerful tool for building Internet of Things (IoT) applications with a focus on simplifying the ‘wiring together’ of code blocks to carry out tasks. It uses a visual programming approach that allows developers to connect predefined code blocks, known as ‘nodes’, together to perform a task. The connected nodes, usually a combination of input nodes, processing nodes and output nodes, when wired together, make up a ‘flows’.

Node-RED は IoT アプリケーションを構築するためのための強力なツールで、特に、様々な機能の連携をシンプルに実装することに注力しています。タスクを処理する役目を持つ「コードブロック」を、シンプルにつなぐだけで実装出来るのです。Node-RED は視覚的なプログラミング手法を採用しており、開発者は予め用意されたコード・ブロック = nodes をつなげることで、タスクを処理させます。通常は input 用の node があり、処理用の node があり、最後に output 用のノードがあります。これらが結線されて、「flows」を形成します。

Originally developed as an open source project at IBM in late 2013, to meet their need to quickly connect hardware and devices to web services and other software – as a sort of glue for the IoT – it has quickly evolved to be a general purpose IoT programming tool. Importantly, Node-RED has rapidly developed a significant and growing user base and an active developer community who are contributing new nodes that allow programmers to reuse Node-RED code for a wide variety of tasks.

Node-RED は IBM のオープンソースプロジェクトとして2013年に開発が始められました。IBM は、ハードウェアや各種デバイスを、ウェブサービスや様々なソフトウェアと接続する必要があり、そのために開発されたのです。つまり IoT におけるつなぎの役目を果たします。その後 Node-RED 急速に進展し、IoT 全般で用いることができるツールになりました。また Node-RED が特に優れているのは、 急速に莫大なユーザーを獲得し、それから開発者コミュニティーが成長し続けていることにあります。新しい node がどんどんと追加され、様々なタスクを処理することが可能です。

Although Node-RED was originally designed to work with the Internet of Things, i.e. devices that interact and control the real world, as it has evolved, it has become useful for a range of applications.

Node-RED はもともと IoT のために作られたものではあるのですが、今ではもっと広い範囲のアプリケーションの作成においても便利なものになっています。

This lecture will introduce you to some examples of Node-RED, both to give you a sense of its capabilities and to introduce its basic concepts. We’ll also discuss the history of Node-RED and its origins to give you an idea of what Node-RED is good for and of what types of tasks are best left to a more traditional programming language and environments.

このレクチャーでは Node-RED を用いた作例を紹介し、Node-RED でどのようなことができるか、またその基本概念についてもお伝えします。Node-RED の歴史と起源についても触れ、それによって Node-RED がどのようなタスクに向いていて、またどのようなタスクについては古典的なプログラミング言語で処理したほうがいいのか、ということについても考えていきます。

By the end of this lecture you should have a high-level understanding of Node-RED, its programming model and some simple pre-built nodes as well as an insight into the origins and best usage of Node-RED.

このレクチャーのおわりには、Node-RED の深い理解を得て、Node-RED プログラミングの構造と、予め用意された Node への理解、それから Node-RED の起源と、最適な使用状況についての理解を得ることが出来るはずです。

Node-RED を知ろう

Getting to know Node-RED

Let’s get started by looking at a few simple examples of the kinds of thing you can do with Node-RED. Our goal in this lecture is not to get you programming with Node-RED, but to give you a sense of its capabilities through some high level examples. If you really want to dive straight in, you can skip ahead to lecture 2 where you’ll be taken through the steps to create and run your first flow.

Node-RED でどんなことができるのか、シンプルな例をみていきましょう。この記事の目的は、Node-RED でのプログラミングの方法の学習ではなくて、作例をみながらどんなことが Node-RED によって可能になるのか、という知見をもってもらうことにあります。すぐにでもプログラミングを始めたい場合には、この記事はスキップしてレクチャー2に進んでください。そこでは実際にプログラミングをして最初のフローを作成していきます。

This first example flow will receive a message from a Twitter feed containing a hashtag and turn on and off a LED when a new tweet has arrived. For this example let’s assume that NODE-RED is running on a Raspberry PI – a common situation for many Node-RED users.

次の最初の flow の例は、Twitter からハッシュタグをもつメッセージをフィードから取得し、新しい Tweet がされた時に、LED を点滅させるものです。この例においては Node-RED は Rasberry PI 上で動作させられることが想定されています。これは Node-RED の使用方法として非常に一般的なものです。

例1.1 Twitter を用いて Raspberry PI をコントロールする

Example 1.1 Using Twitter to control a Raspberry PI

The Node-RED flow to check Twitter and to see if a hashtag #led is detected, turns on a LED connected to a Pi is shown in Fig. 1.1. As you can see, it’s quite simple; it consists of 3 nodes wired together – a twitter node on the left, a trigger node in the middle and a Raspberry Pi (gpionode) node on the right. (gpio stands for General Purpose Input/Output and is the name given to the generic Raspberry PI node that handles IO). The nodes, represented by rounded boxes, usually have an icon to represent their type, e.g. the Twitter bird icon in the first node, and a text name that can be set by the programmer.

Node-RED の flow は Twitter をチェックして、#led のハッシュタグが検知された場合には、Raspberry PI に接続された LED を点灯させます。これを示したのが下記の図です。ご覧の通り非常にシンプルです。3つの node がつなげられています。Twitter のためのノードは左側にあり、トリガー用のノードが真ん中に、Raspberry Pi 用のノード(goionode)は右側にあります。(gpio はGeneral Purpose Input/Output の略記で、同時にここでは Raspberry Pi のIn/Out をコントールする一般的な node のための名前でもあります) ノードは丸みを帯びた四角形で表され、通常はその役割を表すアイコンを持ちます。 また名前を自分でつけることができます。

Each of these three nodes is built into the Node-RED visual programming tool and can be dragged from a node palette onto the main workspace. They are then ‘wired’ together by joining their output tabs to the input tab of the next node in the flow (the little grey blobs on the right or left of the node boxes.) The next lecture will look at the UI in detail, but for now let’s focus on the high-level capabilities.

それぞれ3つのノードは、Node-RED に組み込まれており、ノード・パレットからメインの作業スペースにドラッグ・アンド・ドロップで配置することができます。ノードを接続するためには、outputを、フロー上で次にくるInputにつなぎます。(左右にある、小さい灰色の丸がそれです。) 次のレクチャーではUIをより詳細にみていきますが、いまのところは概念的な説明をしていきます。

The Twitter node is a built-in node in Node-RED and hides all of the complexity of using the Twitter API. It can be configured with a user’s account credentials and a variety of search strings, in our case it’s simply looking for hashtag ‘#led’.

Twitter 用の node は Node-RED に最初から組み込まれており、Twitter API を使う上で生じる複雑さに触れる必要がないようにしてくれています。必要なのは、ユーザー認証情報と、検索用の文字列、このケースでいえば単純に #led のハッシュタグを探していいます。

When the Twitter node sees the tag either in a tweet to the user, or the public tweet feed, it creates a new message with the details of the tweet, which is forwards to the next node in the flow. In our example, since the Twitter node’s output is wired to the trigger node’s input, the trigger node receives a message with the details of the tweet.

Twitter ノードは、ユーザーのツイートとそれ以外の全ユーザーのツイートにおいて、指定されたツイートがされたことを確認すると、そのツイートの詳細情報を元に新しいメッセージを作成し、これをフロー上の次のノードに渡します。この例では、ツイッターノードのoutputはトリガーノードのInputにつながっており、トリガーノードはツイートの情報をもったメッセージを受け取ります。

The trigger node is another built-in node in Node-RED and its default behaviour is to wait for any message on its input. When it receives a message, it ‘triggers’, and sends a message on its output with the value “1” as the message body. It then waits 1 second and sends a second message with the value “0” in the message body.

Trigger ノードも Node-RED に最初から組み込まれているノードで、デフォルトの挙動は、Inputにくるメッセージを待ち受けることです。メッセージを受け取ったら、「トリガー」し、outputにメッセージを送ります。そのメッセージのbody値は0です。その後、1秒待った後に、bodyの値が0のメッセージを送ります。

Since the trigger node is connected to the gpionode, which controls the Input/Output or IO pins on the Raspberry PI, it get’s these two messages, 1 second apart, on its input.

トリガーノードは、gpionode に接続されているので、gpinode は送られてくる2つのメッセージを、1秒開けて、Inputから受け取ります。

Again, the gpionode is a built-in node in Node-RED that hides the details of setting the IO pins on the PI. When it gets a message with a value of “1” in the body, it takes the IO pin high, and when it receives a message with body of “0”, it takes the pin low. In this example, the gpionode is configured to control pin number 12, and so the node shows that in the node icon.

繰り返しになりますが、gpionode はNode-RED に最初から組み込まれており、ラズパイのIOピンの詳細設定に触れる必要をなくしてくれています。このノードが、body が1であるメッセージを受け取ると、IO ピンをhighにし、0を受け取るとピンをlowにします。この例ではgpionodeはピンナンバー12をコントロールするように設定されていますので、それがノードのアイコンでも示されています。

If you have your PI wired up with an LED connected to Pin 12, the gpionode going high for 1 second and then low will cause the LED to blink on for 1 second.

ラズパイの12pinがLEDに接続されていれば、gpionodeは1秒high、その後lowになるので、LEDを1秒点滅させることになります。

If you think about what’s happening here, it’s actually an incredibly powerful example of Node-RED and the Internet of Things (IoT). It’s connecting the ‘Twitterverse’ to a PI and an LED, but requires no programming – all the tasks are carried out by pre-built nodes in Node-RED which just need configuring. This really demonstrates the power of Node-RED when running on a simple device such as a Raspberry PI.

ここでおきていることは、Node-RED と IoT の強力さを示しています。「ツイッターの世界」がラズパイとそのLEDに接続されているのですが、そのためにはプログラミングが必要ないのです。全てのタスクは、Node-RED に最初から用意されている node によってなされてしまうのです。この例はラズパイのようなシンプルなデバイス上で Node-RED を動かくことによるパワフルな効果を示す良い例です。

So just to recap. Node-RED is a flow-based programming tool with a visual editor that allows you to wire together nodes to create flows. In this case, 3 nodes create our first flow. Real-world events, e.g. a tweet with the #led hashtag, are converted to messages, which ‘flow’ along the wires between the nodes. Nodes process messages on their input and, as a result, send messages on their outputs to the next node in the flow. In this simple example, we look for a tweet with hashtag #led and use it to trigger a message to a Raspberry PI node that cause IO pin 12 to go high for 1 second, which in turns causes a LED to blink on for 1 second.

振り返ってみましょう。Node-RED はフロー・ベースのプログラミング・ツールで、視覚的なエディターをもっています。これによってノードをつなげて、フローを作成します。この例の場合は、3つのノードをつなげてフローを作成しました。実際の世界の変化が、ここでは#ledをもったツイートが、メッセージに変換され、結線されたノードの間を流れて=flowしていきます。NodeはInputに来たメッセージを処理し、アウトプットからメッセージをだし、それがフロー上の次のノードに渡されます。このシンプルな例においては、#ledをもつツイートを探しました。そしてラズパイ用のノードに送るメッセージをトリガーして、IO ピンの12番めを1秒ハイにすることで、LEDを1秒点滅させました。

This example – and the rest in this lecture – are mostly to show you the kinds of things we can do with Node-RED. If you want to play around with the example, you should look at lecture 2 to see how to setup an account with FRED (the cloud based Node-RED service we use) and how to get started. You can find the node-red description of this flow at:

この例、それから今後のレクチャーで用いられる例は、うまくNode-REDできることを伝えています。実際にNode-REDで作業をしたいのであれば、レクチャー2を参考にして、FRED(クラウドベースのNode-REDサービスです)のアカウントを設定して、はじめていきましょう。このフローの説明は次のリンクから確認できます。

https://raw.githubusercontent.com/SenseTecnic/nrguideflows/master/lesson1/1-1_twitter.json

例1.2 Node-REDを使ってトレーニングの予定を守らなかった時にアラートを鳴らす

Example 1.2 Using Node-RED to alert you when you’re falling behind on your exercise schedule

Our second example shows a different usage of Node-RED. Rather than controlling a device such as a Raspberry PI, this flow combines weather info and your fitbit usage to send you an email alert when the weather is good and you’re behind on your exercise schedule. The flow is a little more complicated, using 6 nodes (see Fig 1.2), but again, by using built-in nodes you can accomplish complex tasks with little or no programming.

付きの二つ目の例は、Node-REDの先ほどとは少し異なった使い方を示しています。ラズパイのようなデバイスをコントロールするのではなくて、このフローは天気情報とfitbit(訳注:フィットネス向けのアップルウォッチのようなウェアラブルデバイス、及び関連サービス)をつなげて、天気が晴れなのに、エクササイズをしていない時に、アラートメールを送ります。このフローは、少し複雑で、6つのノードを使います。しかしもとから用意されているノードを使うので、複雑なタスクを最小限にしてくれますし、もっといえばプログラミングのする必要もありません。

Figure 1.2 A simple flow to alert you when you are not exercising and the weather is good

As before, nodes are dragged from the node palette in the Node-RED UI and wired together on the flow canvas. Starting at the leftmost node, let’s begin with an openweather node which you can configure to check the weather for any major city at set intervals. When it checks, it packages up the results in a message which is forwarded to the next node, in this case, to a switch node. The switch node performs a simple test, checking the input message for a value and sending a message with a value of “1” if the test is true. In our case, it’s been configured to test the temperature value (tempc) to see if it’s 15 degrees celsius or higher.

先程と同じように、ノードをノードパレットからドラッグ・アンド・ドロップして、それをつなげていきましょう。一番左のノードから始めましょう。これは openweather ノードで主要な都市の天気を設定した間隔で確認することができます。確認をしたときに、その結果をメーセージにまとめあげて、次のノードに渡します。このケースではswitchノードです。switchノードは簡単な分析をします。つまり、Input送られてきたメッセージの値をチェックして、分析がtrueなら、値が1のメッセージを送信します。このケースでは、気温が(tempc)が15度以上であるかどうかを分析するように設定されています。

When the switch node tests to true, or ‘switches on’, it sends a message onto the fitbit node which is the next node in the flow. The fitbit node is another powerful built-in node that you can configure to get statistics on your fitbit device from the fitbit.com portal. The fitbit node packages the statistics for your device into a message and forwards it to the next node in the flow.

switchノードのテスト結果がtrueの場合には、「スイッチオン」になり、フローの次のノードにあるfitbitノードにメッセージを送ります。fitbitノードも最初から組み込まれている強力なノードで、fitbit.comポータルから、あなたのデバイスの情報を取得することができます。fitbitノードはその情報をパッケージにして、次のノードにメッセージとして送ります。

The next node is another switch node. This one has been configured to check if the number of steps you’ve walked today is less than 1000. It does this by testing to see if the fitbit data field, summary.steps, is less than 1000. Remember, it just got these statistics in a message from the fitbit node, which in turn got them by making a call to the fitbit API on fitbit.com.

次のノードもスイッチノードです。これは。今日あるいた歩数が1000より少ないかどうかをチェックします。fitbitデータのうち、summary.stepsの値をあっクニンして、1000より少ないかどうかを判断します。ここではあくまでfitbitノードから受け取った値を分析しているだけで、fitbit.com のAPIにアクセスしているのはfitbitノードです。

If you have walked less than 1000 steps today, then the switch node generates a message that is passed on through the flow to a function node. The function node is a generic all-purpose node that allows you to write your own programming logic in Javascript. This node will be discussed in more detail in the next lecture. For now you can assume that this node just creates a new message with an email subject line and a text body that can be sent by email.

もし今日1000歩歩いていなければ、スイッチノードはメッセージを作成し、次のファンクションノードに渡されます。ファンクションノードは、JavaScriptでロジックを自分で書くことができる、様々な目的のために使われるノードです。これについては次のレクチャーでより説明します。さしあたってここでは、このノードは単に新しいEメールのタイトルと、Eメールで送る内容をtext bodyとしてもったメッセージをつくっていると理解しておいてください。

Once this message is created within the function node, it is sent through the flow to the final node which is an email node. This node will take the body of any incoming message and send it to the email account configured when the node is initialized. In this case, you’d set it up to send a message to yourself.

このメッセージがファンクションノードの中で作られると、最後のノードに送られます。Emailノードです。このノードは、受け取ったメッセージのbodyをもとに、Eメールを設定されたアカウントに送ります。ここではあなた自身に送られるようにしておきます。

So again, a very simple flow that uses the power of Node-RED’s built-in nodes to check your local weather. And if it’s reasonably warm and you haven’t done much walking today, it sends you an email reminder.

振り返ってみましょう。とてもシンプルなフローですが、Node-REDが予め用意した便利なノードを使って天気をチェックします。そして温度がそれなりに暖かい日で、しかもあなたが今日十分に歩いていない場合には、リマインダーメールが送られます。

Although the example seems quite simple, just checking the weather and your fitbit activity, you can use similar flows to check the status of home devices, of computers in your server farm, of devices in a factory, etc., and you can then use output nodes to send mail, tweets, make API calls to back-office software, control real world devices – in fact the choices are endless. Node-RED is an extremely powerful tool for wiring together inputs and outputs and offers many nodes, either built in or developed by the Node-RED community, to carry out an amazing range of tasks.

この例はとてもシンプルで、天気やfibitの状態をチェックするだけですが、同様なフローを使って、家にある機器や、サーバーにあるコンピューターや、工場のデバイス等々をチェックすることができます。そしてoutputノードを使って、メールを送ったり、ツイートをしたり、バックオフィスにあるソフトウェアのAPIをたたり、実世界のデバイスをコントロールしたりすることができます。その選択肢は無限です。Node-REDはInputとoutputをつなぐパワフルなツールです。そのためのノードは、最初から組み込まれているものもありますし、ユーザーコミュニティによって開発されたものもあります。それによって驚くほど広範囲の処理をこなしてくれるのです。

You can find the node-red description of this flow at:

https://raw.githubusercontent.com/SenseTecnic/nrguideflows/master/lesson1/1-2_weatheralert.json

例1.3 Node-REDのHTTPノードを使って、シンプルなウェブサービスを構築する

Example 1.3 Building a simple web service using Node-RED’s built-in HTTP nodes

Our final example in this high-level introduction is yet another class of flows. It shows how to create a simple web service that responds to a browser sending a HTTP request by querying some real-world data, and then delivers a web page with a graphical representation of that data back to the browser – essentially Node-RED is being used to provide a web server and simple service all with a few nodes.

次の例は、ブラウザが送るHTTPリクエストによるリアルワールドの情報に対するqueryに応答する、シンプルなウェブサービスです。そしてデータをもとにしたグラフィカルな表示が含まれるウェブページを、ブラウザに返します。Node-REDはWebサーバを提供するためにも使えるので、シンプルなサービスであればかなり少ないノードで実現できます。

Sticking with the fitbit node introduced in the previous example, and this example creates a simple web service that allows you to query your fitbit stats for the day and, using a nice donut chart, display how many calories you’ve ‘burned off’ through exercise.

先程の例で紹介したFitbitノードをもう一度扱います。この例では、fitbitのその日の状態を問い合わせ、円グラフを使ってどれだけのカロリーを消費したかを示す、シンプルなアプリケーションを作ってみましょう。

The flow is shown in Fig 1.3 and consists of 4 nodes. The first and final nodes are http input and output nodes that work together to listen for HTTP requests and send HTTP responses. This flow listens for a HTTP request from any source, but let’s assume a regular browser here. When it arrives, it queries your fitbit stats from fitbit.com, then uses a template node to build a HTTP page, and passes that to the http output node which sends back the webpage to the browser.

次の図をみてください。4つのノードから構成されています。最初と最後のノードはHTTPに関するもので、outputとInputを担います。HTTPリクエストうけ、HTTPレスポンスを返します。どんなHTTPリクエストも受けることが出来るのですが、今回は一般的なブラウザからのリクエストを受けることにしましょう。HTTPリクエストが届くと、Node-REDはfitbit.comに問い合わせをして、fitbitの状態を取得します。そしてHTTPページを送信するためのテンプレートノードを使ってデータを作成し、それをHTTPoutputにわたし、そのウェブページをブラウザを介して返送します。

Figure 1.3 A simple web server example to graph fitbit data

Again, this is just to give you a sense of the power and flexibility of Node-RED without going into all the details of how this flow works. You’ll get to know more about that in later lectures. At a high level, the http input node has been configured to listen for HTTP requests on a URL, which is a combination of the hosting service that’s used in these lectures plus your login name {username} and the /fitbit string. This will be explained in more detail in lecture two.

振り返ってみましょう。HTTPInputノードは特定のURLへのHTTPリクエストを待ち受けます。これはホスティングサービスの名前と、それからユーザーネームと、fitbitという文字列から構成されています。これについてはレクチャー2で解説します。

When a HTTP request comes in, the http input node creates a message to trigger the fitbit node, which is the next node in the flow. The fitbit node gets the current statistics for the user, and then passes those statistics, as a message, to a template node. The html template node is another pre-built node in Node-RED, which, like the function node, allows you to build arbitrary code. However, rather than using JavaScript like the function node, the template node works with text such as HTML.

HTTPリクエストが送られてくると、HTTPインプットノードは、fitbitノードをトリガーするためのメッセージを生成します。fitbitノードは現在の状態を取得し、それをテンプレートノードにわたします。htmlテンプレートノードは、最初から用意されているノードの一つで、自由にコードをかくことができます。JSを書くことができるファンクションノードに似ていますが、テンプレートノードは、HTMLのような単なるテキストを作成するためにあります。

The HTML code in the template node is shown in Listing 1.1, so you can see what’s happening. However, there’s no need to examine it in detail if you don’t want to. Basically, the template node takes the calorie consumption data from fitbit and, using a 3rd party graphing library, creates a simple HTML file that will tell the receiving browser to use the 3rd party graphing library to display a donut chart of calorie consumption.

基本的にはテンプレートノードはカロリー消費のデータを受け取って、サードパーティーのグラフライブラリを使ってシンプルなHTMLファイルを作成し、そのファイルによってブラウザへ、ドーナッツを描画させているだけです。

Listing 1.1 A simple HTML template to display a donut chart of calorie usage

  1. <!doctype html>
  2. <head>
  3.     <title>A Node RED Example</title>
  4.     <link rel=”stylesheet” href=”//cdnjs.cloudflare.com/ajax/libs/morris.js/0.5.1/morris.css”>
  5.     <script src=”//cdnjs.cloudflare.com/ajax/libs/raphael/2.1.0/raphael-min.js”></script>
  6.     <script src=”//ajax.googleapis.com/ajax/libs/jquery/1.9.0/jquery.min.js”></script>
  7.     <script src=”//cdnjs.cloudflare.com/ajax/libs/morris.js/0.5.1/morris.min.js”></script>
  8. </head>
  9. <html>
  10.     <div id=”chart-example” style=”height: 250px;”></div>
  11.     <script>
  12.         Morris.Donut({
  13.            element: ‘chart-example’,
  14.            data: [
  15.              {label: “Activity Calories”, value: {{payload.summary.activityCalories}} },
  16.              {label: “Calories BMR”, value: {{payload.summary.caloriesBMR}} },
  17.              {label: “Calories Out”, value: {{payload.summary.caloriesOut}} }
  18.           ]
  19.        });
  20.     </script>
  21. </html>

Once the template node has generated the HTML file, it passes it as a message to the final node, which is a http response node. This node packages up the HTML as a HTTP response which it send back to the browser.

テンプレートノードがHTMLファイルを作成すると、それはメッセージとして最後のノード、HTTPレスポンスノードに渡されます。このノードがブラウザにレスポンスを返します。

The user will then see a simple donut chart of their calorie usage for the day (see Fig 1.4)  – all built and served by a simple Node-RED flow!

ユーザーはシンプルな円グラフによってこの日にどれだけのカロリーを消費したのかを確認することができます。全てNode-REDだけで作成され、そしてその上で機能しています!

 

 

Figure 1.4 A donut chart, served up by Node-RED showing calorie counts from fitbit

 

You can find the node-red description of this flow at:

https://raw.githubusercontent.com/SenseTecnic/nrguideflows/master/lesson1/1-3_webservice.json

The History of Node-RED

読めばわかる。ということで翻訳パス。

As the examples in the previous section have shown, Node-RED is a powerful tool for building IoT applications and services. Its genesis was triggered exactly by this need to rapidly prototype IoT applications and Node-RED was created as an open source project by the IBM Emerging Technologies group, in particular by two researchers, Nick O’Leary and Dave Conway-Jones. They created Node-RED initially as a tool for themselves as they were working on IoT projects and were “looking for a way to simplify the process of hooking together systems and sensors when building proof-of-concept technologies for customers.”

An initial version of Node-RED was released as an open source project in late 2013 and built up a small but active user and developer group during 2014. At the time of writing, Node-RED is still an emerging technology, but has already seen significant adoption by makers, experimentalists and a number of large and small companies experimenting with using it for their needs.

Today there is a vibrant user and developer community, with a core group working on the Node-RED code itself and most developers contributing nodes or flows to the flow library. You can check out the mailing list and github repositories using the links provided in Appendix A or just google them.

Since Node-RED is still a rapidly evolving technology, be aware that things can change quickly. These lectures were written against the 0.11.0 release of Node-RED and the examples will be updated as Node-RED evolves. However, it’s always wise, as with any new technology, to check compatibility if things aren’t working the way you expect.

Node-REDとIoT

Node-RED and the IoT

When the IBM folks created Node-RED, they were mostly focused on the Internet of Things, i.e connecting devices to processing and processing to devices. As a tool for rapid application development for the IoT, Node-RED is both powerful and flexible. Its power comes from a combination of two factors:

IBMのメンバーはNode-REDを作ったときには、IoTにフォーカスしていました。つまりデバイスをプロセスにつないだり、プロセスをデバイスにつなげるという使用方法です。IoTのための迅速なアプリケーション開発ツールであるので、Node-REDはパワフルであり、フレキシブルです。その強みは、次の2つの要素の組み合わせによってもたらされています。

  • Node-RED is an example of a flow-based programming model – messages representing events flow between nodes, triggering processing that results in output. The flow-based programming model maps well to typical IoT applications which are characterised by real-world events that trigger some sort of processing which in turn results in real-world actions. Node-RED packages these events as messages which offer a simple and uniform model for events as they flow between nodes that make up the flows.
  • Node-REDはフローベースのプログラミングモデルを採用しています。つまり、メッセージはイベントを表しており、これがノードの間を伝わっていきます。そして処理をトリガーして、その結果がoutputにもたらされます。フローベースのプログラミングモデルは、典型的なIoTアプリケーションに上手く適合します。つまり実世界のイベントが、ある処理をトリガーし、そしてそれが順番に処理されていって、最後に実世界へのアクションという結果を生むアプリケーションです。Node-REDはこれらのイベントをメッセージへとまとめあげて、イベントをシンプルで単一モデルで扱うことができ、ノード間をこのメッセージを流していきます。これがフロウです。
  • The set of built-in nodes is the second part of the Node-RED story. By building a set of powerful input and output nodes, each of which hides much of the complexity of interacting with the real world, Node-RED offers developers powerful building blocks to allow them to quickly put together flows that accomplish a lot, without having to worry about the programming details.
  • パワフルなinput/outputノードを組み立てることで、実世界と連携するための面倒事のほとんどから遠ざけてくれ、開発者は素早く問題解決のためのフローを作成することができます。プログラミングの細かいことを気にする必要がありません。

These two factors make Node-RED a powerful tool for IoT application development. When combined with the flexibility to create and use nodes such as the function node, which allows the developer to quickly write arbitrary JavaScript, plus the Node-RED community, who are constantly creating and sharing new nodes, Node-RED is likely to be one of the main tools in the IoT developers toolbox.

この2つの要因によって、Node-REDはIoTアプリケーション開発のための強力なツールになります。JSで書けるより柔軟性の高いファンクションノードや、Node-REDコミュニティが提供するノードを使うことで、IoT開発者にとって主要なツールとなったのです。

However, Node-RED isn’t always the best tool for IoT application development. While powerful and flexible, it isn’t always the right solution. Some situations where Node-RED may not be the first choice include:

しかし、Node-RED は常にベストなツールとは限りません。パワフルでフレキシブルではありますが、常に最適な解決法ではありません。Node-REDが第一の選択肢に上がらない場合には、次のようなケースがあるでしょう。

  • Complex multi-function IoT applications. Node-RED excels at rapid application development and at acting as the glue for connecting events to actions, or sensors to actuators, if you like. However, when an application gets above a certain size, it becomes complex to visually program and manage through Node-RED. There are some features to help with this, e.g. sub-flows (see lecture 5), but eventually the UI becomes a bottleneck.
  • 複雑で複数の機能を持つIoTアプリケーションの場合。Node-REDは迅速な開発、それからイベントやアクションをつなぐための「のり」としての役割においては、他を圧倒しますが、アプリケーションの規模がある程度大きくなってしまうと、ビジュアル・プログラミングで扱うには複雑すぎ、Node-REDで管理をするのが難しくなってきます。もちろんこの問題をサポートする幾つかの機能はあります。例えばsub-flows(これはレクチャー5で扱います)などがありますが、しかしいつかはUIがボトルネックになるときがきます。
  • Flow-based programming is a programming model that is not always the most suitable for application development. In much the same way that certain programming languages excel at some tasks but not others, flow-based programming has its weaknesses. A good example are loops: Node-RED is cumbersome when handling loops.
  • フローベースのプログラミングは、アプリケーション開発にとって常に最適なモデルだとは限りません。あるプログラミング言語がある特定のタスクに向いていても、他のタスクについてはそうではないように、フローベースののプログラミング言語にも弱点があります。例えばループはNode-REDでは扱うのがとても面倒です。
  • Specific use cases. Flow-based programming is a general purpose model and not targeted or optimized for specific needs, for example Data Analytics or User Interface development. At the moment Node-RED has no specific support for these type of applications and no easy way to add such support. Obviously, because the underlying technology of Node-RED is JavaScript, you can leverage its capabilities for these needs. If want to use Node-RED to prototype something, one approach is to implement parts or all of your application in another language more suited to your task and use Node-RED for the overall control.
  • 特定のケース。フローベースのプログラミングは、汎用的な目的に使われるモデルであって、特定の目的のために最適化されていません。例えば、データアナリティクスやユーザーインタフェースの開発には向いていません。今のところNode-REDはこういった種類のアプリケーション開発をサポートしていませんし、それらの機能を追加するのも簡単ではありません。Node-REDはJavaScriptによってできているので、その能力を使うことでこういった問題に対処することはできます。Node-REDをプロトタイプの作成に使いたいのであれば、一つの方法として、アプリケーションでつかうパーツや、もしくはアプリケーション全体を、他のもっと適した言語で作成し、Node-REDは、全体をコントロールするためだけに使う方法があります。

Having said that, as has been shown in this lecture and will be demonstrated in the following lectures,  Node-RED is a powerful tool for a large number of IoT applications. As it evolves it will become both more sophisticated and more usable in a wider range of circumstances.

既に説明してきたように、Node-REDはかなり範囲の広いIoTアプリケーションにとってパワフルなツールです。進化続けてきたことで、様々な状況において便利で洗練された解決策を提供します。

Perhaps just as important, as you explore Node-RED in subsequent lectures, you will realise that although Node-RED’s roots are in the IoT, it is a tool that can be used to build a wide variety of applications, not just IoT applications. In fact, in these lectures you will see example of Node-RED being used for web apps, social media apps, back-office integration, IT task management, i.e. across the range of modern computing tasks.

Node-REDの続くレクチャーにおいて探求していくにつれてわかると思うのですが、Node-REDはIoTに軸足を持ちつつも、IoTだけではない、より広い範囲のアプリケーションをつくるためにも有効です。Node-REDをウェブアプリのために使ったり、SNSアプリのためにつかったり、バックオフィスの統合のために使ったり、ITタスクのマネジメントのために使うことができます。コンピューターを使っておこなわれるタスク全体をカバーします。

Our hope is that by the end of this lecture course, you will see Node-RED, as we do, as a flexible and powerful tool that can be used in many situations, both for prototyping but also for production level development.

このレクチャーを通して、Node-REDがフレキシブルで強力なツールであり、さまざまな状況で使うことができ、プロトタイプの作成にとっても、製品レベルの開発においても、有効であることが伝われば幸いです。

要約

Summary

In this lecture we’ve taken you through a high-level look at Node-RED. You’ve seen how Node-RED wires together building blocks, using a visual tool to rapidly create simple flows that actually carry out sophisticated real-world tasks. You’ve also learnt a little about the origins of Node-RED as a rapid application development tool for the IoT and how, as it has evolved, it’s now being used for a variety of tasks, not just IoT programming. Finally, we’ve discussed the limitations of Node-RED and indicated some areas where other languages and tools may serve you better. In the next lecture, we’ll start on some real programming and show you how to build your own flows using the basic nodes that Node-RED provides.

このレクチャーでは、Node-REDの概念について説明してきました。Node-REDはブロック同士を接続し、視覚的なツールをつかって速攻でシンプルなフローを作成し、洗練された方法で実世界のタスクを処理してくれます。またNode-REDの起源と歴史についても説明しました。IoTのためのツールで、迅速に開発するために生まれたのですそして今ではより広い範囲のタスクを処理するためにも使うことができ、IoTの範囲に留まりません。最後に、Node-REDの限界について検討し、一般的な他の言語やツールをもちいたほうがよいシーンについても考察しました。次のレクチャーでは、実際のプログラミングをしていきながら、フローを作成していきます。ここでは最初から組み込まれたノードを使っていきます。

display: flex で画面幅に対して相対的に縦横の長さが決まる親要素divの中に、親要素の幅に対して比率で決まる画像を中央に配置する

タイトルが長くなったが、レスポンシブのサイトを画像メインで作る場合によく使うレイアウトで、幅、高さを親要素に対する割合で決めて、さらにその中に伸縮する画像を中央に配置したい場合のやりかた。

.background に対してバックグラウンドイメージを指定すると、背景画像を使ったボタンに、画像のテキストを中央揃え、といったことが可能になる。

See the Pen used display: flex center by nakanishi (@nakanishi) on CodePen.

ちなみに以下のようなレイアウトにしてもflexは思った通りにはならない。何故なら子要素としてボタン用とテキスト用の画像があるため、この2つを並べようとしてしまうため。absolute のほうだけを真ん中に、みたいな気持ちはあるが、ならない。

<div display:flex, justify-content:center, align-items: center/>
<img/ ボタンの画像>
<img/ ボタンのテキスト absolute>
</div>

Sonic Pi メモ

全て公式マニュアルから引用

ショートカットキー

  • cmd R ラン
  • cmd S ストップ
  • cont a 行頭、 cont e 行終わりに移動
  • cont k 一行削除
  • cmd i ヘルプ
  • cmd m コード整列
  • cmd d,h 前後の文字を消す
  • cmd shift b ボタンを消す
  • cnt shif {} バッファータブを左右に移動

言語選択

言語選択を設定画面からおこなうことができない。unix コマンドでできそうな情報もあるがわからなかった。OS の言語が、そのまま Sonic Pi の言語として選択されてしまうので、さしあたって Mac の第一言語を英語に変えた。

音の指定

配列に入れる

配列にいれて再生した場合には、配列内のデータを全て同時に再生するので、ここでは和音が演奏される。

MIDIノートナンバーでの指定

play [52, 55, 59]

音名での指定

play [:E3, :F4, :G5]

配列から一つ指定する

play [:E3, :F4, :G5][2]

↑はG5だけが、単音として再生される。プログラミング恒例の、1番目を指定するには0のスタイル。

コード

play chord(:E3, :minor)

  • chord(:E3, :m7)
  • chord(:E3, :minor)
  • chord(:E3, :dim7)
  • chord(:E3, :dom7)

使えるコードのリストは Lang 内の chord の中にある。特殊なやつは”で囲むパターン。

(chord :C, ‘1’)
(chord :C, ‘5’)
(chord :C, ‘+5’)
(chord :C, ‘m+5’)
(chord :C, :sus2)
(chord :C, :sus4)
(chord :C, ‘6’)
(chord :C, :m6)
(chord :C, ‘7sus2’)
(chord :C, ‘7sus4’)
(chord :C, ‘7-5’)
(chord :C, ‘m7-5’)
(chord :C, ‘7+5’)
(chord :C, ‘m7+5’)
(chord :C, ‘9’)
(chord :C, :m9)
(chord :C, ‘m7+9’)
(chord :C, :maj9)
(chord :C, ‘9sus4’)
(chord :C, ‘6*9’)
(chord :C, ‘m6*9’)
(chord :C, ‘7-9’)
(chord :C, ‘m7-9’)
(chord :C, ‘7-10’)
(chord :C, ‘9+5’)
(chord :C, ‘m9+5’)
(chord :C, ‘7+5-9’)
(chord :C, ‘m7+5-9′)
(chord :C, ’11’)
(chord :C, :m11)
(chord :C, :maj11)
(chord :C, ’11+’)
(chord :C, ‘m11+’)
(chord :C, ’13’)
(chord :C, :m13)
(chord :C, :add2)
(chord :C, :add4)
(chord :C, :add9)
(chord :C, :add11)
(chord :C, :add13)
(chord :C, :madd2)
(chord :C, :madd4)
(chord :C, :madd9)
(chord :C, :madd11)
(chord :C, :madd13)
(chord :C, :major)
(chord :C, :M)
(chord :C, :minor)
(chord :C, :m)
(chord :C, :major7)
(chord :C, :dom7)
(chord :C, ‘7’)
(chord :C, :M7)
(chord :C, :minor7)
(chord :C, :m7)
(chord :C, :augmented)
(chord :C, :a)
(chord :C, :diminished)
(chord :C, :dim)
(chord :C, :i)
(chord :C, :diminished7)
(chord :C, :dim7)
(chord :C, :i7)

アルペジオ

play_pattern chord(:E3, :m7)

間隔、sleep: 1 スリープタイムを 0.25 に明示的に指定。

play_pattern_timed chord(:E3, :m13), [0.25, 0.5]

1番目、3番目、5番目…は0.25で、2,4,6…は0.5で。

スケールの演奏

play_pattern_timed scale(:c3, :major), 0.125, release: 0.1

We can even ask for more octaves: オクターブ範囲を指定

play_pattern_timed scale(:c3, :major, num_octaves: 3), 0.125, release: 0.1

How about all the notes in a pentatonic scale?  ペンタトニックもある

play_pattern_timed scale(:c3, :major_pentatonic, num_octaves: 3), 0.125, release: 0.1

ランダム選択

use_synth :tb303
loop do
play choose(chord(:E3, :minor)), release: 0.3, cutoff: rrand(60, 120)
sleep 0.25
end

Eminor の3音からランダムで選択

ループさせる ring 機能

puts [52, 55, 59][1]
counter = 0
notes = [52, 55, 59]
puts notes[counter]

この2つのどちらかで可能

(ring 52, 55, 59)
[52, 55, 59].ring

配列の操作

8.5 ring chains に多く配列操作の仕組みがある。

WebStorm の設定を複数の端末で共有する

WebStorm の設定、例えばショートカットキーやエディター画面の色、等を Git で管理して、保存、参照することができます。現在の最新版、WebStorm 2017.1 には必要なプラグインが最初から入っています。

同期といってもローカルの設定を変更した場合に、それがリモートのリポジトリに勝手に反映されるのではないようです。ローカルでの変更をリモートのリポジトリに反映させたい場合には、File → Setting Repository から Overwrite Remote してあげればいいようです。

なので運用としては、常にローカルの設定をリモートと同期させておいて、ローカルで設定変更をしたら、それをリモートにプッシュ。でいいのではないでしょうか。

https://www.jetbrains.com/help/webstorm/2017.1/settings-repository.html

Sharing Your IDE Settings

On this page:

Introduction

WebStorm allows you to share your IDE settings between different instances of WebStorm (or other IntelliJ platform-based) products installed on different computers.

WebStorm は、複数の異なるコンピューターにインストールされていても、その設定を共有することができます。

This is useful if you are using several WebStorm installations, or want to implement the same settings among your team members or company-wide.

この機能は次の場合に有用です。例えばウェブストームを複数のパソコンにインストールしている場合や、同じ設定をチームメンバーや会社で共有したい場合です。

Prerequisites

 

Before you start working with Settings Repository, make sure that the Settings Repository plugin is enabled. The plugin is bundled with WebStorm and is activated by default. If the plugin is not activated, enable it on the Plugins page of the Settings / Preferences Dialog as described in Enabling and Disabling Plugins.

設定保存用のレポジトリでの作業をするまえに、まずは Setting Repository プラグインが有効になっていることを確認してください。このプラグインはウェブストームに最初から含まれており、初期設定で有効になっています。もし有効になっていなければ設定画面のプラグインページで有効にしてください。

Configuring settings repository

If you want to share your IDE settings, perform the following steps:

IDE の設定を共有するためには、次の作業をおこなってください。

  1. Create a Git repository on any hosting service, such as Bitbucket or GitHub.  Git リポジトリを Bitbucket や GitHub といたホスティングサービス上で作成してください。
  2. On the computer where the WebStorm instance whose settings you want to share is installed, navigate to File | Settings Repository. Specify the URL of the repository you’ve created and click Overwrite Remote.
    共有したい設定がされているウェブストームがインストールされているパソコンで次の作業をします。File → Settings Repository → 設定を保存するためのリポジトリのURLを記入します。その上で Overwite Remote を選択して、リポジトリに上書きします。
  3. On each computer where you want your settings to be applied, in the Settings/Preferences dialog, expand the Tools node and choose Settings Repository, specify the URL of the repository you’ve created, and click Overwrite Local.You can click Merge if you want the repository to keep a combination of the remote settings and your local settings. If any conflicts are detected, a dialog will be displayed where you can resolve these conflicts.
    次に、保存した設定を適用させたいパソコンでは次の作業をおこないます。Settings/Preferences → Tools → 先程作り設定を保存したリポジトリの URL を設定します。そして Overwrite Local をクリックしてローカルの設定を上書きします。もしリモートリポジトリの設定と自分のローカルの設定との組み合わせにしたい場合は、Merge を選択します。それによってコンフリクトが発生した場合は、そのコンフリクトを解消するようにダイアログが表示されます。If you want to overwrite the remote settings with your local settings, click Overwrite Remote.
    ローカルセッティングをリポジトリに上書きしたい場合には Overwrite Remote を選択します。

    Your local settings will be automatically synchronized with the settings stored in the repository each time you perform an Update Project or a Push operation, or when you close your project or exit WebStorm.

    ローカルの設定は自動的にリポジトリに保存された設定と、次のタイミングで同期します。プロジェクトをアップデートした時、プッシュした時、プロジェクトを閉じた時、ウェブストームを閉じたときです。

If you want to disable automatic settings synchronization, navigate to File | Settings | Tools | Settings Repository and disable the Auto Sync option. You will be able to update your settings manually by choosing VCS | Sync Settings from the main menu.

設定の自動同期を無効にしたい場合は、File → Setting → Tools → Settings Repository から Auto Sync を向こうにしてください。その場合は、VCS → Sync Setting から手動で同期を行うことができます。

Authentication

On the first sync, you will be prompted to specify a username and password.

It is recommended to use an access token for GitHub authentication. If, for some reason, you want to use a username and password instead of an access token, or your Git hosting provider doesn’t support it, it is recommended to configure theGit credentials helper.

Note that the macOS Keychain is supported, which means you can share your credentials between all IntelliJ Platform-based products (you will be prompted to grant access if the original IDE is different from the requestor IDE).

Configuring a read-only source

Apart from the Settings Repository, you can configure any number of additional repositories containing any types of settings you want to share, including live templates, file templates, schemes, deployment options, etc.

These repositories are referred to as Read-only sources, as they cannot be overwritten or merged, just used as a source of settings as is.

To configure such repositories, do the following:

  1. In the Settings/Preferences dialog, expand the Tools node and choose Settings Repository.
  2. Click /help/img/idea/2017.1/add_icon.png and add the URL of the GitHub repository that contains the settings you want to share.

Synchronization with the settings from read-only sources is performed in the same way as for the Settings Repository.