* Return the AM address of the destination of the AM packet.
* If <tt>amsg</tt> is not an AM packet, the results of this command
* are undefined.
- * @param amsg the packet
+ * @param 'message_t* ONE amsg' the packet
* @return the destination address of the packet.
*/
* Return the AM address of the source of the AM packet.
* If <tt>amsg</tt> is not an AM packet, the results of this command
* are undefined.
- * @param amsg the packet
+ * @param 'message_t* ONE amsg' the packet
* @return the source address of the packet.
*/
* and then recover it when actually sending. If <tt>amsg</tt> is
* not an AM packet, the results of this command are undefined.
*
- * @param amsg the packet
+ * @param 'message_t* ONE amsg' the packet
* @param addr the address
*/
* layer (e.g., a protocol bridge). If <tt>amsg</tt> is
* not an AM packet, the results of this command are undefined.
*
- * @param amsg the packet
+ * @param 'message_t* ONE amsg' the packet
* @param addr the address
*/
* the mote's local address. If <tt>amsg</tt> is not an AM packet,
* the results of this command are undefined.
*
- * @param amsg the packet
+ * @param 'message_t* ONE amsg' the packet
* @return whether the packet is addressed to this AM stack
*/
command bool isForMe(message_t* amsg);
* If <tt>amsg</tt> is not an AM packet, the results of this command
* are undefined.
*
- * @param amsg the packet
+ * @param 'message_t* ONE amsg' the packet
* @return the AM type
*/
* sending. If <tt>amsg</tt> is not an AM packet, the results of
* this command are undefined.
*
- * @param amsg the packet
+ * @param 'message_t* ONE amsg' the packet
* @param t the AM type
*/
* nodes only receive packets whose AM group field matches their
* own.
*
- * @param amsg the packet
+ * @param 'message_t* ONE amsg' the packet
* @return the AM group of this packet
*/
* stacks will set this field automatically on a send request, which
* may overwrite changes made with this command.
*
- * @param amsg the packet
+ * @param 'message_t* ONE amsg' the packet
* @param group the packet's new AM group value
*/
command void setGroup(message_t* amsg, am_group_t grp);
* will signal sendDone with error code.
*
* @param addr address to which to send the packet
- * @param msg the packet
+ * @param 'message_t* ONE msg' the packet
* @param len the length of the data in the packet payload
* @return SUCCESS if the request to send succeeded and a
* sendDone will be signaled later, EBUSY if the
* A successful call to cancel must always result in a
* sendFailed event, and never a sendSucceeded event.
*
- * @param msg the packet whose transmission should be cancelled.
+ * @param 'message_t* ONE msg' the packet whose transmission should be cancelled.
* @return SUCCESS if the transmission was cancelled, FAIL otherwise.
* @see sendDone
*/
* the message buffer sent, and <tt>error</tt> indicates whether
* the send was successful.
*
- * @param msg the packet which was submitted as a send request
+ * @param 'message_t* ONE msg' the packet which was submitted as a send request
* @param error SUCCESS if it was sent successfully, FAIL if it was not,
* ECANCEL if it was cancelled
* @see send
* (minus the length parameter) and is included in this interface
* as a convenience.
*
- * @param msg the packet
- * @return the payload of the packet
+ * @param 'message_t* ONE msg' the packet
+ * @return 'void* COUNT(len)' the payload of the packet
*/
command void* getPayload(message_t* msg, uint8_t len);
* operation.
*
* @param addr starting address to begin reading.
- * @param buf buffer to place read data.
+ * @param 'void* COUNT(len) buf' buffer to place read data.
* @param len number of bytes to read.
* @return
* <li>SUCCESS if the request was accepted,
* Signals the completion of a read operation.
*
* @param addr starting address of read.
- * @param buf buffer where read data was placed.
+ * @param 'void* COUNT(len) buf' buffer where read data was placed.
* @param len number of bytes read.
* @param error SUCCESS if the operation was successful, FAIL if
* it failed
* Between two erases, no byte may be written more than once.
*
* @param addr starting address to begin write.
- * @param buf buffer to write data from.
+ * @param 'void* COUNT(len) buf' buffer to write data from.
* @param len number of bytes to write.
* @return
* <li>SUCCESS if the request was accepted,
* been completed.
*
* @param addr starting address of write.
- * @param buf buffer that written data was read from.
+ * @param 'void* COUNT(len) buf' buffer that written data was read from.
* @param len number of bytes written.
* @param error SUCCESS if the operation was successful, FAIL if
* it failed
* as of the last commit operation.
*
* @param addr starting address to begin reading.
- * @param buf buffer to place read data.
+ * @param 'void* COUNT(len) buf' buffer to place read data.
* @param len number of bytes to read.
* @return
* <li>SUCCESS if the request was accepted,
* Signals the completion of a read operation.
*
* @param addr starting address of read.
- * @param buf buffer where read data was placed.
+ * @param 'void* COUNT(len) buf' buffer where read data was placed.
* @param len number of bytes read.
* @param error SUCCESS if the operation was successful, FAIL if
* it failed
* operation.
*
* @param addr starting address to begin write.
- * @param buf buffer to write data from.
+ * @param 'void* COUNT(len) buf' buffer to write data from.
* @param len number of bytes to write.
* @return
* <li>SUCCESS if the request was accepted,
* been completed.
*
* @param addr starting address of write.
- * @param buf buffer that written data was read from.
+ * @param 'void* COUNT(len) buf' buffer that written data was read from.
* @param len number of bytes written.
* @param error SUCCESS if the operation was successful, FAIL if
* it failed
/**
* Compute the CRC-16 value of a byte array.
*
- * @param buf A pointer to the buffer over which to compute CRC.
+ * @param 'void* COUNT(len) buf' A pointer to the buffer over which to compute CRC.
* @param len The length of the buffer over which to compute CRC.
* @return The CRC-16 value.
*/
* of discontinuous data.
*
* @param startCrc An initial CRC value to begin with
- * @param buf A pointer to a buffer of data
+ * @param 'void* COUNT(len) buf' A pointer to a buffer of data
* @param len The length of the buffer
* @return The CRC-16 value.
*/
/**
* Return initial backoff time before attempting to send message m. The
* units are radio dependent.
+ * @param 'message_t* ONE m'
* @return Initial backoff time
*/
async event uint16_t initial(message_t* m);
/**
* Return backoff time after message m could not be send due to congestion.
* The units are raio dependent.
+ * @param 'message_t* ONE m'
* @return Backoff time after congestion
*/
async event uint16_t congestion(message_t* m);
* flag cannot be used with the I2C_STOP flag.
* @param addr The slave device address. Only used if I2C_START is set.
* @param length Length, in bytes, to be read
- * @param data A point to a data buffer to read into
+ * @param 'uint8_t* COUNT(length) data' A point to a data buffer to read into
*
* @return SUCCESS if bus available and request accepted.
*/
* packet if set.
* @param addr The slave device address. Only used if I2C_START is set.
* @param length Length, in bytes, to be read
- * @param data A point to a data buffer to read into
+ * @param 'uint8_t* COUNT(length) data' A point to a data buffer to read into
*
* @return SUCCESS if bus available and request accepted.
*/
*
* @param addr The slave device address
* @param length Length, in bytes, read
- * @param data Pointer to the received data buffer
+ * @param 'uint8_t* COUNT(length) data' Pointer to the received data buffer
* @param success SUCCESS if transfer completed without error.
*/
async event void readDone(error_t error, uint16_t addr, uint8_t length, uint8_t* data);
*
* @param addr The slave device address
* @param length Length, in bytes, written
- * @param data Pointer to the data buffer written
+ * @param 'uint8_t* COUNT(length) data' Pointer to the data buffer written
* @param success SUCCESS if transfer completed without error.
*/
async event void writeDone(error_t error, uint16_t addr, uint8_t length, uint8_t* data);
* Signals that a message has been received, which is supposed to be
* forwarded to another destination.
*
- * @param msg The complete message received.
+ * @param 'message_t* ONE msg' The complete message received.
*
- * @param payload The payload portion of the packet for this
+ * @param 'void* COUNT(len) payload' The payload portion of the packet for this
* protocol layer.
*
* @param len The length of the payload buffer.
* return them in <code>buf</code>.
*
* @param addr A pointer to the starting address from which to read.
- * @param buf A pointer to the buffer into which read bytes are
+ * @param 'void* COUNT(size) buf' A pointer to the buffer into which read bytes are
* placed.
* @param size The number of bytes to read.
* @return SUCCESS if the bytes were successfully read.
* flash starting at <code>addr</code>.
*
* @param addr A pointer to the starting address to which to write.
- * @param buf A pointer to the buffer from which bytes are read.
+ * @param 'void* COUNT(size) buf' A pointer to the buffer from which bytes are read.
* @param size The number of bytes to write.
* @return SUCCESS if the bytes were successfully written.
* FAIL if the call could not be completed.
* A good rule of thumb for "high quality" is that the channel quality
* would enable MTU packets to have a reception rate of 90% or greater.
*
- * @param msg A received packet during which the channel was measured.
+ * @param 'message_t* ONE msg' A received packet during which the channel was measured.
* @return Whether the channel had high quality.
*/
async command bool highChannelQuality(message_t* msg);
* volume. On SUCCESS, the <code>readDone</code> event will signal
* completion of the operation.
*
- * @param buf buffer to place read data.
+ * @param 'void* COUNT(len) buf' buffer to place read data.
* @param len number of bytes to read.
* @return
* <li>SUCCESS if the request was accepted,
* advanced by <code>len</code> bytes.
*
* @param addr starting address of read.
- * @param buf buffer where read data was placed.
+ * @param 'void* COUNT(len) buf' buffer where read data was placed.
* @param len number of bytes read - this may be less than requested
* (even equal to 0) if the end of the log was reached
* @param error SUCCESS if read was possible, FAIL otherwise
* Append data to a given volume. On SUCCESS, the <code>appendDone</code>
* event will signal completion of the operation.
*
- * @param buf buffer to write data from.
+ * @param 'void* COUNT(len) buf' buffer to write data from.
* @param len number of bytes to write.
* @return
* <li>SUCCESS if the request was accepted,
* guaranteed to survive a power-cycle unless a commit operation has
* been completed.
*
- * @param buf buffer that written data was read from.
+ * @param 'void* COUNT(len) buf' buffer that written data was read from.
* @param len number of bytes actually written (valid even in case of error)
* @param records_lost TRUE if this append destroyed some old records from
* the beginning of the log (only possible for circular logs).
/**
* Configure this outgoing message so it can be transmitted to a neighbor mote
* with the specified Rx sleep interval.
- * @param msg Pointer to the message that will be sent
+ * @param 'message_t* ONE msg' Pointer to the message that will be sent
* @param sleepInterval The receiving node's sleep interval, in [ms]
*/
command void setRxSleepInterval(message_t *msg, uint16_t sleepIntervalMs);
/**
+ * @param 'message_t* ONE msg'
* @return the destination node's sleep interval configured in this message
*/
command uint16_t getRxSleepInterval(message_t *msg);
* with the specified Rx duty cycle rate.
* Duty cycle is in units of [percentage*100], i.e. 0.25% duty cycle = 25.
*
- * @param msg Pointer to the message that will be sent
+ * @param 'message_t* ONE msg' Pointer to the message that will be sent
* @param dutyCycle The duty cycle of the receiving mote, in units of
* [percentage*100]
*/
command void setRxDutyCycle(message_t *msg, uint16_t dutyCycle);
/**
+ * @param 'message_t* ONE msg'
* @return the destination node's duty cycle configured in this message
* in units of [percentage*100]
*/
* Clear out this packet. Note that this is a deep operation and
* total operation: calling clear() on any layer will completely
* clear the packet for reuse.
- * @param msg the packet to clear
+ * @param 'message_t* ONE msg' the packet to clear
*/
command void clear(message_t* msg);
* sized data regions, then payloadLength() will always return
* the same value as maxPayloadLength().
*
- * @param msg the packet to examine
+ * @param 'message_t* ONE msg' the packet to examine
* @return the length of its current payload
*/
* specified in the request and later recover it when actually
* sending.
*
- * @param msg the packet
+ * @param 'message_t* ONE msg' the packet
* @param len the value to set its length field to
*/
* a given <tt>msg</tt> this command will always return the same
* pointer or NULL.
*
- * @param msg the packet
+ * @param 'message_t* ONE msg' the packet
* @param len the length of payload required
- * @return a pointer to the packet's data payload for this layer
+ * @return 'void* COUNT_NOK(len)' a pointer to the packet's data payload for this layer
* or NULL if <tt>len</tt> is too big
*/
command void* getPayload(message_t* msg, uint8_t len);
* ack was received through the wasAcked() command as soon as a send operation
* completes.
*
- * @param msg - A message which should be acknowledged when transmitted.
+ * @param 'message_t* ONE msg' - A message which should be acknowledged when transmitted.
* @return SUCCESS if acknowledgements are enabled, EBUSY
* if the communication layer cannot enable them at this time, FAIL
* if it does not support them.
* Tell a protocol that when it sends this packet, it should not use
* synchronous acknowledgments.
*
- * @param msg - A message which should not be acknowledged when transmitted.
+ * @param 'message_t* ONE msg' - A message which should not be acknowledged when transmitted.
* @return SUCCESS if acknowledgements are disabled, EBUSY
* if the communication layer cannot disable them at this time, FAIL
* if it cannot support unacknowledged communication.
* layer does not support acknowledgements, this command must return always
* return FALSE.
*
- * @param msg - A transmitted message.
+ * @param 'message_t* ONE msg' - A transmitted message.
* @return Whether the packet was acknowledged.
*
*/
/**
* Set the maximum number of times attempt message delivery
* Default is 0
- * @param msg
+ * @param 'message_t* ONE msg'
* @param maxRetries the maximum number of attempts to deliver
* the message
*/
command void setRetryDelay(message_t *msg, uint16_t retryDelay);
/**
+ * @param 'message_t* ONE msg'
* @return the maximum number of retry attempts for this message
*/
command uint16_t getRetries(message_t *msg);
/**
+ * @param 'message_t* ONE msg'
* @return the delay between retry attempts in ms for this message
*/
command uint16_t getRetryDelay(message_t *msg);
/**
+ * @param 'message_t* ONE msg'
* @return TRUE if the message was delivered.
*/
command bool wasDelivered(message_t *msg);
/**
* Deallocate an object, putting it back into the pool.
*
+ * @param 't* ONE newVal'
* @return SUCCESS if the entry was put in successfully, FAIL
* if the pool is full.
*/
/**
* Allocate an element from the pool.
*
- * @return A pointer if the pool is not empty, NULL if
+ * @return 't* ONE_NOK' A pointer if the pool is not empty, NULL if
* the pool is empty.
*/
command t* get();
* Get the head of the queue without removing it. If the queue
* is empty, the return value is undefined.
*
- * @return The head of the queue.
+ * @return 't ONE' The head of the queue.
*/
command t head();
* Remove the head of the queue. If the queue is empty, the return
* value is undefined.
*
- * @return The head of the queue.
+ * @return 't ONE' The head of the queue.
*/
command t dequeue();
/**
* Enqueue an element to the tail of the queue.
*
- * @param newVal - the element to enqueue
+ * @param 't ONE newVal' - the element to enqueue
* @return SUCCESS if the element was enqueued successfully, FAIL
* if it was not enqueued.
*/
* the return value is undefined.
*
* @param index - the index of the element to return
- * @return the requested element in the queue.
+ * @return 't ONE' the requested element in the queue.
*/
command t element(uint8_t idx);
}
/**
* Provides the time at which start of frame delimiter has been
* transmitted: units are in terms of a 32kHz clock.
+ * @param 'message_t* ONE p_msg'
*/
async event void transmittedSFD( uint16_t time, message_t* p_msg );
/**
* Initiates a read of the value.
*
- * @param val a pointer to space that will be filled by the value
+ * @param 'val_t* ONE val' a pointer to space that will be filled by the value
*
* @return SUCCESS if a readDone() event will eventually come back.
*/
* be the same as the original pointer passed to read().
*
* @param result SUCCESS if the read() was successful
- * @param val a pointer to the value that has been read
+ * @param 'val_t* ONE val' a pointer to the value that has been read
*/
event void readDone( error_t result, val_t* val );
}
* should be placed into the buffer. Make sure your count doesn't
* overrun the buffer.
*
- * @param buf a pointer to the buffer
+ * @param 'val_t* COUNT(count) buf' a pointer to the buffer
* @param count the number of values the buffer should hold
*
* @return SUCCESS if the post was successful
* SUCCESS, and the buffer will be filled with zeroes.
*
* @param result SUCCESS if the buffer was filled without errors
- * @param buf a pointer to the buffer that has been filled
+ * @param 'val_t* COUNT(count) buf' a pointer to the buffer that has been filled
* @param count the number of values actually read
*/
event void bufferDone(error_t result,
* the component's data. This would cause the mote to possibly
* instead send a packet it most recently received.
*
- * @param msg the receied packet
- * @param payload a pointer to the packet's payload
+ * @param 'message_t* ONE msg' the receied packet
+ * @param 'void* COUNT(len) payload' a pointer to the packet's payload
* @param len the length of the data region pointed to by payload
- * @return a packet buffer for the stack to use for the next
+ * @return 'message_t* ONE' a packet buffer for the stack to use for the next
* received packet.
*/
* cannot satisfy; in this case, it will signal sendDone with an
* appropriate error code.
*
- * @param msg the packet to send
+ * @param 'message_t* ONE msg' the packet to send
* @param len the length of the packet payload
* @return SUCCESS if the request was accepted and will issue
* a sendDone event, EBUSY if the component cannot accept
* handling much of the logic; in this case, a component
* should be conservative and return an appropriate error code.
*
- * @param msg the packet whose transmission should be cancelled
+ * @param 'message_t* ONE msg' the packet whose transmission should be cancelled
* @return SUCCESS if the packet was successfully cancelled, FAIL
* otherwise
*/
* is the sent buffer, and <tt>error</tt> indicates whether the
* send was succesful, and if not, the cause of the failure.
*
- * @param msg the message which was requested to send
+ * @param 'message_t* ONE msg' the message which was requested to send
* @param error SUCCESS if it was transmitted successfully, FAIL if
* it was not, ECANCEL if it was cancelled via <tt>cancel</tt>
*/
* behaves identicallt to <tt>Packet.getPayload</tt> and is
* included in this interface as a convenience.
*
- * @param msg the packet
- * @return a pointer to the packet's payload
+ * @param 'message_t* ONE msg' the packet
+ * @return 'void* COUNT_NOK(len)' a pointer to the packet's payload
*/
command void* getPayload(message_t* msg, uint8_t len);
* and the message will be sent.
*
* @param dest The destination address of the messsage
- * @param msg The message about to be transmitted
+ * @param 'message_t* ONE msg' The message about to be transmitted
*/
event void aboutToSend(am_addr_t dest, message_t *msg);
/**
* Send a message over the SPI bus.
*
- * @param txBuf A pointer to the buffer to send over the bus. If this
+ * @param 'uint8_t* COUNT_NOK(len) txBuf' A pointer to the buffer to send over the bus. If this
* parameter is NULL, then the SPI will send zeroes.
- * @param rxBuf A pointer to the buffer where received data should
+ * @param 'uint8_t* COUNT_NOK(len) rxBuf' A pointer to the buffer where received data should
* be stored. If this parameter is NULL, then the SPI will
* discard incoming bytes.
* @param len Length of the message. Note that non-NULL rxBuf and txBuf
/**
* Notification that the send command has completed.
*
- * @param txBuf The buffer used for transmission
- * @param rxBuf The buffer used for reception
+ * @param 'uint8_t* COUNT(len) txBuf' The buffer used for transmission
+ * @param 'uint8_t* COUNT(len) rxBuf' The buffer used for reception
* @param len The request length of the transfer, but not necessarily
* the number of bytes that were actually transferred
* @param error SUCCESS if the operation completed successfully, FAIL
* Receive a single uart byte. The call blocks until a byte is
* received.
*
- * @param byte Where to place received byte.
+ * @param 'uint8_t* ONE byte' Where to place received byte.
* @param timeout How long in byte times to wait.
* @return SUCCESS if a byte was received, FAIL if timed out.
*/
* <code>sendDone</code> will be signalled when transmission is
* complete.
*
- * @param buf Buffer for bytes to send.
+ * @param 'uint8_t* COUNT(len) buf' Buffer for bytes to send.
* @param len Number of bytes to send.
* @return SUCCESS if request was accepted, FAIL otherwise.
*/
/**
* Signal completion of sending a stream.
*
- * @param buf Bytes sent.
+ * @param 'uint8_t* COUNT(len) buf' Bytes sent.
* @param len Number of bytes sent.
* @param error SUCCESS if the transmission was successful, FAIL otherwise.
*/
* <code>receiveDone</code> will be signalled when reception is
* complete.
*
- * @param buf Buffer for received bytes.
+ * @param 'uint8_t* COUNT(len) buf' Buffer for received bytes.
* @param len Number of bytes to receive.
* @return SUCCESS if request was accepted, FAIL otherwise.
*/
/**
* Signal completion of receiving a stream.
*
- * @param buf Buffer for bytes received.
+ * @param 'uint8_t* COUNT(len) buf' Buffer for bytes received.
* @param len Number of bytes received.
* @param error SUCCESS if the reception was successful, FAIL otherwise.
*/
projects / tinyos-2.x.git / commitdiff