There are multiple ways of using the applications:

* You may clone the project in your computer, and execute npm install from the root of the project, in order to download the dependencies. You can start both applications from the same folder using different console windows.
* Another option is to install directly with npm install -g lwm2m-node-lib. This will install the library in the global node_modules.

Take into account that all the information loaded or registered by any of the applications is transient, so it will be lost once the processes have been stopped.

$3

#### Usage
From the root of the project type (make sure the npm install command has been previously executed to download all the dependencies):
``
bin/iotagent-lwm2m-server.js
`
You can type help in the command line at any moment to get a full list of the available commands.

All the server configuration is read from the config.js file in the root of the project. You can print the configuration that is actually being used using the config command.

To exit the command line client, use CTRL-C.

#### Command reference
`
start

Starts a new Lightweight M2M server listening in the prefconfigured port.

stop

Stops the current LWTM2M Server running.

list

List all the devices connected to the server.

write

Writes the given value to the resource indicated by the URI (in LWTM2M format) in the givendevice.

execute

Executes the selected resource with the given arguments.

read

Reads the value of the resource indicated by the URI (in LWTM2M format) in the given device.

discover

Sends a discover order for the given resource to the given device.

discoverObj

Sends a discover order for the given instance to the given device.

discoverType

Sends a discover order for the given resource to the given device.

observe

Stablish an observation over the selected resource.

writeAttr

Write a new set of observation attributes to the selected resource. The attributes should be
in the following format: name=value(,name=value)*. E.g.: pmin=1,pmax=2.

cancel

Cancel the observation order for the given resource (defined with a LWTM2M URI) to the given device.

config

Print the current config.
`

$3

#### Usage
From the root of the project type (make sure the npm install command has been previously executed to download all the dependencies):
`
bin/iotagent-lwm2m-client.js
`
You can type help in the command line at any moment to get a full list of the available commands.

All the client configuration is read from the config.js file in the root of the project. You can print the configuration that is actually being used using the config command.

To exit the command line client, use CTRL-C or the quit command.

The command line client can also be used to execute scripts. Each line of the script is interpreted as a line in the command line. You have to take two things into account:
* The script is executed as an input to the client, line by line, and it will not end unless a quit command is explicitly issued. In that case, the client will end up in a prepaired state, with the prompt available to receive further commands.
* Currently, all the commands are executed asynchronously, so actions like connection and discconnection may rise errors if executed in the same script (as the disconnection could be exectued before the connection is completed).

The following is an example of script:
`
create /75001/2
create /75002/2
set /75001/2 0 440.81
set /75002/2 1 Connected
connect localhost 60001 PruebasDuplex /
quit
`

#### Command reference
`
create

Create a new object. The object is specified using the /type/id OMA notation.

get

Get all the information on the selected object.

remove

Remove an object. The object is specified using the /type/id OMA notation.

set

Set the value for a resource. If the resource does not exist, it is created.

unset

Removes a resource from the selected object.

list

List all the available objects along with its resource names and values.

connect

Connect to the server in the selected host and port, using the selected endpointName.

updateConnection

Updates the current connection to a server.

disconnect

Disconnect from the current server.

config

Print the current config.

quit

Exit the client.
`

`
"lwm2m-node-lib": "*"
`

In order to use this library, first you must require it:
`
var lwtm2m = require('lwm2m-node-lib');
`
As a Lightweight M2M Server, the library supports four groups of features, one for each direction of the communication: client-to-server and server-to-client (and each flow both for the client and the server). Each feature set is defined in the following sections.

$3

#### Starting and stopping the server
To start the LWTM2M Server execute the following command:
`
lwtm2m.start(config, function(error) {
console.log('Listening');
});
`
The config object contains all the information required to start the server (see its structure in the Configuration section below).

Only one server can be listening at a time in the library (is treated as a singleton), so multiple calls to 'start()' without a previous call to 'stop()' will end up in an error.

To stop the server, execute the following method:
`
lwtm2m.stop(function(error) {
console.log('Server stopped');
});
`
No information is needed to stop the server, as there is a single instance per module.

#### Handling incoming messages
The server listens to multiple kinds incoming messages from the devices, described in the different LWTM2M Interfaces. For each operation of an interface that needs to be captured by the server, this library provides a handler that will have the opportunity to manage the event.

The following table lists the current supported events along with the expected signature of the handlers. Be careful with the handler signatures, as an interruption in the callbacks pipeline may hang up your server.

| Interface | Operation | Code | Signature |
|:---------------- |:---------------------- |:--------------------- |:-------------------- |
| Registration | Register | registration | fn(endpoint, lifetime, version, binding, callback) |
| Registration | Update | unregistration | fn(device, callback) |
| Registration | De-register | updateRegistration | function(object, callback) |

The meaning of each parameter should be clear reading the operation description in OMA's documentation.

$3

#### Device Management Interface: Write
Signature:
`
function write(deviceId, objectType, objectId, resourceId, value, callback)
`
Execute a Write operation over the selected resource, identified following the LWTM2M conventions by its: deviceId, objectType, objectId and resourceId, changing its value to the value passed as a parameter. The device id can be found from the register, based on the name or listing all the available ones.

#### Device Management Interface: Execute
Signature:
`
function execute(deviceId, objectType, objectId, resourceId, arguments, callback)
`
Executes the resource identified following the LWTM2M conventions by its: deviceId, objectType, objectId and resourceId, with the arguments passed as a parameter. The device id can be found from the register, based on the name or listing all the available ones.

#### Device Management Interface: Read
Signature:
`
function read(deviceId, objectType, objectId, resourceId, callback)
`
Execute a read operation for the selected resource, identified following the LWTM2M conventions by its: deviceId, objectType, objectId and resourceId. The device id can be found from the register, based on the name or listing all the available ones.

$3

#### Configuration
The LWM2M Client library has to be configured before any interaction with the remote LWM2M server. This configuration is done through the use of the init() function.
This function takes a configuration object (can be the same one passed to the server), that has a client attribute with the configuraiton for the client (as described
in the configuration section). Failing to do so may lead to unexpected results.

#### Registration
Before making any interaction with a Lightweight M2M server, a client must register to it. This registration can be done with the following function:
`
lwm2mClient.register(host, port, endpointName, function (error, deviceInfo) {
...
});
`
The registration process needs the host and port of the destination server and an endpointName for the device (that must be unique for that server). The server will keep the client's IP in order to send the server-initiated requests.

The callback of the register function returns all the information about the created connection. There are two important pieces of information in this object:
* serverInfo: includes all the information about the listening socket created in the client to attend server calls. It will be needed to stop the client completely.
* location: indicates the URL the client should use to communicate with the server (includes its client ID in the server).

When the client register to a server, it also opens a socket for listening in its machine, so to receive server-initiated requests (the port for listening can be configured in the config object).

The connection to the server can be closed using the following function:
`
lwm2mClient.unregister(deviceInformation, function (error) {
...
})
`
If the client changes its IP for whatever reason, it must updates its registration in the server, by using the following function:
`
lwm2mClient.update(deviceInformation, function (error) {
...
})
`

#### Object repository
All the information in a Lightweight M2M client is organized in objects and resources of those objects. To assist the client with the management of this information, the library provides a object repository (currently a in-memory transient repository only). This repository can be accessed in the lwm2mClient.registry attribute.

The repository offers the standard CRUD operations over objects, and methods to set and unset resource values inside the objects.

All the objects are identified by a URI that is composed of an Object ID and an Object Instance sepparated by slashes, as specified by the Lightweight M2M specification (e.g.: /1/3).