The Internet of Things is rising fast, but how to run it safely and efficiently using standards?
OMA Lightweight M2M is the brand new IoT protocol for managing smart objects. It provides answers to the typical IoT needs: monitoring, configuring, securing and upgrading devices.
It’s bandwidth efficient and fits in constrained embedded environments while providing friendly and discoverable RESTful API.
This tutorial aims at giving you a hands-on experience with Lightweight M2M by showing you the power and simplicity of the Eclipse Leshan library for managing real world IoT application.
Agenda:
- Introduction to CoAP and Lightweight M2M
- Demo and live discovery of a connected smartwatch
- Presentation of Eclipse Leshan, a lightweight M2M implementation for Java
- Code your own Java server, and start managing fleet of smartwatches!
- Presentation of more advanced lightweight M2M topic: firmware upgrade, security, bootstrap, Wakaama and Tinydtls
- Code a smartwatch application using Lightweight M2M
5. 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
9. A new protocol for a new world
Class 1 devices
~100KiB Flash
~10KiB RAM
Low-power networks
<100Bytes packets
10. Where old solutions doesn’t fit
Target
of less than $1
for IoT SoC
TCP and HTTP
are not a good fit
11. 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
12. Compact and binary
Binary protocol
- Low parsing complexity
- Small message size
Options
- Binary HTTP-like headers
0 – 8 Bytes Token
Exchange handle for client
4-byte Base Header
Version | Type | T-len | Code | ID
Options
Location, Max-Age, ETag, …
Marker
0xFF
Payload
Representation
13. 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
17. Standard objects
Example: Device
Manufacturer
Model number
Serial number
Firmware version
Reboot
Factory reset
Power sources
Power V/A
Battery level
Memory free
Error code
Current time
UTC offset
Timezone
18. Custom objects
You can define your own objects
Discoverable using CoAP Link Format
IPSO Alliance Smart Objects:
accelerometer, temperature, sensors,...
21. 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
22. 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
23. LwM2M playground: Public sandbox
http://leshan.eclipse.org
Bleeding edge: deployed on master commit
IPv4 and IPv6
Press “CoAP messages” for low-level traces
24. Commiters
Simon Bernard - Sierra Wireless
Kai Hudalla - Bosch Software Innovations
Manuel Sangoï - Sierra Wireless
J.F. Schloman - Zebra Technologies, Zatar
Julien Vermillard - Sierra Wireless
27. 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
28. Server API
// Build LWM2M server
lwServer = new LeshanServerBuilder().build();
lwServer.getClientRegistry().addListener(new ClientRegistryListener() {
@Override
public void registered(Client client) {
System.out.println("New registered client with endpoint: " +
client.getEndpoint());
}
@Override
public void updated(Client clientUpdated) {
System.out.println("Registration updated”);
}
@Override
public void unregistered(Client client) {
System.out.println("Registration deleted”);
}
});
// Start
lwServer.start();
System.out.println("Demo server started");
29. Server API
// Prepare the new value
LwM2mResource currentTimeResource = new LwM2mResource(13,
Value.newDateValue(new
Date()));
// Send a write request to a client
WriteRequest 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());
30. Implements your own store
ClientRegistry:
Store currently registered clients
SecurityRegistry:
Store security informations
Default implementations are “in-memory”
for demo only!
31. Client API
// Initialize object tree with device(3) and location(6) objects
List<ObjectEnabler> enablers = new ObjectsInitializer().create(3, 6);
// Create a client
LeshanClient client = new LeshanClient(new InetSocketAddress("127.0.0.1", 5683),
new ArrayList<LwM2mObjectEnabler>(enablers));
// Start it
client.start();
// Register to the server
RegisterResponse response = client.send(new RegisterRequest("myDevice"));
System.out.println("Response to register request from server : " + response.getCode());
32. Implements your own LwM2m Objects
Lwm2m Object instance are mapped on Java
instance.
Default implementation are just stupid mock for
demo only.
34. Getting started
● Tutorial projects
From the USB stick
or
https://github.com/msangoi/leshan-tuto
● Launch Eclipse and import the projects
File > Import... > Existing projects into workspace
35. Step 1
Register a LWM2M client with a server
1. Complete the code
Send a registration request to the server
2. Run a local server (leshan standalone)
java -jar leshan-standalone.jar
Web UI available: http://localhost:8080/#/clients
3. Run the client
36. Step 2
Define your own Device standard object
1. Complete the code
a. Handle Read requests for some resources
(Manufacturer model, Current timestamp…)
b. Handle Write requests for Current timestamp resource
c. Handle Exec requests for Reboot resource
2. Run the client (same server as Step 1)
37. Step 3
Run a server synchronizing the current time of
each new registered client
1. Complete the code
a. Build a leshan server
b. Listen for new client registrations
c. Send a write request to synchronize the current time
of the client (resource with path /3/0/13)
2. Run the server
3. Test with the client from Step 2
38. 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 code
a. Listen for new observations and log the new value
when a new notification is received
b. Listen for new registrations and send an observe
request (path /3/0/13) to the new clients
40. 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
44. objArray[0] = get_object_device();
if (NULL == objArray[0])
{
fprintf(stderr, "Failed to create Device objectrn");
return -1;
}
objArray[1] = get_object_firmware();
if (NULL == objArray[1])
{
fprintf(stderr, "Failed to create Firmware objectrn");
return -1;
}
objArray[2] = get_test_object();
if (NULL == objArray[2])
{
fprintf(stderr, "Failed to create test objectrn");
return -1;
}
lwm2mH = lwm2m_init(prv_connect_server, prv_buffer_send, &data);
if (NULL == lwm2mH)
{
fprintf(stderr, "lwm2m_init() failedrn");
return -1;
}
result = lwm2m_configure(lwm2mH, "testlwm2mclient", BINDING_U, NULL, OBJ_COUNT, objArray);
...
result = lwm2m_start(lwm2mH);
Configure
Wakaama!
45. 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%Xrn", result);
return -1;
}
Active Loop
46. 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_8
TLS_ECDHE_ECDSA_WITH_AES128_CCM_8