Merge TinyOS 2.1.1 into master.

[tinyos-2.x.git] / tos / lib / serial / SerialActiveMessageP.nc

diff --git a/tos/lib/serial/SerialActiveMessageP.nc b/tos/lib/serial/SerialActiveMessageP.nc
index 3a123a9b3c7d252f9bfbed290015645e0b1b5d5b..7bdc56382c65d5716fcff5c5d799098ab8a5955c 100644 (file)
--- a/tos/lib/serial/SerialActiveMessageP.nc
+++ b/tos/lib/serial/SerialActiveMessageP.nc
@@ -46,18 +46,32 @@ generic module SerialActiveMessageP () {
 }
 implementation {
 
-  serial_header_t* getHeader(message_t* msg) {
-    return (serial_header_t*)(msg->data - sizeof(serial_header_t));
+  serial_header_t* ONE getHeader(message_t* ONE msg) {
+    return TCAST(serial_header_t* ONE, (uint8_t*)msg + offsetof(message_t, data) - sizeof(serial_header_t));
+  }
+
+  serial_metadata_t* getMetadata(message_t* msg) {
+    return (serial_metadata_t*)(msg->metadata);
   }
   
   command error_t AMSend.send[am_id_t id](am_addr_t dest,
                                          message_t* msg,
                                          uint8_t len) {
     serial_header_t* header = getHeader(msg);
-    header->addr = dest;
+
+    if (len > call Packet.maxPayloadLength()) {
+      return ESIZE;
+    }
+
+    header->dest = dest;
+    // Do not set the source address or group, as doing so
+    // prevents transparent bridging. Need a better long-term
+    // solution for this.
+    //header->src = call AMPacket.address();
+    //header->group = TOS_AM_GROUP;
     header->type = id;
     header->length = len;
-    header->group = TOS_AM_GROUP;
+
     return call SubSend.send(msg, len);
   }
 
@@ -69,8 +83,8 @@ implementation {
     return call Packet.maxPayloadLength();
   }
 
-  command void* AMSend.getPayload[am_id_t id](message_t* m) {
-    return call Packet.getPayload(m, NULL);
+  command void* AMSend.getPayload[am_id_t id](message_t* m, uint8_t len) {
+    return call Packet.getPayload(m, len);
   }
   
   event void SubSend.sendDone(message_t* msg, error_t result) {
@@ -85,20 +99,12 @@ implementation {
    return msg;
  }
  
-  
-  command void* Receive.getPayload[am_id_t id](message_t* m, uint8_t* len) {
-    return call Packet.getPayload(m, len);
-  }
-
-  command uint8_t Receive.payloadLength[am_id_t id](message_t* m) {
-    return call Packet.payloadLength(m);
-  }
-  
-  event message_t* SubReceive.receive(message_t* msg, void* payload, uint8_t len) {
+ event message_t* SubReceive.receive(message_t* msg, void* payload, uint8_t len) {
     return signal Receive.receive[call AMPacket.type(msg)](msg, msg->data, len);
   }
 
   command void Packet.clear(message_t* msg) {
+    memset(getHeader(msg), 0, sizeof(serial_header_t));
     return;
   }
 
@@ -115,11 +121,13 @@ implementation {
     return TOSH_DATA_LENGTH;
   }
   
-  command void* Packet.getPayload(message_t* msg, uint8_t* len) {
-    if (len != NULL) { 
-      *len = call Packet.payloadLength(msg);
+  command void* Packet.getPayload(message_t* msg, uint8_t len) {
+    if (len > call Packet.maxPayloadLength()) {
+      return NULL;
+    }
+    else {
+      return (void * COUNT_NOK(len))msg->data;
     }
-    return msg->data;
   }
 
   command am_addr_t AMPacket.address() {
@@ -128,12 +136,22 @@ implementation {
 
   command am_addr_t AMPacket.destination(message_t* amsg) {
     serial_header_t* header = getHeader(amsg);
-    return header->addr;
+    return header->dest;
+  }
+
+  command am_addr_t AMPacket.source(message_t* amsg) {
+    serial_header_t* header = getHeader(amsg);
+    return header->src;
   }
 
   command void AMPacket.setDestination(message_t* amsg, am_addr_t addr) {
     serial_header_t* header = getHeader(amsg);
-    header->addr = addr;
+    header->dest = addr;
+  }
+
+  command void AMPacket.setSource(message_t* amsg, am_addr_t addr) {
+    serial_header_t* header = getHeader(amsg);
+    header->src = addr;
   }
   
   command bool AMPacket.isForMe(message_t* amsg) {
@@ -156,7 +174,22 @@ implementation {
   async command error_t PacketAcknowledgements.noAck( message_t* msg ) {
     return SUCCESS;
   }
-   
+  
+  command void AMPacket.setGroup(message_t* msg, am_group_t group) {
+    serial_header_t* header = getHeader(msg);
+    header->group = group;
+  }
+
+  command am_group_t AMPacket.group(message_t* msg) {
+    serial_header_t* header = getHeader(msg);
+    return header->group;
+  }
+
+  command am_group_t AMPacket.localGroup() {
+    return TOS_AM_GROUP;
+  }
+
+ 
   async command bool PacketAcknowledgements.wasAcked(message_t* msg) {
     return FALSE;
   }