{
/**
* This command is called when the message first enters the radio stack
- * via the Send.send command. This should clear the packet if the user
- * forgot to do so (or return EINVAL to be strict).
+ * via the Send.send command. This command should return TRUE if the
+ * packet is deffinitely not cleared, FALSE otherwise.
*/
- command error_t checkPacket(message_t* msg);
-
- /**
- * Returns a pointer to the ActiveMessage header field in the message
- */
- command activemessage_header_t* getHeader(message_t* msg);
+ command bool forgotToClear(message_t* msg);
/** Same as AMPacket.destination */
command am_addr_t destination(message_t* msg);
* Author: Miklos Maroti
*/
-#include <ActiveMessageLayer.h>
-
configuration ActiveMessageLayerC
{
provides
{
+ interface RadioPacket;
interface AMPacket;
+ interface Packet;
interface AMSend[am_id_t id];
interface Receive[am_id_t id];
interface Receive as Snoop[am_id_t id];
uses
{
+ interface RadioPacket as SubPacket;
interface Send as SubSend;
interface Receive as SubReceive;
interface ActiveMessageConfig as Config;
components ActiveMessageLayerP, ActiveMessageAddressC;
ActiveMessageLayerP.ActiveMessageAddress -> ActiveMessageAddressC;
+ RadioPacket = ActiveMessageLayerP;
AMPacket = ActiveMessageLayerP;
+ Packet = ActiveMessageLayerP;
AMSend = ActiveMessageLayerP;
Receive = ActiveMessageLayerP.Receive;
Snoop = ActiveMessageLayerP.Snoop;
+ SubPacket = ActiveMessageLayerP;
SubSend = ActiveMessageLayerP;
SubReceive = ActiveMessageLayerP;
Config = ActiveMessageLayerP;
* Author: Miklos Maroti
*/
+#include <ActiveMessageLayer.h>
+
module ActiveMessageLayerP
{
provides
{
+ interface RadioPacket;
interface AMPacket;
+ interface Packet;
interface AMSend[am_id_t id];
interface Receive[am_id_t id];
interface Receive as Snoop[am_id_t id];
uses
{
+ interface RadioPacket as SubPacket;
interface Send as SubSend;
interface Receive as SubReceive;
interface ActiveMessageConfig as Config;
implementation
{
+
+ activemessage_header_t* getHeader(message_t* msg)
+ {
+ return ((void*)msg) + call SubPacket.headerLength(msg);
+ }
+
/*----------------- Send -----------------*/
command error_t AMSend.send[am_id_t id](am_addr_t addr, message_t* msg, uint8_t len)
{
- error_t error;
-
- error = call Config.checkPacket(msg);
- if( error != SUCCESS )
- return error;
+ if( call Config.forgotToClear(msg) )
+ {
+ // return FAIL;
+ call Packet.clear(msg);
+ }
call AMPacket.setSource(msg, call AMPacket.address());
call AMPacket.setGroup(msg, call AMPacket.localGroup());
inline command am_id_t AMPacket.type(message_t* msg)
{
- return (call Config.getHeader(msg))->type;
+ return getHeader(msg)->type;
}
inline command void AMPacket.setType(message_t* msg, am_id_t type)
{
- (call Config.getHeader(msg))->type = type;
+ getHeader(msg)->type = type;
}
inline command am_group_t AMPacket.group(message_t* msg)
inline async event void ActiveMessageAddress.changed()
{
}
+
+/*----------------- RadioPacket -----------------*/
+
+ async command uint8_t RadioPacket.headerLength(message_t* msg)
+ {
+ return call SubPacket.headerLength(msg) + sizeof(activemessage_header_t);
+ }
+
+ async command uint8_t RadioPacket.payloadLength(message_t* msg)
+ {
+ return call SubPacket.payloadLength(msg) - sizeof(activemessage_header_t);
+ }
+
+ async command void RadioPacket.setPayloadLength(message_t* msg, uint8_t length)
+ {
+ call SubPacket.setPayloadLength(msg, length + sizeof(activemessage_header_t));
+ }
+
+ async command uint8_t RadioPacket.maxPayloadLength()
+ {
+ return call SubPacket.maxPayloadLength() - sizeof(activemessage_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 ((void*)msg) + call RadioPacket.headerLength(msg);
+ }
}
interface RadioSend;
interface RadioReceive;
interface RadioCCA;
+ interface RadioPacket;
interface DummyConfig as UnconnectedConfig;
}
uses
{
+ interface SplitControl as SubControl;
+ interface Send as SubSend;
+ interface Receive as SubReceive;
+
interface RadioState as SubState;
interface RadioSend as SubRadioSend;
interface RadioReceive as SubRadioReceive;
interface RadioCCA as SubRadioCCA;
- interface SplitControl as SubControl;
- interface Send as SubSend;
- interface Receive as SubReceive;
+ interface RadioPacket as SubPacket;
interface DummyConfig as Config;
}
RadioSend = SubRadioSend;
RadioReceive = SubRadioReceive;
RadioCCA = SubRadioCCA;
+ RadioPacket = SubPacket;
SplitControl = SubControl;
Send = SubSend;
{
*(timesync_absolute_t*)(msg->data + len) = event_time;
- call PacketTimeSyncOffset.set(msg, len);
+ call PacketTimeSyncOffset.set(msg, offsetof(message_t, data) + len);
return call SubSend.send[id](addr, msg, len + sizeof(timesync_relative_t));
}
+++ /dev/null
-/*
- * Copyright (c) 2009, Vanderbilt University
- * All rights reserved.
- *
- * Permission to use, copy, modify, and distribute this software and its
- * documentation for any purpose, without fee, and without written agreement is
- * hereby granted, provided that the above copyright notice, the following
- * two paragraphs and the author appear in all copies of this software.
- *
- * IN NO EVENT SHALL THE VANDERBILT UNIVERSITY BE LIABLE TO ANY PARTY FOR
- * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
- * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE VANDERBILT
- * UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * THE VANDERBILT UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
- * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
- * ON AN "AS IS" BASIS, AND THE VANDERBILT UNIVERSITY HAS NO OBLIGATION TO
- * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
- *
- * Author: Miklos Maroti
- */
-
-#include <IEEE154MessageLayer.h>
-
-interface IEEE154MessageConfig
-{
- /**
- * Returns a pointer to the IEEE 802.15.4 header fields in the message
- */
- async command ieee154_header_t* getHeader(message_t* msg);
-}
typedef nx_struct ieee154_header_t
{
- nxle_uint8_t length;
nxle_uint16_t fcf;
nxle_uint8_t dsn;
nxle_uint16_t destpan;
nxle_uint16_t src;
} ieee154_header_t;
-// the actual radio driver might not use this
-typedef nx_struct ieee154_footer_t
-{
- nxle_uint16_t crc;
-} ieee154_footer_t;
-
enum ieee154_fcf_enums {
IEEE154_FCF_FRAME_TYPE = 0,
IEEE154_FCF_SECURITY_ENABLED = 3,
*/
interface IEEE154MessageLayer
{
- /**
- * Returns the raw value (unadjusted) of the length field
- */
- async command uint8_t getLength(message_t* msg);
-
- /**
- * Sets the length field
- */
- async command void setLength(message_t* msg, uint8_t length);
-
/**
* Returns the frame control field. This method should not be used,
* isDataFrame and isAckFrame should be used instead.
provides
{
interface IEEE154MessageLayer;
+ interface RadioPacket;
+ interface Ieee154Packet;
+ interface Packet;
+ interface Ieee154Send;
}
uses
{
- interface IEEE154MessageConfig as Config;
+ interface RadioPacket as SubPacket;
+ interface Send as SubSend;
}
}
IEEE154MessageLayerP.ActiveMessageAddress -> ActiveMessageAddressC;
IEEE154MessageLayer = IEEE154MessageLayerP;
- Config = IEEE154MessageLayerP;
+ RadioPacket = IEEE154MessageLayerP;
+ SubPacket = IEEE154MessageLayerP;
+ Ieee154Packet = IEEE154MessageLayerP;
+ Packet = IEEE154MessageLayerP;
+ Ieee154Send = IEEE154MessageLayerP;
+ SubSend = IEEE154MessageLayerP;
}
provides
{
interface IEEE154MessageLayer;
+ interface RadioPacket;
interface Ieee154Packet;
+ interface Packet;
+ interface Ieee154Send;
}
uses
{
interface ActiveMessageAddress;
- interface IEEE154MessageConfig as Config;
+ interface RadioPacket as SubPacket;
+ interface Send as SubSend;
}
}
| (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);
- }
-
- async command uint8_t IEEE154MessageLayer.getLength(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 SubPacket.headerLength(msg);
}
async command uint16_t IEEE154MessageLayer.getFCF(message_t* msg)
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;
}
{
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);
+ call IEEE154MessageLayer.createDataFrame(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 ((void*)msg) + call RadioPacket.headerLength(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)
+ {
+ ieee154_header_t* header = getHeader(msg);
+
+ header->dest = addr;
+ header->destpan = call Ieee154Packet.localPan();
+ header->src = call Ieee154Packet.address();
+
+ // Notifier (in original ActiveMessage) --> Not used in CC2420
+ // signal SendNotifier.aboutToSend(addr, msg);
+
+ return call SubSend.send(msg, len);
+ }
+
+ event void SubSend.sendDone(message_t* msg, error_t error)
+ {
+ signal Ieee154Send.sendDone(msg, error);
+ }
+
+ default event void Ieee154Send.sendDone(message_t* msg, error_t error)
+ {
+ }
}
* Author: Miklos Maroti
*/
-#include <LowPowerListeningLayer.h>
-
interface LowPowerListeningConfig
{
- /**
- * Returns a pointer to the low power listening metadata fields in
- * the message
- */
- async command lpl_metadata_t* metadata(message_t* msg);
-
- /**
- * Clears the low power listening metadata fields in order to disable
- * low power listening for the message
- */
- async event void clear(message_t* msg);
-
/**
* Returns TRUE if an acknowledgement is requested for this message.
*/
interface SplitControl;
interface Send;
interface Receive;
+ interface RadioPacket;
interface LowPowerListening;
}
interface SplitControl as SubControl;
interface Send as SubSend;
interface Receive as SubReceive;
+ interface RadioPacket as SubPacket;
}
}
SplitControl = SubControl;
Send = SubSend;
Receive = SubReceive;
+ RadioPacket = SubPacket;
components LowPowerListeningDummyP;
LowPowerListening = LowPowerListeningDummyP;
* Author: Miklos Maroti
*/
-#include <LowPowerListeningLayer.h>
-
#warning "*** USING LOW POWER LISTENING LAYER"
configuration LowPowerListeningLayerC
interface SplitControl;
interface Send;
interface Receive;
+ interface RadioPacket;
interface LowPowerListening;
}
interface SplitControl as SubControl;
interface Send as SubSend;
interface Receive as SubReceive;
+ interface RadioPacket as SubPacket;
interface LowPowerListeningConfig as Config;
interface PacketAcknowledgements;
SplitControl = LowPowerListeningLayerP;
Send = LowPowerListeningLayerP;
Receive = LowPowerListeningLayerP;
+ RadioPacket = LowPowerListeningLayerP;
LowPowerListening = LowPowerListeningLayerP;
SubControl = LowPowerListeningLayerP;
SubSend = LowPowerListeningLayerP;
SubReceive = LowPowerListeningLayerP;
+ SubPacket = LowPowerListeningLayerP;
Config = LowPowerListeningLayerP;
PacketAcknowledgements = LowPowerListeningLayerP;
interface SplitControl;
interface Send;
interface Receive;
+ interface RadioPacket;
interface LowPowerListening;
}
interface SplitControl as SubControl;
interface Send as SubSend;
interface Receive as SubReceive;
+ interface RadioPacket as SubPacket;
interface PacketAcknowledgements;
interface LowPowerListeningConfig as Config;
/*----------------- LowPowerListening -----------------*/
+ lpl_metadata_t* getMeta(message_t* msg)
+ {
+ return ((void*)msg) + sizeof(message_t) - call RadioPacket.metadataLength(msg);
+ }
+
command uint16_t LowPowerListening.dutyCycleToSleepInterval(uint16_t dutyCycle)
{
if( dutyCycle >= 10000 )
else if( interval > MAX_SLEEP )
interval = MAX_SLEEP;
- (call Config.metadata(msg))->sleepint = interval;
+ getMeta(msg)->sleepint = interval;
}
command uint16_t LowPowerListening.getRxSleepInterval(message_t *msg)
{
- uint16_t sleepint = (call Config.metadata(msg))->sleepint;
+ uint16_t sleepint = getMeta(msg)->sleepint;
return sleepint != 0 ? sleepint : sleepInterval;
}
call LowPowerListening.getRxSleepInterval(msg));
}
- async event void Config.clear(message_t* msg)
+/*----------------- RadioPacket -----------------*/
+
+ async command uint8_t RadioPacket.headerLength(message_t* msg)
+ {
+ return call SubPacket.headerLength(msg);
+ }
+
+ async command uint8_t RadioPacket.payloadLength(message_t* msg)
+ {
+ return call SubPacket.payloadLength(msg);
+ }
+
+ async command void RadioPacket.setPayloadLength(message_t* msg, uint8_t length)
+ {
+ call SubPacket.setPayloadLength(msg, length);
+ }
+
+ async command uint8_t RadioPacket.maxPayloadLength()
+ {
+ return call SubPacket.maxPayloadLength();
+ }
+
+ async command uint8_t RadioPacket.metadataLength(message_t* msg)
+ {
+ return call SubPacket.metadataLength(msg) + sizeof(lpl_metadata_t);
+ }
+
+ async command void RadioPacket.clear(message_t* msg)
{
- (call Config.metadata(msg))->sleepint = 0;
+ getMeta(msg)->sleepint = 0;
+ call SubPacket.clear(msg);
}
}
+++ /dev/null
-/*
- * Copyright (c) 2007, Vanderbilt University
- * All rights reserved.
- *
- * Permission to use, copy, modify, and distribute this software and its
- * documentation for any purpose, without fee, and without written agreement is
- * hereby granted, provided that the above copyright notice, the following
- * two paragraphs and the author appear in all copies of this software.
- *
- * IN NO EVENT SHALL THE VANDERBILT UNIVERSITY BE LIABLE TO ANY PARTY FOR
- * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
- * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE VANDERBILT
- * UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * THE VANDERBILT UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
- * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
- * ON AN "AS IS" BASIS, AND THE VANDERBILT UNIVERSITY HAS NO OBLIGATION TO
- * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
- *
- * Author: Miklos Maroti
- */
-
-#include <LowpanNetworkLayer.h>
-
-interface LowpanNetworkConfig
-{
- /**
- * Returns a pointer to the 6LowPAN header field in the message
- */
- command lowpan_header_t* getHeader(message_t* msg);
-}
* Author: Miklos Maroti
*/
+#include <LowpanNetworkLayer.h>
+
module LowpanNetworkLayerC
{
provides
{
interface Send;
interface Receive;
+ interface RadioPacket;
interface Receive as NonTinyosReceive[uint8_t network];
}
{
interface Send as SubSend;
interface Receive as SubReceive;
- interface LowpanNetworkConfig as Config;
+ interface RadioPacket as SubPacket;
}
}
#define TINYOS_6LOWPAN_NETWORK_ID 0x3f
#endif
+ lowpan_header_t* getHeader(message_t* msg)
+ {
+ return ((void*)msg) + call SubPacket.headerLength(msg);
+ }
+
command error_t Send.send(message_t* msg, uint8_t len)
{
- (call Config.getHeader(msg))->network = TINYOS_6LOWPAN_NETWORK_ID;
+ getHeader(msg)->network = TINYOS_6LOWPAN_NETWORK_ID;
return call SubSend.send(msg, len);
}
event message_t *SubReceive.receive(message_t *msg, void *payload, uint8_t len)
{
- uint8_t network = (call Config.getHeader(msg))->network;
+ uint8_t network = getHeader(msg)->network;
if( network == TINYOS_6LOWPAN_NETWORK_ID )
return signal Receive.receive(msg, payload, len);
else
{
return msg;
}
+
+/*----------------- RadioPacket -----------------*/
+
+ async command uint8_t RadioPacket.headerLength(message_t* msg)
+ {
+ return call SubPacket.headerLength(msg) + sizeof(lowpan_header_t);
+ }
+
+ async command uint8_t RadioPacket.payloadLength(message_t* msg)
+ {
+ return call SubPacket.payloadLength(msg) - sizeof(lowpan_header_t);
+ }
+
+ async command void RadioPacket.setPayloadLength(message_t* msg, uint8_t length)
+ {
+ call SubPacket.setPayloadLength(msg, length + sizeof(lowpan_header_t));
+ }
+
+ async command uint8_t RadioPacket.maxPayloadLength()
+ {
+ return call SubPacket.maxPayloadLength() - sizeof(lowpan_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);
+ }
}
provides
{
interface PacketFlag[uint8_t bit];
+ interface RadioPacket;
}
uses
{
- interface PacketData<flags_metadata_t> as PacketFlagsMetadata;
+ interface RadioPacket as SubPacket;
}
}
implementation
{
+ flags_metadata_t* getMeta(message_t* msg)
+ {
+ return ((void*)msg) + sizeof(message_t) - call RadioPacket.metadataLength(msg);
+ }
+
+/*----------------- RadioPacket -----------------*/
+
async command bool PacketFlag.get[uint8_t bit](message_t* msg)
{
- return (call PacketFlagsMetadata.get(msg))->flags & (1<<bit);
+ return getMeta(msg)->flags & (1<<bit);
}
async command void PacketFlag.set[uint8_t bit](message_t* msg)
{
ASSERT( bit < 8 );
- (call PacketFlagsMetadata.get(msg))->flags |= (1<<bit);
+ getMeta(msg)->flags |= (1<<bit);
}
async command void PacketFlag.clear[uint8_t bit](message_t* msg)
{
ASSERT( bit < 8 );
- (call PacketFlagsMetadata.get(msg))->flags &= ~(1<<bit);
+ getMeta(msg)->flags &= ~(1<<bit);
}
async command void PacketFlag.setValue[uint8_t bit](message_t* msg, bool value)
call PacketFlag.clear[bit](msg);
}
- async event void PacketFlagsMetadata.clear(message_t* msg)
+/*----------------- RadioPacket -----------------*/
+
+ async command uint8_t RadioPacket.headerLength(message_t* msg)
+ {
+ return call SubPacket.headerLength(msg);
+ }
+
+ async command uint8_t RadioPacket.payloadLength(message_t* msg)
+ {
+ return call SubPacket.payloadLength(msg);
+ }
+
+ async command void RadioPacket.setPayloadLength(message_t* msg, uint8_t length)
+ {
+ call SubPacket.setPayloadLength(msg, length);
+ }
+
+ async command uint8_t RadioPacket.maxPayloadLength()
+ {
+ return call SubPacket.maxPayloadLength();
+ }
+
+ async command uint8_t RadioPacket.metadataLength(message_t* msg)
+ {
+ return call SubPacket.metadataLength(msg) + sizeof(flags_metadata_t);
+ }
+
+ async command void RadioPacket.clear(message_t* msg)
{
- (call PacketFlagsMetadata.get(msg))->flags = 0;
+ getMeta(msg)->flags = 0;
+ call SubPacket.clear(msg);
}
}
provides {
interface Send;
interface PacketLink;
+ interface RadioPacket;
}
uses {
interface Send as SubSend;
- interface PacketData<link_metadata_t> as PacketLinkMetadata;
+ interface RadioPacket as SubPacket;
interface PacketAcknowledgements;
}
}
components PacketLinkLayerP, new TimerMilliC() as DelayTimerC;
PacketLink = PacketLinkLayerP;
- Send = PacketLinkLayerP.Send;
- SubSend = PacketLinkLayerP.SubSend;
+ Send = PacketLinkLayerP;
+ SubSend = PacketLinkLayerP;
PacketAcknowledgements = PacketLinkLayerP;
- PacketLinkMetadata = PacketLinkLayerP;
+ RadioPacket = PacketLinkLayerP;
+ SubPacket = PacketLinkLayerP;
PacketLinkLayerP.DelayTimer -> DelayTimerC;
}
provides {
interface Send;
interface PacketLink;
+ interface RadioPacket;
}
uses {
interface Send as SubSend;
interface PacketAcknowledgements;
interface Timer<TMilli> as DelayTimer;
- interface PacketData<link_metadata_t> as PacketLinkMetadata;
+ interface RadioPacket as SubPacket;
}
}
/***************** PacketLink Commands ***************/
+
+ link_metadata_t* getMeta(message_t* msg) {
+ return ((void*)msg) + sizeof(message_t) - call RadioPacket.metadataLength(msg);
+ }
+
/**
* Set the maximum number of times attempt message delivery
* Default is 0
* the message
*/
command void PacketLink.setRetries(message_t *msg, uint16_t maxRetries) {
- (call PacketLinkMetadata.get(msg))->maxRetries = maxRetries;
+ getMeta(msg)->maxRetries = maxRetries;
}
/**
* @param retryDelay the delay betweeen retry attempts, in milliseconds
*/
command void PacketLink.setRetryDelay(message_t *msg, uint16_t retryDelay) {
- (call PacketLinkMetadata.get(msg))->retryDelay = retryDelay;
+ getMeta(msg)->retryDelay = retryDelay;
}
/**
* @return the maximum number of retry attempts for this message
*/
command uint16_t PacketLink.getRetries(message_t *msg) {
- return (call PacketLinkMetadata.get(msg))->maxRetries;
+ return getMeta(msg)->maxRetries;
}
/**
* @return the delay between retry attempts in ms for this message
*/
command uint16_t PacketLink.getRetryDelay(message_t *msg) {
- return (call PacketLinkMetadata.get(msg))->retryDelay;
+ return getMeta(msg)->retryDelay;
}
/**
return call PacketAcknowledgements.wasAcked(msg);
}
- async event void PacketLinkMetadata.clear(message_t* msg) {
- (call PacketLinkMetadata.get(msg))->maxRetries = 0;
- }
-
/***************** Send Commands ***************/
/**
* Each call to this send command gives the message a single
call PacketLink.setRetries(msg, totalRetries);
signal Send.sendDone(msg, error);
}
+
+ /***************** Functions ***************/
+ async command uint8_t RadioPacket.headerLength(message_t* msg) {
+ return call SubPacket.headerLength(msg);
+ }
+
+ async command uint8_t RadioPacket.payloadLength(message_t* msg) {
+ return call SubPacket.payloadLength(msg);
+ }
+
+ async command void RadioPacket.setPayloadLength(message_t* msg, uint8_t length) {
+ call SubPacket.setPayloadLength(msg, length);
+ }
+
+ async command uint8_t RadioPacket.maxPayloadLength() {
+ return call SubPacket.maxPayloadLength();
+ }
+
+ async command uint8_t RadioPacket.metadataLength(message_t* msg) {
+ return call SubPacket.metadataLength(msg) + sizeof(link_metadata_t);
+ }
+
+ async command void RadioPacket.clear(message_t* msg) {
+ getMeta(msg)->maxRetries = 0;
+ call SubPacket.clear(msg);
+ }
}
{
interface RadioSend;
interface RadioReceive;
+
interface PacketAcknowledgements;
}
+
uses
{
interface RadioSend as SubSend;
interface RadioReceive;
interface PacketAcknowledgements;
}
+
uses
{
interface RadioSend as SubSend;
{
interface PacketTimeStamp<TMilli, uint32_t> as PacketTimeStampMilli;
interface PacketTimeStamp<TRadio, uint32_t> as PacketTimeStampRadio;
+ interface RadioPacket;
}
uses
{
interface LocalTime<TRadio> as LocalTimeRadio;
- interface PacketData<timestamp_metadata_t> as PacketTimeStampMetadata;
+ interface RadioPacket as SubPacket;
}
}
PacketTimeStampMilli = TimeStampingLayerP;
PacketTimeStampRadio = TimeStampingLayerP;
- PacketTimeStampMetadata = TimeStampingLayerP.PacketTimeStampMetadata;
+ RadioPacket = TimeStampingLayerP.RadioPacket;
+ SubPacket = TimeStampingLayerP.SubPacket;
LocalTimeRadio = TimeStampingLayerP;
TimeStampingLayerP.LocalTimeMilli -> LocalTimeMilliC;
{
interface PacketTimeStamp<TMilli, uint32_t> as PacketTimeStampMilli;
interface PacketTimeStamp<TRadio, uint32_t> as PacketTimeStampRadio;
+ interface RadioPacket;
}
uses
interface LocalTime<TRadio> as LocalTimeRadio;
interface LocalTime<TMilli> as LocalTimeMilli;
- interface PacketData<timestamp_metadata_t> as PacketTimeStampMetadata;
+ interface RadioPacket as SubPacket;
}
}
implementation
{
+ timestamp_metadata_t* getMeta(message_t* msg)
+ {
+ return ((void*)msg) + sizeof(message_t) - call RadioPacket.metadataLength(msg);
+ }
+
+/*----------------- PacketTimeStampRadio -----------------*/
+
async command bool PacketTimeStampRadio.isValid(message_t* msg)
{
return call TimeStampFlag.get(msg);
async command uint32_t PacketTimeStampRadio.timestamp(message_t* msg)
{
- return (call PacketTimeStampMetadata.get(msg))->timestamp;
+ return getMeta(msg)->timestamp;
}
async command void PacketTimeStampRadio.clear(message_t* msg)
async command void PacketTimeStampRadio.set(message_t* msg, uint32_t value)
{
call TimeStampFlag.set(msg);
- (call PacketTimeStampMetadata.get(msg))->timestamp = value;
+ getMeta(msg)->timestamp = value;
}
- async event void PacketTimeStampMetadata.clear(message_t* msg)
- {
- }
+/*----------------- PacketTimeStampMilli -----------------*/
async command bool PacketTimeStampMilli.isValid(message_t* msg)
{
call PacketTimeStampRadio.set(msg, offset + call LocalTimeRadio.get());
}
+
+/*----------------- RadioPacket -----------------*/
+
+ async command uint8_t RadioPacket.headerLength(message_t* msg)
+ {
+ return call SubPacket.headerLength(msg);
+ }
+
+ async command uint8_t RadioPacket.payloadLength(message_t* msg)
+ {
+ return call SubPacket.payloadLength(msg);
+ }
+
+ async command void RadioPacket.setPayloadLength(message_t* msg, uint8_t length)
+ {
+ call SubPacket.setPayloadLength(msg, length);
+ }
+
+ async command uint8_t RadioPacket.maxPayloadLength()
+ {
+ return call SubPacket.maxPayloadLength();
+ }
+
+ async command uint8_t RadioPacket.metadataLength(message_t* msg)
+ {
+ return call SubPacket.metadataLength(msg) + sizeof(timestamp_metadata_t);
+ }
+
+ async command void RadioPacket.clear(message_t* msg)
+ {
+ // all flags are automatically cleared
+ call SubPacket.clear(msg);
+ }
}
typedef nx_struct rf212packet_header_t
{
+ rf212_header_t rf212;
ieee154_header_t ieee154;
#ifndef TFRAMES_ENABLED
lowpan_header_t lowpan;
typedef struct rf212packet_metadata_t
{
- flags_metadata_t flags;
- rf212_metadata_t rf212;
- timestamp_metadata_t timestamp;
#ifdef LOW_POWER_LISTENING
lpl_metadata_t lpl;
#endif
#ifdef PACKET_LINK
link_metadata_t link;
#endif
+ timestamp_metadata_t timestamp;
+ flags_metadata_t flags;
+ rf212_metadata_t rf212;
} rf212packet_metadata_t;
#endif//__RF212ACTIVEMESSAGE_H__
RF212ActiveMessageP.IEEE154MessageLayer -> IEEE154MessageLayerC;
RF212ActiveMessageP.RadioAlarm -> RadioAlarmC.RadioAlarm[unique("RadioAlarm")];
RF212ActiveMessageP.PacketTimeStamp -> TimeStampingLayerC;
- Packet = RF212ActiveMessageP;
+ RF212ActiveMessageP.ActiveMessagePacket -> ActiveMessageLayerC;
+ RF212ActiveMessageP.RF212Packet -> RF212DriverLayerC;
// -------- Active Message
ActiveMessageLayerC.Config -> RF212ActiveMessageP;
ActiveMessageLayerC.SubSend -> LowpanNetworkLayerC;
ActiveMessageLayerC.SubReceive -> LowpanNetworkLayerC;
+ ActiveMessageLayerC.SubPacket ->LowpanNetworkLayerC;
AMSend = ActiveMessageLayerC;
+ Packet = ActiveMessageLayerC;
Receive = ActiveMessageLayerC.Receive;
Snoop = ActiveMessageLayerC.Snoop;
AMPacket = ActiveMessageLayerC;
components new DummyLayerC() as LowpanNetworkLayerC;
#else
components LowpanNetworkLayerC;
- LowpanNetworkLayerC.Config -> RF212ActiveMessageP;
#endif
LowpanNetworkLayerC.SubSend -> UniqueLayerC;
LowpanNetworkLayerC.SubReceive -> LowPowerListeningLayerC;
+ LowpanNetworkLayerC.SubPacket -> IEEE154MessageLayerC;
-// -------- IEEE154 Packet
+// -------- IEEE154 Message
components IEEE154MessageLayerC;
- IEEE154MessageLayerC.Config -> RF212ActiveMessageP;
+ IEEE154MessageLayerC.SubPacket -> LowPowerListeningLayerC;
// -------- UniqueLayer Send part (wired twice)
LowPowerListeningLayerC.SubControl -> MessageBufferLayerC;
LowPowerListeningLayerC.SubSend -> PacketLinkLayerC;
LowPowerListeningLayerC.SubReceive -> MessageBufferLayerC;
+ LowPowerListeningLayerC.SubPacket -> PacketLinkLayerC;
SplitControl = LowPowerListeningLayerC;
LowPowerListening = LowPowerListeningLayerC;
#ifdef PACKET_LINK
components PacketLinkLayerC;
PacketLink = PacketLinkLayerC;
- PacketLinkLayerC.PacketLinkMetadata -> RF212ActiveMessageP;
PacketLinkLayerC.PacketAcknowledgements -> SoftwareAckLayerC;
#else
components new DummyLayerC() as PacketLinkLayerC;
#endif
PacketLinkLayerC.SubSend -> MessageBufferLayerC;
+ PacketLinkLayerC.SubPacket -> TimeStampingLayerC;
// -------- MessageBuffer
components MessageBufferLayerC;
- MessageBufferLayerC.Packet -> RF212ActiveMessageP;
+ MessageBufferLayerC.Packet -> ActiveMessageLayerC;
MessageBufferLayerC.RadioSend -> TrafficMonitorLayerC;
MessageBufferLayerC.RadioReceive -> UniqueLayerC;
MessageBufferLayerC.RadioState -> TrafficMonitorLayerC;
CsmaLayerC -> RF212DriverLayerC.RadioSend;
CsmaLayerC -> RF212DriverLayerC.RadioCCA;
+// -------- TimeStamping
+
+ components TimeStampingLayerC;
+ TimeStampingLayerC.LocalTimeRadio -> RF212DriverLayerC;
+ TimeStampingLayerC.SubPacket -> MetadataFlagsLayerC;
+ PacketTimeStampRadio = TimeStampingLayerC;
+ PacketTimeStampMilli = TimeStampingLayerC;
+
+// -------- MetadataFlags
+
+ components MetadataFlagsLayerC;
+ MetadataFlagsLayerC.SubPacket -> RF212DriverLayerC;
+
// -------- RF212 Driver
components RF212DriverLayerC;
- RF212DriverLayerC.PacketRF212Metadata -> RF212ActiveMessageP;
- RF212DriverLayerC.RF212DriverConfig -> RF212ActiveMessageP;
+ RF212DriverLayerC.Config -> RF212ActiveMessageP;
RF212DriverLayerC.PacketTimeStamp -> TimeStampingLayerC;
PacketTransmitPower = RF212DriverLayerC.PacketTransmitPower;
PacketLinkQuality = RF212DriverLayerC.PacketLinkQuality;
PacketRSSI = RF212DriverLayerC.PacketRSSI;
LocalTimeRadio = RF212DriverLayerC;
-
-// -------- MetadataFlags
-
- components MetadataFlagsLayerC;
- MetadataFlagsLayerC.PacketFlagsMetadata -> RF212ActiveMessageP;
-
-// -------- TimeStamping
-
- components TimeStampingLayerC;
- TimeStampingLayerC.LocalTimeRadio -> RF212DriverLayerC;
- TimeStampingLayerC.PacketTimeStampMetadata -> RF212ActiveMessageP;
- PacketTimeStampRadio = TimeStampingLayerC;
- PacketTimeStampMilli = TimeStampingLayerC;
}
interface RandomCollisionConfig;
interface SlottedCollisionConfig;
interface ActiveMessageConfig;
- interface LowpanNetworkConfig;
- interface IEEE154MessageConfig;
interface DummyConfig;
- interface Packet;
-
- interface PacketData<flags_metadata_t> as PacketFlagsMetadata;
- interface PacketData<rf212_metadata_t> as PacketRF212Metadata;
- interface PacketData<timestamp_metadata_t> as PacketTimeStampMetadata;
-
#ifdef LOW_POWER_LISTENING
interface LowPowerListeningConfig;
-#endif
-#ifdef PACKET_LINK
- interface PacketData<link_metadata_t> as PacketLinkMetadata;
#endif
}
{
interface IEEE154MessageLayer;
interface RadioAlarm;
+ interface RadioPacket as ActiveMessagePacket;
+ interface RadioPacket as RF212Packet;
interface PacketTimeStamp<TRadio, uint32_t>;
}
implementation
{
- rf212packet_header_t* getHeader(message_t* msg)
- {
- return (rf212packet_header_t*)(msg->data - sizeof(rf212packet_header_t));
- }
-
- rf212packet_metadata_t* getMeta(message_t* msg)
- {
- return (rf212packet_metadata_t*)(msg->metadata);
- }
/*----------------- RF212DriverConfig -----------------*/
- async command uint8_t RF212DriverConfig.getLength(message_t* msg)
+ async command uint8_t RF212DriverConfig.headerLength(message_t* msg)
{
- return call IEEE154MessageLayer.getLength(msg);
+ return offsetof(message_t, data) - sizeof(rf212packet_header_t);
}
- async command void RF212DriverConfig.setLength(message_t* msg, uint8_t len)
+ async command uint8_t RF212DriverConfig.maxPayloadLength()
{
- call IEEE154MessageLayer.setLength(msg, len);
+ return sizeof(rf212packet_header_t) + TOSH_DATA_LENGTH;
}
- async command uint8_t* RF212DriverConfig.getPayload(message_t* msg)
+ async command uint8_t RF212DriverConfig.metadataLength(message_t* msg)
{
- return ((uint8_t*)(call IEEE154MessageConfig.getHeader(msg))) + 1;
+ return 0;
}
- async command uint8_t RF212DriverConfig.getHeaderLength()
+ async command uint8_t RF212DriverConfig.headerPreloadLength()
{
// we need the fcf, dsn, destpan and dest
return 7;
}
- async command uint8_t RF212DriverConfig.getMaxLength()
- {
- // note, that the ieee154_footer_t is not stored, but we should include it here
- return sizeof(rf212packet_header_t) - 1 + TOSH_DATA_LENGTH + sizeof(ieee154_footer_t);
- }
-
async command bool RF212DriverConfig.requiresRssiCca(message_t* msg)
{
return call IEEE154MessageLayer.isDataFrame(msg);
/*----------------- ActiveMessageConfig -----------------*/
- command error_t ActiveMessageConfig.checkPacket(message_t* msg)
- {
- // the user forgot to call clear, we should return EINVAL
- if( ! call IEEE154MessageLayer.isDataFrame(msg) )
- call Packet.clear(msg);
-
- return SUCCESS;
- }
-
- command activemessage_header_t* ActiveMessageConfig.getHeader(message_t* msg)
+ command bool ActiveMessageConfig.forgotToClear(message_t* msg)
{
- return &(getHeader(msg)->am);
+ return ! call IEEE154MessageLayer.isDataFrame(msg);
}
command am_addr_t ActiveMessageConfig.destination(message_t* msg)
* ack required: 8-16 byte separation, 11 bytes airtime, 5-10 bytes separation
*/
- uint8_t len = call IEEE154MessageLayer.getLength(msg);
+ uint8_t len = call RF212Packet.payloadLength(msg);
return call IEEE154MessageLayer.getAckRequired(msg) ? len + 6 + 16 + 11 + 10 : len + 6 + 10;
}
{
}
-/*----------------- LowpanNetwork -----------------*/
-
- command lowpan_header_t* LowpanNetworkConfig.getHeader(message_t* msg)
- {
- return &(getHeader(msg)->lowpan);
- }
-
-/*----------------- IEEE154Message -----------------*/
-
- async command ieee154_header_t* IEEE154MessageConfig.getHeader(message_t* msg)
- {
- return &(getHeader(msg)->ieee154);
- }
-
/*----------------- LowPowerListening -----------------*/
#ifdef LOW_POWER_LISTENING
- async command lpl_metadata_t* LowPowerListeningConfig.metadata(message_t* msg)
- {
- return &(getMeta(msg)->lpl);
- }
-
async command bool LowPowerListeningConfig.getAckRequired(message_t* msg)
{
return call IEEE154MessageLayer.getAckRequired(msg);
#endif
-/*----------------- Headers and Metadata -----------------*/
-
- async command flags_metadata_t* PacketFlagsMetadata.get(message_t* msg)
- {
- return &(getMeta(msg)->flags);
- }
-
- async command rf212_metadata_t* PacketRF212Metadata.get(message_t* msg)
- {
- return &(getMeta(msg)->rf212);
- }
-
- async command timestamp_metadata_t* PacketTimeStampMetadata.get(message_t* msg)
- {
- return &(getMeta(msg)->timestamp);
- }
-
-#ifdef PACKET_LINK
- async command link_metadata_t* PacketLinkMetadata.get(message_t* msg)
- {
- return &(getMeta(msg)->link);
- }
-#endif
-
-/*----------------- Packet -----------------*/
-
- enum
- {
- PACKET_LENGTH_INCREASE =
- sizeof(rf212packet_header_t) - 1 // the 8-bit length field is not counted
- + sizeof(ieee154_footer_t), // the CRC is not stored in memory
- };
-
- command void Packet.clear(message_t* msg)
- {
- signal PacketFlagsMetadata.clear(msg);
- signal PacketRF212Metadata.clear(msg);
- signal PacketTimeStampMetadata.clear(msg);
-#ifdef LOW_POWER_LISTENING
- signal LowPowerListeningConfig.clear(msg);
-#endif
-#ifdef PACKET_LINK
- signal PacketLinkMetadata.clear(msg);
-#endif
- call IEEE154MessageLayer.createDataFrame(msg);
- }
-
- command void Packet.setPayloadLength(message_t* msg, uint8_t len)
- {
- call IEEE154MessageLayer.setLength(msg, len + PACKET_LENGTH_INCREASE);
- }
-
- command uint8_t Packet.payloadLength(message_t* msg)
- {
- return call IEEE154MessageLayer.getLength(msg) - PACKET_LENGTH_INCREASE;
- }
-
- command uint8_t Packet.maxPayloadLength()
- {
- return TOSH_DATA_LENGTH;
- }
-
- command void* Packet.getPayload(message_t* msg, uint8_t len)
- {
- if( len > TOSH_DATA_LENGTH )
- return NULL;
-
- return msg->data;
- }
}
* Author: Miklos Maroti
*/
-/**
- * This interface needs to be implemented by the MAC to control the behaviour
- * of the RF212DriverLayerC component.
- */
interface RF212DriverConfig
{
/**
- * Returns the length of the PHY payload (including the FCF field).
- * This value must be in the range [3, 127].
+ * Returns the length of a dummy header to align the payload properly.
*/
- async command uint8_t getLength(message_t* msg);
+ async command uint8_t headerLength(message_t* msg);
/**
- * Sets the length of the PHY payload.
+ * Returns the maximum length of the PHY payload including the
+ * length field but not counting the FCF field.
*/
- async command void setLength(message_t* msg, uint8_t len);
+ async command uint8_t maxPayloadLength();
/**
- * Returns a pointer to the start of the PHY payload that contains
- * getLength()-2 number of bytes. The FCF field (CRC-16) is not stored,
- * but automatically appended / verified.
+ * Returns the length of a dummy metadata section to align the
+ * metadata section properly.
*/
- async command uint8_t* getPayload(message_t* msg);
+ async command uint8_t metadataLength(message_t* msg);
/**
* Gets the number of bytes we should read before the RadioReceive.header
* event is fired. If the length of the packet is less than this amount,
* then that event is fired earlier. The header length must be at least one.
*/
- async command uint8_t getHeaderLength();
-
- /**
- * Returns the maximum PHY length that can be set via the setLength command
- */
- async command uint8_t getMaxLength();
+ async command uint8_t headerPreloadLength();
/**
* Returns TRUE if before sending this message we should make sure that
#ifndef __RF212DRIVERLAYER_H__
#define __RF212DRIVERLAYER_H__
+typedef nx_struct rf212_header_t
+{
+ nxle_uint8_t length;
+} rf212_header_t;
+
typedef struct rf212_metadata_t
{
uint8_t lqi;
/*
- * Copyright (c) 2009, Vanderbilt University
+ * Copyright (c) 2007, Vanderbilt University
* All rights reserved.
*
* Permission to use, copy, modify, and distribute this software and its
interface RadioSend;
interface RadioReceive;
interface RadioCCA;
+ interface RadioPacket;
interface PacketField<uint8_t> as PacketTransmitPower;
interface PacketField<uint8_t> as PacketRSSI;
uses
{
- interface RF212DriverConfig;
+ interface RF212DriverConfig as Config;
interface PacketTimeStamp<TRadio, uint32_t>;
- interface PacketData<rf212_metadata_t> as PacketRF212Metadata;
}
}
RadioSend = RF212DriverLayerP;
RadioReceive = RF212DriverLayerP;
RadioCCA = RF212DriverLayerP;
+ RadioPacket = RF212DriverLayerP;
LocalTimeRadio = HplRF212C;
- RF212DriverConfig = RF212DriverLayerP;
- PacketRF212Metadata = RF212DriverLayerP;
+ Config = RF212DriverLayerP;
PacketTransmitPower = RF212DriverLayerP.PacketTransmitPower;
components new MetadataFlagC() as TransmitPowerFlagC;
interface RadioSend;
interface RadioReceive;
interface RadioCCA;
+ interface RadioPacket;
interface PacketField<uint8_t> as PacketTransmitPower;
interface PacketField<uint8_t> as PacketRSSI;
interface BusyWait<TMicro, uint16_t>;
interface LocalTime<TRadio>;
- interface RF212DriverConfig;
+ interface RF212DriverConfig as Config;
- interface PacketData<rf212_metadata_t> as PacketRF212Metadata;
interface PacketFlag as TransmitPowerFlag;
interface PacketFlag as RSSIFlag;
interface PacketFlag as TimeSyncFlag;
implementation
{
+ rf212_header_t* getHeader(message_t* msg)
+ {
+ return ((void*)msg) + call Config.headerLength(msg);
+ }
+
+ void* getPayload(message_t* msg)
+ {
+ return ((void*)msg) + call RadioPacket.headerLength(msg);
+ }
+
+ rf212_metadata_t* getMeta(message_t* msg)
+ {
+ return ((void*)msg) + sizeof(message_t) - call RadioPacket.metadataLength(msg);
+ }
+
/*----------------- STATE -----------------*/
tasklet_norace uint8_t state;
writeRegister(RF212_PHY_TX_PWR, txPower);
}
- if( call RF212DriverConfig.requiresRssiCca(msg)
+ if( call Config.requiresRssiCca(msg)
&& (readRegister(RF212_PHY_RSSI) & RF212_RSSI_MASK) > ((rssiClear + rssiBusy) >> 3) )
return EBUSY;
// do something useful, just to wait a little
time32 = call LocalTime.get();
- timesync = call PacketTimeSyncOffset.isSet(msg) ? msg->data + call PacketTimeSyncOffset.get(msg) : 0;
+ timesync = call PacketTimeSyncOffset.isSet(msg) ? ((void*)msg) + call PacketTimeSyncOffset.get(msg) : 0;
// we have missed an incoming message in this short amount of time
if( (readRegister(RF212_TRX_STATUS) & RF212_TRX_STATUS_MASK) != RF212_PLL_ON )
call SELN.clr();
call FastSpiByte.splitWrite(RF212_CMD_FRAME_WRITE);
- length = call RF212DriverConfig.getLength(msg);
- data = call RF212DriverConfig.getPayload(msg);
+ data = getPayload(msg);
+ length = getHeader(msg)->length;
// length | data[0] ... data[length-3] | automatically generated FCS
call FastSpiByte.splitReadWrite(length);
// the FCS is atomatically generated (2 bytes)
length -= 2;
- header = call RF212DriverConfig.getHeaderLength();
+ header = call Config.headerPreloadLength();
if( header > length )
header = length;
#ifdef RADIO_DEBUG_MESSAGES
if( call DiagMsg.record() )
{
- length = call RF212DriverConfig.getLength(msg);
+ length = getHeader(msg)->length;
call DiagMsg.str("tx");
call DiagMsg.uint16(time);
call DiagMsg.uint8(length);
- call DiagMsg.hex8s(data, length - 2);
+ call DiagMsg.hex8s(getPayload(msg), length - 2);
call DiagMsg.send();
}
#endif
length = call FastSpiByte.write(0);
// if correct length
- if( length >= 3 && length <= call RF212DriverConfig.getMaxLength() )
+ if( length >= 3 && length <= call RadioPacket.maxPayloadLength() + 2 )
{
uint8_t read;
uint8_t* data;
// initiate the reading
call FastSpiByte.splitWrite(0);
- call RF212DriverConfig.setLength(rxMsg, length);
- data = call RF212DriverConfig.getPayload(rxMsg);
+ data = getPayload(rxMsg);
+ getHeader(rxMsg)->length = length;
crc = 0;
// we do not store the CRC field
length -= 2;
- read = call RF212DriverConfig.getHeaderLength();
+ read = call Config.headerPreloadLength();
if( length < read )
read = length;
#ifdef RADIO_DEBUG_MESSAGES
if( call DiagMsg.record() )
{
- length = call RF212DriverConfig.getLength(rxMsg);
+ length = getHeader(rxMsg)->length;
call DiagMsg.str("rx");
call DiagMsg.uint32(call PacketTimeStamp.isValid(rxMsg) ? call PacketTimeStamp.timestamp(rxMsg) : 0);
call DiagMsg.uint16(call RadioAlarm.getNow());
- call DiagMsg.uint8(crc == 0);
+ call DiagMsg.uint8(crc != 0);
call DiagMsg.uint8(length);
- call DiagMsg.hex8s(call RF212DriverConfig.getPayload(rxMsg), length - 2);
+ call DiagMsg.hex8s(getPayload(rxMsg), length - 2);
call DiagMsg.send();
}
#endif
call SpiResource.release();
}
-/*----------------- PACKET -----------------*/
+/*----------------- RadioPacket -----------------*/
+
+ async command uint8_t RadioPacket.headerLength(message_t* msg)
+ {
+ return call Config.headerLength(msg) + sizeof(rf212_header_t);
+ }
+
+ async command uint8_t RadioPacket.payloadLength(message_t* msg)
+ {
+ return getHeader(msg)->length - 2;
+ }
+
+ async command void RadioPacket.setPayloadLength(message_t* msg, uint8_t length)
+ {
+ ASSERT( 1 <= length && length <= 125 );
+ ASSERT( call RadioPacket.headerLength(msg) + length + call RadioPacket.metadataLength(msg) <= sizeof(message_t) );
+
+ // we add the length of the CRC, which is automatically generated
+ getHeader(msg)->length = length + 2;
+ }
- async event void PacketRF212Metadata.clear(message_t* msg)
+ async command uint8_t RadioPacket.maxPayloadLength()
{
+ ASSERT( call Config.maxPayloadLength() <= 125 );
+
+ return call Config.maxPayloadLength() - sizeof(rf212_header_t);
}
-// --- TransmitPower
+ async command uint8_t RadioPacket.metadataLength(message_t* msg)
+ {
+ return call Config.metadataLength(msg) + sizeof(rf212_metadata_t);
+ }
+
+ async command void RadioPacket.clear(message_t* msg)
+ {
+ // all flags are automatically cleared
+ }
+
+/*----------------- PacketTransmitPower -----------------*/
async command bool PacketTransmitPower.isSet(message_t* msg)
{
async command uint8_t PacketTransmitPower.get(message_t* msg)
{
- return (call PacketRF212Metadata.get(msg))->power;
+ return getMeta(msg)->power;
}
async command void PacketTransmitPower.clear(message_t* msg)
async command void PacketTransmitPower.set(message_t* msg, uint8_t value)
{
call TransmitPowerFlag.set(msg);
- (call PacketRF212Metadata.get(msg))->power = value;
+ getMeta(msg)->power = value;
}
-// --- RSSI
+/*----------------- PacketRSSI -----------------*/
async command bool PacketRSSI.isSet(message_t* msg)
{
async command uint8_t PacketRSSI.get(message_t* msg)
{
- return (call PacketRF212Metadata.get(msg))->rssi;
+ return getMeta(msg)->rssi;
}
async command void PacketRSSI.clear(message_t* msg)
call TransmitPowerFlag.clear(msg);
call RSSIFlag.set(msg);
- (call PacketRF212Metadata.get(msg))->rssi = value;
+ getMeta(msg)->rssi = value;
}
-// --- TimeSyncOffset
-
- enum
- {
- PACKET_LENGTH_INCREASE =
- sizeof(rf212packet_header_t) - 1 // the 8-bit length field is not counted
- + sizeof(ieee154_footer_t), // the CRC is not stored in memory
- };
+/*----------------- PacketTimeSyncOffset -----------------*/
async command bool PacketTimeSyncOffset.isSet(message_t* msg)
{
async command uint8_t PacketTimeSyncOffset.get(message_t* msg)
{
- return call RF212DriverConfig.getLength(msg) - PACKET_LENGTH_INCREASE - sizeof(timesync_absolute_t);
+ return call RadioPacket.headerLength(msg) + call RadioPacket.payloadLength(msg) - sizeof(timesync_absolute_t);
}
async command void PacketTimeSyncOffset.clear(message_t* msg)
async command void PacketTimeSyncOffset.set(message_t* msg, uint8_t value)
{
// we do not store the value, the time sync field is always the last 4 bytes
- ASSERT( call RF212DriverConfig.getLength(msg) - PACKET_LENGTH_INCREASE - sizeof(timesync_absolute_t) == value );
+ ASSERT( call PacketTimeSyncOffset.get(msg) == value );
call TimeSyncFlag.set(msg);
}
-// --- LinkQuality
+/*----------------- PacketLinkQuality -----------------*/
async command bool PacketLinkQuality.isSet(message_t* msg)
{
async command uint8_t PacketLinkQuality.get(message_t* msg)
{
- return (call PacketRF212Metadata.get(msg))->lqi;
+ return getMeta(msg)->lqi;
}
async command void PacketLinkQuality.clear(message_t* msg)
async command void PacketLinkQuality.set(message_t* msg, uint8_t value)
{
- (call PacketRF212Metadata.get(msg))->lqi = value;
+ getMeta(msg)->lqi = value;
}
}
--- /dev/null
+/*
+ * Copyright (c) 2007, Vanderbilt University
+ * All rights reserved.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation for any purpose, without fee, and without written agreement is
+ * hereby granted, provided that the above copyright notice, the following
+ * two paragraphs and the author appear in all copies of this software.
+ *
+ * IN NO EVENT SHALL THE VANDERBILT UNIVERSITY BE LIABLE TO ANY PARTY FOR
+ * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
+ * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE VANDERBILT
+ * UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * THE VANDERBILT UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
+ * ON AN "AS IS" BASIS, AND THE VANDERBILT UNIVERSITY HAS NO OBLIGATION TO
+ * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+ *
+ * Author: Miklos Maroti
+ */
+
+#include <RadioConfig.h>
+
+configuration RF212Ieee154MessageC
+{
+ provides
+ {
+ interface SplitControl;
+
+ interface Ieee154Send;
+ interface Receive as Ieee154Receive;
+ interface Ieee154Packet;
+ interface Packet;
+ interface PacketAcknowledgements;
+ interface LowPowerListening;
+ interface PacketLink;
+
+ interface RadioChannel;
+
+ interface PacketField<uint8_t> as PacketLinkQuality;
+ interface PacketField<uint8_t> as PacketTransmitPower;
+ interface PacketField<uint8_t> as PacketRSSI;
+
+ interface LocalTime<TRadio> as LocalTimeRadio;
+ interface PacketTimeStamp<TRadio, uint32_t> as PacketTimeStampRadio;
+ interface PacketTimeStamp<TMilli, uint32_t> as PacketTimeStampMilli;
+ }
+}
+
+implementation
+{
+ components RF212ActiveMessageP, RadioAlarmC;
+
+#ifdef RADIO_DEBUG
+ components AssertC;
+#endif
+
+ RF212ActiveMessageP.IEEE154MessageLayer -> IEEE154MessageLayerC;
+ RF212ActiveMessageP.RadioAlarm -> RadioAlarmC.RadioAlarm[unique("RadioAlarm")];
+ RF212ActiveMessageP.PacketTimeStamp -> TimeStampingLayerC;
+ RF212ActiveMessageP.RF212Packet -> RF212DriverLayerC;
+
+// -------- IEEE154 Message
+
+ components IEEE154MessageLayerC;
+ IEEE154MessageLayerC.SubPacket -> LowPowerListeningLayerC;
+ IEEE154MessageLayerC.SubSend -> UniqueLayerC;
+ Ieee154Send = IEEE154MessageLayerC;
+ Packet = IEEE154MessageLayerC;
+ Ieee154Receive = LowPowerListeningLayerC;
+ Ieee154Packet = IEEE154MessageLayerC;
+
+// -------- UniqueLayer Send part (wired twice)
+
+ components UniqueLayerC;
+ UniqueLayerC.Config -> RF212ActiveMessageP;
+ UniqueLayerC.SubSend -> LowPowerListeningLayerC;
+
+// -------- Low Power Listening
+
+#ifdef LOW_POWER_LISTENING
+ components LowPowerListeningLayerC;
+ LowPowerListeningLayerC.Config -> RF212ActiveMessageP;
+ LowPowerListeningLayerC.PacketAcknowledgements -> SoftwareAckLayerC;
+#else
+ components LowPowerListeningDummyC as LowPowerListeningLayerC;
+#endif
+ LowPowerListeningLayerC.SubControl -> MessageBufferLayerC;
+ LowPowerListeningLayerC.SubSend -> PacketLinkLayerC;
+ LowPowerListeningLayerC.SubReceive -> MessageBufferLayerC;
+ LowPowerListeningLayerC.SubPacket -> PacketLinkLayerC;
+ SplitControl = LowPowerListeningLayerC;
+ LowPowerListening = LowPowerListeningLayerC;
+
+// -------- Packet Link
+
+ components PacketLinkLayerC;
+ PacketLink = PacketLinkLayerC;
+ PacketLinkLayerC.PacketAcknowledgements -> SoftwareAckLayerC;
+ PacketLinkLayerC.SubSend -> MessageBufferLayerC;
+ PacketLinkLayerC.SubPacket -> TimeStampingLayerC;
+
+// -------- MessageBuffer
+
+ components MessageBufferLayerC;
+ MessageBufferLayerC.Packet -> IEEE154MessageLayerC; // to get the payload for the Ieee154Receive.receive
+ MessageBufferLayerC.RadioSend -> TrafficMonitorLayerC;
+ MessageBufferLayerC.RadioReceive -> UniqueLayerC;
+ MessageBufferLayerC.RadioState -> TrafficMonitorLayerC;
+ RadioChannel = MessageBufferLayerC;
+
+// -------- UniqueLayer receive part (wired twice)
+
+ UniqueLayerC.SubReceive -> TrafficMonitorLayerC;
+
+// -------- Traffic Monitor
+
+ components TrafficMonitorLayerC;
+ TrafficMonitorLayerC.Config -> RF212ActiveMessageP;
+ TrafficMonitorLayerC.SubSend -> CollisionAvoidanceLayerC;
+ TrafficMonitorLayerC.SubReceive -> CollisionAvoidanceLayerC;
+ TrafficMonitorLayerC.SubState -> RF212DriverLayerC;
+
+// -------- CollisionAvoidance
+
+#ifdef SLOTTED_MAC
+ components SlottedCollisionLayerC as CollisionAvoidanceLayerC;
+#else
+ components RandomCollisionLayerC as CollisionAvoidanceLayerC;
+#endif
+ CollisionAvoidanceLayerC.Config -> RF212ActiveMessageP;
+ CollisionAvoidanceLayerC.SubSend -> SoftwareAckLayerC;
+ CollisionAvoidanceLayerC.SubReceive -> SoftwareAckLayerC;
+
+// -------- SoftwareAcknowledgement
+
+ components SoftwareAckLayerC;
+ SoftwareAckLayerC.Config -> RF212ActiveMessageP;
+ SoftwareAckLayerC.SubSend -> CsmaLayerC;
+ SoftwareAckLayerC.SubReceive -> RF212DriverLayerC;
+ PacketAcknowledgements = SoftwareAckLayerC;
+
+// -------- Carrier Sense
+
+ components new DummyLayerC() as CsmaLayerC;
+ CsmaLayerC.Config -> RF212ActiveMessageP;
+ CsmaLayerC -> RF212DriverLayerC.RadioSend;
+ CsmaLayerC -> RF212DriverLayerC.RadioCCA;
+
+// -------- TimeStamping
+
+ components TimeStampingLayerC;
+ TimeStampingLayerC.LocalTimeRadio -> RF212DriverLayerC;
+ TimeStampingLayerC.SubPacket -> MetadataFlagsLayerC;
+ PacketTimeStampRadio = TimeStampingLayerC;
+ PacketTimeStampMilli = TimeStampingLayerC;
+
+// -------- MetadataFlags
+
+ components MetadataFlagsLayerC;
+ MetadataFlagsLayerC.SubPacket -> RF212DriverLayerC;
+
+// -------- RF212 Driver
+
+ components RF212DriverLayerC;
+ RF212DriverLayerC.Config -> RF212ActiveMessageP;
+ RF212DriverLayerC.PacketTimeStamp -> TimeStampingLayerC;
+ PacketTransmitPower = RF212DriverLayerC.PacketTransmitPower;
+ PacketLinkQuality = RF212DriverLayerC.PacketLinkQuality;
+ PacketRSSI = RF212DriverLayerC.PacketRSSI;
+ LocalTimeRadio = RF212DriverLayerC;
+}
typedef nx_struct rf230packet_header_t
{
+ rf230_header_t rf230;
ieee154_header_t ieee154;
#ifndef TFRAMES_ENABLED
lowpan_header_t lowpan;
typedef struct rf230packet_metadata_t
{
- flags_metadata_t flags;
- rf230_metadata_t rf230;
- timestamp_metadata_t timestamp;
#ifdef LOW_POWER_LISTENING
lpl_metadata_t lpl;
#endif
#ifdef PACKET_LINK
link_metadata_t link;
#endif
+ timestamp_metadata_t timestamp;
+ flags_metadata_t flags;
+ rf230_metadata_t rf230;
} rf230packet_metadata_t;
#endif//__RF230ACTIVEMESSAGE_H__
RF230ActiveMessageP.IEEE154MessageLayer -> IEEE154MessageLayerC;
RF230ActiveMessageP.RadioAlarm -> RadioAlarmC.RadioAlarm[unique("RadioAlarm")];
RF230ActiveMessageP.PacketTimeStamp -> TimeStampingLayerC;
- Packet = RF230ActiveMessageP;
+ RF230ActiveMessageP.ActiveMessagePacket -> ActiveMessageLayerC;
+ RF230ActiveMessageP.RF230Packet -> RF230DriverLayerC;
// -------- Active Message
ActiveMessageLayerC.Config -> RF230ActiveMessageP;
ActiveMessageLayerC.SubSend -> LowpanNetworkLayerC;
ActiveMessageLayerC.SubReceive -> LowpanNetworkLayerC;
+ ActiveMessageLayerC.SubPacket ->LowpanNetworkLayerC;
AMSend = ActiveMessageLayerC;
+ Packet = ActiveMessageLayerC;
Receive = ActiveMessageLayerC.Receive;
Snoop = ActiveMessageLayerC.Snoop;
AMPacket = ActiveMessageLayerC;
components new DummyLayerC() as LowpanNetworkLayerC;
#else
components LowpanNetworkLayerC;
- LowpanNetworkLayerC.Config -> RF230ActiveMessageP;
#endif
LowpanNetworkLayerC.SubSend -> UniqueLayerC;
LowpanNetworkLayerC.SubReceive -> LowPowerListeningLayerC;
+ LowpanNetworkLayerC.SubPacket -> IEEE154MessageLayerC;
-// -------- IEEE154 Packet
+// -------- IEEE154 Message
components IEEE154MessageLayerC;
- IEEE154MessageLayerC.Config -> RF230ActiveMessageP;
+ IEEE154MessageLayerC.SubPacket -> LowPowerListeningLayerC;
// -------- UniqueLayer Send part (wired twice)
LowPowerListeningLayerC.SubControl -> MessageBufferLayerC;
LowPowerListeningLayerC.SubSend -> PacketLinkLayerC;
LowPowerListeningLayerC.SubReceive -> MessageBufferLayerC;
+ LowPowerListeningLayerC.SubPacket -> PacketLinkLayerC;
SplitControl = LowPowerListeningLayerC;
LowPowerListening = LowPowerListeningLayerC;
#ifdef PACKET_LINK
components PacketLinkLayerC;
PacketLink = PacketLinkLayerC;
- PacketLinkLayerC.PacketLinkMetadata -> RF230ActiveMessageP;
PacketLinkLayerC.PacketAcknowledgements -> SoftwareAckLayerC;
#else
components new DummyLayerC() as PacketLinkLayerC;
#endif
PacketLinkLayerC.SubSend -> MessageBufferLayerC;
+ PacketLinkLayerC.SubPacket -> TimeStampingLayerC;
// -------- MessageBuffer
components MessageBufferLayerC;
- MessageBufferLayerC.Packet -> RF230ActiveMessageP;
+ MessageBufferLayerC.Packet -> ActiveMessageLayerC;
MessageBufferLayerC.RadioSend -> TrafficMonitorLayerC;
MessageBufferLayerC.RadioReceive -> UniqueLayerC;
MessageBufferLayerC.RadioState -> TrafficMonitorLayerC;
CsmaLayerC -> RF230DriverLayerC.RadioSend;
CsmaLayerC -> RF230DriverLayerC.RadioCCA;
+// -------- TimeStamping
+
+ components TimeStampingLayerC;
+ TimeStampingLayerC.LocalTimeRadio -> RF230DriverLayerC;
+ TimeStampingLayerC.SubPacket -> MetadataFlagsLayerC;
+ PacketTimeStampRadio = TimeStampingLayerC;
+ PacketTimeStampMilli = TimeStampingLayerC;
+
+// -------- MetadataFlags
+
+ components MetadataFlagsLayerC;
+ MetadataFlagsLayerC.SubPacket -> RF230DriverLayerC;
+
// -------- RF230 Driver
components RF230DriverLayerC;
- RF230DriverLayerC.PacketRF230Metadata -> RF230ActiveMessageP;
- RF230DriverLayerC.RF230DriverConfig -> RF230ActiveMessageP;
+ RF230DriverLayerC.Config -> RF230ActiveMessageP;
RF230DriverLayerC.PacketTimeStamp -> TimeStampingLayerC;
PacketTransmitPower = RF230DriverLayerC.PacketTransmitPower;
PacketLinkQuality = RF230DriverLayerC.PacketLinkQuality;
PacketRSSI = RF230DriverLayerC.PacketRSSI;
LocalTimeRadio = RF230DriverLayerC;
-
-// -------- MetadataFlags
-
- components MetadataFlagsLayerC;
- MetadataFlagsLayerC.PacketFlagsMetadata -> RF230ActiveMessageP;
-
-// -------- TimeStamping
-
- components TimeStampingLayerC;
- TimeStampingLayerC.LocalTimeRadio -> RF230DriverLayerC;
- TimeStampingLayerC.PacketTimeStampMetadata -> RF230ActiveMessageP;
- PacketTimeStampRadio = TimeStampingLayerC;
- PacketTimeStampMilli = TimeStampingLayerC;
}
interface RandomCollisionConfig;
interface SlottedCollisionConfig;
interface ActiveMessageConfig;
- interface LowpanNetworkConfig;
- interface IEEE154MessageConfig;
interface DummyConfig;
- interface Packet;
-
- interface PacketData<flags_metadata_t> as PacketFlagsMetadata;
- interface PacketData<rf230_metadata_t> as PacketRF230Metadata;
- interface PacketData<timestamp_metadata_t> as PacketTimeStampMetadata;
-
#ifdef LOW_POWER_LISTENING
interface LowPowerListeningConfig;
-#endif
-#ifdef PACKET_LINK
- interface PacketData<link_metadata_t> as PacketLinkMetadata;
#endif
}
{
interface IEEE154MessageLayer;
interface RadioAlarm;
+ interface RadioPacket as ActiveMessagePacket;
+ interface RadioPacket as RF230Packet;
interface PacketTimeStamp<TRadio, uint32_t>;
}
implementation
{
- rf230packet_header_t* getHeader(message_t* msg)
- {
- return (rf230packet_header_t*)(msg->data - sizeof(rf230packet_header_t));
- }
-
- rf230packet_metadata_t* getMeta(message_t* msg)
- {
- return (rf230packet_metadata_t*)(msg->metadata);
- }
/*----------------- RF230DriverConfig -----------------*/
- async command uint8_t RF230DriverConfig.getLength(message_t* msg)
+ async command uint8_t RF230DriverConfig.headerLength(message_t* msg)
{
- return call IEEE154MessageLayer.getLength(msg);
+ return offsetof(message_t, data) - sizeof(rf230packet_header_t);
}
- async command void RF230DriverConfig.setLength(message_t* msg, uint8_t len)
+ async command uint8_t RF230DriverConfig.maxPayloadLength()
{
- call IEEE154MessageLayer.setLength(msg, len);
+ return sizeof(rf230packet_header_t) + TOSH_DATA_LENGTH;
}
- async command uint8_t* RF230DriverConfig.getPayload(message_t* msg)
+ async command uint8_t RF230DriverConfig.metadataLength(message_t* msg)
{
- return ((uint8_t*)(call IEEE154MessageConfig.getHeader(msg))) + 1;
+ return 0;
}
- async command uint8_t RF230DriverConfig.getHeaderLength()
+ async command uint8_t RF230DriverConfig.headerPreloadLength()
{
// we need the fcf, dsn, destpan and dest
return 7;
}
- async command uint8_t RF230DriverConfig.getMaxLength()
- {
- // note, that the ieee154_footer_t is not stored, but we should include it here
- return sizeof(rf230packet_header_t) - 1 + TOSH_DATA_LENGTH + sizeof(ieee154_footer_t);
- }
-
async command bool RF230DriverConfig.requiresRssiCca(message_t* msg)
{
return call IEEE154MessageLayer.isDataFrame(msg);
/*----------------- ActiveMessageConfig -----------------*/
- command error_t ActiveMessageConfig.checkPacket(message_t* msg)
- {
- // the user forgot to call clear, we should return EINVAL
- if( ! call IEEE154MessageLayer.isDataFrame(msg) )
- call Packet.clear(msg);
-
- return SUCCESS;
- }
-
- command activemessage_header_t* ActiveMessageConfig.getHeader(message_t* msg)
+ command bool ActiveMessageConfig.forgotToClear(message_t* msg)
{
- return &(getHeader(msg)->am);
+ return ! call IEEE154MessageLayer.isDataFrame(msg);
}
command am_addr_t ActiveMessageConfig.destination(message_t* msg)
* ack required: 8-16 byte separation, 11 bytes airtime, 5-10 bytes separation
*/
- uint8_t len = call IEEE154MessageLayer.getLength(msg);
+ uint8_t len = call RF230Packet.payloadLength(msg);
return call IEEE154MessageLayer.getAckRequired(msg) ? len + 6 + 16 + 11 + 10 : len + 6 + 10;
}
{
}
-/*----------------- LowpanNetwork -----------------*/
-
- command lowpan_header_t* LowpanNetworkConfig.getHeader(message_t* msg)
- {
- return &(getHeader(msg)->lowpan);
- }
-
-/*----------------- IEEE154Message -----------------*/
-
- async command ieee154_header_t* IEEE154MessageConfig.getHeader(message_t* msg)
- {
- return &(getHeader(msg)->ieee154);
- }
-
/*----------------- LowPowerListening -----------------*/
#ifdef LOW_POWER_LISTENING
- async command lpl_metadata_t* LowPowerListeningConfig.metadata(message_t* msg)
- {
- return &(getMeta(msg)->lpl);
- }
-
async command bool LowPowerListeningConfig.getAckRequired(message_t* msg)
{
return call IEEE154MessageLayer.getAckRequired(msg);
#endif
-/*----------------- Headers and Metadata -----------------*/
-
- async command flags_metadata_t* PacketFlagsMetadata.get(message_t* msg)
- {
- return &(getMeta(msg)->flags);
- }
-
- async command rf230_metadata_t* PacketRF230Metadata.get(message_t* msg)
- {
- return &(getMeta(msg)->rf230);
- }
-
- async command timestamp_metadata_t* PacketTimeStampMetadata.get(message_t* msg)
- {
- return &(getMeta(msg)->timestamp);
- }
-
-#ifdef PACKET_LINK
- async command link_metadata_t* PacketLinkMetadata.get(message_t* msg)
- {
- return &(getMeta(msg)->link);
- }
-#endif
-
-/*----------------- Packet -----------------*/
-
- enum
- {
- PACKET_LENGTH_INCREASE =
- sizeof(rf230packet_header_t) - 1 // the 8-bit length field is not counted
- + sizeof(ieee154_footer_t), // the CRC is not stored in memory
- };
-
- command void Packet.clear(message_t* msg)
- {
- signal PacketFlagsMetadata.clear(msg);
- signal PacketRF230Metadata.clear(msg);
- signal PacketTimeStampMetadata.clear(msg);
-#ifdef LOW_POWER_LISTENING
- signal LowPowerListeningConfig.clear(msg);
-#endif
-#ifdef PACKET_LINK
- signal PacketLinkMetadata.clear(msg);
-#endif
- call IEEE154MessageLayer.createDataFrame(msg);
- }
-
- command void Packet.setPayloadLength(message_t* msg, uint8_t len)
- {
- call IEEE154MessageLayer.setLength(msg, len + PACKET_LENGTH_INCREASE);
- }
-
- command uint8_t Packet.payloadLength(message_t* msg)
- {
- return call IEEE154MessageLayer.getLength(msg) - PACKET_LENGTH_INCREASE;
- }
-
- command uint8_t Packet.maxPayloadLength()
- {
- return TOSH_DATA_LENGTH;
- }
-
- command void* Packet.getPayload(message_t* msg, uint8_t len)
- {
- if( len > TOSH_DATA_LENGTH )
- return NULL;
-
- return msg->data;
- }
}
* Author: Miklos Maroti
*/
-/**
- * This interface needs to be implemented by the MAC to control the behaviour
- * of the RF230DriverLayerC component.
- */
interface RF230DriverConfig
{
/**
- * Returns the length of the PHY payload (including the FCF field).
- * This value must be in the range [3, 127].
+ * Returns the length of a dummy header to align the payload properly.
*/
- async command uint8_t getLength(message_t* msg);
+ async command uint8_t headerLength(message_t* msg);
/**
- * Sets the length of the PHY payload.
+ * Returns the maximum length of the PHY payload including the
+ * length field but not counting the FCF field.
*/
- async command void setLength(message_t* msg, uint8_t len);
+ async command uint8_t maxPayloadLength();
/**
- * Returns a pointer to the start of the PHY payload that contains
- * getLength()-2 number of bytes. The FCF field (CRC-16) is not stored,
- * but automatically appended / verified.
+ * Returns the length of a dummy metadata section to align the
+ * metadata section properly.
*/
- async command uint8_t* getPayload(message_t* msg);
+ async command uint8_t metadataLength(message_t* msg);
/**
* Gets the number of bytes we should read before the RadioReceive.header
* event is fired. If the length of the packet is less than this amount,
* then that event is fired earlier. The header length must be at least one.
*/
- async command uint8_t getHeaderLength();
-
- /**
- * Returns the maximum PHY length that can be set via the setLength command
- */
- async command uint8_t getMaxLength();
+ async command uint8_t headerPreloadLength();
/**
* Returns TRUE if before sending this message we should make sure that
#ifndef __RF230DRIVERLAYER_H__
#define __RF230DRIVERLAYER_H__
+typedef nx_struct rf230_header_t
+{
+ nxle_uint8_t length;
+} rf230_header_t;
+
typedef struct rf230_metadata_t
{
uint8_t lqi;
interface RadioSend;
interface RadioReceive;
interface RadioCCA;
+ interface RadioPacket;
interface PacketField<uint8_t> as PacketTransmitPower;
interface PacketField<uint8_t> as PacketRSSI;
uses
{
- interface RF230DriverConfig;
+ interface RF230DriverConfig as Config;
interface PacketTimeStamp<TRadio, uint32_t>;
- interface PacketData<rf230_metadata_t> as PacketRF230Metadata;
}
}
RadioSend = RF230DriverLayerP;
RadioReceive = RF230DriverLayerP;
RadioCCA = RF230DriverLayerP;
+ RadioPacket = RF230DriverLayerP;
LocalTimeRadio = HplRF230C;
- RF230DriverConfig = RF230DriverLayerP;
- PacketRF230Metadata = RF230DriverLayerP;
+ Config = RF230DriverLayerP;
PacketTransmitPower = RF230DriverLayerP.PacketTransmitPower;
components new MetadataFlagC() as TransmitPowerFlagC;
interface RadioSend;
interface RadioReceive;
interface RadioCCA;
+ interface RadioPacket;
interface PacketField<uint8_t> as PacketTransmitPower;
interface PacketField<uint8_t> as PacketRSSI;
interface BusyWait<TMicro, uint16_t>;
interface LocalTime<TRadio>;
- interface RF230DriverConfig;
+ interface RF230DriverConfig as Config;
- interface PacketData<rf230_metadata_t> as PacketRF230Metadata;
interface PacketFlag as TransmitPowerFlag;
interface PacketFlag as RSSIFlag;
interface PacketFlag as TimeSyncFlag;
implementation
{
+ rf230_header_t* getHeader(message_t* msg)
+ {
+ return ((void*)msg) + call Config.headerLength(msg);
+ }
+
+ void* getPayload(message_t* msg)
+ {
+ return ((void*)msg) + call RadioPacket.headerLength(msg);
+ }
+
+ rf230_metadata_t* getMeta(message_t* msg)
+ {
+ return ((void*)msg) + sizeof(message_t) - call RadioPacket.metadataLength(msg);
+ }
+
/*----------------- STATE -----------------*/
tasklet_norace uint8_t state;
writeRegister(RF230_PHY_TX_PWR, RF230_TX_AUTO_CRC_ON | txPower);
}
- if( call RF230DriverConfig.requiresRssiCca(msg)
+ if( call Config.requiresRssiCca(msg)
&& (readRegister(RF230_PHY_RSSI) & RF230_RSSI_MASK) > ((rssiClear + rssiBusy) >> 3) )
return EBUSY;
// do something useful, just to wait a little
time32 = call LocalTime.get();
- timesync = call PacketTimeSyncOffset.isSet(msg) ? msg->data + call PacketTimeSyncOffset.get(msg) : 0;
+ timesync = call PacketTimeSyncOffset.isSet(msg) ? ((void*)msg) + call PacketTimeSyncOffset.get(msg) : 0;
// we have missed an incoming message in this short amount of time
if( (readRegister(RF230_TRX_STATUS) & RF230_TRX_STATUS_MASK) != RF230_PLL_ON )
call SELN.clr();
call FastSpiByte.splitWrite(RF230_CMD_FRAME_WRITE);
- length = call RF230DriverConfig.getLength(msg);
- data = call RF230DriverConfig.getPayload(msg);
+ data = getPayload(msg);
+ length = getHeader(msg)->length;
// length | data[0] ... data[length-3] | automatically generated FCS
call FastSpiByte.splitReadWrite(length);
// the FCS is atomatically generated (2 bytes)
length -= 2;
- header = call RF230DriverConfig.getHeaderLength();
+ header = call Config.headerPreloadLength();
if( header > length )
header = length;
#ifdef RADIO_DEBUG_MESSAGES
if( call DiagMsg.record() )
{
- length = call RF230DriverConfig.getLength(msg);
+ length = getHeader(msg)->length;
call DiagMsg.str("tx");
call DiagMsg.uint16(time);
call DiagMsg.uint8(length);
- call DiagMsg.hex8s(data, length - 2);
+ call DiagMsg.hex8s(getPayload(msg), length - 2);
call DiagMsg.send();
}
#endif
length = call FastSpiByte.write(0);
// if correct length
- if( length >= 3 && length <= call RF230DriverConfig.getMaxLength() )
+ if( length >= 3 && length <= call RadioPacket.maxPayloadLength() + 2 )
{
uint8_t read;
uint8_t* data;
// initiate the reading
call FastSpiByte.splitWrite(0);
- call RF230DriverConfig.setLength(rxMsg, length);
- data = call RF230DriverConfig.getPayload(rxMsg);
+ data = getPayload(rxMsg);
+ getHeader(rxMsg)->length = length;
crc = 0;
// we do not store the CRC field
length -= 2;
- read = call RF230DriverConfig.getHeaderLength();
+ read = call Config.headerPreloadLength();
if( length < read )
read = length;
#ifdef RADIO_DEBUG_MESSAGES
if( call DiagMsg.record() )
{
- length = call RF230DriverConfig.getLength(rxMsg);
+ length = getHeader(rxMsg)->length;
call DiagMsg.str("rx");
call DiagMsg.uint32(call PacketTimeStamp.isValid(rxMsg) ? call PacketTimeStamp.timestamp(rxMsg) : 0);
call DiagMsg.uint16(call RadioAlarm.getNow());
call DiagMsg.uint8(crc != 0);
call DiagMsg.uint8(length);
- call DiagMsg.hex8s(call RF230DriverConfig.getPayload(rxMsg), length - 2);
+ call DiagMsg.hex8s(getPayload(rxMsg), length - 2);
call DiagMsg.send();
}
#endif
call SpiResource.release();
}
-/*----------------- PACKET -----------------*/
+/*----------------- RadioPacket -----------------*/
+
+ async command uint8_t RadioPacket.headerLength(message_t* msg)
+ {
+ return call Config.headerLength(msg) + sizeof(rf230_header_t);
+ }
+
+ async command uint8_t RadioPacket.payloadLength(message_t* msg)
+ {
+ return getHeader(msg)->length - 2;
+ }
+
+ async command void RadioPacket.setPayloadLength(message_t* msg, uint8_t length)
+ {
+ ASSERT( 1 <= length && length <= 125 );
+ ASSERT( call RadioPacket.headerLength(msg) + length + call RadioPacket.metadataLength(msg) <= sizeof(message_t) );
+
+ // we add the length of the CRC, which is automatically generated
+ getHeader(msg)->length = length + 2;
+ }
- async event void PacketRF230Metadata.clear(message_t* msg)
+ async command uint8_t RadioPacket.maxPayloadLength()
{
+ ASSERT( call Config.maxPayloadLength() <= 125 );
+
+ return call Config.maxPayloadLength() - sizeof(rf230_header_t);
}
-// --- TransmitPower
+ async command uint8_t RadioPacket.metadataLength(message_t* msg)
+ {
+ return call Config.metadataLength(msg) + sizeof(rf230_metadata_t);
+ }
+
+ async command void RadioPacket.clear(message_t* msg)
+ {
+ // all flags are automatically cleared
+ }
+
+/*----------------- PacketTransmitPower -----------------*/
async command bool PacketTransmitPower.isSet(message_t* msg)
{
async command uint8_t PacketTransmitPower.get(message_t* msg)
{
- return (call PacketRF230Metadata.get(msg))->power;
+ return getMeta(msg)->power;
}
async command void PacketTransmitPower.clear(message_t* msg)
async command void PacketTransmitPower.set(message_t* msg, uint8_t value)
{
call TransmitPowerFlag.set(msg);
- (call PacketRF230Metadata.get(msg))->power = value;
+ getMeta(msg)->power = value;
}
-// --- RSSI
+/*----------------- PacketRSSI -----------------*/
async command bool PacketRSSI.isSet(message_t* msg)
{
async command uint8_t PacketRSSI.get(message_t* msg)
{
- return (call PacketRF230Metadata.get(msg))->rssi;
+ return getMeta(msg)->rssi;
}
async command void PacketRSSI.clear(message_t* msg)
call TransmitPowerFlag.clear(msg);
call RSSIFlag.set(msg);
- (call PacketRF230Metadata.get(msg))->rssi = value;
+ getMeta(msg)->rssi = value;
}
-// --- TimeSyncOffset
-
- enum
- {
- PACKET_LENGTH_INCREASE =
- sizeof(rf230packet_header_t) - 1 // the 8-bit length field is not counted
- + sizeof(ieee154_footer_t), // the CRC is not stored in memory
- };
+/*----------------- PacketTimeSyncOffset -----------------*/
async command bool PacketTimeSyncOffset.isSet(message_t* msg)
{
async command uint8_t PacketTimeSyncOffset.get(message_t* msg)
{
- return call RF230DriverConfig.getLength(msg) - PACKET_LENGTH_INCREASE - sizeof(timesync_absolute_t);
+ return call RadioPacket.headerLength(msg) + call RadioPacket.payloadLength(msg) - sizeof(timesync_absolute_t);
}
async command void PacketTimeSyncOffset.clear(message_t* msg)
async command void PacketTimeSyncOffset.set(message_t* msg, uint8_t value)
{
// we do not store the value, the time sync field is always the last 4 bytes
- ASSERT( call RF230DriverConfig.getLength(msg) - PACKET_LENGTH_INCREASE - sizeof(timesync_absolute_t) == value );
+ ASSERT( call PacketTimeSyncOffset.get(msg) == value );
call TimeSyncFlag.set(msg);
}
-// --- LinkQuality
+/*----------------- PacketLinkQuality -----------------*/
async command bool PacketLinkQuality.isSet(message_t* msg)
{
async command uint8_t PacketLinkQuality.get(message_t* msg)
{
- return (call PacketRF230Metadata.get(msg))->lqi;
+ return getMeta(msg)->lqi;
}
async command void PacketLinkQuality.clear(message_t* msg)
async command void PacketLinkQuality.set(message_t* msg, uint8_t value)
{
- (call PacketRF230Metadata.get(msg))->lqi = value;
+ getMeta(msg)->lqi = value;
}
}
+++ /dev/null
-/*
- * Copyright (c) 2007, Vanderbilt University
- * All rights reserved.
- *
- * Permission to use, copy, modify, and distribute this software and its
- * documentation for any purpose, without fee, and without written agreement is
- * hereby granted, provided that the above copyright notice, the following
- * two paragraphs and the author appear in all copies of this software.
- *
- * IN NO EVENT SHALL THE VANDERBILT UNIVERSITY BE LIABLE TO ANY PARTY FOR
- * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
- * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE VANDERBILT
- * UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * THE VANDERBILT UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES,
- * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
- * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
- * ON AN "AS IS" BASIS, AND THE VANDERBILT UNIVERSITY HAS NO OBLIGATION TO
- * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
- *
- * Author: Miklos Maroti
- */
-
-interface PacketData<data_t>
-{
- /**
- * This command returns a pointer to a set of packet fields (in the header, footer
- * or metadata) with the given data type.
- */
- async command data_t* get(message_t* msg);
-
- /**
- * This event is signalled, when the these fields should be reset to their default
- * value (usually called from Packet.clear)
- */
- async event void clear(message_t* msg);
-}
--- /dev/null
+/*
+ * Copyright (c) 2007, Vanderbilt University
+ * All rights reserved.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation for any purpose, without fee, and without written agreement is
+ * hereby granted, provided that the above copyright notice, the following
+ * two paragraphs and the author appear in all copies of this software.
+ *
+ * IN NO EVENT SHALL THE VANDERBILT UNIVERSITY BE LIABLE TO ANY PARTY FOR
+ * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
+ * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE VANDERBILT
+ * UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * THE VANDERBILT UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
+ * ON AN "AS IS" BASIS, AND THE VANDERBILT UNIVERSITY HAS NO OBLIGATION TO
+ * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+ *
+ * Author: Miklos Maroti
+ */
+
+interface RadioPacket
+{
+ /**
+ * This command returns the length of the header. The header
+ * starts at the first byte of the message_t structure
+ * (some layers may add dummy bytes to allign the payload to
+ * the msg->data section).
+ */
+ async command uint8_t headerLength(message_t* msg);
+
+ /**
+ * Returns the length of the payload. The payload starts right
+ * after th header.
+ */
+ async command uint8_t payloadLength(message_t* msg);
+
+ /**
+ * Sets the length of the payload.
+ */
+ async command void setPayloadLength(message_t* msg, uint8_t length);
+
+ /**
+ * Returns the maximum length that can be set for this message.
+ */
+ async command uint8_t maxPayloadLength();
+
+ /**
+ * Returns the length of the metadata section. The metadata section
+ * is at the very end of the message_t structure and grows downwards.
+ */
+ async command uint8_t metadataLength(message_t* msg);
+
+ /**
+ * Clears all metadata and sets all default values in the headers.
+ */
+ async command void clear(message_t* msg);
+}
projects / tinyos-2.x.git / commitdiff