public synchronized void messageReceived(int to, Message m) { DrainMsg mhMsg = (DrainMsg) m; log.debug( "incoming: localDest: " + to + " type:" + mhMsg.get_type() + " hops:" + (16 - mhMsg.get_ttl()) + " seqNo:" + mhMsg.get_seqNo() + " source:" + mhMsg.get_source() + " finalDest:" + mhMsg.get_dest()); // lets assume that the network cannot buffer more than 25 drain msgs from a single source at a // time (should be more than reasonable) if (seqNos.containsKey(new Integer(mhMsg.get_source()))) { int oldSeqNo = ((Integer) seqNos.get(new Integer(mhMsg.get_source()))).intValue(); int upperBound = mhMsg.get_seqNo() + 25; int wrappedUpperBound = 25 - (255 - mhMsg.get_seqNo()); if ((oldSeqNo >= mhMsg.get_seqNo() && oldSeqNo < upperBound) || (oldSeqNo >= 0 && oldSeqNo < wrappedUpperBound)) { log.debug( "Dropping message from " + mhMsg.get_source() + " with duplicate seqNo: " + mhMsg.get_seqNo()); return; } } seqNos.put(new Integer(mhMsg.get_source()), new Integer(mhMsg.get_seqNo())); if (to != spAddr && to != MoteIF.TOS_BCAST_ADDR && to != TOS_UART_ADDR) { log.debug("Dropping message not for me."); return; } HashSet promiscuousSet = (HashSet) idTable.get(new Integer(BCAST_ID)); HashSet listenerSet = (HashSet) idTable.get(new Integer(mhMsg.get_type())); if (listenerSet != null && promiscuousSet != null) { listenerSet.addAll(promiscuousSet); } else if (listenerSet == null && promiscuousSet != null) { listenerSet = promiscuousSet; } if (listenerSet == null) { log.debug("No Listener for type: " + mhMsg.get_type()); return; } for (Iterator it = listenerSet.iterator(); it.hasNext(); ) { MessageListener ml = (MessageListener) it.next(); ml.messageReceived(to, mhMsg); } }
public void registerListener(int id, MessageListener m) { HashSet listenerSet = (HashSet) idTable.get(new Integer(id)); if (listenerSet == null) { listenerSet = new HashSet(); idTable.put(new Integer(id), listenerSet); } listenerSet.add(m); log.info("New Listener for id=" + id); }
public Drip(int id) { log.info("Started id=" + id); try { moteIF = new MoteIF(); moteIF.registerListener(new DripMsg(), this); } catch (Exception e) { System.out.println("ERROR: Couldn't contact serial forwarder."); System.exit(1); } this.id = id; }
public void messageReceived(int to, Message m) { DripMsg msg = (DripMsg) m; int newId = msg.get_metadata_id(); int newSeqno = msg.get_metadata_seqno(); log.debug("Received Msg: id=" + newId + ",seqno=" + newSeqno); if (newId != id) { log.debug("dropped, not ID " + id); return; } if ((newSeqno & ~DripConsts.DRIP_WAKEUP_BIT) == DripConsts.DRIP_SEQNO_NEWEST) { log.debug("dropped, a special seqno " + newSeqno); return; } switch (state) { case PROBING: seqno = newSeqno; log.info( "Receive: id=" + id + ",seqno=" + dripMsg.get_metadata_seqno() + " Heard Old Seqno"); incrementSeqno(); state = SENDING_SEQNO; case SENDING_SEQNO: if (seqno == newSeqno) { log.info( "Receive: id=" + id + ",seqno=" + dripMsg.get_metadata_seqno() + " Heard New Seqno"); trickle.cancel(); trickleTask.cancel(); sendDone(); } default: } }
public class Drip implements MessageListener { public static int SEND_COUNT = 12; public static int SEND_RATE = DripConsts.DRIP_TIMER_PERIOD; public static int WAKEUP_SEND_COUNT = 25; public static int WAKEUP_SEND_RATE = 40; private Logger log = Logger.getLogger(Drip.class.getName()); private static final int IDLE = 0; private static final int PROBING = 1; private static final int SENDING_SEQNO = 2; private static final int SENT_SEQNO = 3; private static final int SENDING_NEW = 4; private int state = IDLE; int id; int seqno; int sendCount = 0; int maxSendCount; Timer trickle; TimerTask trickleTask; MoteIF moteIF; DripMsg dripMsg; boolean hasMessage = false; boolean sentOK = true; boolean wakeupMsg = false; public Drip(int id) { log.info("Started id=" + id); try { moteIF = new MoteIF(); moteIF.registerListener(new DripMsg(), this); } catch (Exception e) { System.out.println("ERROR: Couldn't contact serial forwarder."); System.exit(1); } this.id = id; } public Drip(int id, MoteIF p_moteIF) { log.info("Started with own moteIF id=" + id); try { moteIF = p_moteIF; moteIF.registerListener(new DripMsg(), this); } catch (Exception e) { System.out.println("ERROR: Couldn't contact serial forwarder."); System.exit(1); } this.id = id; } void setupDrip(Message msg, int msgSize) { trickle = new Timer(); trickleTask = new DripSender(); dripMsg = new DripMsg(DripMsg.DEFAULT_MESSAGE_SIZE + msgSize); dripMsg.dataSet(msg.dataGet(), 0, dripMsg.offset_data(0), msgSize); sendCount = 0; } Message buildAddrMsg(int dest, Message msg, int msgSize) { AddressMsg addrMsg = new AddressMsg(AddressMsg.DEFAULT_MESSAGE_SIZE + msgSize); String moteid = Env.getenv("MOTEID"); int source = 0xFFFF; if (moteid != null) { source = Integer.parseInt(moteid); } addrMsg.dataSet(msg.dataGet(), 0, addrMsg.offset_data(0), msgSize); addrMsg.set_dest(dest); addrMsg.set_source(source); return addrMsg; } public synchronized void send(Message msg, int msgSize) { setupDrip(msg, msgSize); state = PROBING; wakeupMsg = false; sendCount = 0; maxSendCount = SEND_COUNT; trickle.schedule(trickleTask, 0, 500); try { wait(); } catch (InterruptedException e) { // return } } public synchronized void sendAddressed(int dest, Message msg, int msgSize) { AddressMsg addrMsg = (AddressMsg) buildAddrMsg(dest, msg, msgSize); send(addrMsg, msgSize + AddressMsg.DEFAULT_MESSAGE_SIZE); } public synchronized void sendUnreliable(Message msg, int msgSize) { setupDrip(msg, msgSize); state = SENDING_NEW; wakeupMsg = false; sendCount = 0; maxSendCount = 1; trickle.schedule(trickleTask, 0, SEND_RATE); try { wait(); } catch (InterruptedException e) { // return } } public synchronized void sendAddressedUnreliable(int dest, Message msg, int msgSize) { AddressMsg addrMsg = (AddressMsg) buildAddrMsg(dest, msg, msgSize); sendUnreliable(addrMsg, msgSize + AddressMsg.DEFAULT_MESSAGE_SIZE); } public synchronized void sendWakeup(Message msg, int msgSize) { setupDrip(msg, msgSize); state = SENDING_NEW; wakeupMsg = true; sendCount = 0; maxSendCount = WAKEUP_SEND_COUNT; trickle.schedule(trickleTask, 0, WAKEUP_SEND_RATE); try { wait(); } catch (InterruptedException e) { // return } } private synchronized void sendDone() { notifyAll(); state = IDLE; } class DripSender extends TimerTask { public void run() { boolean stopSending = false; log.debug("DripSender.run(state=" + state + " sendCount= " + sendCount + ")"); dripMsg.set_metadata_id((short) id); switch (state) { case PROBING: if (sendCount < maxSendCount) { log.debug("probing"); dripMsg.set_metadata_seqno((byte) DripConsts.DRIP_SEQNO_OLDEST); } else { log.debug("probing finished"); stopSending = true; } break; case SENDING_SEQNO: if (sendCount < maxSendCount) { log.debug("sending new seqno " + seqno); dripMsg.set_metadata_seqno((byte) seqno); } else { log.debug("sending finished"); stopSending = true; } break; case SENDING_NEW: if (sendCount < maxSendCount) { log.debug("sending unreliably"); dripMsg.set_metadata_seqno((byte) DripConsts.DRIP_SEQNO_NEWEST); } else { log.debug("sending unreliably finished"); stopSending = true; } break; case SENT_SEQNO: log.debug("done sending"); stopSending = true; return; default: } if (wakeupMsg == true) { dripMsg.set_metadata_seqno((short) ((dripMsg.get_metadata_seqno() + 1) % 256)); } if (stopSending) { trickle.cancel(); trickleTask.cancel(); sendDone(); } else { log.info( "Sending Msg " + sendCount + ": id=" + id + ",seqno=" + dripMsg.get_metadata_seqno()); send(dripMsg); sendCount++; } } } private void send(Message m) { try { moteIF.send(MoteIF.TOS_BCAST_ADDR, m); } catch (IOException e) { e.printStackTrace(); System.out.println("ERROR: Can't send message"); System.exit(1); } catch (Exception e) { e.printStackTrace(); } } public void messageReceived(int to, Message m) { DripMsg msg = (DripMsg) m; int newId = msg.get_metadata_id(); int newSeqno = msg.get_metadata_seqno(); log.debug("Received Msg: id=" + newId + ",seqno=" + newSeqno); if (newId != id) { log.debug("dropped, not ID " + id); return; } if ((newSeqno & ~DripConsts.DRIP_WAKEUP_BIT) == DripConsts.DRIP_SEQNO_NEWEST) { log.debug("dropped, a special seqno " + newSeqno); return; } switch (state) { case PROBING: seqno = newSeqno; log.info( "Receive: id=" + id + ",seqno=" + dripMsg.get_metadata_seqno() + " Heard Old Seqno"); incrementSeqno(); state = SENDING_SEQNO; case SENDING_SEQNO: if (seqno == newSeqno) { log.info( "Receive: id=" + id + ",seqno=" + dripMsg.get_metadata_seqno() + " Heard New Seqno"); trickle.cancel(); trickleTask.cancel(); sendDone(); } default: } } private void incrementSeqno() { if (wakeupMsg && ((seqno & DripConsts.DRIP_WAKEUP_BIT) == 0)) { seqno = (seqno + 1) % 256; } if (!wakeupMsg && ((seqno & DripConsts.DRIP_WAKEUP_BIT) == 1)) { seqno = (seqno + 1) % 256; } seqno = (seqno + 1) % 256; seqno = (seqno + 1) % 256; while ((seqno & ~DripConsts.DRIP_WAKEUP_BIT) == DripConsts.DRIP_SEQNO_OLDEST || (seqno & ~DripConsts.DRIP_WAKEUP_BIT) == DripConsts.DRIP_SEQNO_NEWEST || (seqno & ~DripConsts.DRIP_WAKEUP_BIT) == DripConsts.DRIP_SEQNO_UNKNOWN) { seqno = (seqno + 1) % 256; seqno = (seqno + 1) % 256; } } private static int data = 1000; private static int channel = 254; private static boolean wakeup = false; public static void main(String[] args) { parseArgs(args); Drip drip = new Drip(channel); TestDripMsg msg = new TestDripMsg(); msg.set_data((short) data); if (wakeup) { drip.sendWakeup(msg, TestDripMsg.DEFAULT_MESSAGE_SIZE); } else { drip.send(msg, TestDripMsg.DEFAULT_MESSAGE_SIZE); } System.exit(0); } private static void parseArgs(String args[]) { ArrayList cleanedArgs = new ArrayList(); for (int i = 0; i < args.length; i++) { if (args[i].startsWith("--")) { // Parse Long Options String longopt = args[i].substring(2); if (longopt.equals("help")) { usage(); } } else if (args[i].startsWith("-")) { // Parse Short Options String opt = args[i].substring(1); if (opt.equals("d")) { data = Integer.parseInt(args[++i]); } else if (opt.equals("w")) { wakeup = true; } else if (opt.equals("c")) { channel = Integer.parseInt(args[++i]); } else if (opt.equals("h")) { usage(); } } else { // Place into args string cleanedArgs.add(args[i]); } } } private static void usage() { System.err.println("usage: java net.tinyos.drain.Drip <opts>"); System.err.println(" -d <data value>"); System.err.println(" -c <channel id>"); System.err.println(" -w : send message with wakeup bit set"); System.err.println(" -h, --help : this information"); System.exit(1); } }
public DrainConnector(int p_spAddr, MoteIF p_moteIF) { spAddr = p_spAddr; moteIF = p_moteIF; moteIF.registerListener(new DrainMsg(), this); log.info("Started myAddr = " + spAddr + ", listening for DrainMsg"); }
public class DrainConnector implements MessageListener { public static int TOS_UART_ADDR = 0x7e; public static int DEFAULT_MOTE_ID = 0xfffe; public static int BCAST_ID = 0xff; private MoteIF moteIF; private Logger log = Logger.getLogger(DrainConnector.class.getName()); private int spAddr; private Hashtable seqNos = new Hashtable(); private HashMap idTable = new HashMap(); public DrainConnector() { this(DrainLib.setSPAddr(), DrainLib.startMoteIF()); } public DrainConnector(int p_spAddr, MoteIF p_moteIF) { spAddr = p_spAddr; moteIF = p_moteIF; moteIF.registerListener(new DrainMsg(), this); log.info("Started myAddr = " + spAddr + ", listening for DrainMsg"); } public void registerListener(int id, MessageListener m) { HashSet listenerSet = (HashSet) idTable.get(new Integer(id)); if (listenerSet == null) { listenerSet = new HashSet(); idTable.put(new Integer(id), listenerSet); } listenerSet.add(m); log.info("New Listener for id=" + id); } public void deregisterListener(int id, MessageListener m) { HashSet listenerSet = (HashSet) idTable.get(new Integer(id)); if (listenerSet == null) { throw new IllegalArgumentException("No listeners registered for message type " + id); } listenerSet.remove(m); } public synchronized void messageReceived(int to, Message m) { DrainMsg mhMsg = (DrainMsg) m; log.debug( "incoming: localDest: " + to + " type:" + mhMsg.get_type() + " hops:" + (16 - mhMsg.get_ttl()) + " seqNo:" + mhMsg.get_seqNo() + " source:" + mhMsg.get_source() + " finalDest:" + mhMsg.get_dest()); // lets assume that the network cannot buffer more than 25 drain msgs from a single source at a // time (should be more than reasonable) if (seqNos.containsKey(new Integer(mhMsg.get_source()))) { int oldSeqNo = ((Integer) seqNos.get(new Integer(mhMsg.get_source()))).intValue(); int upperBound = mhMsg.get_seqNo() + 25; int wrappedUpperBound = 25 - (255 - mhMsg.get_seqNo()); if ((oldSeqNo >= mhMsg.get_seqNo() && oldSeqNo < upperBound) || (oldSeqNo >= 0 && oldSeqNo < wrappedUpperBound)) { log.debug( "Dropping message from " + mhMsg.get_source() + " with duplicate seqNo: " + mhMsg.get_seqNo()); return; } } seqNos.put(new Integer(mhMsg.get_source()), new Integer(mhMsg.get_seqNo())); if (to != spAddr && to != MoteIF.TOS_BCAST_ADDR && to != TOS_UART_ADDR) { log.debug("Dropping message not for me."); return; } HashSet promiscuousSet = (HashSet) idTable.get(new Integer(BCAST_ID)); HashSet listenerSet = (HashSet) idTable.get(new Integer(mhMsg.get_type())); if (listenerSet != null && promiscuousSet != null) { listenerSet.addAll(promiscuousSet); } else if (listenerSet == null && promiscuousSet != null) { listenerSet = promiscuousSet; } if (listenerSet == null) { log.debug("No Listener for type: " + mhMsg.get_type()); return; } for (Iterator it = listenerSet.iterator(); it.hasNext(); ) { MessageListener ml = (MessageListener) it.next(); ml.messageReceived(to, mhMsg); } } public static void main(String args[]) { DrainConnector dc = new DrainConnector(); } }