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
- 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
- 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
- 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
- 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
- IIS Crypto tool
- 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
- 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
- IoT Gateway repository
- 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
- Let's Encrypt
- 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
- MIoT project
- reference / For further study
- Mono
- 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
- Open Mobile Alliance (OMA)
- 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
- 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)
- 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
- 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
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
- 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
- Windows Service
- IoT Gateway, executing / Running the gateway as a Windows service
- Wireshark
- 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
- 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
