Galileo Tutorial
Networking and node.js
Senzations 2014
Jason Wright
Biograd na Moru
Galileo Tutorial I/Os, Sensing and Actuation
WHAT WILL YOU MAKE?
Learning goals
Basics of node.js
why & how its useful
server/client networking
How to deploy a node.js server on Galileo
Interacting with Galileo through the browser
Reading and displaying sensor data
Galileo Tutorial I/Os, Sensing and Actuation
WHAT WILL YOU MAKE?
What is node.js?
node.js (or just node) is a JavaScript runtime designed for lightweight
server applications
It is not a full webserver (e.g. Apache, nginx)
The incoming request handler is single-threaded instead of multithreaded
request
request
request
request
request
request
thread
request
thread
thread
thread
thread
Traditional server
3
Galileo Tutorial I/Os, Sensing and Actuation
request
node.js server
WHAT WILL YOU MAKE?
Why use node.js?
Consistent: Server/client language and data representations are the
same
Scalable: Single-threaded architecture minimizes memory usage
and avoids cost of context-switching between threads
Problem: What if one client is computationally demanding?
Problem: What if theres a core exception?
Fast (at certain things)
node is especially useful if I/O is likely to be your bottleneck (i.e., your
server isnt doing that much)
examples: queued inputs, data streaming, web sockets
Generally speaking, node is ideal for lightweight, real-time tasks and
a bad choice for computationally intensive tasks
Galileo Tutorial I/Os, Sensing and Actuation
WHAT WILL YOU MAKE?
Setting up networking on Galileo
Setup WiFi SSID and authentication (as needed)
Enable network interface
ifup eth0
ifup wlan0
Check network status
ifconfig
Galileo Tutorial I/Os, Sensing and Actuation
WHAT WILL YOU MAKE?
Setting up node.js on Galileo
Node should come preinstalled on your Galileo image
Verify that its installed and working:
node --version
Test it out using the interactive shell:
The interactive shell will
always print the return value
of any command.
console.log has no return
value, so it prints undefined.
Ctrl+D to quit (or Ctrl+C twice)
Galileo Tutorial I/Os, Sensing and Actuation
WHAT WILL YOU MAKE?
Setting up node.js on Galileo
You can also run node by passing in a script this is how well
handle server operations
Galileo Tutorial I/Os, Sensing and Actuation
WHAT WILL YOU MAKE?
Setting up node.js on Galileo
Node comes with its own package manager, called npm
Also verify that this is installed and working
npm version && npm ls
Well install some packages that will come in handy, but first we
need to correct the Galileos clock
If you dont do this, date will be wrong and npm installations will fail with
an SSL CERT_NOT_YET_VALID error
Galileo Tutorial I/Os, Sensing and Actuation
WHAT WILL YOU MAKE?
Setting up node.js on Galileo
Install a few modules (this can be a bit slow)
npm install express ejs socket.io galileo-io
Galileo Tutorial I/Os, Sensing and Actuation
WHAT WILL YOU MAKE?
Writing a server, part 1: http
The http module handles requests and responses via a server object
Most basic example (server_basic.js):
var http = require("http");
var server = http.createServer(function(request, response) {
response.writeHead(200, {"Content-Type": "text/html"});
response.write("Galileo Server!");
response.end();
});
server.listen(80);
console.log("Server listening!");
Launch this server by calling it with node:
node server_basic.js
Youll notice the program doesnt terminateit will continually run
and process requests as they come in
10
Galileo Tutorial I/Os, Sensing and Actuation
WHAT WILL YOU MAKE?
Writing a server, part 1: http
11
Galileo Tutorial I/Os, Sensing and Actuation
WHAT WILL YOU MAKE?
Writing a server, part 2: express
express is a web application framework for node
In this context well mainly be using it as a way to serve up dynamically
generated HTML content, but it has many other features
Main benefit in this context is that we can use a templating engine to
avoid spitting out tons of HTML in a redundant way
12
Well use ejs as our templating engine (jade, haml are also popular)
Instead of directly writing the HTTP response, pass in a view and a set of
parameters
Galileo Tutorial I/Os, Sensing and Actuation
WHAT WILL YOU MAKE?
Writing a server, part 2: express
Server (server_express.js):
var express = require('express');
var app = express();
app.set('view engine', 'ejs');
app.get('/', function(request, response) {
response.render('index', {
title: 'Home',
message: 'This is an Express app running on the Galileo'
});
});
app.listen(80);
console.log("Server listening!");
Template (views/index.ejs):
<!doctype html>
<html lang="en">
<head>
<title><%= title %></title>
</head>
<body>
<h1><%= title %></h1>
<p><%= message %></p>
</body>
</html>
13
Galileo Tutorial I/Os, Sensing and Actuation
WHAT WILL YOU MAKE?
Writing a server, part 2: express
14
Galileo Tutorial I/Os, Sensing and Actuation
WHAT WILL YOU MAKE?
Writing a server, part 3: sockets
WebSockets a full-duplex (bidirectional) TCP communications
channel
socket.io a simple-to-use WebSockets implementation for node
server_socket.js:
var io = require('socket.io').listen(server);
...
io.on('connection', function(socket) {
console.log('user connected');
socket.on('myAction', function(msg) {
console.log('woohoo!');
});
});
views/action.ejs:
<script src="/socket.io/socket.io.js"></script>
<script>var socket = io();</script>
<button onclick="socket.emit('myAction');">Click Me!</button>
15
Galileo Tutorial I/Os, Sensing and Actuation
WHAT WILL YOU MAKE?
Working with sensor data
Linux provides a virtual filesystem called sysfs that allows for easy
access to underlying hardware from userspace
This makes working with sensor data as simple as reading and
writing to files
Arduino functionality on Galileo is implemented via abstracted sysfs
interactions
Quick example: reading the core temperature
16
cat /sys/class/thermal/thermal_zone0/temp
Divide by 1000 to get the SoC temperature in C
(Quark can run hot, but its normal)
Galileo Tutorial I/Os, Sensing and Actuation
WHAT WILL YOU MAKE?
Working with sensor data GPIO access
Export the port
echo -n "3" > /sys/class/gpio/export
A new folder (gpio3) will appear in /sys/class/gpio
This particular GPIO pin is wired to the green onboard LED
Set port direction
echo -n "out" > /sys/class/gpio/gpio3/direction
Read/write value
17
echo -n "1" > /sys/class/gpio/gpio3/value
echo -n "0" > /sys/class/gpio/gpio3/value
Galileo Tutorial I/Os, Sensing and Actuation
WHAT WILL YOU MAKE?
Working with sensor data ADC read
For this example well use the Grove Shield with the light sensor
connected to A0
18
Galileo Tutorial I/Os, Sensing and Actuation
WHAT WILL YOU MAKE?
Working with sensor data ADC read
First, set a multiplexer value to connect the GPIO to the ADC
echo -n "37" > /sys/class/gpio/export
echo -n "out" > /sys/class/gpio/gpio37/direction
echo -n "0" > /sys/class/gpio/gpio37/value
Next, read directly from sysfs
cat /sys/bus/iio/devices/iio\:device0/in_voltage0_raw
The Galileos ADC chip (AD7298) can be temperature compensated
for more accurate measurements
Once you have exported the GPIO pins you need, you dont need to
do it again
19
Galileo Tutorial I/Os, Sensing and Actuation
WHAT WILL YOU MAKE?
Back to node fs and galileo-io
There is a node module called fs to handle filesystem interactions
fs.readFile('/etc/passwd', function (err, data) {
if (err) throw err;
console.log(data);
});
We could use this to handle all GPIO interactions, but there is a
nice npm wrapper called galileo-io to make this a little cleaner
20
This is only capable of digital read/write and analog read/write from
individual pins
Other useful Galileo hardware requires a bit more (UART, I2C, SPI, etc)
Galileo Tutorial I/Os, Sensing and Actuation
WHAT WILL YOU MAKE?
Writing a server, part 4: data
This example will stream new ADC measurements using socket.io
A static content folder is needed to serve up the client-side JS
server_data.js:
var Galileo = require('galileo-io');
var board = new Galileo();
app.use(express.static(__dirname + '/js'));
...
board.analogRead("A0", function(data) {
io.emit('data', data);
});
views/data.ejs:
<script src="jquery-1.11.1.min.js"></script>
<script>
socket.on('data', function(msg) {
$('#data').text(msg);
});
</script>
...
<div id="data"></div>
21
Galileo Tutorial I/Os, Sensing and Actuation
WHAT WILL YOU MAKE?
Writing a server, part 5: chart
Chart.js is a library to easily generate nice-looking plots
Other great visualization options in d3.js (Data-Driven Documents)
server_chart.js includes a new route (/chart) to utilize a new view
(views/chart.ejs) to demonstrate this
22
Galileo Tutorial I/Os, Sensing and Actuation
WHAT WILL YOU MAKE?
Download these slides (and examples)
https://github.com/jpwright/senzations14-galileo-nodejs
23
Galileo Tutorial I/Os, Sensing and Actuation
WHAT WILL YOU MAKE?
Questions
24
24
WHAT
WILL YOU MAKE?
Galileo Tutorial I/Os, Sensing and
Actuation
WHAT WILL YOU MAKE?
TCP/IP Network structure
Senzations.net
(194.9.94.234)
Internet
Router
(123.456.789.000)
192.168.0.1
26
192.168.0.2
Galileo Tutorial I/Os, Sensing and Actuation
192.168.0.3
WHAT WILL YOU MAKE?
192.168.0.4
TCP/IP Network terminology
IP address unique designator for a device on a network
IPv4: 50.131.197.209
IPv6: 2001:0db8:85a3:0000:0000:8a2e:0370:7334
Local IP designator for a device on a local area network
External IP designator for a device to the entire Internet
DHCP (dynamic host configuration protocol) means for a router to
automatically assign IP addresses to devices on its network
Subnet mask used to define a network prefix (e.g., use 192.168.0.x
to refer to devices on the LAN)
DNS (domain name service) translate human-readable URL to an IP
address of a server
27
Galileo Tutorial I/Os, Sensing and Actuation
WHAT WILL YOU MAKE?
TCP/IP Network structure
When the Galileo pings
Senzations.net, it first contacts
the DNS server to ask where
DNS
Senzations.net is located.
(8.8.8.8)
Senzations.net
(194.9.94.234)
Internet
The DNS server responds with
the IP address 194.9.94.234.
The router directs traffic from
Router
194.9.94.234 to the Galileo at
(123.456.789.000)
192.168.0.2.
Using DHCP, the
Galileo is assigned an
IP address of
192.168.0.2 by the
router.
192.168.0.1
28
192.168.0.2
Galileo Tutorial I/Os, Sensing and Actuation
The subnet mask tells
the Galileo to look for
192.168.0.3 within
the local area
network.
192.168.0.3
WHAT WILL YOU MAKE?
192.168.0.4
How do we run our own server?
A server is just a device that responds to requests on a network, and
which is typically always on
Traffic of incoming/outgoing requests is divided into ports (the TCP
part of TCP/IP)
HTTP (web) port 80
SSH (secure shell) port 22
FTP (file transfer protocol) port 20
SMTP (mail) port 25
Anything else you want
Ports are typically appended on to the end of an address, e.g.
192.168.0.1:80
29
Galileo Tutorial I/Os, Sensing and Actuation
WHAT WILL YOU MAKE?
How do we run our own server?
An HTTP server typically listens on port 80 and responds with HTML
content designed to be viewed in a web browser.
The HTTP protocol has standard headers in each request
User-Agent: the type of device making the request
Content-Type: how the body of the request is formatted
Referrer: the previous page from which a link was followed
Many more
The HTTP server will respond with one of many status codes
30
200: Everythings OK
401: Not authorized
404: File not found
418: Im a teapot
Galileo Tutorial I/Os, Sensing and Actuation
WHAT WILL YOU MAKE?
