From bb1bd3a70613676f9a2e474b244d578507443361 Mon Sep 17 00:00:00 2001 From: joxe Date: Tue, 24 Feb 2009 07:49:42 +0000 Subject: [PATCH] added radio communication between micaz nodes --- .../src/se/sics/cooja/avrmote/MicaZMote.java | 16 +- .../cooja/avrmote/interfaces/MicaClock.java | 92 +++++ .../cooja/avrmote/interfaces/MicaZRadio.java | 374 ++++++++++++++++++ .../cooja/avrmote/interfaces/RadioByte.java | 51 +++ 4 files changed, 530 insertions(+), 3 deletions(-) create mode 100644 tools/cooja/apps/avrora/src/se/sics/cooja/avrmote/interfaces/MicaClock.java create mode 100644 tools/cooja/apps/avrora/src/se/sics/cooja/avrmote/interfaces/MicaZRadio.java create mode 100644 tools/cooja/apps/avrora/src/se/sics/cooja/avrmote/interfaces/RadioByte.java diff --git a/tools/cooja/apps/avrora/src/se/sics/cooja/avrmote/MicaZMote.java b/tools/cooja/apps/avrora/src/se/sics/cooja/avrmote/MicaZMote.java index 57d4bb593..cbc8552de 100755 --- a/tools/cooja/apps/avrora/src/se/sics/cooja/avrmote/MicaZMote.java +++ b/tools/cooja/apps/avrora/src/se/sics/cooja/avrmote/MicaZMote.java @@ -26,7 +26,7 @@ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * - * $Id: MicaZMote.java,v 1.1 2009/02/22 16:45:01 joxe Exp $ + * $Id: MicaZMote.java,v 1.2 2009/02/24 07:49:42 joxe Exp $ */ package se.sics.cooja.avrmote; @@ -48,7 +48,9 @@ import se.sics.cooja.MoteInterfaceHandler; import se.sics.cooja.MoteMemory; import se.sics.cooja.MoteType; import se.sics.cooja.Simulation; +import se.sics.cooja.avrmote.interfaces.MicaClock; import se.sics.cooja.avrmote.interfaces.MicaZLED; +import se.sics.cooja.avrmote.interfaces.MicaZRadio; import se.sics.cooja.interfaces.Position; import avrora.sim.*; import avrora.sim.platform.*; @@ -92,6 +94,10 @@ public class MicaZMote implements Mote { stopNextInstruction = true; } + public MicaZ getMicaZ() { + return micaZ; + } + public MicaZMote() { mySimulation = null; myCpu = null; @@ -271,8 +277,12 @@ public class MicaZMote implements Mote { moteInterfaceHandler.addInterface(motePosition); // Add LED interface - MicaZLED moteLED = new MicaZLED(micaZ); - moteInterfaceHandler.addInterface(moteLED); + moteInterfaceHandler.addInterface(new MicaZLED(micaZ)); + // Add Radio interface + moteInterfaceHandler.addInterface(new MicaZRadio(this)); + // Add Radio interface + moteInterfaceHandler.addInterface(new MicaClock(this)); + return moteInterfaceHandler; } diff --git a/tools/cooja/apps/avrora/src/se/sics/cooja/avrmote/interfaces/MicaClock.java b/tools/cooja/apps/avrora/src/se/sics/cooja/avrmote/interfaces/MicaClock.java new file mode 100644 index 000000000..f820274db --- /dev/null +++ b/tools/cooja/apps/avrora/src/se/sics/cooja/avrmote/interfaces/MicaClock.java @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2009, 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: MicaClock.java,v 1.1 2009/02/24 07:49:42 joxe Exp $ + */ + +package se.sics.cooja.avrmote.interfaces; + +import java.util.Collection; +import javax.swing.JPanel; +import org.apache.log4j.Logger; +import org.jdom.Element; + +import se.sics.cooja.*; +import se.sics.cooja.avrmote.MicaZMote; +import se.sics.cooja.interfaces.Clock; + + +/** + * @author Fredrik Österlind, Joakim Eriksson + */ +@ClassDescription("Cycle clock") +public class MicaClock extends Clock { + private static Logger logger = Logger.getLogger(MicaClock.class); + + private MicaZMote myMote; + + public MicaClock(MicaZMote mote) { + myMote = mote; + } + + public void setTime(long newTime) { + logger.fatal("Can't change emulated CPU time"); + } + + public long getTime() { + int time = (int) ((myMote.cycleCounter) / MicaZMote.NR_CYCLES_PER_MSEC); + return time > 0 ? time : 0; + } + + public void setDrift(int drift) { + myMote.cycleDrift = MicaZMote.NR_CYCLES_PER_MSEC * drift; + } + + public int getDrift() { + return (int) (myMote.cycleDrift / MicaZMote.NR_CYCLES_PER_MSEC); + } + + public JPanel getInterfaceVisualizer() { + return null; + } + + public void releaseInterfaceVisualizer(JPanel panel) { + } + + public double energyConsumption() { + return 0; + } + + public Collection getConfigXML() { + return null; + } + + public void setConfigXML(Collection configXML, boolean visAvailable) { + } + +} diff --git a/tools/cooja/apps/avrora/src/se/sics/cooja/avrmote/interfaces/MicaZRadio.java b/tools/cooja/apps/avrora/src/se/sics/cooja/avrmote/interfaces/MicaZRadio.java new file mode 100644 index 000000000..c2513e589 --- /dev/null +++ b/tools/cooja/apps/avrora/src/se/sics/cooja/avrmote/interfaces/MicaZRadio.java @@ -0,0 +1,374 @@ +/* + * Copyright (c) 2009, 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: MicaZRadio.java,v 1.1 2009/02/24 07:49:42 joxe Exp $ + */ + +package se.sics.cooja.avrmote.interfaces; + +import java.awt.BorderLayout; +import java.awt.GridLayout; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.util.*; +import javax.swing.*; +import org.apache.log4j.Logger; +import org.jdom.Element; + +import avrora.sim.platform.MicaZ; +import avrora.sim.radio.CC2420Radio; +import avrora.sim.radio.Medium; + +import se.sics.cooja.*; +import se.sics.cooja.avrmote.MicaZMote; +import se.sics.cooja.interfaces.CustomDataRadio; +import se.sics.cooja.interfaces.Position; +import se.sics.cooja.interfaces.Radio; + +/** + * CC2420 to COOJA wrapper. + * + * @author Joakim Eriksson + */ +@ClassDescription("CC2420") +public class MicaZRadio extends Radio implements CustomDataRadio { + private static Logger logger = Logger.getLogger(MicaZRadio.class); + + private long lastEventTime = 0; + + private RadioEvent lastEvent = RadioEvent.UNKNOWN; + + private MicaZMote mote; + private MicaZ micaz; + private CC2420Radio cc2420; + + private boolean isInterfered = false; + + private boolean isTransmitting = false; + + private boolean isReceiving = false; +// private boolean hasFailedReception = false; + + private boolean radioOn = true; + + private RadioByte lastOutgoingByte = null; + + private RadioByte lastIncomingByte = null; + + private RadioPacket lastOutgoingPacket = null; + + private RadioPacket lastIncomingPacket = null; + +// private int mode; + Medium.Transmitter trans; + CC2420Radio.Receiver recv; + + public MicaZRadio(MicaZMote mote) { + this.mote = mote; + micaz = mote.getMicaZ(); + cc2420 = (CC2420Radio) micaz.getDevice("radio"); + trans = cc2420.getTransmitter(); + recv = (CC2420Radio.Receiver) cc2420.getReceiver(); + trans.insertProbe(new Medium.Probe.Empty() { + int len = 0; + int expLen = 0; + byte[] buffer = new byte[127 + 15]; + + public void fireBeforeTransmit(Medium.Transmitter t, byte val) { + if (len == 0) { + lastEventTime = MicaZRadio.this.mote.getSimulation().getSimulationTime(); + lastEvent = RadioEvent.TRANSMISSION_STARTED; + /*logger.debug("----- SKY TRANSMISSION STARTED -----");*/ + setChanged(); + notifyObservers(); + } + System.out.println("Node transmitting byte: " + + Integer.toString(val & 0xff, 16)); + + /* send this byte to all nodes */ + lastOutgoingByte = new RadioByte(val); + lastEventTime = MicaZRadio.this.mote.getSimulation().getSimulationTime(); + lastEvent = RadioEvent.CUSTOM_DATA_TRANSMITTED; + setChanged(); + notifyObservers(); + + buffer[len++] = val; + + if (len == 6) { +// System.out.println("## CC2420 Packet of length: " + data + " expected..."); + expLen = val + 6; + } + + if (len == expLen) { + /*logger.debug("----- SKY CUSTOM DATA TRANSMITTED -----");*/ + +// NO CROSSLAYER FOR NOW... +// lastOutgoingPacket = CC2420RadioPacketConverter.fromCC2420ToCooja(buffer); +// lastEventTime = MicaZRadio.this.mote.getSimulation().getSimulationTime(); +// lastEvent = RadioEvent.PACKET_TRANSMITTED; +// /*logger.debug("----- SKY PACKET TRANSMITTED -----");*/ +// setChanged(); +// notifyObservers(); + + // System.out.println("## CC2420 Transmission finished..."); + + lastEventTime = MicaZRadio.this.mote.getSimulation().getSimulationTime(); + /*logger.debug("----- SKY TRANSMISSION FINISHED -----");*/ + lastEvent = RadioEvent.TRANSMISSION_FINISHED; + setChanged(); + notifyObservers(); + len = 0; + } + } + }); + } + + /* Packet radio support */ + public RadioPacket getLastPacketTransmitted() { + return lastOutgoingPacket; + } + + public RadioPacket getLastPacketReceived() { + return lastIncomingPacket; + } + + public void setReceivedPacket(RadioPacket packet) { + } + + /* Custom data radio support */ + public Object getLastCustomDataTransmitted() { + return lastOutgoingByte; + } + + public Object getLastCustomDataReceived() { + return lastIncomingByte; + } + + public void receiveCustomData(Object data) { + if (data instanceof RadioByte) { + lastIncomingByte = (RadioByte) data; + System.out.println("Node receiving byte: " + lastIncomingByte.getPacketData()[0]); + recv.nextByte(true, (byte)lastIncomingByte.getPacketData()[0]); + } + } + + /* General radio support */ + public boolean isTransmitting() { + return isTransmitting; + } + + public boolean isReceiving() { + return isReceiving; + } + + public boolean isInterfered() { + return isInterfered; + } + + public int getChannel() { +// cc2420.updateActiveFrequency(); +// return cc2420.getActiveChannel(); + return 0; + } + + public int getFrequency() { +// cc2420.updateActiveFrequency(); +// return cc2420.getActiveFrequency(); + return 0; + } + + public void signalReceptionStart() { +// cc2420.setCCA(true); +// hasFailedReception = mode == CC2420.MODE_TXRX_OFF; + isReceiving = true; + /* TODO cc2420.setSFD(true); */ + + lastEventTime = mote.getSimulation().getSimulationTime(); + lastEvent = RadioEvent.RECEPTION_STARTED; + /*logger.debug("----- SKY RECEPTION STARTED -----");*/ + setChanged(); + notifyObservers(); + } + + public void signalReceptionEnd() { + /* Deliver packet data */ + isReceiving = false; +// hasFailedReception = false; + isInterfered = false; +// cc2420.setCCA(false); + + /* tell the receiver that the packet is ended */ + recv.nextByte(false, (byte)0); + + lastEventTime = mote.getSimulation().getSimulationTime(); + lastEvent = RadioEvent.RECEPTION_FINISHED; + /*logger.debug("----- SKY RECEPTION FINISHED -----");*/ + setChanged(); + notifyObservers(); + } + + public RadioEvent getLastEvent() { + return lastEvent; + } + + public void interfereAnyReception() { + isInterfered = true; + isReceiving = false; +// hasFailedReception = false; + lastIncomingPacket = null; + + //cc2420.setCCA(true); + + /* is this ok ?? */ + recv.nextByte(false, (byte)0); + + + lastEventTime = mote.getSimulation().getSimulationTime(); + lastEvent = RadioEvent.RECEPTION_INTERFERED; + /*logger.debug("----- SKY RECEPTION INTERFERED -----");*/ + setChanged(); + notifyObservers(); + } + + public double getCurrentOutputPower() { + return 0.0;//cc2420.getOutputPower(); + } + + public int getCurrentOutputPowerIndicator() { + return 0; //cc2420.getOutputPowerIndicator(); + } + + public int getOutputPowerIndicatorMax() { + return 31; + } + + public double getCurrentSignalStrength() { + return 1;//cc2420.getRSSI(); + } + + public void setCurrentSignalStrength(double signalStrength) { + //cc2420.setRSSI((int) signalStrength); + } + + public double energyConsumption() { + return 0; + } + + public JPanel getInterfaceVisualizer() { + // Location + JPanel wrapperPanel = new JPanel(new BorderLayout()); + JPanel panel = new JPanel(new GridLayout(5, 2)); + + final JLabel statusLabel = new JLabel(""); + final JLabel lastEventLabel = new JLabel(""); + final JLabel channelLabel = new JLabel(""); + final JLabel powerLabel = new JLabel(""); + final JLabel ssLabel = new JLabel(""); + final JButton updateButton = new JButton("Update"); + + panel.add(new JLabel("STATE:")); + panel.add(statusLabel); + + panel.add(new JLabel("LAST EVENT:")); + panel.add(lastEventLabel); + + panel.add(new JLabel("CHANNEL:")); + panel.add(channelLabel); + + panel.add(new JLabel("OUTPUT POWER:")); + panel.add(powerLabel); + + panel.add(new JLabel("SIGNAL STRENGTH:")); + JPanel smallPanel = new JPanel(new GridLayout(1, 2)); + smallPanel.add(ssLabel); + smallPanel.add(updateButton); + panel.add(smallPanel); + + updateButton.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent e) { + channelLabel.setText(getChannel() + " (freq=" + getFrequency() + " MHz)"); + powerLabel.setText(getCurrentOutputPower() + " dBm (indicator=" + getCurrentOutputPowerIndicator() + "/" + getOutputPowerIndicatorMax() + ")"); + ssLabel.setText(getCurrentSignalStrength() + " dBm"); + } + }); + + Observer observer; + this.addObserver(observer = new Observer() { + public void update(Observable obs, Object obj) { + if (isTransmitting()) { + statusLabel.setText("transmitting"); + } else if (isReceiving()) { + statusLabel.setText("receiving"); + } else if (radioOn /* mode != CC2420.MODE_TXRX_OFF */) { + statusLabel.setText("listening for traffic"); + } else { + statusLabel.setText("HW off"); + } + + lastEventLabel.setText(lastEvent + " @ time=" + lastEventTime); + + channelLabel.setText(getChannel() + " (freq=" + getFrequency() + " MHz)"); + powerLabel.setText(getCurrentOutputPower() + " dBm (indicator=" + getCurrentOutputPowerIndicator() + "/" + getOutputPowerIndicatorMax() + ")"); + ssLabel.setText(getCurrentSignalStrength() + " dBm"); + } + }); + + observer.update(null, null); + + wrapperPanel.add(BorderLayout.NORTH, panel); + + // Saving observer reference for releaseInterfaceVisualizer + wrapperPanel.putClientProperty("intf_obs", observer); + return wrapperPanel; + } + + public void releaseInterfaceVisualizer(JPanel panel) { + Observer observer = (Observer) panel.getClientProperty("intf_obs"); + if (observer == null) { + logger.fatal("Error when releasing panel, observer is null"); + return; + } + + this.deleteObserver(observer); + } + + public Mote getMote() { + return mote; + } + + public Position getPosition() { + return mote.getInterfaces().getPosition(); + } + + public Collection getConfigXML() { + return null; + } + + public void setConfigXML(Collection configXML, boolean visAvailable) { + } +} diff --git a/tools/cooja/apps/avrora/src/se/sics/cooja/avrmote/interfaces/RadioByte.java b/tools/cooja/apps/avrora/src/se/sics/cooja/avrmote/interfaces/RadioByte.java new file mode 100644 index 000000000..d2376dfc2 --- /dev/null +++ b/tools/cooja/apps/avrora/src/se/sics/cooja/avrmote/interfaces/RadioByte.java @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2009, 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: RadioByte.java,v 1.1 2009/02/24 07:49:42 joxe Exp $ + */ + +package se.sics.cooja.avrmote.interfaces; +import se.sics.cooja.RadioPacket; + +/* TODO: this should be a "standard" class in COOJA core */ +public class RadioByte implements RadioPacket { + private byte[] data = new byte[1]; + + public RadioByte(byte data) { + this.data[0] = data; + } + + public RadioByte(int intData) { + this.data[0] = (byte) intData; + } + + public byte[] getPacketData() { + return data; + } + +}