Upload
julien-vermillard
View
1.381
Download
10
Embed Size (px)
Citation preview
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?