Merge TinyOS 2.1.1 into master.

[tinyos-2.x.git] / tos / chips / xe1205 / XE1205SendReceiveP.nc

diff --git a/tos/chips/xe1205/XE1205SendReceiveP.nc b/tos/chips/xe1205/XE1205SendReceiveP.nc
index 2d5f67ff8a638d228eb9e03ce9427ad4700b6769..9d11b1c4728024d8440da7e1f27568d1ea9e5a79 100644 (file)
--- a/tos/chips/xe1205/XE1205SendReceiveP.nc
+++ b/tos/chips/xe1205/XE1205SendReceiveP.nc
@@ -137,7 +137,7 @@ implementation {
        return call Packet.getPayload(m, len);
     }
 
-   task void sendDoneTask() {
+    task void sendDoneTask() {
        txMsgSendDonePtr = txMsgPtr;
        txMsgPtr=NULL;
        signal Send.sendDone(txMsgSendDonePtr, SUCCESS);
@@ -151,6 +151,13 @@ implementation {
 
     }
 
+   task void sendDoneNoAckTask() {
+       txMsgSendDonePtr = txMsgPtr;
+       txMsgPtr=NULL;
+       signal Send.sendDone(txMsgSendDonePtr, ENOACK);
+   }
+
+
     command error_t SplitControl.start() {
        error_t err;
        err = call PhySplitControl.start();
@@ -193,23 +200,23 @@ implementation {
 
 
 
- task void sendAck() {
-     atomic {
-        ((xe1205_metadata_t*)((uint8_t*)ackMsgPtr->footer + sizeof(xe1205_footer_t)))->length = sizeof(ackMsg_t);
-        ((xe1205_header_t*)(&ackMsg.data - sizeof(xe1205_header_t)))->group = \
-            (getHeader((message_t*)rxMsgPtr))->group;
-        ((xe1205_header_t*)(ackMsgPtr->data - sizeof(xe1205_header_t)))->type = \
-            ((xe1205_header_t*)(rxMsgPtr->data - sizeof(xe1205_header_t)))->type;
-        ((xe1205_header_t*)(ackMsgPtr->data - sizeof(xe1205_header_t)))->dest = \
-            ((xe1205_header_t*)(rxMsgPtr->data - sizeof(xe1205_header_t)))->source;
-        ((xe1205_header_t*)(ackMsgPtr->data - sizeof(xe1205_header_t)))->source = TOS_NODE_ID; 
-        ((ackMsg_t*)(ackMsgPtr->data))->pl = ackPayload;
-
-        txMsgPtr = ackMsgPtr;
-     }
-        _len = sizeof(ackMsg_t);
-     sendRadioOn(ACK_CODE);
- }
+    task void sendAck() {
+       atomic {
+           ((xe1205_metadata_t*)((uint8_t*)ackMsgPtr->footer + sizeof(xe1205_footer_t)))->length = sizeof(ackMsg_t);
+           ((xe1205_header_t*)(&ackMsg.data - sizeof(xe1205_header_t)))->group = \
+               (getHeader((message_t*)rxMsgPtr))->group;
+           ((xe1205_header_t*)(ackMsgPtr->data - sizeof(xe1205_header_t)))->type = \
+               ((xe1205_header_t*)(rxMsgPtr->data - sizeof(xe1205_header_t)))->type;
+           ((xe1205_header_t*)(ackMsgPtr->data - sizeof(xe1205_header_t)))->dest = \
+               ((xe1205_header_t*)(rxMsgPtr->data - sizeof(xe1205_header_t)))->source;
+           ((xe1205_header_t*)(ackMsgPtr->data - sizeof(xe1205_header_t)))->source = TOS_NODE_ID; 
+           ((ackMsg_t*)(ackMsgPtr->data))->pl = ackPayload;
+
+           txMsgPtr = ackMsgPtr;
+       }
+       _len = sizeof(ackMsg_t);
+       sendRadioOn(ACK_CODE);
+    }
 
     command error_t Send.cancel(message_t* msg) {
        /* Cancel is unsupported for now. */
@@ -247,7 +254,7 @@ implementation {
        txPhyHdr.length = _len;
        txRunningCRC=0;
        getMetadata(txMsgPtr)->length = _len; 
-       if (((xe1205_header_t*)( (uint8_t*)txMsgPtr->data - sizeof(xe1205_header_t)))->ack==1) {
+       if ((((xe1205_header_t*)( (uint8_t*)txMsgPtr->data - sizeof(xe1205_header_t)))->ack & 0x01)==0x01) {
            call XE1205PhyRxTx.enableAck(TRUE);
        }
        txIndex = min(sizeof(xe1205_header_t) + _len + sizeof(xe1205_footer_t), 
@@ -264,8 +271,7 @@ implementation {
            sendingAck=TRUE;
            memcpy(txBuf, ackPreamble, sizeof(ackPreamble));
            memcpy(txBuf + sizeof(pktPreamble), &txPhyHdr, sizeof(txPhyHdr));
-
-           post signalPacketReceived();
+         
            break;
        }
        
@@ -347,23 +353,36 @@ implementation {
     uint8_t sendDones = 0;
     async event void XE1205PhyRxTx.sendFrameDone(error_t err) __attribute__ ((noinline)) {
        sendDones++;
-       if(sendingAck==FALSE)
-           if(err==SUCCESS) {
+       if(sendingAck==FALSE) {
+           switch (err) {
+
+           case SUCCESS:
                if (post sendDoneTask() != SUCCESS)
                    xe1205check(2, FAIL);
-           } else {
+               break;
+               
+           case ENOACK:
+               if(post sendDoneNoAckTask() !=SUCCESS)
+                   xe1205check(2, FAIL);
+               break;
+
+           default:    
                if (post sendDoneFailTask() != SUCCESS)
                    xe1205check(2, FAIL);
            }
-       else {
 
+       } else {
+           
            txMsgPtr = NULL;
-           sendingAck=FALSE;
+           sendingAck=FALSE; 
+           post signalPacketReceived();
        }
     }
 
     command void Packet.clear(message_t* msg) {
-       memset(msg, 0, sizeof(message_t));
+      memset(getHeader(msg), 0, sizeof(xe1205_header_t));
+      memset(getFooter(msg), 0, sizeof(xe1205_footer_t));
+      memset(getMetadata(msg), 0, sizeof(xe1205_metadata_t));
     }
 
     command uint8_t Packet.payloadLength(message_t* msg) {
@@ -379,12 +398,12 @@ implementation {
     }
 
     command void* Packet.getPayload(message_t* msg, uint8_t len) {
-      if (len <= TOSH_DATA_LENGTH) {
-       return (void*)msg->data;
-      }
-      else {
-       return NULL;
-      }
+       if (len <= TOSH_DATA_LENGTH) {
+           return (void*)msg->data;
+       }
+       else {
+           return NULL;
+       }
     }
 
     async command error_t PacketAcknowledgements.requestAck(message_t* msg) {
@@ -414,7 +433,7 @@ implementation {
      return datalen + sizeof(xe1205_header_t) + sizeof(xe1205_footer_t) + sizeof(xe1205_phy_header_t);
  }
 
- task void signalPacketReceived()   __attribute__ ((noinline)) {
+ task void signalPacketReceived() {
      
      atomic { 
         getMetadata((message_t*) rxMsgPtr)->length = rxPhyHdr.length; 
@@ -426,6 +445,7 @@ implementation {
 
 
  uint32_t nrxmsgs;
+
  async event void XE1205PhyRxTx.rxFrameEnd(char* data, uint8_t len, error_t status)   __attribute__ ((noinline)) {
      if (status != SUCCESS){ return;}
 
@@ -446,11 +466,46 @@ implementation {
         (((getHeader((message_t*)rxMsgPtr))->ack)& 0x01)==1) {
         post sendAck();
      } else {
+        post signalPacketReceived();
+     }
+
+ }
+
+ async event void XE1205PhyRxTx.rxAckEnd(char* data, uint8_t len, error_t status)   __attribute__ ((noinline)) {
+
+     sendingAck=FALSE;
+
+     if (status != SUCCESS) { 
+        post sendDoneNoAckTask();
+        return;
+     }
+
+     if (rxBufPtr) {
+        post sendDoneNoAckTask();
+        return; // this could happen whenever rxFrameBegin was called with rxBufPtr still active
+     }
+
+     rxBufPtr = (data + sizeof(xe1205_phy_header_t));
+
+     checkCrcAndUnwhiten(rxBufPtr, rxPhyHdr.whitening, rxPhyHdr.length);
+
+     if (!getFooter(rxMsgPtr)->crc) {
+        post sendDoneNoAckTask();
         atomic rxBufPtr = NULL;
-        rxMsgPtr =  signal Receive.receive(rxMsgPtr, rxMsgPtr->data, getMetadata(rxMsgPtr)->length);
+        return;
      }
+     
+     getMetadata((message_t*) rxMsgPtr)->strength =  call XE1205PhyRssi.readRxRssi();
+     getMetadata((message_t*) rxMsgPtr)->length = rxPhyHdr.length;
 
+     if ((getHeader((message_t*)rxMsgPtr))->dest == TOS_NODE_ID) {
+        post sendDoneTask();
+     } else {
+        post sendDoneNoAckTask();
+     }
+     atomic rxBufPtr = NULL;
  }
+
  async event void XE1205PhyRssi.rssiDone(uint8_t _rssi) { }
 
 }