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

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

diff --git a/tos/chips/rf2xx/layers/IEEE154MessageLayerP.nc b/tos/chips/rf2xx/layers/IEEE154MessageLayerP.nc
index a9a82bb07bff66c044f82608eb33e600c86a9876..56379e3b2d331edf97963be8a3e65270357baa89 100644 (file)
--- a/tos/chips/rf2xx/layers/IEEE154MessageLayerP.nc
+++ b/tos/chips/rf2xx/layers/IEEE154MessageLayerP.nc
@@ -28,13 +28,21 @@ module IEEE154MessageLayerP
        provides 
        {
                interface IEEE154MessageLayer;
+               interface RadioPacket;
                interface Ieee154Packet;
+               interface Packet;
+               interface Ieee154Send;
+               interface BareSend as Send;
+               interface Receive as Ieee154Receive;
+               interface SendNotifier;
        }
 
        uses
        {
                interface ActiveMessageAddress;
-               interface IEEE154MessageConfig as Config;
+               interface RadioPacket as SubPacket;
+               interface BareSend as SubSend;
+               interface BareReceive as SubReceive;
        }
 }
 
@@ -54,24 +62,19 @@ implementation
                        | (IEEE154_ADDR_SHORT << IEEE154_FCF_DEST_ADDR_MODE) 
                        | (IEEE154_ADDR_SHORT << IEEE154_FCF_SRC_ADDR_MODE),
 
-               IEEE154_ACK_FRAME_LENGTH = 5,   // includes the FCF, DSN and FCS
+               IEEE154_ACK_FRAME_LENGTH = 3,   // includes the FCF, DSN
                IEEE154_ACK_FRAME_MASK = (IEEE154_TYPE_MASK << IEEE154_FCF_FRAME_TYPE), 
                IEEE154_ACK_FRAME_VALUE = (IEEE154_TYPE_ACK << IEEE154_FCF_FRAME_TYPE),
        };
 
        ieee154_header_t* getHeader(message_t* msg)
        {
-               return call Config.getHeader(msg);
+               return ((void*)msg) + call SubPacket.headerLength(msg);
        }
 
-       async command uint8_t IEEE154MessageLayer.getLength(message_t* msg)
+       void* getPayload(message_t* msg)
        {
-               return getHeader(msg)->length;
-       }
-
-       async command void IEEE154MessageLayer.setLength(message_t* msg, uint8_t length)
-       {
-               getHeader(msg)->length = length;
+               return ((void*)msg) + call RadioPacket.headerLength(msg);
        }
 
        async command uint16_t IEEE154MessageLayer.getFCF(message_t* msg)
@@ -101,17 +104,15 @@ implementation
 
        async command void IEEE154MessageLayer.createAckFrame(message_t* msg)
        {
-               ieee154_header_t* header = getHeader(msg);
-
-               header->length = IEEE154_ACK_FRAME_LENGTH;
-               header->fcf = IEEE154_ACK_FRAME_VALUE;
+               call SubPacket.setPayloadLength(msg, IEEE154_ACK_FRAME_LENGTH);
+               getHeader(msg)->fcf = IEEE154_ACK_FRAME_VALUE;
        }
 
        async command void IEEE154MessageLayer.createAckReply(message_t* data, message_t* ack)
        {
                ieee154_header_t* header = getHeader(ack);
+               call SubPacket.setPayloadLength(ack, IEEE154_ACK_FRAME_LENGTH);
 
-               header->length = IEEE154_ACK_FRAME_LENGTH;
                header->fcf = IEEE154_ACK_FRAME_VALUE;
                header->dsn = getHeader(data)->dsn;
        }
@@ -186,7 +187,7 @@ implementation
        }
 
        async command void IEEE154MessageLayer.setSrcAddr(message_t* msg, uint16_t addr)
-       {
+       {       
                getHeader(msg)->src = addr;
        }
 
@@ -255,4 +256,141 @@ implementation
        {
                return call ActiveMessageAddress.amGroup();
        }
+
+/*----------------- RadioPacket -----------------*/
+
+       async command uint8_t RadioPacket.headerLength(message_t* msg)
+       {
+               return call SubPacket.headerLength(msg) + sizeof(ieee154_header_t);
+       }
+
+       async command uint8_t RadioPacket.payloadLength(message_t* msg)
+       {
+               return call SubPacket.payloadLength(msg) - sizeof(ieee154_header_t);
+       }
+
+       async command void RadioPacket.setPayloadLength(message_t* msg, uint8_t length)
+       {
+               call SubPacket.setPayloadLength(msg, length + sizeof(ieee154_header_t));
+       }
+
+       async command uint8_t RadioPacket.maxPayloadLength()
+       {
+               return call SubPacket.maxPayloadLength() - sizeof(ieee154_header_t);
+       }
+
+       async command uint8_t RadioPacket.metadataLength(message_t* msg)
+       {
+               return call SubPacket.metadataLength(msg);
+       }
+
+       async command void RadioPacket.clear(message_t* msg)
+       {
+               call SubPacket.clear(msg);
+       }
+
+/*----------------- Packet -----------------*/
+
+       command void Packet.clear(message_t* msg)
+       {
+               call RadioPacket.clear(msg);
+       }
+
+       command uint8_t Packet.payloadLength(message_t* msg)
+       {
+               return call RadioPacket.payloadLength(msg);
+       }
+
+       command void Packet.setPayloadLength(message_t* msg, uint8_t len)
+       {
+               call RadioPacket.setPayloadLength(msg, len);
+       }
+
+       command uint8_t Packet.maxPayloadLength()
+       {
+               return call RadioPacket.maxPayloadLength();
+       }
+
+       command void* Packet.getPayload(message_t* msg, uint8_t len)
+       {
+               if( len > call RadioPacket.maxPayloadLength() )
+                       return NULL;
+
+               return getPayload(msg);
+       }
+
+/*----------------- Ieee154Send -----------------*/
+
+       command void * Ieee154Send.getPayload(message_t* msg, uint8_t len)
+       {
+               return call Packet.getPayload(msg, len);
+       }
+
+       command uint8_t Ieee154Send.maxPayloadLength()
+       {
+               return call Packet.maxPayloadLength();
+       }
+
+       command error_t Ieee154Send.cancel(message_t* msg)
+       {
+               return call SubSend.cancel(msg);
+       }
+
+       command error_t Ieee154Send.send(ieee154_saddr_t addr, message_t* msg, uint8_t len)
+       {
+               if( len > call Packet.maxPayloadLength() )
+                       return EINVAL;
+
+               call IEEE154MessageLayer.createDataFrame(msg);
+               call Packet.setPayloadLength(msg, len);
+               call Ieee154Packet.setSource(msg, call Ieee154Packet.address());
+               call Ieee154Packet.setDestination(msg, addr);
+               call Ieee154Packet.setPan(msg, call Ieee154Packet.localPan());
+               
+               signal SendNotifier.aboutToSend(addr, msg);
+       
+               return call SubSend.send(msg);
+       }
+
+       default event void Ieee154Send.sendDone(message_t* msg, error_t error)
+       {
+       }
+
+       default event void SendNotifier.aboutToSend(am_addr_t addr, message_t* msg)
+       {
+       }
+
+/*----------------- Send -----------------*/
+
+       command error_t Send.send(message_t* msg)
+       {
+               // lower leveles can send other frames
+               call IEEE154MessageLayer.createDataFrame(msg);
+
+               return call SubSend.send(msg);
+       }
+
+       command error_t Send.cancel(message_t* msg)
+       {
+               return call SubSend.cancel(msg);
+       }
+
+       event void SubSend.sendDone(message_t* msg, error_t error)
+       {
+               // we signal  both, only one of them should be connected
+               signal Ieee154Send.sendDone(msg, error);
+               signal Send.sendDone(msg, error);
+       }
+
+       default event void Send.sendDone(message_t* msg, error_t error)
+       {
+       }
+
+/*----------------- Receive -----------------*/
+
+       event message_t* SubReceive.receive(message_t* msg)
+       {
+               return signal Ieee154Receive.receive(msg,
+                       getPayload(msg), call Packet.payloadLength(msg));
+       }
 }