* Implemented software-based address recognition in ReceiveP.
* Applied Steve Dawson-Haggerty's patch to make the RadioBackoff interface parameterized by AM ID only at the top of the stack, whiich allows stack modifications that do not support AM ID's to exist below the active message layer.
nxle_uint8_t network;
#endif
+#ifndef TINYOS_IP
nxle_uint8_t type;
+#endif
+
} cc2420_header_t;
/**
#endif
- RadioBackoff = CsmaC;
+ RadioBackoff = AM;
Packet = AM;
AMSend = AM;
SendNotifier = AM;
AM.CC2420PacketBody -> CC2420PacketC;
AM.CC2420Config -> CC2420ControlC;
+ AM.SubBackoff -> CsmaC;
+
}
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;
}
}
implementation {
header->type = id;
header->dest = addr;
header->destpan = call CC2420Config.getPanAddr();
+ header->src = call AMPacket.address();
signal SendNotifier.aboutToSend[id](addr, msg);
event void CC2420Config.syncDone( error_t error ) {
}
+
+ /***************** RadioBackoff ***********************/
+
+ async event void SubBackoff.requestInitialBackoff(message_t *msg) {
+ signal RadioBackoff.requestInitialBackoff[((cc2420_header_t*)(msg->data -
+ sizeof(cc2420_header_t)))->type](msg);
+ }
+
+ async event void SubBackoff.requestCongestionBackoff(message_t *msg) {
+ signal RadioBackoff.requestCongestionBackoff[((cc2420_header_t*)(msg->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[((cc2420_header_t*)(msg->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 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) {
+ }
}
/**
* Write the MDMCTRL0 register
+ * Disabling hardware address recognition improves acknowledgment success
+ * rate and low power communications reliability by causing the local node
+ * to do work while the real destination node of the packet is acknowledging.
*/
void writeMdmctrl0() {
atomic {
call MDMCTRL0.write( ( 1 << CC2420_MDMCTRL0_RESERVED_FRAME_MODE ) |
- ( addressRecognition << CC2420_MDMCTRL0_ADR_DECODE ) |
+ ( 0 << CC2420_MDMCTRL0_ADR_DECODE ) |
( 2 << CC2420_MDMCTRL0_CCA_HYST ) |
( 3 << CC2420_MDMCTRL0_CCA_MOD ) |
( 1 << CC2420_MDMCTRL0_AUTOCRC ) |
provides interface SplitControl;
provides interface Send;
provides interface Receive;
- provides interface RadioBackoff[am_id_t amId];
+ provides interface RadioBackoff;
}
SplitControl = CsmaP;
Send = CsmaP;
- components CC2420ActiveMessageC;
- CsmaP.AMPacket -> CC2420ActiveMessageC;
-
components CC2420ControlC;
CsmaP.Resource -> CC2420ControlC;
CsmaP.CC2420Power -> CC2420ControlC;
provides interface SplitControl;
provides interface Send;
- provides interface RadioBackoff[am_id_t amId];
+ provides interface RadioBackoff;
uses interface Resource;
uses interface CC2420Power;
uses interface CC2420Transmit;
uses interface RadioBackoff as SubBackoff;
uses interface Random;
- uses interface AMPacket;
uses interface Leds;
uses interface CC2420Packet;
uses interface CC2420PacketBody;
( 1 << IEEE154_FCF_INTRAPAN ) |
( IEEE154_ADDR_SHORT << IEEE154_FCF_DEST_ADDR_MODE ) |
( IEEE154_ADDR_SHORT << IEEE154_FCF_SRC_ADDR_MODE ) );
- header->src = call AMPacket.address();
+
metadata->ack = FALSE;
metadata->rssi = 0;
metadata->lqi = 0;
metadata->time = 0;
ccaOn = TRUE;
- signal RadioBackoff.requestCca[((cc2420_header_t*)(m_msg->data -
- sizeof(cc2420_header_t)))->type](m_msg);
+ signal RadioBackoff.requestCca(m_msg);
+
call CC2420Transmit.send( m_msg, ccaOn );
return SUCCESS;
* Must be called within a requestInitialBackoff event
* @param backoffTime the amount of time in some unspecified units to backoff
*/
- async command void RadioBackoff.setInitialBackoff[am_id_t amId](uint16_t backoffTime) {
+ async command void RadioBackoff.setInitialBackoff(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) {
+ async command void RadioBackoff.setCongestionBackoff(uint16_t backoffTime) {
call SubBackoff.setCongestionBackoff(backoffTime);
}
* event
* @param ccaOn TRUE to enable CCA, which is the default.
*/
- async command void RadioBackoff.setCca[am_id_t amId](bool useCca) {
+ async command void RadioBackoff.setCca(bool useCca) {
ccaOn = useCca;
}
call SubBackoff.setInitialBackoff ( call Random.rand16()
% (0x1F * CC2420_BACKOFF_PERIOD) + CC2420_MIN_BACKOFF);
- signal RadioBackoff.requestInitialBackoff[((cc2420_header_t*)(msg->data -
- sizeof(cc2420_header_t)))->type](msg);
+ signal RadioBackoff.requestInitialBackoff(msg);
}
async event void SubBackoff.requestCongestionBackoff(message_t *msg) {
call SubBackoff.setCongestionBackoff( call Random.rand16()
% (0x7 * CC2420_BACKOFF_PERIOD) + CC2420_MIN_BACKOFF);
- signal RadioBackoff.requestCongestionBackoff[((cc2420_header_t*)(msg->data -
- sizeof(cc2420_header_t)))->type](msg);
+ signal RadioBackoff.requestCongestionBackoff(msg);
}
async event void SubBackoff.requestCca(message_t *msg) {
// Lower layers than this do not configure the CCA settings
+ signal RadioBackoff.requestCca(msg);
}
default event void SplitControl.stopDone(error_t error) {
}
-
- default async event void RadioBackoff.requestInitialBackoff[am_id_t amId](
- message_t *msg) {
+ default async event void RadioBackoff.requestInitialBackoff(message_t *msg) {
}
- default async event void RadioBackoff.requestCongestionBackoff[am_id_t amId](
- message_t *msg) {
+ default async event void RadioBackoff.requestCongestionBackoff(message_t *msg) {
}
- default async event void RadioBackoff.requestCca[am_id_t amId](
- message_t *msg) {
+ default async event void RadioBackoff.requestCca(message_t *msg) {
}
+
+
}
uses {
interface Send as SubSend;
interface CC2420Transmit as Resend;
- interface RadioBackoff[am_id_t amId];
+ interface RadioBackoff;
interface Receive as SubReceive;
interface AMPacket;
interface SplitControl as SubControl;
return SUCCESS;
}
- return FAIL;
+ return EBUSY;
}
command error_t Send.cancel(message_t *msg) {
/***************** RadioBackoff Events ****************/
- async event void RadioBackoff.requestInitialBackoff[am_id_t amId](message_t *msg) {
+ async event void RadioBackoff.requestInitialBackoff(message_t *msg) {
if((call CC2420PacketBody.getMetadata(msg))->rxInterval
> ONE_MESSAGE) {
- call RadioBackoff.setInitialBackoff[amId]( call Random.rand16()
+ call RadioBackoff.setInitialBackoff( call Random.rand16()
% (0x4 * CC2420_BACKOFF_PERIOD) + CC2420_MIN_BACKOFF);
}
}
- async event void RadioBackoff.requestCongestionBackoff[am_id_t amId](message_t *msg) {
+ async event void RadioBackoff.requestCongestionBackoff(message_t *msg) {
if((call CC2420PacketBody.getMetadata(msg))->rxInterval
> ONE_MESSAGE) {
- call RadioBackoff.setCongestionBackoff[amId]( call Random.rand16()
+ call RadioBackoff.setCongestionBackoff( call Random.rand16()
% (0x3 * CC2420_BACKOFF_PERIOD) + CC2420_MIN_BACKOFF);
}
}
- async event void RadioBackoff.requestCca[am_id_t amId](message_t *msg) {
+ async event void RadioBackoff.requestCca(message_t *msg) {
}
*/
#include "IEEE802154.h"
+#include "message.h"
+#include "AM.h"
module CC2420ReceiveP {
void receive();
void waitForNextPacket();
void flush();
+ bool passesAddressCheck(message_t *msg);
task void receiveDone_task();
metadata->crc = buf[ rxFrameLength ] >> 7;
metadata->lqi = buf[ rxFrameLength ] & 0x7f;
metadata->rssi = buf[ rxFrameLength - 1 ];
- m_p_rx_buf = signal Receive.receive( m_p_rx_buf, m_p_rx_buf->data,
- rxFrameLength );
-
+
+ if(passesAddressCheck(m_p_rx_buf)) {
+ m_p_rx_buf = signal Receive.receive( m_p_rx_buf, m_p_rx_buf->data,
+ rxFrameLength );
+ }
+
atomic receivingPacket = FALSE;
waitForNextPacket();
}
m_missed_packets = 0;
}
+ /**
+ * @return TRUE if the given message passes address recognition
+ */
+ bool passesAddressCheck(message_t *msg) {
+ cc2420_header_t *header = call CC2420PacketBody.getHeader( msg );
+
+ if(!(call CC2420Config.isAddressRecognitionEnabled())) {
+ return TRUE;
+ }
+
+ return (header->dest == call CC2420Config.getShortAddr());
+ }
}
projects / tinyos-2.x.git / commitdiff