Mastering Internet of Things电子书

Title Page

Copyright and Credits

Mastering Internet of Things

Dedication

Packt Upsell

Why subscribe?

PacktPub.com

Contributors

About the author

About the reviewer

Packt is searching for authors like you

Preface

Defining the Internet of Things

Competing terminology

Envisioning the Smart City

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the color images of this book

Download the example code files

Errata

Piracy

Questions

Preparing Our First Raspberry Pi Project

Getting what you need

Downloading the IoT Dashboard

Installing Windows 10 on your Raspberry Pi

Starting your Raspberry Pi

Connecting to your Raspberry Pi

Downloading the Arduino IDE

Installing Firmata on your Arduino board

Testing your Arduino board

Choosing a development environment

Using the IoT Gateway project and libraries

Creating your first project

Adding NuGet packages

Aggregating capabilities

Initializing the application

Communicating with the Arduino

Testing the app

Deploying the app

Summary

Creating a Sensor to Measure Ambient Light

Preparing our project

Initializing the inventory library

Initializing the persistence library

Sampling raw sensor data

Performing basic error correction

Canceling noise

Removing random spikes

Converting to a physical quantity

Illustrating measurement results

Calculating basic statistics

Defining data persistence

Storing measured data

Removing old data

Summary

Creating an Actuator for Controlling Illumination

Preparing our project

Defining control parameters

Understanding relays

Connecting our lamp

Connecting an LED

Controlling output

Persisting control parameter states

Logging important control events

Using Raspberry Pi GPIO pins directly

Checking whether GPIO is available

Initializing the GPIO output pin

Setting the GPIO pin output

Summary

Publishing Information Using MQTT

Introducing the MQTT protocol

Understanding the Publish/Subscribe pattern

Preparing our project

Selecting an MQTT broker

Creating a Device ID

Connecting to the broker

Monitoring connection events

Recovering from lost connections

Publishing sensor data

Choosing relevant values

Choosing a quality of service

Publishing the light field

Checking encrypted communication

Adding MQTT support to the actuator

Subscribing to topics

Handling incoming commands

Testing MQTT

Security considerations

Managing authentication

Managing privacy

Managing interoperability

Managing authorization

Summary

Publishing Data Using HTTP

Introducing the HTTP protocol

Locating a resource

Understanding the Request/Response pattern

Handling sessions

Limiting connectivity

Choosing a connection direction

Understanding methods

Updating resources

Interacting with resources

Encoding content

Applying headers

Optimizing requests

Sending content

Understanding status codes

Using encryption

Validating certificates

Redefining the web

Preparing our project

Creating an HTTP server

Adding dynamic synchronous resources

Choosing representation

Returning an XMLresponse

Adding a schema reference

Adding momentary values

Returning an image response

Explicitly encoding your content

Adding dynamic asynchronous resources

Decoding content

Performing control action

Summary

Creating Web Pages for Your Devices

Adding file-based resources to your projects

Converting Markdown to HTML in real time

Adding simple Markdown content to the sensor project

Calling our sensor API from JavaScript

Adding simple Markdown content to the actuator project

Calling our actuator API from JavaScript

Adding default redirections

Plotting graphs

Reading historical values from the database

Plotting historical values

Displaying the plot

Generalizing the page

Creating a menu system

Creating the master document

Referencing the menu

Authenticating users

Adding a login page

Creating our user

Creating a very simple user database

Posting login form

Parsing the form

Redirecting the user

Authenticating the user

Protecting our web services

Getting a session token

Validating tokens

Using tokens in JavaScript

Summary

Communicating More Efficiently Using CoAP

Introducing CoAP

Using UDP

Efficiently distributing data

Understanding the Observe pattern

Securing CoAP communication

Understanding DTLS sessions

Encoding content

Adding CoAP to our devices

Creating a CoAP endpoint

Publishing interval-based observable data

Publishing event-based observable data

Choosing the desired representation

Returning CoAP content

Adding a control resource to our actuator

Responding to change requests

Adding output triggers

Testing your devices

Discovering the contents of your device

Controlling your device

Securing your devices

Limitations of CoAP

Summary

Interoperability

Understanding the benefits of interoperability

The benefits of application-layer standards

Understanding coupling

Achieving interoperability using CoAP

Discovering resources using CoRE

Understanding the LWM2M object model

Understanding the LWM2M infrastructure

Understanding LWM2M server operations

Using IPSO Smart Objects

Adding LWM2M to our devices

Creating an LWM2M client

Performing the bootstrap procedure

Registering with the LWM2M servers

Following the progress

Defining Smart Objects

Creating the digital input object class

Creating the digital input object instance class

Defining trigger intervals for observable resources

Notifying subscribers manually

Instantiating the digital input object

Creating the digital output object instance class

Setting remotely updated output values

Testing your LWM2M device

Configuring the bootstrap server

Configuring the LWM2M server

Interacting with your devices

Summary

Social Interaction with Your Devices Using XMPP

Introducing XMPP

Using XML

Understanding the value of brokers

Providing global scalability

Extending server functionality

Authenticating clients

Understanding XMPP addresses

Using trust-based communication to secure the network

Understanding XMPP communication patterns

Understanding stanzas

Extending XMPP

Selecting a client library

Selecting a broker

Adding XMPP to our devices

Connecting to our broker

Getting persisted credentials

Preparing the connection for first-time use

Connecting to the server

Following the connection process

Registering a new account

Maintaining the connection

Managing the roster

Making sensor data available over XMPP

Understanding the conceptual model

Creating an XMPP sensor server

Returning momentary values

Returning historical values

Returning writable values

Triggering events

Publishing control parameters

Understanding the conceptual model

Creating an XMPP control server

Adding a chat interface

Creating an XMPP chat server

Testing your devices

Testing the human interface

Testing the machine interface

For further study

Summary

The Controller

Discovering things on the internet

Introducing Thing Registry

Propagating information

Claiming ownership of things

Transferring the conceptual identity to the owner

Using thing registries in XMPP

Registering our devices

Looping through available components

Finding the thing registry

Creating a Thing Registry client

Defining the conceptual identity of the thing

Adding existing location information

Collecting location information

Registering the device

Updating a registration

Creating a controller

Identifying things

Finding friends in the roster

Limiting the search domain

Performing the search

Picking suitable devices

Making new friends

Reacting to roster events

Adding a friend

Losing a friend

Reacting to revoked presence subscriptions

Reacting to presence changes

Interacting with devices

Subscribing to sensor data events

Reacting to sensor data events

Collecting relevant sensor data

Calculating control output

Performing control action

Recovering from stale states

Re-subscribing to sensor data

Invalidating existing friendships

Reconfiguring the controller

Decommissioning of devices

Summary

Product Life Cycle

Defining ownership of data

Choosing who should own the data

Understanding ownership of physical objects

Defining ownership of information

Understanding provisioning

Using a Thing Registry to register ownership

Provisioning of a claimed thing

Ending ownership

Adding provisioning support to our devices

Searching for a provisioning server

Creating a provisioning client

Adding provisioning support

Registration of device

Transmitting the conceptual identity

Reacting to claims

Updating the registration of our device

Reacting to being disowned

Managing the owner side

Deciding what to do

Managing owned devices

Using tokens for identification

Testing provisioning

Provisioning your devices

Claiming a device

Adding rules

Summary

Concentrators and Bridges

Introducing concentrators

Understanding concentrators in XMPP

Modeling a Programmable Logic Controller

Bridging protocols

Integrating backend systems

Referencing embedded nodes

Referencing embedded sensor nodes

Supporting embedded sensor nodes

Referencing embedded actuator nodes

Supporting embedded actuator nodes

Using embedded nodes in Thing Registries

Using embedded nodes in provisioning

Managing a concentrator

Interfacing a concentrator

Building a concentrator

Defining data sources

Defining embedded nodes

Redirecting node requests

Implementing a concentrator

Instantiating the concentrator

Defining the data source

Providing basic access control

Publishing our nodes

Defining our embedded sensor node

Defining basic properties

Defining the node topology

Providing displayable parameters

Providing status feedback

Performing readout of a sensor

Defining our embedded actuator node

Defining control parameters for embedded nodes

Registering our embedded nodes

Trying your concentrator

Adding provisioning support to the concentrator

Summary

Using an Internet of Things Service Platform

Understanding the IoT Gateway project

Running the IoT Gateway

Running the console version

Running the gateway as a Windows service

Running the gateway as an app

Configuring the IoT Gateway

Configuring the XMPP interface

Securing the password

Setting basic properties of the gateway

Providing a certificate

Providing web content

Publishing network folders

Using Markdown

Using metadata for Search Engine Optimization

Providing menus using the Master/Detail model

Customizing the user experience

Adding security headers

Authorizing user privileges

Customizing content using server-side script

Using pre-processed script

Interacting with .NET code from script

Testing script

Customizing code visualization

Visualizing Graphviz graphs

Customizing multimedia presentation

Pushing information to web clients

Monitoring performance

Monitoring event logs

Monitoring communication sniffers

Developing services for the IoT Gateway

Creating a service module

Understanding the basic architecture

Creating a manifest file

Installing your service

Testing and debugging your service

Deploying your service to an embedded device

Extending communication capabilities

Interfacing things

Using the Metering Topology data source

Controlling node hierarchy

Editing node properties

Interacting with your things

Managing your things

Packaging your service

Creating an installer

Summary

IoT Harmonization

Envisioning the Smart City

Deriving some immediate consequences

Avoiding the lure of the dark side

Understanding the driving forces

Dividing responsibilities

Proposing a solution

Developing standards

Using abstractions

Choosing XMPP

Defining economic feedback models

Defining new roles

Summary

Security for the Internet of Things

Understanding the risks

Getting to a bad place

Understanding the root causes

Looking at alternative options

Getting to a better place

Mastering data protection technologies

Skimming the basics of encryption

Protecting data integrity

Understanding key sizes

Using certificates

Avoiding self-signed certificates

Avoiding creating a Certificate Authority

Using tokens to transport claims

Enforcing ubiquitous encryption

Creating checklists

Updating your firmware

Distributing your risks

Avoiding leaking data unintentionally

Summary

Privacy

Defining privacy

Understanding the importance

Understanding what it means

Being informed

Introducing the GDPR

Balancing rights

Measuring proportionality

Defining personal data

Anonymizing data

Defining processing

Doing as little as possible

Informing the data subjects

Finding your legal grounds

Avoiding certain topics

Distributing responsibilities

Avoiding sanctions

Assisting controllers and processors

Protecting personal data

Giving individual rights

Solving the puzzle

Summary

Other Books You May Enjoy

Leave a review - let other readers know what you think