Index

A

• abstraction layer / Using abstractions
• access control list (ACL)
  • using / Selecting an MQTT broker, Managing privacy
  • URL / Selecting an MQTT broker
• Acknowledgement messages (ACK) / Responding to change requests
• ACME client / Avoiding self-signed certificates
• Actuator project
  • preparing / Preparing our project
  • control parameters, defining / Defining control parameters
  • output, controlling / Controlling output
  • Markdown content, adding / Adding simple Markdown content to the actuator project
• Advanced Encryption Standard (AES) / Managing privacy, Skimming the basics of encryption
• AES CCM cipher / Securing CoAP communication
• agile / Looking at alternative options
• alternating current (AC) / Connecting an LED
• anonymization / Anonymizing data
• antistatic wrist strap / Testing your Arduino board
• application-layer standards
  • benefits / The benefits of application-layer standards
• Application Programming Interfaces (APIs) / Redefining the web
• Arduino board
  • testing / Testing your Arduino board
• Arduino IDE
  • downloading / Downloading the Arduino IDE
  • Firmata, installing on Arduino board / Installing Firmata on your Arduino board
  • FirstApp project, communicating with / Communicating with the Arduino
• asymmetric ciphers / Skimming the basics of encryption
• At least once / Choosing a quality of service
• At most once / Choosing a quality of service
• audit-logs / Redirecting the user
• authentication
  • about / Redefining the web
  • reference / Authenticating clients

B

• B-tree-ordered files / Initializing the persistence library
• backend system integration / Integrating backend systems
• Bidirectional-streams Over Synchronous HTTP (BOSH) connections / Providing global scalability
• big data / Defining ownership of data
• Binary Large Objects (BLOBs) / Initializing the persistence library
• binary socket connections / Providing global scalability
• Bits of Binary / Creating an XMPP chat server
• black-list authorization / Protecting personal data
• blocks / Introducing CoAP
• block size / Initializing the persistence library, Introducing CoAP
• bootstrapping / Understanding the LWM2M infrastructure
• broker
  • about / Understanding the Publish/Subscribe pattern, Limitations of CoAP, Understanding the value of brokers
  • global scalability, providing / Providing global scalability
  • clients, authenticating / Authenticating clients
  • selecting / Selecting a broker
  • references / Selecting a broker
• broker, XMPP devices
  • connecting / Connecting to our broker
  • persisted credentials, obtaining / Getting persisted credentials
  • connection for first-time use, preparing / Preparing the connection for first-time use
  • server, connecting / Connecting to the server
  • connection process, following / Following the connection process
  • new account, registering / Registering a new account
  • connection, maintaining / Maintaining the connection
  • roster, managing / Managing the roster

C

• cache / Initializing the persistence library
• canonical extensions
  • about / Plotting historical values
  • reference / Plotting historical values
• Cascading Style Sheet (CSS) / Introducing the HTTP protocol, Customizing the user experience
• certbot / Avoiding self-signed certificates
• Certificate Authority (CA)
  • about / Validating certificates, Using certificates
  • creation, avoiding / Avoiding creating a Certificate Authority
• certificates
  • validating / Validating certificates
  • using / Using certificates
• chat interface, XMPP device
  • adding / Adding a chat interface
  • XMPP chat server, creating / Creating an XMPP chat server
• client cookie / Understanding DTLS sessions
• ClientEvents class, methods
  • GetOpenLocations() / Pushing information to web clients
  • GetTabIDsForLocation() / Pushing information to web clients
  • GetTabIDsForLocations() / Pushing information to web clients
  • GetTabIDs() / Pushing information to web clients
  • PushEvent() / Pushing information to web clients
• client hold-off time / Performing the bootstrap procedure
• client library
  • reference / Selecting a client library
  • selecting / Selecting a client library
• CoAP-enabled devices
  • CoAP endpoint, creating / Creating a CoAP endpoint
  • interval-based observable data, publishing / Publishing interval-based observable data
  • event-based observable data, publishing / Publishing event-based observable data
  • desired representation, selecting / Choosing the desired representation
  • CoAP content, returning / Returning CoAP content
  • control resource, adding to actuator / Adding a control resource to our actuator
  • change requests, responding / Responding to change requests
  • output triggers, adding / Adding output triggers
  • testing / Testing your devices
  • contents, discovering / Discovering the contents of your device
  • controlling / Controlling your device
  • securing / Securing your devices
• CoAP test tool
  • reference / Testing your devices
• code visualization
  • customizing / Customizing code visualization
  • Graphviz graphs, visualizing / Visualizing Graphviz graphs
• collections / Initializing the persistence library
• command-line switches
  • -? / Running the gateway as a Windows service
  • -console / Running the gateway as a Windows service
  • -install / Running the gateway as a Windows service
  • -displayname Name / Running the gateway as a Windows service
  • -description Desc / Running the gateway as a Windows service
  • -immediate / Running the gateway as a Windows service
  • -localsystem / Running the gateway as a Windows service
  • -localservice / Running the gateway as a Windows service
  • -networkservice / Running the gateway as a Windows service
  • -start Mode / Running the gateway as a Windows service
  • -uninstall / Running the gateway as a Windows service
• Common Ground (COM) connector / Understanding relays
• component connections / Extending server functionality
• concentrators
  • about / Identifying things, Introducing concentrators
  • in XMPP / Understanding concentrators in XMPP
  • Programmable Logic Controller (PLC), modeling / Modeling a Programmable Logic Controller
  • protocol bridge, building / Bridging protocols
  • backend systems, integrating / Integrating backend systems
  • managing / Managing a concentrator
  • interfacing / Interfacing a concentrator
  • building / Building a concentrator
  • data sources, defining / Defining data sources, Defining the data source
  • embedded nodes, defining / Defining embedded nodes
  • node requests, redirecting / Redirecting node requests
  • implementing / Implementing a concentrator
  • instantiating / Instantiating the concentrator
  • basic access control, providing / Providing basic access control
  • nodes, publishing / Publishing our nodes
  • embedded sensor node, defining / Defining our embedded sensor node
  • embedded actuator node, defining / Defining our embedded actuator node
  • embedded nodes, registering / Registering our embedded nodes
  • using, with controller application / Trying your concentrator
  • provisioning support, adding / Adding provisioning support to the concentrator
• concentrators, attribute
  • id / Understanding concentrators in XMPP
  • src / Understanding concentrators in XMPP
  • pt / Understanding concentrators in XMPP
• conceptual identity / Introducing Thing Registry
• conditional requests / Optimizing requests
• Confirmable messages (CON) / Responding to change requests
• Constrained Application Protocol (CoAP)
  • about / Introducing CoAP
  • reference / Introducing CoAP, Limitations of CoAP
  • UDP, using / Using UDP
  • data, distributing / Efficiently distributing data
  • Observe pattern / Understanding the Observe pattern
  • communication, securing / Securing CoAP communication
  • DTLS sessions / Understanding DTLS sessions
  • content, encoding / Encoding content
  • adding, to devices / Adding CoAP to our devices
  • limitations / Limitations of CoAP
• content
  • encoding / Encoding content, Encoding content
  • sending / Sending content
• Content Format
  • about / Encoding content
  • reference / Encoding content
• Content Type / Managing interoperability
• controller application
  • creating / Creating a controller
  • things, identifying / Identifying things
  • friends, searching in roster / Finding friends in the roster
  • search domain, limiting / Limiting the search domain
  • search, performing / Performing the search
  • suitable devices, selecting / Picking suitable devices
  • new friends, creating / Making new friends
  • roster events, reacting to / Reacting to roster events
  • friend, adding / Adding a friend
  • friend, losing / Losing a friend
  • revoked presence subscriptions, reacting to / Reacting to revoked presence subscriptions
  • presence changes, reacting to / Reacting to presence changes
  • interacting, with devices / Interacting with devices
  • sensor data events, subscribing to / Subscribing to sensor data events
  • sensor data events, subscribing / Subscribing to sensor data events
  • sensor data events, reacting to / Reacting to sensor data events
  • relevant sensor data, collecting / Collecting relevant sensor data
  • control output, calculating / Calculating control output
  • control action, performing / Performing control action
  • stale state, recovering from / Recovering from stale states
  • sensor data, re-subscribing to / Re-subscribing to sensor data
  • existing friendships, invalidating / Invalidating existing friendships
  • reconfiguring / Reconfiguring the controller
  • devices, decommissioning / Decommissioning of devices
  • concentrators, using / Trying your concentrator
• controllers / Distributing responsibilities
• control parameters
  • defining / Defining control parameters
  • about / Defining control parameters, Understanding the conceptual model
• control parameters, XMPP device
  • publishing / Publishing control parameters
  • conceptual model / Understanding the conceptual model
  • XMPP control server, creating / Creating an XMPP control server
• cookie / Handling sessions
• Coordinated Universal Time / Subscribing to topics
• Copper (Cu) plugin
  • URL / Testing your devices
• coupling / Understanding coupling
• Cross-origin resource sharing (CORS) / Adding security headers

D

• datagrams / Using UDP
• Datagram Transport Layer Security (DTLS) / Securing CoAP communication
• data integrity
  • protecting / Protecting data integrity
• data masking / Anonymizing data
• data obfuscation / Anonymizing data
• data persistence
  • defining / Defining data persistence
• data protection
  • by design / Protecting personal data
  • by default / Protecting personal data
• Data Protection Impact Assessment (DPIA) / Avoiding certain topics
• Data Protection Officer (DPO) / Assisting controllers and processors
• data protection technologies
  • mastering / Mastering data protection technologies
  • encryption / Skimming the basics of encryption
  • data integrity, protecting / Protecting data integrity
  • key sizes / Understanding key sizes
  • certificates, using / Using certificates
  • self-signed certificates, avoiding / Avoiding self-signed certificates
  • Certificate Authority creation, avoiding / Avoiding creating a Certificate Authority
  • tokens, used for transporting claims / Using tokens to transport claims
  • ubiquitous encryption, enforcing / Enforcing ubiquitous encryption
  • checklists, creating / Creating checklists
  • firmware, updating / Updating your firmware
  • risks, distributing / Distributing your risks
  • data leaks, avoiding / Avoiding leaking data unintentionally
• data subject / Defining personal data
• data type / Defining control parameters
• decentralization / Defining ownership of information
• decommissioning / Decommissioning of devices
• default collection / Initializing the persistence library
• Denial of Service (DoS) attacks / Distributing your risks
• development environment
  • selecting / Choosing a development environment
• Device ID
  • creating / Creating a Device ID
  / Creating a CoAP endpoint
• Device Portal / Connecting to your Raspberry Pi, Preparing the connection for first-time use
• device registration
  • performing / Registering our devices
  • available components, looping through / Looping through available components
  • Thing Registry, searching / Finding the thing registry
  • Thing Registry client, creating / Creating a Thing Registry client
  • conceptual identity of thing, defining / Defining the conceptual identity of the thing
  • existing location information, adding / Adding existing location information
  • location information, collecting / Collecting location information
  • with Thing Registry / Registering the device
  • updating / Updating a registration
• Diffie-Hellman / Skimming the basics of encryption
• direct current (DC) / Connecting an LED
• Distributed Denial of Service (DDoS) attacks / Distributing your risks
• DNS spoofing / Using certificates
• Document Object Model (DOM) / Introducing the HTTP protocol
• domain / Providing global scalability
• domain name / Locating a resource
• domain part / Understanding XMPP addresses
• downgrade attack / Validating certificates, Connecting to the server
• DTLS sessions / Understanding DTLS sessions
• DTLS v1.2
  • reference / Understanding DTLS sessions
• dynamic asynchronous resources, SensorHttp project
  • adding / Adding dynamic asynchronous resources
  • content, decoding / Decoding content
  • control action, performing / Performing control action
• dynamic synchronous resources, SensorHttp project
  • adding / Adding dynamic synchronous resources
  • representation, selecting / Choosing representation
  • XMLresponse, returning / Returning an XMLresponse
  • schema reference, adding / Adding a schema reference
  • momentary values, adding / Adding momentary values
  • image response, returning / Returning an image response
  • content, encoding / Explicitly encoding your content

E

• eavesdropping / Understanding the root causes
• edge computing / Distributing your risks
• Electronic Frontier Foundation
  • URL / Understanding what it means
• embedded actuator node, concentrators
  • defining / Defining our embedded actuator node
  • control parameters, defining / Defining control parameters for embedded nodes
• embedded nodes
  • referencing / Referencing embedded nodes
  • embedded sensor nodes, referencing / Referencing embedded sensor nodes
  • embedded sensor nodes, supporting / Supporting embedded sensor nodes
  • embedded actuator nodes, referencing / Referencing embedded actuator nodes
  • embedded actuator nodes, supporting / Supporting embedded actuator nodes
  • using, in Thing Registry / Using embedded nodes in Thing Registries
  • using, in Provisioning / Using embedded nodes in provisioning
• embedded sensor node, concentrators
  • defining / Defining our embedded sensor node
  • basic properties, defining / Defining basic properties
  • node topology, defining / Defining the node topology
  • displayable parameters, providing / Providing displayable parameters
  • status feedback, providing / Providing status feedback
  • readout, performing of sensor / Performing readout of a sensor
• embedding script, Markdown
  • reference / Customizing content using server-side script
• encrypted communication
  • checking / Checking encrypted communication
• encryption
  • using / Using encryption
  • about / Skimming the basics of encryption
• end-to-end encryption (E2E) / Managing privacy, Skimming the basics of encryption
• error correction, Sensor project
  • performing / Performing basic error correction
  • noise, cancelling / Canceling noise
  • random spikes, removing / Removing random spikes
• errors
  • systematic errors / Performing basic error correction
  • random errors / Performing basic error correction
• event-based methods / Propagating information
• Event Subscription / Efficiently distributing data, Understanding the Observe pattern
• Exactly once / Choosing a quality of service
• EXI compressed connections / Providing global scalability
• expiration date / Using certificates
• Extensible Markup Language (XML)
  • about / Introducing the HTTP protocol
  • using / Using XML
• Extensible Messaging and Presence Protocol (XMPP)
  • about / Introducing XMPP
  • XML, using / Using XML
  • brokers / Understanding the value of brokers
  • XMPP address / Understanding XMPP addresses
  • trust-based communication, used, for securing network / Using trust-based communication to secure the network
  • communication patterns / Understanding XMPP communication patterns
  • stanzas / Understanding stanzas
  • extending / Extending XMPP
  • client library, selecting / Selecting a client library
  • broker, selecting / Selecting a broker
  • thing registries, using / Using thing registries in XMPP
  • concentrators / Understanding concentrators in XMPP
  • used, for privacy protection / Solving the puzzle

F

• federation / Providing global scalability
• fields / Understanding the conceptual model
• file-based resources
  • adding, to projects / Adding file-based resources to your projects
  • Markdown, converting to HTML / Converting Markdown to HTML in real time
  • Markdown content, adding to Sensor project / Adding simple Markdown content to the sensor project
  • sensor API, calling from JavaScript / Calling our sensor API from JavaScript
  • Markdown content, adding to Actuator project / Adding simple Markdown content to the actuator project
  • actuator API, calling from JavaScript / Calling our actuator API from JavaScript
  • default redirections, adding / Adding default redirections
• firewalls / Understanding the Publish/Subscribe pattern, Limiting connectivity
• Firmata
  • installing, on Arduino board / Installing Firmata on your Arduino board
• FirstApp project
  • creating / Creating your first project
  • NuGet packages, adding / Adding NuGet packages
  • capabilities, aggregating / Aggregating capabilities
  • application, initializing / Initializing the application
  • communicating, with Arduino / Communicating with the Arduino
  • testing / Testing the app
  • deploying / Deploying the app
• forward secrecy / Securing CoAP communication
• Full JIDs / Understanding XMPP addresses

G

• General-Purpose Input/Output (GPIO) pins
  • about / Using Raspberry Pi GPIO pins directly
  • availability, checking / Checking whether GPIO is available
  • output pin, initializing / Initializing the GPIO output pin
  • output pin, setting / Setting the GPIO pin output
• General Data Protection Regulation (GDPR)
  • about / Introducing the GDPR
  • reference / Introducing the GDPR
  • rights, balancing / Balancing rights
  • proportionality, measuring / Measuring proportionality
  • personal data, defining / Defining personal data
  • data, anonymizing / Anonymizing data
  • process, defining / Defining processing
  • minimalism / Doing as little as possible
  • data subjects, informing / Informing the data subjects
  • legal grounds, searching / Finding your legal grounds
  • certain topics, avoiding / Avoiding certain topics
  • responsibilities, distributing / Distributing responsibilities
  • sanctions, avoiding / Avoiding sanctions
  • controllers, assisting / Assisting controllers and processors
  • processors, assisting / Assisting controllers and processors
  • personal data, protecting / Protecting personal data
  • individual rights, defining / Giving individual rights
• get callback method / Creating an XMPP control server
• graphs
  • plotting / Plotting graphs
  • historical values, reading from database / Reading historical values from the database
  • historical values, plotting / Plotting historical values
  • plot, displaying / Displaying the plot
  • page, generalizing / Generalizing the page
• Graphviz
  • graphs, visualizing / Visualizing Graphviz graphs
  • reference / Visualizing Graphviz graphs
• ground (GND) / Connecting an LED

H

• hash algorithms / Protecting data integrity
• headers
  • applying / Applying headers
  • Accept / Applying headers
  • Cache-Control / Applying headers
  • Content-Type / Applying headers
  • ETag / Applying headers
  • Expires / Applying headers
  • Last-Modified / Applying headers
  • User-Agent / Applying headers
  • reference / Applying headers
  • Expect / Optimizing requests
  • If-Match / Optimizing requests
  • If-Modified-Since / Optimizing requests
  • If-None-Match / Optimizing requests
  • If-Unmodified-Since / Optimizing requests
• HMAC / Using tokens to transport claims
• horizontal segmentation / Dividing responsibilities
• HTML
  • Markdown, converting / Converting Markdown to HTML in real time
• HTTP/2 / Redefining the web
• HTTP 2.0 / Choosing a connection direction
• HTTP over XMPP / Redefining the web
• HTTPS / Locating a resource, Using encryption
• human-to-machine (H2M) interface / Making sensor data available over XMPP
• hybrid ciphers / Skimming the basics of encryption
• hypertext documents / Introducing the HTTP protocol
• Hypertext Transfer Protocol (HTTP)
  • about / Introducing the HTTP protocol
  • resources, locating / Locating a resource
  • Request/Response pattern / Understanding the Request/Response pattern
  • sessions, handling / Handling sessions
  • connectivity, limiting / Limiting connectivity
  • connection direction, selecting / Choosing a connection direction
  • methods / Understanding methods
  • resources, updating / Updating resources
  • resources, interacting / Interacting with resources
  • content, encoding / Encoding content
  • headers, applying / Applying headers
  • requests, optimizing / Optimizing requests
  • content, sending / Sending content
  • status codes / Understanding status codes
  • encryption, using / Using encryption
  • certificates, validating / Validating certificates
  • web, redefining / Redefining the web

I

• idempotent commands / Choosing a quality of service
• idempotent method calls / Updating resources
• IEEE IoT Harmonization working group
  • about / Making sensor data available over XMPP, Publishing control parameters
  • reference / Making sensor data available over XMPP
• IIS Crypto tool
  • URL / Avoiding self-signed certificates
• In-Band Registration / Registering a new account
• infrastructure, LWM2M
  • clients / Understanding the LWM2M infrastructure
  • servers / Understanding the LWM2M infrastructure
  • bootstrap server / Understanding the LWM2M infrastructure
• injection / Managing authorization
• instant messaging / Introducing XMPP
• Internet Assigned Numbers Authority (IANA) / Encoding content
• Internet Content Type / Encoding content
• Internet Engineering Task Force (IETF) / Introducing the HTTP protocol, Introducing CoAP
• Internet Group Management Protocol (IGMP) / Introducing the MQTT protocol, Efficiently distributing data
• Internet of Things (IoT)
  • about / Introducing the MQTT protocol
  • risks / Understanding the risks
  • security threats / Getting to a bad place
  • security threats, root causes / Understanding the root causes
  • design considerations / Looking at alternative options
  • foundation, laying for communication / Getting to a better place
• interoperability
  • benefits / Understanding the benefits of interoperability
  • application-layer standards, benefits / The benefits of application-layer standards
  • coupling / Understanding coupling
• interoperability, with CoAP
  • achieving / Achieving interoperability using CoAP
  • resources, discovering with CoRE / Discovering resources using CoRE
  • LWM2M / Understanding the LWM2M object model
  • IPSO Smart Objects, using / Using IPSO Smart Objects
• interoperable application / The benefits of application-layer standards
• IoT Client
  • URL / Testing provisioning
• IoT Dashboard
  • downloading / Downloading the IoT Dashboard
  • about / Downloading the IoT Dashboard
  • URL / Downloading the IoT Dashboard
• iotdisco URI scheme
  • URL / Transferring the conceptual identity to the owner
• IoT Gateway
  • executing / Running the IoT Gateway
  • console version, executing / Running the console version
  • executing, as Windows Service / Running the gateway as a Windows service
  • executing, as app / Running the gateway as an app
  • configuring / Configuring the IoT Gateway
  • XMPP interface, configuring / Configuring the XMPP interface
  • password, securing / Securing the password
  • basic properties, setting / Setting basic properties of the gateway
  • certificate, providing / Providing a certificate
  • performance, monitoring / Monitoring performance
  • event logs, monitoring / Monitoring event logs
  • communication sniffers, monitoring / Monitoring communication sniffers
  • services, developing / Developing services for the IoT Gateway
• IoT Gateway project
  • reference / Adding a chat interface, Testing the machine interface, Running the IoT Gateway
  • about / Testing the machine interface, Understanding the IoT Gateway project
• IoT Gateway repository
  • URL / Using the IoT Gateway project and libraries
• IP address / Locating a resource
• IPSO Smart Objects
  • using / Using IPSO Smart Objects
  • references / Using IPSO Smart Objects
• IPv6 / Introducing CoAP

J

• Jabber ID (JID) / Identifying things, Understanding concentrators in XMPP
• Jabber project / Introducing XMPP
• JavaScript
  • sensor API, calling / Calling our sensor API from JavaScript
  • actuator API, calling / Calling our actuator API from JavaScript
  • tokens, using / Using tokens in JavaScript
• JavaScript Object Notation (JSON) / Introducing the HTTP protocol
• JSON Web Tokens (JWT) / Redefining the web, Protecting our web services, Using tokens to transport claims

L

• 6LoWPAN (IPv6 over Low-Power Wireless Personal Area Networks) / Introducing CoAP
• lamp
  • relay, connecting to / Connecting our lamp
  • LED, connecting / Connecting an LED
• latency / Understanding the Observe pattern
• leaf node / Defining the node topology
• LED
  • connecting, to lamp / Connecting an LED
• Leshan
  • about / Performing the bootstrap procedure
  • URL / Performing the bootstrap procedure
• Let's Encrypt
  • URL / Avoiding self-signed certificates
• Linked Data / Redefining the web
• Local Area Networks (LANs) / Limiting connectivity
• local name / Extending XMPP
• local part / Understanding XMPP addresses
• loosely coupled interface / Understanding coupling
• LWM2M
  • object model / Understanding the LWM2M object model
  • infrastructure / Understanding the LWM2M infrastructure
  • server operations / Understanding LWM2M server operations
  • reference / Using IPSO Smart Objects
  • adding, to devices / Adding LWM2M to our devices
  • client, creating / Creating an LWM2M client
  • bootstrap procedure, performing / Performing the bootstrap procedure
  • servers, registering with / Registering with the LWM2M servers
  • progress, following / Following the progress
  • Smart Objects, defining / Defining Smart Objects
• Lwm2mClient object, events
  • OnStateChanged / Following the progress
  • OnBootstrapCompleted / Following the progress
  • OnBootstrapFailed / Following the progress
  • OnRegistrationSuccessful / Following the progress
  • OnRegistrationFailed / Following the progress
  • OnDeregistrationSuccessful / Following the progress
  • OnDeregistrationFailed / Following the progress
  • OnRebootRequest / Following the progress
• LWM2M device
  • testing / Testing your LWM2M device
  • bootstrap server, configuring / Configuring the bootstrap server
  • LWM2M server, configuring / Configuring the LWM2M server
  • interacting with / Interacting with your devices

M

• machine-to-machine (M2M) interface / Making sensor data available over XMPP
• Man-In-The-Middle (MITM) attacks / Validating certificates, Understanding DTLS sessions, Adding security headers, Using certificates
• Markdown
  • about / Converting Markdown to HTML in real time
  • converting, to HTML / Converting Markdown to HTML in real time
  • reference / Adding simple Markdown content to the sensor project
  • using / Using Markdown
  • URL / Using Markdown
• Media Type
  • reference / Encoding content
  • about / Encoding content
• menu system
  • creating / Creating a menu system
  • master document, creating / Creating the master document
  • menu, referencing / Referencing the menu
• metadata tags
  • Login / Authorizing user privileges
  • Privilege / Authorizing user privileges
  • UserVariable / Authorizing user privileges
• Metering Topology
  • using / Using the Metering Topology data source
  • about / Using the Metering Topology data source
• MIoT project
  • reference / For further study
• Mono
  • URL / Downloading the IoT Dashboard
• MQ Telemetry Transport (MQTT) protocol
  • about / Introducing the MQTT protocol
  • Publish/Subscribe pattern / Understanding the Publish/Subscribe pattern
• mqtt-spy
  • URL / Testing MQTT
• MQTT broker
  • selecting / Selecting an MQTT broker
  • URL / Selecting an MQTT broker
• multicast / Efficiently distributing data
• multimedia
  • presentation, customizing / Customizing multimedia presentation
  • reference / Customizing multimedia presentation
• Multipurpose Internet Mail Extensions (MIME) / Encoding content

N

• .NET code
  • reference / Interacting with .NET code from script
  • interacting, from server-side script / Interacting with .NET code from script
• .NET standard 1.3 / Preparing our project
• .NET standard v1.5 / Preparing our project
• namespace / Adding a schema reference, Using XML, Extending XMPP
• network folders
  • publishing / Publishing network folders
• network identity / Introducing Thing Registry
• network protocol analyzer / Checking encrypted communication
• network sniffer / Checking encrypted communication
• nodes / Understanding the Publish/Subscribe pattern, Understanding concentrators in XMPP
• Non-confirmable messages (NON) / Responding to change requests
• Normally Closed (NC) connector / Understanding relays
• Normally Open (NO) connector / Understanding relays
• NuGet package
  • adding / Adding NuGet packages, Preparing our project

O

• OAuth2 / Redefining the web
• object database provider / Initializing the persistence library
• Object ID field / Defining data persistence
• objects, LWM2M
  • security object / Understanding the LWM2M object model
  • server object / Understanding the LWM2M object model
  • access control object / Understanding the LWM2M object model
  • device object / Understanding the LWM2M object model
• observable resources / Understanding the Observe pattern, Publishing interval-based observable data
• Observe pattern
  • about / Efficiently distributing data, Understanding the Observe pattern
  • reference / Understanding the Observe pattern
• Open Mobile Alliance (OMA)
  • URL / Understanding the LWM2M object model
• Open Systems Interconnection (OSI) model / The benefits of application-layer standards
• output, Actuator project
  • controlling / Controlling output
  • control parameter states, persisting / Persisting control parameter states
  • control events, logging / Logging important control events
• owner interface
  • GetDevices method / Managing owned devices
  • ClearDeviceCache method / Managing owned devices
  • ClearDeviceCaches method / Managing owned devices
  • DeleteDeviceRules method / Managing owned devices
• ownership
  • registering, with Thing Registry / Using a Thing Registry to register ownership
  • ending / Ending ownership
• ownership of data
  • defining / Defining ownership of data
  • candidates, selecting / Choosing who should own the data
• ownership of information
  • defining / Defining ownership of information
• ownership of physical objects / Understanding ownership of physical objects
• owner side application
  • managing / Managing the owner side
  • IsFriendQuestion event / Managing the owner side
  • CanReadQuestion event / Managing the owner side
  • CanControlQuestion event / Managing the owner side
  • provisioning server, responding to / Deciding what to do
  • owned devices, managing / Managing owned devices

P

• Pascal casing / Handling incoming commands
• peers / Understanding XMPP addresses
• personal data / Defining personal data
• physical quantity / Converting to a physical quantity
• physical unit / Converting to a physical quantity
• port number / Locating a resource
• Post-Redirect-Get (PRG pattern) / Understanding status codes, Redirecting the user
• pre-defined tags
  • reference / Defining the conceptual identity of the thing
• pre-processed script
  • about / Adding a login page
  • reference / Adding a login page, Using pre-processed script
  • using / Using pre-processed script
• pre-shared keys (PSK) / Securing CoAP communication, Avoiding self-signed certificates
• presence subscriptions
  • about / Using trust-based communication to secure the network
  • reference / Using trust-based communication to secure the network
• primary key / Defining data persistence
• privacy
  • defining / Defining privacy
  • importance / Understanding the importance
  • about / Understanding what it means
  • reference / Understanding what it means
  • arbitrary interference, informing / Being informed
• private key / Using tokens for identification
• processors / Distributing responsibilities
• Program Data folder / Configuring the IoT Gateway
• Programmable Logic Controller (PLC)
  • about / Identifying things, Using embedded nodes in Thing Registries
  • modeling / Modeling a Programmable Logic Controller
  • advantages / Modeling a Programmable Logic Controller
• protocol bridge
  • building / Bridging protocols
• provisioning
  • about / Registering the device, Decommissioning of devices, Defining ownership of information, Understanding provisioning
  • ownership, registering with Thing Registry / Using a Thing Registry to register ownership
  • of claimed thing / Provisioning of a claimed thing
  • ownership, ending / Ending ownership
  • embedded nodes, using / Using embedded nodes in provisioning
• provisioning, testing
  • about / Testing provisioning
  • devices, provisioning / Provisioning your devices
  • device, claiming / Claiming a device
  • rules, adding / Adding rules
• provisioning server / Understanding provisioning, Provisioning of a claimed thing
• provisioning support
  • adding, to devices / Adding provisioning support to our devices
  • provisioning server, searching / Searching for a provisioning server
  • provisioning client, creating / Creating a provisioning client
  • adding / Adding provisioning support
  • device, registration / Registration of device
  • conceptual identity, transmitting / Transmitting the conceptual identity
  • claims, reacting to / Reacting to claims
  • device registration, updating / Updating the registration of our device
  • disowned device, detecting / Reacting to being disowned
• pseudonymization / Anonymizing data
• public claim names
  • URL / Getting a session token
• public key / Using tokens for identification
• Public Key Infrastructure (PKI) / Managing privacy, Skimming the basics of encryption
• Publish/Subscribe pattern / Introducing the MQTT protocol, Understanding the Publish/Subscribe pattern
• publishers / Understanding the Publish/Subscribe pattern

Q

• Quality of Service
  • selecting / Choosing a quality of service
  • At most once / Choosing a quality of service
  • At least once / Choosing a quality of service
  • Exactly Once / Choosing a quality of service

R

• random errors / Performing basic error correction
• Raspberry Pi
  • Windows 10, installing / Installing Windows 10 on your Raspberry Pi
  • starting / Starting your Raspberry Pi
  • connecting to / Connecting to your Raspberry Pi
  • Arduino IDE, downloading / Downloading the Arduino IDE
  • Arduino board, testing / Testing your Arduino board
  • development environment, selecting / Choosing a development environment
  • IoT Gateway project, using / Using the IoT Gateway project and libraries
  • IoT Gateway libraries, using / Using the IoT Gateway project and libraries
  • General-Purpose Input/Output (GPIO) pins, using / Using Raspberry Pi GPIO pins directly
• Raspbian operating system
  • reference / Downloading the IoT Dashboard
• raw sensor data
  • sampling / Sampling raw sensor data
• Recommendations / Introducing the HTTP protocol
• relay
  • about / Understanding relays
  • constructing / Understanding relays
  • connecting, to lamp / Connecting our lamp
• Representational State Transfer (REST) / Introducing the HTTP protocol, Redefining the web
• Request/Response pattern / Understanding the Request/Response pattern
• Request For Comments (RFCs) / Introducing the HTTP protocol
• requests
  • optimizing / Optimizing requests
• Reset messages (RST) / Responding to change requests
• resources
  • about / Introducing the HTTP protocol
  • locating / Locating a resource
  • updating / Updating resources
  • interacting / Interacting with resources
• RESTful web services / Introducing the HTTP protocol
• root node / Defining the node topology
• Roslyn
  • about / Choosing a development environment
  • URL / Choosing a development environment
• roster / Using trust-based communication to secure the network
• RSA / Managing privacy, Skimming the basics of encryption

S

• sampling / Sampling raw sensor data
• script syntax
  • reference / Plotting graphs
• search-based methods / Propagating information
• Search Engine Optimization (SEO)
  • about / Adding simple Markdown content to the sensor project
  • metadata, using / Using metadata for Search Engine Optimization
• Secure Socket Layer (SSL) / Using encryption
• security, SensorMqtt project
  • considerations / Security considerations
  • authentication, managing / Managing authentication
  • privacy, managing / Managing privacy
  • interoperability, managing / Managing interoperability
  • authorization, managing / Managing authorization
• security headers
  • adding / Adding security headers
• self-owned thing / Registering the device
• self-signed certificates
  • avoiding / Avoiding self-signed certificates
• Semantic Web / Redefining the web
• SenML / Understanding LWM2M server operations
• sensor data, over XMPP
  • publishing / Making sensor data available over XMPP
  • conceptual model / Understanding the conceptual model
  • XMPP sensor server, creating / Creating an XMPP sensor server
  • momentary values, returning / Returning momentary values
  • historical values, returning / Returning historical values
  • writable values, returning / Returning writable values
  • events, triggering / Triggering events
• sensor data, SensorMqtt project
  • publishing / Publishing sensor data
  • relevant values, selecting / Choosing relevant values
  • Quality of Service, selecting / Choosing a quality of service
  • light field, publishing / Publishing the light field
• sensor data model
  • timestamps / Understanding the conceptual model
  • nodes / Understanding the conceptual model
• SensorHttp project
  • preparing / Preparing our project
  • HTTP server, creating / Creating an HTTP server
  • dynamic synchronous resources, adding / Adding dynamic synchronous resources
  • dynamic asynchronous resources, adding / Adding dynamic asynchronous resources
• SensorMqtt project
  • preparing / Preparing our project
  • MQTT broker, selecting / Selecting an MQTT broker
  • Device ID, creating / Creating a Device ID
  • connecting, to broker / Connecting to the broker
  • connection events, monitoring / Monitoring connection events
  • lost connections, recovering from / Recovering from lost connections
  • sensor data, publishing / Publishing sensor data
  • encrypted communication, checking / Checking encrypted communication
  • MQTT support, adding to actuator / Adding MQTT support to the actuator
  • topics, subscribing / Subscribing to topics
  • incoming commands, handling / Handling incoming commands
  • MQTT, testing / Testing MQTT
  • security, considerations / Security considerations
• Sensor project
  • preparing / Preparing our project
  • inventory library, initializing / Initializing the inventory library
  • persistence library, initializing / Initializing the persistence library
  • raw sensor data, sampling / Sampling raw sensor data
  • error correction, performing / Performing basic error correction
  • raw data, converting to physical quantity / Converting to a physical quantity
  • measurement results, illustrating / Illustrating measurement results
  • basic statistics, calculating / Calculating basic statistics
  • data persistence, defining / Defining data persistence
  • measured data, storing / Storing measured data
  • old data, removing / Removing old data
  • Markdown content, adding / Adding simple Markdown content to the sensor project
• server-side script
  • content, customizing / Customizing content using server-side script
  • pre-processed script, using / Using pre-processed script
  • .Net code, interacting with / Interacting with .NET code from script
  • testing / Testing script
  • reference / Testing script
• server-to-server (s2s) connections / Providing global scalability
• Service-Oriented Architecture (SOA) / Redefining the web
• Service Discovery / Looping through available components
• services, IoT Gateway
  • developing / Developing services for the IoT Gateway
  • service module, creating / Creating a service module
  • basic architecture / Understanding the basic architecture
  • manifest file, creating / Creating a manifest file
  • installing / Installing your service
  • testing / Testing and debugging your service
  • debugging / Testing and debugging your service
  • deploying, to embedded device / Deploying your service to an embedded device
  • communication capabilities, extending / Extending communication capabilities
  • things, interfacing / Interfacing things
  • packaging / Packaging your service
  • installer, creating / Creating an installer
• sessions
  • handling / Handling sessions
  • about / Handling sessions
• session token
  • obtaining / Getting a session token
• set callback method / Creating an XMPP control server
• SHA / Protecting data integrity
• sibling nodes / Defining the node topology
• Simple Authentication and Security Layer (SASL) / Managing authentication, Authenticating clients
• Simple Object Access Protocol (SOAP) / Introducing the HTTP protocol, Redefining the web
• Simple Service Discovery Protocol (SSDP) / Discovering things on the internet
• SkiaSharp / Returning an image response
• Smart City
  • envisioning / Envisioning the Smart City
  • immediate consequences, deriving / Deriving some immediate consequences
  • risk, with centralized architecture / Avoiding the lure of the dark side
  • driving forces / Understanding the driving forces
  • responsibilities, dividing / Dividing responsibilities
• Smart City, solution
  • proposing / Proposing a solution
  • standards, developing / Developing standards
  • abstractions, using / Using abstractions
  • XMPP, selecting / Choosing XMPP
  • economic feedback models, defining / Defining economic feedback models
  • roles, defining / Defining new roles
• Smart Objects
  • defining / Defining Smart Objects
  • digital input object class, creating / Creating the digital input object class
  • digital input object instance class, creating / Creating the digital input object instance class
  • trigger intervals, defining for observable resources / Defining trigger intervals for observable resources
  • subscribers, notifying manually / Notifying subscribers manually
  • digital input object, instantiating / Instantiating the digital input object
  • digital output object instance class, creating / Creating the digital output object instance class
  • remotely updated output values, setting / Setting remotely updated output values
• sniffer objects / Checking encrypted communication
• sniffing / Skimming the basics of encryption
• spike / Removing random spikes
• spoofing / Getting to a better place
• stale state / Recovering from stale states
• stanzas / Understanding stanzas
• stanzas, attribute
  • id / Understanding stanzas
  • to / Understanding stanzas
  • from / Understanding stanzas
  • type / Understanding stanzas
  • xml*lang / Understanding stanzas
• Starter Kits / Getting what you need
• stateless connection / Handling sessions
• state of the art / Measuring proportionality, Protecting personal data
• Statistical aggregation / Anonymizing data
• status codes
  • about / Understanding status codes
  • 1xx / Understanding status codes
  • 2xx / Understanding status codes
  • 3xx / Understanding status codes
  • 4xx / Understanding status codes
  • 5xx / Understanding status codes
  • 200 / Understanding status codes
  • 301 / Understanding status codes
  • 303 / Understanding status codes
  • 304 / Understanding status codes
  • 307 / Understanding status codes
  • 400 / Understanding status codes
  • 401 / Understanding status codes
  • 403 / Understanding status codes
  • 404 / Understanding status codes
  • 406 / Understanding status codes
  • 500 / Understanding status codes
  • reference / Understanding status codes
• sub-domains / Extending server functionality
• subject name / Validating certificates
• subscribers / Understanding the Publish/Subscribe pattern, Understanding the Observe pattern
• subscription / Understanding the Observe pattern
• symmetric ciphers / Skimming the basics of encryption
• synchronous resource / Adding dynamic synchronous resources
• systematic errors / Performing basic error correction

T

• Thing Registry
  • about / Introducing Thing Registry
  • client, creating / Creating a Thing Registry client
  • ownership, registering / Using a Thing Registry to register ownership
  • embedded nodes, using / Using embedded nodes in Thing Registries
• things
  • discovering, on internet / Discovering things on the internet
  • Thing Registry / Introducing Thing Registry
  • information, propagating / Propagating information
  • ownership of things, claiming / Claiming ownership of things
  • conceptual identity, transferring to owner / Transferring the conceptual identity to the owner
  • thing registries, using in XMPP / Using thing registries in XMPP
  • interfacing / Interfacing things
  • Metering Topology, using / Using the Metering Topology data source
  • node hierarchy, controlling / Controlling node hierarchy
  • node properties, editing / Editing node properties
  • interacting with / Interacting with your things
  • managing / Managing your things
• tightly coupled interface / Understanding coupling
• tokens
  • validating / Validating tokens
  • using, in JavaScript / Using tokens in JavaScript
  • used, for identification / Using tokens for identification
  • GetToken method / Using tokens for identification
  • GetCertificate method / Using tokens for identification
  • used, for transporting claims / Using tokens to transport claims
• topic / Understanding the Publish/Subscribe pattern
• topology independent / Understanding the value of brokers
• Transport Layer Security (TLS) / Using encryption, Securing CoAP communication, Skimming the basics of encryption
• trust-based communication
  • used, for securing network / Using trust-based communication to secure the network
• Trusted Platform Modules (TPM) / Creating checklists
• Type-Length-Value (TLV) format / Understanding LWM2M server operations

U

• ubiquitous encryption
  • about / Providing global scalability
  • enforcing / Enforcing ubiquitous encryption
• UDP
  • using / Using UDP
• unacknowledged service / Using UDP
• Uniform Resource Identifier (URI) / Redefining the web
• Uniform Resource Locator (URL)
  • about / Introducing the HTTP protocol, Redefining the web
  • reference / Locating a resource
• Universal Plug and Play (UPnP) / Discovering things on the internet
• Universal Windows Platform (UWP) applications / Creating your first project, Adding file-based resources to your projects, Running the gateway as an app
• User-Managed Access (UMA) / Redefining the web
• user authentication
  • about / Authenticating users
  • login page, adding / Adding a login page
  • user, creating / Creating our user
  • user database, creating / Creating a very simple user database
  • login form, posting / Posting login form
  • form, parsing / Parsing the form
  • user, redirecting / Redirecting the user
  • authentication method, using / Authenticating the user

V

• vertical segmentation / Dividing responsibilities
• Visual Studio 2017
  • using / Choosing a development environment

W

• Waher.IoTGateway.Win32 / Creating an installer
• Waher.IoTGateway library
  • reference / Running the IoT Gateway
• Waher.Networking.CoAP NuGet / Adding CoAP to our devices
• Waher.Persistence.Files package / Preparing our project
• Waher.Service.GPIO project
  • URL / Testing the app
• Waher.Things.Attributes namespace, attribute
  • AlphaChannel / Editing node properties
  • DateOnly / Editing node properties
  • DefaultLanguage / Editing node properties
  • Header / Editing node properties
  • Masked / Editing node properties
  • Open / Editing node properties
  • Option / Editing node properties
  • Page / Editing node properties
  • Range / Editing node properties
  • ReadOnly / Editing node properties
  • RegularExpression / Editing node properties
  • Required / Editing node properties
  • Section / Editing node properties
  • Text / Editing node properties
  • ToolTip / Editing node properties
• WaherIoT Gateway / Understanding the IoT Gateway project
• web
  • redefining / Redefining the web
• web browsers / Introducing the HTTP protocol
• web content
  • providing / Providing web content
  • network folders, publishing / Publishing network folders
  • Markdown, using / Using Markdown
  • metadata, using for Search Engine Optimization / Using metadata for Search Engine Optimization
  • menus, providing with Master/Detail model / Providing menus using the Master/Detail model
  • user experience, customizing / Customizing the user experience
  • security headers, adding / Adding security headers
  • user privileges, authorizing / Authorizing user privileges
  • customizing, with server-side script / Customizing content using server-side script
  • code visualization, customizing / Customizing code visualization
  • multimedia presentation, customizing / Customizing multimedia presentation
  • information, pushing to web clients / Pushing information to web clients
• web pages / Introducing the HTTP protocol, Redefining the web
• Web RTC / Redefining the web
• web servers / Introducing the HTTP protocol
• web services
  • protecting / Protecting our web services
  • session token, obtaining / Getting a session token
  • tokens, validating / Validating tokens
  • tokens, using in JavaScript / Using tokens in JavaScript
• Web Sockets / Choosing a connection direction, Redefining the web
• web technologies / Introducing the HTTP protocol
• white-list authorization / Protecting personal data
• wildcards
  • about / Understanding the Publish/Subscribe pattern
  • using / Avoiding leaking data unintentionally
• Windows 10
  • installing, on Raspberry Pi / Installing Windows 10 on your Raspberry Pi
• Windows IoT Remote Client / Preparing the connection for first-time use
• Windows Remote Arduino Experience App
  • URL / Testing your Arduino board
• Windows Service
  • IoT Gateway, executing / Running the gateway as a Windows service
• Wireshark
  • URL / Checking encrypted communication
• WiX MSI installer project / Creating an installer
• WiX toolset
  • URL / Creating an installer
  • about / Creating an installer
• World Wide Web (WWW) / Introducing the HTTP protocol
• World Wide Web Consortium (W3C) / Introducing the HTTP protocol

X

• X.509 certificates / Using certificates
• Xamarin Studio
  • about / Choosing a development environment
  • URL / Choosing a development environment
• XML data types
  • reference / Understanding the conceptual model
• XML Schema / Adding a schema reference
• XMPP, adding to devices
  • projects, creating / Adding XMPP to our devices
  • NuGet packages, adding / Adding XMPP to our devices
  • broker, connecting / Connecting to our broker
  • sensor data, publishing over XMPP / Making sensor data available over XMPP
  • control parameters, publishing / Publishing control parameters
  • chat interface, adding / Adding a chat interface
• XMPP address
  • local part / Understanding XMPP addresses
  • resource part / Understanding XMPP addresses
  • reference / Understanding XMPP addresses
• XMPP address, format
  • Domain / Understanding XMPP addresses
  • Local@Domain / Understanding XMPP addresses
  • Local@Domain/Resource / Understanding XMPP addresses
• XMPP devices
  • testing / Testing your devices
  • human interface, testing / Testing the human interface
  • machine interface, testing / Testing the machine interface
• XMPP Extension Protocols (XEPs) / Introducing XMPP
• XMPP extensions
  • reference / Extending XMPP
• XMPP servers / Understanding the value of brokers
• XMPP Standards Foundation (XSF) / Introducing XMPP