Skip to main content
Jump to: navigation, search

Difference between revisions of "OM2M/Developer"

(Edit the Activator class)
(Edit link at the first line, was redirecting to Download page and not to Clone and build)
 
(130 intermediate revisions by 2 users not shown)
Line 1: Line 1:
 +
'''Before doing this tutorial you have to''' [https://wiki.eclipse.org/OM2M/Clone clone and build OM2M using Eclipse]
 +
 
__TOC__
 
__TOC__
  
== Prerequisite ==
+
=Add a new plug-in to  OM2M=
* Eclipse kepler IDE: available on this link: http://www.eclipse.org/kepler/
+
* OM2M source code: you can download OM2M from this link: http://wiki.eclipse.org/OM2M/Download
+
* Maven: It’s available on the the Eclipse Kepler IDE
+
* Tycho: Available on the marketplace of maven
+
  
== Build OM2M from source: step by step ==
+
== Clone and import OM2M ==
'''Download OM2M source code'''
+
* Clone OM2M using the Eclipse IDE.
* Select Windiow->Show View -> Other .
+
* Import all nested projects into your workspace.
* In the dialog box, select the Git view.
+
* Click on “Clone a Git repository”.
+
[[File:Git_clone.png|thumb|center|350px|Git clone]]
+
  
* Clone the OM2M project using the following link: http://git.eclipse.org/gitroot/om2m/org.eclipse.om2m.git. In the first page, enter the mentionned link in the URI’s location field. Click Next .[[File:git_clonebis.png|thumb|center|600px|Git clone]]
+
== Create a new plug-in project ==
  
* In the second page, keep the “master” branch checkbox selected and click Next.
+
*Create a new plug-in project called org.eclipse.om2m.sample.ipu via File → New → Other → Plug-in Project.
[[File:git_clone2bis.png|thumb|center|600px|Git clone]]
+
*Enter the data as depicted in the following screenshots.
 
+
* In the third page, check the “clone submodules” and “import all existing projects after clone finishes” checkboxes and click “Finish”.
+
[[File:git_clone3bis.png|thumb|center|600px|Git clone]]
+
 
+
* The OM2M project is now cloned and is visible on the Git repositories’ and Package’ explorers.
+
 
+
* Now we will add the required libraries. This step will be removed when all third libraries will be validated by Eclipse.
+
* Download the libraries from this link: http://wiki.eclipse.org/OM2M/Download
+
* Extract OM2M-libs and add the following libraries to "org.eclipse.om2m" repository as follows:
+
** "db4o-core-java5-8.1-SNAPSHOT.jar" library under "org.eclipse.om2m.core\libs", 
+
** "obix.jar" library under "org.eclipse.om2m.commons\libs",
+
** "xsd" folder under "org.eclipse.om2m.commons\src\main\resources".
+
 
+
'''Build OM2M using maven'''
+
* Before building the OM2M project, you need to add “Tycho” to Maven eclipse plug-in. To do so, click Window -> Preferences -> maven -> discovery -> open catalog  and type Tycho. Check the “Tycho Configurator” checkbox.
+
[[File:git_clone5bis.png|thumb|center|600px|Git clone]]
+
 
+
* Select “org.eclipse.om2m” package and right click. Select “Run as -> maven install”.
+
* Two Eclipse products will be generated after a successful built:
+
** The NSCL product can be found on this directory: "om2m/org.eclipse.om2m/org.eclipse.om2m.site.nscl/target/products/nscl/<os>/<ws>/<arch>"
+
** The GSCL product can be found on this directory: "om2m/org.eclipse.om2m/org.eclipse.om2m.site.gscl/target/products/gscl/<os>/<ws>/<arch>"
+
 
+
== Develop your interworking proxy unit plug-in ==
+
 
+
We will start this section by demonstring how to create a plug-in in eclipse and associate it to the om2m platform. Then, we will implement the created plug-in, named "''interworking proxy''", by adding an IpuSample class to monitor M2M devices and an IpuController class to manage them. 
+
 
+
==== Create the interworking proxy unit plug-in ====
+
To create the interworking proxy plug-in, we will follow these steps:
+
* The plug-in project creation,
+
* The maven conversion,
+
* The addition of the created plug-in to a parent project,
+
* Including the created plug-in to om2m platform' product(s).
+
+
'''Step 1: The plug-in project creation'''
+
Create a new plug-in project called org.eclipse.om2m.sample.ipu via File → New → Other → Plug-in Project.
+
Enter the data as depicted in the following screenshots.
+
 
[[File:ipu1.png|thumb|center|600px|create a plug-in project: step 1]]
 
[[File:ipu1.png|thumb|center|600px|create a plug-in project: step 1]]
  
 
[[File:ipu2.png|thumb|center|600px|create a plug-in project: step 2]]
 
[[File:ipu2.png|thumb|center|600px|create a plug-in project: step 2]]
  
Uncheck the ''Create a plug-in using one of the templates'' checkbook and press the ''Finish'' button.
+
*Uncheck the ''Create a plug-in using one of the templates'' checkbook and press the ''Finish'' button.
[[File:ipu3.png|thumb|center|600px|create a plug-in project: step 3]]
+
[[File:ipu3bis.png|thumb|center|600px|create a plug-in project: step 3]]
  
As result the following project is created.  
+
*As result the following project is created.  
 
[[File:ipu4.png|thumb|center|600px|sample ipu plug-in]]
 
[[File:ipu4.png|thumb|center|600px|sample ipu plug-in]]
  
 +
== Convert the plugin into maven project ==
  
''' Step 2: The maven conversion'''
+
*Open the build.properties file in XML and update the src attributes as depicted in the following figure.  
 
+
Once the sample.ipu plug-in created, we will convert it to a ''maven'' project. Before that, we will open the build.properties file in XML and update the src attributes as depicted in the following figure.  
+
 
[[File:Configure1.png|thumb|center|600px|build-properties build]]
 
[[File:Configure1.png|thumb|center|600px|build-properties build]]
  
Select the created plug-in "org.eclipse.om2m.sample.ipu" → right click → configure → maven to maven project.  
+
*Select the created plug-in "org.eclipse.om2m.sample.ipu" → right click → configure → convert to maven project.  
Enter the data as illustrated in the following and press the ''Finish'' button.  
+
*Enter the data as illustrated in the following and press the ''Finish'' button.  
 
[[File:maven_conversionbis.png|thumb|center|600px|maven conversion: POM edition]]
 
[[File:maven_conversionbis.png|thumb|center|600px|maven conversion: POM edition]]
  
Once the plug-in is converted, open the ''pom.xml'' file to edit the parent filed. For this, click on "select Parent" icon and insert "org.eclipse.om2m" in the "Enter groupId, artifactId or sh1 prefix or pattern" field. Select the found jar and press ok.  
+
*Once the plug-in is converted, open the ''pom.xml'' file to edit the parent filed.  
 +
*Click on "select Parent" icon and enter "org.eclipse.om2m" in the "Enter groupId, artifactId or sh1 prefix or pattern" field.  
 +
*Select "org.om2m.eclipse" and press ok.  
 
[[File:pom_edition.png|thumb|center|600px|maven conversion: Parent edition]]
 
[[File:pom_edition.png|thumb|center|600px|maven conversion: Parent edition]]
  
We end this step by updating the plug-inf project. For this, select the "org.eclipse.om2m.sample.ipu" project → maven → update project.
+
*We end this step by updating the plug-in project. For this, select the "org.eclipse.om2m.sample.ipu" project → maven → update project.
  
''' Step 3: The addition of the created plug-in to a parent project'''
+
== Add the plugin as a maven module to the OM2M parent project ==
In this part, we will add the created plug-in as a module to the om2m platform. For this, we will follow these steps:  
+
 
# Open the pom file of the ''org.eclipse.om2m'' package.  
+
* In this part, we will add the created plug-in as a module to the om2m platform:
# Go to the ''modules'' tab and press ''Add'' button.
+
** Open the pom file of the ''org.eclipse.om2m'' package.  
# Select the org.eclipse.ipu.om2m.sample.ipu plug-in and press ''ok''.
+
** Go to the ''modules'' tab and press ''Add'' button.
# Build the om2m package and its sub-projects. To do this, select the "om2m.org.eclipse" package → right click → Run as → maven install.  
+
** Select the org.eclipse.ipu.om2m.sample.ipu plug-in and press ''ok''.
# Check the org.eclipse.om2m.sample.ipu was successfully built. At the buid end, we should get this result.  
+
** Build the om2m package and its sub-projects. To do this, select the "om2m.org.eclipse" package → right click → Run as → maven install.  
 +
** Check the org.eclipse.om2m.sample.ipu was successfully built. At the buid end, we should get this result.  
 
[[File:build.png|thumb|center|600px|om2m build]]
 
[[File:build.png|thumb|center|600px|om2m build]]
  
Remark: To keep the same display pattern for all the platform' plugins, you can add ''description'' and ''name'' tags to the  ''org.eclipse.om2m.sample.ipu''' ''pom.xml'' file.  
+
*Remark: To keep the same display pattern for all the platform' plugins, you can add ''description'' and ''name'' tags to the  ''org.eclipse.om2m.sample.ipu''' ''pom.xml'' file.  
 
<pre>
 
<pre>
 
<project>
 
<project>
Line 98: Line 59:
 
</pre>
 
</pre>
  
''' Step 4: Including the created plug-in to om2m platform' product(s)'''
+
== Add the plugin to the OM2M product(s) ==
  
The final step consists of adding the created plug-in to one of om2m platform products, i.e the ''gscl'' or the ''nscl'' executable. In the following, we choose to add the org.eclipse.om2m.sample.ipu plug-in to the gscl product. To do so, follow these steps:  
+
*The final step consists of adding the created plug-in to one of om2m platform products, i.e the ''gscl'' or the ''nscl'' executable. In the following, we choose to add the org.eclipse.om2m.sample.ipu plug-in to the gscl product:
# select the org.eclipse.om2m.site.gscl package.  
+
* select the org.eclipse.om2m.site.gscl package.  
# open the om2m.product file.  
+
* open the om2m.product file.  
# Press Add button and Type org.eclipse.om2m.sample.ipu
+
* Press Add button and Type org.eclipse.om2m.sample.ipu
# Click on ok button and save.  
+
* Click on ok button and save.  
# Build the om2m package and its sub-projects: select the "om2m.org.eclipse" package right click Run as maven install.
+
* Build the om2m package and its sub-projects: select the "om2m.org.eclipse" package -> right click -> Run as -> maven install.
# To check that the "org.eclipse.om2m.sample.ipu" was successfully added to the gscl product, run the gscl and verify in the console if the "org.eclipse.om2m.sample.ipu" is displayed.
+
* To check that the "org.eclipse.om2m.sample.ipu" was successfully added to the gscl product, run the gscl and verify in the console if the "org.eclipse.om2m.sample.ipu" is displayed.
 
[[File:run.png|thumb|center|600px|gscl product]]
 
[[File:run.png|thumb|center|600px|gscl product]]
 +
== Add required dependencies ==
 +
=== Add plugin dependencies ===
 +
* Open the manifest file of the created plugin and select Dependencies tab.
 +
* Add the dependencies depicted in the following figure.
 +
'''Important!''' You need to import om2m nested projects into your workspace to find them in the list below.
 +
[[File:DependenciesPlugin.png|thumb|center|700px|plugin dependencies]]
  
In the next, we will show an example of an IPU plug-in to create required M2M resources on the gscl resource tree to enable monitoring and controlling simulated sensors and actuators.
+
=== Add jar dependencies (Only if required) ===
 +
If you want to add specific jar libraries to your plugin, you can follow these steps:
 +
* Create a "libs" folder on your plugin project.
 +
* Put required specific jar on the "libs" folder.
 +
* Open the manifest file of the created plugin and select "runtime" tab.
 +
* Go to the "classpath" tab and click on the "Add" button.
 +
* Select the required jar and click on "ok" button.
 +
[[File:jars.png|thumb|center|800px|plugin specific jar dependencies]]
  
==== Develop the monitor’ interworking unit  plug-in ====
+
= Develop an Interworking Proxy Unit (IPU) plugin =
'''''The IPU Monitor class'''''
+
== IPU Activator ==
  
----
+
* The Activator class contains the implementation of the start() and stop() method used to activate and deactivate the IPU plugin.
 +
* In the start() method, the Activator registers the IPU Controller service on the registry to make it available for the CORE plugin. Then, it starts tracking the CORE SCL service to use it once it the CORE plugin is activated.
 +
* In the Stop() method, the Activator can execute some process to make a clean before deactivation such as stopping threads, handle exceptions, etc.
  
 
<source lang="java">
 
<source lang="java">
 
package org.eclipse.om2m.sample.ipu;
 
package org.eclipse.om2m.sample.ipu;
 
 
import obix.Bool;
 
import obix.Contract;
 
import obix.Obj;
 
import obix.Op;
 
import obix.Str;
 
import obix.Uri;
 
import obix.io.ObixEncoder;
 
  
 
import org.apache.commons.logging.Log;
 
import org.apache.commons.logging.Log;
 
import org.apache.commons.logging.LogFactory;
 
import org.apache.commons.logging.LogFactory;
import org.eclipse.om2m.commons.resource.Application;
 
import org.eclipse.om2m.commons.resource.ContentInstance;
 
import org.eclipse.om2m.commons.resource.StatusCode;
 
import org.eclipse.om2m.commons.resource.Container;
 
import org.eclipse.om2m.commons.rest.RequestIndication;
 
import org.eclipse.om2m.commons.rest.ResponseConfirm;
 
 
import org.eclipse.om2m.core.service.SclService;
 
import org.eclipse.om2m.core.service.SclService;
 +
import org.eclipse.om2m.ipu.service.IpuService;
 +
import org.osgi.framework.BundleActivator;
 +
import org.osgi.framework.BundleContext;
 +
import org.osgi.framework.ServiceReference;
 +
import org.osgi.util.tracker.ServiceTracker;
  
 +
public class Activator implements BundleActivator {
 +
private static Log logger = LogFactory.getLog(Activator.class);
 +
private ServiceTracker<Object, Object> sclServiceTracker;
  
 +
        // Activate the plugin
 +
public void start(BundleContext context) throws Exception {
 +
logger.info("IPU started");
 +
               
 +
                // Register the IPU Controller service
 +
logger.info("Register IpuService..");
 +
context.registerService(IpuService.class.getName(), new Controller(), null);
 +
logger.info("IpuService is registered.");
  
 +
                // Track the CORE SCL service
 +
sclServiceTracker = new ServiceTracker<Object, Object>(context,
 +
SclService.class.getName(), null) {
 +
public void removedService(ServiceReference<Object> reference, Object service) {
 +
logger.info("SclService removed");
 +
}
  
public class IpuMonitor {
+
public Object addingService(ServiceReference<Object> reference) {
/** Logger */
+
logger.info("SclService discovered");
    private static Log LOGGER = LogFactory.getLog(IpuMonitor.class);
+
SclService sclService = (SclService) this.context.getService(reference);
    /** Sclbase id */
+
final Monitor IpuMonitor = new Monitor(sclService);
    public final static String SCLID = System.getProperty("org.eclipse.om2m.sclBaseId","");
+
new Thread() {
    /** Admin requesting entity */
+
public void run() {
    static String REQENTITY = System.getProperty("org.eclipse.om2m.adminRequestingEntity","");
+
try {
    /** Generic create method name */
+
IpuMonitor.start();
    public final static String METHOD_CREATE = "CREATE";
+
} catch (Exception e) {
    /** Generic execute method name */
+
logger.error("IpuMonitor error", e);
    public final static String METHOD_EXECUTE = "EXECUTE";
+
}
    /** State container id */
+
}
    public final static String DATA = "DATA";
+
}.start();
    /** Descriptor container id */
+
return sclService;
    public final static String DESC = "DESCRIPTOR";
+
}
    /** Discovered SCL service*/
+
};
    static SclService SCL;
+
sclServiceTracker.open();
    public final static String APOCPATH = "ipu";
+
}
    /**
+
       
    * Constructor
+
        // Deactivate the plugin
    * @param scl - discovered SCL
+
public void stop(BundleContext context) throws Exception {
    */
+
logger.info("IPU stopped");
   
+
}
    public IpuMonitor(SclService scl) {
+
        SCL=scl;
+
    }
+
   
+
    public void start () {
+
+
System.out.println("Hello World!!");
+
LOGGER.info("Lamp waiting for attachement..");
+
+
// Create initial resources for the sensor
+
String lampId = "lamp_0";
+
    createLampResources(lampId, false, APOCPATH);
+
 
+
   
+
LOGGER.info("sensors waiting for attachement..");
+
+
    // Create initial resources for the sensor
+
    String sensorId = "sensor_0";
+
    createSensorResources(sensorId, APOCPATH);
+
   
+
 
+
   
+
 
+
 
}
 
}
    /**
 
    * Returns an obix XML representation describing the lamp.
 
    * @param sclId - SclBase id
 
    * @param appId - Application Id
 
    * @param stateCont - the STATE container id
 
    * @return Obix XML representation
 
    */
 
    public static String getDescriptorRep(String sclId, String appId, String stateCont, String aPoCPath) {
 
        LOGGER.info("Descriptor Representation Construction");
 
        // oBIX
 
        Obj obj = new Obj();
 
        obj.add(new Str("type", "Sensor"));
 
        obj.add(new Str("location","Home"));
 
        obj.add(new Str("appId",appId));
 
        // OP GetState from SCL DataBase
 
        Op opState = new Op();
 
        opState.setName("getState");
 
        opState.setHref(new Uri(sclId+"/"+"applications/"+appId+"/containers/"+stateCont+"/contentInstances/latest/content"));
 
        opState.setIs(new Contract("retrieve"));
 
        opState.setIn(new Contract("obix:Nil"));
 
        opState.setOut(new Contract("obix:Nil"));
 
        obj.add(opState);
 
        // OP GetState from SCL IPU
 
        Op opStateDirect = new Op();
 
        opStateDirect.setName("getState(Direct)");
 
        opStateDirect.setHref(new Uri(sclId+"/"+"applications/"+appId+"/"+aPoCPath));
 
        opStateDirect.setIs(new Contract("retrieve"));
 
        opStateDirect.setIn(new Contract("obix:Nil"));
 
        opStateDirect.setOut(new Contract("obix:Nil"));
 
        obj.add(opStateDirect);
 
  
        return ObixEncoder.toString(obj);
+
</source>
    }
+
  
    /**
+
== IPU Monitor ==
    * Returns an obix XML representation describing the current state.
+
    * @param appId - Application Id
+
    * @param value - current lamp state
+
    * @return Obix XML representation
+
    */
+
   
+
    public static String getStateRep(String appId, int value) {
+
        // oBIX
+
        Obj obj = new Obj();
+
        obj.add(new Str("type","sensor"));
+
        obj.add(new Str("location","Home"));
+
        obj.add(new Str("appId",appId));
+
        String strValue = Integer.toString(value);
+
        obj.add(new Str("state",strValue));
+
        return ObixEncoder.toString(obj);
+
  
    }
+
* The Monitor class creates one sensor application called "MY_SENSOR", and one actuator application called "MY_ACTUATOR". It creates two containers for each application: "DESCRIPTOR" container to store the description and "DATA" container to store the measurements. For each container the right oBIX XML payload is created as contentInstance.
   
+
    /**
+
    * Creates all required resources.
+
    * @param appId - Application ID
+
    * @param aPoCPath - sensor aPocPath
+
    */
+
  
public void createSensorResources(String appId, String aPoCPath) {
+
* The Monitor starts two threads to listen to each application data as well. Once a new data is detected, the Monitor creates a new contentInstance including the measurement representation.
        // Create the Application resource
+
    ResponseConfirm response = SCL.doRequest(new RequestIndication(METHOD_CREATE,SCLID+"/applications",REQENTITY,new Application
+
(appId,aPoCPath)));
+
        // Create Application sub-resources only if application not yet created
+
            // Create DESCRIPTOR container sub-resource
+
    SCL.doRequest(new RequestIndication(METHOD_CREATE,SCLID+"/applications/"+appId+"/containers",REQENTITY,new Container(DESC)));
+
            // Create STATE container sub-resource
+
            SCL.doRequest(new RequestIndication(METHOD_CREATE,SCLID+"/applications/"+appId+"/containers",REQENTITY,new Container(DATA)));
+
           
+
    while (true) {
+
            String content, targetID;
+
            // Create DESCRIPTION contentInstance on the DESCRIPTOR container resource
+
            content = getDescriptorRep(SCLID, appId, DATA, aPoCPath);
+
            targetID= SCLID+"/applications/"+appId+"/containers/"+DESC+"/contentInstances";
+
            SCL.doRequest(new RequestIndication(METHOD_CREATE,targetID,REQENTITY,new ContentInstance(content.getBytes())));
+
  
            // Create initial contentInstance on the STATE container resource
+
<source lang="java">
            int initValue = 10 + (int)(Math.random()*100);
+
package org.eclipse.om2m.sample.ipu;
            content = getStateRep(appId, initValue);
+
            targetID = SCLID+"/applications/"+appId+"/containers/"+DATA+"/contentInstances";
+
            SCL.doRequest(new RequestIndication(METHOD_CREATE,targetID,REQENTITY,new ContentInstance(content.getBytes())));
+
     
+
            try {
+
Thread.sleep(2000);
+
} catch (InterruptedException e) {
+
// TODO Auto-generated catch block
+
e.printStackTrace();
+
}
+
    }
+
    }
+
+
  
/**
+
import org.eclipse.om2m.commons.resource.*;
    * Creates all required resources.
+
import org.eclipse.om2m.commons.rest.*;
    * @param appId - Application ID
+
import org.eclipse.om2m.core.service.SclService;
    * @param initValue - initial lamp value
+
    * @param aPoCPath - lamp aPocPath
+
    */
+
+
public void createLampResources(String appId, boolean initValue, String aPoCPath) {
+
        // Create the Application resource
+
        ResponseConfirm response = SCL.doRequest(new RequestIndication(METHOD_CREATE,SCLID+"/applications",REQENTITY,new Application
+
(appId,aPoCPath)));
+
        // Create Application sub-resources only if application not yet created
+
        if(response.getStatusCode().equals(StatusCode.STATUS_CREATED)) {
+
            // Create DESCRIPTOR container sub-resource
+
            SCL.doRequest(new RequestIndication(METHOD_CREATE,SCLID+"/applications/"+appId+"/containers",REQENTITY,new Container(DESC)));
+
            // Create STATE container sub-resource
+
            SCL.doRequest(new RequestIndication(METHOD_CREATE,SCLID+"/applications/"+appId+"/containers",REQENTITY,new Container(DATA)));
+
  
            String content, targetID;
+
public class Monitor {
            // Create DESCRIPTION contentInstance on the DESCRIPTOR container resource
+
static SclService core;
            content = getDescriptorRep(SCLID, appId, DATA, aPoCPath);
+
static String sclId = System.getProperty("org.eclipse.om2m.sclBaseId", "");
            targetID= SCLID+"/applications/"+appId+"/containers/"+DESC+"/contentInstances";
+
static String reqEntity = System.getProperty("org.eclipse.om2m.adminRequestingEntity", "");
            SCL.doRequest(new RequestIndication(METHOD_CREATE,targetID,REQENTITY,new ContentInstance(content.getBytes())));
+
static String ipuId = "sample";
 +
static String actuatorId = "MY_ACTUATOR";
 +
static String sensorId = "MY_SENSOR";
 +
static boolean actuatorValue = false;
 +
static int sensorValue = 0;
 +
       
 +
public Monitor(SclService sclService) {
 +
core = sclService;
 +
}
  
            // Create initial contentInstance on the STATE container resource
+
public void start() {
            content = Lamp.getStateRep(appId, initValue);
+
                // Create required resources for the Sensor
            targetID = SCLID+"/applications/"+appId+"/containers/"+DATA+"/contentInstances";
+
createSensorResources();
            SCL.doRequest(new RequestIndication(METHOD_CREATE,targetID,REQENTITY,new ContentInstance(content.getBytes())));
+
                // Listen for the Sensor data
        }
+
listenToSensor();
    }
+
  
/**
+
                // Create required resources for the Actuator
    * Creates a ContentInstance resource on STATE container.
+
createActuatorResources();
    * @param lampId - Application ID
+
                // Listen for the Actuator data
    * @param value - measured state
+
listenToActuator();
    */
+
}
    public static void createContentResource(String lampId, boolean value) {
+
        // Creates lampCI with new State
+
        String content = Lamp.getStateRep(lampId, value);
+
        String targetID = SCLID+"/applications/"+lampId+"/containers/"+DATA+"/contentInstances";
+
        SCL.doRequest(new RequestIndication(METHOD_CREATE,targetID,REQENTITY,new ContentInstance(content.getBytes())));
+
    }
+
   
+
    /**
+
    * Sets the lamp state.
+
    * @param appId - Application ID
+
    * @param value - measured state
+
    */
+
   
+
    public static void setLampState(final String appId, String value) {
+
        final boolean newState;
+
        boolean currentState = Lamp.getState(appId);
+
        String str = Boolean.toString(currentState);
+
        if(value.equals(str)) {
+
            newState = !currentState;
+
            createContentResource(appId, newState);
+
        } else {
+
            newState = Boolean.parseBoolean(value);
+
            // Create the CI in the case when the newState is different to the Current Lamp State
+
            if (newState != currentState) {
+
                createContentResource(appId, newState);
+
            }
+
        }
+
        //Lamps.LAMPS_STATES.set(index, newState);
+
        Lamp.setState(newState);
+
    }
+
+
  
}
+
public void createSensorResources() {
 +
String targetId, content;
 +
               
 +
                // Create the MY_SENSOR application
 +
targetId = sclId + "/applications";
 +
ResponseConfirm response = core
 +
.doRequest(new RequestIndication("CREATE", targetId, reqEntity,
 +
new Application(sensorId, ipuId)));
  
</source>
+
if (response.getStatusCode().equals(StatusCode.STATUS_CREATED)) {
 +
                        // Create the "DESCRIPTOR" container
 +
targetId = sclId + "/applications/" + sensorId + "/containers";
 +
core.doRequest(new RequestIndication("CREATE", targetId, reqEntity,
 +
new Container("DESCRIPTOR")));
 +
               
 +
                        // Create the "DATA" container
 +
core.doRequest(new RequestIndication("CREATE", targetId, reqEntity,
 +
new Container("DATA")));
  
 +
                        // Create the description contentInstance
 +
content = Mapper.getSensorDescriptorRep(sclId, sensorId, ipuId);
 +
targetId = sclId + "/applications/" + sensorId
 +
+ "/containers/DESCRIPTOR/contentInstances";
 +
core.doRequest(new RequestIndication("CREATE", targetId, reqEntity,
 +
new ContentInstance(content.getBytes())));
 +
                       
 +
                        // Create the data contentInstance
 +
content = Mapper.getSensorDataRep(sensorValue);
 +
targetId = sclId + "/applications/" + sensorId
 +
+ "/containers/DATA/contentInstances";
 +
core.doRequest(new RequestIndication("CREATE", targetId, reqEntity,
 +
new ContentInstance(content.getBytes())));
 +
}
 +
}
  
'''''The LAMP class'''''
+
public void createActuatorResources() {
 +
String targetId, content;
 +
               
 +
                // Create the "MY_ACTUATOR" application
 +
targetId = sclId + "/applications";
 +
ResponseConfirm response = core.doRequest(new RequestIndication(
 +
"CREATE", targetId, reqEntity, new Application(actuatorId,ipuId)));
  
----
+
if (response.getStatusCode().equals(StatusCode.STATUS_CREATED)) {
 +
                        // Create the "DESCRIPTOR" container
 +
targetId = sclId + "/applications/" + actuatorId + "/containers";
 +
core.doRequest(new RequestIndication("CREATE", targetId, reqEntity,
 +
new Container("DESCRIPTOR")));
  
 +
                        // Create the "DATA" container
 +
core.doRequest(new RequestIndication("CREATE", targetId, reqEntity,
 +
new Container("DATA")));
  
<source lang="java">
+
                        // Create the description contentInstance
package org.eclipse.om2m.sample.ipu;
+
content = Mapper.getActutaorDescriptorRep(sclId, actuatorId, ipuId);
 +
targetId = sclId + "/applications/" + actuatorId
 +
+ "/containers/DESCRIPTOR/contentInstances";
 +
core.doRequest(new RequestIndication("CREATE", targetId, reqEntity,
 +
content));
  
import obix.Bool;
+
                        // Create the data contentInstance
import obix.Obj;
+
content = Mapper.getActuatorDataRep(actuatorValue);
import obix.Str;
+
targetId = sclId + "/applications/" + actuatorId
import obix.io.ObixEncoder;
+
+ "/containers/DATA/contentInstances";
 +
core.doRequest(new RequestIndication("CREATE", targetId, reqEntity,
 +
content));
 +
}
 +
}
  
 +
public void listenToSensor() {
 +
new Thread() {
 +
public void run() {
 +
while (true) {
 +
                                        // Simualte a random measurement of the sensor
 +
sensorValue = 10 + (int) (Math.random() * 100);
  
public class Lamp {
+
                                        // Create a data contentInstance
/** Lamp state */
+
String content = Mapper.getSensorDataRep(sensorValue);
    private static boolean state = false;
+
String targetID = sclId + "/applications/" + sensorId
 +
+ "/containers/DATA/contentInstances";
 +
core.doRequest(new RequestIndication("CREATE", targetID,reqEntity,
 +
content));
  
+
                                        // Wait for 2 seconds then loop
/**
+
try {
    * Returns an obix XML representation describing the current state.
+
Thread.sleep(2000);
    * @param appId - Application Id
+
} catch (InterruptedException e) {
    * @param value - current lamp state
+
e.printStackTrace();
    * @return Obix XML representation
+
}
    */
+
}
+
}
public static String getStateRep(String appId, boolean initValue) {
+
}.start();
// oBIX
+
        Obj obj = new Obj();
+
        obj.add(new Str("type","LAMP"));
+
        obj.add(new Str("location","Kitchen"));
+
        obj.add(new Str("appId",appId));
+
        obj.add(new Bool("state",initValue));
+
        return ObixEncoder.toString(obj);
+
 
}
 
}
 
/**
 
    * Gets lampState
 
    * @return lampState
 
    */
 
    public static boolean getState(String lampId) {
 
        return state;
 
    }
 
  
    /**
+
public void listenToActuator() {
    * Sets lampState
+
new Thread() {
    */
+
public void run() {
    public static void setState(boolean state) {
+
        Lamp.state = state;
+
    }
+
  
 +
boolean memorizedActuatorValue = false;
 +
while (true) {
 +
                                        // If the Actuator state has changed
 +
if (memorizedActuatorValue != actuatorValue) {
 +
                                                // Memorize the new Actuator state
 +
memorizedActuatorValue = actuatorValue;
 +
 
 +
                                                // Create a data contentInstance
 +
String content = Mapper.getActuatorDataRep(actuatorValue);
 +
String targetID = sclId + "/applications/" + actuatorId
 +
+ "/containers/DATA/contentInstances";
 +
core.doRequest(new RequestIndication("CREATE",targetID, reqEntity,
 +
content));
 +
}
 +
                         
 +
                                        // Wait for 2 seconds then loop
 +
try {
 +
Thread.sleep(2000);
 +
} catch (InterruptedException e) {
 +
e.printStackTrace();
 +
}
 +
}
 +
}
 +
}.start();
 +
}
 
}
 
}
 
</source>
 
</source>
  
==== Develop the controller’ interworking unit plug-in ====
+
== IPU Mapper ==
 
+
* Convert the description and the measured data of the device to oBIX XML representation.
----
+
  
 
<source lang="java">
 
<source lang="java">
 
package org.eclipse.om2m.sample.ipu;
 
package org.eclipse.om2m.sample.ipu;
 +
import org.eclipse.om2m.commons.obix.*;
 +
import org.eclipse.om2m.commons.obix.io.ObixEncoder;
  
import org.apache.commons.logging.Log;
+
public class Mapper {
import org.apache.commons.logging.LogFactory;
+
import org.eclipse.om2m.commons.resource.ErrorInfo;
+
import org.eclipse.om2m.commons.resource.StatusCode;
+
import org.eclipse.om2m.commons.rest.RequestIndication;
+
import org.eclipse.om2m.commons.rest.ResponseConfirm;
+
import org.eclipse.om2m.ipu.service.IpuService;
+
  
 +
public static String getSensorDescriptorRep(String sclId, String appId, String ipuId) {
 +
Obj obj = new Obj();
  
 +
Op opGet = new Op();
 +
opGet.setName("GET");
 +
opGet.setHref(new Uri(sclId + "/applications/" + appId
 +
+ "/containers/DATA/contentInstances/latest/content"));
 +
opGet.setIs(new Contract("retrieve"));
 +
obj.add(opGet);
  
public class IpuController implements IpuService {
+
Op opGetDirect = new Op();
public final static String APOCPATH = "ipu";
+
opGetDirect.setName("GET(Direct)");
private static Log LOGGER = LogFactory.getLog(IpuController.class);
+
opGetDirect.setHref(new Uri(sclId + "/applications/" + appId + "/" + ipuId));
+
opGetDirect.setIs(new Contract("retrieve"));
+
obj.add(opGetDirect);
  
public ResponseConfirm doExecute(RequestIndication requestIndication) {
+
return ObixEncoder.toString(obj);
String[] info = requestIndication.getTargetID().split("/");
+
        String lampId = info[info.length-3];
+
        String type = lampId.split("_")[0];
+
        String value = info[info.length-1];
+
        try {
+
            if(type.equals("lamp")) {
+
                IpuMonitor.setLampState(lampId, value);
+
                return new ResponseConfirm(StatusCode.STATUS_OK);
+
            } else{
+
                return new ResponseConfirm(StatusCode.STATUS_NOT_FOUND,type+" Not found");
+
            }
+
        } catch (Exception e) {
+
            LOGGER.error("IPU Lamp Error",e);
+
            return new ResponseConfirm(StatusCode.STATUS_NOT_IMPLEMENTED,"IPU Lamp Error");
+
        }
+
 
}
 
}
  
+
public static String getActutaorDescriptorRep(String sclId, String appId, String ipuId) {
public ResponseConfirm doRetrieve(RequestIndication requestIndication) {
+
Obj obj = new Obj();
String[] info = requestIndication.getTargetID().split("/");
+
        String appId = info[info.length-2];
+
        String type= appId.split("_")[0];
+
        int contvalue;
+
        boolean value;
+
        String content=null;
+
        try {
+
        if (type.equals("sensor")){
+
            // Get a random Value for the sensor
+
        contvalue = 10 + (int)(Math.random()*100);
+
        content = IpuMonitor.getStateRep(appId, contvalue);
+
        }
+
        else if (type.equals("lamp")){
+
        // Get the boolean Value for the lamp
+
        value = Lamp.getState(appId);
+
        content = Lamp.getStateRep(appId, value);
+
        }
+
        return new ResponseConfirm(StatusCode.STATUS_OK,content);
+
        } catch (Exception e) {
+
            LOGGER.error("Hello sample Error",e);
+
            return new ResponseConfirm(StatusCode.STATUS_NOT_IMPLEMENTED,"IPU Sample Error" );
+
        }
+
}
+
  
 +
Op opGet = new Op();
 +
opGet.setName("GET");
 +
opGet.setHref(new Uri(sclId + "/applications/" + appId
 +
+ "/containers/DATA/contentInstances/latest/content"));
 +
opGet.setIs(new Contract("retrieve"));
 +
obj.add(opGet);
  
public ResponseConfirm doUpdate(RequestIndication requestIndication) {
+
Op opGetDirect = new Op();
return new ResponseConfirm(new ErrorInfo(StatusCode.STATUS_NOT_IMPLEMENTED,requestIndication.getMethod()+
+
opGetDirect.setName("GET(Direct)");
" Method not Implemented"));
+
opGetDirect.setHref(new Uri(sclId + "/applications/" + appId + "/" + ipuId));
}
+
opGetDirect.setIs(new Contract("retrieve"));
 +
obj.add(opGetDirect);
  
+
Op opON = new Op();
public ResponseConfirm doDelete(RequestIndication requestIndication) {
+
opON.setName("ON");
return new ResponseConfirm(new ErrorInfo(StatusCode.STATUS_NOT_IMPLEMENTED,requestIndication.getMethod()+
+
opON.setHref(new Uri(sclId + "/applications/" + appId + "/" + ipuId + "/true"));
" Method not Implemented"));
+
opON.setIs(new Contract("execute"));
}
+
obj.add(opON);
  
 +
Op opOFF = new Op();
 +
opOFF.setName("OFF");
 +
opOFF.setHref(new Uri(sclId + "/applications/" + appId + "/" + ipuId + "/false"));
 +
opOFF.setIs(new Contract("execute"));
 +
obj.add(opOFF);
  
public ResponseConfirm doCreate(RequestIndication requestIndication) {
+
return ObixEncoder.toString(obj);
return new ResponseConfirm(new ErrorInfo(StatusCode.STATUS_NOT_IMPLEMENTED,requestIndication.getMethod()+
+
" Method not Implemented"));
+
 
}
 
}
  
+
public static String getActuatorDataRep(boolean value) {
public String getAPOCPath() {
+
Obj obj = new Obj();
// TODO Auto-generated method stub
+
obj.add(new Bool("data", value));
return APOCPATH;
+
return ObixEncoder.toString(obj);
 
}
 
}
  
 +
public static String getSensorDataRep(int value) {
 +
Obj obj = new Obj();
 +
obj.add(new Int("data", value));
 +
return ObixEncoder.toString(obj);
 +
}
 
}
 
}
 
 
</source>
 
</source>
  
==== Edit the Activator class ====
+
== IPU Controller ==
 +
 
 +
*  Execute received requests from OM2M to the specific technologies.
  
----
 
 
<source lang="java">
 
<source lang="java">
 
package org.eclipse.om2m.sample.ipu;
 
package org.eclipse.om2m.sample.ipu;
  
import org.apache.commons.logging.Log;
+
import org.eclipse.om2m.commons.resource.StatusCode;
import org.apache.commons.logging.LogFactory;
+
import org.eclipse.om2m.commons.rest.*;
import org.eclipse.om2m.core.service.SclService;
+
 
import org.eclipse.om2m.ipu.service.IpuService;
 
import org.eclipse.om2m.ipu.service.IpuService;
import org.osgi.framework.BundleActivator;
 
import org.osgi.framework.BundleContext;
 
import org.osgi.framework.ServiceReference;
 
import org.osgi.util.tracker.ServiceTracker;
 
  
 +
public class Controller implements IpuService {
  
 +
public ResponseConfirm doExecute(RequestIndication requestIndication) {
 +
String[] parts = requestIndication.getTargetID().split("/");
 +
String appId = parts[2];
 +
String value = parts[4];
  
public class Activator implements BundleActivator {
+
if (appId.equals(Monitor.actuatorId)) {
 +
Monitor.actuatorValue = Boolean.parseBoolean(value);
 +
return new ResponseConfirm(StatusCode.STATUS_OK);
 +
} else {
 +
return new ResponseConfirm(StatusCode.STATUS_NOT_FOUND, appId + " not found");
 +
}
 +
}
  
/*
+
public ResponseConfirm doRetrieve(RequestIndication requestIndication) {
* (non-Javadoc)
+
String[] parts = requestIndication.getTargetID().split("/");
* @see org.osgi.framework.BundleActivator#start(org.osgi.framework.BundleContext)
+
String appId = parts[2];
*/
+
String content;
+
/** Logger */
+
    private static Log logger = LogFactory.getLog(Activator.class);
+
    /** SCL service tracker */
+
    private ServiceTracker<Object, Object> sclServiceTracker;
+
   
+
public void start(BundleContext  context) throws Exception {
+
  
logger.info("Register IpuService..");
+
if (appId.equals(Monitor.sensorId)) {
        context.registerService(IpuService.class.getName(), new IpuController(), null);
+
content = Mapper.getSensorDataRep(Monitor.sensorValue);
        logger.info("IpuService is registered.");
+
return new ResponseConfirm(StatusCode.STATUS_OK, content);
 +
} else if (appId.equals(Monitor.actuatorId)) {
 +
content = Mapper.getActuatorDataRep(Monitor.actuatorValue);
 +
return new ResponseConfirm(StatusCode.STATUS_OK, content);
 +
} else {
 +
return new ResponseConfirm(StatusCode.STATUS_NOT_FOUND, appId + " not found");
 +
}
  
        sclServiceTracker = new ServiceTracker<Object, Object>(context, SclService.class.getName(), null) {
+
}
            public void removedService(ServiceReference<Object> reference, Object service) {
+
                logger.info("SclService removed");
+
            }
+
  
            public Object addingService(ServiceReference<Object> reference) {
+
public ResponseConfirm doUpdate(RequestIndication requestIndication) {
                logger.info("SclService discovered");
+
return new ResponseConfirm(StatusCode.STATUS_NOT_IMPLEMENTED,
                SclService sclService = (SclService) this.context.getService(reference);
+
requestIndication.getMethod() + " not Implemented");
                final IpuMonitor IpuMonitor = new IpuMonitor(sclService);
+
                new Thread(){
+
                    public void run(){
+
                        try {
+
                            IpuMonitor.start();
+
                        } catch (Exception e) {
+
                            logger.error("IpuMonitor error", e);
+
                        }
+
                    }
+
                }.start();
+
                return sclService;
+
            }
+
        };
+
        sclServiceTracker.open();
+
    }
+
/*
+
* (non-Javadoc)
+
* @see org.osgi.framework.BundleActivator#stop(org.osgi.framework.BundleContext)
+
*/
+
public void stop(BundleContext context) throws Exception {
+
System.out.println("End Ipu sample");
+
 
}
 
}
  
 +
public ResponseConfirm doDelete(RequestIndication requestIndication) {
 +
return new ResponseConfirm(StatusCode.STATUS_NOT_IMPLEMENTED,
 +
requestIndication.getMethod() + " not Implemented");
 +
}
  
 +
public ResponseConfirm doCreate(RequestIndication requestIndication) {
 +
return new ResponseConfirm(StatusCode.STATUS_NOT_IMPLEMENTED,
 +
requestIndication.getMethod() + " not Implemented");
 +
}
 +
 +
public String getAPOCPath(){
 +
return Monitor.ipuId;
 +
}
 
}
 
}
 
</source>
 
</source>
 
== Test Scenario ==
 
[[File:applications.png|thumb|center|800px|Lamp and sensor applications]]
 
 
[[File:contentInstance.png|thumb|center|800px|ContentInstance resource]]
 
 
[[File:execute.png|thumb|center|800px|Switch on the lamp]]
 

Latest revision as of 05:10, 12 November 2015

Before doing this tutorial you have to clone and build OM2M using Eclipse

Add a new plug-in to OM2M

Clone and import OM2M

  • Clone OM2M using the Eclipse IDE.
  • Import all nested projects into your workspace.

Create a new plug-in project

  • Create a new plug-in project called org.eclipse.om2m.sample.ipu via File → New → Other → Plug-in Project.
  • Enter the data as depicted in the following screenshots.
create a plug-in project: step 1
create a plug-in project: step 2
  • Uncheck the Create a plug-in using one of the templates checkbook and press the Finish button.
create a plug-in project: step 3
  • As result the following project is created.
sample ipu plug-in

Convert the plugin into maven project

  • Open the build.properties file in XML and update the src attributes as depicted in the following figure.
build-properties build
  • Select the created plug-in "org.eclipse.om2m.sample.ipu" → right click → configure → convert to maven project.
  • Enter the data as illustrated in the following and press the Finish button.
maven conversion: POM edition
  • Once the plug-in is converted, open the pom.xml file to edit the parent filed.
  • Click on "select Parent" icon and enter "org.eclipse.om2m" in the "Enter groupId, artifactId or sh1 prefix or pattern" field.
  • Select "org.om2m.eclipse" and press ok.
maven conversion: Parent edition
  • We end this step by updating the plug-in project. For this, select the "org.eclipse.om2m.sample.ipu" project → maven → update project.

Add the plugin as a maven module to the OM2M parent project

  • In this part, we will add the created plug-in as a module to the om2m platform:
    • Open the pom file of the org.eclipse.om2m package.
    • Go to the modules tab and press Add button.
    • Select the org.eclipse.ipu.om2m.sample.ipu plug-in and press ok.
    • Build the om2m package and its sub-projects. To do this, select the "om2m.org.eclipse" package → right click → Run as → maven install.
    • Check the org.eclipse.om2m.sample.ipu was successfully built. At the buid end, we should get this result.
om2m build
  • Remark: To keep the same display pattern for all the platform' plugins, you can add description and name tags to the org.eclipse.om2m.sample.ipu' pom.xml file.
<project>
......
  <name>org.eclipse.om2m :: sample ipu</name>
  <description>org.eclipse.om2m :: sample ipu</description>
.....
</project>

Add the plugin to the OM2M product(s)

  • The final step consists of adding the created plug-in to one of om2m platform products, i.e the gscl or the nscl executable. In the following, we choose to add the org.eclipse.om2m.sample.ipu plug-in to the gscl product:
  • select the org.eclipse.om2m.site.gscl package.
  • open the om2m.product file.
  • Press Add button and Type org.eclipse.om2m.sample.ipu
  • Click on ok button and save.
  • Build the om2m package and its sub-projects: select the "om2m.org.eclipse" package -> right click -> Run as -> maven install.
  • To check that the "org.eclipse.om2m.sample.ipu" was successfully added to the gscl product, run the gscl and verify in the console if the "org.eclipse.om2m.sample.ipu" is displayed.
gscl product

Add required dependencies

Add plugin dependencies

  • Open the manifest file of the created plugin and select Dependencies tab.
  • Add the dependencies depicted in the following figure.

Important! You need to import om2m nested projects into your workspace to find them in the list below.

plugin dependencies

Add jar dependencies (Only if required)

If you want to add specific jar libraries to your plugin, you can follow these steps:

  • Create a "libs" folder on your plugin project.
  • Put required specific jar on the "libs" folder.
  • Open the manifest file of the created plugin and select "runtime" tab.
  • Go to the "classpath" tab and click on the "Add" button.
  • Select the required jar and click on "ok" button.
plugin specific jar dependencies

Develop an Interworking Proxy Unit (IPU) plugin

IPU Activator

  • The Activator class contains the implementation of the start() and stop() method used to activate and deactivate the IPU plugin.
  • In the start() method, the Activator registers the IPU Controller service on the registry to make it available for the CORE plugin. Then, it starts tracking the CORE SCL service to use it once it the CORE plugin is activated.
  • In the Stop() method, the Activator can execute some process to make a clean before deactivation such as stopping threads, handle exceptions, etc.
package org.eclipse.om2m.sample.ipu;
 
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.eclipse.om2m.core.service.SclService;
import org.eclipse.om2m.ipu.service.IpuService;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceReference;
import org.osgi.util.tracker.ServiceTracker;
 
public class Activator implements BundleActivator {
	private static Log logger = LogFactory.getLog(Activator.class);
	private ServiceTracker<Object, Object> sclServiceTracker;
 
        // Activate the plugin
	public void start(BundleContext context) throws Exception {
		logger.info("IPU started");
 
                // Register the IPU Controller service
		logger.info("Register IpuService..");
		context.registerService(IpuService.class.getName(), new Controller(), null);
		logger.info("IpuService is registered.");
 
                // Track the CORE SCL service
		sclServiceTracker = new ServiceTracker<Object, Object>(context,
				SclService.class.getName(), null) {
			public void removedService(ServiceReference<Object> reference, Object service) {
				logger.info("SclService removed");
			}
 
			public Object addingService(ServiceReference<Object> reference) {
				logger.info("SclService discovered");
				SclService sclService = (SclService) this.context.getService(reference);
				final Monitor IpuMonitor = new Monitor(sclService);
				new Thread() {
					public void run() {
						try {
							IpuMonitor.start();
						} catch (Exception e) {
							logger.error("IpuMonitor error", e);
						}
					}
				}.start();
				return sclService;
			}
		};
		sclServiceTracker.open();
	}
 
        // Deactivate the plugin
	public void stop(BundleContext context) throws Exception {
		logger.info("IPU stopped");
	}
}

IPU Monitor

  • The Monitor class creates one sensor application called "MY_SENSOR", and one actuator application called "MY_ACTUATOR". It creates two containers for each application: "DESCRIPTOR" container to store the description and "DATA" container to store the measurements. For each container the right oBIX XML payload is created as contentInstance.
  • The Monitor starts two threads to listen to each application data as well. Once a new data is detected, the Monitor creates a new contentInstance including the measurement representation.
package org.eclipse.om2m.sample.ipu;
 
import org.eclipse.om2m.commons.resource.*;
import org.eclipse.om2m.commons.rest.*;
import org.eclipse.om2m.core.service.SclService;
 
public class Monitor {
	static SclService core;
	static String sclId = System.getProperty("org.eclipse.om2m.sclBaseId", "");
	static String reqEntity = System.getProperty("org.eclipse.om2m.adminRequestingEntity", "");
	static String ipuId = "sample";
	static String actuatorId = "MY_ACTUATOR";
	static String sensorId = "MY_SENSOR";
	static boolean actuatorValue = false;
	static int sensorValue = 0;
 
	public Monitor(SclService sclService) {
		core = sclService;
	}
 
	public void start() {
                // Create required resources for the Sensor
		createSensorResources();
                // Listen for the Sensor data
		listenToSensor();
 
                // Create required resources for the Actuator
		createActuatorResources();
                // Listen for the Actuator data
		listenToActuator();
	}
 
	public void createSensorResources() {
		String targetId, content;
 
                // Create the MY_SENSOR application
		targetId = sclId + "/applications";
		ResponseConfirm response = core
				.doRequest(new RequestIndication("CREATE", targetId, reqEntity,
						new Application(sensorId, ipuId)));
 
		if (response.getStatusCode().equals(StatusCode.STATUS_CREATED)) {
                        // Create the "DESCRIPTOR" container
			targetId = sclId + "/applications/" + sensorId + "/containers";
			core.doRequest(new RequestIndication("CREATE", targetId, reqEntity,
					new Container("DESCRIPTOR")));
 
                         // Create the "DATA" container
			core.doRequest(new RequestIndication("CREATE", targetId, reqEntity,
					new Container("DATA")));
 
                         // Create the description contentInstance
			content = Mapper.getSensorDescriptorRep(sclId, sensorId, ipuId);
			targetId = sclId + "/applications/" + sensorId
					+ "/containers/DESCRIPTOR/contentInstances";
			core.doRequest(new RequestIndication("CREATE", targetId, reqEntity,
					new ContentInstance(content.getBytes())));
 
                         // Create the data contentInstance
			content = Mapper.getSensorDataRep(sensorValue);
			targetId = sclId + "/applications/" + sensorId
					+ "/containers/DATA/contentInstances";
			core.doRequest(new RequestIndication("CREATE", targetId, reqEntity,
					new ContentInstance(content.getBytes())));
		}
	}
 
	public void createActuatorResources() {
		String targetId, content;
 
                // Create the "MY_ACTUATOR" application
		targetId = sclId + "/applications";
		ResponseConfirm response = core.doRequest(new RequestIndication(
				"CREATE", targetId, reqEntity, new Application(actuatorId,ipuId)));
 
		if (response.getStatusCode().equals(StatusCode.STATUS_CREATED)) {
                        // Create the "DESCRIPTOR" container
			targetId = sclId + "/applications/" + actuatorId + "/containers";
			core.doRequest(new RequestIndication("CREATE", targetId, reqEntity,
					new Container("DESCRIPTOR")));
 
                         // Create the "DATA" container
			core.doRequest(new RequestIndication("CREATE", targetId, reqEntity,
					new Container("DATA")));
 
                        // Create the description contentInstance
			content = Mapper.getActutaorDescriptorRep(sclId, actuatorId, ipuId);
			targetId = sclId + "/applications/" + actuatorId
					+ "/containers/DESCRIPTOR/contentInstances";
			core.doRequest(new RequestIndication("CREATE", targetId, reqEntity, 
					content));
 
                        // Create the data contentInstance
			content = Mapper.getActuatorDataRep(actuatorValue);
			targetId = sclId + "/applications/" + actuatorId
					+ "/containers/DATA/contentInstances";
			core.doRequest(new RequestIndication("CREATE", targetId, reqEntity,	
					content));
		}
	}
 
	public void listenToSensor() {
		new Thread() {
			public void run() {
				while (true) {
                                        // Simualte a random measurement of the sensor
					sensorValue = 10 + (int) (Math.random() * 100);
 
                                        // Create a data contentInstance
					String content = Mapper.getSensorDataRep(sensorValue);
					String targetID = sclId + "/applications/" + sensorId
							+ "/containers/DATA/contentInstances";
					core.doRequest(new RequestIndication("CREATE", targetID,reqEntity, 
							content));
 
                                        // Wait for 2 seconds then loop
					try {
						Thread.sleep(2000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}.start();
	}
 
	public void listenToActuator() {
		new Thread() {
			public void run() {
 
				boolean memorizedActuatorValue = false;
				while (true) {
                                        // If the Actuator state has changed
					if (memorizedActuatorValue != actuatorValue) {
                                                // Memorize the new Actuator state
						memorizedActuatorValue = actuatorValue;
 
                                                // Create a data contentInstance
						String content = Mapper.getActuatorDataRep(actuatorValue);
						String targetID = sclId + "/applications/" + actuatorId
								+ "/containers/DATA/contentInstances";
						core.doRequest(new RequestIndication("CREATE",targetID, reqEntity, 
								content));
					}
 
                                        // Wait for 2 seconds then loop
					try {
						Thread.sleep(2000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}.start();
	}
}

IPU Mapper

  • Convert the description and the measured data of the device to oBIX XML representation.
package org.eclipse.om2m.sample.ipu;
import org.eclipse.om2m.commons.obix.*;
import org.eclipse.om2m.commons.obix.io.ObixEncoder;
 
public class Mapper {
 
	public static String getSensorDescriptorRep(String sclId, String appId, String ipuId) {
		Obj obj = new Obj();
 
		Op opGet = new Op();
		opGet.setName("GET");
		opGet.setHref(new Uri(sclId + "/applications/" + appId
				+ "/containers/DATA/contentInstances/latest/content"));
		opGet.setIs(new Contract("retrieve"));
		obj.add(opGet);
 
		Op opGetDirect = new Op();
		opGetDirect.setName("GET(Direct)");
		opGetDirect.setHref(new Uri(sclId + "/applications/" + appId + "/" + ipuId));
		opGetDirect.setIs(new Contract("retrieve"));
		obj.add(opGetDirect);
 
		return ObixEncoder.toString(obj);
	}
 
	public static String getActutaorDescriptorRep(String sclId, String appId, String ipuId) {
		Obj obj = new Obj();
 
		Op opGet = new Op();
		opGet.setName("GET");
		opGet.setHref(new Uri(sclId + "/applications/" + appId
				+ "/containers/DATA/contentInstances/latest/content"));
		opGet.setIs(new Contract("retrieve"));
		obj.add(opGet);
 
		Op opGetDirect = new Op();
		opGetDirect.setName("GET(Direct)");
		opGetDirect.setHref(new Uri(sclId + "/applications/" + appId + "/" + ipuId));
		opGetDirect.setIs(new Contract("retrieve"));
		obj.add(opGetDirect);
 
		Op opON = new Op();
		opON.setName("ON");
		opON.setHref(new Uri(sclId + "/applications/" + appId + "/" + ipuId + "/true"));
		opON.setIs(new Contract("execute"));
		obj.add(opON);
 
		Op opOFF = new Op();
		opOFF.setName("OFF");
		opOFF.setHref(new Uri(sclId + "/applications/" + appId + "/" + ipuId + "/false"));
		opOFF.setIs(new Contract("execute"));
		obj.add(opOFF);
 
		return ObixEncoder.toString(obj);
	}
 
	public static String getActuatorDataRep(boolean value) {
		Obj obj = new Obj();
		obj.add(new Bool("data", value));
		return ObixEncoder.toString(obj);
	}
 
	public static String getSensorDataRep(int value) {
		Obj obj = new Obj();
		obj.add(new Int("data", value));
		return ObixEncoder.toString(obj);
	}
}

IPU Controller

  • Execute received requests from OM2M to the specific technologies.
package org.eclipse.om2m.sample.ipu;
 
import org.eclipse.om2m.commons.resource.StatusCode;
import org.eclipse.om2m.commons.rest.*;
import org.eclipse.om2m.ipu.service.IpuService;
 
public class Controller implements IpuService {
 
	public ResponseConfirm doExecute(RequestIndication requestIndication) {
		String[] parts = requestIndication.getTargetID().split("/");
		String appId = parts[2];
		String value = parts[4];
 
		if (appId.equals(Monitor.actuatorId)) {
			Monitor.actuatorValue = Boolean.parseBoolean(value);
			return new ResponseConfirm(StatusCode.STATUS_OK);
		} else {
			return new ResponseConfirm(StatusCode.STATUS_NOT_FOUND, appId + " not found");
		}
	}
 
	public ResponseConfirm doRetrieve(RequestIndication requestIndication) {
		String[] parts = requestIndication.getTargetID().split("/");
		String appId = parts[2];
		String content;
 
		if (appId.equals(Monitor.sensorId)) {
			content = Mapper.getSensorDataRep(Monitor.sensorValue);
			return new ResponseConfirm(StatusCode.STATUS_OK, content);
		} else if (appId.equals(Monitor.actuatorId)) {
			content = Mapper.getActuatorDataRep(Monitor.actuatorValue);
			return new ResponseConfirm(StatusCode.STATUS_OK, content);
		} else {
			return new ResponseConfirm(StatusCode.STATUS_NOT_FOUND, appId + " not found");
		}
 
	}
 
	public ResponseConfirm doUpdate(RequestIndication requestIndication) {
		return new ResponseConfirm(StatusCode.STATUS_NOT_IMPLEMENTED,
				requestIndication.getMethod() + " not Implemented");
	}
 
	public ResponseConfirm doDelete(RequestIndication requestIndication) {
		return new ResponseConfirm(StatusCode.STATUS_NOT_IMPLEMENTED,
				requestIndication.getMethod() + " not Implemented");
	}
 
	public ResponseConfirm doCreate(RequestIndication requestIndication) {
		return new ResponseConfirm(StatusCode.STATUS_NOT_IMPLEMENTED,
				requestIndication.getMethod() + " not Implemented");
	}
 
	public String getAPOCPath(){
		return Monitor.ipuId;
	}
}

Back to the top