SSN Model


System module

This section describes how to create a System object and uses a simple example to show how to model a system composed of sensors in the SSN ontology. More complex examples where the system class is used in the context of a deployment or when operating restrictions are added to the system definition are provided in the Deploy module documentation.

The ssn:System class for parts of a sensing infrastructure. A system has components, its subsystems, which are other systems. The ssn:hasSubSystem property is used to relate a system to its sub-systems.

A concept map showing the hasSubSystem reflexive relationship of the System class

Figure 5.11 - the ssn:System class and the ssn:hasSubSystem property

How to represent a system composed of sensors

System examples (OWL)

In this example, the system is a sensor network node (a "mote") which includes a Temperature sensor and a Humidity sensor (this is allowed because SensingDevice is a sub-class of System).

 <owl:Ontology rdf:about="">
 <!-- System (TelosB Mote) -->
 <ssn:System rdf:about="">
  <rdfs:comment rdf:datatype="">A sample sensor network node. The data is for
  TELOS-B product and the data sheet is available at: </rdfs:comment>
   <ssn:SensingDevice rdf:about="">
    <rdfs:comment rdf:datatype="">The embedded temperature sensor.</rdfs:comment>
   <ssn:SensingDevice rdf:about="">
    <rdfs:comment rdf:datatype="">The embedded humidity sensor.</rdfs:comment>


Process module

The ssn:Process class in the SSN ontology is defined as the specification of the procedure implemented in a sensor. It may be specified as a known principle or method or, if a computer science approach is followed, as a function which has an output and possibly some inputs.

A concept map showing Process is defined by its Input and Output and is referenced by Sensing and eventually by Sensor

Figure 5.12 - ssn:Process

How to represent a characteristic transfer function implemented by a sensor

Process example - transfer function (OWL)

In this example, the process is used to define the characteristic transfer function of a Wind Sensor.

This sensor implements a known formula for relating the spinning of the cups to windspeed and has different accuracies in different conditions

  <owl:Ontology rdf:about="">
  <!-- Sensor --> 
  <owl:Class rdf:about="">
  <rdfs:subClassOf rdf:resource=""/>
      <owl:onProperty rdf:resource=""/>
        <owl:oneOf rdf:parseType="Collection">
         <rdf:Description rdf:about=""/>

The WM30's characteristic transfer function is the formula used by the device to relate the turning of the cups to windspeed: i.e. it is really the method of measurement used. That is why it is specified here as a sensing method. The actual transducer in the device outputs frequency measured in Hertz and the WM30 converts this to WindSpeed via the function. Thus another modelling option would be to model the whole chain (subdivide the WM30 into further components and show how the output of the transducer is the input of the characteristic transfer function, etc.) indicating more closely how the device actually makes the measurement.

There are any number of ways to specify the characteristic transfer function. DUL's information objects and realisations could be used to provide some other concrete description. In an application that needs to read in the function, perhaps if the specification is of an abstract sensor that needs to be realised at runtime, then some systematic standard or format should be used. Technically, anything could be attached: formatted text, a reference to a scientific paper describing the measurement process, MathML, an algorithm specification in a formal language, program code or an executable. Here the description is just attached as text.

  <owl:Class rdf:about="">
        <owl:oneOf rdf:parseType="Collection">
          <rdf:Description rdf:about=""/>
    <rdfs:subClassOf rdf:resource=""/>

  <owl:NamedIndividual rdf:about="">
    <rdf:type rdf:resource=""/>
    <sensingDescription rdf:datatype="&xsd;string">Characteristic transfer function 
      U = -0.24 + 0.699 × F 
     (where U = wind speed [m/s], F = output frequency [Hz]) 

How to represent a process implemented by a sensor (for programming use case)

Process example - programming (OWL)

In this example, the Process instance is used to specify the output of a Ultrasonic Wind Sensor which is part of an Automatic Weather Station and specifies which physical quantity and which unit of measurement should be used. This specification can be used to create the program which retrieves this information from the sensor if other information on the command to be issued to the sensor is also provided (e.g. the variable code in this example).

  <owl:Ontology rdf:about="">
  <aws:UltrasonicWindSensor rdf:about="">
      <ssn:System rdf:about=""/>
      <ssn:Process rdf:about="">
          <ssn:Output rdf:about="">
              <dim:VelocityOrSpeedUnit rdf:about=""/>
            <phenonet:variable_name>Speed Ave</phenonet:variable_name>
            <phenonet:sensor_name>WXT520 Windcap</phenonet:sensor_name>
          <dim:VelocityOrSpeed rdf:about=""/>
Last modified on 15 June 2011, at 09:11