Added a StdControl interface, and a top-level DisseminationC component. Added a set...

[tinyos-2.x.git] / tos / lib / net / DisseminationEngineImplP.nc

diff --git a/tos/lib/net/DisseminationEngineImplP.nc b/tos/lib/net/DisseminationEngineImplP.nc
index e8fe7e3328d74637d0a0ee386ab9737eb061ae2f..6ee3e36627af8f2b489661dae1b10da7678482d8 100644 (file)
--- a/tos/lib/net/DisseminationEngineImplP.nc
+++ b/tos/lib/net/DisseminationEngineImplP.nc
@@ -43,11 +43,12 @@
  */
 
 module DisseminationEngineImplP {
+  provides interface StdControl;
+
   uses {
-    interface Boot;
-    interface SplitControl as RadioControl;
     interface DisseminationCache[uint16_t key];
     interface TrickleTimer[uint16_t key];
+    interface StdControl as DisseminatorControl[uint16_t id];
 
     interface AMSend;
     interface Receive;
@@ -60,36 +61,55 @@ module DisseminationEngineImplP {
 }
 implementation {
 
+  enum { NUM_DISSEMINATORS = uniqueCount("DisseminationTimerC.TrickleTimer") };
+
   message_t m_buf;
-  bool m_bufBusy = TRUE;
+  bool m_running;
+  bool m_bufBusy;
 
   void sendProbe( uint16_t key );
   void sendObject( uint16_t key );
 
-  event void Boot.booted() {
-    call RadioControl.start(); 
+  command error_t StdControl.start() {
+    uint8_t i;
+    for ( i = 0; i < NUM_DISSEMINATORS; i++ ) {
+      call DisseminatorControl.start[ i ]();
+    }
+    m_running = TRUE;
+    return SUCCESS;
   }
 
-  event void RadioControl.startDone( error_t err ) {
-    m_bufBusy = FALSE;
+  command error_t StdControl.stop() {
+    uint8_t i;
+    for ( i = 0; i < NUM_DISSEMINATORS; i++ ) {
+      call DisseminatorControl.stop[ i ]();
+    }
+    m_running = FALSE;
+    return SUCCESS;
   }
-  event void RadioControl.stopDone( error_t err ) {}
 
-  event void DisseminationCache.init[ uint16_t key ]() {
-    call TrickleTimer.start[ key ]();
+  event error_t DisseminationCache.start[ uint16_t key ]() {
+    error_t result = call TrickleTimer.start[ key ]();
     call TrickleTimer.reset[ key ]();
+    return result;
+  }
+
+  event error_t DisseminationCache.stop[ uint16_t key ]() {
+    call TrickleTimer.stop[ key ]();
+    return SUCCESS;
   }
 
   event void DisseminationCache.newData[ uint16_t key ]() {
+
+    if ( !m_running || m_bufBusy ) { return; }
+
     sendObject( key );
     call TrickleTimer.reset[ key ]();
   }
 
   event void TrickleTimer.fired[ uint16_t key ]() {
 
-    call Leds.led2Toggle();
-
-    if ( m_bufBusy ) { return; }
+    if ( !m_running || m_bufBusy ) { return; }
 
     sendObject( key );
   }
@@ -120,10 +140,10 @@ implementation {
 
     if ( dMsg->seqno != DISSEMINATION_SEQNO_UNKNOWN ) {
       object = call DisseminationCache.requestData[ key ]( &objectSize );
-      objectSize = 
-       objectSize < call AMSend.maxPayloadLength() ?
-       objectSize : call AMSend.maxPayloadLength();
-
+      if ((objectSize + sizeof(dissemination_message_t)) > 
+           call AMSend.maxPayloadLength()) {
+        objectSize = call AMSend.maxPayloadLength() - sizeof(dissemination_message_t);
+      }
       memcpy( dMsg->data, object, objectSize );
     }      
     call AMSend.send( AM_BROADCAST_ADDR,
@@ -149,6 +169,8 @@ implementation {
     uint32_t incomingSeqno = dMsg->seqno;
     uint32_t currentSeqno = call DisseminationCache.requestSeqno[ key ]();
 
+    if ( !m_running ) { return msg; }
+
     if ( currentSeqno == DISSEMINATION_SEQNO_UNKNOWN &&
         incomingSeqno != DISSEMINATION_SEQNO_UNKNOWN ) {
 
@@ -199,6 +221,8 @@ implementation {
     dissemination_probe_message_t* dpMsg = 
       (dissemination_probe_message_t*) payload;
 
+    if ( !m_running ) { return msg; }
+
     if ( call DisseminationCache.requestSeqno[ dpMsg->key ]() != 
         DISSEMINATION_SEQNO_UNKNOWN ) {    
       sendObject( dpMsg->key );
@@ -216,13 +240,16 @@ implementation {
                                                uint32_t seqno ) {}
 
   default command uint32_t 
-    DisseminationCache.requestSeqno[uint16_t key]() { return 0; }
+    DisseminationCache.requestSeqno[uint16_t key]() { return DISSEMINATION_SEQNO_UNKNOWN; }
 
-  default command error_t TrickleTimer.start[uint16_t key]() { return SUCCESS; }
+  default command error_t TrickleTimer.start[uint16_t key]() { return FAIL; }
 
   default command void TrickleTimer.stop[uint16_t key]() { }
 
   default command void TrickleTimer.reset[uint16_t key]() { }
 
   default command void TrickleTimer.incrementCounter[uint16_t key]() { }
+
+  default command error_t DisseminatorControl.start[uint16_t id]() { return FAIL; }
+  default command error_t DisseminatorControl.stop[uint16_t id]() { return FAIL; }
 }