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.


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.


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.



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, or the one that will be used in this lecture, 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.


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


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とか、ですね。


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 (, the mqtt 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.


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.


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.


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).



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.


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

例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.


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.



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:

例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.


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.


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:

例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).


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%.


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.


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:

例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.


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.


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.


Figure 3.16 Final scaled output when analysis is turned off


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


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.


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.


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



次に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.


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.


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: (

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:// 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:

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 (

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:” 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 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 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:


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: 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.


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.


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


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



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.


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.


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.



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.


There are three main  types of nodes:


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


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).


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.


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


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.


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.


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.


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.


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.


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.


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


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.


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.


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.


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.


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.


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:

例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 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.


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 and follow the instructions as shown in the screenshots below.

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



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:


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.


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 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 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.


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


  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.


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 ( === “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.


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


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.


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:


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.


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.


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:


例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.


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 portal. The fitbit node packages the statistics for your device into a message and forwards it to the next node in the flow.


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

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


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.


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.


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

例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.


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.


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, 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.


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.


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.


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.


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=”//”>
  5.     <script src=”//”></script>
  6.     <script src=”//”></script>
  7.     <script src=”//”></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.


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!




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:

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 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:


  • 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.


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.


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.


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.




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.


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>

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 の第一言語を英語に変えた。





play [52, 55, 59]


play [:E3, :F4, :G5]


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



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]



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

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

ループさせる ring 機能

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


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


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

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

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

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


Sharing Your IDE Settings

On this page:


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.




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 から手動で同期を行うことができます。


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.

z-index, stacking context の説明

重なり順をコントロールするためには z-index を使えばいい。上にしたい要素ほど高い z-index の値を与えればいい。と思っていたら全然重なり順が思った通りにならない!!といった経験は CSS を書き始めたばかりの人間が必ず経験する出来事だと思う。


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

まずこの記事を読んでほしいんですが、経験の浅いウェブディベロッパーが z-index で混乱するのは、次の原則を知らないからだと。「z-index は要素の position が absolute, fixed, ralative に指定されていないと機能しない。」作業で疲れてくるとこういうところを見逃しがちです。

その上で MDN のこの記事を読みます。Stacking Context に関する話です。


It is important to note that DIV #4, DIV #5 and DIV #6 are children of DIV #3, so stacking of those elements is completely resolved within DIV#3. Once stacking and rendering within DIV #3 is completed, the whole DIV #3 element is passed for stacking in the root element with respect to its sibling’s DIV.

#4, #5, #6 の DIV は #3 の子要素なので、#4, #5, #6 の重なり順は DIV#3 の中だけで解決されます。DIV#3 のなかで重なり順が処理された後は、DIV#3 は一つ上の階層、つまりここでは Root エレメントの階層の中での重なり順の処理に移行します。ここではルート階層内の親要素とかなり順を考慮することになります。


  1. まずは重なり順に関係してくる要素には必ず position: relative, absolute, fixed のどれかを付ける。(他にも flex とか opacity:0 以外でもなるようだけれども、重なり順のコントロールのためには普通は使わない)
  2. 重なり順が z-index でコントロールできるのは「兄弟要素」の間だけ。
  3. 子要素は絶対に親要素の下には配置できない。
  4. 2,3 が起きるのは スタッキング・コンテクストという考え方が必要になる。
  5. スタッキング・コンテクストのダイジェスト:ある要素の中に potision: static 以外の position を持つ子要素がある場合、まずはその子要素の中だけで z-index の順番に重なり合う。この重なりが決まった時点で、それらの子要素は、親要素の上に乗っかって、それら全体で一枚の紙のような扱いになる。一枚の紙のようになった要素は、さらに親要素があって、兄弟要素があれば、兄弟要素の中でまたこのスタッキングコンテクストの処理をする。→以降無限にこの処理

ということで DOM ツリーの中で、同じ親要素を持つ要素同士 = 兄弟要素内でしか z-index の並び順は効かない。ってことですね。 わかればなんということはない!!


npm script でタスク処理する開発環境を作った npm スクリプトでタスク処理をする環境を作りました。akabebeko さんのものを元に修正しました。.sass, Babel, Browserify, 開発用サーバーを立てる、デプロイ用のイメージを作成する


npm-scripts で Web フロントエンド開発を管理する


  • stylus ではなく Sass を使用する。そのための npm は node-sass を用いる。
  • Sass の import のためのディレクトリも最初から用意。
  • assets以下に、jsだけしか入っていないフォルダ (例えば自分以外の人が以前のプロジェクトで書いたjsを引き継ぐとか、npm にないライブラリを、bower も使わないで管理したいとかそういうフォルダ) を無理くりコピーする。本当は cpx でバチコーンと出来るはずだとは思うんですが、書き方がわからなかった!!
  • 自分は絶対使うので最初から jQuery を仕込む。


ScrollMagic のドキュメントを翻訳する

ランディングページで多用される、スクロール位置でトリガーされるアニメーションを実装するために便利なライブラリ、ScrollMagic について学びます。



Getting Started : How to use ScrollMagic


How does ScrollMagic work?

ScrollMagic はどのように動作しますか?

The principle design pattern of ScrollMagic is a controller[1] that has an arbirtary number of scenes[2] attached to it.

ScrollMagic は基本的に、controller[1] と、それに紐付けられる任意の下図の scenes[2] から構成されています。

  1. There is one controller for each scroll container. In most cases there is only one controller object and the scroll container is the browser window. But you can also use DIV elements for scrolling and even have multiple containers on your page. The controller also defines which direction should be scrolled (horizontal or vertical) and is responsible for keeping all scenes updated.

スクロールするコンテナ毎にそれぞれ1個の controller をもつようにします。大抵のサイトでは、ブラウザ・ウィンドウ用に1つのコントローラーをもつことになります。他にもスクロールする複数の要素を保つ場合には、複数のコントローラーを用意し、それぞれのスクロールに対して ScrollMagic を使うこともできます。controller は、どちらの方向に(縦か横か)スクロールするかを定義することができ、?また全てのシーンを常に最新の状態で保持します。

  1. A scene defines what should happen when, meaning at which scroll position. It can trigger animations, pin an element, change element classes or anything else you might desire.

Scene は、何が、いつ(つまりどのスクロールポジションで)始まるかを定義します。scene はアニメーションをトリガーしたり、要素を固定したり、要素のクラスを変更したり、他にもなんでもできます。

Defining the Controller


As mentioned above in most cases the scroll container is the browser window. To create a ScrollMagic controller with the default settings we use the main ScrollMagic.Controller()class. We create a new instance of it and assign it to a variable, so we can reference it later:

既に述べたように、多くの場合は controller はブラウザ・ウィンドウ用に一つだけ作成する場合が多いでしょう。ScrollMagic の controller を初期設定の状態で作成するには、ScrollMagic.Controller() クラスを使用します。これを用いて新しいインスタンスを作成し、これに対して変数を与えます。変数については後述します。

var controller = new ScrollMagic.Controller();

That’s it! Now for the more interesting part:

これだけです。では続いて、ScrollMagic の面白いパートに進みましょう。

Defining Scenes

Scene を定義する

Scenes are created by using the ScrollMagic.Scene() class. A ScrollMagic.Scene defines where the controller should react and how. Here we define a variable called “scene” and we’ll create a new ScrollMagic.Scene() instance.

Scene は ScrollMagic.Scene() クラスを用いて作成します。ScrollMagic.Scene は、どの位置から controller が反応し、そしてどのような動作をするかを定義します。次のコードで、scene という名前の変数を指定し、その中に ScrollMagic.Scene() で作成した新しいインスタンスを代入しましょう。

var scene = new ScrollMagic.Scene();

Inside ScrollMagic.Scene we can place an object of associated properties and values that are made available according to the docs
These options describe the behavior of our Scene and in order to figure out what value has what effect you can play around in the Scene Manipulation Example

ScrollMagic.Scene の中に、オブジェクトを配置することができます。このオブジェクトはプロパティと値を持ちます。どんなものが使用可能かは docs  を参照してください。これらのオプションでどのような挙動をシーンにさせるのかを定義します。どんな効果があるのかを Scene Manipulation Example で色々試してみてください。

var scene = new ScrollMagic.Scene({
  offset: 100, // start scene after scrolling for 100px
  duration: 400 // pin the element for 400px of scrolling

100px スクロールした後に scene をスタートさせて、400px スクロールするまで固定します。

Adding Scenes to Controller

Scene を コントローラーに追加する

In order to have the scenes react to the scrolling of the container we have to add our scene to the controller we defined at the very beginning…

scene をコンテナのスクロールに反応させるために、scene を controller に追加しなくてはいけません。そう、一番最初に定義した controller にです。

var scene = new ScrollMagic.Scene({
  triggerElement: '#pinned-trigger1', // starting scene, when reaching this element この要素にスクロールが到着したら、シーンを始めます
  duration: 400 // pin the element for a total of 400px 要素を400px固定します
.setPin('#pinned-element1'); // the element we want to pin 固定したい要素を指定します

// Add Scene to ScrollMagic Controller シーンを Controller に追加します

If you desire multiple scenes at once you can pass them to the controller just as the example shows below:


// Add Scene to ScrollMagic Controller

Instead of telling the controller what scenes to add you can also tell the scene to be added to a certain controller:

controller に対してどのシーンを追加するかを指定するのではなくて、シーンに対してどの controller に自分自身を追加するかを指定することもできます。

var scene = new ScrollMagic.Scene({
  triggerElement: '#trigger1'
.addTo(controller); // Add Scene to ScrollMagic Controller

var scene2 = new ScrollMagic.Scene({
  triggerElement: '#trigger2'
.addTo(controller); // Add Scene to ScrollMagic Controller

In the above example we’re using a technique called ”chaining” with the addTo(). If no Semicolon ends the line, we can continue adding ScrollMagic.Scene methods and ”chain” them together.

上記の例で、addTo()の部分でいわゆる「チェイニング」という技術を使っています。セミコロンが行の終わりにない場合には、ScrollMagic.Scene のメソッドを続けていくことができ、それによって連結していくことができます。

Next let’s start adding some animation to our scenes in the next Chapter: Tweens

Plugin: Velocity

ScrollMagic 単体よりも、Velocity.js と連携することでより多用なアニメーションを可能にすることが出来る。そのためのプラグインとメソッドについて。

This plugin is meant to be used in conjunction with the Velocity animation framework. It offers an easy API to trigger Velocity animations.

このプラグインは アニメーションのためのフレームワークである Velocity と連携するためのものです。これによって 簡単に Velocity のアニメーションをトリガーする API を使うことができます。

With the current version of Velocity scrollbound animations (scenes with duration) are not supported.
This feature will be added as soon as Velocity provides the appropriate API.

現在の Velocity のバージョンでは、scrollbound アニメーションは対応していません。(scene に duration を与えた場合) これは Velocity 側が適切な API を提供をしてくれれば、すぐに実現できます。

To have access to this extension, please include plugins/animation.velocity.js.




Scene.setVelocity(elems, properties, options) → {Scene}


Add a Velocity animation to the scene. The method accepts the same parameters as Velocity, with the first parameter being the target element.

Velocity アニメーションをシーンに追加します。このメソッドは Velocity と同じパラメーターを使うことができます。最初のパメーターは対象の要素になります。

To gain better understanding, check out the Velocity example.

より理解するために、次のサンプルを参照してください。Velocity example.


Scene.setVelocity(elems, properties, options) → {Scene}

Name Type Description
elems object | string One or more Dom Elements or a Selector that should be used as the target of the animation.

1つ以上の Dom 要素か、セレクタを指定します。これがアニメーションの対象となります

properties object The CSS properties that should be animated.

アニメーション用の CSS プロパティ

options object Options for the animation, like duration or easing.

例えば duration や easing


Parent object for chaining. { Scene }

// trigger a Velocity animation
scene.setVelocity("#myElement", {opacity: 0.5}, {duration: 1000, easing: "linear"});

Scene.removeVelocity(reset) → {Scene}


Remove the animation from the scene. This will stop the scene from triggering the animation.

Using the reset option you can decide if the animation should remain in the current state or be rewound to set the target elements back to the state they were in before the animation was added to the scene.

Name Type Argument Default Description
reset boolean <optional> false If true the animation will rewound.

Parent object for chaining. { Scene }

// remove the animation from the scene without resetting it

// remove the animation from the scene and reset the elements to initial state

Plugin: addIndicators

This plugin was formerly known as the ScrollMagic debug extension. It enables you to add visual indicators to your page, to be able to see exactly when a scene is triggered.

このプラグインは以前 ScrollMagic debug extension と呼ばれていました。このプラグインを使うことで、ページにデバグ用のインジケーターを追加し、視覚的にシーンがいつトリガーされるのかを確認することができます。

To have access to this extension, please include plugins/debug.addIndicators.js.



new ScrollMagic.Controller(options)

Every ScrollMagic.Controller instance now accepts an additional option.
See ScrollMagic.Controller for a complete list of the standard options.

それぞれの ScrollMagic.Controller インスタンスは、追加オプションを受け取ることができます。受け取ることが出来るオプションの全リストは ScrollMagic.Controller をみてください。


Name Type Argument Description
options object <optional> Options for the Controller.


Name Type Argument Default Description
addIndicators boolean <optional> false If set to true every scene that is added to the controller will automatically get indicators added to it.

true を指定すると、このコントローラーに追加された全てのシーンに対して、自動的にインジケーターを表示するようになります。



// make a controller and add indicators to all scenes attached
// コントローラーを作り、このコントローラーに追加される全てのシーンに対して、インディケーターを表示させる
var controller = new ScrollMagic.Controller({addIndicators: true});

// this scene will automatically have indicators added to it
// 次のコードで作成されたシーンは自動的にインディケーターが表示されます

new ScrollMagic.Scene()


これはシーンが持つことができるオプションの一つで、シーンのトリガー位置を微調整できる。( ここで試すといい )

triggerHook number | string  トリガーフックの持つことが出来るパラメーターは数字か文字列
デフォルトの設定は “onCenter”
Can be a number between 0 and 1 defining the position of the trigger Hook in relation to the viewport. 0から1までの数字を設定でき、これによってどの視線位置(ブラウザのどの位置)からトリガーを開始するかを指定する。

Can also be defined using a string: 次のように文字列で指定することもできる。

“onEnter” => 1 //これはブラウザの一番下の部分でスタートさせる
“onCenter” => 0.5 //これはブラウザの真ん中
“onLeave” => 0 // これはブラウザの一番上でスタート

// create a standard scene and add it to a controller
new ScrollMagic.Scene()

// create a scene with custom options and assign a handler to it.
var scene = new ScrollMagic.Scene({
duration: 100,
offset: 200,
triggerHook: “onEnter”,
reverse: false


これも triggerHook と同じで、シーンが持つことができるオプションの一つで、スクロール位置を戻した時に、アニメーションを逆再生するかしないかを指定する。

boolean をとる
true が初期値
Should the scene reverse, when scrolling up? スクロールを戻した時に、アニメーションを逆再生させるかどうかを指定する。

window.Main = Main;

<script src="./js/velocity.min.js"></script> いつものやつ
<script src="./js/velocity.ui.min.js"></script> UIアニメーション
<script src="./js/ScrollMagic.min.js"></script> 位置情報からトリガーするライブラリ
<script src="./js/animation.velocity.min.js"></script> ScrollMagic のプラグインで velocity との連携を行う
<script src="./js/app.js"></script> メインスクリプト