Framework for IoT Interoperability

Samsung Open Source Group 1Samsung Open Source Group #OSIS2017
Framework for IoT interoperability
Philippe Coval
Samsung Open Source Group / SRUK
philippe.coval@osg.samsung.com
From sensors to Tizen devices and beyond ?
Open Source Innovation Spring
#OSIS2017, CNRS Paris, France <2017-07-11>

/whois Philippe Coval
● Software engineer for Samsung Research
– Belongs to Open Source Group (S-OSG) EU/UK team
● I am based in Rennes, France
– Commits into IoTivity, Tizen, Yocto, Automotive OS (GENIVI, AGL)...
– Ask me about FLOSS, OSHW, DIY, Communities
● Find me online
– https://wiki.tizen.org/wiki/User:Pcoval

Agenda
● What is Open Connectivity's IoTivity ?
● Demo and examples
?

Internet of Things is: A complex equation
● Where all parameters are correlated :
– Connectivity: not only Internet, probably IP, but not only
● Personal (<1m), Local (<10m - 10km), Metropolitan (<10km), Wide Area
(<1000Km)
– Security matters ! (during all expected life span)
● Several surfaces of attacks: service, monitoring, upgrade
– Cost of materials and cost of usage:
● Computing capability (CPU or MCU?), consumption, if 24x7
● Development, maintenance: FLOSS or Closed source ?

● Many Silos / Many implementations :
– One app per device (better than many remote controls)
– Dependence on centralized models (hub/cloud)
● Many concerns or issues:
– Security/Privacy concerns?
– Long term support and maintenance?
– Do we want critical devices exposed to the Internet ?
● Few Interoperability/Interconnection of today's things.
IoT: Internet of Today or Internet of Troubles ?

Samsung Open Source Group 6
“Without trust there's no cooperation.
And without cooperation there's no progress.
History stops.”
~ Rick Yancey, The Last Star

Open connectivity foundation's mission
● Provide software linking the Internet Of Things
– Focus on interoperability and seamless connectivity between devices
● Write specification, Establish a protocol,
– Rely on existing standards (CoAP, TLS), or OSS libs
● Sponsor Reference implementation:
– OpenSource (Apache 2.0 license)
● Hosted by Linux Foundation (like kernel, Tizen etc)
– Rule: No unimplemented features in specification
● Certify conformance to standard of products
● Above 300 members already joined, did you?

Common technology for multiple profiles
Architecture
RESTful
CRUD-N
Communication
CoAP, CBor
+Security
DTLS
Semantics
RAML
Smart
Home:
Zigbee
Blue
Tooth
Personal
Devices
Wearables:
BLE
Cloud: HTTP/ TCP
Mobilty
Automotive
LTE*
V2X*
...

IoTivity Framework for connecting devices
● Core cross platform libraries
– C API: resource layer + connectivity abstraction (IP, BT, BLE...)
● Link to libcoap, tinycbor (code footprint ~128KiB-)
– C++ API: C++11 bindings to build extra services
● + High level services (Mostly C++)
– Data/Device Management: Container, Hosting, Encapsulation, Scene
– Simulator (Eclipse based), http proxy
● + Plugins: Transport, Cloud Interface, Bridging
● Related projects
– IoTivity-Node: Javascript bindings
– IoTivity-contrainted: For thin devices (micro-controllers)

Flow: Create, Read, Update, Delete, Notify
IoTivity Server IoTivity Client(s)
Local IP Network
Registration of resource
Handling new requests Set/Get/ing properties values
Initialization as server Initialization as client
Handling new clients Discovery of resource
POST/ GET
UDP Multicast
+ CoAP
Notify updated resource Observe resource change
& Handling propertiesOBSERVE

11Samsung Open Source Group #OSIS2017
CES2017 Smart Home+Automotive
https://youtu.be/3d0uZE6lHo#smarthome-ces2017
Automotive: SmartHome interaction and more
– https://wiki.iotivity.org/automotive

Resource Model
/example/BinarySwitchResURI
{
“p” : Discoverable & Observable & Secured,
“if” : ["oic.if.a","oic.if.baseline"],
“rt” : [“oic.r.switch.binary”],
“value” : true
...
}
URI:
+ common
properties:
Policy:
& Interface:
Resource Type:
+ attribute(s)
● Well knows resources URI (/oic/*):
– “res” discovery, “p” for platform , “d”: device (role: C/S), “sec/*” : security

Data models can be:
● Described
– For RESTful operations (CRUD)
– RAML+JSON Schemas
● Reviewed and validated
– OCF check consistency
● Shared
– OneIotA.org tool & repository
● Note:
– IoTivity works with private models too
● oic.r.switch.binary.json
– http://www.oneiota.org/revisions/1580
● /* … */ "definitions": {
  "oic.r.switch.binary": {
    "properties": {
      "value": {
        "type": "boolean",
        "description":
          "Status of the switch"
}  }  } /* … */

Hardware Support
● Desktop, Mobile...
● Single Board Computers: RaspberryPI, ARTIK modules...
– Full stack (CSDK, C++, C++ Services)
– IoTivity-node (Javascript bindings)
– OS: Tizen, Yocto, and most GNU/Linux distros
● Microcontollers:
– IoTivity-constrained: implementation of OCF protocol
– OS: Baremetal, Linux, Zephyr, TizenRT, RIOT (WIP)
– Note CSDK (1.2.1-) supported ATmega2560

Security matters
● Connectivity Abstraction layer establishes secure channel using DTLS
● Devices need to be provisioned (using onboarding tool):
– Establish ownership in user's network
● Secure Resource Manager (SRM)
– Secure Virtual resources
● Device provisioning, Credentials, Access control list, persistence
– Policy engine: Request filtering: Grant, deny resource requests
● Per policy, requester ID, ACL, device status...
– Is an OIC resource (“/oic/sec/cred”)
● Hardware hardening: use encryption and secure contexts, RNG, IO etc

Samsung Open Source Group 16
“Talk is cheap.
Show me the code.”
~ Linus Torvalds

Getting started with IoTivity

IoTivity 1.2.1 is latest release
– Uses Scons build system with many options: Transport, Security, Log...
– Note: Upstream just enabled security on 1.3-rel

Prefer to use or rebuild packages to local build/install
– Use standard path (/usr/include …)

Major Operating system are supported
– Tizen provides RPM/spec for Tizen:3 profiles, with security enabled
– Yocto's meta-oic ships it with security disabled like upstream
– Debian, Ubuntu, deb packages are possible too
●
Details: https://wiki.iotivity.org/os , https://wiki.iotivity.org/build
Samsung Open Source Group

IoTivity-example tutorial

OCF application developers might not develop in upstream source tree
– SCons build system is complex (even for sample apps)

A standalone project is better to get inspiration from or derivate (SDK?)
– Tend to be minimalist, can be used as base (fork it at will)

Download a collection of standalone subprojects:
– git clone http://git.s-osg.org/iotivity-example/ ; make

Each ”feature” subproject is a git module (pulling a branch based on other)
– Nice history to understand each steps
– For many OSes or build system (Currently, GNUmake, Linux, Tizen, More welcome)

Base example: Resource discovery

branch=example/master (src/example/master/README.md)
– Server register a “dummy” resource identified as “/ExampleResURI”
– Client discover and list all resources' endpoints served in local network
– GNUmake is used to build it
– Systemd service provided to start it once installed

branch=example/packaging is based on previous one
– Yocto Bitbake recipe
– Tizen RPM spec file
– Debian/Ubuntu packaging files too (more welcome)

IoTivity
Server
IoTivity
Client(s)
IP Network
Resource discovery example flow
class IoTServer {
int main() { init(); … }
OC::PlatformConfig mPlatformConfig;
void init() {
mPlatformConfig = OC::PlatformConfig
(OC::ServiceType::InProc,
OC::ModeType::Server, // different that C
"0.0.0.0", 0, // default for all subnets / ifaces
OC::QualityOfService::LowQos //or HighQos
);
OCPlatform::Configure(mPlatformConfig);
}
};
class IoTClient {
int main() { init(); … }
OC::PlatformConfig mPlatformConfig;
void init() {
mPlatformConfig = OC::PlatformConfig
(OC::ServiceType::InProc,
OC::ModeType::Client, // different than S
"0.0.0.0", 0, // on any random port available
OC::QualityOfService::LowQos // or HighQos
);
OCPlatform::Configure(mPlatformConfig);
}
};

main {
IoTServer::init() { ModeType::Server }
IoTServer::createResource()
{ OCPlatform::registerResource(... uri …) }
// loop on OCProcess() is called internally
}
main {
IoTClient::init() { ModeType::Client }
IoTClient::start()
{ OCPlatform::findResource(onFindCallback) }
IoTClient::onFind(resource)
{ print(resource->uri) }
IoTivity
Server
IoTivity
Client(s)
IP Network
Resource discovery example flow
$ ./bin/server -v
(...)
log: { IoTServer::createResource(...)
log: Successfully created
org.example.r.example resource
log: } OCStackResult
(...)
$ ./bin/client -v
(...)
log: { void IoTClient::onFind(...)
log: Resource: uri: /oic/d
(...)
log: Resource: uri: /ExampleResURI
coap://[fe80::baca:3aff:fe9b:b934%25eth0]:47508

Binary switch example
● Actuator, client change value (on/off) of server's resource
● IoTivity-example's branch=switch/master
– Is based on “example/packaging” and adapted
● Usage:
./bin/client
menu:
0) Set value off
1) Set value on
(...)
1
./bin/server -v
log: { OCEntityHandlerResult
IoTServer::handleEntity(...)
log: { OCStackResult IoTServer::handlePost(...)
log: { void Platform::setValue(bool)
1
log: } void Platform::setValue(bool)
log: { void
IoTServer::postResourceRepresentation()

OCResource::post(rep, callback);
onPost(...)
Switch Example: Resource update
OCPlatform::Configure(...);
OCPlatform::registerResource( …);
handleEntity(OCResourceRequest) {
switch entityHandlerRequest->method {
case 'POST:
// update actuator resource (physically)
...
OCPlatform::sendResponse(response);
}}
OCPlatform::Configure(...);
OCPlatform::findResource(...);
onFind(... resource ...)
IoTivity Server IoTivity Client(s)
IP NetworkIP Network
● Client controls actuator:
– Set resource's value
● Server is handling request
– and responding

Interaction with products
● Tizen is an Operating System based on FLOSS
● Shipped into consumer electronics products
● Tizen IoTivity
– Tizen:3 contains as platform package (.rpm)
– Tizen:2 can ship shared lib into native app (.tpk)
● For Samsung Z{1,2,3} (Tizen:2.4:Mobile)
● Samsung GearS{2,3} (Tizen:2.3.x:Wearable)

Derivate to Tizen native app

iotivity-example branches for Tizen devices:
– Mobile (Z1) : switch/tizen/2.4/mobile/master
– Wearables (GearS2) : sandbox/pcoval/tizen/wearable/2.3.2/master

Need to rebuild IoTivity’s shared lib (to be bundled in tpk):
– Use helper script build rpm and unpack lib
– ./tizen.mk ; ls lib/*.so
– ./tizen.mk run # deploy on root device (ie TM1)

More details or ask for help:
– https://wiki.iotivity.org/tizen

Want more ?

Smart City’s Street lights use case

Various examples combined in demo using nodejs
– Branch “sandbox/pcoval/on/master/demo”
●
Defective Street lights notification service
– Sensor to read luminance
– Switch front light on if too dark
– Send message to ARTIK cloud
– Using geolocation client/server
11
2
3
5
6
4
7

From devices to cloud AutoLinux demo
https://vimeo.com/202478132#iotivity-artik-20170204rzr
1
2
1

/GeoLocationResURI
{
latitude: 52.165,
longitude: -2.21,
}
A Vehicle to Infrastructure notification service
function handle(illuminance) {
  if (gThreshold > illuminance) {
    var data= { illuminance: illuminance,
                latitude: gGeo.latitude, longitude: gGeo.longitude };
    sender.send(data); // { ARTIK's client.post(url...); }
} }
client.on("resourcefound", function(resource) {
  if ("/IlluminanceResURI" === resource.resourcePath) {
    resource.on("update", handle);
  } else if ("/GeolocationResURI" === resource.resourcePath) {
    resource.on("update",
      function(resource) { gGeo = resource.properties; });
} };
1
2
/IlluminanceResURI
{
illuminance: 42
}
https://api.artik.cloud/
{
illuminance: 42,
latitude: 52.165,
longitude: -2.21
}
3
1

Forward data to a cloud backend
● Login your artik.io dashboard
– Select or (re)define “OCF” data models
● https://developer.artik.cloud/dashboard/devicetypes
– Declare devices: (Copy IDs)
● https://my.artik.cloud/devices
– Monitor:
● https://my.artik.cloud/data
● Send data on resource “update” event
– Using http REST (or CoAP, WebSocket...)
require("node-rest-client").Client;
client.post(url, message, callback);
https://api.artik.cloud/v1.1/messages
message = {
  headers: {
    'ContentType': 'application/json',
     Authorization: 'bearer
                BADC0DE(...)DEADBEEF42'
}, data: {
    sdid:'deadbeef(...)badc0de13',
    ts: 1485178599672,
    type: 'message',
    data: { illuminance: 42 }
} }

Summary
● OCF establishes a standard for interconnecting things
– Resource model
– RESTful architecture
– Definitions must be shared to ensure interoperability
● Open Source project IoTivity
– implements it in C, C++, Java and Javascript
– Shipped into Tizen:3+ and available for many OS.
– Provide core and hi level services for management, security, cloud

References
● Entry points:
– https://wiki.iotivity.org/examples : git clone iotivity-example
– https://wiki.iotivity.org/docker : cloud images from Ondrej Tomcik
– http://wiki.iotivity.org/automotive
● Going further:
– https://openconnectivity.org/resources/iotivity
– https://openconnectivity.org/resources/oneiota-data-model-tool
– https://news.samsung.com/global/samsung-contributes-to-open-iot-showcase-at-ces-2017
● Keep in touch online:
– https://www.meetup.com/OCF-France/
– https://wiki.iotivity.org/community
– https://wiki.tizen.org/wiki/Meeting
– https://blogs.s-osg.org/author/pcoval/

Thank you,
Merci, Trugarez,
맙습니다 , 谢谢
Gracias, Danke Schoen!
Resources: flaticons CC
Contact:
https://wiki.tizen.org/wiki/User:Pcoval

Framework for IoT Interoperability

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (19)

Similar a Framework for IoT Interoperability

Similar a Framework for IoT Interoperability (20)

Más de Samsung Open Source Group

Más de Samsung Open Source Group (8)

Último

Último (20)

Framework for IoT Interoperability