-/* tab:4
+/*
* "Copyright (c) 2005 Stanford University. All rights reserved.
*
* Permission to use, copy, modify, and distribute this software and
#include "CC2420.h"
-module CC2420ActiveMessageP {
+module CC2420ActiveMessageP @safe() {
provides {
interface AMSend[am_id_t id];
interface Receive[am_id_t id];
interface AMPacket;
interface Packet;
interface SendNotifier[am_id_t id];
+ interface RadioBackoff[am_id_t id];
}
uses {
interface CC2420PacketBody;
interface CC2420Config;
interface ActiveMessageAddress;
+ interface RadioBackoff as SubBackoff;
+
+ interface Resource as RadioResource;
+ interface Leds;
}
}
implementation {
+ uint16_t pending_length;
+ message_t *pending_message = NULL;
+ /***************** Resource event ****************/
+ event void RadioResource.granted() {
+ uint8_t rc;
+ cc2420_header_t* header = call CC2420PacketBody.getHeader( pending_message );
+
+ signal SendNotifier.aboutToSend[header->type](header->dest, pending_message);
+ rc = call SubSend.send( pending_message, pending_length );
+ if (rc != SUCCESS) {
+ call RadioResource.release();
+ signal AMSend.sendDone[header->type]( pending_message, rc );
+ }
+ }
- enum {
- CC2420_SIZE = MAC_HEADER_SIZE + MAC_FOOTER_SIZE,
- };
-
/***************** AMSend Commands ****************/
command error_t AMSend.send[am_id_t id](am_addr_t addr,
message_t* msg,
uint8_t len) {
cc2420_header_t* header = call CC2420PacketBody.getHeader( msg );
+
+ if (len > call Packet.maxPayloadLength()) {
+ return ESIZE;
+ }
+
header->type = id;
header->dest = addr;
header->destpan = call CC2420Config.getPanAddr();
+ header->src = call AMPacket.address();
- signal SendNotifier.aboutToSend[id](addr, msg);
-
- return call SubSend.send( msg, len + CC2420_SIZE );
+ if (call RadioResource.immediateRequest() == SUCCESS) {
+ error_t rc;
+ signal SendNotifier.aboutToSend[id](addr, msg);
+
+ rc = call SubSend.send( msg, len );
+ if (rc != SUCCESS) {
+ call RadioResource.release();
+ }
+
+ return rc;
+ } else {
+ pending_length = len;
+ pending_message = msg;
+ return call RadioResource.request();
+ }
}
command error_t AMSend.cancel[am_id_t id](message_t* msg) {
/***************** Packet Commands ****************/
command void Packet.clear(message_t* msg) {
+ memset(call CC2420PacketBody.getHeader(msg), 0x0, sizeof(cc2420_header_t));
+ memset(call CC2420PacketBody.getMetadata(msg), 0x0, sizeof(cc2420_metadata_t));
}
command uint8_t Packet.payloadLength(message_t* msg) {
}
command uint8_t Packet.maxPayloadLength() {
- return TOSH_DATA_LENGTH;
+ return call SubSend.maxPayloadLength();
}
command void* Packet.getPayload(message_t* msg, uint8_t len) {
/***************** SubSend Events ****************/
event void SubSend.sendDone(message_t* msg, error_t result) {
+ call RadioResource.release();
signal AMSend.sendDone[call AMPacket.type(msg)](msg, result);
}
/***************** SubReceive Events ****************/
event message_t* SubReceive.receive(message_t* msg, void* payload, uint8_t len) {
- if(!(call CC2420PacketBody.getMetadata(msg))->crc) {
- return msg;
- }
-
if (call AMPacket.isForMe(msg)) {
- return signal Receive.receive[call AMPacket.type(msg)](msg, payload, len - CC2420_SIZE);
+ return signal Receive.receive[call AMPacket.type(msg)](msg, payload, len);
}
else {
- return signal Snoop.receive[call AMPacket.type(msg)](msg, payload, len - CC2420_SIZE);
+ return signal Snoop.receive[call AMPacket.type(msg)](msg, payload, len);
}
}
event void CC2420Config.syncDone( error_t error ) {
}
+
+ /***************** RadioBackoff ***********************/
+
+ async event void SubBackoff.requestInitialBackoff(message_t *msg) {
+ signal RadioBackoff.requestInitialBackoff[(TCAST(cc2420_header_t* ONE,
+ (uint8_t*)msg + offsetof(message_t, data) - sizeof(cc2420_header_t)))->type](msg);
+ }
+
+ async event void SubBackoff.requestCongestionBackoff(message_t *msg) {
+ signal RadioBackoff.requestCongestionBackoff[(TCAST(cc2420_header_t* ONE,
+ (uint8_t*)msg + offsetof(message_t, data) - sizeof(cc2420_header_t)))->type](msg);
+ }
+ async event void SubBackoff.requestCca(message_t *msg) {
+ // Lower layers than this do not configure the CCA settings
+ signal RadioBackoff.requestCca[(TCAST(cc2420_header_t* ONE,
+ (uint8_t*)msg + offsetof(message_t, data) - sizeof(cc2420_header_t)))->type](msg);
+ }
+
+ async command void RadioBackoff.setInitialBackoff[am_id_t amId](uint16_t backoffTime) {
+ call SubBackoff.setInitialBackoff(backoffTime);
+ }
+
+ /**
+ * Must be called within a requestCongestionBackoff event
+ * @param backoffTime the amount of time in some unspecified units to backoff
+ */
+ async command void RadioBackoff.setCongestionBackoff[am_id_t amId](uint16_t backoffTime) {
+ call SubBackoff.setCongestionBackoff(backoffTime);
+ }
+
+
+ /**
+ * Enable CCA for the outbound packet. Must be called within a requestCca
+ * event
+ * @param ccaOn TRUE to enable CCA, which is the default.
+ */
+ async command void RadioBackoff.setCca[am_id_t amId](bool useCca) {
+ call SubBackoff.setCca(useCca);
+ }
+
/***************** Defaults ****************/
default event message_t* Receive.receive[am_id_t id](message_t* msg, void* payload, uint8_t len) {
return msg;
}
default event void AMSend.sendDone[uint8_t id](message_t* msg, error_t err) {
+ call RadioResource.release();
}
default event void SendNotifier.aboutToSend[am_id_t amId](am_addr_t addr, message_t *msg) {
}
+ default async event void RadioBackoff.requestInitialBackoff[am_id_t id](
+ message_t *msg) {
+ }
+
+ default async event void RadioBackoff.requestCongestionBackoff[am_id_t id](
+ message_t *msg) {
+ }
+
+ default async event void RadioBackoff.requestCca[am_id_t id](
+ message_t *msg) {
+ }
}