Example #1
0
  public SPINETest() {

    try {
      // Initialize SPINE by passing the fileName with the configuration properties
      manager = SPINEFactory.createSPINEManager("resources/SPINETestApp.properties");

      // ... then we need to register a SPINEListener implementation to the SPINE manager instance
      // (I register myself since I'm a SPINEListener implementation!)
      manager.addListener(this);

      // we could change the logging level to avoid e.g. prints for the ongoing and incoming low
      // level messages.
      SPINEManager.getLogger().setLevel(Level.ALL);

      // We could even decide to change the default discoveryProcedureTimeout; after that: ok ...
      /* manager.setDiscoveryProcedureTimeout(1000); */

      // ... let's start playing!
      manager.discoveryWsn();

    } catch (InstantiationException e) {
      // if we are here, then the SPINEManager initialization did not work properly
      e.printStackTrace();
    }
  }
Example #2
0
  public void discoveryCompleted(Vector activeNodes) {

    // we loop over the discovered nodes (hopefully, at least a node's showed up!)
    Node curr = null;
    for (int j = 0; j < activeNodes.size(); j++) {

      curr = (Node) activeNodes.elementAt(j);

      // we print for each node its details (nodeID, sensors and functions provided)
      System.out.println(curr);

      // for each node, we look for specific services
      for (int i = 0; i < curr.getSensorsList().size(); i++) {

        byte sensor = ((Sensor) curr.getSensorsList().elementAt(i)).getCode();

        // if the current node has an accelerometer, then...
        if (sensor == SPINESensorConstants.ACC_SENSOR) {

          // ... we first setup that sensor, specifying its sampling time and time scale; then ...
          SpineSetupSensor sss = new SpineSetupSensor();
          sss.setSensor(sensor);
          sss.setTimeScale(SPINESensorConstants.MILLISEC);
          sss.setSamplingTime(SAMPLING_TIME);
          manager.setup(curr, sss);

          // ... we can setup a specific function (in this case a Feature) on that sensor; then ...
          FeatureSpineSetupFunction ssf = new FeatureSpineSetupFunction();
          ssf.setSensor(sensor);
          ssf.setWindowSize(WINDOW_SIZE);
          ssf.setShiftSize(SHIFT_SIZE);
          manager.setup(curr, ssf);

          // ... we can activate that function with function specific parameters
          // (for Feature they are the desired feature extractors); we can also ...
          FeatureSpineFunctionReq sfr = new FeatureSpineFunctionReq();
          sfr.setSensor(sensor);
          sfr.add(
              new Feature(
                  SPINEFunctionConstants.MODE,
                  ((Sensor) curr.getSensorsList().elementAt(i)).getChannelBitmask()));
          sfr.add(
              new Feature(
                  SPINEFunctionConstants.MEDIAN,
                  ((Sensor) curr.getSensorsList().elementAt(i)).getChannelBitmask()));
          sfr.add(
              new Feature(
                  SPINEFunctionConstants.MAX,
                  ((Sensor) curr.getSensorsList().elementAt(i)).getChannelBitmask()));
          sfr.add(
              new Feature(
                  SPINEFunctionConstants.MIN,
                  ((Sensor) curr.getSensorsList().elementAt(i)).getChannelBitmask()));
          manager.activate(curr, sfr);

          // ... split a more complex activation in multiple activations
          // (if the specific function implementation in the node side allows that); of course we
          // always can ...
          sfr = new FeatureSpineFunctionReq();
          sfr.setSensor(sensor);
          sfr.add(
              new Feature(
                  SPINEFunctionConstants.MEAN,
                  ((Sensor) curr.getSensorsList().elementAt(i)).getChannelBitmask()));
          sfr.add(
              new Feature(
                  SPINEFunctionConstants.AMPLITUDE,
                  ((Sensor) curr.getSensorsList().elementAt(i)).getChannelBitmask()));
          manager.activate(curr, sfr);

          // SetUp Alarm Engine
          // Window and Shift may be set to value different from the feature engine ones.
          // here we use the same values for debigging proposes
          AlarmSpineSetupFunction ssf2 = new AlarmSpineSetupFunction();
          ssf2.setSensor(sensor);
          ssf2.setWindowSize(WINDOW_SIZE);
          ssf2.setShiftSize(SHIFT_SIZE);
          manager.setup(curr, ssf2);

          // Activate alarm on MAX value (one of the features computed above) on CH1
          // alarm sent when MAX > upperThresold
          AlarmSpineFunctionReq sfr2 = new AlarmSpineFunctionReq();

          int lowerThreshold = 20;
          int upperThreshold = 40;

          sfr2.setDataType(SPINEFunctionConstants.MAX);
          sfr2.setSensor(SPINESensorConstants.ACC_SENSOR);
          sfr2.setValueType((SPINESensorConstants.CH1_ONLY));
          sfr2.setLowerThreshold(lowerThreshold);
          sfr2.setUpperThreshold(upperThreshold);
          sfr2.setAlarmType(SPINEFunctionConstants.ABOVE_THRESHOLD);

          manager.activate(curr, sfr2);

          // Activate alarm on AMPLITUDE value (one of the features computed above) on CH2
          // alarm sent when AMPLITUDE < lowerThreshold

          lowerThreshold = 2000;
          upperThreshold = 1000;

          sfr2.setDataType(SPINEFunctionConstants.AMPLITUDE);
          sfr2.setSensor(SPINESensorConstants.ACC_SENSOR);
          sfr2.setValueType((SPINESensorConstants.CH2_ONLY));
          sfr2.setLowerThreshold(lowerThreshold);
          sfr2.setUpperThreshold(upperThreshold);
          sfr2.setAlarmType(SPINEFunctionConstants.BELOW_THRESHOLD);

          manager.activate(curr, sfr2);

        }
        // repeat this process for other desired sensors; after that we can finally ...
        else if (sensor == SPINESensorConstants.INTERNAL_TEMPERATURE_SENSOR) {
          SpineSetupSensor sss = new SpineSetupSensor();
          sss.setSensor(sensor);
          sss.setTimeScale(SPINESensorConstants.MILLISEC);
          sss.setSamplingTime(OTHER_SAMPLING_TIME);
          manager.setup(curr, sss);

          FeatureSpineSetupFunction ssf = new FeatureSpineSetupFunction();
          ssf.setSensor(sensor);
          ssf.setWindowSize(OTHER_WINDOW_SIZE);
          ssf.setShiftSize(OTHER_SHIFT_SIZE);
          manager.setup(curr, ssf);

          FeatureSpineFunctionReq sfr = new FeatureSpineFunctionReq();
          sfr.setSensor(sensor);
          sfr.add(
              new Feature(
                  SPINEFunctionConstants.MODE,
                  ((Sensor) curr.getSensorsList().elementAt(i)).getChannelBitmask()));
          sfr.add(
              new Feature(
                  SPINEFunctionConstants.MEDIAN,
                  ((Sensor) curr.getSensorsList().elementAt(i)).getChannelBitmask()));
          sfr.add(
              new Feature(
                  SPINEFunctionConstants.MAX,
                  ((Sensor) curr.getSensorsList().elementAt(i)).getChannelBitmask()));
          sfr.add(
              new Feature(
                  SPINEFunctionConstants.MIN,
                  ((Sensor) curr.getSensorsList().elementAt(i)).getChannelBitmask()));
          manager.activate(curr, sfr);

          // SetUp Alarm Engine
          // Same Window and Shift as before
          AlarmSpineSetupFunction ssf3 = new AlarmSpineSetupFunction();
          ssf3.setSensor(sensor);
          ssf3.setWindowSize(WINDOW_SIZE);
          ssf3.setShiftSize(SHIFT_SIZE);
          manager.setup(curr, ssf3);

          // Activate alarm on MIN value (one of the features computed above)on CH1
          // alarm sent when lowerThreshold < MIN < upperThreshold
          AlarmSpineFunctionReq sfr3 = new AlarmSpineFunctionReq();

          int lowerThreshold = 1000;
          int upperThreshold = 3000;

          sfr3.setDataType(SPINEFunctionConstants.MIN);
          sfr3.setSensor(sensor);
          sfr3.setValueType((SPINESensorConstants.CH1_ONLY));
          sfr3.setLowerThreshold(lowerThreshold);
          sfr3.setUpperThreshold(upperThreshold);
          sfr3.setAlarmType(SPINEFunctionConstants.IN_BETWEEN_THRESHOLDS);

          manager.activate(curr, sfr3);
        }
      }
    }

    // ... start the sensor network sensing and computing our aforeactivated services.
    if (activeNodes.size() > 0)
      manager.startWsn(
          true,
          true); // we can tune a few node parameters at run-time for reducing the power consumption
                 // and the packets drop.
  }
Example #3
0
  public void received(Data data) {
    // the specific application logic behaves w.r.t. the type of data received

    System.out.println(data);

    switch (data.getFunctionCode()) {
      case SPINEFunctionConstants.FEATURE:
        {
          features = ((FeatureData) data).getFeatures();

          counter++;

          // even this simple application shows us up some nice SPINE properties; in fact ...
          if (counter == 5) {
            // it's possible to deactivate functions computation at runtime (even when the radio on
            // the node works in low-power mode)
            FeatureSpineFunctionReq sfr = new FeatureSpineFunctionReq();
            sfr.setSensor(features[0].getSensorCode());
            sfr.remove(new Feature(features[0].getFeatureCode(), SPINESensorConstants.ALL));
            manager.deactivate(data.getNode(), sfr);
          }

          if (counter == 10) {
            // and, of course, we can activate new functions at runtime
            FeatureSpineFunctionReq sfr = new FeatureSpineFunctionReq();
            sfr.setSensor(features[0].getSensorCode());
            sfr.add(new Feature(SPINEFunctionConstants.RANGE, SPINESensorConstants.CH1_ONLY));
            manager.activate(data.getNode(), sfr);
          }

          if (counter == 20) {
            // when we are set, we can decide to ...

            // stop the WSN, forcing a 'software' reset of the nodes
            /* manager.resetWsn(); */

            // or just deregister ourself to further SPINE events.
            // manager.deregisterListener(this);
          }

          break;
        }
      case SPINEFunctionConstants.ONE_SHOT:
        // OneShotData oneShot = (OneShotData)data; // if needed 'data' can be casted to
        // spine.datamodel.OneShotData
        break;

      case SPINEFunctionConstants.ALARM:
        // AlarmData alarm = (AlarmData)data; // if needed 'data' can be casted to
        // spine.datamodel.AlarmData
        counter_alarm++;
        if (counter_alarm == 20) {
          AlarmSpineFunctionReq sfr2 = new AlarmSpineFunctionReq();
          sfr2.setSensor(SPINESensorConstants.ACC_SENSOR);
          sfr2.setAlarmType(SPINEFunctionConstants.ABOVE_THRESHOLD);
          sfr2.setDataType(SPINEFunctionConstants.MAX);
          sfr2.setValueType((SPINESensorConstants.CH1_ONLY));

          manager.deactivate(data.getNode(), sfr2);
        }
        break;
    }
  }