From 1de0d38ccb9bc6c3cdf69c08be7b603caf216671 Mon Sep 17 00:00:00 2001 From: fros4943 Date: Tue, 28 Oct 2008 12:40:35 +0000 Subject: [PATCH] interface handler support for new interface polling format --- .../se/sics/cooja/MoteInterfaceHandler.java | 331 ++++++++---------- 1 file changed, 150 insertions(+), 181 deletions(-) diff --git a/tools/cooja/java/se/sics/cooja/MoteInterfaceHandler.java b/tools/cooja/java/se/sics/cooja/MoteInterfaceHandler.java index 868637a4b..f9a95422b 100644 --- a/tools/cooja/java/se/sics/cooja/MoteInterfaceHandler.java +++ b/tools/cooja/java/se/sics/cooja/MoteInterfaceHandler.java @@ -1,155 +1,119 @@ /* - * Copyright (c) 2006, Swedish Institute of Computer Science. All rights - * reserved. - * + * Copyright (c) 2008, Swedish Institute of Computer Science. + * All rights reserved. + * * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are met: - * 1. Redistributions of source code must retain the above copyright notice, - * this list of conditions and the following disclaimer. 2. Redistributions in - * binary form must reproduce the above copyright notice, this list of - * conditions and the following disclaimer in the documentation and/or other - * materials provided with the distribution. 3. Neither the name of the - * Institute nor the names of its contributors may be used to endorse or promote - * products derived from this software without specific prior written - * permission. - * - * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - * DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND - * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - * $Id: MoteInterfaceHandler.java,v 1.3 2008/09/22 16:18:22 joxe Exp $ + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the Institute nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: MoteInterfaceHandler.java,v 1.4 2008/10/28 12:40:35 fros4943 Exp $ */ package se.sics.cooja; import java.util.*; import org.apache.log4j.Logger; - import se.sics.cooja.interfaces.*; /** - * A mote interface handler holds all interfaces for a specific mote. Even - * though an interface handler strictly does not need any interfaces at all, a - * position interface is highly recommended. (A lot of plugins depend on a mote - * position, for example a typical visualizer.) - * - * Interfaces are divided into active and passive interfaces. Active interfaces - * are only polled if the mote is active, while passive interfaces are polled in - * all states except dead state. - * + * The mote interface handler holds all interfaces for a specific mote. * Interfaces should be polled via this class when the mote is ticked. - * - * @author Fredrik Osterlind + * + * @see #doActiveActionsAfterTick() + * @see #doActiveActionsBeforeTick() + * @see #doPassiveActionsAfterTick() + * @see #doPassiveActionsBeforeTick() + * + * @author Fredrik Österlind */ public class MoteInterfaceHandler { private static Logger logger = Logger.getLogger(MoteInterfaceHandler.class); + private Vector allInterfaces = new Vector(); + + /* Cached interfaces */ private Battery myBattery; - private Beeper myBeeper; - private Button myButton; - private Clock myClock; - private IPAddress myIPAddress; - private LED myLED; - private Log myLog; - private MoteID myMoteID; - private PIR myPIR; - private Position myPosition; - private Radio myRadio; - - private Vector myActiveInterfaces = new Vector(); - private MoteInterface[] activeCache = null; - - private Vector myPassiveInterfaces = new Vector(); + private PolledBeforeActiveTicks[] polledBeforeActive = null; + private PolledAfterActiveTicks[] polledAfterActive = null; + private PolledBeforeAllTicks[] polledBeforeAll = null; + private PolledAfterAllTicks[] polledAfterAll = null; /** - * Creates a new empty mote interface handler. + * Creates new empty mote interface handler. */ public MoteInterfaceHandler() { } /** - * Creates a new mote interface handler. All given interfaces are loaded. - * - * @param mote - * The mote holding this interface handler - * @param allInterfaces - * Simulation interfaces to load + * Creates new mote interface handler. All given interfaces are created. + * + * @param mote Mote + * @param interfaceClasses Mote interface classes */ - public MoteInterfaceHandler(Mote mote, - Vector> allInterfaces) { + public MoteInterfaceHandler(Mote mote, Vector> interfaceClasses) { + for (Class interfaceClass : interfaceClasses) { + MoteInterface intf = MoteInterface.generateInterface(interfaceClass, mote); - // Load all interfaces - for (Class interfaceClass : allInterfaces) { - boolean isPassive = false; - - // Check if interface is active or passive - if (PassiveMoteInterface.class.isAssignableFrom(interfaceClass)) - isPassive = true; - - // Load interface - MoteInterface loadedInterface = MoteInterface.generateInterface( - interfaceClass, mote); - - if (loadedInterface != null) - if (isPassive) - addPassiveInterface(loadedInterface); - else - addActiveInterface(loadedInterface); - else - logger.warn("Interface could not be loaded: " + interfaceClass); + if (intf != null) { + addInterface(intf); + } else { + logger.fatal("Could not load interface: " + interfaceClass); + } } } /** - * Get an interface (active or passive) of the given type. Returns the first - * loaded interface found, that is either of the given class or of a subclass. - * - * For example, if the current radio interface is wanted, this method would be - * called like the following: getInterfaceOfType(Radio.class) - * - * @param interfaceType - * Type of interface to return - * @return Interface or null if no interface loaded of given type + * Returns interface of given type. Returns the first interface found that + * is either of the given class or of a subclass. + * + * Usage: getInterfaceOfType(Radio.class) + * + * @param interfaceType Class of interface to return + * @return Mote interface, or null if no interface exists of given type */ public N getInterfaceOfType(Class interfaceType) { + for (MoteInterface intf : allInterfaces) { + if (interfaceType.isAssignableFrom(intf.getClass())) { + return (N) intf; + } + } - Enumeration allActive = myActiveInterfaces - .elements(); - while (allActive.hasMoreElements()) { - N nextInterface = (N) allActive.nextElement(); - if (interfaceType.isAssignableFrom(nextInterface.getClass())) - return nextInterface; - } - Enumeration allPassive = myPassiveInterfaces - .elements(); - while (allPassive.hasMoreElements()) { - N nextInterface = (N) allPassive.nextElement(); - if (interfaceType.isAssignableFrom(nextInterface.getClass())) - return nextInterface; - } return null; } /** * Returns the battery interface (if any). - * + * * @return Battery interface */ public Battery getBattery() { @@ -161,7 +125,7 @@ public class MoteInterfaceHandler { /** * Returns the beeper interface (if any). - * + * * @return Beeper interface */ public Beeper getBeeper() { @@ -173,7 +137,7 @@ public class MoteInterfaceHandler { /** * Returns the button interface (if any). - * + * * @return Button interface */ public Button getButton() { @@ -185,7 +149,7 @@ public class MoteInterfaceHandler { /** * Returns the clock interface (if any). - * + * * @return Clock interface */ public Clock getClock() { @@ -197,8 +161,8 @@ public class MoteInterfaceHandler { /** * Returns the IP address interface (if any). - * - * @return IPAddress interface + * + * @return IP Address interface */ public IPAddress getIPAddress() { if (myIPAddress == null) { @@ -209,7 +173,7 @@ public class MoteInterfaceHandler { /** * Returns the LED interface (if any). - * + * * @return LED interface */ public LED getLED() { @@ -221,7 +185,7 @@ public class MoteInterfaceHandler { /** * Returns the log interface (if any). - * + * * @return Log interface */ public Log getLog() { @@ -233,7 +197,7 @@ public class MoteInterfaceHandler { /** * Returns the mote ID interface (if any). - * + * * @return Mote ID interface */ public MoteID getMoteID() { @@ -245,7 +209,7 @@ public class MoteInterfaceHandler { /** * Returns the PIR interface (if any). - * + * * @return PIR interface */ public PIR getPIR() { @@ -257,7 +221,7 @@ public class MoteInterfaceHandler { /** * Returns the position interface (if any). - * + * * @return Position interface */ public Position getPosition() { @@ -269,7 +233,7 @@ public class MoteInterfaceHandler { /** * Returns the radio interface (if any). - * + * * @return Radio interface */ public Radio getRadio() { @@ -280,99 +244,104 @@ public class MoteInterfaceHandler { } /** - * Polls all active interfaces. This method should be called during a mote - * tick before the mote software is executed. + * Polls active interfaces before mote tick. */ public void doActiveActionsBeforeTick() { - // Assuming only one caller!!! - if (activeCache == null) { - activeCache = (MoteInterface[]) myActiveInterfaces.toArray(new MoteInterface[myActiveInterfaces.size()]); - } -// for (int i = 0; i < myActiveInterfaces.size(); i++) -// myActiveInterfaces.get(i).doActionsBeforeTick(); - for (int i = 0, n = activeCache.length; i < n; i++) { - activeCache[i].doActionsBeforeTick(); + if (polledBeforeActive == null) { + ArrayList intfs = new ArrayList(); + for (MoteInterface intf: allInterfaces) { + if (intf instanceof PolledBeforeActiveTicks) { + intfs.add((PolledBeforeActiveTicks)intf); + } + } + polledBeforeActive = intfs.toArray(new PolledBeforeActiveTicks[intfs.size()]); + } + + for (PolledBeforeActiveTicks element : polledBeforeActive) { + element.doActionsBeforeTick(); } } /** - * Polls all active interfaces. This method should be called during a mote - * tick after the mote software has executed. + * Polls active interfaces after mote tick. */ public void doActiveActionsAfterTick() { - for (int i = 0; i < myActiveInterfaces.size(); i++) - myActiveInterfaces.get(i).doActionsAfterTick(); + if (polledAfterActive == null) { + ArrayList intfs = new ArrayList(); + for (MoteInterface intf: allInterfaces) { + if (intf instanceof PolledAfterActiveTicks) { + intfs.add((PolledAfterActiveTicks)intf); + } + } + polledAfterActive = intfs.toArray(new PolledAfterActiveTicks[intfs.size()]); + } + + for (PolledAfterActiveTicks element : polledAfterActive) { + element.doActionsAfterTick(); + } } /** - * Polls all passive interfaces. This method should be called during a mote - * tick before the mote software is executed. + * Polls passive interfaces before mote tick. */ public void doPassiveActionsBeforeTick() { - for (int i = 0; i < myPassiveInterfaces.size(); i++) - myPassiveInterfaces.get(i).doActionsBeforeTick(); + if (polledBeforeAll == null) { + ArrayList intfs = new ArrayList(); + for (MoteInterface intf: allInterfaces) { + if (intf instanceof PolledBeforeAllTicks) { + intfs.add((PolledBeforeAllTicks)intf); + } + } + polledBeforeAll = intfs.toArray(new PolledBeforeAllTicks[intfs.size()]); + } + + for (PolledBeforeAllTicks element : polledBeforeAll) { + element.doActionsBeforeTick(); + } } /** - * Polls all passive interfaces. This method should be called during a mote - * tick after the mote software has executed. + * Polls passive interfaces after mote tick. */ public void doPassiveActionsAfterTick() { - for (int i = 0; i < myPassiveInterfaces.size(); i++) - myPassiveInterfaces.get(i).doActionsAfterTick(); + if (polledAfterAll == null) { + ArrayList intfs = new ArrayList(); + for (MoteInterface intf: allInterfaces) { + if (intf instanceof PolledAfterAllTicks) { + intfs.add((PolledAfterAllTicks)intf); + } + } + polledAfterAll = intfs.toArray(new PolledAfterAllTicks[intfs.size()]); + } + + for (PolledAfterAllTicks element : polledAfterAll) { + element.doActionsAfterTick(); + } } /** - * Returns all passive mote interfaces. - * - * @return All passive mote interface + * @return Mote interfaces */ - public Vector getAllPassiveInterfaces() { - return myPassiveInterfaces; + public Vector getInterfaces() { + return allInterfaces; } /** - * Returns all active mote interfaces. - * - * @return All active mote interface + * Add mote interface. + * + * @param intf Mote interface + * @see PolledBeforeActiveTicks + * @see PolledBeforeAllTicks + * @see PolledAfterActiveTicks + * @see PolledAfterAllTicks */ - public Vector getAllActiveInterfaces() { - return myActiveInterfaces; - } + public void addInterface(MoteInterface intf) { + allInterfaces.add(intf); - /** - * Add an active interface to corresponding mote. An active interface is only - * allowed to act if the mote is in active state. However, since interfaces - * may awaken a sleeping mote up via external interrupts, most of the - * interfaces should be active. - * - * For example a button interface should be active. When the button is - * pressed, the interface will wake the mote up (simulated external - * interrupt), and then that button will be allowed to act before next tick. - * - * A passive interface is an interface which will always act if the mote is - * not dead. For example a battery should always be allowed to act since a - * mote needs energy even if it is in sleep mode. - * - * @see #addPassiveInterface(MoteInterface) - * @param newInterface - * New interface - */ - public void addActiveInterface(MoteInterface newInterface) { - myActiveInterfaces.add(newInterface); - activeCache = null; - } - - /** - * Add a passive interface to corresponding mote. For explanation of passive - * vs active interfaces, see addActiveInterface(MoteInterface). - * - * @see #addActiveInterface(MoteInterface) - * @param newInterface - * New interface - */ - public void addPassiveInterface(MoteInterface newInterface) { - myPassiveInterfaces.add(newInterface); + polledBeforeActive = null; + polledAfterActive = null; + polledBeforeAll = null; + polledAfterAll = null; } }