Use BareSend/BareReceive instead of Send/Receive to avoid duplication of payload...

[tinyos-2.x.git] / tos / chips / rf2xx / layers / LowPowerListeningLayerP.nc

diff --git a/tos/chips/rf2xx/layers/LowPowerListeningLayerP.nc b/tos/chips/rf2xx/layers/LowPowerListeningLayerP.nc
index 4bdd79ee301312431ddc65de466b030170d147c7..0b1720408ad79d49dbedfcec973b7fee28e9afdd 100644 (file)
--- a/tos/chips/rf2xx/layers/LowPowerListeningLayerP.nc
+++ b/tos/chips/rf2xx/layers/LowPowerListeningLayerP.nc
@@ -29,8 +29,9 @@ module LowPowerListeningLayerP
        provides
        {
                interface SplitControl;
-               interface Send;
-               interface Receive;
+               interface BareSend as Send;
+               interface BareReceive as Receive;
+               interface RadioPacket;
 
                interface LowPowerListening;
        }
@@ -38,8 +39,9 @@ module LowPowerListeningLayerP
        uses
        {
                interface SplitControl as SubControl;
-               interface Send as SubSend;
-               interface Receive as SubReceive;
+               interface BareSend as SubSend;
+               interface BareReceive as SubReceive;
+               interface RadioPacket as SubPacket;
 
                interface PacketAcknowledgements;
                interface LowPowerListeningConfig as Config;
@@ -68,7 +70,6 @@ implementation
        uint16_t sleepInterval;
 
        message_t* txMsg;
-       uint8_t txLen;
        error_t txError;
 
 /*----------------- state machine -----------------*/
@@ -170,7 +171,7 @@ implementation
                }
                else if( state == SEND_SUBSEND)
                {
-                       txError = call SubSend.send(txMsg, txLen);
+                       txError = call SubSend.send(txMsg);
 
                        if( txError == SUCCESS )
                                state = SEND_SUBSEND_DONE;
@@ -267,7 +268,7 @@ implementation
                post transition();
        }
 
-       event message_t* SubReceive.receive(message_t* msg, void* payload, uint8_t len)
+       event message_t* SubReceive.receive(message_t* msg)
        {
                if( state == SLEEP_SUBSTOP )
                        state = LISTEN;
@@ -275,10 +276,10 @@ implementation
                if( state == LISTEN && sleepInterval > 0 )
                        call Timer.startOneShot(AFTER_RECEIVE);
 
-               return signal Receive.receive(msg, payload, len);
+               return signal Receive.receive(msg);
        }
 
-       command error_t Send.send(message_t* msg, uint8_t len)
+       command error_t Send.send(message_t* msg)
        {
                if( state == LISTEN || state == SLEEP )
                {
@@ -296,7 +297,6 @@ implementation
                        return EBUSY;
 
                txMsg = msg;
-               txLen = len;
                txError = FAIL;
 
                return SUCCESS;
@@ -346,18 +346,13 @@ implementation
                post transition();
        }
 
-       command uint8_t Send.maxPayloadLength()
-       {
-               return call SubSend.maxPayloadLength();
-       }
+/*----------------- LowPowerListening -----------------*/
 
-       command void* Send.getPayload(message_t* msg, uint8_t len)
+       lpl_metadata_t* getMeta(message_t* msg)
        {
-               return call SubSend.getPayload(msg, len);
+               return ((void*)msg) + sizeof(message_t) - call RadioPacket.metadataLength(msg);
        }
 
-/*----------------- LowPowerListening -----------------*/
-
        command uint16_t LowPowerListening.dutyCycleToSleepInterval(uint16_t dutyCycle)
        {
                if( dutyCycle >= 10000 )
@@ -418,12 +413,12 @@ implementation
                else if( interval > MAX_SLEEP )
                        interval = MAX_SLEEP;
 
-               (call Config.metadata(msg))->sleepint = interval;
+               getMeta(msg)->sleepint = interval;
        }
 
        command uint16_t LowPowerListening.getRxSleepInterval(message_t *msg)
        {
-               uint16_t sleepint = (call Config.metadata(msg))->sleepint;
+               uint16_t sleepint = getMeta(msg)->sleepint;
 
                return sleepint != 0 ? sleepint : sleepInterval;
        }
@@ -440,8 +435,36 @@ implementation
                        call LowPowerListening.getRxSleepInterval(msg));
        }
 
-       async event void Config.clear(message_t* msg)
+/*----------------- RadioPacket -----------------*/
+       
+       async command uint8_t RadioPacket.headerLength(message_t* msg)
+       {
+               return call SubPacket.headerLength(msg);
+       }
+
+       async command uint8_t RadioPacket.payloadLength(message_t* msg)
+       {
+               return call SubPacket.payloadLength(msg);
+       }
+
+       async command void RadioPacket.setPayloadLength(message_t* msg, uint8_t length)
+       {
+               call SubPacket.setPayloadLength(msg, length);
+       }
+
+       async command uint8_t RadioPacket.maxPayloadLength()
+       {
+               return call SubPacket.maxPayloadLength();
+       }
+
+       async command uint8_t RadioPacket.metadataLength(message_t* msg)
+       {
+               return call SubPacket.metadataLength(msg) + sizeof(lpl_metadata_t);
+       }
+
+       async command void RadioPacket.clear(message_t* msg)
        {
-               (call Config.metadata(msg))->sleepint = 0;
+               getMeta(msg)->sleepint = 0;
+               call SubPacket.clear(msg);
        }
 }