Hands-on with Lightweight M2M

Run a smartwatch on the Internet-of-Things

Agenda

IntroCoAP & Lightweight M2MDemoEclipse LeshanHands-on!Eclipse WakaamaGoing further

Your devoted presenters

Julien VermillardManuel SangoïSimon Bernard

Lightweight M2MOpen Mobile Alliance

Lightweight M2M - What is it?

A reboot of OMA-DM targeting M2M

Built on top of CoAP (RFC 7252) and DTLS (RFC 6347)

A REST API for device management and applications

Device management?Operate, monitor, configure, upgrade fleets of

communicating objects

Device management

Firmware/software upgrade

Configure “OTA” the device

Monitor connectivity (signal, statistics,..)

Reboot, reset to factory

Rotate security keys

In a consistent way for different hardware

Based on CoAP?The Constrained Application Protocol

A new protocol for a new world

Class 1 devices~100KiB Flash~10KiB RAM

Low-power networks<100Bytes packets

Where old solutions doesn’t fit

Targetof less than $1 for IoT SoC

TCP and HTTPare not a good fit

CoAP - RFC 7252

RESTful protocol designed from scratch

URIs, Internet Media Types

GET, POST, PUT, DELETE

Transparent mapping to HTTP

Additional features for M2M scenarios

Observe

Compact and binary

Binary protocol- Low parsing complexity

- Small message size

Options- Binary HTTP-like headers

0 – 8 Bytes TokenExchange handle for client

4-byte Base HeaderVersion | Type | T-len | Code | ID

OptionsLocation, Max-Age, ETag, …

Marker0xFF

PayloadRepresentation

CoAP Security

Based on DTLS 1.2 (TLS for Datagrams)

Focus on AES and Elliptic Curve Crypto (ECC)

Pre-shared secrets, X.509, or raw public keys

Hardware acceleration in IoT oriented SoC

LwM2MAn API on top of CoAP

Lightweight M2M

REST API for:

Security, Device, Server

Connectivity monitoring, Connectivity statistics

Location, Firmware Upgrade, Software management,

Swipe & Lock

But objects have a numerical identifier

LwM2M URLs

/{object}/{instance}/{resource}

Examples:● "/6/0" the whole location object (binary record)

● "/6/0/1" only the longitude (degree)

Standard objects

Example: Device ManufacturerModel numberSerial numberFirmware versionRebootFactory resetPower sources

Power V/ABattery levelMemory freeError codeCurrent timeUTC offsetTimezone

Custom objects

You can define your own objects

Discoverable using CoAP Link Format

IPSO Alliance Smart Objects:

accelerometer, temperature, sensors,...

Showtime!

The smartwatch demo

Eclipse LeshanLightweight M2M for Java

Leshan

Java library for implementing servers & clients

Friendly for any Java developer

Simple (no framework, few dependencies)

But also a Web UI for discovering and testing

Build using “mvn install”

Based on Californium and Scandium

History

Started 22 Jul. 2013 @ Sierra Wireless

First external contribution 10 March 2014

Public sandbox Jul. 2014

Proposed as an Eclipse project Sep. 2014

Client contributed Oct. 2014

LwM2M playground: Public sandbox

http://leshan.eclipse.org

Bleeding edge: deployed on master commit

IPv4 and IPv6

Press “CoAP messages” for low-level traces

Commiters

Simon Bernard - Sierra Wireless

Kai Hudalla - Bosch Software Innovations

Manuel Sangoï - Sierra Wireless

J.F. Schloman - Zebra Technologies, Zatar

Julien Vermillard - Sierra Wireless

Leshan Features

Client initiated bootstrap

Registration/Deregistration

Read, Write, Create objects

TLV encoding/decoding

OSGi friendly:https://github.com/eclipse/leshan.osgi

Leshan security

DTLS Pre-Shared-Key

DTLS Raw-Public-Key

DTLS X.509

Maven modules

leshan-core commons elements

leshan-server-core server lwm2m logic

leshan-server-cf californium server

leshan-client-core client lwm2m logic

leshan-client-cf californium client

leshan-all everything above in 1 jar

leshan-client-example

leshan-standalone application with web UI

leshan-bs-server standalone bootstrap

leshan-integration-tests

Server API

// Build LWM2M serverlwServer = new LeshanServerBuilder().build();lwServer.getClientRegistry().addListener(new ClientRegistryListener() {

@Overridepublic void registered(Client client) {

System.out.println("New registered client with endpoint: " +client.getEndpoint());

}

@Overridepublic void updated(Client clientUpdated) {

System.out.println("Registration updated”);}

@Overridepublic void unregistered(Client client) {

System.out.println("Registration deleted”);}

});

// StartlwServer.start();System.out.println("Demo server started");

Server API

// Prepare the new valueLwM2mResource currentTimeResource = new LwM2mResource(13,

Value.newDateValue(new Date()));

// Send a write request to a clientWriteRequest writeCurrentTime = new WriteRequest(client, 3, 0, 13,

currentTimeResource, ContentFormat.TEXT, true);

ClientResponse response = lwServer.send(writeCurrentTime);System.out.println("Response to write request from client " +

client.getEndpoint() + ": " +response.getCode());

Implements your own store

ClientRegistry: Store currently registered clients

SecurityRegistry: Store security informations

Default implementations are “in-memory”for demo only!

Client API

// Initialize object tree with device(3) and location(6) objectsList<ObjectEnabler> enablers = new ObjectsInitializer().create(3, 6);

// Create a clientLeshanClient client = new LeshanClient(new InetSocketAddress("127.0.0.1", 5683), new ArrayList<LwM2mObjectEnabler>(enablers));

// Start itclient.start();

// Register to the serverRegisterResponse response = client.send(new RegisterRequest("myDevice"));System.out.println("Response to register request from server : " + response.getCode());

Implements your own LwM2m Objects

Lwm2m Object instance are mapped on Java instance.

Default implementation are just stupid mock for demo only.

Hands-on!

Getting started

● Tutorial projectsFrom the USB stick

orhttps://github.com/msangoi/leshan-tuto

● Launch Eclipse and import the projectsFile > Import... > Existing projects into workspace

Step 1

Register a LWM2M client with a server

1. Complete the codeSend a registration request to the server

2. Run a local server (leshan standalone)java -jar leshan-standalone.jarWeb UI available: http://localhost:8080/#/clients

3. Run the client

Step 2

Define your own Device standard object

1. Complete the codea. Handle Read requests for some resources

(Manufacturer model, Current timestamp…)b. Handle Write requests for Current timestamp resourcec. Handle Exec requests for Reboot resource

2. Run the client (same server as Step 1)

Step 3

Run a server synchronizing the current time of each new registered client

1. Complete the codea. Build a leshan serverb. Listen for new client registrationsc. Send a write request to synchronize the current time

of the client (resource with path /3/0/13)

2. Run the server3. Test with the client from Step 2

Step 4

Observe the current time of a registered client

1. Update the client (from step 2) to notify when the current time value has changed

2. Complete the server codea. Listen for new observations and log the new value

when a new notification is receivedb. Listen for new registrations and send an observe

request (path /3/0/13) to the new clients

Going further

Eclipse Wakaama

A C client and server implementation of LwM2M

Not a shared library (.so/.dll)

Embedded friendly but using malloc/free

Plug your own IP stack and DTLS implementation

Wakaama: Features

Register, registration update, deregister

Read, write resources

Read, write, create, delete object instances

TLV or plain text

Observe

Wakaama: Structure

core :internals.h liblwm2m.c liblwm2m.hlist.c management.c objects.c observe.cpacket.c registration.c tlv.c transaction.curi.c utils.c

core/er-coap-13 :er-coap-13.c er-coap-13.h

lwm2m_object_t * get_object_device(){ lwm2m_object_t * deviceObj; deviceObj = (lwm2m_object_t *)lwm2m_malloc(sizeof(lwm2m_object_t));

if (NULL != deviceObj) { memset(deviceObj, 0, sizeof(lwm2m_object_t)); deviceObj->objID = 3;

deviceObj->readFunc = prv_device_read; deviceObj->writeFunc = prv_device_write; deviceObj->executeFunc = prv_device_execute; deviceObj->userData = lwm2m_malloc(sizeof(device_data_t));

if (NULL != deviceObj->userData) { ((device_data_t*)deviceObj->userData)->time = 1367491215; strcpy(((device_data_t*)deviceObj->userData)->time_offset, "+01:00"); } else { lwm2m_free(deviceObj); deviceObj = NULL; } }

return deviceObj;}

Create objects!

objArray[0] = get_object_device();if (NULL == objArray[0]){ fprintf(stderr, "Failed to create Device object\r\n"); return -1;}objArray[1] = get_object_firmware();if (NULL == objArray[1]){ fprintf(stderr, "Failed to create Firmware object\r\n"); return -1;}objArray[2] = get_test_object();if (NULL == objArray[2]){ fprintf(stderr, "Failed to create test object\r\n"); return -1;}lwm2mH = lwm2m_init(prv_connect_server, prv_buffer_send, &data);if (NULL == lwm2mH){ fprintf(stderr, "lwm2m_init() failed\r\n"); return -1;}result = lwm2m_configure(lwm2mH, "testlwm2mclient", BINDING_U, NULL, OBJ_COUNT, objArray);...result = lwm2m_start(lwm2mH);

ConfigureWakaama!

while (0 == g_quit){ struct timeval tv; tv.tv_sec = 60; tv.tv_usec = 0;

/* * This function does two things: * - first it does the work needed by liblwm2m (eg. (re)sending some packets). * - Secondly it adjust the timeout value (default 60s) depending on the state of the transaction * (eg. retransmission) and the time between the next operation */ result = lwm2m_step(lwm2mH, &tv); if (result != 0) { fprintf(stderr, "lwm2m_step() failed: 0x%X\r\n", result); return -1; }

Active Loop

TinyDTLS

Eclipse Proposal“Support session multiplexing in single-threaded applications and thus targets specifically on embedded systems.”

Examples for Linux, or Contiki OS

TLS_PSK_WITH_AES_128_CCM_8TLS_ECDHE_ECDSA_WITH_AES128_CCM_8

In real hardware?

Spark Core:Cortex-M3 STM32, RAM/ROM 20/128k, 72MHzWiFi

Arduino MegaAVR, ATmega2560,

RAM/ROM 8/256k, 16MHzEthernet

Thank you!

Questions?