interface ActiveMessageConfig
{
- /**
- * This command is called when the message first enters the radio stack
- * via the Send.send command. This command should return TRUE if the
- * packet is deffinitely not cleared, FALSE otherwise.
- */
- command bool forgotToClear(message_t* msg);
-
/** Same as AMPacket.destination */
command am_addr_t destination(message_t* msg);
uses
{
interface RadioPacket as SubPacket;
- interface Send as SubSend;
- interface Receive as SubReceive;
+ interface BareSend as SubSend;
+ interface BareReceive as SubReceive;
interface ActiveMessageConfig as Config;
}
}
uses
{
interface RadioPacket as SubPacket;
- interface Send as SubSend;
- interface Receive as SubReceive;
+ interface BareSend as SubSend;
+ interface BareReceive as SubReceive;
interface ActiveMessageConfig as Config;
interface ActiveMessageAddress;
}
implementation
{
-
activemessage_header_t* getHeader(message_t* msg)
{
return ((void*)msg) + call SubPacket.headerLength(msg);
}
+ void* getPayload(message_t* msg)
+ {
+ return ((void*)msg) + call RadioPacket.headerLength(msg);
+ }
+
/*----------------- Send -----------------*/
command error_t AMSend.send[am_id_t id](am_addr_t addr, message_t* msg, uint8_t len)
{
- if( call Config.forgotToClear(msg) )
- {
- // return FAIL;
- call Packet.clear(msg);
- }
+ if( len > call Packet.maxPayloadLength() )
+ return EINVAL;
+ call Packet.setPayloadLength(msg, len);
call AMPacket.setSource(msg, call AMPacket.address());
call AMPacket.setGroup(msg, call AMPacket.localGroup());
call AMPacket.setType(msg, id);
signal SendNotifier.aboutToSend[id](addr, msg);
- return call SubSend.send(msg, len);
+ return call SubSend.send(msg);
}
inline event void SubSend.sendDone(message_t* msg, error_t error)
inline command uint8_t AMSend.maxPayloadLength[am_id_t id]()
{
- return call SubSend.maxPayloadLength();
+ return call Packet.maxPayloadLength();
}
inline command void* AMSend.getPayload[am_id_t id](message_t* msg, uint8_t len)
{
- return call SubSend.getPayload(msg, len);
+ return call Packet.getPayload(msg, len);
}
default event void SendNotifier.aboutToSend[am_id_t id](am_addr_t addr, message_t* msg)
/*----------------- Receive -----------------*/
- event message_t* SubReceive.receive(message_t* msg, void* payload, uint8_t len)
+ event message_t* SubReceive.receive(message_t* msg)
{
- am_id_t type = call AMPacket.type(msg);
+ am_id_t id = call AMPacket.type(msg);
+ void* payload = getPayload(msg);
+ uint8_t len = call Packet.payloadLength(msg);
msg = call AMPacket.isForMe(msg)
- ? signal Receive.receive[type](msg, payload, len)
- : signal Snoop.receive[type](msg, payload, len);
+ ? signal Receive.receive[id](msg, payload, len)
+ : signal Snoop.receive[id](msg, payload, len);
return msg;
}
call SubPacket.clear(msg);
}
-
/*----------------- Packet -----------------*/
command void Packet.clear(message_t* msg)
{
- call RadioPacket.clear(msg);
+ call SubPacket.clear(msg);
}
command uint8_t Packet.payloadLength(message_t* msg)
{
- return call RadioPacket.payloadLength(msg);
+ return call SubPacket.payloadLength(msg);
}
command void Packet.setPayloadLength(message_t* msg, uint8_t len)
{
- call RadioPacket.setPayloadLength(msg, len);
+ call SubPacket.setPayloadLength(msg, len);
}
command uint8_t Packet.maxPayloadLength()
{
- return call RadioPacket.maxPayloadLength();
+ return call SubPacket.maxPayloadLength();
}
command void* Packet.getPayload(message_t* msg, uint8_t len)
{
- if( len > call RadioPacket.maxPayloadLength() )
+ if( len > call SubPacket.maxPayloadLength() )
return NULL;
- return ((void*)msg) + call RadioPacket.headerLength(msg);
+ return ((void*)msg) + call SubPacket.headerLength(msg);
}
}
provides
{
interface SplitControl;
- interface Send;
- interface Receive;
+ interface BareSend as Send;
+ interface BareReceive as Receive;
interface RadioState;
interface RadioSend;
uses
{
interface SplitControl as SubControl;
- interface Send as SubSend;
- interface Receive as SubReceive;
+ interface BareSend as SubSend;
+ interface BareReceive as SubReceive;
interface RadioState as SubState;
interface RadioSend as SubRadioSend;
{
interface IEEE154MessageLayer;
interface RadioPacket;
+
+ // for passthrough wiring
+ interface BareSend as Send;
+
+ // for gateway wiring
interface Ieee154Packet;
interface Packet;
interface Ieee154Send;
+ interface Receive as Ieee154Receive;
interface SendNotifier;
}
uses
{
interface RadioPacket as SubPacket;
- interface Send as SubSend;
+ interface BareSend as SubSend;
+
+ // for gateway wiring
+ interface BareReceive as SubReceive;
}
}
IEEE154MessageLayer = IEEE154MessageLayerP;
RadioPacket = IEEE154MessageLayerP;
SubPacket = IEEE154MessageLayerP;
+
+ // for passthrough
+ Send = IEEE154MessageLayerP;
+ SubSend = IEEE154MessageLayerP;
+
Ieee154Packet = IEEE154MessageLayerP;
Packet = IEEE154MessageLayerP;
Ieee154Send = IEEE154MessageLayerP;
- SubSend = IEEE154MessageLayerP;
+ Ieee154Receive = IEEE154MessageLayerP;
+ SubReceive = IEEE154MessageLayerP;
SendNotifier = IEEE154MessageLayerP;
}
interface Ieee154Packet;
interface Packet;
interface Ieee154Send;
+ interface BareSend as Send;
+ interface Receive as Ieee154Receive;
interface SendNotifier;
}
{
interface ActiveMessageAddress;
interface RadioPacket as SubPacket;
- interface Send as SubSend;
+ interface BareSend as SubSend;
+ interface BareReceive as SubReceive;
}
}
return ((void*)msg) + call SubPacket.headerLength(msg);
}
+ void* getPayload(message_t* msg)
+ {
+ return ((void*)msg) + call RadioPacket.headerLength(msg);
+ }
+
async command uint16_t IEEE154MessageLayer.getFCF(message_t* msg)
{
return getHeader(msg)->fcf;
}
async command void IEEE154MessageLayer.setSrcAddr(message_t* msg, uint16_t addr)
- {
+ {
getHeader(msg)->src = addr;
}
async command void RadioPacket.clear(message_t* msg)
{
call SubPacket.clear(msg);
- call IEEE154MessageLayer.createDataFrame(msg);
}
/*----------------- Packet -----------------*/
if( len > call RadioPacket.maxPayloadLength() )
return NULL;
- return ((void*)msg) + call RadioPacket.headerLength(msg);
+ return getPayload(msg);
}
/*----------------- Ieee154Send -----------------*/
command error_t Ieee154Send.send(ieee154_saddr_t addr, message_t* msg, uint8_t len)
{
- ieee154_header_t* header = getHeader(msg);
+ if( len > call Packet.maxPayloadLength() )
+ return EINVAL;
- header->dest = addr;
- header->destpan = call Ieee154Packet.localPan();
- header->src = call Ieee154Packet.address();
+ call IEEE154MessageLayer.createDataFrame(msg);
+ call Packet.setPayloadLength(msg, len);
+ call Ieee154Packet.setSource(msg, call Ieee154Packet.address());
+ call Ieee154Packet.setDestination(msg, addr);
+ call Ieee154Packet.setPan(msg, call Ieee154Packet.localPan());
signal SendNotifier.aboutToSend(addr, msg);
- return call SubSend.send(msg, len);
+ return call SubSend.send(msg);
+ }
+
+ default event void Ieee154Send.sendDone(message_t* msg, error_t error)
+ {
+ }
+
+ default event void SendNotifier.aboutToSend(am_addr_t addr, message_t* msg)
+ {
+ }
+
+/*----------------- Send -----------------*/
+
+ command error_t Send.send(message_t* msg)
+ {
+ // lower leveles can send other frames
+ call IEEE154MessageLayer.createDataFrame(msg);
+
+ return call SubSend.send(msg);
+ }
+
+ command error_t Send.cancel(message_t* msg)
+ {
+ return call SubSend.cancel(msg);
}
event void SubSend.sendDone(message_t* msg, error_t error)
{
+ // we signal both, only one of them should be connected
signal Ieee154Send.sendDone(msg, error);
+ signal Send.sendDone(msg, error);
}
- default event void Ieee154Send.sendDone(message_t* msg, error_t error)
+ default event void Send.sendDone(message_t* msg, error_t error)
{
}
- default event void SendNotifier.aboutToSend(am_addr_t addr, message_t* msg)
+/*----------------- Receive -----------------*/
+
+ event message_t* SubReceive.receive(message_t* msg)
{
+ return signal Ieee154Receive.receive(msg,
+ getPayload(msg), call Packet.payloadLength(msg));
}
}
provides
{
interface SplitControl;
- interface Send;
- interface Receive;
+ interface BareSend as Send;
+ interface BareReceive as Receive;
interface RadioPacket;
interface LowPowerListening;
uses
{
interface SplitControl as SubControl;
- interface Send as SubSend;
- interface Receive as SubReceive;
+ interface BareSend as SubSend;
+ interface BareReceive as SubReceive;
interface RadioPacket as SubPacket;
}
}
* Author: Miklos Maroti
*/
-#warning "*** USING LOW POWER LISTENING LAYER"
-
configuration LowPowerListeningLayerC
{
provides
{
interface SplitControl;
- interface Send;
- interface Receive;
+ interface BareSend as Send;
+ interface BareReceive as Receive;
interface RadioPacket;
interface LowPowerListening;
uses
{
interface SplitControl as SubControl;
- interface Send as SubSend;
- interface Receive as SubReceive;
+ interface BareSend as SubSend;
+ interface BareReceive as SubReceive;
interface RadioPacket as SubPacket;
interface LowPowerListeningConfig as Config;
provides
{
interface SplitControl;
- interface Send;
- interface Receive;
+ interface BareSend as Send;
+ interface BareReceive as Receive;
interface RadioPacket;
interface LowPowerListening;
uses
{
interface SplitControl as SubControl;
- interface Send as SubSend;
- interface Receive as SubReceive;
+ interface BareSend as SubSend;
+ interface BareReceive as SubReceive;
interface RadioPacket as SubPacket;
interface PacketAcknowledgements;
uint16_t sleepInterval;
message_t* txMsg;
- uint8_t txLen;
error_t txError;
/*----------------- state machine -----------------*/
}
else if( state == SEND_SUBSEND)
{
- txError = call SubSend.send(txMsg, txLen);
+ txError = call SubSend.send(txMsg);
if( txError == SUCCESS )
state = SEND_SUBSEND_DONE;
post transition();
}
- event message_t* SubReceive.receive(message_t* msg, void* payload, uint8_t len)
+ event message_t* SubReceive.receive(message_t* msg)
{
if( state == SLEEP_SUBSTOP )
state = LISTEN;
if( state == LISTEN && sleepInterval > 0 )
call Timer.startOneShot(AFTER_RECEIVE);
- return signal Receive.receive(msg, payload, len);
+ return signal Receive.receive(msg);
}
- command error_t Send.send(message_t* msg, uint8_t len)
+ command error_t Send.send(message_t* msg)
{
if( state == LISTEN || state == SLEEP )
{
return EBUSY;
txMsg = msg;
- txLen = len;
txError = FAIL;
return SUCCESS;
post transition();
}
- command uint8_t Send.maxPayloadLength()
- {
- return call SubSend.maxPayloadLength();
- }
-
- command void* Send.getPayload(message_t* msg, uint8_t len)
- {
- return call SubSend.getPayload(msg, len);
- }
-
/*----------------- LowPowerListening -----------------*/
lpl_metadata_t* getMeta(message_t* msg)
{
provides
{
- interface Send;
- interface Receive;
+ interface BareSend as Send;
+ interface BareReceive as Receive;
interface RadioPacket;
interface Receive as NonTinyosReceive[uint8_t network];
uses
{
- interface Send as SubSend;
- interface Receive as SubReceive;
+ interface BareSend as SubSend;
+ interface BareReceive as SubReceive;
interface RadioPacket as SubPacket;
}
}
implementation
{
-#ifndef TINYOS_6LOWPAN_NETWORK_ID
-#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)
+ void* getPayload(message_t* msg)
{
- getHeader(msg)->network = TINYOS_6LOWPAN_NETWORK_ID;
- return call SubSend.send(msg, len);
+ return ((void*)msg) + call RadioPacket.headerLength(msg);
}
- command error_t Send.cancel(message_t* msg)
- {
- return call SubSend.cancel(msg);
- }
+#ifndef TINYOS_6LOWPAN_NETWORK_ID
+#define TINYOS_6LOWPAN_NETWORK_ID 0x3f
+#endif
- command uint8_t Send.maxPayloadLength()
+ command error_t Send.send(message_t* msg)
{
- return call SubSend.maxPayloadLength();
+ getHeader(msg)->network = TINYOS_6LOWPAN_NETWORK_ID;
+ return call SubSend.send(msg);
}
- command void* Send.getPayload(message_t* msg, uint8_t len)
+ command error_t Send.cancel(message_t* msg)
{
- return call SubSend.getPayload(msg, len);
+ return call SubSend.cancel(msg);
}
-
+
event void SubSend.sendDone(message_t* msg, error_t error)
{
signal Send.sendDone(msg, error);
}
- event message_t *SubReceive.receive(message_t *msg, void *payload, uint8_t len)
+ event message_t *SubReceive.receive(message_t *msg)
{
uint8_t network = getHeader(msg)->network;
if( network == TINYOS_6LOWPAN_NETWORK_ID )
- return signal Receive.receive(msg, payload, len);
+ return signal Receive.receive(msg);
else
- return signal NonTinyosReceive.receive[network](msg, payload, len);
+ return signal NonTinyosReceive.receive[network](msg,
+ getPayload(msg), call RadioPacket.payloadLength(msg));
}
default event message_t *NonTinyosReceive.receive[uint8_t network](message_t *msg, void *payload, uint8_t len)
provides
{
interface SplitControl;
- interface Send;
- interface Receive;
+ interface BareSend as Send;
+ interface BareReceive as Receive;
interface RadioChannel;
}
uses
interface RadioState;
interface RadioSend;
interface RadioReceive;
-
- interface Packet;
}
}
MessageBufferLayerP.Tasklet -> TaskletC;
RadioSend = MessageBufferLayerP;
RadioReceive = MessageBufferLayerP;
-
- Packet = MessageBufferLayerP;
}
interface SplitControl;
interface Init as SoftwareInit;
- interface Send;
- interface Receive;
+ interface BareSend as Send;
+ interface BareReceive as Receive;
interface RadioChannel;
}
uses
interface Tasklet;
interface RadioSend;
interface RadioReceive;
-
- interface Packet;
}
}
post sendTask();
}
- command error_t Send.send(message_t* msg, uint8_t len)
+ command error_t Send.send(message_t* msg)
{
- if( len > call Packet.maxPayloadLength() )
- return EINVAL;
- else if( state != STATE_READY )
+ if( state != STATE_READY )
return EBUSY;
- call Packet.setPayloadLength(msg, len);
-
txMsg = msg;
state = STATE_TX_PENDING;
retries = 0;
return FAIL;
}
- default event void Send.sendDone(message_t* msg, error_t error)
- {
- }
-
- inline command uint8_t Send.maxPayloadLength()
- {
- return call Packet.maxPayloadLength();
- }
-
- inline command void* Send.getPayload(message_t* msg, uint8_t len)
- {
- return call Packet.getPayload(msg, len);
- }
-
/*----------------- Receive -----------------*/
enum
msg = receiveQueue[receiveQueueHead];
}
- msg = signal Receive.receive(msg,
- call Packet.getPayload(msg, call Packet.maxPayloadLength()),
- call Packet.payloadLength(msg));
+ msg = signal Receive.receive(msg);
atomic
{
return m;
}
- default event message_t* Receive.receive(message_t* msg, void* payload, uint8_t len)
- {
- return msg;
- }
}
#include <PacketLinkLayer.h>
-#warning "*** USING PACKET LINK LAYER"
-
configuration PacketLinkLayerC {
provides {
- interface Send;
+ interface BareSend as Send;
interface PacketLink;
interface RadioPacket;
}
uses {
- interface Send as SubSend;
+ interface BareSend as SubSend;
interface RadioPacket as SubPacket;
interface PacketAcknowledgements;
}
module PacketLinkLayerP {
provides {
- interface Send;
+ interface BareSend as Send;
interface PacketLink;
interface RadioPacket;
}
uses {
- interface Send as SubSend;
+ interface BareSend as SubSend;
interface PacketAcknowledgements;
interface Timer<TMilli> as DelayTimer;
interface RadioPacket as SubPacket;
/** The message currently being sent */
message_t *currentSendMsg;
- /** Length of the current send message */
- uint8_t currentSendLen;
-
/** The length of the current send message */
uint16_t totalRetries;
* a broadcast address message, the receiving end does not
* signal receive() more than once for that message.
*/
- command error_t Send.send(message_t *msg, uint8_t len) {
+ command error_t Send.send(message_t *msg) {
error_t error = EBUSY;
if(currentSendMsg == NULL) {
call PacketAcknowledgements.requestAck(msg);
}
- if((error = call SubSend.send(msg, len)) == SUCCESS) {
+ if((error = call SubSend.send(msg)) == SUCCESS) {
currentSendMsg = msg;
- currentSendLen = len;
totalRetries = 0;
}
}
return FAIL;
}
-
- command uint8_t Send.maxPayloadLength() {
- return call SubSend.maxPayloadLength();
- }
-
- command void *Send.getPayload(message_t* msg, uint8_t len) {
- return call SubSend.getPayload(msg, len);
- }
-
/***************** SubSend Events ***************/
event void SubSend.sendDone(message_t* msg, error_t error) {
totalRetries++;
call PacketAcknowledgements.requestAck(currentSendMsg);
}
- if(call SubSend.send(currentSendMsg, currentSendLen) != SUCCESS) {
+ if(call SubSend.send(currentSendMsg) != SUCCESS) {
post send();
}
}
provides
{
// NOTE, this is a combined layer, should be hooked up at two places
- interface Send;
+ interface BareSend as Send;
interface RadioReceive;
}
uses
{
- interface Send as SubSend;
+ interface BareSend as SubSend;
interface RadioReceive as SubReceive;
interface UniqueConfig as Config;
{
provides
{
- interface Send;
+ interface BareSend as Send;
interface RadioReceive;
interface Init;
uses
{
- interface Send as SubSend;
+ interface BareSend as SubSend;
interface RadioReceive as SubReceive;
interface UniqueConfig;
return SUCCESS;
}
- command error_t Send.send(message_t* msg, uint8_t len)
+ command error_t Send.send(message_t* msg)
{
call UniqueConfig.setSequenceNumber(msg, ++sequenceNumber);
- return call SubSend.send(msg, len);
+ return call SubSend.send(msg);
}
command error_t Send.cancel(message_t* msg)
signal Send.sendDone(msg, error);
}
- command uint8_t Send.maxPayloadLength()
- {
- return call SubSend.maxPayloadLength();
- }
-
- command void* Send.getPayload(message_t* msg, uint8_t len)
- {
- return call SubSend.getPayload(msg, len);
- }
-
tasklet_async event bool SubReceive.header(message_t* msg)
{
// we could scan here, but better be lazy
#else
components LowpanNetworkLayerC;
#endif
- LowpanNetworkLayerC.SubSend -> UniqueLayerC;
+ LowpanNetworkLayerC.SubSend -> IEEE154MessageLayerC;
LowpanNetworkLayerC.SubReceive -> LowPowerListeningLayerC;
LowpanNetworkLayerC.SubPacket -> IEEE154MessageLayerC;
components IEEE154MessageLayerC;
IEEE154MessageLayerC.SubPacket -> LowPowerListeningLayerC;
+ IEEE154MessageLayerC.SubSend -> UniqueLayerC;
// -------- UniqueLayer Send part (wired twice)
// -------- Low Power Listening
#ifdef LOW_POWER_LISTENING
+ #warning "*** USING LOW POWER LISTENING LAYER"
components LowPowerListeningLayerC;
LowPowerListeningLayerC.Config -> RF212ActiveMessageP;
LowPowerListeningLayerC.PacketAcknowledgements -> SoftwareAckLayerC;
// -------- Packet Link
#ifdef PACKET_LINK
+ #warning "*** USING PACKET LINK LAYER"
components PacketLinkLayerC;
PacketLink = PacketLinkLayerC;
PacketLinkLayerC.PacketAcknowledgements -> SoftwareAckLayerC;
// -------- MessageBuffer
components MessageBufferLayerC;
- MessageBufferLayerC.Packet -> ActiveMessageLayerC;
MessageBufferLayerC.RadioSend -> TrafficMonitorLayerC;
MessageBufferLayerC.RadioReceive -> UniqueLayerC;
MessageBufferLayerC.RadioState -> TrafficMonitorLayerC;
/*----------------- ActiveMessageConfig -----------------*/
- command bool ActiveMessageConfig.forgotToClear(message_t* msg)
- {
- return ! call IEEE154MessageLayer.isDataFrame(msg);
- }
-
command am_addr_t ActiveMessageConfig.destination(message_t* msg)
{
return call IEEE154MessageLayer.getDestAddr(msg);
#else
components LowpanNetworkLayerC;
#endif
- LowpanNetworkLayerC.SubSend -> UniqueLayerC;
+ LowpanNetworkLayerC.SubSend -> IEEE154MessageLayerC;
LowpanNetworkLayerC.SubReceive -> LowPowerListeningLayerC;
LowpanNetworkLayerC.SubPacket -> IEEE154MessageLayerC;
components IEEE154MessageLayerC;
IEEE154MessageLayerC.SubPacket -> LowPowerListeningLayerC;
+ IEEE154MessageLayerC.SubSend -> UniqueLayerC;
// -------- UniqueLayer Send part (wired twice)
// -------- Low Power Listening
#ifdef LOW_POWER_LISTENING
+ #warning "*** USING LOW POWER LISTENING LAYER"
components LowPowerListeningLayerC;
LowPowerListeningLayerC.Config -> RF230ActiveMessageP;
LowPowerListeningLayerC.PacketAcknowledgements -> SoftwareAckLayerC;
// -------- Packet Link
#ifdef PACKET_LINK
+ #warning "*** USING PACKET LINK LAYER"
components PacketLinkLayerC;
PacketLink = PacketLinkLayerC;
PacketLinkLayerC.PacketAcknowledgements -> SoftwareAckLayerC;
// -------- MessageBuffer
components MessageBufferLayerC;
- MessageBufferLayerC.Packet -> ActiveMessageLayerC;
MessageBufferLayerC.RadioSend -> TrafficMonitorLayerC;
MessageBufferLayerC.RadioReceive -> UniqueLayerC;
MessageBufferLayerC.RadioState -> TrafficMonitorLayerC;
/*----------------- ActiveMessageConfig -----------------*/
- command bool ActiveMessageConfig.forgotToClear(message_t* msg)
- {
- return ! call IEEE154MessageLayer.isDataFrame(msg);
- }
-
command am_addr_t ActiveMessageConfig.destination(message_t* msg)
{
return call IEEE154MessageLayer.getDestAddr(msg);
--- /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
+ */
+
+interface BareReceive
+{
+ /**
+ * Signals the reception of a message, but only for those messages for
+ * which SUCCESS was returned in the header event. The usual owner rules
+ * apply to the message pointers.
+ */
+ event message_t* receive(message_t* msg);
+}
--- /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
+ */
+
+interface BareSend
+{
+ /**
+ * Starts the transmission of the given message. This command must not
+ * be called while another send is in progress (so one must wait for the
+ * sendDone event). Returns EBUSY if a reception is in progress or for
+ * some other reason the request cannot be temporarily satisfied (e.g.
+ * the SPI bus access could not be acquired). In this case the send
+ * command could be retried from a task. Returns SUCCESS if the
+ * transmission could be started. In this case sendDone will be fired.
+ */
+ command error_t send(message_t* msg);
+
+ /**
+ * Signals the completion of the send command, exactly once for each
+ * successfull send command. If the returned error code is SUCCESS, then
+ * the message was sent (may not have been acknowledged), otherwise
+ * the message was not transmitted over the air.
+ */
+ event void sendDone(message_t* msg, error_t error);
+
+ /**
+ * Cancel a requested transmission. Returns SUCCESS if the
+ * transmission was cancelled properly (not sent in its
+ * entirety). Note that the component may not know
+ * if the send was successfully cancelled, if the radio is
+ * handling much of the logic; in this case, a component
+ * should be conservative and return an appropriate error code.
+ */
+ command error_t cancel(message_t* msg);
+}
projects / tinyos-2.x.git / commitdiff