From 60c48d649028ec3c897fa24cc8dc1cd5739c17c6 Mon Sep 17 00:00:00 2001 From: janhauer Date: Mon, 16 Jun 2008 18:00:22 +0000 Subject: [PATCH] Initial version of TKN15.4, a platform-independent IEEE 802.15.4-2006 MAC implementation (see tinyos-2.x/tos/lib/mac/tkn154/README.txt) --- tos/lib/mac/tkn154/AssociateP.nc | 473 ++++++++ tos/lib/mac/tkn154/BackupP.nc | 57 + tos/lib/mac/tkn154/BeaconSynchronizeP.nc | 442 +++++++ tos/lib/mac/tkn154/BeaconTransmitP.nc | 815 +++++++++++++ tos/lib/mac/tkn154/CapP.nc | 664 ++++++++++ tos/lib/mac/tkn154/CapQueueP.nc | 128 ++ tos/lib/mac/tkn154/CoordBroadcastP.nc | 146 +++ tos/lib/mac/tkn154/CoordRealignmentP.nc | 220 ++++ tos/lib/mac/tkn154/DataP.nc | 278 +++++ tos/lib/mac/tkn154/FrameDispatchImplP.nc | 213 ++++ tos/lib/mac/tkn154/FrameDispatchP.nc | 77 ++ tos/lib/mac/tkn154/IndirectTxP.nc | 300 +++++ tos/lib/mac/tkn154/PibP.nc | 1064 +++++++++++++++++ tos/lib/mac/tkn154/PollP.nc | 223 ++++ tos/lib/mac/tkn154/README.txt | 66 + tos/lib/mac/tkn154/RadioClientC.nc | 75 ++ tos/lib/mac/tkn154/RxEnableP.nc | 274 +++++ tos/lib/mac/tkn154/ScanP.nc | 402 +++++++ .../SimpleRoundRobinTransferArbiterC.nc | 98 ++ tos/lib/mac/tkn154/SimpleTransferArbiterP.nc | 215 ++++ tos/lib/mac/tkn154/TKN154.h | 262 ++++ tos/lib/mac/tkn154/TKN154P.nc | 524 ++++++++ tos/lib/mac/tkn154/TKN154_DEBUG.h | 231 ++++ tos/lib/mac/tkn154/TKN154_MAC.h | 239 ++++ tos/lib/mac/tkn154/TKN154_PIB.h | 167 +++ tos/lib/mac/tkn154/TransferClientP.nc | 75 ++ .../tkn154/dummies/NoBeaconSynchronizeP.nc | 131 ++ .../mac/tkn154/dummies/NoBeaconTransmitP.nc | 215 ++++ tos/lib/mac/tkn154/dummies/NoCapP.nc | 123 ++ tos/lib/mac/tkn154/dummies/NoCapQueueP.nc | 69 ++ tos/lib/mac/tkn154/dummies/NoCoordCfpP.nc | 141 +++ tos/lib/mac/tkn154/dummies/NoDebugP.nc | 54 + .../mac/tkn154/dummies/NoDeviceCapQueueP.nc | 63 + tos/lib/mac/tkn154/dummies/NoDeviceCfpP.nc | 124 ++ tos/lib/mac/tkn154/dummies/NoScanP.nc | 106 ++ .../mac/tkn154/interfaces/MCPS/MCPS_DATA.nc | 102 ++ .../mac/tkn154/interfaces/MCPS/MCPS_PURGE.nc | 53 + .../tkn154/interfaces/MLME/MLME_ASSOCIATE.nc | 120 ++ .../interfaces/MLME/MLME_BEACON_NOTIFY.nc | 54 + .../interfaces/MLME/MLME_COMM_STATUS.nc | 62 + .../interfaces/MLME/MLME_DISASSOCIATE.nc | 102 ++ .../mac/tkn154/interfaces/MLME/MLME_GET.nc | 166 +++ .../mac/tkn154/interfaces/MLME/MLME_GTS.nc | 86 ++ .../mac/tkn154/interfaces/MLME/MLME_ORPHAN.nc | 80 ++ .../mac/tkn154/interfaces/MLME/MLME_POLL.nc | 71 ++ .../mac/tkn154/interfaces/MLME/MLME_RESET.nc | 83 ++ .../tkn154/interfaces/MLME/MLME_RX_ENABLE.nc | 73 ++ .../mac/tkn154/interfaces/MLME/MLME_SCAN.nc | 123 ++ .../mac/tkn154/interfaces/MLME/MLME_SET.nc | 187 +++ .../mac/tkn154/interfaces/MLME/MLME_START.nc | 107 ++ .../mac/tkn154/interfaces/MLME/MLME_SYNC.nc | 60 + .../tkn154/interfaces/MLME/MLME_SYNC_LOSS.nc | 60 + .../tkn154/interfaces/private/DataRequest.nc | 53 + .../interfaces/private/EnergyDetection.nc | 62 + .../interfaces/private/FrameExtracted.nc | 44 + .../mac/tkn154/interfaces/private/FrameRx.nc | 45 + .../mac/tkn154/interfaces/private/FrameTx.nc | 52 + .../tkn154/interfaces/private/FrameTxNow.nc | 54 + .../tkn154/interfaces/private/FrameUtility.nc | 65 + .../interfaces/private/Ieee802154Debug.nc | 39 + .../mac/tkn154/interfaces/private/Purge.nc | 39 + .../mac/tkn154/interfaces/private/RadioOff.nc | 59 + .../mac/tkn154/interfaces/private/RadioRx.nc | 93 ++ .../mac/tkn154/interfaces/private/RadioTx.nc | 166 +++ .../interfaces/private/ResourceTransfer.nc | 58 + .../private/ResourceTransferConnector.nc | 38 + .../private/ResourceTransferControl.nc | 38 + .../interfaces/private/ResourceTransferred.nc | 59 + .../mac/tkn154/interfaces/private/TimeCalc.nc | 48 + .../interfaces/private/WriteBeaconField.nc | 39 + .../interfaces/public/IEEE154BeaconFrame.nc | 137 +++ .../tkn154/interfaces/public/IEEE154Frame.nc | 245 ++++ .../public/IEEE154TxBeaconPayload.nc | 133 +++ 73 files changed, 11909 insertions(+) create mode 100644 tos/lib/mac/tkn154/AssociateP.nc create mode 100644 tos/lib/mac/tkn154/BackupP.nc create mode 100644 tos/lib/mac/tkn154/BeaconSynchronizeP.nc create mode 100644 tos/lib/mac/tkn154/BeaconTransmitP.nc create mode 100644 tos/lib/mac/tkn154/CapP.nc create mode 100644 tos/lib/mac/tkn154/CapQueueP.nc create mode 100644 tos/lib/mac/tkn154/CoordBroadcastP.nc create mode 100644 tos/lib/mac/tkn154/CoordRealignmentP.nc create mode 100644 tos/lib/mac/tkn154/DataP.nc create mode 100644 tos/lib/mac/tkn154/FrameDispatchImplP.nc create mode 100644 tos/lib/mac/tkn154/FrameDispatchP.nc create mode 100644 tos/lib/mac/tkn154/IndirectTxP.nc create mode 100644 tos/lib/mac/tkn154/PibP.nc create mode 100644 tos/lib/mac/tkn154/PollP.nc create mode 100644 tos/lib/mac/tkn154/README.txt create mode 100644 tos/lib/mac/tkn154/RadioClientC.nc create mode 100644 tos/lib/mac/tkn154/RxEnableP.nc create mode 100644 tos/lib/mac/tkn154/ScanP.nc create mode 100644 tos/lib/mac/tkn154/SimpleRoundRobinTransferArbiterC.nc create mode 100644 tos/lib/mac/tkn154/SimpleTransferArbiterP.nc create mode 100644 tos/lib/mac/tkn154/TKN154.h create mode 100644 tos/lib/mac/tkn154/TKN154P.nc create mode 100644 tos/lib/mac/tkn154/TKN154_DEBUG.h create mode 100644 tos/lib/mac/tkn154/TKN154_MAC.h create mode 100644 tos/lib/mac/tkn154/TKN154_PIB.h create mode 100644 tos/lib/mac/tkn154/TransferClientP.nc create mode 100644 tos/lib/mac/tkn154/dummies/NoBeaconSynchronizeP.nc create mode 100644 tos/lib/mac/tkn154/dummies/NoBeaconTransmitP.nc create mode 100644 tos/lib/mac/tkn154/dummies/NoCapP.nc create mode 100644 tos/lib/mac/tkn154/dummies/NoCapQueueP.nc create mode 100644 tos/lib/mac/tkn154/dummies/NoCoordCfpP.nc create mode 100644 tos/lib/mac/tkn154/dummies/NoDebugP.nc create mode 100644 tos/lib/mac/tkn154/dummies/NoDeviceCapQueueP.nc create mode 100644 tos/lib/mac/tkn154/dummies/NoDeviceCfpP.nc create mode 100644 tos/lib/mac/tkn154/dummies/NoScanP.nc create mode 100644 tos/lib/mac/tkn154/interfaces/MCPS/MCPS_DATA.nc create mode 100644 tos/lib/mac/tkn154/interfaces/MCPS/MCPS_PURGE.nc create mode 100644 tos/lib/mac/tkn154/interfaces/MLME/MLME_ASSOCIATE.nc create mode 100644 tos/lib/mac/tkn154/interfaces/MLME/MLME_BEACON_NOTIFY.nc create mode 100644 tos/lib/mac/tkn154/interfaces/MLME/MLME_COMM_STATUS.nc create mode 100644 tos/lib/mac/tkn154/interfaces/MLME/MLME_DISASSOCIATE.nc create mode 100644 tos/lib/mac/tkn154/interfaces/MLME/MLME_GET.nc create mode 100644 tos/lib/mac/tkn154/interfaces/MLME/MLME_GTS.nc create mode 100644 tos/lib/mac/tkn154/interfaces/MLME/MLME_ORPHAN.nc create mode 100644 tos/lib/mac/tkn154/interfaces/MLME/MLME_POLL.nc create mode 100644 tos/lib/mac/tkn154/interfaces/MLME/MLME_RESET.nc create mode 100644 tos/lib/mac/tkn154/interfaces/MLME/MLME_RX_ENABLE.nc create mode 100644 tos/lib/mac/tkn154/interfaces/MLME/MLME_SCAN.nc create mode 100644 tos/lib/mac/tkn154/interfaces/MLME/MLME_SET.nc create mode 100644 tos/lib/mac/tkn154/interfaces/MLME/MLME_START.nc create mode 100644 tos/lib/mac/tkn154/interfaces/MLME/MLME_SYNC.nc create mode 100644 tos/lib/mac/tkn154/interfaces/MLME/MLME_SYNC_LOSS.nc create mode 100644 tos/lib/mac/tkn154/interfaces/private/DataRequest.nc create mode 100644 tos/lib/mac/tkn154/interfaces/private/EnergyDetection.nc create mode 100644 tos/lib/mac/tkn154/interfaces/private/FrameExtracted.nc create mode 100644 tos/lib/mac/tkn154/interfaces/private/FrameRx.nc create mode 100644 tos/lib/mac/tkn154/interfaces/private/FrameTx.nc create mode 100644 tos/lib/mac/tkn154/interfaces/private/FrameTxNow.nc create mode 100644 tos/lib/mac/tkn154/interfaces/private/FrameUtility.nc create mode 100644 tos/lib/mac/tkn154/interfaces/private/Ieee802154Debug.nc create mode 100644 tos/lib/mac/tkn154/interfaces/private/Purge.nc create mode 100644 tos/lib/mac/tkn154/interfaces/private/RadioOff.nc create mode 100644 tos/lib/mac/tkn154/interfaces/private/RadioRx.nc create mode 100644 tos/lib/mac/tkn154/interfaces/private/RadioTx.nc create mode 100644 tos/lib/mac/tkn154/interfaces/private/ResourceTransfer.nc create mode 100644 tos/lib/mac/tkn154/interfaces/private/ResourceTransferConnector.nc create mode 100644 tos/lib/mac/tkn154/interfaces/private/ResourceTransferControl.nc create mode 100644 tos/lib/mac/tkn154/interfaces/private/ResourceTransferred.nc create mode 100644 tos/lib/mac/tkn154/interfaces/private/TimeCalc.nc create mode 100644 tos/lib/mac/tkn154/interfaces/private/WriteBeaconField.nc create mode 100644 tos/lib/mac/tkn154/interfaces/public/IEEE154BeaconFrame.nc create mode 100644 tos/lib/mac/tkn154/interfaces/public/IEEE154Frame.nc create mode 100644 tos/lib/mac/tkn154/interfaces/public/IEEE154TxBeaconPayload.nc diff --git a/tos/lib/mac/tkn154/AssociateP.nc b/tos/lib/mac/tkn154/AssociateP.nc new file mode 100644 index 00000000..c1b8c2b6 --- /dev/null +++ b/tos/lib/mac/tkn154/AssociateP.nc @@ -0,0 +1,473 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + + +#include "TKN154_MAC.h" + +module AssociateP +{ + provides + { + interface Init; + interface MLME_ASSOCIATE; + interface MLME_DISASSOCIATE; + interface MLME_COMM_STATUS; + } + uses + { + interface FrameRx as AssociationRequestRx; + interface FrameTx as AssociationRequestTx; + interface FrameExtracted as AssociationResponseExtracted; + interface FrameTx as AssociationResponseTx; + + interface FrameTx as DisassociationIndirectTx; + interface FrameTx as DisassociationDirectTx; + interface FrameTx as DisassociationToCoord; + + interface FrameRx as DisassociationDirectRxFromCoord; + interface FrameExtracted as DisassociationExtractedFromCoord; + interface FrameRx as DisassociationRxFromDevice; + + interface DataRequest; + interface Timer as ResponseTimeout; + interface Get as IsTrackingBeacons; + interface Pool as TxFramePool; + interface Pool as TxControlPool; + interface MLME_GET; + interface MLME_SET; + interface FrameUtility; + interface IEEE154Frame as Frame; + interface Leds; + interface Get as LocalExtendedAddress; + interface Ieee802154Debug as Debug; + } +} +implementation +{ + enum { + S_IDLE = 0xFF, + }; + uint8_t m_payloadAssocRequest[2]; + uint8_t m_payloadDisassocRequest[2]; + uint8_t m_payloadAssocResponse[MAX_PENDING_ASSOC_RESPONSES][4]; + uint8_t m_coordAddrMode; + uint8_t m_assocRespStatus; + uint16_t m_shortAddress; + bool m_associationOngoing; + bool m_disAssociationOngoing; + + command error_t Init.init() + { + uint8_t i; + call ResponseTimeout.stop(); + m_payloadAssocRequest[0] = S_IDLE; + m_payloadDisassocRequest[0] = S_IDLE; + m_coordAddrMode = 0; + m_associationOngoing = FALSE; + m_disAssociationOngoing = FALSE; + for (i=0; iSecurityLevel) + status = IEEE154_UNSUPPORTED_SECURITY; + else if (ChannelPage != IEEE154_SUPPORTED_CHANNELPAGE || LogicalChannel > 26 || + !(IEEE154_SUPPORTED_CHANNELS & ((uint32_t) 1 << LogicalChannel)) || + (CoordAddrMode != ADDR_MODE_SHORT_ADDRESS && CoordAddrMode != ADDR_MODE_EXTENDED_ADDRESS)) + status = IEEE154_INVALID_PARAMETER; + else if (m_associationOngoing || !(txFrame = call TxFramePool.get())) + status = IEEE154_TRANSACTION_OVERFLOW; + else if (!(txControl = call TxControlPool.get())){ + call TxFramePool.put(txFrame); + status = IEEE154_TRANSACTION_OVERFLOW; + } + if (status == IEEE154_SUCCESS){ + m_assocRespStatus = IEEE154_NO_DATA; + m_shortAddress = 0xFFFF; + call MLME_SET.phyCurrentChannel(LogicalChannel); + call MLME_SET.macPANId(CoordPANID); + m_coordAddrMode = CoordAddrMode; + if (CoordAddrMode == ADDR_MODE_SHORT_ADDRESS) + call MLME_SET.macCoordShortAddress(CoordAddress.shortAddress); + else + call MLME_SET.macCoordExtendedAddress(CoordAddress.extendedAddress); + txFrame->header = &txControl->header; + txFrame->metadata = &txControl->metadata; + srcAddress.extendedAddress = call LocalExtendedAddress.get(); + txFrame->headerLen = call FrameUtility.writeHeader( + txFrame->header->mhr, + CoordAddrMode, + CoordPANID, + &CoordAddress, + ADDR_MODE_EXTENDED_ADDRESS, + 0xFFFF, + &srcAddress, + 0); + txFrame->header->mhr[MHR_INDEX_FC1] = FC1_ACK_REQUEST | FC1_FRAMETYPE_CMD; + txFrame->header->mhr[MHR_INDEX_FC2] = FC2_SRC_MODE_EXTENDED | + (CoordAddrMode == ADDR_MODE_SHORT_ADDRESS ? FC2_DEST_MODE_SHORT : FC2_DEST_MODE_EXTENDED); + m_payloadAssocRequest[0] = CMD_FRAME_ASSOCIATION_REQUEST; + m_payloadAssocRequest[1] = *((uint8_t*) &CapabilityInformation); + txFrame->payload = m_payloadAssocRequest; + txFrame->payloadLen = 2; + m_associationOngoing = TRUE; + if ((status = call AssociationRequestTx.transmit(txFrame)) != IEEE154_SUCCESS){ + m_associationOngoing = FALSE; + call TxFramePool.put(txFrame); + call TxControlPool.put(txControl); + } + } + call Debug.log(LEVEL_INFO, AssociateP_REQUEST, status, 0, 0); + return status; + } + + event void AssociationRequestTx.transmitDone(ieee154_txframe_t *txFrame, ieee154_status_t status) + { + call TxControlPool.put((ieee154_txcontrol_t*) ((uint8_t*) txFrame->header - offsetof(ieee154_txcontrol_t, header))); + call TxFramePool.put(txFrame); + if (status != IEEE154_SUCCESS){ + m_associationOngoing = FALSE; + signal MLME_ASSOCIATE.confirm(0xFFFF, status, 0); + } else { + call ResponseTimeout.startOneShot(call MLME_GET.macResponseWaitTime()*IEEE154_aBaseSuperframeDuration); + call Debug.log(LEVEL_INFO, AssociateP_SETTIMER, + call MLME_GET.macResponseWaitTime()*IEEE154_aBaseSuperframeDuration, 0, 0); + } + call Debug.log(LEVEL_INFO, AssociateP_TXDONE, status, 0, 0); + } + + event void ResponseTimeout.fired() + { + uint8_t coordAddress[8]; + if (!m_associationOngoing) + return; + // have not received an AssociationResponse yet, poll the coordinator now + if (m_coordAddrMode == ADDR_MODE_SHORT_ADDRESS) + *((nxle_uint16_t*) &coordAddress) = call MLME_GET.macCoordShortAddress(); + else + call FrameUtility.copyCoordExtendedAddressLE(coordAddress); + if (call DataRequest.poll(m_coordAddrMode, call MLME_GET.macPANId(), + coordAddress, ADDR_MODE_EXTENDED_ADDRESS) != IEEE154_SUCCESS){ + m_shortAddress = 0xFFFF; + m_assocRespStatus = IEEE154_TRANSACTION_OVERFLOW; + signal DataRequest.pollDone(); + } + } + + event message_t* AssociationResponseExtracted.received(message_t* frame, ieee154_txframe_t *txFrame) + { + uint8_t *payload = (uint8_t *) &frame->data; + if (m_associationOngoing){ + m_shortAddress = *((nxle_uint16_t*) (payload + 1)); + m_assocRespStatus = *(payload + 3); + } + return frame; + } + + event void DataRequest.pollDone() + { + if (m_associationOngoing){ + call Debug.log(LEVEL_INFO, AssociateP_POLL_DONE, m_payloadAssocRequest[0], m_assocRespStatus, 0); + call ResponseTimeout.stop(); + m_associationOngoing = FALSE; + signal MLME_ASSOCIATE.confirm(m_shortAddress, m_assocRespStatus, 0); + } + } + +/* ------------------- MLME_ASSOCIATE Response ------------------- */ + + event message_t* AssociationRequestRx.received(message_t* frame) + { + uint8_t *payload = (uint8_t *) &frame->data; + ieee154_address_t srcAddress; + if (call Frame.getSrcAddrMode(frame) == ADDR_MODE_EXTENDED_ADDRESS && + call Frame.getSrcAddr(frame, &srcAddress) == SUCCESS) + signal MLME_ASSOCIATE.indication(srcAddress.extendedAddress, + *((ieee154_CapabilityInformation_t*) (payload + 1)), 0); + return frame; + } + + command ieee154_status_t MLME_ASSOCIATE.response ( + uint64_t deviceAddress, + uint16_t assocShortAddress, + ieee154_association_status_t status, + ieee154_security_t *security + ) + { + uint8_t i; + ieee154_status_t txStatus = IEEE154_SUCCESS; + ieee154_txframe_t *txFrame; + ieee154_txcontrol_t *txControl; + ieee154_address_t srcAddress; + + for (i=0; iheader = &txControl->header; + txFrame->metadata = &txControl->metadata; + txFrame->payload = m_payloadAssocResponse[i]; + srcAddress.extendedAddress = call LocalExtendedAddress.get(); + txFrame->headerLen = call FrameUtility.writeHeader( + txFrame->header->mhr, + ADDR_MODE_EXTENDED_ADDRESS, + call MLME_GET.macPANId(), + (ieee154_address_t*) &deviceAddress, + ADDR_MODE_EXTENDED_ADDRESS, + call MLME_GET.macPANId(), + &srcAddress, + 1); + txFrame->header->mhr[MHR_INDEX_FC1] = FC1_ACK_REQUEST | FC1_FRAMETYPE_CMD | FC1_PAN_ID_COMPRESSION; + txFrame->header->mhr[MHR_INDEX_FC2] = FC2_SRC_MODE_EXTENDED | FC2_DEST_MODE_EXTENDED; + txFrame->payload[0] = CMD_FRAME_ASSOCIATION_RESPONSE; + *((nxle_uint16_t*) &txFrame->payload[1]) = assocShortAddress; + txFrame->payload[3] = status; + txFrame->payloadLen = 4; + if ((txStatus = call AssociationResponseTx.transmit(txFrame)) != IEEE154_SUCCESS){ + txFrame->payload[0] = S_IDLE; + call TxFramePool.put(txFrame); + call TxControlPool.put(txControl); + } + } + return txStatus; + } + + event void AssociationResponseTx.transmitDone(ieee154_txframe_t *txFrame, ieee154_status_t status) + { + ieee154_address_t srcAddress, deviceAddress; + srcAddress.extendedAddress = call LocalExtendedAddress.get(); + if ((txFrame->header->mhr[MHR_INDEX_FC2] & FC2_DEST_MODE_MASK) == FC2_DEST_MODE_SHORT) + deviceAddress.shortAddress = *((nxle_uint16_t*) (&(txFrame->header->mhr[MHR_INDEX_ADDRESS]) + 2)); + else + call FrameUtility.convertToNative(&deviceAddress.extendedAddress, (&(txFrame->header->mhr[MHR_INDEX_ADDRESS]) + 2)); + txFrame->payload[0] = S_IDLE; + call TxControlPool.put((ieee154_txcontrol_t*) ((uint8_t*) txFrame->header - offsetof(ieee154_txcontrol_t, header))); + call TxFramePool.put(txFrame); + signal MLME_COMM_STATUS.indication(call MLME_GET.macPANId(), ADDR_MODE_EXTENDED_ADDRESS, + srcAddress, ADDR_MODE_EXTENDED_ADDRESS, deviceAddress, + status, 0); + } + + +/* ------------------- MLME_DISASSOCIATE (initiating) ------------------- */ + + command ieee154_status_t MLME_DISASSOCIATE.request ( + uint8_t DeviceAddrMode, + uint16_t DevicePANID, + ieee154_address_t DeviceAddress, + ieee154_disassociation_reason_t DisassociateReason, + bool TxIndirect, + ieee154_security_t *security + ) + { + ieee154_status_t status = IEEE154_SUCCESS; + ieee154_txframe_t *txFrame=0; + ieee154_txcontrol_t *txControl=0; + ieee154_address_t srcAddress; + + if (security && security->SecurityLevel) + status = IEEE154_UNSUPPORTED_SECURITY; + else if (call MLME_GET.macPANId() != DevicePANID || + (DeviceAddrMode != ADDR_MODE_SHORT_ADDRESS && DeviceAddrMode != ADDR_MODE_EXTENDED_ADDRESS)) + status = IEEE154_INVALID_PARAMETER; + else if (m_disAssociationOngoing || !(txFrame = call TxFramePool.get())) + status = IEEE154_TRANSACTION_OVERFLOW; + else if (!(txControl = call TxControlPool.get())){ + call TxFramePool.put(txFrame); + status = IEEE154_TRANSACTION_OVERFLOW; + } + if (status == IEEE154_SUCCESS){ + txFrame->header = &txControl->header; + txFrame->metadata = &txControl->metadata; + srcAddress.extendedAddress = call LocalExtendedAddress.get(); + txFrame->headerLen = call FrameUtility.writeHeader( + txFrame->header->mhr, + DeviceAddrMode, + call MLME_GET.macPANId(), + &DeviceAddress, + ADDR_MODE_EXTENDED_ADDRESS, + call MLME_GET.macPANId(), + &srcAddress, + TRUE); + txFrame->header->mhr[MHR_INDEX_FC1] = FC1_ACK_REQUEST | FC1_FRAMETYPE_CMD | FC1_PAN_ID_COMPRESSION; + txFrame->header->mhr[MHR_INDEX_FC2] = FC2_SRC_MODE_EXTENDED | + (DeviceAddrMode == ADDR_MODE_SHORT_ADDRESS ? FC2_DEST_MODE_SHORT : FC2_DEST_MODE_EXTENDED); + m_payloadDisassocRequest[0] = CMD_FRAME_DISASSOCIATION_NOTIFICATION; + m_payloadDisassocRequest[1] = DisassociateReason; + txFrame->payload = m_payloadDisassocRequest; + txFrame->payloadLen = 2; + m_disAssociationOngoing = TRUE; + if ((DeviceAddrMode == ADDR_MODE_SHORT_ADDRESS && + DeviceAddress.shortAddress == call MLME_GET.macCoordShortAddress()) || + (DeviceAddrMode == ADDR_MODE_EXTENDED_ADDRESS && + DeviceAddress.extendedAddress == call MLME_GET.macCoordExtendedAddress())){ + status = call DisassociationToCoord.transmit(txFrame); + } else if (TxIndirect) { + status = call DisassociationIndirectTx.transmit(txFrame); + } else { + status = call DisassociationDirectTx.transmit(txFrame); + } + if (status != IEEE154_SUCCESS){ + m_disAssociationOngoing = FALSE; + call TxFramePool.put(txFrame); + call TxControlPool.put(txControl); + } + } + call Debug.log(LEVEL_INFO, DISSASSOCIATE_REQUEST, status, 0, 0); + return status; + } + + event void DisassociationToCoord.transmitDone(ieee154_txframe_t *data, ieee154_status_t status) + { + // transmitted a disassociation notification to our coordinator + uint8_t *mhr = MHR(data), srcAddrOffset = 7; + uint8_t DeviceAddrMode = (mhr[MHR_INDEX_FC2] & FC2_SRC_MODE_MASK) >> FC2_SRC_MODE_OFFSET; + uint16_t DevicePANID = *((nxle_uint16_t*) (&(mhr[MHR_INDEX_ADDRESS]))); + ieee154_address_t DeviceAddress; + if ((mhr[MHR_INDEX_FC2] & FC2_DEST_MODE_MASK) == FC2_DEST_MODE_EXTENDED) + srcAddrOffset += 6; + call FrameUtility.convertToNative(&DeviceAddress.extendedAddress, &mhr[srcAddrOffset]); + call TxControlPool.put((ieee154_txcontrol_t*) ((uint8_t*) data->header - offsetof(ieee154_txcontrol_t, header))); + call TxFramePool.put(data); + call Debug.log(LEVEL_INFO, DISSASSOCIATE_TXDONE, status, 2, 0); + m_disAssociationOngoing = FALSE; + signal MLME_DISASSOCIATE.confirm(status, DeviceAddrMode, DevicePANID, DeviceAddress); + } + + event void DisassociationIndirectTx.transmitDone(ieee154_txframe_t *data, ieee154_status_t status) + { + signal DisassociationDirectTx.transmitDone(data, status); + } + + event void DisassociationDirectTx.transmitDone(ieee154_txframe_t *data, ieee154_status_t status) + { + // transmitted a disassociation notification to a device + uint8_t *mhr = MHR(data), dstAddrOffset = 5; + uint8_t DeviceAddrMode = (mhr[1] & FC2_DEST_MODE_MASK) >> FC2_DEST_MODE_OFFSET; + uint16_t DevicePANID = *((nxle_uint16_t*) (&(mhr[MHR_INDEX_ADDRESS]))); + ieee154_address_t DeviceAddress; + call FrameUtility.convertToNative(&DeviceAddress.extendedAddress, &mhr[dstAddrOffset]); + call Debug.log(LEVEL_INFO, DISSASSOCIATE_TXDONE, status, 1, 0); + call TxControlPool.put((ieee154_txcontrol_t*) ((uint8_t*) data->header - offsetof(ieee154_txcontrol_t, header))); + call TxFramePool.put(data); + call Debug.log(LEVEL_INFO, DISSASSOCIATE_TXDONE, status, 2, 0); + m_disAssociationOngoing = FALSE; + signal MLME_DISASSOCIATE.confirm(status, DeviceAddrMode, DevicePANID, DeviceAddress); + } + +/* ------------------- MLME_DISASSOCIATE (receiving) ------------------- */ + + event message_t* DisassociationDirectRxFromCoord.received(message_t* frame) + { + // received a disassociation notification from the coordinator (direct tx) + ieee154_address_t address; + address.extendedAddress = call LocalExtendedAddress.get(); + signal MLME_DISASSOCIATE.indication(address.extendedAddress, frame->data[1], NULL); + return frame; + } + + event message_t* DisassociationExtractedFromCoord.received(message_t* frame, ieee154_txframe_t *txFrame) + { + // received a disassociation notification from the coordinator (indirect transmission) + return signal DisassociationDirectRxFromCoord.received(frame); + } + + event message_t* DisassociationRxFromDevice.received(message_t* frame) + { + // received a disassociation notification from the device + ieee154_address_t address; + call Debug.log(LEVEL_INFO, DISSASSOCIATE_RX, 0, 0, 0); + if (call Frame.getSrcAddrMode(frame) == ADDR_MODE_EXTENDED_ADDRESS && + call Frame.getSrcAddr(frame, &address) == SUCCESS) + signal MLME_DISASSOCIATE.indication(address.extendedAddress, frame->data[1], NULL); + return frame; + } + +/* ------------------- Defaults ------------------- */ + + default event void MLME_DISASSOCIATE.indication ( + uint64_t DeviceAddress, + ieee154_disassociation_reason_t DisassociateReason, + ieee154_security_t *security + ){} + default event void MLME_DISASSOCIATE.confirm ( + ieee154_status_t status, + uint8_t DeviceAddrMode, + uint16_t DevicePANID, + ieee154_address_t DeviceAddress + ){} + default event void MLME_ASSOCIATE.indication ( + uint64_t DeviceAddress, + ieee154_CapabilityInformation_t CapabilityInformation, + ieee154_security_t *security + ){} + default event void MLME_ASSOCIATE.confirm ( + uint16_t AssocShortAddress, + uint8_t status, + ieee154_security_t *security + ){} + default event void MLME_COMM_STATUS.indication ( + uint16_t PANId, + uint8_t SrcAddrMode, + ieee154_address_t SrcAddr, + uint8_t DstAddrMode, + ieee154_address_t DstAddr, + ieee154_status_t status, + ieee154_security_t *security + ){} +} diff --git a/tos/lib/mac/tkn154/BackupP.nc b/tos/lib/mac/tkn154/BackupP.nc new file mode 100644 index 00000000..ef51d0d9 --- /dev/null +++ b/tos/lib/mac/tkn154/BackupP.nc @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +generic module BackupP(typedef backup_t) +{ + provides + { + interface SetNow as Store; + interface GetNow as Retrieve; + } +} +implementation +{ + backup_t m_backup; + async command error_t Store.setNow(backup_t* backup) + { + memcpy(&m_backup, backup, sizeof(backup_t)); + return SUCCESS; + } + + async command backup_t* Retrieve.getNow() + { + return &m_backup; + } +} diff --git a/tos/lib/mac/tkn154/BeaconSynchronizeP.nc b/tos/lib/mac/tkn154/BeaconSynchronizeP.nc new file mode 100644 index 00000000..f58c22f8 --- /dev/null +++ b/tos/lib/mac/tkn154/BeaconSynchronizeP.nc @@ -0,0 +1,442 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + + +#include "TKN154_MAC.h" +#include "TKN154_DEBUG.h" + +module BeaconSynchronizeP +{ + provides + { + interface Init as Reset; + interface MLME_SYNC; + interface MLME_BEACON_NOTIFY; + interface MLME_SYNC_LOSS; + interface Get as IsTrackingBeacons; + interface GetNow as CapStart; + interface GetNow as CapStartRefTime; + interface GetNow as CapLen; + interface GetNow as CapEnd; + interface GetNow as CfpEnd; + interface GetNow as CfpLen; + interface GetNow as BeaconInterval; + interface GetNow as IsBLEActive; + interface GetNow as BLELen; + interface GetNow as GtsField; + interface GetNow as SfSlotDuration; + interface GetNow as FinalCapSlot; + interface GetNow as NumGtsSlots; + interface GetNow as IsRxBroadcastPending; + } + uses + { + interface MLME_GET; + interface MLME_SET; + interface FrameUtility; + interface IEEE154BeaconFrame as BeaconFrame; + interface Alarm as TrackAlarm; + interface RadioRx as BeaconRx; + interface RadioOff; + interface Get as IsBeaconEnabledPAN; + interface DataRequest; + interface FrameRx as CoordRealignmentRx; + interface Resource as Token; + interface ResourceTransfer as TokenToCap; + interface TimeCalc; + interface IEEE154Frame as Frame; + interface Leds; + interface Ieee802154Debug as Debug; + } +} +implementation +{ + + enum { + S_PREPARE = 0, + S_RXNOW = 1, + S_RADIO_OFF = 2, + S_FIRST_SCAN= 3, + + RX_DURATION = 1000, // listen for a beacon for RX_DURATION symbols + RX_LAG = 100, // start to listen for a RX_LAG before expected arrival + }; + + norace bool m_tracking = FALSE; + norace bool m_updatePending = FALSE; + uint8_t m_updateLogicalChannel; + bool m_updateTrackBeacon; + bool m_stopTracking = FALSE; + + norace uint8_t m_numBeaconsLost; + uint8_t m_coordAddress[8]; + message_t m_beaconBuffer; + norace message_t *m_beaconBufferPtr = &m_beaconBuffer; + norace bool m_beaconSwapBufferReady = TRUE; + norace uint32_t m_beaconInterval; + norace uint32_t m_dt; + norace uint32_t m_lastBeaconRxTime; + norace ieee154_reftime_t m_lastBeaconRxRefTime; + norace uint8_t m_state; + norace uint8_t m_beaconOrder; + norace uint32_t m_sfSlotDuration; + norace uint8_t m_finalCapSlot; + norace uint8_t m_numGtsSlots; + norace uint16_t m_BLELen; + norace bool m_broadcastPending; + uint8_t m_gtsField[1+1+3*7]; + task void processBeaconTask(); + + command error_t Reset.init() + { + if (call Token.isOwner()){ + call Leds.led0On(); // internal error + return FAIL; + } + if (m_tracking || m_updatePending) + signal MLME_SYNC_LOSS.indication( + IEEE154_BEACON_LOSS, + call MLME_GET.macPANId(), + call MLME_GET.phyCurrentChannel(), + call MLME_GET.phyCurrentPage(), + NULL); + m_updatePending = m_stopTracking = m_tracking = FALSE; + return SUCCESS; + } + +/* ----------------------- MLME-SYNC ----------------------- */ +/* + * Allows to synchronize with a coordinator. + */ + + command ieee154_status_t MLME_SYNC.request ( + uint8_t logicalChannel, + uint8_t channelPage, + bool trackBeacon) + { + uint32_t supportedChannels = IEEE154_SUPPORTED_CHANNELS; + uint32_t currentChannelBit = 1; + + currentChannelBit <<= logicalChannel; + if (!(currentChannelBit & supportedChannels) || (call MLME_GET.macPANId() == 0xFFFF) || + (channelPage != IEEE154_SUPPORTED_CHANNELPAGE) || !call IsBeaconEnabledPAN.get()) + return IEEE154_INVALID_PARAMETER; + + call Debug.log(LEVEL_INFO,SyncP_REQUEST, logicalChannel, channelPage, trackBeacon); + if (!trackBeacon && m_tracking){ + // stop tracking after next received beacon + m_stopTracking = TRUE; + } else { + m_stopTracking = FALSE; + m_updateLogicalChannel = logicalChannel; + m_updateTrackBeacon = trackBeacon; + atomic m_updatePending = TRUE; + call Debug.log(LEVEL_INFO,SyncP_RESOURCE_REQUEST, 0, 0, 0); + call Token.request(); + } + call Debug.flush(); + return IEEE154_SUCCESS; + } + + event void Token.granted() + { + bool missed = FALSE; + call Debug.log(LEVEL_INFO,SyncP_GOT_RESOURCE, m_lastBeaconRxTime+m_beaconInterval, + m_beaconInterval, (m_updatePending<<1)+m_tracking); + if (m_updatePending){ + m_state = S_FIRST_SCAN; + m_updatePending = FALSE; + m_beaconOrder = call MLME_GET.macBeaconOrder(); + if (m_beaconOrder >= 15) + m_beaconOrder = 14; + call MLME_SET.phyCurrentChannel(m_updateLogicalChannel); + m_tracking = m_updateTrackBeacon; + m_beaconInterval = ((uint32_t) 1 << m_beaconOrder) * (uint32_t) IEEE154_aBaseSuperframeDuration; + m_dt = m_beaconInterval; + m_numBeaconsLost = IEEE154_aMaxLostBeacons; // will be reset when beacon is received + call Debug.log(LEVEL_INFO,SyncP_UPDATING, call MLME_GET.macCoordShortAddress(), + call MLME_GET.macPANId(), m_updateLogicalChannel); + } else { + m_state = S_PREPARE; + if (!m_tracking){ + call Debug.log(LEVEL_INFO,SyncP_RELEASE_RESOURCE, 0, 0, 0); + call Token.release(); + return; + } + while (call TimeCalc.hasExpired(m_lastBeaconRxTime, m_dt)){ // missed a beacon + call Debug.log(LEVEL_INFO,SyncP_BEACON_MISSED_1, m_lastBeaconRxTime, m_dt, missed); + m_dt += m_beaconInterval; + m_numBeaconsLost++; + missed = TRUE; + } + if (m_numBeaconsLost >= IEEE154_aMaxLostBeacons){ + post processBeaconTask(); + return; + } + if (missed){ + call Token.request(); + call Debug.log(LEVEL_INFO,SyncP_RELEASE_RESOURCE, m_lastBeaconRxTime, m_dt, missed); + call Token.release(); + return; + } + } + if (!call RadioOff.isOff()) + call RadioOff.off(); + else + signal RadioOff.offDone(); + } + + async event void TrackAlarm.fired() + { + call Debug.log(LEVEL_IMPORTANT,SyncP_SWITCHOFF, 0,0,0); + atomic { + switch (m_state) + { + case S_PREPARE: + call BeaconRx.prepare(); + break; + case S_RADIO_OFF: + call Debug.log(LEVEL_INFO, SyncP_SWITCHOFF, 0, 0,0); + call RadioOff.off(); + break; + } + } + } + + async event void BeaconRx.prepareDone() + { + if (m_state == S_FIRST_SCAN){ + m_state = S_RADIO_OFF; + atomic { + call BeaconRx.receive(NULL, 0); + call TrackAlarm.start((((uint32_t) 1 << m_beaconOrder) + (uint32_t) 1) * + (uint32_t) IEEE154_aBaseSuperframeDuration * (uint32_t) IEEE154_aMaxLostBeacons); + } + } else { + m_state = S_RADIO_OFF; + call BeaconRx.receive(&m_lastBeaconRxRefTime, m_dt-RX_LAG); + call Debug.log(LEVEL_IMPORTANT,SyncP_RX_ON, call TrackAlarm.getNow(),m_lastBeaconRxTime+m_dt,RX_LAG); + call TrackAlarm.startAt(m_lastBeaconRxTime, m_dt + RX_DURATION); + } + } + + event message_t* BeaconRx.received(message_t *frame, ieee154_reftime_t *timestamp) + { + uint8_t *mhr = MHR(frame); + call Debug.log(LEVEL_INFO,SyncP_RX_PACKET,*((nxle_uint32_t*) &mhr[MHR_INDEX_ADDRESS]), + mhr[MHR_INDEX_FC1] & FC1_FRAMETYPE_MASK,mhr[MHR_INDEX_SEQNO]); + if (!m_beaconSwapBufferReady || !call FrameUtility.isBeaconFromCoord(frame)) + { + return frame; + } else { + message_t *tmp = m_beaconBufferPtr; + call TrackAlarm.stop(); + m_beaconSwapBufferReady = FALSE; + m_beaconBufferPtr = frame; + if (timestamp != NULL) + memcpy(&m_lastBeaconRxRefTime, timestamp, sizeof(ieee154_reftime_t)); + call RadioOff.off(); + return tmp; + } + } + + async event void RadioOff.offDone() + { + if (m_state == S_FIRST_SCAN) + call BeaconRx.prepare(); + else if (m_state == S_PREPARE) + call TrackAlarm.startAt(m_lastBeaconRxTime, m_dt - IEEE154_RADIO_RX_PREPARE_DELAY); + else + post processBeaconTask(); + } + + task void processBeaconTask() + { + + // valid beacon timestamp is pre-condition for slotted CSMA-CA + if (m_beaconSwapBufferReady || !call Frame.isTimestampValid(m_beaconBufferPtr)){ + // missed a beacon! + m_numBeaconsLost++; + m_dt += m_beaconInterval; + call Debug.log(LEVEL_IMPORTANT, SyncP_BEACON_MISSED_3,m_numBeaconsLost,0,m_lastBeaconRxTime); + if (m_numBeaconsLost >= IEEE154_aMaxLostBeacons){ + m_tracking = FALSE; + call Debug.log(LEVEL_IMPORTANT, SyncP_LOST_SYNC,0,0,0); + call Leds.led2Off(); + signal MLME_SYNC_LOSS.indication( + IEEE154_BEACON_LOSS, + call MLME_GET.macPANId(), + call MLME_GET.phyCurrentChannel(), + call MLME_GET.phyCurrentPage(), + NULL // security + ); + } else + call Token.request(); // make another request again (before giving the token up) + call Debug.log(LEVEL_INFO,SyncP_RELEASE_RESOURCE, 0, 0, 0); + call Token.release(); + } else { + // got the beacon! + uint8_t *payload = (uint8_t *) m_beaconBufferPtr->data; + ieee154_macAutoRequest_t autoRequest = call MLME_GET.macAutoRequest(); + uint8_t pendAddrSpecOffset = 3 + (((payload[2] & 7) > 0) ? 1 + (payload[2] & 7) * 3: 0); // skip GTS + uint8_t pendAddrSpec = payload[pendAddrSpecOffset]; + uint8_t *beaconPayload = payload + pendAddrSpecOffset + 1; + uint8_t beaconPayloadSize = call BeaconFrame.getBeaconPayloadLength(m_beaconBufferPtr); + uint8_t pendingAddrMode = ADDR_MODE_NOT_PRESENT; + uint8_t coordBeaconOrder; + uint8_t *mhr = MHR(m_beaconBufferPtr); + uint8_t frameLen = ((uint8_t*) m_beaconBufferPtr)[0] & FRAMECTL_LENGTH_MASK; + uint8_t gtsFieldLength; + uint32_t timestamp = call Frame.getTimestamp(m_beaconBufferPtr); + + call Debug.log(LEVEL_INFO, SyncP_BEACON_RX, m_lastBeaconRxTime, timestamp, mhr[2]); + m_numGtsSlots = (payload[2] & 7); + gtsFieldLength = 1 + ((m_numGtsSlots > 0) ? 1 + m_numGtsSlots * 3: 0); + m_lastBeaconRxTime = timestamp + IEEE154_SYNC_SYMBOL_OFFSET - IEEE154_SYMBOLS_PER_OCTET - IEEE154_PREAMBLE_LENGTH; + m_finalCapSlot = (payload[1] & 0x0F); + m_sfSlotDuration = (((uint32_t) 1) << ((payload[0] & 0xF0) >> 4)) * IEEE154_aBaseSlotDuration; + memcpy(m_gtsField, &payload[2], gtsFieldLength); + + // check for battery life extension + if (payload[1] & 0x10){ + // BLE is active; calculate the time offset from slot0 + m_BLELen = IEEE154_SHR_DURATION + frameLen * IEEE154_SYMBOLS_PER_OCTET; + if (frameLen > IEEE154_aMaxSIFSFrameSize) + m_BLELen += call MLME_GET.macMinLIFSPeriod(); + else + m_BLELen += call MLME_GET.macMinSIFSPeriod(); + m_BLELen += call MLME_GET.macBattLifeExtPeriods(); + } else + m_BLELen = 0; + m_broadcastPending = mhr[MHR_INDEX_FC1] & FC1_FRAME_PENDING ? TRUE : FALSE; + coordBeaconOrder = (payload[0] & 0x0F); + m_dt = m_beaconInterval = ((uint32_t) 1 << coordBeaconOrder) * (uint32_t) IEEE154_aBaseSuperframeDuration; + if (m_stopTracking){ + m_tracking = FALSE; + call Debug.log(LEVEL_INFO,SyncP_RELEASE_RESOURCE, 0, 0, 0); + call Token.release(); + } else { + error_t req = call Token.request(); + call Debug.log(LEVEL_INFO,SyncP_TRANSFER_RESOURCE, req, 0, 0); + call TokenToCap.transfer(); + } + + if (pendAddrSpec & PENDING_ADDRESS_SHORT_MASK) + beaconPayload += (pendAddrSpec & PENDING_ADDRESS_SHORT_MASK) * 2; + if (pendAddrSpec & PENDING_ADDRESS_EXT_MASK) + beaconPayload += ((pendAddrSpec & PENDING_ADDRESS_EXT_MASK) >> 4) * 8; + // check for pending data (once we signal MLME_BEACON_NOTIFY we cannot + // touch the frame anymore) + if (autoRequest) + pendingAddrMode = call BeaconFrame.isLocalAddrPending(m_beaconBufferPtr); + if (pendingAddrMode != ADDR_MODE_NOT_PRESENT){ + // the coord has pending data + uint8_t CoordAddrMode; + uint16_t CoordPANId; + uint8_t *CoordAddress; + uint8_t SrcAddrMode = pendingAddrMode; + if ((mhr[MHR_INDEX_FC2] & FC2_SRC_MODE_MASK) == FC2_SRC_MODE_SHORT) + CoordAddrMode = ADDR_MODE_SHORT_ADDRESS; + else + CoordAddrMode = ADDR_MODE_EXTENDED_ADDRESS; + CoordAddress = &(mhr[MHR_INDEX_ADDRESS+2]); + CoordPANId = *((nxle_uint16_t*) &(mhr[MHR_INDEX_ADDRESS])); + call DataRequest.poll(CoordAddrMode, CoordPANId, CoordAddress, SrcAddrMode); + } + // Beacon Tracking: update state + call Debug.log(LEVEL_INFO, SyncP_NEXT_RX_TIME, 0, timestamp, m_beaconInterval); + m_numBeaconsLost = 0; + // TODO: check PAN ID conflict here? + if (!autoRequest || beaconPayloadSize) + m_beaconBufferPtr = signal MLME_BEACON_NOTIFY.indication(m_beaconBufferPtr); + m_beaconSwapBufferReady = TRUE; + } + } + + command bool IsTrackingBeacons.get(){ return m_tracking;} + + default event message_t* MLME_BEACON_NOTIFY.indication (message_t* frame){return frame;} + + default event void MLME_SYNC_LOSS.indication ( + ieee154_status_t lossReason, + uint16_t panID, + uint8_t logicalChannel, + uint8_t channelPage, + ieee154_security_t *security){} + + event void DataRequest.pollDone(){} + + async command uint8_t* GtsField.getNow() { return m_gtsField; } + async command uint32_t SfSlotDuration.getNow() { return m_sfSlotDuration; } + async command uint8_t FinalCapSlot.getNow() { return m_finalCapSlot; } + async command uint32_t CapStart.getNow() { return m_lastBeaconRxTime; } + async command ieee154_reftime_t* CapStartRefTime.getNow() { return &m_lastBeaconRxRefTime; } + async command uint32_t CapLen.getNow() { return call SfSlotDuration.getNow() * (call FinalCapSlot.getNow() + 1);} + async command uint32_t CapEnd.getNow() + { + return call CapStart.getNow() + call CapLen.getNow(); + } + async command uint32_t CfpEnd.getNow() + { + return call CapStart.getNow() + call SfSlotDuration.getNow() * IEEE154_aNumSuperframeSlots; + } + async command uint32_t CfpLen.getNow() + { + return call SfSlotDuration.getNow() * (15 - call FinalCapSlot.getNow()); + } + async command uint32_t BeaconInterval.getNow() + { + return m_beaconInterval; + } + async command uint8_t NumGtsSlots.getNow() { return m_numGtsSlots; } + async command bool IsBLEActive.getNow(){ return m_BLELen>0;} + async command uint16_t BLELen.getNow(){ return m_BLELen;} + async command bool IsRxBroadcastPending.getNow() { return m_broadcastPending; } + + event message_t* CoordRealignmentRx.received(message_t* frame) + { + uint8_t *payload = call Frame.getPayload(frame); + ieee154_macPANId_t panID = *(nxle_uint16_t*) &payload[1]; + if (panID == call MLME_GET.macPANId()) + signal MLME_SYNC_LOSS.indication( + IEEE154_REALIGNMENT, // LossReason + panID, // PANId + payload[5], // LogicalChannel, + call Frame.getPayloadLength(frame) == 9 ? payload[8] : call MLME_GET.phyCurrentPage(), + NULL + ); + return frame; + } +} diff --git a/tos/lib/mac/tkn154/BeaconTransmitP.nc b/tos/lib/mac/tkn154/BeaconTransmitP.nc new file mode 100644 index 00000000..d3034e14 --- /dev/null +++ b/tos/lib/mac/tkn154/BeaconTransmitP.nc @@ -0,0 +1,815 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +#include "TKN154_MAC.h" +#include "TKN154_PHY.h" +module BeaconTransmitP +{ + provides + { + interface Init as Reset; + interface MLME_START; + interface WriteBeaconField as SuperframeSpecWrite; + interface Get as IsSendingBeacons; + interface GetNow as CapStart; + interface GetNow as CapStartRefTime; + interface GetNow as CapLen; + interface GetNow as CapEnd; + interface GetNow as CfpEnd; + interface GetNow as CfpLen; + interface GetNow as IsBLEActive; + interface GetNow as BLELen; + interface GetNow as GtsField; + interface GetNow as SfSlotDuration; + interface GetNow as BeaconInterval; + interface GetNow as FinalCapSlot; + interface GetNow as NumGtsSlots; + interface GetNow as BeaconFramePendingBit; + interface IEEE154TxBeaconPayload; + } uses { + interface Notify as GtsSpecUpdated; + interface Notify as PendingAddrSpecUpdated; + interface Notify as PIBUpdate[uint8_t attributeID]; + interface Alarm as BeaconTxAlarm; + interface Timer as BeaconPayloadUpdateTimer; + interface RadioOff; + interface Get as IsBeaconEnabledPAN; + interface RadioTx as BeaconTx; + interface MLME_GET; + interface MLME_SET; + interface Resource as Token; + interface ResourceTransfer as TokenToBroadcast; + interface FrameTx as RealignmentBeaconEnabledTx; + interface FrameTx as RealignmentNonBeaconEnabledTx; + interface FrameRx as BeaconRequestRx; + interface WriteBeaconField as GtsInfoWrite; + interface WriteBeaconField as PendingAddrWrite; + interface FrameUtility; + interface Get as IsTrackingBeacons; + interface GetNow as LastBeaconRxTime; + interface GetNow as LastBeaconRxRefTime; + interface Ieee802154Debug as Debug; + interface Set as SetMacSuperframeOrder; + interface Set as SetMacBeaconTxTime; + interface Set as SetMacPanCoordinator; + interface GetSet as GetSetRealignmentFrame; + interface GetNow as IsBroadcastReady; + interface TimeCalc; + interface Leds; + } +} +implementation +{ + + enum { + MAX_BEACON_PAYLOAD_SIZE = IEEE154_aMaxBeaconOverhead + IEEE154_aMaxBeaconPayloadLength, + + REQUEST_UPDATE_SF = 0x01, + REQUEST_REALIGNMENT = 0x02, + REQUEST_CONFIRM_PENDING = 0x04, + REQUEST_REALIGNMENT_DONE_PENDING = 0x08, + + MODIFIED_SF_SPEC = 0x01, + MODIFIED_GTS_FIELD = 0x02, + MODIFIED_PENDING_ADDR_FIELD = 0x04, + MODIFIED_SPECS_MASK = 0x0F, + + MODIFIED_BEACON_PAYLOAD = 0x10, + MODIFIED_BEACON_PAYLOAD_NEW = 0x20, + MODIFIED_BEACON_PAYLOAD_MASK = 0xF0, + + S_TX_IDLE = 0, + S_TX_LOCKED = 1, + S_TX_WAITING = 2, + }; + + norace ieee154_txframe_t m_beaconFrame; + ieee154_header_t m_header; + uint8_t m_payload[MAX_BEACON_PAYLOAD_SIZE]; + ieee154_metadata_t m_metadata; + uint8_t m_gtsField[1+1+3*7]; + + void *m_updateBeaconPayload; + uint8_t m_updateBeaconOffset; + uint8_t m_updateBeaconLength; + uint8_t m_beaconPayloadLen; + uint8_t m_pendingAddrLen; + uint8_t m_pendingGtsLen; + + norace uint8_t m_requests; // TODO: check why norace? + norace uint8_t m_txState; + uint8_t m_payloadState; + norace bool m_txOneBeaconImmediately; + + uint16_t m_PANId; + norace uint32_t m_startTime; + uint8_t m_logicalChannel; + norace uint8_t m_beaconOrder; + norace uint8_t m_superframeOrder; + ieee154_macBattLifeExt_t m_batteryLifeExtension; + bool m_PANCoordinator; + norace uint32_t m_beaconInterval; + norace uint32_t m_previousBeaconInterval; + norace uint32_t m_dt; + norace uint8_t m_bsn; + norace uint32_t m_lastBeaconTxTime; + norace ieee154_reftime_t m_lastBeaconTxRefTime; + norace uint32_t m_coordCapLen; + norace uint32_t m_coordCfpEnd; + norace uint32_t m_sfSlotDuration; + norace uint8_t m_finalCAPSlot; + norace uint8_t m_numGtsSlots; + norace uint16_t m_BLELen; + norace ieee154_macBattLifeExtPeriods_t m_battLifeExtPeriods; + norace bool m_framePendingBit; + + uint16_t m_updatePANId; + uint8_t m_updateLogicalChannel; + uint32_t m_updateStartTime; + uint8_t m_updateBeaconOrder; + uint8_t m_updateSuperframeOrder; + bool m_updatePANCoordinator; + bool m_updateBatteryLifeExtension; + + task void txDoneTask(); + task void signalStartConfirmSuccessTask(); + void prepareNextBeaconTransmission(); + void continueStartRequest(); + void finishRealignment(ieee154_txframe_t *frame, ieee154_status_t status); + + command error_t Reset.init() + { + m_beaconFrame.header = &m_header; + m_beaconFrame.headerLen = 0; + m_beaconFrame.payload = m_payload; + m_beaconFrame.payloadLen = 0; + m_beaconFrame.metadata = &m_metadata; + m_updateBeaconPayload = 0; + m_updateBeaconLength = 0; + m_requests = m_payloadState = m_txState = 0; + m_PANCoordinator = FALSE; + m_beaconPayloadLen = m_pendingAddrLen = m_pendingGtsLen = 0; + m_gtsField[0] = 0; + m_finalCAPSlot = 15; + m_beaconOrder = 15; + call BeaconPayloadUpdateTimer.stop(); + call BeaconTxAlarm.stop(); + return SUCCESS; + } + +/* ----------------------- MLME-START ----------------------- */ +/* "The MLME-START.request primitive allows the PAN coordinator to initiate a + * new PAN or to begin using a new superframe configuration. This primitive may + * also be used by a device already associated with an existing PAN to begin + * using a new superframe configuration." (IEEE 802.15.4-2006 Sect. 7.1.14.1) + **/ + + command ieee154_status_t MLME_START.request ( + uint16_t panID, + uint8_t logicalChannel, + uint8_t channelPage, + uint32_t startTime, + uint8_t beaconOrder, + uint8_t superframeOrder, + bool panCoordinator, + bool batteryLifeExtension, + bool coordRealignment, + ieee154_security_t *coordRealignSecurity, + ieee154_security_t *beaconSecurity) + { + ieee154_macShortAddress_t shortAddress = call MLME_GET.macShortAddress(); + ieee154_status_t status = IEEE154_SUCCESS; + + if ((coordRealignSecurity && coordRealignSecurity->SecurityLevel) || + (beaconSecurity && beaconSecurity->SecurityLevel)) + status = IEEE154_UNSUPPORTED_SECURITY; + else if (shortAddress == 0xFFFF) + status = IEEE154_NO_SHORT_ADDRESS; + else if (logicalChannel > 26 || beaconOrder > 15 || + (channelPage != IEEE154_SUPPORTED_CHANNELPAGE) || + !(IEEE154_SUPPORTED_CHANNELS & ((uint32_t) 1 << logicalChannel)) || + (superframeOrder > beaconOrder)) + status = IEEE154_INVALID_PARAMETER; + else if (startTime && !call IsTrackingBeacons.get()) + status = IEEE154_TRACKING_OFF; + else if (startTime && 0xFF000000) + status = IEEE154_INVALID_PARAMETER; + else if (m_requests & (REQUEST_CONFIRM_PENDING | REQUEST_UPDATE_SF)) + status = IEEE154_TRANSACTION_OVERFLOW; + else if ((call IsBeaconEnabledPAN.get() && beaconOrder > 14) || + (!call IsBeaconEnabledPAN.get() && beaconOrder < 15)) + status = IEEE154_INVALID_PARAMETER; + else { + // new configuration *will* be put in operation + status = IEEE154_SUCCESS; + if (panCoordinator) + startTime = 0; // start immediately + call Debug.log(LEVEL_INFO, StartP_REQUEST, logicalChannel, beaconOrder, superframeOrder); + if (beaconOrder == 15){ + // beaconless PAN + superframeOrder = 15; + } + m_updatePANId = panID; + m_updateLogicalChannel = logicalChannel; + m_updateStartTime = startTime; + m_updateBeaconOrder = beaconOrder; + m_updateSuperframeOrder = superframeOrder; + m_updatePANCoordinator = panCoordinator; + m_updateBatteryLifeExtension = batteryLifeExtension; + m_requests = (REQUEST_CONFIRM_PENDING | REQUEST_UPDATE_SF); // lock + if (coordRealignment) + m_requests |= REQUEST_REALIGNMENT; + if (!call IsSendingBeacons.get()) + call Token.request(); + } + return status; + } + + void continueStartRequest() + { + uint8_t offset; + ieee154_macShortAddress_t shortAddress; + bool isShortAddr; + + // (1) coord realignment? + if (m_requests & REQUEST_REALIGNMENT){ + ieee154_txframe_t *realignmentFrame = call GetSetRealignmentFrame.get(); + m_requests &= ~REQUEST_REALIGNMENT; + if (realignmentFrame == NULL){ + // allocation failed! + m_requests = 0; + signal MLME_START.confirm(IEEE154_TRANSACTION_OVERFLOW); + return; + } + // set the payload portion of the realignmentFrame + // (the header fields are already set correctly) + realignmentFrame->payload[0] = CMD_FRAME_COORDINATOR_REALIGNMENT; + *((nxle_uint16_t*) &realignmentFrame->payload[1]) = m_updatePANId; + *((nxle_uint16_t*) &realignmentFrame->payload[3]) = call MLME_GET.macShortAddress(); + realignmentFrame->payload[5] = m_updateLogicalChannel; + *((nxle_uint16_t*) &realignmentFrame->payload[6]) = 0xFFFF; + realignmentFrame->payloadLen = 8; + + if (call IsSendingBeacons.get()){ + // we're already transmitting beacons; the realignment frame + // must be sent (broadcast) after the next beacon + if (call RealignmentBeaconEnabledTx.transmit(realignmentFrame) != IEEE154_SUCCESS){ + m_requests = 0; + call GetSetRealignmentFrame.set(realignmentFrame); + signal MLME_START.confirm(IEEE154_TRANSACTION_OVERFLOW); + } else { + // The realignment frame will be transmitted immediately after + // the next beacon - the result will be signalled in + // RealignmentBeaconEnabledTx.transmitDone(). Only then the superframe + // structure is updated and MLME_START.confirm signalled. + m_requests |= REQUEST_REALIGNMENT_DONE_PENDING; // lock + } + } else { + // send realignment frame in unslotted csma-ca now + if (call RealignmentNonBeaconEnabledTx.transmit(realignmentFrame) != IEEE154_SUCCESS){ + m_requests = 0; + call GetSetRealignmentFrame.set(realignmentFrame); + signal MLME_START.confirm(IEEE154_TRANSACTION_OVERFLOW); + } else { + // A realignment frame will be transmitted now, the result will + // be signalled in RealignmentNonBeaconEnabledTx.transmitDone(). Only + // then the superframe structure is updated and MLME_START.confirm + // signalled. + m_requests |= REQUEST_REALIGNMENT_DONE_PENDING; // lock + } + } + return; + } + + // (2) update internal state + m_startTime = m_updateStartTime; + m_txOneBeaconImmediately = FALSE; + m_previousBeaconInterval = 0; + if (m_startTime){ + m_lastBeaconTxRefTime = *call LastBeaconRxRefTime.getNow(); + m_lastBeaconTxTime = call LastBeaconRxTime.getNow(); + } else { + // no StartTime defined by next higher layer - but + // if a realignment frame was transmitted, the next + // beacon tx time must take the old BI into consideration + if (m_requests & REQUEST_REALIGNMENT_DONE_PENDING) + m_previousBeaconInterval = m_beaconInterval; + else + m_txOneBeaconImmediately = TRUE; + } + m_PANId = m_updatePANId; + m_logicalChannel = m_updateLogicalChannel; + m_beaconOrder = m_updateBeaconOrder; + m_superframeOrder = m_updateSuperframeOrder; + m_PANCoordinator = m_updatePANCoordinator; + if (m_beaconOrder < 15){ + m_batteryLifeExtension = m_updateBatteryLifeExtension; + m_beaconInterval = ((uint32_t) 1 << m_updateBeaconOrder) * IEEE154_aBaseSuperframeDuration; + } else { + m_batteryLifeExtension = FALSE; + m_beaconInterval = 0; + } + m_txState = S_TX_IDLE; + m_bsn = call MLME_GET.macBSN()+1; + m_battLifeExtPeriods = call MLME_GET.macBattLifeExtPeriods(); + + // (3) update PIB + call MLME_SET.macBeaconOrder(m_beaconOrder); + call SetMacSuperframeOrder.set(m_superframeOrder); + call MLME_SET.macPANId(m_PANId); + call MLME_SET.phyCurrentChannel(m_logicalChannel); + if (m_beaconOrder < 15) + call MLME_SET.macBattLifeExt(m_batteryLifeExtension); + call SetMacPanCoordinator.set(m_PANCoordinator); + + // (4) assemble beacon header and payload + shortAddress = call MLME_GET.macShortAddress(); + isShortAddr = (shortAddress != 0xFFFE); + m_beaconFrame.header->mhr[MHR_INDEX_FC1] = FC1_FRAMETYPE_BEACON; + m_beaconFrame.header->mhr[MHR_INDEX_FC2] = isShortAddr ? FC2_SRC_MODE_SHORT : FC2_SRC_MODE_EXTENDED; + offset = MHR_INDEX_ADDRESS; + *((nxle_uint16_t*) &m_beaconFrame.header->mhr[offset]) = m_PANId; + offset += sizeof(ieee154_macPANId_t); + if (isShortAddr){ + *((nxle_uint16_t*) &m_beaconFrame.header->mhr[offset]) = shortAddress; + offset += sizeof(ieee154_macShortAddress_t); + } else { + call FrameUtility.copyLocalExtendedAddressLE(&m_beaconFrame.header->mhr[offset]); + offset += 8; + } + m_beaconFrame.headerLen = offset; + m_payloadState |= MODIFIED_SPECS_MASK; // update beacon payload + signal BeaconPayloadUpdateTimer.fired(); // assemble initial beacon payload + + if (m_beaconOrder < 15){ + // beacon-enabled PAN, signal confirm after next + // beacon has been transmitted (see MSC, Fig. 38) + m_requests = REQUEST_CONFIRM_PENDING; + } else { + // beaconless PAN, we're done + m_requests = 0; + signal MLME_START.confirm(IEEE154_SUCCESS); + } + } + + task void grantedTask() + { + signal Token.granted(); + } + + event void Token.granted() + { + call Debug.log(LEVEL_INFO, StartP_GOT_RESOURCE, m_lastBeaconTxTime, m_beaconInterval, m_requests); + if (m_requests & REQUEST_REALIGNMENT_DONE_PENDING){ + // unlikely to occur: we have not yet received a done() + // event after sending out a realignment frame + post grantedTask(); // spin + return; + } + if (m_requests & REQUEST_UPDATE_SF){ + m_requests &= ~REQUEST_UPDATE_SF; + continueStartRequest(); + call Debug.log(LEVEL_INFO, StartP_UPDATE_STATE, 0, 0, 0); + } + if (call RadioOff.isOff()) + prepareNextBeaconTransmission(); + else + call RadioOff.off(); + } + + async event void RadioOff.offDone() + { + prepareNextBeaconTransmission(); + } + + void prepareNextBeaconTransmission() + { + if (m_txState == S_TX_LOCKED){ + // have not had time to finish processing the last sent beacon + post grantedTask(); + call Debug.log(LEVEL_CRITICAL, StartP_OWNER_TOO_FAST, 0, 0, 0); + return; + } else if (m_beaconOrder > 14){ + call Token.release(); + } else { + atomic { + m_txState = S_TX_WAITING; + if (m_txOneBeaconImmediately){ + signal BeaconTxAlarm.fired(); + return; + } else if (m_startTime != 0){ + // a new sf spec was put into operation, with a user-defined StartTime + // here m_lastBeaconTxTime is actually the last time a beacon was received + m_dt = m_startTime; + m_startTime = 0; + } else if (m_previousBeaconInterval != 0){ + // a new sf spec was put into operation, after a realignment frame was + // broadcast; the next beacon time should still be calculated using the + // old BI (one last time) + m_dt = m_previousBeaconInterval; + m_previousBeaconInterval = 0; + if (m_requests & REQUEST_CONFIRM_PENDING){ + // only now the next higher layer is to be informed + m_requests &= ~REQUEST_CONFIRM_PENDING; + post signalStartConfirmSuccessTask(); + } + } else { + // the usual case: next beacon tx time = last time + BI + m_dt = m_beaconInterval; + } + while (call TimeCalc.hasExpired(m_lastBeaconTxTime, m_dt)){ // missed sending a beacon + call Debug.log(LEVEL_INFO, StartP_SKIPPED_BEACON, m_lastBeaconTxTime, m_dt, 0); + m_dt += m_beaconInterval; + } + if (m_dt < IEEE154_RADIO_TX_PREPARE_DELAY) + m_dt = IEEE154_RADIO_TX_PREPARE_DELAY; + // don't call BeaconTx.load just yet, otherwise the next + // higher layer cannot modify the beacon payload anymore; + // rather, set an alarm + call BeaconTxAlarm.startAt(m_lastBeaconTxTime, m_dt - IEEE154_RADIO_TX_PREPARE_DELAY); + } + } + } + + async event void BeaconTxAlarm.fired() + { + atomic { + switch (m_txState) + { + case S_TX_WAITING: + m_txState = S_TX_LOCKED; + if (call IsBroadcastReady.getNow()) + m_beaconFrame.header->mhr[MHR_INDEX_FC1] |= FC1_FRAME_PENDING; + else + m_beaconFrame.header->mhr[MHR_INDEX_FC1] &= ~FC1_FRAME_PENDING; + m_beaconFrame.header->mhr[MHR_INDEX_SEQNO] = m_bsn; // update beacon seqno + call Debug.log(LEVEL_INFO, StartP_PREPARE_TX, 0, m_lastBeaconTxTime, 0); + call BeaconTx.load(&m_beaconFrame); + break; + case S_TX_LOCKED: + call Debug.log(LEVEL_INFO, StartP_TRANSMIT, m_lastBeaconTxTime, m_dt, ((uint32_t)m_lastBeaconTxRefTime)); + call BeaconTx.transmit(&m_lastBeaconTxRefTime, m_dt, 0, FALSE); + break; + } + } + } + + async event void BeaconTx.loadDone() + { + atomic { + call Debug.log(LEVEL_INFO, StartP_PREPARE_TXDONE, 0, m_lastBeaconTxTime, 0); + if (m_txOneBeaconImmediately){ + m_txOneBeaconImmediately = FALSE; + call BeaconTx.transmit(0, 0, 0, FALSE); // now! + } else + call BeaconTxAlarm.startAt(m_lastBeaconTxTime, m_dt - IEEE154_RADIO_TX_SEND_DELAY); + } + } + + async event void BeaconTx.transmitDone(ieee154_txframe_t *frame, + ieee154_reftime_t *referenceTime, bool pendingFlag, error_t error) + { + // Coord CAP has just started... + uint8_t gtsFieldLength; + // Sec. 7.5.1.1: "start of slot 0 is defined as the point at which + // the first symbol of the beacon PPDU is transmitted" + call Debug.log(LEVEL_INFO, StartP_BEACON_TRANSMITTED, frame->metadata->timestamp, m_lastBeaconTxTime, m_dt); + m_lastBeaconTxTime = frame->metadata->timestamp; + memcpy(&m_lastBeaconTxRefTime, referenceTime, sizeof(ieee154_reftime_t)); + m_numGtsSlots = (frame->payload[2] & 0x07); + gtsFieldLength = 1 + ((m_numGtsSlots > 0) ? 1 + m_numGtsSlots * 3: 0); + m_finalCAPSlot = (frame->payload[1] & 0x0F); + m_sfSlotDuration = (((uint32_t) 1) << ((frame->payload[0] & 0xF0) >> 4)) * IEEE154_aBaseSlotDuration; + if (frame->header->mhr[0] & FC1_FRAME_PENDING) + m_framePendingBit = TRUE; + else + m_framePendingBit = FALSE; + memcpy(m_gtsField, &frame->payload[0], gtsFieldLength); + if (frame->payload[1] & 0x10){ + // BLE is active; calculate the time offset from slot0 + m_BLELen = IEEE154_SHR_DURATION + + (frame->headerLen + frame->payloadLen) * IEEE154_SYMBOLS_PER_OCTET; + if (frame->headerLen + frame->payloadLen > IEEE154_aMaxSIFSFrameSize) + m_BLELen += IEEE154_MIN_LIFS_PERIOD; + else + m_BLELen += IEEE154_MIN_SIFS_PERIOD; + m_BLELen += m_battLifeExtPeriods; + } else + m_BLELen = 0; + call Token.request(); // register another request, before ... + call TokenToBroadcast.transfer(); // ... we let Broadcast module take over + post txDoneTask(); + } + + task void txDoneTask() + { + call MLME_SET.macBSN(m_bsn++); + call SetMacBeaconTxTime.set(m_lastBeaconTxTime); // start of slot0, ie. first preamble byte of beacon + call BeaconPayloadUpdateTimer.startOneShotAt(m_lastBeaconTxTime, + (m_beaconInterval>BEACON_PAYLOAD_UPDATE_INTERVAL) ? (m_beaconInterval - BEACON_PAYLOAD_UPDATE_INTERVAL): 0); + if (m_requests & REQUEST_CONFIRM_PENDING){ + m_requests &= ~REQUEST_CONFIRM_PENDING; + signal MLME_START.confirm(IEEE154_SUCCESS); + } + m_txState = S_TX_IDLE; + signal IEEE154TxBeaconPayload.beaconTransmitted(); + call Debug.flush(); + } + + +/* ----------------------- Beacon Payload ----------------------- */ +/* + * All access to the payload fields in the beacon happen + * through a set of temporary variables/flags, and just before + * the frame is loaded into the radio these changes are + * propagated into the actual payload portion of the beacon frame. + */ + + command error_t IEEE154TxBeaconPayload.setBeaconPayload(void *beaconPayload, uint8_t length) + { + if (length > IEEE154_aMaxBeaconPayloadLength) + return ESIZE; + else { + if (m_payloadState & MODIFIED_BEACON_PAYLOAD) + return EBUSY; + m_updateBeaconPayload = beaconPayload; + m_updateBeaconLength = length; + m_updateBeaconOffset = 0; + m_payloadState |= (MODIFIED_BEACON_PAYLOAD | MODIFIED_BEACON_PAYLOAD_NEW); + } + return SUCCESS; + } + + command const void* IEEE154TxBeaconPayload.getBeaconPayload() + { + return &m_payload[IEEE154_aMaxBeaconOverhead]; + } + + command uint8_t IEEE154TxBeaconPayload.getBeaconPayloadLength() + { + return m_beaconFrame.payloadLen - (m_pendingAddrLen + m_pendingGtsLen + 2); + } + + command error_t IEEE154TxBeaconPayload.modifyBeaconPayload(uint8_t offset, void *buffer, uint8_t bufferLength) + { + uint16_t totalLen = offset + bufferLength; + if (totalLen > IEEE154_aMaxBeaconPayloadLength || + call IEEE154TxBeaconPayload.getBeaconPayloadLength() < totalLen) + return ESIZE; + else { + if (m_payloadState & MODIFIED_BEACON_PAYLOAD) + return EBUSY; + m_updateBeaconPayload = buffer; + m_updateBeaconOffset = offset; + m_updateBeaconLength = bufferLength; + m_payloadState |= MODIFIED_BEACON_PAYLOAD; + } + return SUCCESS; + } + + event void PIBUpdate.notify[uint8_t attributeID](const void* attributeValue) + { + switch (attributeID) + { + case IEEE154_macAssociationPermit: + atomic m_payloadState |= MODIFIED_SF_SPEC; + break; + case IEEE154_macGTSPermit: + atomic m_payloadState |= MODIFIED_GTS_FIELD; + break; + default: + break; + } + } + + event void PendingAddrSpecUpdated.notify(bool val) + { + atomic m_payloadState |= MODIFIED_PENDING_ADDR_FIELD; + } + + event void GtsSpecUpdated.notify(bool val) + { + atomic m_payloadState |= MODIFIED_GTS_FIELD; + } + + uint8_t getNumGtsSlots(uint8_t *gtsInfoField) + { + uint8_t i, num=0; + for (i=0; i<(gtsInfoField[0] & GTS_DESCRIPTOR_COUNT_MASK); i++) + num += ((gtsInfoField[4+i*3] & GTS_LENGTH_MASK) >> GTS_LENGTH_OFFSET); + return num; + } + + event void BeaconPayloadUpdateTimer.fired() + { + // in this order the MAC payload is updated: + // (1) pending addresses + // (2) GTS spec + // (3) sf spec + // (4) beacon payload (if there's enough time) + uint8_t len=0, *beaconSpecs = &m_payload[IEEE154_aMaxBeaconOverhead]; // going backwards + uint8_t beaconPayloadUpdated = 0, numGtsSlots = 15 - m_finalCAPSlot; + + atomic { + if (m_txState == S_TX_LOCKED) + { + call Debug.log(LEVEL_INFO, StartP_BEACON_UPDATE, 0, 0, m_txState); + return; // too late ! + } + if (m_payloadState & MODIFIED_PENDING_ADDR_FIELD){ + len = call PendingAddrWrite.getLength(); + beaconSpecs -= len; + call PendingAddrWrite.write(beaconSpecs, len); + if (len != m_pendingAddrLen){ + m_pendingAddrLen = len; + m_payloadState |= MODIFIED_SPECS_MASK; // need to rewrite specs before + } + } else + beaconSpecs -= m_pendingAddrLen; + if (m_payloadState & MODIFIED_GTS_FIELD){ + len = call GtsInfoWrite.getLength(); + beaconSpecs -= len; + call GtsInfoWrite.write(beaconSpecs, len); + numGtsSlots = getNumGtsSlots(beaconSpecs); + if (len != m_pendingGtsLen || ((15-numGtsSlots) != m_finalCAPSlot)){ + m_pendingGtsLen = len; + m_payloadState |= MODIFIED_SPECS_MASK; // need to rewrite specs before + } + } else + beaconSpecs -= m_pendingGtsLen; + beaconSpecs -= 2; // sizeof SF Spec + if (m_payloadState & MODIFIED_SF_SPEC){ + call SuperframeSpecWrite.write(beaconSpecs, 2); + beaconSpecs[1] &= 0xF0; // clear FinalCAPSlot field + beaconSpecs[1] |= ((15-numGtsSlots) & 0x0F); // update FinalCAPSlot field + } + m_beaconFrame.payloadLen = (m_pendingAddrLen + m_pendingGtsLen + 2) + m_beaconPayloadLen; + m_beaconFrame.payload = beaconSpecs; + m_payloadState &= ~MODIFIED_SPECS_MASK; // clear flags + } // end atomic (give BeaconTxAlarm.fired() the chance to execute) + signal IEEE154TxBeaconPayload.aboutToTransmit(); + atomic { + if (m_txState == S_TX_LOCKED) + { + call Debug.log(LEVEL_INFO, StartP_BEACON_UPDATE_2, 0, 0, m_txState); + return; // too late ! + } + if (m_payloadState & MODIFIED_BEACON_PAYLOAD){ + memcpy(&m_payload[IEEE154_aMaxBeaconOverhead + m_updateBeaconOffset], + m_updateBeaconPayload, m_updateBeaconLength); + beaconPayloadUpdated = (m_payloadState & MODIFIED_BEACON_PAYLOAD_MASK); + if (beaconPayloadUpdated & MODIFIED_BEACON_PAYLOAD_NEW) + m_beaconPayloadLen = m_updateBeaconOffset + m_updateBeaconLength; + } + m_beaconFrame.payloadLen = (m_pendingAddrLen + m_pendingGtsLen + 2) + m_beaconPayloadLen; + m_payloadState &= ~MODIFIED_BEACON_PAYLOAD_MASK; + } + if (beaconPayloadUpdated){ + if ((beaconPayloadUpdated & MODIFIED_BEACON_PAYLOAD_NEW)) + signal IEEE154TxBeaconPayload.setBeaconPayloadDone(m_updateBeaconPayload, m_updateBeaconLength); + else + signal IEEE154TxBeaconPayload.modifyBeaconPayloadDone(m_updateBeaconOffset, + m_updateBeaconPayload, m_updateBeaconLength); + } + } + +/* ----------------------- SuperframeSpec ----------------------- */ + + command uint8_t SuperframeSpecWrite.write(uint8_t *superframeSpecField, uint8_t maxlen) + { + if (call SuperframeSpecWrite.getLength() > maxlen) + return 0; + superframeSpecField[0] = m_beaconOrder | (m_superframeOrder << 4); + superframeSpecField[1] = m_finalCAPSlot; + if (m_PANCoordinator) + superframeSpecField[1] |= SF_SPEC2_PAN_COORD; + if (call MLME_GET.macAssociationPermit()) + superframeSpecField[1] |= SF_SPEC2_ASSOCIATION_PERMIT; + return 2; + } + + command uint8_t SuperframeSpecWrite.getLength() + { + return 2; + } + +/* ----------------------- Realignment ----------------------- */ +/* In beacon-enabled mode a realignment frame was broadcast in the CAP + * immediately after the beacon was transmitted. In non-beacon-enabled mode a + * realignment frame was sent using unslotted CSMA. In both cases, if the + * transmission was successful, the superframe spec must be updated now. + **/ + + event void RealignmentBeaconEnabledTx.transmitDone(ieee154_txframe_t *frame, ieee154_status_t status) + { + finishRealignment(frame, status); + } + + event void RealignmentNonBeaconEnabledTx.transmitDone(ieee154_txframe_t *frame, ieee154_status_t status) + { + finishRealignment(frame, status); + } + + void finishRealignment(ieee154_txframe_t *frame, ieee154_status_t status) + { + call GetSetRealignmentFrame.set(frame); + if (status == IEEE154_SUCCESS){ + continueStartRequest(); + m_requests &= ~REQUEST_REALIGNMENT_DONE_PENDING; // unlock + // signal confirm where we calculate the next beacon transmission time + } else { + m_requests = 0; + signal MLME_START.confirm(status); + } + } + +/* ----------------------- BeaconRequest ----------------------- */ + + event message_t* BeaconRequestRx.received(message_t* frame) + { + if (!call IsSendingBeacons.get()){ + // transmit the beacon frame using unslotted CSMA-CA + // TODO + } + return frame; + } + +/* ----------------------- Defaults, etc. ----------------------- */ + + task void signalStartConfirmSuccessTask() + { + signal MLME_START.confirm(SUCCESS); + } + + command bool IsSendingBeacons.get(){ return m_beaconOrder < 15;} + + async command uint32_t BeaconInterval.getNow() { return m_beaconInterval; } + async command uint32_t CapStart.getNow() { return m_lastBeaconTxTime; } + async command ieee154_reftime_t* CapStartRefTime.getNow() { return &m_lastBeaconTxRefTime; } + async command uint32_t CapLen.getNow() { return call SfSlotDuration.getNow() * (call FinalCapSlot.getNow() + 1);} + async command uint32_t CapEnd.getNow() + { + return call CapStart.getNow() + call CapLen.getNow(); + } + async command uint32_t CfpEnd.getNow() + { + return call CapStart.getNow() + call SfSlotDuration.getNow() * IEEE154_aNumSuperframeSlots; + } + async command uint32_t CfpLen.getNow() + { + return call SfSlotDuration.getNow() * (15 - call FinalCapSlot.getNow()); + } + async command bool IsBLEActive.getNow(){ return m_BLELen>0;} + async command uint16_t BLELen.getNow(){ return m_BLELen;} + async command bool BeaconFramePendingBit.getNow(){ return m_framePendingBit;} + + async command uint8_t* GtsField.getNow() { return m_gtsField; } + async command uint32_t SfSlotDuration.getNow() { return m_sfSlotDuration; } + async command uint8_t FinalCapSlot.getNow() { return m_finalCAPSlot; } + async command uint8_t NumGtsSlots.getNow() { return m_numGtsSlots; } + + default event void MLME_START.confirm ( + ieee154_status_t status + ){} + + default event void IEEE154TxBeaconPayload.setBeaconPayloadDone(void *beaconPayload, uint8_t length){} + + default event void IEEE154TxBeaconPayload.modifyBeaconPayloadDone(uint8_t offset, void *buffer, uint8_t bufferLength){} + + default event void IEEE154TxBeaconPayload.aboutToTransmit(){} + + default event void IEEE154TxBeaconPayload.beaconTransmitted(){} + +} diff --git a/tos/lib/mac/tkn154/CapP.nc b/tos/lib/mac/tkn154/CapP.nc new file mode 100644 index 00000000..c07ccc56 --- /dev/null +++ b/tos/lib/mac/tkn154/CapP.nc @@ -0,0 +1,664 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +#include "TKN154_PHY.h" +#include "TKN154_MAC.h" + +/** + * This module is responsible for sending/receiving frames during the + * contention access period (CAP in beacon-enabled mode). It does slightly + * different things depending on whether it is the CAP for an outgoing + * superframe (superframeDirection = OUTGOING_SUPERFRAME), i.e. the CAP from + * the perspective of a coordinator after it has transmitted its own beacon; or + * for an incoming superframe (superframeDirection = INCOMING_SUPERFRAME), i.e. + * the CAP from the perspective of a device after it has received a beacon from + * its coordinator (e.g. in the CAP a coordinator will usually listen for + * incoming frames from the devices, and a device will usually switch the + * radio off unless it has a frame to transmit). + */ + +generic module CapP(uint8_t superframeDirection) +{ + provides + { + interface Init as Reset; + interface FrameTx as CapTx; + interface FrameRx as FrameRx[uint8_t frameType]; + interface FrameExtracted as FrameExtracted[uint8_t frameType]; + interface FrameTxNow as BroadcastTx; + interface Notify as WasRxEnabled; + } + uses + { + interface Random; + interface Alarm as CapEndAlarm; + interface Alarm as BLEAlarm; + interface Alarm as IndirectTxWaitAlarm; + interface Alarm as BroadcastAlarm; + interface Resource as Token; + interface ResourceTransfer as TokenToCfp; + interface ResourceTransferred as TokenTransferred; + interface ResourceRequested as TokenRequested; + interface GetNow as IsTokenRequested; + interface GetNow as CapStart; + interface GetNow as CapStartRefTime; + interface GetNow as CapLen; + interface GetNow as IsBLEActive; + interface GetNow as BLELen; + interface GetNow as IsRxBroadcastPending; + interface GetNow as IsRxEnableActive; + interface Notify as RxEnableStateChange; + interface FrameUtility; + interface RadioTx; + interface RadioRx; + interface RadioOff; + interface Get as IsBeaconEnabledPAN; + interface MLME_GET; + interface MLME_SET; + interface Ieee802154Debug as Debug; + interface TimeCalc; + interface Leds; + interface SetNow as FrameBackup; + interface GetNow as FrameRestore; + } +} +implementation +{ + typedef enum { + SWITCH_OFF, + LOAD_TX, + PREPARE_RX, + DO_NOTHING, + WAIT_FOR_TXDONE, + } next_state_t; + + typedef enum { + INDIRECT_TX_ALARM, + BROADCAST_ALARM, + NO_ALARM, + } rx_alarm_t; + + enum { + COORD_ROLE = (superframeDirection == OUTGOING_SUPERFRAME), + DEVICE_ROLE = !COORD_ROLE, + }; + + norace bool m_lock; + norace ieee154_txframe_t *m_currentFrame; + norace ieee154_txframe_t *m_bcastFrame; + norace ieee154_txframe_t *m_lastFrame; + norace ieee154_macMaxBE_t m_BE; + norace ieee154_macMaxCSMABackoffs_t m_allowedBackoffs; + norace ieee154_macMaxBE_t m_macMaxBE; + norace uint16_t m_backoff; + norace uint16_t m_backoffElapsed; + norace ieee154_status_t m_result; + norace uint32_t m_transactionTime; + norace bool m_indirectTxPending = FALSE; + norace bool m_broadcastRxPending; + norace ieee154_macMaxFrameTotalWaitTime_t m_macMaxFrameTotalWaitTime; + + uint16_t generateRandomBackoff(uint8_t BE); + void stopAllAlarms(); + next_state_t tryReceive(rx_alarm_t alarmType); + next_state_t tryTransmit(); + next_state_t trySwitchOff(); + void backupCurrentFrame(); + void restoreFrameFromBackup(); + void updateState(); + void setCurrentFrame(ieee154_txframe_t *frame); + void signalTxBroadcastDone(ieee154_txframe_t *frame, ieee154_status_t error); + task void signalTxDoneTask(); + task void setupTxBroadcastTask(); + task void wasRxEnabledTask(); + + command error_t Reset.init() + { + if (call Token.isOwner()){ + call Leds.led0On(); // internal error + return FAIL; + } + if (m_currentFrame) + signal CapTx.transmitDone(m_currentFrame, IEEE154_TRANSACTION_OVERFLOW); + if (m_lastFrame) + signal CapTx.transmitDone(m_lastFrame, IEEE154_TRANSACTION_OVERFLOW); + if (m_bcastFrame) + signalTxBroadcastDone(m_bcastFrame, IEEE154_TRANSACTION_OVERFLOW); + m_currentFrame = m_lastFrame = m_bcastFrame = NULL; + m_macMaxFrameTotalWaitTime = call MLME_GET.macMaxFrameTotalWaitTime(); + stopAllAlarms(); + return SUCCESS; + } + + async event void TokenTransferred.transferred() + { + // we got the token, i.e. CAP has just started + uint32_t actualCapLen = call CapLen.getNow(); + if (actualCapLen < IEEE154_RADIO_GUARD_TIME){ + call Debug.log(LEVEL_IMPORTANT, CapP_TOO_SHORT, superframeDirection, actualCapLen, IEEE154_RADIO_GUARD_TIME); + call TokenToCfp.transfer(); + return; + } else { + actualCapLen -= IEEE154_RADIO_GUARD_TIME; + if (DEVICE_ROLE) + m_broadcastRxPending = call IsRxBroadcastPending.getNow(); + else { + // COORD_ROLE + if (m_bcastFrame != NULL) { + // we have to transmit a broadcast frame immediately; this + // (possibly) requires a backup of the previously active frame + // and a reinitializing the CSMA parameters -> will do it + // in task context and then continue + m_lock = TRUE; + post setupTxBroadcastTask(); + } + } + call CapEndAlarm.startAt(call CapStart.getNow(), actualCapLen); + if (call IsBLEActive.getNow()) + call BLEAlarm.startAt(call CapStart.getNow(), call BLELen.getNow()); + call Debug.log(LEVEL_IMPORTANT, CapP_SET_CAP_END, call CapStart.getNow(), actualCapLen, call CapStart.getNow()+ actualCapLen); + } + updateState(); + } + + command ieee154_status_t CapTx.transmit(ieee154_txframe_t *frame) + { + // this frame (DATA or COMMAND) should be transmitted in the CAP + if (m_currentFrame != NULL) + return IEEE154_TRANSACTION_OVERFLOW; + else { + setCurrentFrame(frame); + updateState(); + return IEEE154_SUCCESS; + } + } + + task void setupTxBroadcastTask() + { + ieee154_macDSN_t tmp; + ieee154_txframe_t *oldFrame = m_currentFrame; + if (COORD_ROLE){ + if (m_bcastFrame != NULL){ + // broadcasts should be transmitted *immediately* after the beacon, + // which may interrupt a pending transmit operation from the previous + // CAP; back up the last active frame configuration (may be none) + // and restore it after the broadcast frame has been transmitted; + // do this through interfaces and don't wire them for DEVICE_ROLE, + // so we don't waste the RAM of devices + backupCurrentFrame(); + setCurrentFrame(m_bcastFrame); + if (oldFrame){ + // now the sequence number are out of order... swap them back + tmp = m_bcastFrame->header->mhr[MHR_INDEX_SEQNO]; + m_bcastFrame->header->mhr[MHR_INDEX_SEQNO] = + oldFrame->header->mhr[MHR_INDEX_SEQNO]; + oldFrame->header->mhr[MHR_INDEX_SEQNO] = tmp; + } + } + } + m_lock = FALSE; + updateState(); + } + + void setCurrentFrame(ieee154_txframe_t *frame) + { + ieee154_macDSN_t dsn = call MLME_GET.macDSN(); + frame->header->mhr[MHR_INDEX_SEQNO] = dsn++; + call MLME_SET.macDSN(dsn); + // m_allowedBackoffs will be decreased in every iteration (at zero the transmission failed) + m_allowedBackoffs = call MLME_GET.macMaxCSMABackoffs(); + m_macMaxBE = call MLME_GET.macMaxBE(); + m_BE = call MLME_GET.macMinBE(); + if (call MLME_GET.macBattLifeExt() && m_BE > 2) + m_BE = 2; + m_transactionTime = IEEE154_SHR_DURATION + + (frame->headerLen + frame->payloadLen) * IEEE154_SYMBOLS_PER_OCTET; + if (frame->header->mhr[0] & FC1_ACK_REQUEST) + m_transactionTime += (IEEE154_aTurnaroundTime + IEEE154_aUnitBackoffPeriod + + 11 * IEEE154_SYMBOLS_PER_OCTET); + if (frame->headerLen + frame->payloadLen > IEEE154_aMaxSIFSFrameSize) + m_transactionTime += call MLME_GET.macMinLIFSPeriod(); + else + m_transactionTime += call MLME_GET.macMinSIFSPeriod(); + m_backoff = generateRandomBackoff(m_BE) * IEEE154_aUnitBackoffPeriod; // initial backoff + m_macMaxFrameTotalWaitTime = call MLME_GET.macMaxFrameTotalWaitTime(); + m_backoffElapsed = 0; + m_currentFrame = frame; + } + + uint16_t generateRandomBackoff(uint8_t BE) + { + // return random number from [0,(2^BE) - 1] (uniform distr.) + uint16_t res = call Random.rand16(); + uint16_t mask = 0xFFFF; + mask <<= BE; + mask = ~mask; + res &= mask; + return res; + } + + void stopAllAlarms() + { + call CapEndAlarm.stop(); + if (DEVICE_ROLE){ + call IndirectTxWaitAlarm.stop(); + call BroadcastAlarm.stop(); + } + call BLEAlarm.stop(); + } + + /** + * The updateState() function is called whenever some event happened that + * might require a state change; it implements a lock mechanism (m_lock) to + * prevent race conditions. Whenever the lock is set a "done"-event (from a + * RadioTx/RadioRx/RadioOff interface) is pending and will "soon" unset the + * lock (and then updateState() will called again). The updateState() + * function decides about the next state by checking a list of possible + * current states ordered by priority, e.g. it first always checks whether + * the CAP is still active. Calling this function more than necessary can do + * no harm, but it SHOULD be called whenever an event happened that might + * lead to a state change. + */ + + void updateState() + { + error_t result = SUCCESS; + next_state_t next; + atomic { + // long atomics are bad... but in this block, once the + // current state has been determined only one branch will + // be taken (no loops, etc.) + if (m_lock || !call Token.isOwner()) + return; + m_lock = TRUE; // lock + + // Check 1: has the CAP finished? + if (call TimeCalc.hasExpired(call CapStart.getNow(), call CapLen.getNow()-IEEE154_RADIO_GUARD_TIME) || + !call CapEndAlarm.isRunning()){ + if (call RadioOff.isOff()) { + stopAllAlarms(); // may still fire, locked through isOwner() + if (DEVICE_ROLE && m_indirectTxPending) + signal IndirectTxWaitAlarm.fired(); + m_broadcastRxPending = FALSE; + if (COORD_ROLE && m_bcastFrame){ + // didn't manage to transmit a broadcast + restoreFrameFromBackup(); + signalTxBroadcastDone(m_bcastFrame, IEEE154_CHANNEL_ACCESS_FAILURE); + m_bcastFrame = NULL; + } + m_lock = FALSE; // unlock + call TokenToCfp.transfer(); + return; + } else + next = SWITCH_OFF; + } + + // Check 2: should a broadcast frame be received/transmitted immediately + // at the start of CAP? + else if (DEVICE_ROLE && m_broadcastRxPending){ + // receive a broadcast from coordinator + next = tryReceive(BROADCAST_ALARM); + } else if (COORD_ROLE && m_bcastFrame){ + next = tryTransmit(); + } + + // Check 3: was an indirect transmission successfully started + // and are we now waiting for a frame from the coordinator? + else if (DEVICE_ROLE && m_indirectTxPending) { + next = tryReceive(INDIRECT_TX_ALARM); + } + + // Check 4: is some other operation (like MLME-SCAN or MLME-RESET) pending? + else if (call IsTokenRequested.getNow()) { + if (call RadioOff.isOff()) { + stopAllAlarms(); // may still fire, locked through isOwner() + call Token.release(); + next = DO_NOTHING; + } else + next = SWITCH_OFF; + } + + // Check 5: is battery life extension (BLE) active and + // has the BLE period expired? + else if (call IsBLEActive.getNow() && + call TimeCalc.hasExpired(call CapStart.getNow(), call BLELen.getNow()) && + !call IsRxEnableActive.getNow()) { + next = trySwitchOff(); + } + + // Check 6: is there a frame ready to transmit? + else if (m_currentFrame != NULL) { + next = tryTransmit(); + } + + // Check 7: should we be in receive mode? + else if (COORD_ROLE || call IsRxEnableActive.getNow()) { + next = tryReceive(NO_ALARM); + if (next == DO_NOTHING && call IsRxEnableActive.getNow()){ + // this means there is an active MLME_RX_ENABLE.request + // and the radio was just switched to Rx mode - signal + // a notify event to inform the next higher layer + post wasRxEnabledTask(); + } + } + + // Check 8: just make sure the radio is switched off + else { + next = trySwitchOff(); + } + + // if there is nothing to do, then we must clear the lock + if (next == DO_NOTHING) + m_lock = FALSE; + } // atomic + // put next state in operation (possibly keeping the lock) + switch (next) + { + case SWITCH_OFF: result = call RadioOff.off(); break; + case LOAD_TX: result = call RadioTx.load(m_currentFrame); break; + case PREPARE_RX: result = call RadioRx.prepare(); break; + case WAIT_FOR_TXDONE: break; + case DO_NOTHING: break; + } + if (result != SUCCESS) + call Leds.led0On(); // internal error: could not update state !!! + } + + next_state_t tryTransmit() + { + // tries to transmit m_currentFrame using the configuration stored + // in other module variables (m_backoff, etc.) + next_state_t next; + if (call RadioTx.getLoadedFrame() == m_currentFrame){ + // the frame is already loaded -> transmit it now (if there's enough time) + uint32_t capLen = call CapLen.getNow(), capStart = call CapStart.getNow(); + uint32_t elapsed, totalTime; + totalTime = IEEE154_RADIO_TX_SEND_DELAY + + m_backoff - m_backoffElapsed + m_transactionTime + IEEE154_RADIO_GUARD_TIME; + if (totalTime > capLen) + totalTime = capLen; // CAP is too short + elapsed = call TimeCalc.timeElapsed(capStart, call CapEndAlarm.getNow()); + elapsed += (20 - (elapsed % 20)); // round to backoff boundary + if (!call TimeCalc.hasExpired(capStart, capLen - totalTime)){ + call RadioTx.transmit(call CapStartRefTime.getNow(), + elapsed + IEEE154_RADIO_TX_SEND_DELAY + m_backoff - m_backoffElapsed, + 2, + m_currentFrame->header->mhr[0] & FC1_ACK_REQUEST ? TRUE : FALSE); + next = WAIT_FOR_TXDONE; // ATTENTION: this will NOT clear the lock + } else { + // frame does not fit in remaing portion of the CAP + if (elapsed < call CapLen.getNow()){ + m_backoffElapsed += call CapLen.getNow() - elapsed; + if (m_backoffElapsed > m_backoff) + m_backoffElapsed = m_backoff; + } + next = SWITCH_OFF; + } + } else { + // the frame to transmit has not yet been loaded -> load it now + if (!call RadioOff.isOff()) + next = SWITCH_OFF; + else { + if (m_lastFrame){ + // we just transmitted a frame and have not yet + // signalled the done to the upper layer -> wait + next = DO_NOTHING; + } else + next = LOAD_TX; + } + } + return next; + } + + next_state_t tryReceive(rx_alarm_t alarmType) + { + next_state_t next; + if (call RadioRx.isReceiving()){ + next = DO_NOTHING; + } else if (call RadioRx.isPrepared()){ + call RadioRx.receive(NULL, 0); + switch (alarmType) + { + case INDIRECT_TX_ALARM: call IndirectTxWaitAlarm.start(m_macMaxFrameTotalWaitTime); break; + case BROADCAST_ALARM: call BroadcastAlarm.start(m_macMaxFrameTotalWaitTime); break; + case NO_ALARM: break; + } + next = DO_NOTHING; + } else if (call RadioOff.isOff()) + next = PREPARE_RX; + else + next = SWITCH_OFF; + return next; + } + + next_state_t trySwitchOff() + { + next_state_t next; + if (call RadioOff.isOff()) + next = DO_NOTHING; + else + next = SWITCH_OFF; + return next; + } + + async event void RadioTx.loadDone(){ m_lock = FALSE; updateState();} + async event void RadioOff.offDone(){ m_lock = FALSE; updateState();} + async event void RadioRx.prepareDone(){ m_lock = FALSE; updateState();} + + async event void CapEndAlarm.fired(){ + call Debug.log(LEVEL_IMPORTANT, CapP_CAP_END_FIRED, superframeDirection, 0, 0); + updateState(); + } + async event void BLEAlarm.fired(){ updateState();} + event void RxEnableStateChange.notify(bool whatever){ updateState();} + async event void BroadcastAlarm.fired(){ m_broadcastRxPending = FALSE; updateState();} + + async event void IndirectTxWaitAlarm.fired() + { + atomic { + if (m_indirectTxPending){ + m_indirectTxPending = FALSE; + post signalTxDoneTask(); + } + } + } + + async event void RadioTx.transmitDone(ieee154_txframe_t *frame, + ieee154_reftime_t *referenceTime, bool ackPendingFlag, error_t error) + { + switch (error) + { + case SUCCESS: + m_result = IEEE154_SUCCESS; + if (DEVICE_ROLE && frame->payload[0] == CMD_FRAME_DATA_REQUEST && + ((frame->header->mhr[MHR_INDEX_FC1]) & FC1_FRAMETYPE_MASK) == FC1_FRAMETYPE_CMD){ + // just transmitted a data request frame + m_result = IEEE154_NO_DATA; // pessimistic + if (ackPendingFlag){ + // the coordinator has data for us; switch to Rx + // to complete the indirect transmission + m_indirectTxPending = TRUE; + m_lastFrame = m_currentFrame; + m_currentFrame = NULL; + if (call RadioRx.prepare() != SUCCESS) // SHOULD succeed + call RadioOff.off(); + return; + } + } + break; + case EBUSY: + m_result = IEEE154_CHANNEL_ACCESS_FAILURE; + if (m_allowedBackoffs > 0){ + m_allowedBackoffs -= 1; + m_BE += 1; + if (m_BE > m_macMaxBE) + m_BE = m_macMaxBE; + m_backoff = generateRandomBackoff(m_BE) * IEEE154_aUnitBackoffPeriod; // next backoff + m_backoffElapsed = 0; + m_lock = FALSE; + updateState(); + return; + } + break; + case ENOACK: + m_result = IEEE154_NO_ACK; + break; + default: break; + } + if (COORD_ROLE && frame == m_bcastFrame){ + // signal result of broadcast transmissions immediately + restoreFrameFromBackup(); + signalTxBroadcastDone(m_bcastFrame, m_result); + m_bcastFrame = NULL; + } else { + m_lastFrame = m_currentFrame; + m_currentFrame = NULL; + post signalTxDoneTask(); + } + m_lock = FALSE; + updateState(); + } + + task void signalTxDoneTask() + { + ieee154_txframe_t *lastFrame = m_lastFrame; + m_lastFrame = NULL; // only now can a next transmission begin + m_indirectTxPending = FALSE; + if (lastFrame) + signal CapTx.transmitDone(lastFrame, m_result); + updateState(); + } + + event message_t* RadioRx.received(message_t* frame, ieee154_reftime_t *timestamp) + { + // received a frame during CAP - find out frame type and + // signal it to corresponding client component + uint8_t *payload = (uint8_t *) frame->data; + uint8_t *mhr = MHR(frame); + uint8_t frameType = mhr[MHR_INDEX_FC1] & FC1_FRAMETYPE_MASK; + if (frameType == FC1_FRAMETYPE_CMD) + frameType += payload[0]; + atomic { + if (DEVICE_ROLE && m_indirectTxPending){ + message_t* frameBuf; + call IndirectTxWaitAlarm.stop(); + // TODO: check! + //if (frame->payloadLen) + // is this frame from our coordinator? hmm... we cannot say + // with certainty, because we might only know either the + // coordinator extended or short address (and the frame could + // have been sent with the other addressing mode) ?? + m_result = IEEE154_SUCCESS; + frameBuf = signal FrameExtracted.received[frameType](frame, m_lastFrame); + signal IndirectTxWaitAlarm.fired(); + return frameBuf; + } else + return signal FrameRx.received[frameType](frame); + } + } + + void backupCurrentFrame() + { + ieee154_cap_frame_backup_t backup = {m_currentFrame, m_BE, m_allowedBackoffs, + m_macMaxBE, m_backoff, m_backoffElapsed, m_transactionTime}; + call FrameBackup.setNow(&backup); + } + + void restoreFrameFromBackup() + { + ieee154_cap_frame_backup_t *backup = call FrameRestore.getNow(); + if (backup != NULL){ + m_currentFrame = backup->frame; + m_BE = backup->BE; + m_allowedBackoffs = backup->allowedBackoffs; + m_macMaxBE = backup->macMaxBE; + m_backoff = backup->backoff; + m_backoffElapsed = backup->backoffElapsed; + m_transactionTime = backup->transactionTime; + } + } + + async command ieee154_status_t BroadcastTx.transmitNow(ieee154_txframe_t *frame) + { + // if this command is called then it is (MUST be) called + // only just before the token is transferred to this component + // and it is then be called only once per CAP (max. one broadcast + // is allowed after a beacon transmission) + atomic { + if (!call Token.isOwner() && m_bcastFrame == NULL){ + m_bcastFrame = frame; + return IEEE154_SUCCESS; + } else { + call Leds.led0On(); + return IEEE154_TRANSACTION_OVERFLOW; + } + } + } + + void signalTxBroadcastDone(ieee154_txframe_t *frame, ieee154_status_t error) + { + signal BroadcastTx.transmitNowDone(frame, error); + } + + task void wasRxEnabledTask() + { + signal WasRxEnabled.notify(TRUE); + } + + async event void TokenRequested.requested() {} + async event void TokenRequested.immediateRequested() {} + event void Token.granted(){} + + default event void CapTx.transmitDone(ieee154_txframe_t *data, ieee154_status_t status){} + default event message_t* FrameRx.received[uint8_t client](message_t* data){return data;} + default async command bool IsRxEnableActive.getNow(){return FALSE;} + + default async command void IndirectTxWaitAlarm.start(uint32_t dt){call Leds.led0On();} + default async command void IndirectTxWaitAlarm.stop(){call Leds.led0On();} + default async command void IndirectTxWaitAlarm.startAt(uint32_t t0, uint32_t dt){call Leds.led0On();} + + default async command void BroadcastAlarm.start(uint32_t dt){call Leds.led0On();} + default async command void BroadcastAlarm.stop(){call Leds.led0On();} + default async command void BroadcastAlarm.startAt(uint32_t t0, uint32_t dt){call Leds.led0On();} + + default async command bool IsRxBroadcastPending.getNow(){ return FALSE;} + default async event void BroadcastTx.transmitNowDone(ieee154_txframe_t *frame, ieee154_status_t status){} + default event message_t* FrameExtracted.received[uint8_t client](message_t* msg, ieee154_txframe_t *txFrame){return msg;} + default async command error_t FrameBackup.setNow(ieee154_cap_frame_backup_t* val ){return FAIL;} + default async command ieee154_cap_frame_backup_t* FrameRestore.getNow(){return NULL;} + + command error_t WasRxEnabled.enable(){return FAIL;} + command error_t WasRxEnabled.disable(){return FAIL;} +} diff --git a/tos/lib/mac/tkn154/CapQueueP.nc b/tos/lib/mac/tkn154/CapQueueP.nc new file mode 100644 index 00000000..b3104d4c --- /dev/null +++ b/tos/lib/mac/tkn154/CapQueueP.nc @@ -0,0 +1,128 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ +#include "TKN154_MAC.h" +generic module CapQueueP() { + provides + { + interface Init as Reset; + interface FrameTx[uint8_t client]; + interface FrameRx as FrameExtracted[uint8_t client]; + interface Purge; + } uses { + interface Queue; + interface FrameTx as CapTx; + interface FrameRx as SubFrameExtracted; + } +} +implementation +{ + task void tryCapTxTask(); + bool m_busy; + uint8_t m_client; + + command error_t Reset.init() + { + while (call Queue.size()){ + ieee154_txframe_t *txFrame = call Queue.dequeue(); + signal FrameTx.transmitDone[txFrame->client](txFrame, IEEE154_TRANSACTION_OVERFLOW); + } + m_busy = FALSE; + return SUCCESS; + } + + command ieee154_status_t FrameTx.transmit[uint8_t client](ieee154_txframe_t *txFrame) + { + txFrame->client = client; + if (call Queue.enqueue(txFrame) != SUCCESS) + return IEEE154_TRANSACTION_OVERFLOW; + else { + post tryCapTxTask(); + return IEEE154_SUCCESS; + } + } + + task void tryCapTxTask() + { + if (!m_busy && call Queue.size()){ + ieee154_txframe_t *txFrame = call Queue.head(); + if (txFrame->headerLen == 0){ + // was purged + call Queue.dequeue(); + signal Purge.purgeDone(txFrame, IEEE154_SUCCESS); + post tryCapTxTask(); + } + m_client = txFrame->client; + if (call CapTx.transmit(txFrame) == IEEE154_SUCCESS){ + m_busy = TRUE; + } + } + } + + event void CapTx.transmitDone(ieee154_txframe_t *txFrame, ieee154_status_t status) + { + call Queue.dequeue(); + m_busy = FALSE; + signal FrameTx.transmitDone[txFrame->client](txFrame, status); + post tryCapTxTask(); + } + + event message_t* SubFrameExtracted.received(message_t* frame) + { + // this event is signalled when a frame has been received + // in response to a data request command frame. The transmitDone + // event will be signalled later + return signal FrameExtracted.received[m_client](frame); + } + + default event void FrameTx.transmitDone[uint8_t client](ieee154_txframe_t *txFrame, ieee154_status_t status){} + + command ieee154_status_t Purge.purge(uint8_t msduHandle) + { + uint8_t qSize = call Queue.size(), i; + if (qSize > 1){ + for (i=0; iheader->mhr[MHR_INDEX_FC1] & FC1_FRAMETYPE_MASK) == FC1_FRAMETYPE_DATA) && + txFrame->handle == msduHandle){ + txFrame->headerLen = 0; // mark as invalid + return IEEE154_SUCCESS; + } + } + } + return IEEE154_INVALID_HANDLE; + } + + default event void Purge.purgeDone(ieee154_txframe_t *txFrame, ieee154_status_t status){} +} diff --git a/tos/lib/mac/tkn154/CoordBroadcastP.nc b/tos/lib/mac/tkn154/CoordBroadcastP.nc new file mode 100644 index 00000000..3046a12d --- /dev/null +++ b/tos/lib/mac/tkn154/CoordBroadcastP.nc @@ -0,0 +1,146 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +/* This component is responsible for sending broadcast frames from + * a coordinator to devices. + **/ + +#include "TKN154_MAC.h" +module CoordBroadcastP +{ + provides + { + interface Init as Reset; + interface FrameTx as BroadcastDataFrame; + interface FrameTx as RealignmentTx; + interface GetNow as IsBroadcastReady; + } uses { + interface Queue; + interface FrameTxNow as CapTransmitNow; + interface ResourceTransfer as TokenToCap; + interface ResourceTransferred as TokenTransferred; + interface GetNow as BeaconFramePendingBit; + interface Leds; + } +} +implementation +{ + norace bool m_lock; + norace ieee154_txframe_t *m_realignmentFrame; + norace ieee154_txframe_t *m_queueHead; + norace ieee154_txframe_t *m_transmittedFrame; + norace ieee154_status_t m_status; + + task void transmitNowDoneTask(); + + command error_t Reset.init() + { + while (call Queue.size()) + signal BroadcastDataFrame.transmitDone(call Queue.dequeue(), IEEE154_TRANSACTION_OVERFLOW); + if (m_realignmentFrame) + signal RealignmentTx.transmitDone(m_realignmentFrame, IEEE154_TRANSACTION_OVERFLOW); + m_realignmentFrame = m_queueHead = m_transmittedFrame = NULL; + m_lock = FALSE; + return SUCCESS; + } + + command ieee154_status_t BroadcastDataFrame.transmit(ieee154_txframe_t *txFrame) + { + if (call Queue.enqueue(txFrame) != SUCCESS) + return IEEE154_TRANSACTION_OVERFLOW; + atomic { + if (m_queueHead == NULL) + m_queueHead = call Queue.head(); + } + return IEEE154_SUCCESS; + } + + command ieee154_status_t RealignmentTx.transmit(ieee154_txframe_t *frame) + { + atomic { + if (!m_realignmentFrame){ + m_realignmentFrame = frame; + return IEEE154_SUCCESS; + } else + return IEEE154_TRANSACTION_OVERFLOW; + } + } + + async command bool IsBroadcastReady.getNow() + { + if (m_lock) + return FALSE; + else + return (m_realignmentFrame != NULL || m_queueHead != NULL); + } + + async event void TokenTransferred.transferred() + { + // CAP has started - are there any broadcast frames to be transmitted? + if (call BeaconFramePendingBit.getNow()){ + ieee154_txframe_t *broadcastFrame = m_realignmentFrame; + if (broadcastFrame == NULL) + broadcastFrame = m_queueHead; + if (broadcastFrame){ + m_lock = TRUE; + call CapTransmitNow.transmitNow(broadcastFrame); + } else + call Leds.led0On(); // internal error! + } + call TokenToCap.transfer(); + } + + async event void CapTransmitNow.transmitNowDone(ieee154_txframe_t *txFrame, ieee154_status_t status) + { + m_transmittedFrame = txFrame; + m_status = status; + post transmitNowDoneTask(); + } + + task void transmitNowDoneTask() + { + if (!m_lock) + return; + if (m_transmittedFrame == m_realignmentFrame){ + m_realignmentFrame = NULL; + signal RealignmentTx.transmitDone(m_transmittedFrame, m_status); + } else if (m_transmittedFrame == m_queueHead){ + call Queue.dequeue(); + m_queueHead = call Queue.head(); + signal BroadcastDataFrame.transmitDone(m_transmittedFrame, m_status); + } + m_lock = FALSE; + } +} diff --git a/tos/lib/mac/tkn154/CoordRealignmentP.nc b/tos/lib/mac/tkn154/CoordRealignmentP.nc new file mode 100644 index 00000000..70421aa9 --- /dev/null +++ b/tos/lib/mac/tkn154/CoordRealignmentP.nc @@ -0,0 +1,220 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +/* "The coordinator realignment command is sent by the PAN coordinator or a + * coordinator either following the reception of an orphan notification command + * from a device that is recognized to be on its PAN or when any of its PAN + * configuration attributes change due to the receipt of an MLME-START.request + * primitive." IEEE 802.15.4-2006, Sec. 7.3.8 **/ + +#include "TKN154_MAC.h" +module CoordRealignmentP +{ + provides + { + interface Init; + interface MLME_ORPHAN; + interface MLME_COMM_STATUS; + interface GetSet as GetSetRealignmentFrame; + } + uses + { + interface FrameTx as CoordRealignmentTx; + interface FrameRx as OrphanNotificationRx; + interface FrameUtility; + interface MLME_GET; + interface IEEE154Frame as Frame; + interface Pool as TxFramePool; + interface Pool as TxControlPool; + interface Get as LocalExtendedAddress; + } +} +implementation +{ + enum { + ORPHAN_RESPONSE, + BEACON_REALIGNMENT, + }; + uint8_t m_payload[9]; + bool m_busy = FALSE; + void destroyRealignmentFrame(ieee154_txframe_t *frame); + ieee154_txframe_t *newRealignmentFrame(uint8_t type, ieee154_address_t *dstAddress); + + command error_t Init.init() + { + return SUCCESS; + } + + command ieee154_txframe_t* GetSetRealignmentFrame.get() + { + ieee154_address_t bcastAddr; + bcastAddr.shortAddress = 0xFFFF; + return newRealignmentFrame(BEACON_REALIGNMENT, &bcastAddr); + } + + command void GetSetRealignmentFrame.set(ieee154_txframe_t* frame) + { + destroyRealignmentFrame(frame); + } + + event message_t* OrphanNotificationRx.received(message_t* frame) + { + ieee154_address_t srcAddress; + if (call Frame.getSrcAddrMode(frame) == ADDR_MODE_EXTENDED_ADDRESS && + call Frame.getSrcAddr(frame, &srcAddress) == SUCCESS) + signal MLME_ORPHAN.indication ( + srcAddress.extendedAddress, + NULL // security + ); + return frame; + } + + command ieee154_status_t MLME_ORPHAN.response ( + uint64_t OrphanAddress, + uint16_t ShortAddress, + bool AssociatedMember, + ieee154_security_t *security + ) + { + ieee154_txframe_t *txFrame; + ieee154_status_t txStatus; + ieee154_address_t dstAddress; + + dstAddress.extendedAddress = OrphanAddress; + if (!AssociatedMember) + txStatus = IEEE154_SUCCESS; + else if (m_busy || (txFrame = newRealignmentFrame(ORPHAN_RESPONSE, &dstAddress)) != NULL) + txStatus = IEEE154_TRANSACTION_OVERFLOW; + else { + m_busy = TRUE; + txFrame->payload[0] = CMD_FRAME_COORDINATOR_REALIGNMENT; + *((nxle_uint16_t*) &txFrame->payload[1]) = call MLME_GET.macPANId(); + *((nxle_uint16_t*) &txFrame->payload[3]) = call MLME_GET.macShortAddress(); + txFrame->payload[5] = call MLME_GET.phyCurrentChannel(); + *((nxle_uint16_t*) &txFrame->payload[6]) = ShortAddress; + txFrame->payloadLen = 8; + if ((txStatus = call CoordRealignmentTx.transmit(txFrame)) != IEEE154_SUCCESS){ + m_busy = FALSE; + destroyRealignmentFrame(txFrame); + } + } + return txStatus; + } + + ieee154_txframe_t *newRealignmentFrame(uint8_t type, ieee154_address_t *dstAddress) + { + ieee154_txframe_t *txFrame = NULL; + ieee154_txcontrol_t *txControl; + uint8_t dstAddrMode; + ieee154_address_t srcAddress; + + if ((txFrame = call TxFramePool.get()) != NULL){ + if ((txControl = call TxControlPool.get()) == NULL){ + call TxFramePool.put(txFrame); + txFrame = NULL; + } else { + txFrame->header = &txControl->header; + txFrame->metadata = &txControl->metadata; + txFrame->payload = m_payload; + txFrame->header->mhr[MHR_INDEX_FC1] = FC1_FRAMETYPE_CMD; + txFrame->header->mhr[MHR_INDEX_FC2] = FC2_SRC_MODE_EXTENDED; + if (type == ORPHAN_RESPONSE){ + txFrame->header->mhr[MHR_INDEX_FC2] |= FC2_DEST_MODE_EXTENDED; + dstAddrMode = ADDR_MODE_EXTENDED_ADDRESS; + txFrame->header->mhr[MHR_INDEX_FC1] |= FC1_ACK_REQUEST; + } else { + txFrame->header->mhr[MHR_INDEX_FC2] |= FC2_DEST_MODE_SHORT; + dstAddrMode = ADDR_MODE_SHORT_ADDRESS; + } + srcAddress.extendedAddress = call LocalExtendedAddress.get(); + txFrame->headerLen = call FrameUtility.writeHeader( + txFrame->header->mhr, + dstAddrMode, + 0xFFFF, + dstAddress, + ADDR_MODE_EXTENDED_ADDRESS, + call MLME_GET.macPANId(), + &srcAddress, + FALSE); + } + } + return txFrame; + } + + void destroyRealignmentFrame(ieee154_txframe_t *frame) + { + call TxControlPool.put((ieee154_txcontrol_t*) ((uint8_t*) frame->header - offsetof(ieee154_txcontrol_t, header))); + call TxFramePool.put(frame); + } + + + event void CoordRealignmentTx.transmitDone(ieee154_txframe_t *txFrame, ieee154_status_t status) + { + uint8_t *mhr = MHR(txFrame); + ieee154_address_t dstAddr; + ieee154_address_t srcAddr; + if (m_busy){ + call FrameUtility.convertToNative(&dstAddr.extendedAddress, &mhr[MHR_INDEX_ADDRESS+2]); + call FrameUtility.convertToNative(&srcAddr.extendedAddress, &mhr[MHR_INDEX_ADDRESS+2+8+2]); + signal MLME_COMM_STATUS.indication ( + *((nxle_uint16_t*) &txFrame->payload[1]), // PANId + ADDR_MODE_EXTENDED_ADDRESS, // SrcAddrMode + srcAddr, + ADDR_MODE_EXTENDED_ADDRESS, // DstAddrMode + dstAddr, + status, + NULL //security + ); + call TxControlPool.put((ieee154_txcontrol_t*) ((uint8_t*) txFrame->header - offsetof(ieee154_txcontrol_t, header))); + call TxFramePool.put(txFrame); + m_busy = FALSE; + } + } + + default event void MLME_COMM_STATUS.indication ( + uint16_t PANId, + uint8_t SrcAddrMode, + ieee154_address_t SrcAddr, + uint8_t DstAddrMode, + ieee154_address_t DstAddr, + ieee154_status_t status, + ieee154_security_t *security + ){} + + default event void MLME_ORPHAN.indication ( + uint64_t OrphanAddress, + ieee154_security_t *security + ){} +} diff --git a/tos/lib/mac/tkn154/DataP.nc b/tos/lib/mac/tkn154/DataP.nc new file mode 100644 index 00000000..4e951b0e --- /dev/null +++ b/tos/lib/mac/tkn154/DataP.nc @@ -0,0 +1,278 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ +#include "TKN154_MAC.h" + +module DataP +{ + provides + { + interface Init; + interface MCPS_DATA; + interface MCPS_PURGE; + } uses { + interface Get as IsSendingBeacons; + interface FrameRx as CoordCapRx; + interface FrameTx as DeviceCapTx; + interface FrameTx as CoordCapTx; + interface FrameTx as BroadcastTx; + interface FrameRx as DeviceCapRx; + interface Pool as TxFramePool; + interface FrameTx as DeviceCfpTx; + interface FrameTx as CoordCfpTx; + interface FrameTx as IndirectTx; + interface FrameRx as CoordCfpRx; + interface FrameRx as DeviceCfpRx; + interface FrameUtility; + interface Purge as PurgeDirect; + interface Purge as PurgeIndirect; + interface Purge as PurgeGtsDevice; + interface Purge as PurgeGtsCoord; + interface MLME_GET; + interface Leds; + interface Packet; + interface IEEE154Frame as Frame; + interface Get as LocalExtendedAddress; + } +} +implementation +{ + message_t* dataReceived(message_t* frame); + void finishTxTransaction(ieee154_txframe_t *txFrame, ieee154_status_t status); + + command error_t Init.init() + { + return SUCCESS; + } + + command ieee154_status_t MCPS_DATA.request ( + message_t *frame, + uint8_t payloadLen, + uint8_t msduHandle, + uint8_t txOptions + ) + { + uint8_t srcAddrMode = call Frame.getSrcAddrMode(frame); + uint8_t dstAddrMode = call Frame.getDstAddrMode(frame); + ieee154_address_t dstAddr; + ieee154_status_t txStatus; + ieee154_txframe_t *txFrame; + uint8_t sfType=0; + uint8_t *mhr; + + if (payloadLen > call Packet.maxPayloadLength()) + txStatus = IEEE154_INVALID_PARAMETER; + else if ((!srcAddrMode && !dstAddrMode) || + (srcAddrMode > ADDR_MODE_EXTENDED_ADDRESS || dstAddrMode > ADDR_MODE_EXTENDED_ADDRESS) || + (srcAddrMode == ADDR_MODE_RESERVED || dstAddrMode == ADDR_MODE_RESERVED)) + txStatus = IEEE154_INVALID_ADDRESS; + else if (!(txFrame = call TxFramePool.get())) + txStatus = IEEE154_TRANSACTION_OVERFLOW; + else { + // construct the DATA frame + txFrame->header = &((message_header_t*) frame->header)->ieee154; + txFrame->payload = (uint8_t*) frame->data; + txFrame->metadata = &((message_metadata_t*) frame->metadata)->ieee154; + txFrame->payloadLen = payloadLen; + mhr = txFrame->header->mhr; + txFrame->headerLen = call Frame.getHeaderLength(frame); + mhr[MHR_INDEX_FC1] &= ~(FC1_FRAMETYPE_MASK | FC1_FRAME_PENDING | FC1_ACK_REQUEST); + mhr[MHR_INDEX_FC1] |= FC1_FRAMETYPE_DATA; + if (txOptions & TX_OPTIONS_ACK) + mhr[MHR_INDEX_FC1] |= FC1_ACK_REQUEST; + mhr[MHR_INDEX_FC2] &= ~FC2_FRAME_VERSION_MASK; + if (payloadLen > IEEE154_aMaxMACSafePayloadSize) + mhr[MHR_INDEX_FC2] |= FC2_FRAME_VERSION_1; + txFrame->handle = msduHandle; + + // in case a node is both, coordinator and device (e.g. in a + // cluster-tree topology), it has to be decided whether the frame + // is to be sent in the incoming or outgoing superframe (sf); + // we do this by comparing the destination address to the + // coordinator address in the PIB, if they match the frame is + // sent in the incoming sf otherwise in the outgoing sf + call Frame.getDstAddr(frame, &dstAddr); + if (dstAddrMode == ADDR_MODE_SHORT_ADDRESS){ + if (dstAddr.shortAddress == call MLME_GET.macCoordShortAddress()) + sfType = INCOMING_SUPERFRAME; + else + sfType = OUTGOING_SUPERFRAME; + } else if (dstAddrMode == ADDR_MODE_EXTENDED_ADDRESS){ + if (dstAddr.extendedAddress == call MLME_GET.macCoordExtendedAddress()) + sfType = INCOMING_SUPERFRAME; + else + sfType = OUTGOING_SUPERFRAME; + } else if (dstAddrMode == ADDR_MODE_NOT_PRESENT) // to PAN Coord + sfType = INCOMING_SUPERFRAME; + + // GTS? + if (txOptions & TX_OPTIONS_GTS){ + if (sfType == INCOMING_SUPERFRAME) + txStatus = call DeviceCfpTx.transmit(txFrame); + else + txStatus = call CoordCfpTx.transmit(txFrame); + + // indirect transmission? + } else if ((txOptions & TX_OPTIONS_INDIRECT) && + call IsSendingBeacons.get() && + (dstAddrMode >= ADDR_MODE_SHORT_ADDRESS)){ + if (dstAddrMode == ADDR_MODE_SHORT_ADDRESS && dstAddr.shortAddress == 0xFFFF){ + mhr[MHR_INDEX_FC1] &= ~FC1_ACK_REQUEST; + txStatus = call BroadcastTx.transmit(txFrame); + } else + txStatus = call IndirectTx.transmit(txFrame); + + // transmission in the CAP + } else + if (sfType == INCOMING_SUPERFRAME) + txStatus = call DeviceCapTx.transmit(txFrame); + else + txStatus = call CoordCapTx.transmit(txFrame); + + if (txStatus != IEEE154_SUCCESS){ + call TxFramePool.put(txFrame); + } + } + return txStatus; + } + + command ieee154_status_t MCPS_PURGE.request ( + uint8_t msduHandle + ) + { + if (call PurgeDirect.purge(msduHandle) == IEEE154_SUCCESS || + call PurgeIndirect.purge(msduHandle) == IEEE154_SUCCESS || + call PurgeGtsDevice.purge(msduHandle) == IEEE154_SUCCESS || + call PurgeGtsCoord.purge(msduHandle) == IEEE154_SUCCESS) + return IEEE154_SUCCESS; + else + return IEEE154_INVALID_HANDLE; + } + + event void PurgeDirect.purgeDone(ieee154_txframe_t *data, ieee154_status_t status) + { + finishTxTransaction(data, status); + } + + event void PurgeIndirect.purgeDone(ieee154_txframe_t *data, ieee154_status_t status) + { + finishTxTransaction(data, status); + } + + event void PurgeGtsDevice.purgeDone(ieee154_txframe_t *data, ieee154_status_t status) + { + finishTxTransaction(data, status); + } + + event void PurgeGtsCoord.purgeDone(ieee154_txframe_t *data, ieee154_status_t status) + { + finishTxTransaction(data, status); + } + + event message_t* CoordCfpRx.received(message_t* frame) + { + return dataReceived(frame); + } + + event message_t* DeviceCfpRx.received(message_t* frame) + { + return dataReceived(frame); + } + + event message_t* CoordCapRx.received(message_t* frame) + { + return dataReceived(frame); + } + + event message_t* DeviceCapRx.received(message_t* frame) + { + return dataReceived(frame); + } + + message_t* dataReceived(message_t* frame) + { + return signal MCPS_DATA.indication( frame ); + } + + void finishTxTransaction(ieee154_txframe_t *txFrame, ieee154_status_t status) + { + uint8_t handle = txFrame->handle; + uint32_t txTime = txFrame->metadata->timestamp; + message_t *msg = (message_t*) ((uint8_t*) txFrame->header - offsetof(message_t, header)); + call TxFramePool.put(txFrame); + signal MCPS_DATA.confirm(msg, handle, status, txTime); + } + + event void BroadcastTx.transmitDone(ieee154_txframe_t *txFrame, ieee154_status_t status) + { + finishTxTransaction(txFrame, status); + } + + event void DeviceCapTx.transmitDone(ieee154_txframe_t *txFrame, ieee154_status_t status) + { + finishTxTransaction(txFrame, status); + } + + event void CoordCapTx.transmitDone(ieee154_txframe_t *txFrame, ieee154_status_t status) + { + finishTxTransaction(txFrame, status); + } + + event void DeviceCfpTx.transmitDone(ieee154_txframe_t *txFrame, ieee154_status_t status) + { + finishTxTransaction(txFrame, status); + } + + event void CoordCfpTx.transmitDone(ieee154_txframe_t *txFrame, ieee154_status_t status) + { + finishTxTransaction(txFrame, status); + } + + + event void IndirectTx.transmitDone(ieee154_txframe_t *txFrame, ieee154_status_t status) + { + finishTxTransaction(txFrame, status); + } + + default event void MCPS_DATA.confirm( + message_t *msg, + uint8_t msduHandle, + ieee154_status_t status, + uint32_t Timestamp + ){} + + default event message_t* MCPS_DATA.indication ( message_t* frame ){ return frame; } + default command ieee154_status_t DeviceCfpTx.transmit(ieee154_txframe_t *data){return IEEE154_INVALID_GTS;} + default command ieee154_status_t CoordCfpTx.transmit(ieee154_txframe_t *data){return IEEE154_INVALID_GTS;} +} diff --git a/tos/lib/mac/tkn154/FrameDispatchImplP.nc b/tos/lib/mac/tkn154/FrameDispatchImplP.nc new file mode 100644 index 00000000..c9527132 --- /dev/null +++ b/tos/lib/mac/tkn154/FrameDispatchImplP.nc @@ -0,0 +1,213 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ +#include "TKN154_MAC.h" +#include "TKN154_DEBUG.h" +module FrameDispatchImplP +{ + provides + { + interface RadioRx as MacRx[uint8_t client]; + interface RadioTx as MacTx[uint8_t client]; + interface RadioOff as MacRadioOff[uint8_t client]; + } uses { + interface ArbiterInfo; + interface RadioRx as PhyRx; + interface RadioTx as PhyTx; + interface RadioOff as PhyRadioOff; + interface Get as RadioPromiscuousMode; + interface Leds; + interface Ieee802154Debug as Debug; + } +} +implementation +{ + +/* ----------------------- RadioRx ----------------------- */ + + async command error_t MacRx.prepare[uint8_t client]() + { + if (client == call ArbiterInfo.userId()) + return call PhyRx.prepare(); + else { + call Leds.led0On(); + return FAIL; + } + } + + async event void PhyRx.prepareDone() + { + signal MacRx.prepareDone[call ArbiterInfo.userId()](); + } + + async command bool MacRx.isPrepared[uint8_t client]() + { + if (client == call ArbiterInfo.userId()) + return call PhyRx.isPrepared(); + else { + call Leds.led0On(); + return FAIL; + } + } + + async command error_t MacRx.receive[uint8_t client](ieee154_reftime_t *t0, uint32_t dt) + { + if (client == call ArbiterInfo.userId()) + return call PhyRx.receive(t0, dt); + else { + call Leds.led0On(); + return IEEE154_TRANSACTION_OVERFLOW; + } + } + + event message_t* PhyRx.received(message_t *msg, ieee154_reftime_t *timestamp) + { + uint8_t *mhr = MHR(msg); + if (((mhr[1] & FC2_FRAME_VERSION_MASK) > FC2_FRAME_VERSION_1) + && (!call RadioPromiscuousMode.get())) + return msg; +#ifndef IEEE154_SECURITY_ENABLED + if ((mhr[0] & FC1_SECURITY_ENABLED) + && (!call RadioPromiscuousMode.get())) + return msg; +#endif + return signal MacRx.received[call ArbiterInfo.userId()](msg, timestamp); + } + + async command bool MacRx.isReceiving[uint8_t client]() + { + if (client == call ArbiterInfo.userId()) + return call PhyRx.isReceiving(); + else { + call Leds.led0On(); + return FAIL; + } + } + +/* ----------------------- RadioTx ----------------------- */ + + async command error_t MacTx.load[uint8_t client](ieee154_txframe_t *frame) + { + if (client == call ArbiterInfo.userId()) + return call PhyTx.load(frame); + else { + call Leds.led0On(); + return IEEE154_TRANSACTION_OVERFLOW; + } + } + + async event void PhyTx.loadDone() + { + signal MacTx.loadDone[call ArbiterInfo.userId()](); + } + + async command ieee154_txframe_t* MacTx.getLoadedFrame[uint8_t client]() + { + if (client == call ArbiterInfo.userId()) + return call PhyTx.getLoadedFrame(); + else { + call Leds.led0On(); + return NULL; + } + } + + + async command error_t MacTx.transmit[uint8_t client](ieee154_reftime_t *referenceTime, + uint32_t timeOffset, uint8_t numCCA, bool ackRequest) + { + if (client == call ArbiterInfo.userId()) + return call PhyTx.transmit(referenceTime, timeOffset, numCCA, ackRequest); + else { + call Leds.led0On(); + return IEEE154_TRANSACTION_OVERFLOW; + } + } + + async event void PhyTx.transmitDone(ieee154_txframe_t *frame, + ieee154_reftime_t *referenceTime, bool ackPendingFlag, error_t error) + { + signal MacTx.transmitDone[call ArbiterInfo.userId()](frame, referenceTime, ackPendingFlag, error); + } + +/* ----------------------- RadioOff ----------------------- */ + + async command error_t MacRadioOff.off[uint8_t client]() + { + if (client == call ArbiterInfo.userId()) + return call PhyRadioOff.off(); + else { + call Leds.led0On(); + return EBUSY; + } + } + + async event void PhyRadioOff.offDone() + { + signal MacRadioOff.offDone[call ArbiterInfo.userId()](); + } + + + async command bool MacRadioOff.isOff[uint8_t client]() + { + if (client == call ArbiterInfo.userId()) + return call PhyRadioOff.isOff(); + else + return EBUSY; + } + +/* ----------------------- Defaults ----------------------- */ + + default async event void MacTx.loadDone[uint8_t client]() + { + call Debug.log(LEVEL_CRITICAL, RadioRxTxP_DEFAULT_PREPARE_TX_DONE, 0, 0, 0); + } + default async event void MacTx.transmitDone[uint8_t client](ieee154_txframe_t *frame, + ieee154_reftime_t *referenceTime, bool ackPendingFlag, error_t error) + { + call Debug.log(LEVEL_CRITICAL, RadioRxTxP_DEFAULT_TX_DONE, 0, 0, 0); + } + default async event void MacRx.prepareDone[uint8_t client]() + { + call Debug.log(LEVEL_CRITICAL, RadioRxTxP_DEFAULT_PREPARE_RX_DONE, 0, 0, 0); + } + default event message_t* MacRx.received[uint8_t client](message_t *frame, ieee154_reftime_t *timestamp) + { + call Debug.log(LEVEL_INFO, RadioRxTxP_DEFAULT_RECEIVED, client, call ArbiterInfo.userId(), 0xff); + return frame; + } + default async event void MacRadioOff.offDone[uint8_t client]() + { + call Debug.log(LEVEL_CRITICAL, RadioRxTxP_DEFAULT_OFFDONE, 0, 0, 0); + } +} diff --git a/tos/lib/mac/tkn154/FrameDispatchP.nc b/tos/lib/mac/tkn154/FrameDispatchP.nc new file mode 100644 index 00000000..7f69f9e8 --- /dev/null +++ b/tos/lib/mac/tkn154/FrameDispatchP.nc @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ +#include "TKN154_MAC.h" +configuration FrameDispatchP +{ + provides + { + interface RadioRx as RadioRx[uint8_t client]; + interface RadioTx as RadioTx[uint8_t client]; + interface RadioOff as RadioOff[uint8_t client]; + interface Resource as Token[uint8_t client]; + interface ResourceRequested as TokenRequested[uint8_t client]; + interface ResourceTransferControl as TokenTransferControl; + interface GetNow as IsResourceRequested; + interface Leds as LedsRadioClient; + } uses { + interface RadioRx as PhyRx; + interface RadioTx as PhyTx; + interface RadioOff as PhyRadioOff; + interface Get as RadioPromiscuousMode; + interface Leds; + interface Ieee802154Debug as Debug; + } +} +implementation +{ + components FrameDispatchImplP; + RadioRx = FrameDispatchImplP.MacRx; + RadioTx = FrameDispatchImplP.MacTx; + RadioOff = FrameDispatchImplP.MacRadioOff; + PhyRx = FrameDispatchImplP.PhyRx; + PhyTx = FrameDispatchImplP.PhyTx; + PhyRadioOff = FrameDispatchImplP.PhyRadioOff; + RadioPromiscuousMode = FrameDispatchImplP; + Leds = FrameDispatchImplP; + Debug = FrameDispatchImplP; + LedsRadioClient = Leds; + + components new SimpleRoundRobinTransferArbiterC(IEEE802154_RADIO_RESOURCE) as Arbiter; + Token = Arbiter; + TokenRequested = Arbiter; + TokenTransferControl = Arbiter; + IsResourceRequested = Arbiter; + FrameDispatchImplP.ArbiterInfo -> Arbiter; +} diff --git a/tos/lib/mac/tkn154/IndirectTxP.nc b/tos/lib/mac/tkn154/IndirectTxP.nc new file mode 100644 index 00000000..5cb6dd27 --- /dev/null +++ b/tos/lib/mac/tkn154/IndirectTxP.nc @@ -0,0 +1,300 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +module IndirectTxP +{ + provides + { + interface Init as Reset; + interface FrameTx[uint8_t client]; + interface WriteBeaconField as PendingAddrWrite; + interface Notify as PendingAddrSpecUpdated; + interface Purge; + } + uses + { + interface FrameTx as CoordCapTx; + interface FrameRx as DataRequestRx; + interface MLME_GET; + interface FrameUtility; + interface Timer as IndirectTxTimeout; + interface TimeCalc; + interface Leds; + interface Ieee802154Debug as Debug; + } +} +implementation +{ + enum { + SEND_THIS_FRAME = 0x80, + NUM_MAX_PENDING = 7, + }; + + ieee154_txframe_t *m_txFrameTable[NUM_MAX_PENDING]; + ieee154_txframe_t *m_pendingTxFrame; + uint8_t m_client; + uint8_t m_numTableEntries; + uint8_t m_numShortPending; + uint8_t m_numExtPending; + task void tryCoordCapTxTask(); + void tryCoordCapTx(); + + command error_t Reset.init() + { + uint8_t i; + // CAP/Queue component is always reset first, i.e. there + // should be no outstanding frames + call IndirectTxTimeout.stop(); + for (i=0; iclient](m_txFrameTable[i], IEEE154_TRANSACTION_OVERFLOW); + for (i=0; i maxlen) + return 0; + pendingAddrField[0] = 0; + adrPtr = (nxle_uint16_t *) &pendingAddrField[1]; + for (i=0; iheader->mhr[MHR_INDEX_FC2] & FC2_DEST_MODE_MASK) == FC2_DEST_MODE_SHORT){ + *adrPtr++ = *((nxle_uint16_t*) &txFrame->header->mhr[MHR_INDEX_ADDRESS + sizeof(ieee154_macPANId_t)]); + } else if ((txFrame->header->mhr[MHR_INDEX_FC2] & FC2_DEST_MODE_MASK) == FC2_DEST_MODE_EXTENDED) + longAdrPtr[k++] = &(txFrame->header->mhr[MHR_INDEX_ADDRESS + sizeof(ieee154_macPANId_t)]); + } + for (i=0; i= NUM_MAX_PENDING){ + call Debug.log(LEVEL_IMPORTANT, IndirectTxP_OVERFLOW, 0,0,0); + return IEEE154_TRANSACTION_OVERFLOW; + } + txFrame->client = client; + txFrame->metadata->timestamp = call IndirectTxTimeout.getNow(); + for (i=0; iheader->mhr[MHR_INDEX_FC2] & FC2_DEST_MODE_MASK) == FC2_DEST_MODE_SHORT) + m_numShortPending++; + else if ((txFrame->header->mhr[MHR_INDEX_FC2] & FC2_DEST_MODE_MASK) == FC2_DEST_MODE_EXTENDED) + m_numExtPending++; + if (!call IndirectTxTimeout.isRunning()) + call IndirectTxTimeout.startOneShot(getPersistenceTime()); + call Debug.log(LEVEL_INFO, IndirectTxP_NOTIFIED, 0,0,0); + signal PendingAddrSpecUpdated.notify(TRUE); + return IEEE154_SUCCESS; + } + + event message_t* DataRequestRx.received(message_t* frame) + { + uint8_t i, j, srcAddressMode, dstAddressMode, *src; + uint8_t *mhr = MHR(frame); + uint8_t destMode = (mhr[1] & FC2_DEST_MODE_MASK); + + // received a data request frame from a device + // have we got some pending data for it ? + if (!m_numTableEntries) + return frame; + srcAddressMode = (mhr[1] & FC2_SRC_MODE_MASK); + if (!(srcAddressMode & FC2_SRC_MODE_SHORT)) + return frame; // no source address + src = mhr + MHR_INDEX_ADDRESS; + if (destMode == FC2_DEST_MODE_SHORT) + src += 4; + else if (destMode == FC2_DEST_MODE_EXTENDED) + src += 10; + if (!((mhr[0] & FC1_PAN_ID_COMPRESSION) && (mhr[1] & FC2_DEST_MODE_SHORT))) + src += 2; + for (i=0; iheader->mhr[1] & FC2_DEST_MODE_MASK); + if ((dstAddressMode << 4) != srcAddressMode) + continue; + else { + // we know: dstAddressMode IN [2,3] + uint8_t *dst = &(m_txFrameTable[i]->header->mhr[MHR_INDEX_ADDRESS]) + 2; + uint8_t len = ((srcAddressMode == FC2_SRC_MODE_SHORT) ? 2 : 8); + for (j=0; jclient |= SEND_THIS_FRAME; + post tryCoordCapTxTask(); + } else { + // TODO: send an empty data frame to the device + } + return frame; + } + + void tryCoordCapTx() + { + // iterate over the queued frames and transmit them in the CAP + // (if they are marked for transmission) + uint8_t i; + if (!m_pendingTxFrame && m_numTableEntries){ + for (i=0; iclient & SEND_THIS_FRAME)){ + // TODO: set frame pending bit, if there's more data for this destination + m_pendingTxFrame = m_txFrameTable[i]; + m_client = m_txFrameTable[i]->client; + if (call CoordCapTx.transmit(m_txFrameTable[i]) == IEEE154_SUCCESS){ + call Debug.log(LEVEL_INFO, IndirectTxP_SEND_NOW, 0,0,0); + } else { + m_pendingTxFrame = 0; + post tryCoordCapTxTask(); + } + return; // done - wait for txDone + } + } + } + + task void tryCoordCapTxTask() + { + tryCoordCapTx(); + } + + event void IndirectTxTimeout.fired() + { + // a transaction has expired + uint32_t now = call IndirectTxTimeout.getNow(), dt=0; + uint32_t persistenceTime = getPersistenceTime(); + uint8_t i; + + for (i=0; imetadata->timestamp, persistenceTime)){ + ieee154_txframe_t *txFrame = m_txFrameTable[i]; + txFrame->client &= ~SEND_THIS_FRAME; + m_txFrameTable[i] = NULL; + m_numTableEntries -= 1; + if ((txFrame->header->mhr[MHR_INDEX_FC2] & FC2_DEST_MODE_MASK) == FC2_DEST_MODE_SHORT) + m_numShortPending--; + else if ((txFrame->header->mhr[MHR_INDEX_FC2] & FC2_DEST_MODE_MASK) == FC2_DEST_MODE_EXTENDED) + m_numExtPending--; + signal FrameTx.transmitDone[txFrame->client](txFrame, IEEE154_TRANSACTION_EXPIRED); + signal PendingAddrSpecUpdated.notify(TRUE); + } else if (call TimeCalc.timeElapsed(m_txFrameTable[i]->metadata->timestamp, now) > dt){ + dt = call TimeCalc.timeElapsed(m_txFrameTable[i]->metadata->timestamp, now); + } + } + if (dt != 0){ + if (dt > persistenceTime) + dt = persistenceTime; + call IndirectTxTimeout.startOneShot(persistenceTime - dt); + } + } + + event void CoordCapTx.transmitDone(ieee154_txframe_t *txFrame, ieee154_status_t status) + { + uint8_t i; + for (i=0; iclient = m_client; + txFrame->client &= ~SEND_THIS_FRAME; + m_numTableEntries -= 1; + if ((txFrame->header->mhr[MHR_INDEX_FC2] & FC2_DEST_MODE_MASK) == FC2_DEST_MODE_SHORT) + m_numShortPending--; + else if ((txFrame->header->mhr[MHR_INDEX_FC2] & FC2_DEST_MODE_MASK) == FC2_DEST_MODE_EXTENDED) + m_numExtPending--; + signal FrameTx.transmitDone[txFrame->client](txFrame, status); + post tryCoordCapTxTask(); + call Debug.log(LEVEL_INFO, IndirectTxP_SEND_DONE, status,m_numTableEntries,0); + } + + command error_t PendingAddrSpecUpdated.enable(){return FAIL;} + command error_t PendingAddrSpecUpdated.disable(){return FAIL;} + default event void FrameTx.transmitDone[uint8_t client](ieee154_txframe_t *txFrame, ieee154_status_t status){} +} diff --git a/tos/lib/mac/tkn154/PibP.nc b/tos/lib/mac/tkn154/PibP.nc new file mode 100644 index 00000000..d3d3b3b9 --- /dev/null +++ b/tos/lib/mac/tkn154/PibP.nc @@ -0,0 +1,1064 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +/* This component maintains the PIB (PAN Information Base) attributes and + * provides interfaces for accessing fields in a MAC frame. */ + +#include "TKN154.h" +#include "TKN154_PIB.h" +#include "TKN154_PHY.h" + +module PibP { + provides + { + interface Init as LocalInit; + interface MLME_RESET; + interface MLME_GET; + interface MLME_SET; + interface Set as SetMacSuperframeOrder; + interface Set as SetMacBeaconTxTime; + interface Set as SetMacPanCoordinator; + interface Get as IsMacPanCoordinator; + interface Get as IsBeaconEnabledPAN; + interface FrameUtility; + interface IEEE154Frame as Frame; + interface IEEE154BeaconFrame as BeaconFrame; + interface Get as GetLocalExtendedAddress; + interface Notify as PIBUpdate[uint8_t PIBAttributeID]; + interface Packet; + interface TimeCalc; + } + uses + { + interface Get as PromiscuousModeGet; + interface Init as CapReset; + interface Init as CapQueueReset; + interface Init as MacReset; + interface SplitControl as RadioControl; + interface Random; + interface Resource as Token; + interface RadioOff; + interface LocalTime; + } +} +implementation +{ + ieee154_PIB_t m_pib; + uint8_t m_numResetClientPending; + bool m_setDefaultPIB; + uint8_t m_panType; + uint8_t m_resetSpin; + +#ifdef IEEE154_EXTENDED_ADDRESS + const uint64_t m_aExtendedAddressLE = IEEE154_EXTENDED_ADDRESS; +#else + norace uint64_t m_aExtendedAddressLE; +#endif + task void radioControlStopTask(); + void updateMacMaxFrameTotalWaitTime(); + void resetAttributesToDefault(); + bool isLocalExtendedAddress(uint8_t *addrLE); + bool isCoordExtendedAddress(uint8_t *addrLE); + uint8_t getPendAddrSpecOffset(uint8_t *macPayloadField); + task void resetSpinTask(); + + command error_t LocalInit.init() + { +#ifndef IEEE154_EXTENDED_ADDRESS + uint32_t *p = (uint32_t*) &m_aExtendedAddressLE; + *p++ = call Random.rand32(); + *p = call Random.rand32(); +#endif + resetAttributesToDefault(); + return SUCCESS; + } + + void resetAttributesToDefault() { + m_pib.phyCurrentChannel = IEEE154_DEFAULT_CURRENTCHANNEL; + m_pib.phyTransmitPower = (IEEE154_TXPOWER_TOLERANCE | (IEEE154_DEFAULT_TRANSMITPOWER_dBm & 0x3F)); + m_pib.phyCCAMode = IEEE154_DEFAULT_CCAMODE; + m_pib.phyCurrentPage = IEEE154_DEFAULT_CURRENTPAGE; + + m_pib.macAssociatedPANCoord = IEEE154_DEFAULT_ASSOCIATEDPANCOORD; + m_pib.macAssociationPermit = IEEE154_DEFAULT_ASSOCIATIONPERMIT; + m_pib.macAutoRequest = IEEE154_DEFAULT_AUTOREQUEST; + m_pib.macBattLifeExt = IEEE154_DEFAULT_BATTLIFEEXT; + m_pib.macBeaconPayloadLength = IEEE154_DEFAULT_BEACONPAYLOADLENGTH; + m_pib.macBeaconOrder = IEEE154_DEFAULT_BEACONORDER; + m_pib.macBeaconTxTime = IEEE154_DEFAULT_BEACONTXTIME; + m_pib.macBSN = 0xFF & (call Random.rand16()); + // macCoordExtendedAddress: default is undefined + m_pib.macCoordShortAddress = IEEE154_DEFAULT_COORDSHORTADDRESS; + m_pib.macDSN = 0xFF & (call Random.rand16()); + m_pib.macGTSPermit = IEEE154_DEFAULT_GTSPERMIT; + m_pib.macMaxBE = IEEE154_DEFAULT_MAXBE; + m_pib.macMaxCSMABackoffs = IEEE154_DEFAULT_MAXCSMABACKOFFS; + m_pib.macMaxFrameRetries = IEEE154_DEFAULT_MAXFRAMERETRIES; + m_pib.macMinBE = IEEE154_DEFAULT_MINBE; + m_pib.macPANId = IEEE154_DEFAULT_PANID; + m_pib.macPromiscuousMode = IEEE154_DEFAULT_PROMISCUOUSMODE; + m_pib.macResponseWaitTime = IEEE154_DEFAULT_RESPONSEWAITTIME; + m_pib.macRxOnWhenIdle = IEEE154_DEFAULT_RXONWHENIDLE; + m_pib.macSecurityEnabled = IEEE154_DEFAULT_SECURITYENABLED; + m_pib.macShortAddress = IEEE154_DEFAULT_SHORTADDRESS; + m_pib.macSuperframeOrder = IEEE154_DEFAULT_SUPERFRAMEORDER; + m_pib.macTransactionPersistenceTime = IEEE154_DEFAULT_TRANSACTIONPERSISTENCETIME; + updateMacMaxFrameTotalWaitTime(); + } + + void updateMacMaxFrameTotalWaitTime() + { + // using equation 14 on page 160 + ieee154_macMinBE_t macMinBE = m_pib.macMinBE; + ieee154_macMaxBE_t macMaxBE = m_pib.macMaxBE; + ieee154_macMaxCSMABackoffs_t macMaxCSMABackoffs = m_pib.macMaxCSMABackoffs; + uint8_t m = macMaxBE - macMinBE, k; + uint32_t waitTime = 0; + + if (macMaxCSMABackoffs < m) + m = macMaxCSMABackoffs; + waitTime = (((uint16_t) 1 << macMaxBE) - 1) * (macMaxCSMABackoffs - m); + if (m) { + k = 0; + while (k != m){ + waitTime += ((uint16_t) 1 << (macMaxBE+k)); + k += 1; + } + } + waitTime *= IEEE154_aUnitBackoffPeriod; + waitTime += IEEE154_SHR_DURATION; + m_pib.macMaxFrameTotalWaitTime = waitTime; + } + + command ieee154_status_t MLME_RESET.request(bool SetDefaultPIB, uint8_t PANType) + { + // resetting the complete stack is not so easy... + // first we acquire the Token (get exclusive radio access), then we switch off + // the radio and reset all MAC components, starting from the ones that might + // still have any frames queued / allocated to get them flushed out. While we + // own the Token all other components are "inactive" (and there are no pending + // Alarms!), but there can still be pending Timers/tasks -> we stop all Timers + // through MacReset.init() and then spin a few tasks in between to get + // everything "flushed out" + if (PANType != BEACON_ENABLED_PAN && PANType != NONBEACON_ENABLED_PAN) + return IEEE154_INVALID_PARAMETER; + if (call PromiscuousModeGet.get()) + return IEEE154_TRANSACTION_OVERFLOW; // must first cancel promiscuous mode! + + // nonbeacon-enabled mode is not yet implemented! + if (PANType != BEACON_ENABLED_PAN) + return IEEE154_INVALID_PARAMETER; + + m_setDefaultPIB = SetDefaultPIB; + m_panType = PANType; // TODO: set this later? + if (!call Token.isOwner()) + call Token.request(); + return IEEE154_SUCCESS; + } + + event void Token.granted() + { + error_t error = call RadioOff.off(); + if (error != SUCCESS) // either it is already off or driver has not been started + signal RadioOff.offDone(); + } + + async event void RadioOff.offDone() + { + post radioControlStopTask(); + } + + task void radioControlStopTask() + { + if (call RadioControl.stop() == EALREADY) + signal RadioControl.stopDone(SUCCESS); + } + + event void RadioControl.stopDone(error_t error) + { + call CapReset.init(); // resets the CAP component(s) + call CapQueueReset.init(); // resets the CAP queue component(s) + call MacReset.init(); // resets the remaining components + m_resetSpin = 5; + post resetSpinTask(); + } + + task void resetSpinTask() + { + if (m_resetSpin == 2){ + // just to be safe... + call CapReset.init(); + call CapQueueReset.init(); + call MacReset.init(); + } + if (m_resetSpin--){ + post resetSpinTask(); + return; + } + if (call RadioControl.start() == EALREADY) + signal RadioControl.startDone(SUCCESS); + } + + event void RadioControl.startDone(error_t error) + { + if (m_setDefaultPIB) + resetAttributesToDefault(); + else { + // restore previous PHY attributes + signal PIBUpdate.notify[IEEE154_phyCurrentChannel](&m_pib.phyCurrentChannel); + signal PIBUpdate.notify[IEEE154_phyTransmitPower](&m_pib.phyTransmitPower); + signal PIBUpdate.notify[IEEE154_phyCCAMode](&m_pib.phyCCAMode); + signal PIBUpdate.notify[IEEE154_phyCurrentPage](&m_pib.phyCurrentPage); + signal PIBUpdate.notify[IEEE154_macPANId](&m_pib.macPANId); + signal PIBUpdate.notify[IEEE154_macShortAddress](&m_pib.macShortAddress); + signal PIBUpdate.notify[IEEE154_macPanCoordinator](&m_pib.macPanCoordinator); + } + call Token.release(); + signal MLME_RESET.confirm(IEEE154_SUCCESS); + } + +/* ----------------------- MLME-GET ----------------------- */ + + command ieee154_phyCurrentChannel_t MLME_GET.phyCurrentChannel(){ return m_pib.phyCurrentChannel;} + + command ieee154_phyChannelsSupported_t MLME_GET.phyChannelsSupported(){ return IEEE154_SUPPORTED_CHANNELS;} + + command ieee154_phyTransmitPower_t MLME_GET.phyTransmitPower(){ return m_pib.phyTransmitPower;} + + command ieee154_phyCCAMode_t MLME_GET.phyCCAMode(){ return m_pib.phyCCAMode;} + + command ieee154_phyCurrentPage_t MLME_GET.phyCurrentPage(){ return m_pib.phyCurrentPage;} + + command ieee154_phyMaxFrameDuration_t MLME_GET.phyMaxFrameDuration(){ return IEEE154_MAX_FRAME_DURATION;} + + command ieee154_phySHRDuration_t MLME_GET.phySHRDuration(){ return IEEE154_SHR_DURATION;} + + command ieee154_phySymbolsPerOctet_t MLME_GET.phySymbolsPerOctet(){ return IEEE154_SYMBOLS_PER_OCTET;} + + command ieee154_macAckWaitDuration_t MLME_GET.macAckWaitDuration(){ return IEEE154_ACK_WAIT_DURATION;} + + command ieee154_macAssociationPermit_t MLME_GET.macAssociationPermit(){ return m_pib.macAssociationPermit;} + + command ieee154_macAutoRequest_t MLME_GET.macAutoRequest(){ return m_pib.macAutoRequest;} + + command ieee154_macBattLifeExt_t MLME_GET.macBattLifeExt(){ return m_pib.macBattLifeExt;} + + command ieee154_macBattLifeExtPeriods_t MLME_GET.macBattLifeExtPeriods(){ return IEEE154_BATT_LIFE_EXT_PERIODS;} + + command ieee154_macBeaconOrder_t MLME_GET.macBeaconOrder(){ return m_pib.macBeaconOrder;} + + command ieee154_macBeaconTxTime_t MLME_GET.macBeaconTxTime(){ return m_pib.macBeaconTxTime;} + + command ieee154_macBSN_t MLME_GET.macBSN(){ return m_pib.macBSN;} + + command ieee154_macCoordExtendedAddress_t MLME_GET.macCoordExtendedAddress(){ return m_pib.macCoordExtendedAddress;} + + command ieee154_macCoordShortAddress_t MLME_GET.macCoordShortAddress(){ return m_pib.macCoordShortAddress;} + + command ieee154_macDSN_t MLME_GET.macDSN(){ return m_pib.macDSN;} + + command ieee154_macGTSPermit_t MLME_GET.macGTSPermit(){ return m_pib.macGTSPermit;} + + command ieee154_macMaxCSMABackoffs_t MLME_GET.macMaxCSMABackoffs(){ return m_pib.macMaxCSMABackoffs;} + + command ieee154_macMinBE_t MLME_GET.macMinBE(){ return m_pib.macMinBE;} + + command ieee154_macPANId_t MLME_GET.macPANId(){ return m_pib.macPANId;} + + command ieee154_macPromiscuousMode_t MLME_GET.macPromiscuousMode(){ return call PromiscuousModeGet.get();} + + command ieee154_macRxOnWhenIdle_t MLME_GET.macRxOnWhenIdle(){ return m_pib.macRxOnWhenIdle;} + + command ieee154_macShortAddress_t MLME_GET.macShortAddress(){ return m_pib.macShortAddress;} + + command ieee154_macSuperframeOrder_t MLME_GET.macSuperframeOrder(){ return m_pib.macSuperframeOrder;} + + command ieee154_macTransactionPersistenceTime_t MLME_GET.macTransactionPersistenceTime(){ return m_pib.macTransactionPersistenceTime;} + + command ieee154_macAssociatedPANCoord_t MLME_GET.macAssociatedPANCoord(){ return m_pib.macAssociatedPANCoord;} + + command ieee154_macMaxBE_t MLME_GET.macMaxBE(){ return m_pib.macMaxBE;} + + command ieee154_macMaxFrameTotalWaitTime_t MLME_GET.macMaxFrameTotalWaitTime(){ return m_pib.macMaxFrameTotalWaitTime;} + + command ieee154_macMaxFrameRetries_t MLME_GET.macMaxFrameRetries(){ return m_pib.macMaxFrameRetries;} + + command ieee154_macResponseWaitTime_t MLME_GET.macResponseWaitTime(){ return m_pib.macResponseWaitTime;} + + command ieee154_macSyncSymbolOffset_t MLME_GET.macSyncSymbolOffset(){ return IEEE154_SYNC_SYMBOL_OFFSET;} + + command ieee154_macTimestampSupported_t MLME_GET.macTimestampSupported(){ return IEEE154_TIMESTAMP_SUPPORTED;} + + command ieee154_macSecurityEnabled_t MLME_GET.macSecurityEnabled(){ return m_pib.macSecurityEnabled;} + + command ieee154_macMinLIFSPeriod_t MLME_GET.macMinLIFSPeriod(){ return IEEE154_MIN_LIFS_PERIOD;} + + command ieee154_macMinSIFSPeriod_t MLME_GET.macMinSIFSPeriod(){ return IEEE154_MIN_SIFS_PERIOD;} + +/* ----------------------- MLME-SET ----------------------- */ + + command ieee154_status_t MLME_SET.phyCurrentChannel(ieee154_phyCurrentChannel_t value){ + uint32_t i = 1; + uint8_t k = value; + while (i && k){ + i <<= 1; + k -= 1; + } + if (!(IEEE154_SUPPORTED_CHANNELS & i)) + return IEEE154_INVALID_PARAMETER; + m_pib.phyCurrentChannel = value; + signal PIBUpdate.notify[IEEE154_phyCurrentChannel](&m_pib.phyCurrentChannel); + return IEEE154_SUCCESS; + } + + command ieee154_status_t MLME_SET.phyTransmitPower(ieee154_phyTransmitPower_t value){ + m_pib.phyTransmitPower = (value & 0x3F); + signal PIBUpdate.notify[IEEE154_phyTransmitPower](&m_pib.phyTransmitPower); + return IEEE154_SUCCESS; + } + + command ieee154_status_t MLME_SET.phyCCAMode(ieee154_phyCCAMode_t value){ + if (value < 1 || value > 3) + return IEEE154_INVALID_PARAMETER; + m_pib.phyCCAMode = value; + signal PIBUpdate.notify[IEEE154_phyCCAMode](&m_pib.phyCCAMode); + return IEEE154_SUCCESS; + } + + command ieee154_status_t MLME_SET.phyCurrentPage(ieee154_phyCurrentPage_t value){ + if (value > 31) + return IEEE154_INVALID_PARAMETER; + m_pib.phyCurrentPage = value; + signal PIBUpdate.notify[IEEE154_phyCurrentPage](&m_pib.phyCurrentPage); + return IEEE154_SUCCESS; + } + + command ieee154_status_t MLME_SET.macAssociationPermit(ieee154_macAssociationPermit_t value){ + m_pib.macAssociationPermit = value; + signal PIBUpdate.notify[IEEE154_macAssociationPermit](&m_pib.macAssociationPermit); + return IEEE154_SUCCESS; + } + + command ieee154_status_t MLME_SET.macAutoRequest(ieee154_macAutoRequest_t value){ + m_pib.macAutoRequest = value; + signal PIBUpdate.notify[IEEE154_macAutoRequest](&m_pib.macAutoRequest); + return IEEE154_SUCCESS; + } + + command ieee154_status_t MLME_SET.macBattLifeExt(ieee154_macBattLifeExt_t value){ + m_pib.macBattLifeExt = value; + signal PIBUpdate.notify[IEEE154_macBattLifeExt](&m_pib.macBattLifeExt); + return IEEE154_SUCCESS; + } + + command ieee154_status_t MLME_SET.macBattLifeExtPeriods(ieee154_macBattLifeExtPeriods_t value){ + if (value < 6 || value > 41) + return IEEE154_INVALID_PARAMETER; + m_pib.macBattLifeExtPeriods = value; + signal PIBUpdate.notify[IEEE154_macBattLifeExtPeriods](&m_pib.macBattLifeExtPeriods); + return IEEE154_SUCCESS; + } + + command ieee154_status_t MLME_SET.macBeaconOrder(ieee154_macBeaconOrder_t value){ + if (value > 15) + return IEEE154_INVALID_PARAMETER; + m_pib.macBeaconOrder = value; + signal PIBUpdate.notify[IEEE154_macBeaconOrder](&m_pib.macBeaconOrder); + return IEEE154_SUCCESS; + } + + command ieee154_status_t MLME_SET.macBSN(ieee154_macBSN_t value){ + m_pib.macBSN = value; + signal PIBUpdate.notify[IEEE154_macBSN](&m_pib.macBSN); + return IEEE154_SUCCESS; + } + + command ieee154_status_t MLME_SET.macCoordExtendedAddress(ieee154_macCoordExtendedAddress_t value){ + m_pib.macCoordExtendedAddress = value; + signal PIBUpdate.notify[IEEE154_macCoordExtendedAddress](&m_pib.macCoordExtendedAddress); + return IEEE154_SUCCESS; + } + + command ieee154_status_t MLME_SET.macCoordShortAddress(ieee154_macCoordShortAddress_t value){ + m_pib.macCoordShortAddress = value; + signal PIBUpdate.notify[IEEE154_macCoordShortAddress](&m_pib.macCoordShortAddress); + return IEEE154_SUCCESS; + } + + command ieee154_status_t MLME_SET.macDSN(ieee154_macDSN_t value){ + m_pib.macDSN = value; + signal PIBUpdate.notify[IEEE154_macDSN](&m_pib.macDSN); + return IEEE154_SUCCESS; + } + + command ieee154_status_t MLME_SET.macGTSPermit(ieee154_macGTSPermit_t value){ + m_pib.macGTSPermit = value; + signal PIBUpdate.notify[IEEE154_macGTSPermit](&m_pib.macGTSPermit); + return IEEE154_SUCCESS; + } + + command ieee154_status_t MLME_SET.macMaxCSMABackoffs(ieee154_macMaxCSMABackoffs_t value){ + if (value > 5) + return IEEE154_INVALID_PARAMETER; + m_pib.macMaxCSMABackoffs = value; + updateMacMaxFrameTotalWaitTime(); + signal PIBUpdate.notify[IEEE154_macMaxCSMABackoffs](&m_pib.macMaxCSMABackoffs); + return IEEE154_SUCCESS; + } + + command ieee154_status_t MLME_SET.macMinBE(ieee154_macMinBE_t value){ + if (value > m_pib.macMaxBE) + return IEEE154_INVALID_PARAMETER; + m_pib.macMinBE = value; + updateMacMaxFrameTotalWaitTime(); + signal PIBUpdate.notify[IEEE154_macMinBE](&m_pib.macMinBE); + return IEEE154_SUCCESS; + } + + command ieee154_status_t MLME_SET.macPANId(ieee154_macPANId_t value){ + m_pib.macPANId = value; + signal PIBUpdate.notify[IEEE154_macPANId](&m_pib.macPANId); + return IEEE154_SUCCESS; + } + + command ieee154_status_t MLME_SET.macRxOnWhenIdle(ieee154_macRxOnWhenIdle_t value){ + m_pib.macRxOnWhenIdle = value; + signal PIBUpdate.notify[IEEE154_macRxOnWhenIdle](&m_pib.macRxOnWhenIdle); + return IEEE154_SUCCESS; + } + + command ieee154_status_t MLME_SET.macShortAddress(ieee154_macShortAddress_t value){ + m_pib.macShortAddress = value; + signal PIBUpdate.notify[IEEE154_macShortAddress](&m_pib.macShortAddress); + return IEEE154_SUCCESS; + } + + command ieee154_status_t MLME_SET.macTransactionPersistenceTime(ieee154_macTransactionPersistenceTime_t value){ + m_pib.macTransactionPersistenceTime = value; + signal PIBUpdate.notify[IEEE154_macTransactionPersistenceTime](&m_pib.macTransactionPersistenceTime); + return IEEE154_SUCCESS; + } + + command ieee154_status_t MLME_SET.macAssociatedPANCoord(ieee154_macAssociatedPANCoord_t value){ + m_pib.macAssociatedPANCoord = value; + signal PIBUpdate.notify[IEEE154_macAssociatedPANCoord](&m_pib.macAssociatedPANCoord); + return IEEE154_SUCCESS; + } + + command ieee154_status_t MLME_SET.macMaxBE(ieee154_macMaxBE_t value){ + if (value < 3 || value > 8) + return IEEE154_INVALID_PARAMETER; + m_pib.macMaxBE = value; + updateMacMaxFrameTotalWaitTime(); + signal PIBUpdate.notify[IEEE154_macMaxBE](&m_pib.macMaxBE); + return IEEE154_SUCCESS; + } + + command ieee154_status_t MLME_SET.macMaxFrameTotalWaitTime(ieee154_macMaxFrameTotalWaitTime_t value){ + // equation 14 on page 160 defines how macMaxFrameTotalWaitTime is calculated; + // its value depends only on other PIB attributes and constants - why does the standard + // allow setting it by the next higher layer ?? + m_pib.macMaxFrameTotalWaitTime = value; + signal PIBUpdate.notify[IEEE154_macMaxFrameTotalWaitTime](&m_pib.macMaxFrameTotalWaitTime); + return IEEE154_SUCCESS; + } + + command ieee154_status_t MLME_SET.macMaxFrameRetries(ieee154_macMaxFrameRetries_t value){ + if (value > 7) + return IEEE154_INVALID_PARAMETER; + m_pib.macMaxFrameRetries = value; + signal PIBUpdate.notify[IEEE154_macMaxFrameRetries](&m_pib.macMaxFrameRetries); + return IEEE154_SUCCESS; + } + + command ieee154_status_t MLME_SET.macResponseWaitTime(ieee154_macResponseWaitTime_t value){ + if (value < 2 || value > 64) + return IEEE154_INVALID_PARAMETER; + m_pib.macResponseWaitTime = value; + signal PIBUpdate.notify[IEEE154_macResponseWaitTime](&m_pib.macResponseWaitTime); + return IEEE154_SUCCESS; + } + + command ieee154_status_t MLME_SET.macSecurityEnabled(ieee154_macSecurityEnabled_t value){ + return IEEE154_UNSUPPORTED_ATTRIBUTE; + } + + // Read-only attributes (writable only by MAC components) + command void SetMacSuperframeOrder.set( ieee154_macSuperframeOrder_t value ){ + m_pib.macSuperframeOrder = value; + signal PIBUpdate.notify[IEEE154_macSuperframeOrder](&m_pib.macSuperframeOrder); + } + + command void SetMacBeaconTxTime.set( ieee154_macBeaconTxTime_t value ){ + m_pib.macBeaconTxTime = value; + signal PIBUpdate.notify[IEEE154_macBeaconTxTime](&m_pib.macBeaconTxTime); + } + + command void SetMacPanCoordinator.set( ieee154_macPanCoordinator_t value ){ + m_pib.macPanCoordinator = value; + signal PIBUpdate.notify[IEEE154_macPanCoordinator](&m_pib.macPanCoordinator); + } + + command ieee154_macPanCoordinator_t IsMacPanCoordinator.get(){ + return m_pib.macPanCoordinator; + } + +/* ----------------------- TimeCalc ----------------------- */ + + async command uint32_t TimeCalc.timeElapsed(uint32_t t0, uint32_t t1) + { + // t0 occured before t1, what is the delta? + if (t0 <= t1) + return t1 - t0; + else + return ~(t0 - t1) + 1; + } + + async command bool TimeCalc.hasExpired(uint32_t t0, uint32_t dt) + { + // t0 is in the past, what about t0+dt? + uint32_t now = call LocalTime.get(), elapsed; + if (now >= t0) + elapsed = now - t0; + else + elapsed = ~(t0 - now) + 1; + return (elapsed >= dt); + } + +/* ----------------------- Frame Access ----------------------- */ + + command void Packet.clear(message_t* msg) + { + uint8_t i; + memset(msg->header, 0, sizeof(message_header_t)); + memset(msg->metadata, 0, sizeof(message_metadata_t)); + } + + command uint8_t Packet.payloadLength(message_t* msg) + { + return ((message_header_t*) msg->header)->ieee154.length; + } + + command void Packet.setPayloadLength(message_t* msg, uint8_t len) + { + ((message_header_t*) msg->header)->ieee154.length = len; + } + + command uint8_t Packet.maxPayloadLength() + { +#if TOSH_DATA_LENGTH < 118 +#warning Payload portion in message_t is smaller than required (TOSH_DATA_LENGTH < IEEE154_aMaxMACPayloadSize). This means that larger packets cannot be sent/received. +#endif + return TOSH_DATA_LENGTH; + } + + command void* Packet.getPayload(message_t* msg, uint8_t len) + { + return msg->data; + } + + async command uint8_t FrameUtility.writeHeader( + uint8_t* mhr, + uint8_t DstAddrMode, + uint16_t DstPANId, + ieee154_address_t* DstAddr, + uint8_t SrcAddrMode, + uint16_t SrcPANId, + const ieee154_address_t* SrcAddr, + bool PANIDCompression) + { + uint8_t offset = MHR_INDEX_ADDRESS; + if (DstAddrMode == ADDR_MODE_SHORT_ADDRESS || DstAddrMode == ADDR_MODE_EXTENDED_ADDRESS){ + *((nxle_uint16_t*) &mhr[offset]) = DstPANId; + offset += 2; + if (DstAddrMode == ADDR_MODE_SHORT_ADDRESS){ + *((nxle_uint16_t*) &mhr[offset]) = DstAddr->shortAddress; + offset += 2; + } else { + call FrameUtility.convertToLE(&mhr[offset], &DstAddr->extendedAddress); + offset += 8; + } + } + if (SrcAddrMode == ADDR_MODE_SHORT_ADDRESS || SrcAddrMode == ADDR_MODE_EXTENDED_ADDRESS){ + if (DstPANId != SrcPANId || !PANIDCompression){ + *((nxle_uint16_t*) &mhr[offset]) = SrcPANId; + offset += 2; + } + if (SrcAddrMode == ADDR_MODE_SHORT_ADDRESS){ + *((nxle_uint16_t*) &mhr[offset]) = SrcAddr->shortAddress; + offset += 2; + } else { + call FrameUtility.convertToLE(&mhr[offset], &SrcAddr->extendedAddress); + offset += 8; + } + } + return offset; + } + + command bool FrameUtility.isBeaconFromCoord(message_t *frame) + { + uint8_t offset = MHR_INDEX_ADDRESS; + uint8_t *mhr = MHR(frame); + + if ((mhr[MHR_INDEX_FC1] & FC1_FRAMETYPE_MASK) != FC1_FRAMETYPE_BEACON) + return FALSE; // not a beacon frame + if (!(mhr[MHR_INDEX_FC2] & FC2_SRC_MODE_MASK)) + return FALSE; // source address information missing + if (mhr[MHR_INDEX_FC2] & FC2_DEST_MODE_MASK) + return FALSE; // beacons don't include dest address + if ((*(nxle_uint16_t*) (&mhr[offset])) != m_pib.macPANId) + return FALSE; // wrong PAN ID + offset += 2; + if ((mhr[MHR_INDEX_FC2] & FC2_SRC_MODE_MASK) == FC2_SRC_MODE_SHORT){ + if ((*(nxle_uint16_t*) (&mhr[offset])) != m_pib.macCoordShortAddress) + return FALSE; + } else if ((mhr[MHR_INDEX_FC2] & FC2_SRC_MODE_MASK) == FC2_SRC_MODE_EXTENDED){ + if (!isCoordExtendedAddress(mhr + offset)) + return FALSE; + } + return TRUE; + } + + async command error_t FrameUtility.getMHRLength(uint8_t fcf1, uint8_t fcf2, uint8_t *len) + { + uint8_t idCompression; + uint8_t offset = MHR_INDEX_ADDRESS; + + if (fcf1 & FC1_SECURITY_ENABLED) + return FAIL; // not supported + idCompression = (fcf1 & FC1_PAN_ID_COMPRESSION); + if (fcf2 & 0x08){ // short or ext. address + offset += 4; // pan id + short address + if (fcf2 & 0x04) // ext. address + offset += 6; // diff to short address + } + if (fcf2 & 0x80){ // short or ext. address + offset += 2; + if (!idCompression) + offset += 2; + if (fcf2 & 0x40) // ext. address + offset += 6; // diff to short address + } + *len = offset; + return SUCCESS; + } + + + command error_t Frame.setAddressingFields(message_t* frame, + uint8_t srcAddrMode, + uint8_t dstAddrMode, + uint16_t dstPANId, + ieee154_address_t *dstAddr, + ieee154_security_t *security) + { + uint8_t *mhr = MHR(frame); + ieee154_address_t srcAddress; + ieee154_macPANId_t srcPANId = call MLME_GET.macPANId(); + + if (security && security->SecurityLevel) + return FAIL; // not implemented + mhr[MHR_INDEX_FC2] &= (FC2_DEST_MODE_MASK | FC2_SRC_MODE_MASK); + mhr[MHR_INDEX_FC2] |= dstAddrMode << FC2_DEST_MODE_OFFSET; + mhr[MHR_INDEX_FC2] |= srcAddrMode << FC2_SRC_MODE_OFFSET; + if (srcAddrMode == ADDR_MODE_SHORT_ADDRESS) + srcAddress.shortAddress = call MLME_GET.macShortAddress(); + else + srcAddress.extendedAddress = call GetLocalExtendedAddress.get(); + if (dstAddrMode >= ADDR_MODE_SHORT_ADDRESS && + srcAddrMode >= ADDR_MODE_SHORT_ADDRESS && + dstPANId == srcPANId) + mhr[MHR_INDEX_FC1] |= FC1_PAN_ID_COMPRESSION; + else + mhr[MHR_INDEX_FC1] &= ~FC1_PAN_ID_COMPRESSION; + call FrameUtility.writeHeader( + mhr, + dstAddrMode, + dstPANId, + dstAddr, + srcAddrMode, + srcPANId, + &srcAddress, + (mhr[MHR_INDEX_FC1] & FC1_PAN_ID_COMPRESSION) ? TRUE: FALSE); + return SUCCESS; + } + + command uint8_t Frame.getFrameType(message_t* frame) + { + uint8_t *mhr = MHR(frame); + return (mhr[MHR_INDEX_FC1] & FC1_FRAMETYPE_MASK); + } + + command void* Frame.getHeader(message_t* frame) + { + uint8_t *mhr = MHR(frame); + return (void*) &(mhr[MHR_INDEX_FC1]); + } + + command uint8_t Frame.getHeaderLength(message_t* frame) + { + uint8_t len; + uint8_t *mhr = MHR(frame); + call FrameUtility.getMHRLength(mhr[0], mhr[1], &len); + return len; + } + + command void* Frame.getPayload(message_t* frame) + { + uint8_t *payload = (uint8_t *) frame->data; + return payload; + } + + command uint8_t Frame.getPayloadLength(message_t* frame) + { + uint8_t len = ((ieee154_header_t*) frame->header)->length & FRAMECTL_LENGTH_MASK; + return len; + } + + command uint32_t Frame.getTimestamp(message_t* frame) + { + ieee154_metadata_t *metadata = (ieee154_metadata_t*) frame->metadata; + return metadata->timestamp; + } + + command bool Frame.isTimestampValid(message_t* frame) + { + ieee154_metadata_t *metadata = (ieee154_metadata_t*) frame->metadata; + if (metadata->timestamp == IEEE154_INVALID_TIMESTAMP) + return FALSE; + else + return TRUE; + } + + command uint8_t Frame.getDSN(message_t* frame) + { + uint8_t *mhr = MHR(frame); + return mhr[MHR_INDEX_SEQNO]; + } + + command uint8_t Frame.getLinkQuality(message_t* frame) + { + ieee154_metadata_t *metadata = (ieee154_metadata_t*) frame->metadata; + return metadata->linkQuality; + } + + command uint8_t Frame.getSrcAddrMode(message_t* frame) + { + uint8_t *mhr = MHR(frame); + return (mhr[MHR_INDEX_FC2] & FC2_SRC_MODE_MASK) >> FC2_SRC_MODE_OFFSET; + } + + command error_t Frame.getSrcAddr(message_t* frame, ieee154_address_t *address) + { + uint8_t *mhr = MHR(frame); + uint8_t offset = MHR_INDEX_ADDRESS; + uint8_t destMode = (mhr[MHR_INDEX_FC2] & FC2_DEST_MODE_MASK); + if (!(mhr[MHR_INDEX_FC2] & FC2_SRC_MODE_SHORT)) + return FAIL; + if (destMode == FC2_DEST_MODE_SHORT) + offset += 4; + else if (destMode == FC2_DEST_MODE_EXTENDED) + offset += 10; + if (!((mhr[MHR_INDEX_FC1] & FC1_PAN_ID_COMPRESSION) && (mhr[MHR_INDEX_FC2] & FC2_DEST_MODE_SHORT))) + offset += 2; + if ((mhr[MHR_INDEX_FC2] & FC2_SRC_MODE_MASK) == FC2_SRC_MODE_SHORT) + address->shortAddress = *((nxle_uint16_t*) (&(mhr[offset]))); + else + call FrameUtility.convertToNative(&address->extendedAddress, (&(mhr[offset]) )); + return SUCCESS; + } + + command error_t Frame.getSrcPANId(message_t* frame, uint16_t *PANID) + { + uint8_t *mhr = MHR(frame); + uint8_t offset = MHR_INDEX_ADDRESS; + uint8_t destMode = (mhr[1] & FC2_DEST_MODE_MASK); + if (!(mhr[MHR_INDEX_FC2] & FC2_SRC_MODE_SHORT)) + return FAIL; + if (destMode == FC2_DEST_MODE_SHORT) + offset += 4; + else if (destMode == FC2_DEST_MODE_EXTENDED) + offset += 10; + if ((mhr[MHR_INDEX_FC1] & FC1_PAN_ID_COMPRESSION) && (mhr[MHR_INDEX_FC2] & FC2_DEST_MODE_SHORT)) + *PANID = *((nxle_uint16_t*) (&(mhr[MHR_INDEX_ADDRESS]))); + else if ((mhr[MHR_INDEX_FC2] & FC2_SRC_MODE_MASK) == FC2_SRC_MODE_SHORT) + *PANID = *((nxle_uint16_t*) (&(mhr[offset]))); + else + *PANID = *((nxle_uint16_t*) (&(mhr[offset]))); + return SUCCESS; + } + + command uint8_t Frame.getDstAddrMode(message_t* frame) + { + uint8_t *mhr = MHR(frame); + return (mhr[MHR_INDEX_FC2] & FC2_DEST_MODE_MASK) >> FC2_DEST_MODE_OFFSET; + } + + command error_t Frame.getDstAddr(message_t* frame, ieee154_address_t *address) + { + uint8_t *mhr = MHR(frame); + if (!(mhr[MHR_INDEX_FC2] & FC2_DEST_MODE_SHORT)) + return FAIL; + if ((mhr[MHR_INDEX_FC2] & FC2_DEST_MODE_MASK) == FC2_DEST_MODE_SHORT) + address->shortAddress = *((nxle_uint16_t*) (&(mhr[MHR_INDEX_ADDRESS]) + 2)); + else + call FrameUtility.convertToNative(&address->extendedAddress, (&(mhr[MHR_INDEX_ADDRESS]) + 2)); + return SUCCESS; + } + + command error_t Frame.getDstPANId(message_t* frame, uint16_t *PANID) + { + uint8_t *mhr = MHR(frame); + if (!(mhr[MHR_INDEX_FC2] & FC2_DEST_MODE_SHORT)) + return FAIL; + *PANID = *((nxle_uint16_t*) (&(mhr[MHR_INDEX_ADDRESS]))); + return SUCCESS; + } + + command bool Frame.wasPromiscuousModeEnabled(message_t* frame) + { + return (((ieee154_header_t*) frame->header)->length & FRAMECTL_PROMISCUOUS) ? TRUE : FALSE; + } + + command bool Frame.hasStandardCompliantHeader(message_t* frame) + { + uint8_t *mhr = MHR(frame); + if ( ((mhr[0] & FC1_FRAMETYPE_MASK) > 0x03) || + ((mhr[MHR_INDEX_FC2] & FC2_DEST_MODE_MASK) == 0x04) || + ((mhr[MHR_INDEX_FC2] & FC2_SRC_MODE_MASK) == 0x40) || +#ifndef IEEE154_SECURITY_ENABLED + ((mhr[0] & FC1_SECURITY_ENABLED)) || +#endif + (mhr[MHR_INDEX_FC2] & FC2_FRAME_VERSION_2) + ) + return FALSE; + else + return TRUE; + } + +/* ----------------------- Beacon Frame Access ----------------------- */ + + uint8_t getPendAddrSpecOffset(uint8_t *macPayloadField) + { + uint8_t gtsDescriptorCount = macPayloadField[BEACON_INDEX_GTS_SPEC] & GTS_DESCRIPTOR_COUNT_MASK; + return BEACON_INDEX_GTS_SPEC + 1 + ((gtsDescriptorCount > 0) ? 1 + gtsDescriptorCount * 3: 0); + } + + command error_t BeaconFrame.getPendAddrSpec(message_t* frame, uint8_t* pendAddrSpec) + { + uint8_t *mhr = MHR(frame); + if (((mhr[MHR_INDEX_FC1] & FC1_FRAMETYPE_MASK) != FC1_FRAMETYPE_BEACON)) + return FAIL; + else { + uint8_t *payload = (uint8_t *) frame->data; + uint8_t pendAddrSpecOffset = getPendAddrSpecOffset(payload); + *pendAddrSpec = payload[pendAddrSpecOffset]; + return SUCCESS; + } + } + + command error_t BeaconFrame.getPendAddr(message_t* frame, uint8_t addrMode, + ieee154_address_t buffer[], uint8_t bufferSize) + { + uint8_t *mhr = MHR(frame); + uint8_t *payload = (uint8_t *) frame->data; + uint8_t pendAddrSpecOffset = getPendAddrSpecOffset(payload); + uint8_t pendAddrSpec = payload[pendAddrSpecOffset], i; + if (((mhr[MHR_INDEX_FC1] & FC1_FRAMETYPE_MASK) != FC1_FRAMETYPE_BEACON)) + return FAIL; + if (addrMode == ADDR_MODE_SHORT_ADDRESS){ + for (i=0; i<(pendAddrSpec & PENDING_ADDRESS_SHORT_MASK) && i> 4) && idata; + uint8_t pendAddrSpecOffset = getPendAddrSpecOffset(payload); + uint8_t pendAddrSpec = payload[pendAddrSpecOffset], i; + ieee154_macShortAddress_t shortAddress = call MLME_GET.macShortAddress(); + if (((mhr[MHR_INDEX_FC1] & FC1_FRAMETYPE_MASK) != FC1_FRAMETYPE_BEACON)) + return ADDR_MODE_NOT_PRESENT; + for (i=0; i<(pendAddrSpec & PENDING_ADDRESS_SHORT_MASK); i++) + if (*((nxle_uint16_t*) (payload + pendAddrSpecOffset + 1 + 2*i)) == shortAddress) + return ADDR_MODE_SHORT_ADDRESS; + for (i=0; i<((pendAddrSpec & PENDING_ADDRESS_EXT_MASK) >> 4); i++) + if (isLocalExtendedAddress(((payload + pendAddrSpecOffset + + 1 + (pendAddrSpec & PENDING_ADDRESS_SHORT_MASK)*2 + 8*i)))) + return ADDR_MODE_EXTENDED_ADDRESS; + return ADDR_MODE_NOT_PRESENT; + } + + command void* BeaconFrame.getBeaconPayload(message_t* frame) + { + uint8_t *mhr = MHR(frame); + uint8_t *payload = (uint8_t *) frame->data; + if ((mhr[MHR_INDEX_FC1] & FC1_FRAMETYPE_MASK) == FC1_FRAMETYPE_BEACON){ + uint8_t pendAddrSpecOffset = getPendAddrSpecOffset(payload); + uint8_t pendAddrSpec = payload[pendAddrSpecOffset]; + payload += (pendAddrSpecOffset + 1); + if (pendAddrSpec & PENDING_ADDRESS_SHORT_MASK) + payload += (pendAddrSpec & PENDING_ADDRESS_SHORT_MASK) * 2; + if (pendAddrSpec & PENDING_ADDRESS_EXT_MASK) + payload += ((pendAddrSpec & PENDING_ADDRESS_EXT_MASK) >> 4) * 8; + } + return payload; + } + + command uint8_t BeaconFrame.getBeaconPayloadLength(message_t* frame) + { + uint8_t *mhr = MHR(frame); + uint8_t len = ((ieee154_header_t*) frame->header)->length & FRAMECTL_LENGTH_MASK; + if ((mhr[MHR_INDEX_FC1] & FC1_FRAMETYPE_MASK) == FC1_FRAMETYPE_BEACON){ + uint8_t *payload = call Frame.getPayload(frame); + len = len - (payload - (uint8_t *) frame->data); + } + return len; + } + + command uint8_t BeaconFrame.getBSN(message_t* frame) + { + return call Frame.getDSN(frame); + } + + command error_t BeaconFrame.parsePANDescriptor( + message_t *frame, + uint8_t LogicalChannel, + uint8_t ChannelPage, + ieee154_PANDescriptor_t *PANDescriptor + ) + { + uint8_t *mhr = MHR(frame); + uint8_t offset; + ieee154_metadata_t *metadata = (ieee154_metadata_t*) frame->metadata; + + if ( (mhr[MHR_INDEX_FC1] & FC1_FRAMETYPE_MASK) != FC1_FRAMETYPE_BEACON || + (((mhr[MHR_INDEX_FC2] & FC2_SRC_MODE_MASK) != FC2_SRC_MODE_SHORT) && + ((mhr[MHR_INDEX_FC2] & FC2_SRC_MODE_MASK) != FC2_SRC_MODE_EXTENDED)) ) + return FAIL; + PANDescriptor->CoordAddrMode = (mhr[MHR_INDEX_FC2] & FC2_SRC_MODE_MASK) >> FC2_SRC_MODE_OFFSET; + offset = MHR_INDEX_ADDRESS; + PANDescriptor->CoordPANId = *((nxle_uint16_t*) &mhr[offset]); + offset += sizeof(ieee154_macPANId_t); + if ((mhr[MHR_INDEX_FC2] & FC2_SRC_MODE_MASK) == FC2_SRC_MODE_SHORT) + PANDescriptor->CoordAddress.shortAddress = *((nxle_uint16_t*) &mhr[offset]); + else + call FrameUtility.convertToNative(&PANDescriptor->CoordAddress.extendedAddress, &mhr[offset]); + PANDescriptor->LogicalChannel = LogicalChannel; + PANDescriptor->ChannelPage = ChannelPage; + ((uint8_t*) &PANDescriptor->SuperframeSpec)[0] = frame->data[BEACON_INDEX_SF_SPEC1]; // little endian + ((uint8_t*) &PANDescriptor->SuperframeSpec)[1] = frame->data[BEACON_INDEX_SF_SPEC2]; + PANDescriptor->GTSPermit = (frame->data[BEACON_INDEX_GTS_SPEC] & GTS_SPEC_PERMIT) ? 1 : 0; + PANDescriptor->LinkQuality = metadata->linkQuality; + PANDescriptor->TimeStamp = metadata->timestamp; +#ifndef IEEE154_SECURITY_ENABLED + PANDescriptor->SecurityFailure = IEEE154_SUCCESS; + PANDescriptor->SecurityLevel = 0; + PANDescriptor->KeyIdMode = 0; + PANDescriptor->KeySource = 0; + PANDescriptor->KeyIndex = 0; +#else +#error Implementation of BeaconFrame.parsePANDescriptor() needs adaptation ! +#endif + return SUCCESS; + } + +/* ----------------------- FrameUtility, etc. ----------------------- */ + + command uint64_t GetLocalExtendedAddress.get() + { + return m_aExtendedAddressLE; + } + + async command void FrameUtility.convertToLE(uint8_t *destLE, const uint64_t *src) + { + uint8_t i; + uint64_t srcCopy = *src; + for (i=0; i<8; i++){ + destLE[i] = srcCopy; + srcCopy >>= 8; + } + } + + async command void FrameUtility.convertToNative(uint64_t *dest, const uint8_t *srcLE) + { + // on msp430 nxle_uint64_t doesn't work, this is a workaround + uint32_t lower = *((nxle_uint32_t*) srcLE); + uint64_t upper = *((nxle_uint32_t*) (srcLE+4)); + *dest = (upper << 32) + lower; + + } + + async command void FrameUtility.copyLocalExtendedAddressLE(uint8_t *destLE) + { + call FrameUtility.convertToLE(destLE, &m_aExtendedAddressLE); + } + + command void FrameUtility.copyCoordExtendedAddressLE(uint8_t *destLE) + { + call FrameUtility.convertToLE(destLE, &m_pib.macCoordExtendedAddress); + } + + bool isLocalExtendedAddress(uint8_t *addrLE) + { + uint64_t dest; + call FrameUtility.convertToNative(&dest, addrLE); + return dest == m_aExtendedAddressLE; + } + + bool isCoordExtendedAddress(uint8_t *addrLE) + { + uint64_t dest; + call FrameUtility.convertToNative(&dest, addrLE); + return dest == m_pib.macCoordExtendedAddress; + } + + command bool IsBeaconEnabledPAN.get() + { + return (m_panType == BEACON_ENABLED_PAN); + } + + default event void PIBUpdate.notify[uint8_t PIBAttributeID](const void* PIBAttributeValue){} + command error_t PIBUpdate.enable[uint8_t PIBAttributeID](){return FAIL;} + command error_t PIBUpdate.disable[uint8_t PIBAttributeID](){return FAIL;} +} diff --git a/tos/lib/mac/tkn154/PollP.nc b/tos/lib/mac/tkn154/PollP.nc new file mode 100644 index 00000000..df20b2a8 --- /dev/null +++ b/tos/lib/mac/tkn154/PollP.nc @@ -0,0 +1,223 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + + +#include "TKN154_MAC.h" + +module PollP +{ + provides + { + interface Init; + interface MLME_POLL; + interface FrameRx as DataRx; + interface DataRequest as DataRequest[uint8_t client]; + } + uses + { + interface FrameTx as PollTx; + interface FrameExtracted as DataExtracted; + interface FrameUtility; + interface Pool as TxFramePool; + interface Pool as TxControlPool; + interface Ieee802154Debug as Debug; + interface MLME_GET; + interface Get as LocalExtendedAddress; + } +} +implementation +{ + enum { + HANDLE_MLME_POLL_REQUEST = 0xFF, + HANDLE_MLME_POLL_SUCCESS = 0xFE, + }; + int m_numPending; + uint8_t m_dataRequestCmdID = CMD_FRAME_DATA_REQUEST; + void buildDataRequestFrame( uint8_t destAddrMode, uint16_t destPANId, + uint8_t* DstAddr, uint8_t srcAddrMode, ieee154_txframe_t *txFrame); + + command error_t Init.init() + { + m_numPending = 0; + return SUCCESS; + } + + command ieee154_status_t MLME_POLL.request ( + uint8_t coordAddrMode, + uint16_t coordPANID, + ieee154_address_t coordAddress, + ieee154_security_t *security + ) + { + ieee154_txframe_t *txFrame; + ieee154_txcontrol_t *txControl; + uint8_t srcAddrMode = 2; + ieee154_status_t txStatus = IEEE154_SUCCESS; + uint8_t coordAddressLE[8]; // little endian is what we want + + if (security && security->SecurityLevel) + txStatus = IEEE154_UNSUPPORTED_SECURITY; + else if (coordAddrMode < 2 || coordAddrMode > 3 || coordPANID == 0xFFFF) + txStatus = IEEE154_INVALID_PARAMETER; + else if (!(txFrame = call TxFramePool.get())) + // none of the predefined return value really fits + txStatus = IEEE154_TRANSACTION_OVERFLOW; + else if (!(txControl = call TxControlPool.get())){ + call TxFramePool.put(txFrame); + txStatus = IEEE154_TRANSACTION_OVERFLOW; + } else { + txFrame->header = &txControl->header; + txFrame->metadata = &txControl->metadata; + if (coordAddrMode == ADDR_MODE_SHORT_ADDRESS) + *((nxle_uint16_t*) &coordAddressLE) = coordAddress.shortAddress; + else + call FrameUtility.convertToLE(coordAddressLE, &coordAddress.extendedAddress); + txFrame->handle = HANDLE_MLME_POLL_REQUEST; + if (call MLME_GET.macShortAddress() >= 0xFFFE) + srcAddrMode = 3; + buildDataRequestFrame(coordAddrMode, coordPANID, coordAddressLE, srcAddrMode, txFrame); + if ((txStatus = call PollTx.transmit(txFrame)) != IEEE154_SUCCESS){ + call TxFramePool.put(txFrame); + call TxControlPool.put(txControl); + call Debug.log(LEVEL_IMPORTANT, PollP_ALLOC_FAIL1, 0, 0, 0); + } else + m_numPending++; + } + return txStatus; + } + + command ieee154_status_t DataRequest.poll[uint8_t client](uint8_t CoordAddrMode, + uint16_t CoordPANId, uint8_t *CoordAddressLE, uint8_t srcAddrMode) + { + ieee154_txframe_t *txFrame; + ieee154_txcontrol_t *txControl; + ieee154_status_t status = IEEE154_TRANSACTION_OVERFLOW; + call Debug.log(LEVEL_INFO, PollP_INTERNAL_POLL, CoordAddrMode, client, m_numPending); + if (client == SYNC_CLIENT && m_numPending != 0){ + // no point in auto-requesting if user request is pending + signal DataRequest.pollDone[client](); + return IEEE154_SUCCESS; + } else if ((txFrame = call TxFramePool.get())){ + if (!(txControl = call TxControlPool.get())) + call TxFramePool.put(txFrame); + else { + txFrame->header = &txControl->header; + txFrame->metadata = &txControl->metadata; + txFrame->handle = client; + buildDataRequestFrame(CoordAddrMode, CoordPANId, + CoordAddressLE, srcAddrMode, txFrame); + if ((status = call PollTx.transmit(txFrame)) != IEEE154_SUCCESS){ + call TxControlPool.put(txControl); + call TxFramePool.put(txFrame); + call Debug.log(LEVEL_IMPORTANT, PollP_ALLOC_FAIL2, 0, 0, 0); + } else + m_numPending++; + } + } + if (status != IEEE154_SUCCESS) + signal DataRequest.pollDone[client](); + return status; + } + + void buildDataRequestFrame(uint8_t destAddrMode, uint16_t destPANId, + uint8_t* destAddrPtrLE, uint8_t srcAddrMode, ieee154_txframe_t *txFrame) + { + // destAddrPtrLE points to an address in little-endian format ! + ieee154_address_t srcAddress; + uint8_t *mhr; + uint16_t srcPANId; + ieee154_address_t DstAddr; + srcPANId = call MLME_GET.macPANId(); + + memcpy(&DstAddr, destAddrPtrLE, destAddrMode == 2 ? 2 : 8); + mhr = txFrame->header->mhr; + mhr[MHR_INDEX_FC1] = FC1_FRAMETYPE_CMD | FC1_ACK_REQUEST; + if (destAddrMode >= 2 && srcAddrMode >= 2 && destPANId == srcPANId) + mhr[MHR_INDEX_FC1] |= FC1_PAN_ID_COMPRESSION; + mhr[MHR_INDEX_FC2] = destAddrMode << FC2_DEST_MODE_OFFSET; + mhr[MHR_INDEX_FC2] |= srcAddrMode << FC2_SRC_MODE_OFFSET; + if (srcAddrMode == 2) + srcAddress.shortAddress = call MLME_GET.macShortAddress(); + else + srcAddress.extendedAddress = call LocalExtendedAddress.get(); + txFrame->headerLen = call FrameUtility.writeHeader( + txFrame->header->mhr, + destAddrMode, + destPANId, + &DstAddr, + srcAddrMode, + srcPANId, + &srcAddress, + (mhr[MHR_INDEX_FC1] & FC1_PAN_ID_COMPRESSION) ? TRUE: FALSE); + txFrame->payload = &m_dataRequestCmdID; + txFrame->payloadLen = 1; + } + + event message_t* DataExtracted.received(message_t* frame, ieee154_txframe_t *txFrame) + { + if (!txFrame){ + call Debug.log(LEVEL_CRITICAL, PollP_INTERNAL_ERROR, 0, 0, 0); + return frame; + } else + call Debug.log(LEVEL_INFO, PollP_SUCCESS, 0, 0, 0); + if (txFrame->handle == HANDLE_MLME_POLL_REQUEST) + signal MLME_POLL.confirm(IEEE154_SUCCESS); + else + signal DataRequest.pollDone[txFrame->handle](); + txFrame->handle = HANDLE_MLME_POLL_SUCCESS; // mark as processed + // TODO: check if pending bit is set (then initiate another POLL) + call Debug.log(LEVEL_IMPORTANT, PollP_RX, txFrame->handle, 0, 0); + return signal DataRx.received(frame); + } + + event void PollTx.transmitDone(ieee154_txframe_t *txFrame, ieee154_status_t status) + { + call Debug.log(LEVEL_IMPORTANT, PollP_TXDONE, status, txFrame->handle, 0); + m_numPending--; + if (txFrame->handle != HANDLE_MLME_POLL_SUCCESS){ + // didn't receive a DATA frame from the coordinator + if (status == IEEE154_SUCCESS) // TODO: can this happen if a frame other than DATA was extracted? + status = IEEE154_NO_DATA; + if (txFrame->handle == HANDLE_MLME_POLL_REQUEST) + signal MLME_POLL.confirm(status); + else + signal DataRequest.pollDone[txFrame->handle](); + } + call TxControlPool.put((ieee154_txcontrol_t*) ((uint8_t*) txFrame->header - offsetof(ieee154_txcontrol_t, header))); + call TxFramePool.put(txFrame); + } + default event void MLME_POLL.confirm(ieee154_status_t status){} + default event void DataRequest.pollDone[uint8_t client](){} +} diff --git a/tos/lib/mac/tkn154/README.txt b/tos/lib/mac/tkn154/README.txt new file mode 100644 index 00000000..50d370c3 --- /dev/null +++ b/tos/lib/mac/tkn154/README.txt @@ -0,0 +1,66 @@ +This directory contains "TKN15.4", a platform-independent IEEE 802.15.4-2006 +MAC implementation. The code is still under active development, but most of the +functionality described in the standard is implemented. The MAC itself is +platform-independent, but it requires (1) a suitable radio driver, (2) +Alarms/Timers with symbol precision and (3) some "platform glue" code (defining +guard times, etc.). Currently the only supported platform is TelosB (however: +without additional hardware support the timing is not standard compliant). + +Status 6/16/08 +-------------- + +missing functionality: + +- security (not planned) +- GTS (not planned) +- non-beacon-enabled mode +- PAN ID conflict resolution +- multiple indirect transmissions to the same destination +- documentation + +Implementation +-------------- + +MAC implementation: tinyos-2.x/tos/lib/mac/tkn154 +MAC interfaces: tinyos-2.x/tos/lib/mac/tkn154/interfaces +CC2420 driver: tinyos-2.x/tos/chips/cc2420_tkn154 +TelosB "platform glue" code: tinyos-2.x/tos/platforms/telosb/mac/tkn154 +Example applications: tinyos-2.x/apps/tests/tkn154 + +Copyright +--------- + +This work was supported by the the European Commision within the 6th Framework +Project 2005-IST-5-033406-STP (ANGEL project) + +Author: Jan-Hinrich Hauer + +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + diff --git a/tos/lib/mac/tkn154/RadioClientC.nc b/tos/lib/mac/tkn154/RadioClientC.nc new file mode 100644 index 00000000..53b6e9b7 --- /dev/null +++ b/tos/lib/mac/tkn154/RadioClientC.nc @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ +#include "TKN154_MAC.h" +generic configuration RadioClientC() +{ + provides + { + interface RadioRx; + interface RadioTx; + interface RadioOff; + interface Resource as Token; + interface ResourceRequested as TokenRequested; + interface ResourceTransfer; + interface ResourceTransferred; + interface ResourceTransferConnector as TransferFrom; + interface GetNow as IsResourceRequested; + } uses { + interface ResourceTransferConnector as TransferTo; + } +} +implementation +{ + enum { + CLIENT = unique(IEEE802154_RADIO_RESOURCE), + }; + + components FrameDispatchP; + RadioRx = FrameDispatchP.RadioRx[CLIENT]; + RadioTx = FrameDispatchP.RadioTx[CLIENT]; + RadioOff = FrameDispatchP.RadioOff[CLIENT]; + Token = FrameDispatchP.Token[CLIENT]; + IsResourceRequested = FrameDispatchP.IsResourceRequested; + TokenRequested = FrameDispatchP.TokenRequested[CLIENT]; + + components new TransferClientP(CLIENT); + ResourceTransfer = TransferClientP; + ResourceTransferred = TransferClientP; + TransferTo = TransferClientP; + TransferFrom = TransferClientP; + TransferClientP.ResourceTransferControl -> FrameDispatchP; + TransferClientP.Leds -> FrameDispatchP; +} + diff --git a/tos/lib/mac/tkn154/RxEnableP.nc b/tos/lib/mac/tkn154/RxEnableP.nc new file mode 100644 index 00000000..7d5df58c --- /dev/null +++ b/tos/lib/mac/tkn154/RxEnableP.nc @@ -0,0 +1,274 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +#include "TKN154_PHY.h" +#include "TKN154_MAC.h" +module RxEnableP +{ + provides + { + interface Init; + interface MLME_RX_ENABLE; + interface SplitControl as PromiscuousMode; + interface FrameRx; + interface Get as PromiscuousModeGet; + interface GetNow as IsRxEnableActive; + interface Notify as RxEnableStateChange; + } + uses + { + interface Resource as Token; + interface RadioRx as PromiscuousRx; + interface RadioOff; + interface Set as RadioPromiscuousMode; + interface Ieee802154Debug as Debug; + interface Timer as RxEnableTimer; + interface Get as IsBeaconEnabledPAN; + interface Get as IsMacPanCoordinator; + interface Get as IsTrackingBeacons; + interface GetNow as IncomingSfStart; + interface GetNow as IncomingBeaconInterval; + interface Get as IsSendingBeacons; + interface GetNow as OutgoingSfStart; + interface GetNow as OutgoingBeaconInterval; + interface Notify as WasRxEnabled; + interface TimeCalc; + } +} +implementation +{ + enum promiscuous_state { + S_IDLE, + S_STARTING, + S_STARTED, + S_STOPPING, + } m_promiscuousState; + + uint32_t m_rxOnDuration; + uint32_t m_rxOnOffset; + uint32_t m_rxOnAnchor; + norace bool m_isRxEnabled; + bool m_isRxEnableConfirmPending; + + task void prepareDoneTask(); + task void radioOffDoneTask(); + + command error_t Init.init() + { + if (m_isRxEnableConfirmPending){ + m_isRxEnableConfirmPending = FALSE; + signal MLME_RX_ENABLE.confirm(IEEE154_SUCCESS); + } + m_isRxEnabled = FALSE; + call RxEnableTimer.stop(); + return SUCCESS; + } + +/* ----------------------- MLME-RX-ENABLE ----------------------- */ + + command ieee154_status_t MLME_RX_ENABLE.request ( + bool DeferPermit, + uint32_t RxOnTime, + uint32_t RxOnDuration + ) + { + uint32_t lastBeaconTime=0; + uint32_t beaconInterval=0; + + if (m_isRxEnableConfirmPending) + return IEEE154_TRANSACTION_OVERFLOW; + if (RxOnTime > 0xFFFFFF || RxOnDuration > 0xFFFFFF) + return IEEE154_INVALID_PARAMETER; + if (call IsBeaconEnabledPAN.get()){ + if (call IsSendingBeacons.get() && call IsMacPanCoordinator.get()){ + // for OUTGOING SUPERFRAME + lastBeaconTime = call OutgoingSfStart.getNow(); + beaconInterval = call OutgoingBeaconInterval.getNow(); + } else if (call IsTrackingBeacons.get()){ + // for INCOMING SUPERFRAME + lastBeaconTime = call IncomingSfStart.getNow(); + beaconInterval = call IncomingBeaconInterval.getNow(); + } + if (beaconInterval == 0) + return IEEE154_PAST_TIME; // we're not even sending/receiving beacons + if (RxOnTime+RxOnDuration >= beaconInterval) + return IEEE154_ON_TIME_TOO_LONG; + if (call TimeCalc.hasExpired(lastBeaconTime, RxOnTime - IEEE154_aTurnaroundTime)){ + if (!DeferPermit) + return IEEE154_PAST_TIME; + else { + // defer to next beacon + RxOnTime += beaconInterval; + } + } + m_rxOnAnchor = lastBeaconTime; + m_rxOnOffset = RxOnTime; + } else { + m_rxOnAnchor = call RxEnableTimer.getNow(); + m_rxOnOffset = 0; + } + m_rxOnDuration = RxOnDuration; + m_isRxEnabled = FALSE; + m_isRxEnableConfirmPending = TRUE; + call RxEnableTimer.startOneShotAt(m_rxOnAnchor, m_rxOnOffset); + signal RxEnableStateChange.notify(TRUE); + return IEEE154_SUCCESS; + } + + event void RxEnableTimer.fired() + { + if (!m_isRxEnabled){ + m_isRxEnabled = TRUE; + call RxEnableTimer.startOneShotAt(m_rxOnAnchor, m_rxOnOffset + m_rxOnDuration); + } else { + m_isRxEnabled = FALSE; + if (m_isRxEnableConfirmPending){ + // this means we tried to enable rx, but never + // succeeded, because there were "other + // responsibilities" - but is SUCCESS really + // an appropriate error code in this case? + m_isRxEnableConfirmPending = FALSE; + signal MLME_RX_ENABLE.confirm(IEEE154_SUCCESS); + } + } + signal RxEnableStateChange.notify(TRUE); + } + + async command bool IsRxEnableActive.getNow() + { + return m_isRxEnabled; + } + + event void WasRxEnabled.notify( bool val ) + { + if (m_isRxEnabled && m_isRxEnableConfirmPending){ + m_isRxEnableConfirmPending = FALSE; + signal MLME_RX_ENABLE.confirm(IEEE154_SUCCESS); + } + } + + command error_t RxEnableStateChange.enable(){return FAIL;} + command error_t RxEnableStateChange.disable(){return FAIL;} + +/* ----------------------- Promiscuous Mode ----------------------- */ + + command bool PromiscuousModeGet.get() + { + return (m_promiscuousState == S_STARTED); + } + + command error_t PromiscuousMode.start() + { + if (m_promiscuousState != S_IDLE) + return FAIL; + m_promiscuousState = S_STARTING; + call Token.request(); + call Debug.log(LEVEL_INFO, EnableRxP_PROMISCUOUS_REQUEST, m_promiscuousState, 0, 0); + call Debug.flush(); + return SUCCESS; + } + + event void Token.granted() + { + if (m_promiscuousState != S_STARTING){ + call Token.release(); + return; + } + call RadioPromiscuousMode.set(TRUE); + if (call PromiscuousRx.prepare() != IEEE154_SUCCESS){ + m_promiscuousState = S_IDLE; + call Token.release(); + call Debug.log(LEVEL_IMPORTANT, EnableRxP_RADIORX_ERROR, 0, 0, 0); + signal PromiscuousMode.startDone(FAIL); + } + } + + async event void PromiscuousRx.prepareDone() + { + post prepareDoneTask(); + } + + task void prepareDoneTask() + { + if (m_promiscuousState != S_STARTING){ + call Token.release(); + return; + } + m_promiscuousState = S_STARTED; + call PromiscuousRx.receive(NULL, 0); + signal PromiscuousMode.startDone(SUCCESS); + call Debug.log(LEVEL_INFO, EnableRxP_PROMISCUOUS_ON, m_promiscuousState, 0, 0); + } + + event message_t* PromiscuousRx.received(message_t *frame, ieee154_reftime_t *timestamp) + { + if (m_promiscuousState == S_STARTED){ + ((ieee154_header_t*) frame->header)->length |= FRAMECTL_PROMISCUOUS; + return signal FrameRx.received(frame); + } else + return frame; + } + + command error_t PromiscuousMode.stop() + { + if (m_promiscuousState != S_STARTED) + return FAIL; + m_promiscuousState = S_STOPPING; + call RadioOff.off(); + return SUCCESS; + } + + async event void RadioOff.offDone() + { + post radioOffDoneTask(); + } + + task void radioOffDoneTask() + { + if (m_promiscuousState != S_STOPPING){ + call Token.release(); + return; + } + m_promiscuousState = S_IDLE; + call RadioPromiscuousMode.set(FALSE); + call Token.release(); + signal PromiscuousMode.stopDone(SUCCESS); + call Debug.log(LEVEL_INFO, EnableRxP_PROMISCUOUS_OFF, m_promiscuousState, 0, 0); + } + + default event void PromiscuousMode.startDone(error_t error){} + default event void PromiscuousMode.stopDone(error_t error){} + default event void MLME_RX_ENABLE.confirm(ieee154_status_t status){} +} diff --git a/tos/lib/mac/tkn154/ScanP.nc b/tos/lib/mac/tkn154/ScanP.nc new file mode 100644 index 00000000..d5cd2355 --- /dev/null +++ b/tos/lib/mac/tkn154/ScanP.nc @@ -0,0 +1,402 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +#include "TKN154_MAC.h" +module ScanP +{ + provides + { + interface Init; + interface MLME_SCAN; + interface MLME_BEACON_NOTIFY; + } + uses + { + interface MLME_GET; + interface MLME_SET; + interface EnergyDetection; + interface RadioOff; + interface RadioRx; + interface RadioTx; + interface IEEE154Frame as Frame; + interface IEEE154BeaconFrame as BeaconFrame; + interface Timer as ScanTimer; + interface Pool as TxFramePool; + interface Pool as TxControlPool; + interface Resource as Token; + interface FrameUtility; + interface Leds; + } +} +implementation +{ + enum { + MAX_PAYLOAD_SIZE = 1, + }; + + ieee154_txframe_t *m_txFrame = NULL; + uint8_t m_payload[MAX_PAYLOAD_SIZE]; + uint8_t m_scanType; + uint32_t m_scanChannels; + uint32_t m_unscannedChannels; + ieee154_macAutoRequest_t m_macAutoRequest; + norace uint32_t m_currentChannelBit; + norace uint8_t m_currentChannelNum; + void* m_resultList; + uint8_t m_resultListNumEntries; + uint8_t m_resultIndex; + ieee154_macPANId_t m_PANID; + norace uint32_t m_scanDuration; + bool m_busy = FALSE; + + void nextIteration(); + task void startTimerTask(); + task void nextIterationTask(); + + command error_t Init.init() + { + // triggered by MLME_RESET; remember: Init will not be called + // while this component owns the Token, so the worst case is + // that a MLME_SCAN was accepted (returned IEEE154_SUCCESS) + // but the Token.granted() has not been signalled + if (m_busy){ + m_currentChannelNum = 27; + nextIteration(); // signals confirm and resets state + } + return SUCCESS; + } + +/* ----------------------- MLME-SCAN ----------------------- */ +/* "The MLME-SCAN.request primitive is used to initiate a channel scan over a + * given list of channels. A device can use a channel scan to measure the + * energy on the channel, search for the coordinator with which it associated, + * or search for all coordinators transmitting beacon frames within the POS of + * the scanning device." (IEEE 802.15.4-2006 Sect. 7.1.11.1) + **/ + + command ieee154_status_t MLME_SCAN.request ( + uint8_t ScanType, + uint32_t ScanChannels, + uint8_t ScanDuration, + uint8_t ChannelPage, + uint8_t EnergyDetectListNumEntries, + int8_t* EnergyDetectList, + uint8_t PANDescriptorListNumEntries, + ieee154_PANDescriptor_t* PANDescriptorList, + ieee154_security_t *security + ) + { + ieee154_status_t status = IEEE154_SUCCESS; + ieee154_phyChannelsSupported_t supportedChannels = call MLME_GET.phyChannelsSupported(); + ieee154_txcontrol_t *txControl = NULL; + + if (m_busy){ + status = IEEE154_SCAN_IN_PROGRESS; + } else if (security && security->SecurityLevel){ + status = IEEE154_UNSUPPORTED_SECURITY; + } if ( (ScanType > 3) || (ScanType < 3 && ScanDuration > 14) || + (ChannelPage != IEEE154_SUPPORTED_CHANNELPAGE) || + !(supportedChannels & ScanChannels) || + (EnergyDetectListNumEntries && PANDescriptorListNumEntries) || + (EnergyDetectList != NULL && PANDescriptorList != NULL) || + (EnergyDetectListNumEntries && EnergyDetectList == NULL) || + (PANDescriptorListNumEntries && PANDescriptorList == NULL)) { + status = IEEE154_INVALID_PARAMETER; + } else if (ScanType != ENERGY_DETECTION_SCAN && + !(m_txFrame = call TxFramePool.get())) { + status = IEEE154_TRANSACTION_OVERFLOW; + } else if (ScanType != ENERGY_DETECTION_SCAN && + !(txControl = call TxControlPool.get())) { + call TxFramePool.put(m_txFrame); + m_txFrame = NULL; + status = IEEE154_TRANSACTION_OVERFLOW; + } else { + m_txFrame->header = &txControl->header; + m_txFrame->payload = m_payload; + m_txFrame->metadata = &txControl->metadata; + m_busy = TRUE; + m_scanType = ScanType; + m_scanChannels = ScanChannels; + m_scanDuration = (((uint32_t) 1 << ScanDuration) + 1) * IEEE154_aBaseSuperframeDuration; + m_macAutoRequest = call MLME_GET.macAutoRequest(); + m_PANID = call MLME_GET.macPANId(); + m_unscannedChannels = 0; + m_currentChannelBit = 1; + m_currentChannelNum = 0; + m_resultIndex = 0; + if (ScanType == ENERGY_DETECTION_SCAN){ + m_resultList = EnergyDetectList; + m_resultListNumEntries = EnergyDetectListNumEntries; + } else { + m_resultList = PANDescriptorList; + m_resultListNumEntries = PANDescriptorListNumEntries; + } + if (m_resultList == NULL) + m_resultListNumEntries = 0; + call Token.request(); + } + return status; + } + + event void Token.granted() + { + uint8_t i; + ieee154_macPANId_t bcastPANID = 0xFFFF; + ieee154_macDSN_t dsn = call MLME_GET.macDSN(); + + if (!m_busy){ + call Token.release(); + return; + } + switch (m_scanType){ + case ACTIVE_SCAN: + // beacon request frame + m_txFrame->header->mhr[MHR_INDEX_FC1] = FC1_FRAMETYPE_CMD; + m_txFrame->header->mhr[MHR_INDEX_FC2] = FC2_DEST_MODE_SHORT; + m_txFrame->header->mhr[MHR_INDEX_SEQNO] = dsn; + call MLME_SET.macDSN(dsn+1); + for (i=0; i<4; i++) // broadcast dest PAN ID + broadcast dest addr + m_txFrame->header->mhr[MHR_INDEX_ADDRESS + i] = 0xFF; + m_txFrame->headerLen = 7; + m_payload[0] = CMD_FRAME_BEACON_REQUEST; + m_txFrame->payloadLen = 1; + // fall through + case PASSIVE_SCAN: + call MLME_SET.macPANId(bcastPANID); + break; + case ORPHAN_SCAN: + // orphan notification frame + m_scanDuration = call MLME_GET.macResponseWaitTime(); + m_txFrame->header->mhr[MHR_INDEX_FC1] = FC1_FRAMETYPE_CMD | FC1_PAN_ID_COMPRESSION; + m_txFrame->header->mhr[MHR_INDEX_FC2] = FC2_SRC_MODE_EXTENDED | FC2_DEST_MODE_SHORT; + m_txFrame->header->mhr[MHR_INDEX_SEQNO] = dsn; + call MLME_SET.macDSN(dsn+1); + for (i=0; i<4; i++) // broadcast dest PAN ID + broadcast dest addr + m_txFrame->header->mhr[MHR_INDEX_ADDRESS + i] = 0xFF; + call FrameUtility.copyLocalExtendedAddressLE((uint8_t*) &(m_txFrame->header[MHR_INDEX_ADDRESS + i])); + m_txFrame->headerLen = 15; + m_payload[0] = CMD_FRAME_ORPHAN_NOTIFICATION; + m_txFrame->payloadLen = 1; + break; + } + nextIteration(); + } + + void nextIteration() + { + error_t radioStatus = SUCCESS; + uint32_t supportedChannels = IEEE154_SUPPORTED_CHANNELS; + atomic { + while (!(m_scanChannels & m_currentChannelBit & supportedChannels) && m_currentChannelNum < 27){ + m_unscannedChannels |= m_currentChannelBit; + m_currentChannelBit <<= 1; + m_currentChannelNum++; + } + } + if (m_currentChannelNum < 27) { + call MLME_SET.phyCurrentChannel(m_currentChannelNum); + switch (m_scanType){ + case PASSIVE_SCAN: + radioStatus = call RadioRx.prepare(); + break; + case ACTIVE_SCAN: + case ORPHAN_SCAN: + radioStatus = call RadioTx.load(m_txFrame); + break; + case ENERGY_DETECTION_SCAN: + radioStatus = call EnergyDetection.start(m_scanDuration); + break; + } + if (radioStatus != SUCCESS){ + call Leds.led0On(); + } + } else { + ieee154_status_t result = IEEE154_SUCCESS; + // we're done + m_currentChannelBit <<= 1; + while (m_currentChannelBit){ + m_unscannedChannels |= m_currentChannelBit; + m_currentChannelBit <<= 1; + } + m_unscannedChannels &= m_scanChannels; // only channels that were requested + if (m_scanType != ENERGY_DETECTION_SCAN && !m_resultIndex) + result = IEEE154_NO_BEACON; + if (m_scanType == PASSIVE_SCAN || m_scanType == ACTIVE_SCAN) + call MLME_SET.macPANId(m_PANID); + if (m_txFrame != NULL){ + call TxControlPool.put((ieee154_txcontrol_t*) ((uint8_t*) m_txFrame->header - offsetof(ieee154_txcontrol_t, header))); + call TxFramePool.put(m_txFrame); + } + m_txFrame = NULL; + if (call Token.isOwner()) + call Token.release(); + m_busy = FALSE; + signal MLME_SCAN.confirm ( + result, + m_scanType, + IEEE154_SUPPORTED_CHANNELPAGE, + m_unscannedChannels, + (m_scanType == ENERGY_DETECTION_SCAN) ? m_resultIndex : 0, + (m_scanType == ENERGY_DETECTION_SCAN) ? (uint8_t*) m_resultList : NULL, + ((m_scanType == ACTIVE_SCAN || + m_scanType == PASSIVE_SCAN) && m_macAutoRequest) ? m_resultIndex : 0, + ((m_scanType == ACTIVE_SCAN || + m_scanType == PASSIVE_SCAN) && m_macAutoRequest) ? (ieee154_PANDescriptor_t*) m_resultList : NULL + ); + } + } + +/* ----------------------- EnergyDetection ----------------------- */ + + event void EnergyDetection.done(error_t status, int8_t EnergyLevel) + { + if (status == SUCCESS && m_resultListNumEntries) + ((uint8_t*) m_resultList)[m_resultIndex++] = EnergyLevel; + else + m_unscannedChannels |= m_currentChannelBit; + if (m_resultIndex == m_resultListNumEntries) + m_currentChannelNum = 27; // done + else + m_currentChannelNum++; + call RadioOff.off(); + } + +/* ----------------------- Active/Orphan scan ----------------------- */ + + async event void RadioTx.loadDone() + { + call RadioTx.transmit(0, 0, 0, FALSE); + } + + async event void RadioTx.transmitDone(ieee154_txframe_t *frame, + ieee154_reftime_t *referenceTime, bool ackPendingFlag, error_t error) + { + if (call RadioRx.prepare() != SUCCESS) // must succeed + call Leds.led0On(); + } + +/* -------- Receive events (for Active/Passive/Orphan scan) -------- */ + + async event void RadioRx.prepareDone() + { + call RadioRx.receive(NULL, 0); + post startTimerTask(); + } + + event message_t* RadioRx.received(message_t *frame, ieee154_reftime_t *timestamp) + { + atomic { + if (!m_busy) + return frame; + if (m_scanType == ORPHAN_SCAN){ + if (!m_resultIndex) + if ((MHR(frame)[0] & FC1_FRAMETYPE_MASK) == FC1_FRAMETYPE_CMD && + ((uint8_t*)call Frame.getPayload(frame))[0] == CMD_FRAME_COORDINATOR_REALIGNMENT){ + m_resultIndex++; + m_currentChannelNum = 27; // terminate scan + call RadioOff.off(); + } + } else if ((((ieee154_header_t*) frame->header)->mhr[0] & FC1_FRAMETYPE_MASK) == FC1_FRAMETYPE_BEACON) { + // PASSIVE_SCAN / ACTIVE_SCAN + if (!m_macAutoRequest) + return signal MLME_BEACON_NOTIFY.indication (frame); + else if (m_resultListNumEntries && m_resultIndex < m_resultListNumEntries && + call BeaconFrame.parsePANDescriptor( + frame, + m_currentChannelNum, + IEEE154_SUPPORTED_CHANNELPAGE, + &((ieee154_PANDescriptor_t*) m_resultList)[m_resultIndex]) == SUCCESS){ + // check uniqueness: both PAN ID and source address must not be in a previously received beacon + uint8_t i; + if (m_resultIndex) + for (i=0; i
+ * + * This component provides the Resource, ArbiterInfo, and Resource + * Controller interfaces and uses the ResourceConfigure interface as + * described in TEP 108. It provides arbitration to a shared resource in + * an FCFS fashion. An array is used to keep track of which users have put + * in requests for the resource. Upon the release of the resource by one + * of these users, the array is checked and the next user (in FCFS order) + * that has a pending request will ge granted control of the resource. If + * there are no pending requests, then the resource becomes idle and any + * user can put in a request and immediately receive access to the + * Resource. + * + * @param resourceName -- The name of the Resource being shared + * + * @author Kevin Klues (klues@tkn.tu-berlin.de) + * @author Philip Levis + */ + +generic configuration SimpleRoundRobinTransferArbiterC(char resourceName[]) { + provides { + interface Resource[uint8_t id]; + interface ResourceRequested[uint8_t id]; + interface ResourceTransferControl; + interface ArbiterInfo; + interface GetNow as IsResourceRequested; + } + uses interface ResourceConfigure[uint8_t id]; +} +implementation { + components MainC; + components new RoundRobinResourceQueueC(uniqueCount(resourceName)) as Queue; + components new SimpleTransferArbiterP() as Arbiter; + + MainC.SoftwareInit -> Queue; + + Resource = Arbiter; + ResourceRequested = Arbiter; + ArbiterInfo = Arbiter; + ResourceConfigure = Arbiter; + ResourceTransferControl = Arbiter; + IsResourceRequested = Arbiter; + + Arbiter.Queue -> Queue; +} diff --git a/tos/lib/mac/tkn154/SimpleTransferArbiterP.nc b/tos/lib/mac/tkn154/SimpleTransferArbiterP.nc new file mode 100644 index 00000000..76ae05b4 --- /dev/null +++ b/tos/lib/mac/tkn154/SimpleTransferArbiterP.nc @@ -0,0 +1,215 @@ +/* + * Copyright (c) 2004, Technische Universitat Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitat Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/** + * Please refer to TEP 108 for more information about this component and its + * intended use.

+ * + * This component provides the Resource, ArbiterInfo, and ResourceRequested + * interfaces and uses the ResourceConfigure interface as + * described in TEP 108. It provides arbitration to a shared resource. + * An queue is used to keep track of which users have put + * in requests for the resource. Upon the release of the resource by one + * of these users, the queue is checked and the next user + * that has a pending request will ge granted control of the resource. If + * there are no pending requests, then the resource becomes idle and any + * user can put in a request and immediately receive access to the + * Resource. + * + * @author Kevin Klues (klues@tkn.tu-berlin.de) + * @author Philip Levis + * @author: Jan Hauer (added resource transfer) + */ + +generic module SimpleTransferArbiterP() { + provides { + interface Resource[uint8_t id]; + interface ResourceRequested[uint8_t id]; + interface ResourceTransferControl; + interface ArbiterInfo; + interface GetNow as IsResourceRequested; + } + uses { + interface ResourceConfigure[uint8_t id]; + interface ResourceQueue as Queue; + } +} +implementation { + + enum {RES_IDLE = 0, RES_GRANTING = 1, RES_BUSY = 2}; + enum {NO_RES = 0xFF}; + + uint8_t state = RES_IDLE; + norace uint8_t resId = NO_RES; + norace uint8_t reqResId; + norace uint8_t numTransfers; + norace bool reqWhileTransferred; + + task void grantedTask(); + task void checkResourceRequestedTask(); + + async command error_t Resource.request[uint8_t id]() { + signal ResourceRequested.requested[resId](); + atomic { + if (numTransfers > 0) + reqWhileTransferred = TRUE; + if(state == RES_IDLE) { + state = RES_GRANTING; + reqResId = id; + post grantedTask(); + return SUCCESS; + } + return call Queue.enqueue(id); + } + } + + async command error_t Resource.immediateRequest[uint8_t id]() { + signal ResourceRequested.immediateRequested[resId](); + atomic { + if(state == RES_IDLE) { + state = RES_BUSY; + resId = id; + call ResourceConfigure.configure[resId](); + return SUCCESS; + } + return FAIL; + } + } + + async command error_t Resource.release[uint8_t id]() { + bool released = FALSE; + atomic { + if(state == RES_BUSY && resId == id) { + numTransfers = 0; + reqWhileTransferred = FALSE; + if(call Queue.isEmpty() == FALSE) { + reqResId = call Queue.dequeue(); + state = RES_GRANTING; + post grantedTask(); + } + else { + resId = NO_RES; + state = RES_IDLE; + } + released = TRUE; + } + } + if(released == TRUE) { + call ResourceConfigure.unconfigure[id](); + return SUCCESS; + } + return FAIL; + } + + async command bool IsResourceRequested.getNow() + { + return reqWhileTransferred; + } + + task void checkResourceRequestedTask() + { + if (numTransfers && reqWhileTransferred) + signal ResourceRequested.requested[resId](); + } + + async command error_t ResourceTransferControl.transfer(uint8_t fromClient, uint8_t toClient) + { + atomic { + if (call ArbiterInfo.userId() == fromClient){ + numTransfers += 1; + call ResourceConfigure.unconfigure[fromClient](); + call ResourceConfigure.configure[resId](); + resId = toClient; + post checkResourceRequestedTask(); + return SUCCESS; + } + } + return FAIL; + } + + async command error_t ResourceTransferControl.release(uint8_t client) + { + return call Resource.release[client](); + } + + /** + Check if the Resource is currently in use + */ + async command bool ArbiterInfo.inUse() { + atomic { + if (state == RES_IDLE) + return FALSE; + } + return TRUE; + } + + /** + Returns the current user of the Resource. + If there is no current user, the return value + will be 0xFF + */ + async command uint8_t ArbiterInfo.userId() { + atomic { + if(state != RES_BUSY) + return NO_RES; + return resId; + } + } + + /** + * Returns whether you are the current owner of the resource or not + */ + async command uint8_t Resource.isOwner[uint8_t id]() { + atomic { + if(resId == id && state == RES_BUSY) return TRUE; + else return FALSE; + } + } + + task void grantedTask() { + atomic { + resId = reqResId; + state = RES_BUSY; + } + call ResourceConfigure.configure[resId](); + signal Resource.granted[resId](); + } + + //Default event/command handlers + default event void Resource.granted[uint8_t id]() { + } + default async event void ResourceRequested.requested[uint8_t id]() { + } + default async event void ResourceRequested.immediateRequested[uint8_t id]() { + } + default async command void ResourceConfigure.configure[uint8_t id]() { + } + default async command void ResourceConfigure.unconfigure[uint8_t id]() { + } +} diff --git a/tos/lib/mac/tkn154/TKN154.h b/tos/lib/mac/tkn154/TKN154.h new file mode 100644 index 00000000..9889b7eb --- /dev/null +++ b/tos/lib/mac/tkn154/TKN154.h @@ -0,0 +1,262 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +#ifndef __TKN154_H +#define __TKN154_H + + +/**************************************************** + * IEEE 802.15.4 Enumerations + */ + +typedef enum ieee154_status +{ + IEEE154_SUCCESS = 0x00, + IEEE154_BEACON_LOSS = 0xE0, + IEEE154_CHANNEL_ACCESS_FAILURE = 0xE1, + IEEE154_COUNTER_ERROR = 0xDB, + IEEE154_DENIED = 0xE2, + IEEE154_DISABLE_TRX_FAILURE = 0xE3, + IEEE154_FRAME_TOO_LONG = 0xE5, + IEEE154_IMPROPER_KEY_TYPE = 0xDC, + IEEE154_IMPROPER_SECURITY_LEVEL = 0xDD, + IEEE154_INVALID_ADDRESS = 0xF5, + IEEE154_INVALID_GTS = 0xE6, + IEEE154_INVALID_HANDLE = 0xE7, + IEEE154_INVALID_INDEX = 0xF9, + IEEE154_INVALID_PARAMETER = 0xE8, + IEEE154_LIMIT_REACHED = 0xFA, + IEEE154_NO_ACK = 0xE9, + IEEE154_NO_BEACON = 0xEA, + IEEE154_NO_DATA = 0xEB, + IEEE154_NO_SHORT_ADDRESS = 0xEC, + IEEE154_ON_TIME_TOO_LONG = 0xF6, + IEEE154_OUT_OF_CAP = 0xED, + IEEE154_PAN_ID_CONFLICT = 0xEE, + IEEE154_PAST_TIME = 0xF7, + IEEE154_READ_ONLY = 0xFB, + IEEE154_REALIGNMENT = 0xEF, + IEEE154_SCAN_IN_PROGRESS = 0xFC, + IEEE154_SECURITY_ERROR = 0xE4, //FAILED_SECURITY_CHECK = 0xE4 //802.15.4_2003 + IEEE154_SUPERFRAME_OVERLAP = 0xFD, + IEEE154_TRACKING_OFF = 0xF8, + IEEE154_TRANSACTION_EXPIRED = 0xF0, + IEEE154_TRANSACTION_OVERFLOW = 0xF1, + IEEE154_TX_ACTIVE = 0xF2, + IEEE154_UNAVAILABLE_KEY = 0xF3, + IEEE154_UNSUPPORTED_ATTRIBUTE = 0xF4, + IEEE154_UNSUPPORTED_LEGACY = 0xDE, + IEEE154_UNSUPPORTED_SECURITY = 0xDF, +} ieee154_status_t; + +typedef enum ieee154_association_status +{ + IEEE154_ASSOCIATION_SUCCESSFUL = 0x00, + IEEE154_PAN_AT_CAPACITY = 0x01, + IEEE154_ACCESS_DENIED = 0x02 +} ieee154_association_status_t; + +typedef enum ieee154_disassociation_reason +{ + IEEE154_COORDINATOR_WISHES_DEVICE_TO_LEAVE = 0x01, + IEEE154_DEVICE_WISHES_TO_LEAVE = 0x02 +} ieee154_disassociation_reason_t; + +typedef union ieee154_address { + // Whether this is a short or extended address + // depends on the respective addressing mode + uint16_t shortAddress; + uint64_t extendedAddress; +} ieee154_address_t; + +typedef struct ieee154_security { + // Whether the first 0, 4 or 8 byte of KeySource + // are valid depends on the KeyIdMode parameter + uint8_t SecurityLevel; + uint8_t KeyIdMode; + uint8_t KeySource[8]; + uint8_t KeyIndex; +} ieee154_security_t; + +typedef nx_struct +{ + nxle_uint8_t AlternatePANCoordinator :1; + nxle_uint8_t DeviceType :1; + nxle_uint8_t PowerSource :1; + nxle_uint8_t ReceiverOnWhenIdle :1; + nxle_uint8_t Reserved :2; + nxle_uint8_t SecurityCapability :1; + nxle_uint8_t AllocateAddress :1; +} ieee154_CapabilityInformation_t; + +typedef nx_struct +{ + nxle_uint8_t BeaconOrder :4; + nxle_uint8_t SuperframeOrder :4; + nxle_uint8_t FinalCAPSlot :4; + nxle_uint8_t BatteryLifeExtension :1; + nxle_uint8_t Reserved :1; + nxle_uint8_t PANCoordinator :1; + nxle_uint8_t AssociationPermit :1; +} ieee154_SuperframeSpec_t; + +typedef struct ieee154_PANDescriptor { + uint8_t CoordAddrMode; + uint16_t CoordPANId; + ieee154_address_t CoordAddress; + uint8_t LogicalChannel; + uint8_t ChannelPage; + ieee154_SuperframeSpec_t SuperframeSpec; + bool GTSPermit; + uint8_t LinkQuality; + uint32_t TimeStamp; + ieee154_status_t SecurityFailure; + uint8_t SecurityLevel; + uint8_t KeyIdMode; + uint64_t KeySource; + uint8_t KeyIndex; +} ieee154_PANDescriptor_t; + +enum { + // Values for the PANType parameter of the MLME_RESET.request primitive + BEACON_ENABLED_PAN, + NONBEACON_ENABLED_PAN, + + // Values for the TxOptions parameter of MCPS_DATA.request() + TX_OPTIONS_ACK = 0x01, + TX_OPTIONS_GTS = 0x02, + TX_OPTIONS_INDIRECT = 0x04, + + // Values for Destination/Source Addressing Mode (MCPS_DATA.request(), etc.) + ADDR_MODE_NOT_PRESENT = 0x00, + ADDR_MODE_RESERVED = 0x01, + ADDR_MODE_SHORT_ADDRESS = 0x02, + ADDR_MODE_EXTENDED_ADDRESS = 0x03, + + // ScanType parameter for MLME-SCAN primitive + ENERGY_DETECTION_SCAN = 0x00, + ACTIVE_SCAN = 0x01, + PASSIVE_SCAN = 0x02, + ORPHAN_SCAN = 0x03, + + // Frame types + FRAMETYPE_BEACON = 0x00, + FRAMETYPE_DATA = 0x01, + FRAMETYPE_ACK = 0x02, + FRAMETYPE_CMD = 0x03, +}; + +/**************************************************** + * typedefs PIB value types + */ + +typedef uint8_t ieee154_phyCurrentChannel_t; +typedef uint32_t ieee154_phyChannelsSupported_t; +typedef uint8_t ieee154_phyTransmitPower_t; +typedef uint8_t ieee154_phyCCAMode_t; +typedef uint8_t ieee154_phyCurrentPage_t; +typedef uint16_t ieee154_phyMaxFrameDuration_t; +typedef uint8_t ieee154_phySHRDuration_t; +typedef uint8_t ieee154_phySymbolsPerOctet_t; + +typedef uint8_t ieee154_macAckWaitDuration_t; +typedef bool ieee154_macAssociatedPANCoord_t; +typedef bool ieee154_macAssociationPermit_t; +typedef bool ieee154_macAutoRequest_t; +typedef bool ieee154_macBattLifeExt_t; +typedef uint8_t ieee154_macBattLifeExtPeriods_t; +typedef uint8_t* ieee154_macBeaconPayload_t; +typedef uint8_t ieee154_macBeaconPayloadLength_t; +typedef uint8_t ieee154_macBeaconOrder_t; +typedef uint32_t ieee154_macBeaconTxTime_t; +typedef uint8_t ieee154_macBSN_t; +typedef uint64_t ieee154_macCoordExtendedAddress_t; +typedef uint16_t ieee154_macCoordShortAddress_t; +typedef uint8_t ieee154_macDSN_t; +typedef bool ieee154_macGTSPermit_t; +typedef uint8_t ieee154_macMaxBE_t; +typedef uint8_t ieee154_macMaxCSMABackoffs_t; +typedef uint32_t ieee154_macMaxFrameTotalWaitTime_t; +typedef uint8_t ieee154_macMaxFrameRetries_t; +typedef uint8_t ieee154_macMinBE_t; +typedef uint8_t ieee154_macMinLIFSPeriod_t; +typedef uint8_t ieee154_macMinSIFSPeriod_t; +typedef uint16_t ieee154_macPANId_t; +typedef bool ieee154_macPromiscuousMode_t; +typedef uint8_t ieee154_macResponseWaitTime_t; +typedef bool ieee154_macRxOnWhenIdle_t; +typedef bool ieee154_macSecurityEnabled_t; +typedef uint16_t ieee154_macShortAddress_t; +typedef uint8_t ieee154_macSuperframeOrder_t; +typedef uint16_t ieee154_macSyncSymbolOffset_t; +typedef bool ieee154_macTimestampSupported_t; +typedef uint16_t ieee154_macTransactionPersistenceTime_t; + +// own typedefs +typedef bool ieee154_macPanCoordinator_t; + +// When security is implemented the following line should be commented out +#define IEEE154_SECURITY_DISABLED + +/**************************************************** + * Static memory allocation for Queue/Pool + */ + +#ifndef TXFRAME_POOL_SIZE +#define TXFRAME_POOL_SIZE 5 +#endif + +#ifndef TXCONTROL_POOL_SIZE +#define TXCONTROL_POOL_SIZE 5 +#endif + +#ifndef CAP_TX_QUEUE_SIZE +#define CAP_TX_QUEUE_SIZE 10 +#endif + +#ifndef INDIRECT_TX_QUEUE_SIZE +#define INDIRECT_TX_QUEUE_SIZE 7 +#endif + +#ifndef MAX_PENDING_ASSOC_RESPONSES +#define MAX_PENDING_ASSOC_RESPONSES INDIRECT_TX_QUEUE_SIZE +#endif + +enum { + // PHY sublayer constant needed to calculate mpdu size + IEEE154_aMaxPHYPacketSize = 127, +}; + +#endif // __TKN154_H diff --git a/tos/lib/mac/tkn154/TKN154P.nc b/tos/lib/mac/tkn154/TKN154P.nc new file mode 100644 index 00000000..31f16599 --- /dev/null +++ b/tos/lib/mac/tkn154/TKN154P.nc @@ -0,0 +1,524 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +#include "TKN154_PHY.h" +#include "TKN154_MAC.h" +#include "TKN154_PIB.h" +#include "TKN154_DEBUG.h" + +configuration TKN154P +{ + provides + { + // MCPS-SAP + interface MCPS_DATA; + interface MCPS_PURGE; + interface Packet; + + // MLME-SAP + interface MLME_ASSOCIATE; + interface MLME_BEACON_NOTIFY; + interface MLME_COMM_STATUS; + interface MLME_DISASSOCIATE; + interface MLME_GET; +/* interface MLME_GTS;*/ + interface MLME_ORPHAN; + interface MLME_POLL; + interface MLME_RESET; + interface MLME_RX_ENABLE; + interface MLME_SCAN; + interface MLME_SET; + interface MLME_START; + interface MLME_SYNC; + interface MLME_SYNC_LOSS; + + interface Notify as PIBUpdate[uint8_t attributeID]; + interface IEEE154Frame; + interface IEEE154BeaconFrame; + interface IEEE154TxBeaconPayload; + interface SplitControl as PromiscuousMode; + interface Get as GetLocalExtendedAddress; + interface TimeCalc; + interface FrameUtility; + + } uses { + + interface RadioRx; + interface RadioTx; + interface RadioOff; + interface EnergyDetection; + interface SplitControl as PhySplitControl; + interface Set as RadioPromiscuousMode; + + interface Alarm as Alarm1; + interface Alarm as Alarm2; + interface Alarm as Alarm3; + interface Alarm as Alarm4; + interface Alarm as Alarm5; + interface Alarm as Alarm6; + interface Alarm as Alarm7; + interface Alarm as Alarm8; + interface Alarm as Alarm9; + interface Alarm as Alarm10; + interface Alarm as Alarm11; + interface Alarm as Alarm12; + + interface Timer as Timer1; + interface Timer as Timer2; + interface Timer as Timer3; + interface Timer as Timer4; + interface Timer as Timer5; + + interface Ieee802154Debug[uint8_t client]; + interface LocalTime; + interface Random; + interface Leds; + } +} +implementation +{ + components +#ifndef IEEE154_SCAN_DISABLED + ScanP, +#else + NoScanP as ScanP, +#endif + DataP, + AssociateP, + PollP, + RxEnableP, + IndirectTxP, + PibP, + FrameDispatchP, + +#ifndef IEEE154_BEACON_SYNC_DISABLED + BeaconSynchronizeP, + new CapQueueP() as DeviceCapQueue, + new CapP(INCOMING_SUPERFRAME) as DeviceCap, +#else + NoBeaconSynchronizeP as BeaconSynchronizeP, + new NoCapQueueP() as DeviceCapQueue, + new NoCapP() as DeviceCap, +#endif + NoDeviceCfpP as DeviceCfp, + +#ifndef IEEE154_BEACON_TX_DISABLED + BeaconTransmitP, + new CapQueueP() as CoordCapQueue, + new CapP(OUTGOING_SUPERFRAME) as CoordCap, +#else + NoBeaconTransmitP as BeaconTransmitP, + new NoCapQueueP() as CoordCapQueue, + new NoCapP() as CoordCap, +#endif + NoCoordCfpP as CoordCfp, + + CoordRealignmentP, + CoordBroadcastP, + new PoolC(ieee154_txframe_t, TXFRAME_POOL_SIZE) as TxFramePoolP, + new PoolC(ieee154_txcontrol_t, TXCONTROL_POOL_SIZE) as TxControlPoolP, + new QueueC(ieee154_txframe_t*, CAP_TX_QUEUE_SIZE) as DeviceCapQueueC, + new QueueC(ieee154_txframe_t*, CAP_TX_QUEUE_SIZE) as CoordCapQueueC, + new QueueC(ieee154_txframe_t*, CAP_TX_QUEUE_SIZE) as BroadcastQueueC; + + components MainC; + + // MCPS + MCPS_DATA = DataP; + MCPS_PURGE = DataP; + + //MLME + MLME_START = BeaconTransmitP; + MLME_ASSOCIATE = AssociateP; + MLME_BEACON_NOTIFY = BeaconSynchronizeP; + MLME_BEACON_NOTIFY = ScanP; + MLME_COMM_STATUS = AssociateP; + MLME_COMM_STATUS = CoordRealignmentP; + MLME_DISASSOCIATE = AssociateP; + MLME_GET = PibP; + MLME_ORPHAN = CoordRealignmentP; +/* MLME_GTS = CfpTransmitP;*/ + MLME_POLL = PollP; + MLME_RESET = PibP; + MLME_RX_ENABLE = RxEnableP; + MLME_SCAN = ScanP; + MLME_SET = PibP; + MLME_SYNC = BeaconSynchronizeP; + MLME_SYNC_LOSS = BeaconSynchronizeP; + IEEE154Frame = PibP; + IEEE154BeaconFrame = PibP; + PromiscuousMode = RxEnableP; + GetLocalExtendedAddress = PibP.GetLocalExtendedAddress; + IEEE154TxBeaconPayload = BeaconTransmitP; + Packet = PibP; + TimeCalc = PibP; + FrameUtility = PibP; + +/* ----------------------- Scanning (MLME-SCAN) ----------------------- */ + + components new RadioClientC() as ScanRadioClient; + PibP.MacReset -> ScanP; + ScanP.MLME_GET -> PibP; + ScanP.MLME_SET -> PibP.MLME_SET; + ScanP.EnergyDetection = EnergyDetection; + ScanP.RadioRx -> ScanRadioClient; + ScanP.RadioTx -> ScanRadioClient; + ScanP.Frame -> PibP; + ScanP.BeaconFrame -> PibP; + ScanP.RadioOff -> ScanRadioClient; + ScanP.ScanTimer = Timer1; + ScanP.TxFramePool -> TxFramePoolP; + ScanP.TxControlPool -> TxControlPoolP; + ScanP.Token -> ScanRadioClient; + ScanP.FrameUtility -> PibP; + ScanP.Leds = Leds; + +/* ----------------- Beacon Transmission (MLME-START) ----------------- */ + + components new RadioClientC() as StartRadioClient; + PibP.MacReset -> BeaconTransmitP; + BeaconTransmitP.PIBUpdate[IEEE154_macAssociationPermit] -> PibP.PIBUpdate[IEEE154_macAssociationPermit]; + BeaconTransmitP.PIBUpdate[IEEE154_macGTSPermit] -> PibP.PIBUpdate[IEEE154_macGTSPermit]; + BeaconTransmitP.BeaconTxAlarm = Alarm1; + BeaconTransmitP.BeaconPayloadUpdateTimer = Timer2; + BeaconTransmitP.RadioOff -> StartRadioClient; + BeaconTransmitP.IsBeaconEnabledPAN -> PibP.IsBeaconEnabledPAN; + BeaconTransmitP.BeaconTx -> StartRadioClient; + BeaconTransmitP.MLME_SET -> PibP.MLME_SET; + BeaconTransmitP.MLME_GET -> PibP; + BeaconTransmitP.SetMacSuperframeOrder -> PibP.SetMacSuperframeOrder; + BeaconTransmitP.SetMacBeaconTxTime -> PibP.SetMacBeaconTxTime; + BeaconTransmitP.SetMacPanCoordinator -> PibP.SetMacPanCoordinator; + BeaconTransmitP.Token -> StartRadioClient; + BeaconTransmitP.TokenToBroadcast -> StartRadioClient; + BeaconTransmitP.RealignmentBeaconEnabledTx -> CoordBroadcastP.RealignmentTx; + BeaconTransmitP.RealignmentNonBeaconEnabledTx -> CoordCapQueue.FrameTx[unique(CAP_TX_CLIENT)]; + BeaconTransmitP.BeaconRequestRx -> CoordCap.FrameRx[FC1_FRAMETYPE_CMD + CMD_FRAME_BEACON_REQUEST]; + BeaconTransmitP.GtsInfoWrite -> CoordCfp.GtsInfoWrite; + BeaconTransmitP.PendingAddrSpecUpdated -> IndirectTxP.PendingAddrSpecUpdated; + BeaconTransmitP.PendingAddrWrite -> IndirectTxP.PendingAddrWrite; + BeaconTransmitP.FrameUtility -> PibP.FrameUtility; + BeaconTransmitP.IsTrackingBeacons -> BeaconSynchronizeP.IsTrackingBeacons; + BeaconTransmitP.LastBeaconRxRefTime -> BeaconSynchronizeP.CapStartRefTime; + BeaconTransmitP.LastBeaconRxTime -> BeaconSynchronizeP.CapStart; + BeaconTransmitP.GetSetRealignmentFrame -> CoordRealignmentP; + BeaconTransmitP.IsBroadcastReady -> CoordBroadcastP.IsBroadcastReady; + BeaconTransmitP.TimeCalc -> PibP; + BeaconTransmitP.Leds = Leds; + BeaconTransmitP.Debug = Ieee802154Debug[START_CLIENT]; + StartRadioClient.TransferTo -> CoordBroadcastRadioClient.TransferFrom; + +/* ---------------- Beacon Synchronization (MLME-SYNC) ---------------- */ + + components new RadioClientC() as SyncRadioClient; + PibP.MacReset -> BeaconSynchronizeP; + BeaconSynchronizeP.MLME_SET -> PibP.MLME_SET; + BeaconSynchronizeP.MLME_GET -> PibP; + BeaconSynchronizeP.TrackAlarm = Alarm2; + BeaconSynchronizeP.FrameUtility -> PibP; + BeaconSynchronizeP.Frame -> PibP; + BeaconSynchronizeP.BeaconFrame -> PibP; + BeaconSynchronizeP.BeaconRx -> SyncRadioClient; + BeaconSynchronizeP.RadioOff -> SyncRadioClient; + BeaconSynchronizeP.IsBeaconEnabledPAN -> PibP.IsBeaconEnabledPAN; + BeaconSynchronizeP.DataRequest -> PollP.DataRequest[SYNC_CLIENT]; + BeaconSynchronizeP.Token -> SyncRadioClient; + BeaconSynchronizeP.TokenToCap -> SyncRadioClient; + BeaconSynchronizeP.TimeCalc -> PibP; + BeaconSynchronizeP.CoordRealignmentRx -> DeviceCap.FrameRx[FC1_FRAMETYPE_CMD + CMD_FRAME_COORDINATOR_REALIGNMENT]; + BeaconSynchronizeP.Leds = Leds; + BeaconSynchronizeP.Debug = Ieee802154Debug[SYNC_CLIENT]; + SyncRadioClient.TransferTo -> DeviceCapRadioClient.TransferFrom; + +/* --------------- Dis/Association (MLME-DIS/ASSOCIATE) --------------- */ + + PibP.MacReset -> AssociateP; + AssociateP.AssociationRequestRx -> CoordCap.FrameRx[FC1_FRAMETYPE_CMD + CMD_FRAME_ASSOCIATION_REQUEST]; + AssociateP.AssociationRequestTx -> DeviceCapQueue.FrameTx[unique(CAP_TX_CLIENT)]; + AssociateP.AssociationResponseExtracted -> DeviceCap.FrameExtracted[FC1_FRAMETYPE_CMD + CMD_FRAME_ASSOCIATION_RESPONSE]; + AssociateP.AssociationResponseTx -> IndirectTxP.FrameTx[unique(INDIRECT_TX_CLIENT)]; + AssociateP.DisassociationIndirectTx -> IndirectTxP.FrameTx[unique(INDIRECT_TX_CLIENT)]; + AssociateP.DisassociationDirectTx -> CoordCapQueue.FrameTx[unique(CAP_TX_CLIENT)]; + AssociateP.DisassociationToCoord -> DeviceCapQueue.FrameTx[unique(CAP_TX_CLIENT)]; + AssociateP.DisassociationDirectRxFromCoord -> + DeviceCap.FrameRx[FC1_FRAMETYPE_CMD + CMD_FRAME_DISASSOCIATION_NOTIFICATION]; + AssociateP.DisassociationExtractedFromCoord -> + DeviceCap.FrameExtracted[FC1_FRAMETYPE_CMD + CMD_FRAME_DISASSOCIATION_NOTIFICATION]; + AssociateP.DisassociationRxFromDevice -> + CoordCap.FrameRx[FC1_FRAMETYPE_CMD + CMD_FRAME_DISASSOCIATION_NOTIFICATION]; + AssociateP.DataRequest -> PollP.DataRequest[ASSOCIATE_CLIENT]; + AssociateP.ResponseTimeout = Timer3; + AssociateP.IsTrackingBeacons -> BeaconSynchronizeP.IsTrackingBeacons; + AssociateP.TxFramePool -> TxFramePoolP; + AssociateP.TxControlPool -> TxControlPoolP; + AssociateP.MLME_GET -> PibP; + AssociateP.MLME_SET -> PibP.MLME_SET; + AssociateP.FrameUtility -> PibP; + AssociateP.Frame -> PibP; + AssociateP.Leds = Leds; + AssociateP.LocalExtendedAddress -> PibP.GetLocalExtendedAddress; + AssociateP.Debug = Ieee802154Debug[ASSOCIATE_CLIENT]; + +/* ------------------ Data Transmission (MCPS-DATA) ------------------- */ + + PibP.MacReset -> DataP; + DataP.IsSendingBeacons -> BeaconTransmitP.IsSendingBeacons; + DataP.CoordCapRx -> CoordCap.FrameRx[FC1_FRAMETYPE_DATA]; + DataP.DeviceCapTx -> DeviceCapQueue.FrameTx[unique(CAP_TX_CLIENT)]; + DataP.CoordCapTx -> CoordCapQueue.FrameTx[unique(CAP_TX_CLIENT)]; + DataP.DeviceCapRx -> PollP.DataRx; // indirect + DataP.DeviceCapRx -> RxEnableP.FrameRx; // promiscuous + DataP.DeviceCapRx -> DeviceCap.FrameRx[FC1_FRAMETYPE_DATA]; // broadcast + DataP.TxFramePool -> TxFramePoolP; + DataP.BroadcastTx -> CoordBroadcastP.BroadcastDataFrame; + DataP.DeviceCfpTx -> DeviceCfp.CfpTx; + DataP.IndirectTx -> IndirectTxP.FrameTx[unique(INDIRECT_TX_CLIENT)]; + DataP.FrameUtility -> PibP; + DataP.Frame -> PibP; + DataP.PurgeDirect -> DeviceCapQueue; + DataP.PurgeIndirect -> IndirectTxP; + DataP.PurgeGtsDevice -> DeviceCfp; + DataP.PurgeGtsCoord -> CoordCfp; + DataP.MLME_GET -> PibP; + DataP.LocalExtendedAddress -> PibP.GetLocalExtendedAddress; + DataP.Packet -> PibP; + DataP.Leds = Leds; + +/* ------------------------ Polling (MLME-POLL) ----------------------- */ + + PibP.MacReset -> PollP; + PollP.PollTx -> DeviceCapQueue.FrameTx[unique(CAP_TX_CLIENT)]; + PollP.DataExtracted -> DeviceCap.FrameExtracted[FC1_FRAMETYPE_DATA]; + PollP.FrameUtility -> PibP; + PollP.TxFramePool -> TxFramePoolP; + PollP.TxControlPool -> TxControlPoolP; + PollP.Debug = Ieee802154Debug[POLL_CLIENT]; + PollP.MLME_GET -> PibP; + PollP.LocalExtendedAddress -> PibP.GetLocalExtendedAddress; + +/* ---------------------- Indirect transmission ----------------------- */ + + PibP.MacReset -> IndirectTxP; + IndirectTxP.CoordCapTx -> CoordCapQueue.FrameTx[unique(CAP_TX_CLIENT)]; + IndirectTxP.DataRequestRx -> CoordCap.FrameRx[FC1_FRAMETYPE_CMD + CMD_FRAME_DATA_REQUEST]; + IndirectTxP.MLME_GET -> PibP; + IndirectTxP.FrameUtility -> PibP; + IndirectTxP.IndirectTxTimeout = Timer4; + IndirectTxP.TimeCalc -> PibP; + IndirectTxP.Leds = Leds; + IndirectTxP.Debug = Ieee802154Debug[INDIRECTTX_DEBUG_CLIENT]; + +/* ---------------------------- Realignment --------------------------- */ + + PibP.MacReset -> CoordRealignmentP; + CoordRealignmentP.CoordRealignmentTx -> CoordCapQueue.FrameTx[unique(CAP_TX_CLIENT)]; + CoordRealignmentP.OrphanNotificationRx -> CoordCap.FrameRx[FC1_FRAMETYPE_CMD + CMD_FRAME_ORPHAN_NOTIFICATION]; + CoordRealignmentP.FrameUtility -> PibP; + CoordRealignmentP.Frame -> PibP; + CoordRealignmentP.TxFramePool -> TxFramePoolP; + CoordRealignmentP.TxControlPool -> TxControlPoolP; + CoordRealignmentP.MLME_GET -> PibP; + CoordRealignmentP.LocalExtendedAddress -> PibP.GetLocalExtendedAddress; + +/* ---------------------------- Broadcasts ---------------------------- */ + + components new RadioClientC() as CoordBroadcastRadioClient; + PibP.MacReset -> CoordBroadcastP; + CoordBroadcastP.TokenTransferred -> CoordBroadcastRadioClient; + CoordBroadcastP.TokenToCap -> CoordBroadcastRadioClient; + CoordBroadcastRadioClient.TransferTo -> CoordCapRadioClient.TransferFrom; + CoordBroadcastP.BeaconFramePendingBit -> BeaconTransmitP.BeaconFramePendingBit; + CoordBroadcastP.CapTransmitNow -> CoordCap.BroadcastTx; + CoordBroadcastP.Queue -> BroadcastQueueC; + CoordBroadcastP.Leds = Leds; + +/* --------------------- CAP (incoming superframe) -------------------- */ + + PibP.CapQueueReset -> DeviceCapQueue; + DeviceCapQueue.Queue -> DeviceCapQueueC; + DeviceCapQueue.CapTx -> DeviceCap; + + PibP.CapQueueReset -> CoordCapQueue; + CoordCapQueue.Queue -> CoordCapQueueC; + CoordCapQueue.CapTx -> CoordCap; + + components new RadioClientC() as DeviceCapRadioClient; + PibP.CapReset -> DeviceCap; + DeviceCap.Random = Random; + DeviceCap.CapEndAlarm = Alarm3; + DeviceCap.BLEAlarm = Alarm4; + DeviceCap.IndirectTxWaitAlarm = Alarm5; + DeviceCap.BroadcastAlarm = Alarm6; + DeviceCap.Token -> DeviceCapRadioClient; + DeviceCap.TokenToCfp -> DeviceCapRadioClient; + DeviceCap.TokenTransferred -> DeviceCapRadioClient; + DeviceCap.TokenRequested -> DeviceCapRadioClient; + DeviceCap.IsTokenRequested -> DeviceCapRadioClient; + DeviceCap.CapStart -> BeaconSynchronizeP.CapStart; + DeviceCap.CapStartRefTime -> BeaconSynchronizeP.CapStartRefTime; + DeviceCap.CapLen -> BeaconSynchronizeP.CapLen; + DeviceCap.IsBLEActive -> BeaconSynchronizeP.IsBLEActive; + DeviceCap.BLELen -> BeaconSynchronizeP.BLELen; + DeviceCap.IsRxBroadcastPending -> BeaconSynchronizeP.IsRxBroadcastPending; + DeviceCap.IsRxEnableActive -> RxEnableP.IsRxEnableActive; + DeviceCap.RxEnableStateChange -> RxEnableP.RxEnableStateChange; + DeviceCap.FrameUtility -> PibP; + DeviceCap.RadioTx -> DeviceCapRadioClient; + DeviceCap.RadioRx -> DeviceCapRadioClient; + DeviceCap.RadioOff -> DeviceCapRadioClient; + DeviceCap.IsBeaconEnabledPAN -> PibP.IsBeaconEnabledPAN; + DeviceCap.MLME_GET -> PibP; + DeviceCap.MLME_SET -> PibP.MLME_SET; + DeviceCap.Debug = Ieee802154Debug[DEVICE_CAP_CLIENT]; + DeviceCap.TimeCalc -> PibP; + DeviceCap.Leds = Leds; + DeviceCapRadioClient.TransferTo -> DeviceCfpRadioClient.TransferFrom; + +/* ---------------------- CAP (outgoing superframe) ------------------- */ + + components new RadioClientC() as CoordCapRadioClient, + new BackupP(ieee154_cap_frame_backup_t); + PibP.CapReset -> CoordCap; + CoordCap.Random = Random; + CoordCap.CapEndAlarm = Alarm7; + CoordCap.BLEAlarm = Alarm8; + CoordCap.Token -> CoordCapRadioClient; + CoordCap.TokenToCfp -> CoordCapRadioClient; + CoordCap.TokenTransferred -> CoordCapRadioClient; + CoordCap.TokenRequested -> CoordCapRadioClient; + CoordCap.IsTokenRequested -> CoordCapRadioClient; + CoordCap.CapStart -> BeaconTransmitP.CapStart; + CoordCap.CapStartRefTime -> BeaconTransmitP.CapStartRefTime; + CoordCap.CapLen -> BeaconTransmitP.CapLen; + CoordCap.IsBLEActive -> BeaconTransmitP.IsBLEActive; + CoordCap.BLELen -> BeaconTransmitP.BLELen; + CoordCap.IsRxEnableActive -> RxEnableP.IsRxEnableActive; + CoordCap.RxEnableStateChange -> RxEnableP.RxEnableStateChange; + CoordCap.FrameUtility -> PibP; + CoordCap.RadioTx -> CoordCapRadioClient; + CoordCap.RadioRx -> CoordCapRadioClient; + CoordCap.RadioOff -> CoordCapRadioClient; + CoordCap.IsBeaconEnabledPAN -> PibP.IsBeaconEnabledPAN; + CoordCap.MLME_GET -> PibP; + CoordCap.MLME_SET -> PibP.MLME_SET; + CoordCap.Debug = Ieee802154Debug[COORD_CAP_CLIENT]; + CoordCap.TimeCalc -> PibP; + CoordCap.Leds = Leds; + CoordCapRadioClient.TransferTo -> CoordCfpRadioClient.TransferFrom; + CoordCap.FrameBackup -> BackupP; + CoordCap.FrameRestore -> BackupP; + +/* -------------------- GTS (incoming superframe) --------------------- */ + + components new RadioClientC() as DeviceCfpRadioClient; + PibP.MacReset -> DeviceCfp; + DeviceCfp.Token -> DeviceCfpRadioClient; + DeviceCfp.TokenTransferred -> DeviceCfpRadioClient; + DeviceCfp.TokenRequested -> DeviceCfpRadioClient; + DeviceCfp.CapStartRefTime -> BeaconSynchronizeP.CapStartRefTime; + DeviceCfp.CfpEnd -> BeaconSynchronizeP.CfpEnd; + DeviceCfp.GtsField -> BeaconSynchronizeP.GtsField; + DeviceCfp.SfSlotDuration -> BeaconSynchronizeP.SfSlotDuration; + DeviceCfp.FinalCapSlot -> BeaconSynchronizeP.FinalCapSlot; + DeviceCfp.CfpSlotAlarm = Alarm9; + DeviceCfp.CfpEndAlarm = Alarm10; + DeviceCfp.RadioTx -> DeviceCfpRadioClient; + DeviceCfp.RadioRx -> DeviceCfpRadioClient; + DeviceCfp.RadioOff -> DeviceCfpRadioClient; + DeviceCfp.MLME_GET -> PibP; + DeviceCfp.MLME_SET -> PibP.MLME_SET; + +/* -------------------- GTS (outgoing superframe) --------------------- */ + + components new RadioClientC() as CoordCfpRadioClient; + PibP.MacReset -> CoordCfp; + CoordCfp.Token -> CoordCfpRadioClient; + CoordCfp.TokenTransferred -> CoordCfpRadioClient; + CoordCfp.TokenRequested -> CoordCfpRadioClient; + CoordCfp.CfpEnd -> BeaconTransmitP.CfpEnd; + CoordCfp.GtsField -> BeaconTransmitP.GtsField; + CoordCfp.SfSlotDuration -> BeaconTransmitP.SfSlotDuration; + CoordCfp.FinalCapSlot -> BeaconTransmitP.FinalCapSlot; + CoordCfp.CfpSlotAlarm = Alarm11; + CoordCfp.CfpEndAlarm = Alarm12; + CoordCfp.RadioTx -> CoordCfpRadioClient; + CoordCfp.RadioRx -> CoordCfpRadioClient; + CoordCfp.RadioOff -> CoordCfpRadioClient; + CoordCfp.MLME_GET -> PibP; + CoordCfp.MLME_SET -> PibP.MLME_SET; + +/* ------------------ MLME-RX-ENABLE / promiscuous mode --------------- */ + + components new RadioClientC() as RxEnableRadioClient; + PibP.MacReset -> RxEnableP; + RxEnableP.Token -> RxEnableRadioClient; + RxEnableP.PromiscuousRx -> RxEnableRadioClient; + RxEnableP.IncomingSfStart -> BeaconSynchronizeP.CapStart; + RxEnableP.OutgoingSfStart -> BeaconTransmitP.CapStart; + RxEnableP.IncomingBeaconInterval -> BeaconSynchronizeP.BeaconInterval; + RxEnableP.OutgoingBeaconInterval -> BeaconTransmitP.BeaconInterval; + RxEnableP.IsTrackingBeacons -> BeaconSynchronizeP.IsTrackingBeacons; + RxEnableP.IsSendingBeacons-> BeaconTransmitP.IsSendingBeacons; + RxEnableP.IsMacPanCoordinator -> PibP.IsMacPanCoordinator; + RxEnableP.IsBeaconEnabledPAN -> PibP.IsBeaconEnabledPAN; + RxEnableP.TimeCalc -> PibP.TimeCalc; + RxEnableP.RadioOff -> RxEnableRadioClient; + RxEnableP.RadioPromiscuousMode = RadioPromiscuousMode; + RxEnableP.WasRxEnabled -> DeviceCap; + RxEnableP.WasRxEnabled -> CoordCap; + RxEnableP.RxEnableTimer = Timer5; + RxEnableP.Debug = Ieee802154Debug[RXENABLE_CLIENT]; + +/* ------------------------------- PIB -------------------------------- */ + + components new RadioClientC() as PibRadioClient; + PIBUpdate = PibP; + MainC.SoftwareInit -> PibP.LocalInit; + PibP.RadioControl = PhySplitControl; + PibP.Random = Random; + PibP.PromiscuousModeGet -> RxEnableP; + PibP.LocalTime = LocalTime; + PibP.Token -> PibRadioClient; + PibP.RadioOff -> PibRadioClient; + +/* ---------------------------- Dispatcher ---------------------------- */ + + FrameDispatchP.PhyTx = RadioTx; + FrameDispatchP.PhyRx = RadioRx; + FrameDispatchP.PhyRadioOff = RadioOff; + FrameDispatchP.RadioPromiscuousMode -> RxEnableP; + FrameDispatchP.Leds = Leds; + FrameDispatchP.Debug = Ieee802154Debug[RADIORXTX_CLIENT]; +} diff --git a/tos/lib/mac/tkn154/TKN154_DEBUG.h b/tos/lib/mac/tkn154/TKN154_DEBUG.h new file mode 100644 index 00000000..9ca3d908 --- /dev/null +++ b/tos/lib/mac/tkn154/TKN154_DEBUG.h @@ -0,0 +1,231 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +#ifndef __TKN154_DEBUG_H +#define __TKN154_DEBUG_H + +#define LEVEL_INFO 0 +#define LEVEL_IMPORTANT 50 +#define LEVEL_CRITICAL 100 + +#define RadioRxTxP_ACQUIRED 0 +#define RadioRxTxP_NOT_ACQUIRED 1 +#define RadioRxTxP_TRANSFERRED 2 +#define RadioRxTxP_NOT_TRANSFERRED 3 +#define RadioRxTxP_RELEASED 4 +#define RadioRxTxP_NOT_RELEASED 5 +#define RadioRxTxP_TRANSFER_REQUEST 6 +#define RadioRxTxP_DEFAULT_PREPARE_TX_DONE 7 +#define RadioRxTxP_DEFAULT_TX_DONE 8 +#define RadioRxTxP_DEFAULT_PREPARE_RX_DONE 9 +#define RadioRxTxP_DEFAULT_RECEIVED 10 +#define RadioRxTxP_DEFAULT_OFFDONE 11 +#define RadioRxTxP_DEFAULT_TRANSFERRED 12 +#define RadioRxTxP_DEFAULT_TRANSFERREQUEST 13 +#define RadioRxTxP_ASK_ISOWNER 14 +#define RadioRxTxP_RX_NOOWNER 15 +#define RadioRxTxP_DEFAULT_CANCEL_TX_DONE 16 +#define RadioRxTxP_DEFAULT_CANCEL_RX_DONE 17 + +#define SyncP_BEACON_MISSED_1 0 +#define SyncP_BEACON_MISSED_2 1 +#define SyncP_BEACON_MISSED_3 2 +#define SyncP_TRACK_ALARM 3 +#define SyncP_INVALID_PARAM 4 +#define SyncP_RX_ON 5 +#define SyncP_INTERNAL_ERROR 6 +#define SyncP_BEACON_RX 7 +#define SyncP_RADIO_BUSY 8 +#define SyncP_LOST_SYNC 9 +#define SyncP_RX_PACKET 10 +#define SyncP_NEXT_RX_TIME 11 +#define SyncP_SWITCHOFF 12 +#define SyncP_RX_GARBAGE 13 +#define SyncP_GOT_RESOURCE 14 +#define SyncP_RELEASE_RESOURCE 15 +#define SyncP_RESOURCE_REQUEST 16 +#define SyncP_TRANSFER_RESOURCE 17 +#define SyncP_PREPARE_RX 18 +#define SyncP_REQUEST 19 +#define SyncP_UPDATING 20 +#define SyncP_PREPARE_RX_DONE 21 +#define SyncP_INVALID_TIMESTAMP 22 +#define SyncP_RX_BEACON SyncP_RX_PACKET + +#define StartP_BEACON_TRANSMITTED 0 +#define StartP_UPDATE_STATE 1 +#define StartP_REQUEST 2 +#define StartP_OWNER_TOO_FAST 3 +#define StartP_BEACON_UPDATE 4 +#define StartP_BEACON_UPDATE_2 5 +#define StartP_PREPARE_TX 6 +#define StartP_PREPARE_TXDONE 7 +#define StartP_SKIPPED_BEACON 8 +#define StartP_GOT_RESOURCE 9 +#define StartP_TRANSMIT 10 + +#define PollP_ALLOC_FAIL1 0 +#define PollP_ALLOC_FAIL2 1 +#define PollP_INTERNAL_POLL 2 +#define PollP_SUCCESS 3 +#define PollP_TXDONE 4 +#define PollP_WRONG_FORMAT 5 +#define PollP_INTERNAL_ERROR 6 +#define PollP_RX 7 + +#define IndirectTxP_OVERFLOW 0 +#define IndirectTxP_NOTIFIED 1 +#define IndirectTxP_REQUESTED 2 +#define IndirectTxP_BUSY 3 +#define IndirectTxP_DATA_REQUEST 4 +#define IndirectTxP_SEND_NOW 5 +#define IndirectTxP_SEND_NOW_FAIL 6 +#define IndirectTxP_SEND_DONE 7 +#define IndirectTxP_BEACON_ASSEMBLY 8 + +#define EnableRxP_RADIORX_ERROR 0 +#define EnableRxP_PROMISCUOUS_REQUEST 1 +#define EnableRxP_PROMISCUOUS_ON 2 +#define EnableRxP_PROMISCUOUS_OFF 3 + +#define AssociateP_REQUEST 0 +#define AssociateP_TXDONE 1 +#define AssociateP_TIMEOUT 2 +#define AssociateP_RX 3 +#define AssociateP_SETTIMER 4 +#define AssociateP_POLL_DONE 5 + +#define DISSASSOCIATE_REQUEST 50 +#define DISSASSOCIATE_TXDONE 51 +#define DISSASSOCIATE_RX 52 + +#define CapP_TOO_SHORT 0 +#define CapP_SET_CAP_END 1 +#define CapP_CAP_END_FIRED 2 + +#define DeviceCapTransmitP_CONTINUE 0 +#define DeviceCapTransmitP_TOVERFLOW 1 +#define DeviceCapTransmitP_RADIO_RESERVE 2 +#define DeviceCapTransmitP_CCA_FAIL 3 +#define DeviceCapTransmitP_NO_ACK 4 +#define DeviceCapTransmitP_TX_DONE 5 +#define DeviceCapTransmitP_TX_PREPARE 6 +#define DeviceCapTransmitP_TX_NOW 7 +#define DeviceCapTransmitP_TX_CANCEL 8 +#define DeviceCapTransmitP_TX_PREPARE_DONE 9 +#define DeviceCapTransmitP_CAP_END_ALARM 10 +#define DeviceCapTransmitP_RADIO_OFF 11 +#define DeviceCapTransmitP_RADIO_RX 12 +#define DeviceCapTransmitP_TX_CANCEL_DONE 13 +#define DeviceCapTransmitP_TX_DONE_UNKNOWN 14 +#define DeviceCapTransmitP_RESOURCE_REQ 15 +#define DeviceCapTransmitP_GOT_RESOURCE 16 + +#define CoordCapTransmitP_RADIO_RESERVE 0 +#define CoordCapTransmitP_TX_CANCEL 1 +#define CoordCapTransmitP_CCA_FAIL 2 +#define CoordCapTransmitP_CAP_END_ALARM 3 +#define CoordCapTransmitP_OFF_DONE 4 +#define CoordCapTransmitP_FINISH_TX 5 +#define CoordCapTransmitP_RADIO_RX 6 + +#define Phy_RX_CANCEL 0 +#define Phy_RX_NOW 1 +#define Phy_LOAD_TX_FIFO 2 +#define Phy_LOAD_TX_FIFO_DONE 3 +#define Phy_LOAD_TX_CANCEL 4 +#define Phy_LOAD_TX_NOW 5 +#define Phy_LOAD_TX_RX_NOW 6 +#define Phy_SEND_DONE 7 +#define Phy_SPI_GRANTED 8 +#define Phy_RADIO_OFF 9 +#define Phy_RADIO_OFF_DONE 10 +#define Phy_RADIO_PREPARE_RX 11 +#define Phy_RADIO_PREPARE_TX 12 +#define Phy_RADIO_TX_DONE 13 +#define Phy_RADIO_RECEIVED 14 + +#define PhyRx_START 0 +#define PhyRx_STOP 1 +#define PhyRx_FIFOP 2 +#define PhyRx_RXON 3 + +enum { + // IDs assigned for debugging + START_CLIENT = 0, + COORD_CAP_CLIENT = 1, + COORD_CFP_CLIENT = 2, + + SYNC_CLIENT = 3, + DEVICE_CAP_CLIENT = 4, + DEVICE_CFP_CLIENT = 5, + + SCAN_CLIENT = 6, + + RADIORXTX_CLIENT = 7, + PIBDATABASE_CLIENT = 8, + ASSOCIATE_CLIENT = 9, + DEVICECAPQUEUE_CLIENT = 10, + INDIRECTTX_DEBUG_CLIENT = 11, + DATA_CLIENT = 12, + POLL_CLIENT = 13, + DISASSOCIATE_CLIENT = 14, + RXENABLE_CLIENT = 15, + + PHY_CLIENT = 16, + PHY_TXCLIENT = 17, + PHY_RXCLIENT = 18, +}; + +typedef nx_struct serial_debug_msg { + nx_uint8_t client; + nx_uint8_t eventID; + nx_uint8_t seqno; + nx_uint8_t priority; + nx_uint32_t timestamp; + nx_uint32_t param1; + nx_uint32_t param2; + nx_uint32_t param3; +} serial_debug_msg_t; + +#ifndef SERIAL_DBG_MSGBUF_SIZE +#define SERIAL_DBG_MSGBUF_SIZE 25 +#endif + +enum { + AM_SERIAL_DEBUG_MSG = 222, +}; + +#endif // __TKN154_DEBUG_H diff --git a/tos/lib/mac/tkn154/TKN154_MAC.h b/tos/lib/mac/tkn154/TKN154_MAC.h new file mode 100644 index 00000000..ec64503e --- /dev/null +++ b/tos/lib/mac/tkn154/TKN154_MAC.h @@ -0,0 +1,239 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +#ifndef __TKN154_MAC_H +#define __TKN154_MAC_H + +#include "TKN154.h" +#include "TKN154_PHY.h" + +/**************************************************** + * IEEE 802.15.4 PAN information base identifiers + **/ + +enum { + // PHY Sublayer PIB + IEEE154_phyCurrentChannel = 0x00, + IEEE154_phyChannelsSupported = 0x01, + IEEE154_phyTransmitPower = 0x02, + IEEE154_phyCCAMode = 0x03, + IEEE154_phyCurrentPage = 0x04, + IEEE154_phyMaxFrameDuration = 0x05, + IEEE154_phySHRDuration = 0x06, + IEEE154_phySymbolsPerOctet = 0x07, + + // MAC Sublayer PIB + IEEE154_macAckWaitDuration = 0x40, + IEEE154_macAssociatedPANCoord = 0x56, + IEEE154_macAssociationPermit = 0x41, + IEEE154_macAutoRequest = 0x42, + IEEE154_macBattLifeExt = 0x43, + IEEE154_macBattLifeExtPeriods = 0x44, + IEEE154_macBeaconPayload = 0x45, + IEEE154_macBeaconPayloadLength = 0x46, + IEEE154_macBeaconOrder = 0x47, + IEEE154_macBeaconTxTime = 0x48, + IEEE154_macBSN = 0x49, + IEEE154_macCoordExtendedAddress = 0x4A, + IEEE154_macCoordShortAddress = 0x4B, + IEEE154_macDSN = 0x4C, + IEEE154_macGTSPermit = 0x4D, + IEEE154_macMaxBE = 0x57, + IEEE154_macMaxCSMABackoffs = 0x4E, + IEEE154_macMaxFrameTotalWaitTime = 0x58, + IEEE154_macMaxFrameRetries = 0x59, + IEEE154_macMinBE = 0x4F, +// no identifier defined in standard + IEEE154_macMinLIFSPeriod = 0xA0, +// no identifier defined in standard + IEEE154_macMinSIFSPeriod = 0xA1, + IEEE154_macPANId = 0x50, + IEEE154_macPromiscuousMode = 0x51, + IEEE154_macResponseWaitTime = 0x5A, + IEEE154_macRxOnWhenIdle = 0x52, + IEEE154_macSecurityEnabled = 0x5D, + IEEE154_macShortAddress = 0x53, + IEEE154_macSuperframeOrder = 0x54, + IEEE154_macSyncSymbolOffset = 0x5B, + IEEE154_macTimestampSupported = 0x5C, + IEEE154_macTransactionPersistenceTime = 0x55, + +// attributes not present in the standard PIB: + IEEE154_macPanCoordinator = 0xF0, +}; + +enum { + // MAC header indices + MHR_INDEX_FC1 = 0, + MHR_INDEX_FC2 = 1, + MHR_INDEX_SEQNO = 2, + MHR_INDEX_ADDRESS = 3, + MHR_MAX_LEN = 23, + + // Frame Control field in MHR + FC1_FRAMETYPE_BEACON = 0x00, + FC1_FRAMETYPE_DATA = 0x01, + FC1_FRAMETYPE_ACK = 0x02, + FC1_FRAMETYPE_CMD = 0x03, + FC1_FRAMETYPE_MASK = 0x07, + + FC1_SECURITY_ENABLED = 0x08, + FC1_FRAME_PENDING = 0x10, + FC1_ACK_REQUEST = 0x20, + FC1_PAN_ID_COMPRESSION = 0x40, + + FC2_DEST_MODE_SHORT = 0x08, + FC2_DEST_MODE_EXTENDED = 0x0c, + FC2_DEST_MODE_MASK = 0x0c, + FC2_DEST_MODE_OFFSET = 2, + + FC2_SRC_MODE_SHORT = 0x80, + FC2_SRC_MODE_EXTENDED = 0xc0, + FC2_SRC_MODE_MASK = 0xc0, + FC2_SRC_MODE_OFFSET = 6, + + FC2_FRAME_VERSION_1 = 0x10, + FC2_FRAME_VERSION_2 = 0x20, + FC2_FRAME_VERSION_MASK = 0x30, +}; + +#define CAP_TX_CLIENT "CapQueueP.FrameTx.client" +#define INDIRECT_TX_CLIENT "IndirectTx.client" +#define IEEE802154_RADIO_RESOURCE "RadioRxTxP.resource" + +enum { + OUTGOING_SUPERFRAME, + INCOMING_SUPERFRAME, +}; + +typedef struct { + uint8_t length; // top bit denotes -> promiscuous mode + uint8_t mhr[MHR_MAX_LEN]; +} ieee154_header_t; + +typedef struct { + uint8_t rssi; + uint8_t linkQuality; + uint32_t timestamp; +} ieee154_metadata_t; + +typedef struct +{ + uint8_t client; + uint8_t handle; + ieee154_header_t *header; + uint8_t headerLen; + uint8_t *payload; + uint8_t payloadLen; + ieee154_metadata_t *metadata; +} ieee154_txframe_t; + +typedef struct +{ + ieee154_header_t header; + ieee154_metadata_t metadata; +} ieee154_txcontrol_t; + +typedef struct { + ieee154_txframe_t *frame; + ieee154_macMaxBE_t BE; + ieee154_macMaxCSMABackoffs_t allowedBackoffs; + ieee154_macMaxBE_t macMaxBE; + uint16_t backoff; + uint16_t backoffElapsed; + uint32_t transactionTime; +} ieee154_cap_frame_backup_t; + +#define MHR(x) (((ieee154_header_t*) (x)->header)->mhr) + +// COMMAND frames +enum { + CMD_FRAME_ASSOCIATION_REQUEST = 1, + CMD_FRAME_ASSOCIATION_RESPONSE = 2, + CMD_FRAME_DISASSOCIATION_NOTIFICATION = 3, + CMD_FRAME_DATA_REQUEST = 4, + CMD_FRAME_PAN_ID_CONFLICT_NOTIFICATION = 5, + CMD_FRAME_ORPHAN_NOTIFICATION = 6, + CMD_FRAME_BEACON_REQUEST = 7, + CMD_FRAME_COORDINATOR_REALIGNMENT = 8, + CMD_FRAME_GTS_REQUEST = 9 +}; + +enum { + // MAC payload fields inside a beacon frame + BEACON_INDEX_SF_SPEC1 = 0, + BEACON_INDEX_SF_SPEC2 = 1, + BEACON_INDEX_GTS_SPEC = 2, + + SF_SPEC2_PAN_COORD = 0x40, + SF_SPEC2_ASSOCIATION_PERMIT = 0x80, + + GTS_DESCRIPTOR_COUNT_MASK = 0x07, + GTS_LENGTH_MASK = 0xF0, + GTS_LENGTH_OFFSET = 4, + GTS_SPEC_PERMIT = 0x80, + + PENDING_ADDRESS_SHORT_MASK = 0x07, + PENDING_ADDRESS_EXT_MASK = 0x70, +}; + +enum { + // PHY sublayer constants + IEEE154_aTurnaroundTime = 12, + + FRAMECTL_LENGTH_MASK = 0x7F, // "length" member in ieee154_frame_t + FRAMECTL_PROMISCUOUS = 0x80, // "length" member in ieee154_frame_t +}; +#define IEEE154_SUPPORTED_CHANNELPAGE (IEEE154_SUPPORTED_CHANNELS >> 27) + +enum { + // MAC sublayer constants + IEEE154_aNumSuperframeSlots = 16, + IEEE154_aMaxMPDUUnsecuredOverhead = 25, + IEEE154_aMinMPDUOverhead = 9, + IEEE154_aBaseSlotDuration = 60, + IEEE154_aBaseSuperframeDuration = (IEEE154_aBaseSlotDuration * IEEE154_aNumSuperframeSlots), + IEEE154_aGTSDescPersistenceTime = 4, + IEEE154_aMaxBeaconOverhead = 75, + IEEE154_aMaxBeaconPayloadLength = (IEEE154_aMaxPHYPacketSize - IEEE154_aMaxBeaconOverhead), + IEEE154_aMaxLostBeacons = 4, + IEEE154_aMaxMACSafePayloadSize = (IEEE154_aMaxPHYPacketSize - IEEE154_aMaxMPDUUnsecuredOverhead), + IEEE154_aMaxMACPayloadSize = (IEEE154_aMaxPHYPacketSize - IEEE154_aMinMPDUOverhead), + IEEE154_aMaxSIFSFrameSize = 18, + IEEE154_aMinCAPLength = 440, + IEEE154_aUnitBackoffPeriod = 20, +}; + + +#endif // __TKN154_MAC_H diff --git a/tos/lib/mac/tkn154/TKN154_PIB.h b/tos/lib/mac/tkn154/TKN154_PIB.h new file mode 100644 index 00000000..22481539 --- /dev/null +++ b/tos/lib/mac/tkn154/TKN154_PIB.h @@ -0,0 +1,167 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Date$ + * @author Torsten Halbhuebner + * ======================================================================== + */ + +#ifndef __TKN154_PIB_H +#define __TKN154_PIB_H + +/**************************************************** + * IEEE 802.15.4 PAN information base (PIB) + */ + + +typedef struct ieee154_PIB_t { + + /**************/ + /* bool types */ + /**************/ + + // 0x41 + ieee154_macAssociationPermit_t macAssociationPermit; + // 0x42 + ieee154_macAutoRequest_t macAutoRequest; + // 0x43 + ieee154_macBattLifeExt_t macBattLifeExt; + // 0x4D + ieee154_macGTSPermit_t macGTSPermit; + // 0x51 + ieee154_macPromiscuousMode_t macPromiscuousMode; + // 0x52 + ieee154_macRxOnWhenIdle_t macRxOnWhenIdle; + // 0x56 + ieee154_macAssociatedPANCoord_t macAssociatedPANCoord; + // 0x5D + ieee154_macSecurityEnabled_t macSecurityEnabled; + // no standard attribute + ieee154_macPanCoordinator_t macPanCoordinator; + /*****************/ + /* uint8_t types */ + /*****************/ + + // 0x00 + ieee154_phyCurrentChannel_t phyCurrentChannel; + // 0x02 + ieee154_phyTransmitPower_t phyTransmitPower; + // 0x03 + ieee154_phyCCAMode_t phyCCAMode; + // 0x04 + ieee154_phyCurrentPage_t phyCurrentPage; + // 0x44 + ieee154_macBattLifeExtPeriods_t macBattLifeExtPeriods; + // 0x46 + ieee154_macBeaconPayloadLength_t macBeaconPayloadLength; + // 0x47 + ieee154_macBeaconOrder_t macBeaconOrder; + // 0x49 + ieee154_macBSN_t macBSN; + // 0x4C + ieee154_macDSN_t macDSN; + // 0x4E + ieee154_macMaxCSMABackoffs_t macMaxCSMABackoffs; + // 0x4F + ieee154_macMinBE_t macMinBE; + // 0x54 + ieee154_macSuperframeOrder_t macSuperframeOrder; + // 0x57 + ieee154_macMaxBE_t macMaxBE; + // 0x59 + ieee154_macMaxFrameRetries_t macMaxFrameRetries; + // 0x5a + ieee154_macResponseWaitTime_t macResponseWaitTime; + + /*****************************/ + /* larger than uint8_t types */ + /*****************************/ + + // 0x4B + ieee154_macCoordShortAddress_t macCoordShortAddress; + // 0x50 + ieee154_macPANId_t macPANId; + // 0x53 + ieee154_macShortAddress_t macShortAddress; + // 0x55 + ieee154_macTransactionPersistenceTime_t macTransactionPersistenceTime; + + // TODO: check type + ieee154_macMaxFrameTotalWaitTime_t macMaxFrameTotalWaitTime; + + ieee154_macBeaconTxTime_t macBeaconTxTime; + // 0x4A + ieee154_macCoordExtendedAddress_t macCoordExtendedAddress; + +} ieee154_PIB_t; + +// PHY PIB default attributes + +#define IEEE154_DEFAULT_CURRENTCHANNEL 26 +#define IEEE154_DEFAULT_CHANNELSSUPPORTED_PAGE0 0x07FFF800 +#define IEEE154_DEFAULT_CHANNELSSUPPORTED_PAGE1 0 +#define IEEE154_DEFAULT_CHANNELSSUPPORTED_PAGE2 0 +#define IEEE154_DEFAULT_CCAMODE 3 +#define IEEE154_DEFAULT_CURRENTPAGE 0 +#define IEEE154_DEFAULT_TRANSMITPOWER_dBm 0 + +// MAC PIB default attributes +#define IEEE154_DEFAULT_ASSOCIATEDPANCOORD FALSE +#define IEEE154_DEFAULT_ASSOCIATIONPERMIT FALSE +#define IEEE154_DEFAULT_AUTOREQUEST TRUE +#define IEEE154_DEFAULT_BATTLIFEEXT FALSE +#define IEEE154_DEFAULT_BATTLIFEEXTPERIODS 6 +#define IEEE154_DEFAULT_BEACONPAYLOAD NULL +#define IEEE154_DEFAULT_BEACONPAYLOADLENGTH 0 +#define IEEE154_DEFAULT_BEACONORDER 15 +#define IEEE154_DEFAULT_BEACONTXTIME 0 +#define IEEE154_DEFAULT_COORDSHORTADDRESS 0xFFFF +#define IEEE154_DEFAULT_GTSPERMIT TRUE +#define IEEE154_DEFAULT_MAXBE 5 +#define IEEE154_DEFAULT_MAXCSMABACKOFFS 4 +#define IEEE154_DEFAULT_MAXFRAMETOTALWAITTIME 2626 +#define IEEE154_DEFAULT_MAXFRAMERETRIES 3 +#define IEEE154_DEFAULT_MINBE 3 +#define IEEE154_DEFAULT_MINLIFSPERIOD 40 +#define IEEE154_DEFAULT_MINSIFSPERIOD 12 +#define IEEE154_DEFAULT_PANID 0xFFFF +#define IEEE154_DEFAULT_PROMISCUOUSMODE FALSE +#define IEEE154_DEFAULT_RESPONSEWAITTIME 32 +#define IEEE154_DEFAULT_RXONWHENIDLE FALSE +#define IEEE154_DEFAULT_SECURITYENABLED FALSE +#define IEEE154_DEFAULT_SHORTADDRESS 0xFFFF + +#define IEEE154_DEFAULT_SUPERFRAMEORDER 15 +#define IEEE154_DEFAULT_SYNCSYMBOLOFFSET 0 +#define IEEE154_DEFAULT_TIMESTAMPSUPPORTED TRUE +#define IEEE154_DEFAULT_TRANSACTIONPERSISTENCETIME 0x01F4 + +#define IEEE154_INVALID_TIMESTAMP (0xffffffff) + +#endif // __TKN154_PIB_H diff --git a/tos/lib/mac/tkn154/TransferClientP.nc b/tos/lib/mac/tkn154/TransferClientP.nc new file mode 100644 index 00000000..be6b4f25 --- /dev/null +++ b/tos/lib/mac/tkn154/TransferClientP.nc @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ +generic module TransferClientP(uint8_t myUserId) +{ + provides + { + interface ResourceTransfer; + interface ResourceTransferred; + interface ResourceTransferConnector as TransferredFrom; + } uses { + interface ResourceTransferConnector as TransferTo; + interface ResourceTransferControl; + interface Leds; + } +} +implementation +{ + async command error_t ResourceTransfer.transfer() + { + error_t result; + uint8_t toClient = call TransferTo.getUserId(); + atomic { + result = call ResourceTransferControl.transfer(myUserId, toClient); + if (result == SUCCESS) + call TransferTo.transfer(); + } + return result; + } + + async command uint8_t TransferredFrom.getUserId(){ return myUserId;} + + async command void TransferredFrom.transfer() + { + signal ResourceTransferred.transferred(); + } + + async command error_t ResourceTransferred.release() + { + return call ResourceTransferControl.release(myUserId); + } + default async command uint8_t TransferTo.getUserId(){ call Leds.led0On(); return 0xFF;} + default async command void TransferTo.transfer(){ call Leds.led0On(); } +} diff --git a/tos/lib/mac/tkn154/dummies/NoBeaconSynchronizeP.nc b/tos/lib/mac/tkn154/dummies/NoBeaconSynchronizeP.nc new file mode 100644 index 00000000..418c0a9d --- /dev/null +++ b/tos/lib/mac/tkn154/dummies/NoBeaconSynchronizeP.nc @@ -0,0 +1,131 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + + +#include "TKN154_MAC.h" + +module NoBeaconSynchronizeP +{ + provides + { + interface Init; + interface MLME_SYNC; + interface MLME_BEACON_NOTIFY; + interface MLME_SYNC_LOSS; + interface Get as IsTrackingBeacons; + interface Get as GetLastBeaconRxTime; + interface GetNow as CapStart; + interface GetNow as CapStartRefTime; + interface GetNow as CapLen; + interface GetNow as CapEnd; + interface GetNow as CfpEnd; + interface GetNow as CfpLen; + interface GetNow as BeaconInterval; + interface GetNow as IsBLEActive; + interface GetNow as BLELen; + interface GetNow as GtsField; + interface GetNow as SfSlotDuration; + interface GetNow as FinalCapSlot; + interface GetNow as NumGtsSlots; + interface GetNow as IsRxBroadcastPending; + } + uses + { + interface MLME_GET; + interface MLME_SET; + interface FrameUtility; + interface IEEE154BeaconFrame as BeaconFrame; + interface Alarm as TrackAlarm; + interface RadioRx as BeaconRx; + interface RadioOff; + interface Get as IsBeaconEnabledPAN; + interface DataRequest; + interface FrameRx as CoordRealignmentRx; + interface Resource as Token; + interface ResourceTransfer as TokenToCap; + interface ResourceTransferred as TokenTransferred; + interface GetNow as IsSendingBeacons; + interface TimeCalc; + interface IEEE154Frame as Frame; + interface Leds; + interface Ieee802154Debug as Debug; + } +} +implementation +{ + + command error_t Init.init() { return SUCCESS; } + + command ieee154_status_t MLME_SYNC.request ( + uint8_t logicalChannel, + uint8_t channelPage, + bool trackBeacon + ) + { + return IEEE154_TRANSACTION_OVERFLOW; + } + + event void Token.granted() { } + + async event void TokenTransferred.transferred() { call Token.release(); } + + async event void TrackAlarm.fired() {} + + async event void BeaconRx.prepareDone() {} + + event message_t* BeaconRx.received(message_t* frame, ieee154_reftime_t *timestamp) { return frame;} + + async event void RadioOff.offDone() {} + + command bool IsTrackingBeacons.get(){ return FALSE;} + command uint32_t GetLastBeaconRxTime.get(){ return 0;} + async command uint8_t* GtsField.getNow() { return 0; } + async command uint32_t SfSlotDuration.getNow() { return 0; } + async command uint8_t FinalCapSlot.getNow() { return 0; } + + event void DataRequest.pollDone(){} + async command uint32_t CapEnd.getNow() { return 0; } + async command uint32_t CapStart.getNow() { return 0; } + async command uint32_t CapLen.getNow() { return 0; } + async command uint32_t CfpEnd.getNow() { return 0; } + async command ieee154_reftime_t* CapStartRefTime.getNow() { return NULL; } + async command uint32_t CfpLen.getNow(){ return 0;} + async command uint32_t BeaconInterval.getNow(){ return 0;} + async command bool IsBLEActive.getNow(){ return 0;} + async command uint16_t BLELen.getNow(){ return 0;} + async command uint8_t NumGtsSlots.getNow() { return 0; } + async command bool IsRxBroadcastPending.getNow() { return FALSE; } + event message_t* CoordRealignmentRx.received(message_t* frame) {return frame;} +} diff --git a/tos/lib/mac/tkn154/dummies/NoBeaconTransmitP.nc b/tos/lib/mac/tkn154/dummies/NoBeaconTransmitP.nc new file mode 100644 index 00000000..50a8cb54 --- /dev/null +++ b/tos/lib/mac/tkn154/dummies/NoBeaconTransmitP.nc @@ -0,0 +1,215 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +#include "TKN154_MAC.h" +#include "TKN154_PHY.h" +module NoBeaconTransmitP +{ + provides + { + interface Init; + interface MLME_START; + interface WriteBeaconField as SuperframeSpecWrite; + interface Get as IsSendingBeacons; + interface GetNow as CapStart; + interface GetNow as CapStartRefTime; + interface GetNow as CapLen; + interface GetNow as CapEnd; + interface GetNow as CfpEnd; + interface GetNow as CfpLen; + interface GetNow as IsBLEActive; + interface GetNow as BLELen; + interface GetNow as GtsField; + interface GetNow as SfSlotDuration; + interface GetNow as BeaconInterval; + interface GetNow as FinalCapSlot; + interface GetNow as NumGtsSlots; + interface GetNow as BeaconFramePendingBit; + interface IEEE154TxBeaconPayload; + } uses { + interface Notify as GtsSpecUpdated; + interface Notify as PendingAddrSpecUpdated; + interface Notify as PIBUpdate[uint8_t attributeID]; + interface Alarm as BeaconTxAlarm; + interface Timer as BeaconPayloadUpdateTimer; + interface RadioOff; + interface Get as IsBeaconEnabledPAN; + interface RadioTx as BeaconTx; + interface MLME_GET; + interface MLME_SET; + interface Resource as Token; + interface ResourceTransfer as TokenToBroadcast; + interface FrameTx as RealignmentBeaconEnabledTx; + interface FrameTx as RealignmentNonBeaconEnabledTx; + interface FrameRx as BeaconRequestRx; + interface WriteBeaconField as GtsInfoWrite; + interface WriteBeaconField as PendingAddrWrite; + interface FrameUtility; + interface Get as IsTrackingBeacons; + interface GetNow as LastBeaconRxTime; + interface GetNow as LastBeaconRxRefTime; + interface Ieee802154Debug as Debug; + interface Set as SetMacSuperframeOrder; + interface Set as SetMacBeaconTxTime; + interface Set as SetMacPanCoordinator; + interface GetSet as GetSetRealignmentFrame; + interface GetNow as IsBroadcastReady; + interface TimeCalc; + interface Leds; + } +} +implementation +{ + command error_t Init.init() + { + return SUCCESS; + } + command ieee154_status_t MLME_START.request ( + uint16_t panID, + uint8_t logicalChannel, + uint8_t channelPage, + uint32_t startTime, + uint8_t beaconOrder, + uint8_t superframeOrder, + bool panCoordinator, + bool batteryLifeExtension, + bool coordRealignment, + ieee154_security_t *coordRealignSecurity, + ieee154_security_t *beaconSecurity) + { + return IEEE154_TRANSACTION_OVERFLOW; + } + + event void Token.granted() { } + + async event void RadioOff.offDone() { } + + async event void BeaconTxAlarm.fired() {} + + async event void BeaconTx.loadDone() {} + + async event void BeaconTx.transmitDone(ieee154_txframe_t *frame, + ieee154_reftime_t *referenceTime, bool pendingFlag, error_t error) { } + + command error_t IEEE154TxBeaconPayload.setBeaconPayload(void *beaconPayload, uint8_t length) { return ESIZE; } + + command const void* IEEE154TxBeaconPayload.getBeaconPayload() { return NULL; } + + command uint8_t IEEE154TxBeaconPayload.getBeaconPayloadLength() {return 0; } + + command error_t IEEE154TxBeaconPayload.modifyBeaconPayload(uint8_t offset, void *buffer, uint8_t bufferLength) + { + return ESIZE; + } + + event void PIBUpdate.notify[uint8_t attributeID](const void* attributeValue) + { + } + + event void PendingAddrSpecUpdated.notify(bool val) + { + } + + event void GtsSpecUpdated.notify(bool val) + { + } + + event void BeaconPayloadUpdateTimer.fired() + { + } + + command uint8_t SuperframeSpecWrite.write(uint8_t *superframeSpecField, uint8_t maxlen) + { + return 0; + } + + command uint8_t SuperframeSpecWrite.getLength() + { + return 0; + } + + event void RealignmentBeaconEnabledTx.transmitDone(ieee154_txframe_t *frame, ieee154_status_t status) + { + } + + event void RealignmentNonBeaconEnabledTx.transmitDone(ieee154_txframe_t *frame, ieee154_status_t status) + { + } + + event message_t* BeaconRequestRx.received(message_t* frame) + { + return frame; + } + + command bool IsSendingBeacons.get(){ return FALSE;} + + async command uint32_t CapStart.getNow() { return 0; } + async command ieee154_reftime_t* CapStartRefTime.getNow() { return NULL; } + async command uint32_t CapLen.getNow() { return 0;} + async command uint32_t CapEnd.getNow() + { + return 0; + } + async command uint32_t CfpEnd.getNow() + { + return 0; + } + async command uint32_t CfpLen.getNow() + { + return 0; + } + async command bool IsBLEActive.getNow(){ return FALSE;} + async command uint16_t BLELen.getNow(){ return 0;} + async command bool BeaconFramePendingBit.getNow(){ return FALSE;} + + async command uint8_t* GtsField.getNow() { return NULL; } + async command uint32_t SfSlotDuration.getNow() { return 0; } + async command uint32_t BeaconInterval.getNow() { return 0; } + async command uint8_t FinalCapSlot.getNow() { return 0; } + async command uint8_t NumGtsSlots.getNow() { return 0; } + + default event void MLME_START.confirm ( + ieee154_status_t status + ){} + + default event void IEEE154TxBeaconPayload.setBeaconPayloadDone(void *beaconPayload, uint8_t length){} + + default event void IEEE154TxBeaconPayload.modifyBeaconPayloadDone(uint8_t offset, void *buffer, uint8_t bufferLength){} + + default event void IEEE154TxBeaconPayload.aboutToTransmit(){} + + default event void IEEE154TxBeaconPayload.beaconTransmitted(){} + +} diff --git a/tos/lib/mac/tkn154/dummies/NoCapP.nc b/tos/lib/mac/tkn154/dummies/NoCapP.nc new file mode 100644 index 00000000..ba4f409a --- /dev/null +++ b/tos/lib/mac/tkn154/dummies/NoCapP.nc @@ -0,0 +1,123 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +#include "TKN154_PHY.h" +#include "TKN154_MAC.h" + +generic module NoCapP() +{ + provides + { + interface Init as Reset; + interface FrameTx as CapTx; + interface FrameRx as FrameRx[uint8_t frameType]; + interface FrameExtracted as FrameExtracted[uint8_t frameType]; + interface FrameTxNow as BroadcastTx; + interface Notify as WasRxEnabled; + } + uses + { + interface Random; + interface Alarm as CapEndAlarm; + interface Alarm as BLEAlarm; + interface Alarm as IndirectTxWaitAlarm; + interface Alarm as BroadcastAlarm; + interface Resource as Token; + interface ResourceTransfer as TokenToCfp; + interface ResourceTransferred as TokenTransferred; + interface ResourceRequested as TokenRequested; + interface GetNow as IsTokenRequested; + interface GetNow as CapStart; + interface GetNow as CapStartRefTime; + interface GetNow as CapLen; + interface GetNow as IsBLEActive; + interface GetNow as BLELen; + interface GetNow as IsRxEnableActive; + interface GetNow as IsRxBroadcastPending; + interface Notify as RxEnableStateChange; + interface FrameUtility; + interface RadioTx; + interface RadioRx; + interface RadioOff; + interface Get as IsBeaconEnabledPAN; + interface MLME_GET; + interface MLME_SET; + interface Ieee802154Debug as Debug; + interface TimeCalc; + interface Leds; + interface SetNow as FrameBackup; + interface GetNow as FrameRestore; + } +} +implementation +{ + command error_t Reset.init() + { + return SUCCESS; + } + + async event void TokenTransferred.transferred() + { + call TokenToCfp.transfer(); + } + + command ieee154_status_t CapTx.transmit(ieee154_txframe_t *frame) + { + return IEEE154_TRANSACTION_OVERFLOW; + } + + async event void RadioTx.loadDone(){ } + async event void RadioOff.offDone(){ } + async event void RadioRx.prepareDone(){ } + + async event void CapEndAlarm.fired(){ } + async event void BLEAlarm.fired(){ } + event void RxEnableStateChange.notify(bool x){ } + async event void BroadcastAlarm.fired(){ } + + async event void IndirectTxWaitAlarm.fired() { } + + async event void RadioTx.transmitDone(ieee154_txframe_t *frame, ieee154_reftime_t + *referenceTime, bool ackPendingFlag, error_t error) { } + + event message_t* RadioRx.received(message_t* frame, ieee154_reftime_t* referenceTime) { return frame; } + async command ieee154_status_t BroadcastTx.transmitNow(ieee154_txframe_t *frame){ return IEEE154_TRANSACTION_OVERFLOW; } + + async event void TokenRequested.requested() {} + async event void TokenRequested.immediateRequested() {} + event void Token.granted(){} + command error_t WasRxEnabled.enable(){return FAIL;} + command error_t WasRxEnabled.disable(){return FAIL;} +} diff --git a/tos/lib/mac/tkn154/dummies/NoCapQueueP.nc b/tos/lib/mac/tkn154/dummies/NoCapQueueP.nc new file mode 100644 index 00000000..7796ad16 --- /dev/null +++ b/tos/lib/mac/tkn154/dummies/NoCapQueueP.nc @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ +#include "TKN154_MAC.h" +generic module NoCapQueueP() +{ + provides + { + interface Init; + interface FrameTx[uint8_t client]; + interface FrameRx as FrameExtracted[uint8_t client]; + interface Purge; + } + uses + { + interface Queue; + interface FrameTx as CapTx; + interface FrameRx as SubFrameExtracted; + } +} +implementation +{ + command error_t Init.init() + { + return SUCCESS; + } + + command ieee154_status_t FrameTx.transmit[uint8_t client](ieee154_txframe_t *data) + { + return IEEE154_TRANSACTION_OVERFLOW; + } + + event void CapTx.transmitDone(ieee154_txframe_t *data, ieee154_status_t status) { } + + event message_t* SubFrameExtracted.received(message_t* frame) { return frame; } + + command ieee154_status_t Purge.purge(uint8_t msduHandle) { return IEEE154_INVALID_HANDLE; } +} diff --git a/tos/lib/mac/tkn154/dummies/NoCoordCfpP.nc b/tos/lib/mac/tkn154/dummies/NoCoordCfpP.nc new file mode 100644 index 00000000..145df15f --- /dev/null +++ b/tos/lib/mac/tkn154/dummies/NoCoordCfpP.nc @@ -0,0 +1,141 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +/** + * The contention free period (CFP) in beacon mode, a.k.a. GTS, is not yet + * implemented - this is only an empty placeholder. In contrast to the CAP + * component the GTS component for an incoming superframe will probably be very + * different from the GTS for an outgoing superframe. That is why there are two + * separate placeholder components (DeviceCfpP and CoordCfpP) instead of one + * generic CfpP component. This component would deal with the GTS for an + * outgoing superframe, i.e. from the perspective of a coordinator. + */ + +#include "TKN154_MAC.h" +module NoCoordCfpP +{ + provides { + interface Init; + interface WriteBeaconField as GtsInfoWrite; + interface FrameTx as CfpTx; + interface Purge; + } uses { + interface Resource as Token; + interface ResourceTransferred as TokenTransferred; + interface ResourceRequested as TokenRequested; + interface GetNow as CfpEnd; + interface GetNow as CapStartRefTime; + interface GetNow as GtsField; + interface GetNow as SfSlotDuration; + interface GetNow as FinalCapSlot; + interface Alarm as CfpSlotAlarm; + interface Alarm as CfpEndAlarm; + interface RadioTx; + interface RadioRx; + interface RadioOff; + interface MLME_GET; + interface MLME_SET; + } +} +implementation +{ + command error_t Init.init() + { + // initialize any module variables + return SUCCESS; + } + + command ieee154_status_t CfpTx.transmit(ieee154_txframe_t *data) + { + // send a frame in a GTS slot (triggered by MCPS_DATA.request()) + return IEEE154_INVALID_GTS; + } + + command ieee154_status_t Purge.purge(uint8_t msduHandle) + { + // request to purge a frame (triggered by MCPS_DATA.purge()) + return IEEE154_INVALID_HANDLE; + } + + async event void TokenTransferred.transferred() + { + // the CFP has started, this component now owns the token - + // because GTS is not implemented we release the token + // immediately; the general rule is: as long as a component + // owns the token it has exclusive access to the radio + call Token.release(); + } + + async event void CfpEndAlarm.fired() { } + + async event void CfpSlotAlarm.fired() {} + + async event void RadioOff.offDone() + { + call Token.release(); + } + + command uint8_t GtsInfoWrite.write(uint8_t *gtsSpecField, uint8_t maxlen) + { + // write the current GTS spec at the given address + if (call GtsInfoWrite.getLength() > maxlen) + return 0; + gtsSpecField[0] = 0; + return 1; + } + + command uint8_t GtsInfoWrite.getLength() + { + // returns the length of the current GTS spec + // must return the same value as GtsInfoWrite.write + return 1; + } + + async event void RadioTx.loadDone(){} + async event void RadioTx.transmitDone(ieee154_txframe_t *frame, + ieee154_reftime_t *referenceTime, bool ackPendingFlag, error_t error){} + + async event void RadioRx.prepareDone(){} + event message_t* RadioRx.received(message_t *frame, ieee154_reftime_t *timestamp){return frame;} + + async event void TokenRequested.requested() + { + // someone (e.g. SCAN component) requested access to the radio, + // you might want to release the token... + } + + async event void TokenRequested.immediateRequested(){ } + event void Token.granted(){ } +} diff --git a/tos/lib/mac/tkn154/dummies/NoDebugP.nc b/tos/lib/mac/tkn154/dummies/NoDebugP.nc new file mode 100644 index 00000000..229ae19f --- /dev/null +++ b/tos/lib/mac/tkn154/dummies/NoDebugP.nc @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ +#include "TKN154_DEBUG.h" +module NoDebugP +{ + provides + { + interface Ieee802154Debug[uint8_t client]; + } +} +implementation +{ + async command void Ieee802154Debug.log[uint8_t client]( + uint8_t priority, + uint8_t eventID, + uint32_t param1, + uint32_t param2, + uint32_t param3) + { + } + command void Ieee802154Debug.flush[uint8_t client](){} +} diff --git a/tos/lib/mac/tkn154/dummies/NoDeviceCapQueueP.nc b/tos/lib/mac/tkn154/dummies/NoDeviceCapQueueP.nc new file mode 100644 index 00000000..31c9a28f --- /dev/null +++ b/tos/lib/mac/tkn154/dummies/NoDeviceCapQueueP.nc @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ +#include "TKN154_MAC.h" +module NoDeviceCapQueueP +{ + provides + { + interface Init; + interface FrameTx[uint8_t client]; + interface FrameRx as FrameExtracted[uint8_t client]; + interface Purge; + } + uses + { + interface Queue; + interface FrameTx as DeviceCapTx; + interface FrameRx as SubFrameExtracted; + } +} +implementation +{ + command error_t Init.init() { return SUCCESS; } + + command ieee154_status_t FrameTx.tx[uint8_t client](ieee154_txframe_t *data) { return TRANSACTION_OVERFLOW; } + + event void DeviceCapTx.transmitDone(ieee154_txframe_t *data, ieee154_status_t status) { } + + event message_t* SubFrameExtracted.received(message_t* data) { return data; } + + command ieee154_status_t Purge.purge(uint8_t msduHandle) { return INVALID_HANDLE; } +} diff --git a/tos/lib/mac/tkn154/dummies/NoDeviceCfpP.nc b/tos/lib/mac/tkn154/dummies/NoDeviceCfpP.nc new file mode 100644 index 00000000..f8761ad3 --- /dev/null +++ b/tos/lib/mac/tkn154/dummies/NoDeviceCfpP.nc @@ -0,0 +1,124 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +/** + * The contention free period (CFP) in beacon mode, a.k.a. GTS, is not yet + * implemented - this is only an empty placeholder. In contrast to the CAP + * component the GTS component for an incoming superframe will probably be very + * different from the GTS for an outgoing superframe. That is why there are two + * separate placeholder components (DeviceCfpP and CoordCfpP) instead of one + * generic CfpP component. This component would deal with the GTS for an + * incoming superframe, i.e. from the perspective of a device. + */ + +#include "TKN154_MAC.h" +module NoDeviceCfpP +{ + provides { + interface Init; + interface FrameTx as CfpTx; + interface Purge; + } uses { + interface Resource as Token; + interface ResourceTransferred as TokenTransferred; + interface ResourceRequested as TokenRequested; + interface GetNow as CapStartRefTime; + interface GetNow as CfpEnd; + interface GetNow as GtsField; + interface GetNow as SfSlotDuration; + interface GetNow as FinalCapSlot; + interface Alarm as CfpSlotAlarm; + interface Alarm as CfpEndAlarm; + interface RadioTx; + interface RadioRx; + interface RadioOff; + interface MLME_GET; + interface MLME_SET; + } +} +implementation +{ + command error_t Init.init() + { + // initialize any module variables + return SUCCESS; + } + + command ieee154_status_t CfpTx.transmit(ieee154_txframe_t *data) + { + // request to send a frame in a GTS slot (triggered by MCPS_DATA.request()) + return IEEE154_INVALID_GTS; + } + + command ieee154_status_t Purge.purge(uint8_t msduHandle) + { + // request to purge a frame (triggered by MCPS_DATA.purge()) + return IEEE154_INVALID_HANDLE; + } + + async event void TokenTransferred.transferred() + { + // the CFP has started, this component now owns the token - + // because GTS is not implemented we release the token + // immediately; the general rule is: as long as a component + // owns the token it has exclusive access to the radio + call Token.release(); + } + + async event void CfpEndAlarm.fired() { } + + async event void CfpSlotAlarm.fired() {} + + async event void RadioOff.offDone() + { + call Token.release(); + } + + async event void RadioTx.loadDone(){} + async event void RadioTx.transmitDone(ieee154_txframe_t *frame, + ieee154_reftime_t *referenceTime, bool ackPendingFlag, error_t error){} + + async event void RadioRx.prepareDone(){} + event message_t* RadioRx.received(message_t *frame, ieee154_reftime_t *timestamp){return frame;} + + async event void TokenRequested.requested() + { + // someone requested access to the radio, you might + // consider releasing it... + } + + async event void TokenRequested.immediateRequested(){ } + event void Token.granted(){ } +} diff --git a/tos/lib/mac/tkn154/dummies/NoScanP.nc b/tos/lib/mac/tkn154/dummies/NoScanP.nc new file mode 100644 index 00000000..38a7697a --- /dev/null +++ b/tos/lib/mac/tkn154/dummies/NoScanP.nc @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +#include "TKN154_MAC.h" + +module NoScanP +{ + provides + { + interface Init; + interface MLME_SCAN; + interface MLME_BEACON_NOTIFY; + } + uses + { + interface MLME_GET; + interface MLME_SET; + interface EnergyDetection; + interface RadioOff; + interface RadioRx; + interface RadioTx; + interface IEEE154Frame as Frame; + interface IEEE154BeaconFrame as BeaconFrame; + interface Timer as ScanTimer; + interface Pool as TxFramePool; + interface Pool as TxControlPool; + interface Resource as Token; + interface FrameUtility; + interface Leds; + } +} +implementation +{ + + command error_t Init.init() { return SUCCESS;} + + command ieee154_status_t MLME_SCAN.request ( + uint8_t ScanType, + uint32_t ScanChannels, + uint8_t ScanDuration, + uint8_t ChannelPage, + uint8_t EnergyDetectListNumEntries, + int8_t* EnergyDetectList, + uint8_t PANDescriptorListNumEntries, + ieee154_PANDescriptor_t* PANDescriptorList, + ieee154_security_t *security + ) + { + return IEEE154_TRANSACTION_OVERFLOW; + } + + event void Token.granted() + { + call Token.release(); + } + + event void EnergyDetection.done(error_t status, int8_t EnergyLevel){} + + async event void RadioRx.prepareDone() { } + + event message_t* RadioRx.received(message_t *frame, ieee154_reftime_t *time) + { + return frame; + } + + async event void RadioTx.loadDone() { } + + async event void RadioTx.transmitDone(ieee154_txframe_t *frame, ieee154_reftime_t *t0, + bool ackPendingFlag, error_t error){} + + event void ScanTimer.fired() { } + + async event void RadioOff.offDone() { } +} diff --git a/tos/lib/mac/tkn154/interfaces/MCPS/MCPS_DATA.nc b/tos/lib/mac/tkn154/interfaces/MCPS/MCPS_DATA.nc new file mode 100644 index 00000000..58709438 --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/MCPS/MCPS_DATA.nc @@ -0,0 +1,102 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author: Jan Hauer + * ======================================================================== + */ + +#include "TKN154.h" +#include + +interface MCPS_DATA +{ + + /** + * "The MCPS-DATA.request primitive requests the transfer of a data + * SPDU (i.e., MSDU) from a local SSCS entity to a single peer SSCS + * entity." (IEEE 802.15.4-2006, Sec. 7.1.1.1) + * + * The MSDU is the payload portion of a message_t (frame<\code> + * parameter) and can be accessed through the IEEE154Frame<\code> + * interface. In contrast to the standard interface definition address + * information is not passed as separate parameters; instead, the + * address information is already part of the frame<\code>, + * i.e. it must have been set (through the IEEE154Frame<\code> + * interface) before this command is called. + * + * If this command returns IEEE154_SUCCESS, then the confirm event + * will be signalled in the future; otherwise, the confirm event + * will not be signalled. + * + * @param frame The frame to send + * @param payloadLen The length of the frame payload + * @param msduHandle Handle associated with the frame to be transmitted + * @param TxOptions Bitwised OR transmission options + * + * @return IEEE154_SUCCESS if the request succeeded and a confirm event + * will be signalled, an appropriate error code otherwise + * (no confirm event will be signalled in this case) + * @see confirm + */ + + command ieee154_status_t request ( + message_t *frame, + uint8_t payloadLen, + uint8_t msduHandle, + uint8_t TxOptions + ); + + /** + * Confirm reports the results of a request to transfer a frame to a + * peer SSCS entity. + * + * @param frame The frame which was requested to send + * @param msduHandle The handle associated with the frame + * @param status The status of the last MSDU transmission + * @param timestamp Time of transmission (invalid if status is + * not IEEE154_SUCCESS) + */ + event void confirm ( + message_t *frame, + uint8_t msduHandle, + ieee154_status_t status, + uint32_t Timestamp + ); + + /** + * Indicates the arrival of a frame. Address information can be accessed + * through the IEEE154Frame<\code> interface. + * + * @return A frame buffer for the stack to use for the next received frame + */ + event message_t* indication ( message_t* frame ); + +} diff --git a/tos/lib/mac/tkn154/interfaces/MCPS/MCPS_PURGE.nc b/tos/lib/mac/tkn154/interfaces/MCPS/MCPS_PURGE.nc new file mode 100644 index 00000000..c598a15f --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/MCPS/MCPS_PURGE.nc @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author: Jan Hauer + * ======================================================================== + */ + +#include "TKN154.h" + +interface MCPS_PURGE { + + /** + * Request to purge a frame from the transaction queue. + * The result will be returned immediately (there + * is no confirm event for this command). + * + * @param msduHandle The handle of the frame to be purged from the + * transaction queue + * @return IEEE154_SUCCESS if the request succeeded, an + * appropriate error code otherwise + */ + command ieee154_status_t request ( + uint8_t msduHandle + ); +} diff --git a/tos/lib/mac/tkn154/interfaces/MLME/MLME_ASSOCIATE.nc b/tos/lib/mac/tkn154/interfaces/MLME/MLME_ASSOCIATE.nc new file mode 100644 index 00000000..ce135fda --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/MLME/MLME_ASSOCIATE.nc @@ -0,0 +1,120 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author: Jan Hauer + * ======================================================================== + */ + +#include "TKN154.h" + +interface MLME_ASSOCIATE { + + /** + * Requests to associate with a PAN. + * + * @param LogicalChannel The logical channel on which to attempt + * association + * @param ChannelPage The channel page on which to attempt association + * @param CoordAddrMode The coordinator addressing mode + * @param CoordPANID The 16 bit PAN identifier of the coordinator + * @param CoordAddress Individual device address of the coordinator as + * per the CoordAddrMode + * @param CapabilityInformation Specifies the operational capabilities + * of the associating device + * @param security The security options (NULL means security is + * disabled) + * @return IEEE154_SUCCESS if the request succeeded and a confirm event + * will be signalled, an appropriate error code otherwise + * (no confirm event will be signalled in this case) + * @see confirm + */ + command ieee154_status_t request ( + uint8_t LogicalChannel, + uint8_t ChannelPage, + uint8_t CoordAddrMode, + uint16_t CoordPANID, + ieee154_address_t CoordAddress, + ieee154_CapabilityInformation_t CapabilityInformation, + ieee154_security_t *security + ); + + /** + * Notification that a device has requested to associate with a PAN. + * + * @param DeviceAddress the 64-bit address of the requesting device + * @param CapabilityInformation Specifies the operational capabilities + * of the associating device + * @param security The security options (NULL means security is + * disabled) + */ + event void indication ( + uint64_t DeviceAddress, + ieee154_CapabilityInformation_t CapabilityInformation, + ieee154_security_t *security + ); + + /** + * Send a response to a device's request to associate + * + * @param DeviceAddress The 64-bit address of the device to respond to + * @param AssocShortAddress The short device address allocated by the + * coordinator on successful allocation. + * @param status The status of the association attempt + * @param security The security options (NULL means security is + * disabled) + * @return IEEE154_SUCCESS if the request succeeded and an indication event + * will be signalled through the MLME_COMM_STATUS interface later, + * otherwise an appropriate error code (no MLME_COMM_STATUS.indication + * event will be signalled in this case) + */ + command ieee154_status_t response ( + uint64_t DeviceAddress, + uint16_t AssocShortAddress, + ieee154_association_status_t status, + ieee154_security_t *security + ); + + /** + * Confirmation of the association attempt. + * + * @param AssocShortAddress The short device address allocated by the + * coordinator on successful association + * @param status The status of the association attempt + * @param security The security options, NULL means security is + * disabled + */ + event void confirm ( + uint16_t AssocShortAddress, + uint8_t status, + ieee154_security_t *security + ); + +} diff --git a/tos/lib/mac/tkn154/interfaces/MLME/MLME_BEACON_NOTIFY.nc b/tos/lib/mac/tkn154/interfaces/MLME/MLME_BEACON_NOTIFY.nc new file mode 100644 index 00000000..c7e81d94 --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/MLME/MLME_BEACON_NOTIFY.nc @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author: Jan Hauer + * ======================================================================== + */ + +#include "TKN154.h" +#include +interface MLME_BEACON_NOTIFY { + + /** + * A beacon frame has been received. This event is signalled only if + * either the PIB attribute macAutoRequest is set to FALSE or the + * beacon payload is not empty. + * + * The beacon parameters can be accessed through the + * IEEE154BeaconFrame<\code> interface. The + * IEEE154Frame<\code> interface can be used to + * inspect the addressing fields in the MAC header. + * + * @param beacon The beacon frame + * @return A frame buffer for the stack to use for the next received frame + */ + event message_t* indication ( message_t *beaconFrame ); +} diff --git a/tos/lib/mac/tkn154/interfaces/MLME/MLME_COMM_STATUS.nc b/tos/lib/mac/tkn154/interfaces/MLME/MLME_COMM_STATUS.nc new file mode 100644 index 00000000..e435e30c --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/MLME/MLME_COMM_STATUS.nc @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author: Jan Hauer + * ======================================================================== + */ + +#include "TKN154.h" +interface MLME_COMM_STATUS { + + /** + * Allows the MLME to indicate a communications status. + * + * @param PanID The 16-bit PAN identifier of the device from which the + * frame was received or to which the frame was being sent + * @param SrcAddrMode The source addressing mode + * @param SrcAddr Individual device address of the source as per SrcAddrMode + * @param DstAddrMode The destination addressing mode + * @param DstAddr Individual device address of the destination + * as per DstAddrMode + * @param status The communications status + * @param security The security options, NULL means security is + * disabled + */ + event void indication ( + uint16_t PANId, + uint8_t SrcAddrMode, + ieee154_address_t SrcAddr, + uint8_t DstAddrMode, + ieee154_address_t DstAddr, + ieee154_status_t status, + ieee154_security_t *security + ); +} diff --git a/tos/lib/mac/tkn154/interfaces/MLME/MLME_DISASSOCIATE.nc b/tos/lib/mac/tkn154/interfaces/MLME/MLME_DISASSOCIATE.nc new file mode 100644 index 00000000..9602ba3d --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/MLME/MLME_DISASSOCIATE.nc @@ -0,0 +1,102 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author: Jan Hauer + * ======================================================================== + */ + +#include "TKN154.h" +interface MLME_DISASSOCIATE { + + /** + * Request disassociation from a PAN. + * + * @param DeviceAddrMode The addressing mode of the device to which to send + * the disassociation notification command. + * @param DevicePANID The PAN identifier of the device to which to send the + * disassociation notification command. + * @param DeviceAddress The address of the device to which to send the + * disassociation notification command + * @param DisassociateReason The reason for the disassociation + * @param TxIndirect TRUE if disassociation notification command is to be sent + * indirectly + * @param security The security options (NULL means security is + * disabled) + * @return IEEE154_SUCCESS if the request succeeded and a confirm event + * will be signalled, an appropriate error code otherwise + * (no confirm event will be signalled in this case) + * @see confirm + */ + command ieee154_status_t request ( + uint8_t DeviceAddrMode, + uint16_t DevicePANID, + ieee154_address_t DeviceAddress, + ieee154_disassociation_reason_t DisassociateReason, + bool TxIndirect, + ieee154_security_t *security + ); + + /** + * Signals that a device has requested disassociation. + * + * @param DeviceAddress the 64-bit address of the requesting device + * @param DisassociateReason Reason for the disassociation + * @param security The security options (NULL means security is + * disabled) + */ + event void indication ( + uint64_t DeviceAddress, + ieee154_disassociation_reason_t DisassociateReason, + ieee154_security_t *security + ); + + /** + * Confirmation of the disassociation attempt. + * + * @param status The status of the disassociation attempt + * @param DeviceAddrMode The addressing mode of the device that has either + * requested disassociation or been instructed to + * disassociate by its coordinator. + * @param DevicePANID The PAN identifier of the device that has either + * requested disassociation or been instructed to + * disassociate by its coordinator. + * @param DeviceAddress The address of the device that has either requested + * disassociation or been instructed to disassociate + * by its coordinator. + */ + event void confirm ( + ieee154_status_t status, + uint8_t DeviceAddrMode, + uint16_t DevicePANID, + ieee154_address_t DeviceAddress + ); + +} diff --git a/tos/lib/mac/tkn154/interfaces/MLME/MLME_GET.nc b/tos/lib/mac/tkn154/interfaces/MLME/MLME_GET.nc new file mode 100644 index 00000000..73783230 --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/MLME/MLME_GET.nc @@ -0,0 +1,166 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +/** + * This interface can be used to read attribute values from the PHY/MAC PIB. + * Instead of passing the PIB attribute identifier, there is a separate + * command per attribute (and there are no confirm events). + * + * NOTE: for the attributes macBeaconPayload (0x45) and + * macBeaconPayloadLength (0x46) use the IEEE154TxBeaconPayload <\code> + * interface; for promiscuous mode there is a separate (SplitControl) + * interface. + **/ + +#include "TKN154.h" +interface MLME_GET { + + /** @return PIB attribute phyCurrentChannel (0x00) */ + command ieee154_phyCurrentChannel_t phyCurrentChannel(); + + /** @return PIB attribute phyChannelsSupported (0x01) */ + command ieee154_phyChannelsSupported_t phyChannelsSupported(); + + /** @return PIB attribute phyTransmitPower (0x02) */ + command ieee154_phyTransmitPower_t phyTransmitPower(); + + /** @return PIB attribute phyCCAMode (0x03) */ + command ieee154_phyCCAMode_t phyCCAMode(); + + /** @return PIB attribute phyCurrentPage (0x04) */ + command ieee154_phyCurrentPage_t phyCurrentPage(); + + /** @return PIB attribute phyMaxFrameDuration (0x05) */ + command ieee154_phyMaxFrameDuration_t phyMaxFrameDuration(); + + /** @return PIB attribute phySHRDuration (0x06) */ + command ieee154_phySHRDuration_t phySHRDuration(); + + /** @return PIB attribute phySymbolsPerOctet (0x07) */ + command ieee154_phySymbolsPerOctet_t phySymbolsPerOctet(); + + /** @return PIB attribute macAckWaitDuration (0x40) */ + command ieee154_macAckWaitDuration_t macAckWaitDuration(); + + /** @return PIB attribute macAssociationPermit (0x41) */ + command ieee154_macAssociationPermit_t macAssociationPermit(); + + /** @return PIB attribute macAutoRequest (0x42) */ + command ieee154_macAutoRequest_t macAutoRequest(); + + /** @return PIB attribute macBattLifeExt (0x43) */ + command ieee154_macBattLifeExt_t macBattLifeExt(); + + /** @return PIB attribute macBattLifeExtPeriods (0x44) */ + command ieee154_macBattLifeExtPeriods_t macBattLifeExtPeriods(); + + /* macBeaconPayload (0x45) and macBeaconPayloadLength (0x46) are read + * through the IEEE154TxBeaconPayload<\code> interface. */ + + /** @return PIB attribute macBeaconOrder (0x47) */ + command ieee154_macBeaconOrder_t macBeaconOrder(); + + /** @return PIB attribute macBeaconTxTime (0x48) */ + command ieee154_macBeaconTxTime_t macBeaconTxTime(); + + /** @return PIB attribute macBSN (0x49) */ + command ieee154_macBSN_t macBSN(); + + /** @return PIB attribute macCoordExtendedAddress (0x4A) */ + command ieee154_macCoordExtendedAddress_t macCoordExtendedAddress(); + + /** @return PIB attribute macCoordShortAddress (0x4B) */ + command ieee154_macCoordShortAddress_t macCoordShortAddress(); + + /** @return PIB attribute macDSN (0x4C) */ + command ieee154_macDSN_t macDSN(); + + /** @return PIB attribute macGTSPermit (0x4D) */ + command ieee154_macGTSPermit_t macGTSPermit(); + + /** @return PIB attribute macMaxCSMABackoffs (0x4E) */ + command ieee154_macMaxCSMABackoffs_t macMaxCSMABackoffs(); + + /** @return PIB attribute macMinBE (0x4F) */ + command ieee154_macMinBE_t macMinBE(); + + /** @return PIB attribute macPANId (0x50) */ + command ieee154_macPANId_t macPANId(); + + /** @return PIB attribute macPromiscuousMode (0x51) */ + command ieee154_macPromiscuousMode_t macPromiscuousMode(); + + /** @return PIB attribute macRxOnWhenIdle (0x52) */ + command ieee154_macRxOnWhenIdle_t macRxOnWhenIdle(); + + /** @return PIB attribute macShortAddress (0x53) */ + command ieee154_macShortAddress_t macShortAddress(); + + /** @return PIB attribute macSuperframeOrder (0x54) */ + command ieee154_macSuperframeOrder_t macSuperframeOrder(); + + /** @return PIB attribute macTransactionPersistenceTime (0x55) */ + command ieee154_macTransactionPersistenceTime_t macTransactionPersistenceTime(); + + /** @return PIB attribute macAssociatedPANCoord (0x56) */ + command ieee154_macAssociatedPANCoord_t macAssociatedPANCoord(); + + /** @return PIB attribute macMaxBE (0x57) */ + command ieee154_macMaxBE_t macMaxBE(); + + /** @return PIB attribute macMaxFrameTotalWaitTime (0x58) */ + command ieee154_macMaxFrameTotalWaitTime_t macMaxFrameTotalWaitTime(); + + /** @return PIB attribute macMaxFrameRetries (0x59) */ + command ieee154_macMaxFrameRetries_t macMaxFrameRetries(); + + /** @return PIB attribute macResponseWaitTime (0x5A) */ + command ieee154_macResponseWaitTime_t macResponseWaitTime(); + + /** @return PIB attribute macSyncSymbolOffset (0x5B) */ + command ieee154_macSyncSymbolOffset_t macSyncSymbolOffset(); + + /** @return PIB attribute macTimestampSupported (0x5C) */ + command ieee154_macTimestampSupported_t macTimestampSupported(); + + /** @return PIB attribute macSecurityEnabled (0x5D) */ + command ieee154_macSecurityEnabled_t macSecurityEnabled(); + + /** @return PIB attribute macMinLIFSPeriod */ + command ieee154_macMinLIFSPeriod_t macMinLIFSPeriod(); + + /** @return PIB attribute macMinSIFSPeriod */ + command ieee154_macMinSIFSPeriod_t macMinSIFSPeriod(); +} diff --git a/tos/lib/mac/tkn154/interfaces/MLME/MLME_GTS.nc b/tos/lib/mac/tkn154/interfaces/MLME/MLME_GTS.nc new file mode 100644 index 00000000..d90bbe57 --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/MLME/MLME_GTS.nc @@ -0,0 +1,86 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +#include "TKN154.h" +interface MLME_GTS { + + /** + * Request allocation of a new GTS or deallocation from the PAN + * coordinator. + * + * @param GtsCharacteristics The characteristics of the GTS request + * @param security The security options (NULL means security is + * disabled) + * @return IEEE154_SUCCESS if the request succeeded and a confirm event + * will be signalled, an appropriate error code otherwise + * (no confirm event will be signalled in this case) + * @see confirm + */ + command ieee154_status_t request ( + uint8_t GtsCharacteristics, + ieee154_security_t *security + ); + + /** + * Reports the results of a request to allocated a new GTS or + * deallocate an existing GTS + * + * @param GtsCharacteristics The characteristics of the GTS request + * @param status The status of the GTS request + */ + event void confirm ( + uint8_t GtsCharacteristics, + ieee154_status_t status + ); + + /** + * Indicates that a GTS has been allocated or that a previously allocated + * GTS has been deallocated + * + * All pointers are valid only until the return of this event. + * + * @param DeviceAddress Short address of the device that has been allocated + * or deallocated a GTS + * @param GtsCharacteristics The characteristics of the GTS request + * @param security The security options, NULL means security is + * disabled + */ + event void indication ( + uint16_t DeviceAddress, + uint8_t GtsCharacteristics, + ieee154_security_t *security + ); + +} diff --git a/tos/lib/mac/tkn154/interfaces/MLME/MLME_ORPHAN.nc b/tos/lib/mac/tkn154/interfaces/MLME/MLME_ORPHAN.nc new file mode 100644 index 00000000..5f9aca89 --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/MLME/MLME_ORPHAN.nc @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +#include "TKN154.h" +interface MLME_ORPHAN { + + /** + * Allows the MLME of a coordinator to notify the next higher layer of the + * presence of an orphaned device + * + * @param OrphanAddress The 64-bit extended address of the orphaned device + * @param security The security options (NULL means security is + * disabled) + */ + event void indication ( + uint64_t OrphanAddress, + ieee154_security_t *security + ); + + /** + * Allows the next higher layer of a coordinator to respond to the + * indication primitive + * + * @param OrphanAddres The 64-bit extended address of the orphaned device + * @param ShortAddress The 16-bit short address allocated to the orphaned + * device if it is associated with this coordinator. The + * special short address 0xfffe indicates that no short + * address was allocated, and the device will use its + * 64-bit extended address in all communications. If the + * device was not associated with this coordinator, this + * field will contain the value 0xffff and be ignored on + * receipt. + * @param AssociatedMember TRUE if the orphaned device is associated + * with this coordinator + * @param security The security options (NULL means security is + * disabled) + * @return IEEE154_SUCCESS if the request succeeded and an indication event + * will be signalled through the MLME_COMM_STATUS interface later, + * otherwise an appropriate error code (no MLME_COMM_STATUS.indication + * event will be signalled in this case) + */ + command ieee154_status_t response ( + uint64_t OrphanAddres, + uint16_t ShortAddress, + bool AssociatedMember, + ieee154_security_t *security + ); +} diff --git a/tos/lib/mac/tkn154/interfaces/MLME/MLME_POLL.nc b/tos/lib/mac/tkn154/interfaces/MLME/MLME_POLL.nc new file mode 100644 index 00000000..77a801a7 --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/MLME/MLME_POLL.nc @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ +#include "TKN154.h" + +interface MLME_POLL { + + /** + * Prompts the device to request data from the coordinator. + * + * @param CoordAddrMode The addressing mode of the coordinator to which + * the poll is intended + * @param CoordPANID The PAN identifier of the coordinator to which the + * poll is intended + * @param CoordAddress The address of the coordinator to which the + * poll is intended + * @param security The security options (NULL means security is + * disabled) + * @return IEEE154_SUCCESS if the request succeeded and a confirm event + * will be signalled, an appropriate error code otherwise + * (no confirm event will be signalled in this case) + * @see confirm + */ + command ieee154_status_t request ( + uint8_t CoordAddrMode, + uint16_t CoordPANID, + ieee154_address_t CoordAddress, + ieee154_security_t *security + ); + + /** + * Reports the results of a request to poll the coordinator for data + * + * @param status The status of the data request + */ + event void confirm ( + ieee154_status_t status + ); + +} diff --git a/tos/lib/mac/tkn154/interfaces/MLME/MLME_RESET.nc b/tos/lib/mac/tkn154/interfaces/MLME/MLME_RESET.nc new file mode 100644 index 00000000..480a1b90 --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/MLME/MLME_RESET.nc @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +#include "TKN154.h" +interface MLME_RESET { + + /** + * Allows the next higher layer to request that the MLME performs a + * reset operation. This command initializes the MAC and must be called + * before calling any other MAC primitive. It extends the standard + * interface definition by a parameter PANType, which defines + * whether the device/coordinator will operate on a beacon-enabled PAN + * or on a nonbeacon-enabled PAN. + * + * Two things are important: + * (1) This command will fail while promiscuous mode is enabled + * (promiscuous mode is controlled through a separate SplitControl + * interface). (2) While the MLME_RESET.confirm is pending the next + * higher layer MUST NOT call any MAC commands; if there are any + * other pending request the MAC will signal their corresponding confirm + * events before MLME_RESET.confirm is signalled (with a status code of + * IEEE154_TRANSACTION_OVERFLOW). + * + * @param SetDefaultPIB If TRUE, the MAC sublayer is reset and all MAC PIB + * attributes are set to their default values. If + * FALSE, the MAC sublayer is reset but all MAC PIB + * attributes retain their values prior to the + * generation of the reset primitive. + * @param PANType Either BEACON_ENABLED_PAN for beacon-enabled PANs + * or NONBEACON_ENABLED_PAN for nonbeacon-enabled PANs + * + * @return IEEE154_SUCCESS if the request succeeded and a confirm event + * will be signalled, an appropriate error code otherwise + * (no confirm event will be signalled in this case) + * + */ + command ieee154_status_t request ( + bool SetDefaultPIB, + uint8_t PANType + ); + + /** + * Reports the results of the reset operation + * + * @param status The status of the reset operation + */ + event void confirm ( + ieee154_status_t status + ); + +} diff --git a/tos/lib/mac/tkn154/interfaces/MLME/MLME_RX_ENABLE.nc b/tos/lib/mac/tkn154/interfaces/MLME/MLME_RX_ENABLE.nc new file mode 100644 index 00000000..7abdb3f6 --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/MLME/MLME_RX_ENABLE.nc @@ -0,0 +1,73 @@ + +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +#include "TKN154.h" +interface MLME_RX_ENABLE { + + /** + * Allows the next higher layer to request that the receiver is + * enabled for a finite period of time + * + * @param DeferPermit TRUE if the receiver enable can be deferred until + * during the next superframe if the requested time has + * already passed + * @param RxOnTime The number of symbols from the start of the superframe + * before the receiver is to be enabled. The precision + * of this value is a minimum of 20 bits. This parameter + * is ignored for nonbeacon-enabled PANs + * @param RxOnDuration The number of symbols for which the receiver + * is to be enabled + * @return IEEE154_SUCCESS if the request succeeded and a confirm event + * will be signalled, an appropriate error code otherwise + * (no confirm event will be signalled in this case) + * @see confirm + */ + command ieee154_status_t request ( + bool DeferPermit, + uint32_t RxOnTime, + uint32_t RxOnDuration + ); + + /** + * Reports the results of the attempt to enable the receiver + * + * @param status The status of the receiver enable request + */ + event void confirm ( + ieee154_status_t status + ); + +} diff --git a/tos/lib/mac/tkn154/interfaces/MLME/MLME_SCAN.nc b/tos/lib/mac/tkn154/interfaces/MLME/MLME_SCAN.nc new file mode 100644 index 00000000..551e35d6 --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/MLME/MLME_SCAN.nc @@ -0,0 +1,123 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +#include "TKN154.h" +interface MLME_SCAN +{ + + /** + * Initializes a channel scan over a given list of channels. + * + * If the PIB attribute macAutoRequest is set to FALSE, then + * for each received beacon a PAN descriptor is signalled to the next higher + * layer through a separate MLME_BEACON_NOTIFY.indication() + * event; otherwise the result of the channel scan is stored in a user + * allocated buffer, either EnergyDetectList or + * PANDescriptorList depending on ScanType, and the + * buffer is returned when the scan is completed. + * + * Both of the parameters EnergyDetectList and + * PANDescriptorList may be NULL, but at least one of them + * must be NULL. + * + * @param ScanType The type of scan performed: ENERGY_DETECTION_SCAN, + * ACTIVE_SCAN, PASSIVE_SCAN or ORPHAN_SCAN + * @param ScanChannels The 27 LSBs indicate which channels are to be + * scanned (1 = scan, 0 = don't scan) + * @param ScanDuration Value used to calculate the length of time to + * spend scanning each channel for ED, active, and + * passive scans. This parameter is ignored for + * orphan scans. + * @param ChannelPage The channel page on which to perform the scan + * @param EnergyDetectListNumEntries The number of entries in the + * EnergyDetectList. + * @param EnergyDetectList An empty buffer (allocated by the caller) + * to store the result of the energy measurements + * or NULL if the result should not be stored + * @param PANDescriptorListNumEntries The number of entries in the + * PANDescriptorList. + * @param PANDescriptorList An empty buffer (allocated by the caller) + * to store the result of the active/passive scan + * or NULL if the result should not be stored + * @param security The security options (NULL means security is + * disabled) + * @return IEEE154_SUCCESS if the request succeeded and a confirm event + * will be signalled, an appropriate error code otherwise + * (no confirm event will be signalled in this case) + * @see confirm + */ + command ieee154_status_t request ( + uint8_t ScanType, + uint32_t ScanChannels, + uint8_t ScanDuration, + uint8_t ChannelPage, + uint8_t EnergyDetectListNumEntries, + int8_t* EnergyDetectList, + uint8_t PANDescriptorListNumEntries, + ieee154_PANDescriptor_t* PANDescriptorList, + ieee154_security_t *security + ); + + /** + * Reports the results of the channel scan request, returning + * the buffers passed in the request command. + * + * @param status The status of the scan request + * @param ScanType The type of scan performed + * @param ChannelPage The channel page on which the scan + * was performed (see 6.1.2). + * @param UnscannedChannels The 27 LSBs indicate which channels are not + * scanned (0 = scanned, 1 = not scanned) + * @param EnergyDetectNumResults The number of valid entries in the + * EnergyDetectList. + * @param EnergyDetectList The buffer list of energy measurements, one for + * each channel searched during an ED scan + @param PANDescriptorListNumResults The number of valid entries in the + * PANDescriptorList. + * @param PANDescriptorList The list of PAN descriptors, one for each + * unique beacon found during an active or passive scan + */ + event void confirm ( + ieee154_status_t status, + uint8_t ScanType, + uint8_t ChannelPage, + uint32_t UnscannedChannels, + uint8_t EnergyDetectNumResults, + int8_t* EnergyDetectList, + uint8_t PANDescriptorListNumResults, + ieee154_PANDescriptor_t* PANDescriptorList + ); + +} diff --git a/tos/lib/mac/tkn154/interfaces/MLME/MLME_SET.nc b/tos/lib/mac/tkn154/interfaces/MLME/MLME_SET.nc new file mode 100644 index 00000000..b2ba46ee --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/MLME/MLME_SET.nc @@ -0,0 +1,187 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + + +/** + * This interface can be used to set attribute values in the PHY/MAC PIB. + * Instead of passing the PIB attribute identifier, there is a separate + * command per attribute (and there are no confirm events). + * + * NOTE: for the attributes macBeaconPayload (0x45) and + * macBeaconPayloadLength (0x46) use the IEEE154TxBeaconPayload <\code> + * interface; for promiscuous mode there is a separate (SplitControl) + * interface. + **/ + +#include "TKN154.h" +interface MLME_SET { + + /** @param value new PIB attribute value for phyCurrentChannel (0x00) + * @returns IEEE154_SUCCESS if PIB attribute was updated, INVALID_PARAMETER if + * parameter value is out of valid range and PIB was not updated */ + command ieee154_status_t phyCurrentChannel(ieee154_phyCurrentChannel_t value); + + /** @param value new PIB attribute value for phyTransmitPower (0x02) + * (2 MSBs are ignored) + * @returns IEEE154_SUCCESS if PIB attribute was updated, INVALID_PARAMETER if + * parameter value is out of valid range and PIB was not updated */ + command ieee154_status_t phyTransmitPower(ieee154_phyTransmitPower_t value); + + /** @param value new PIB attribute value for phyCCAMode (0x03) + * @returns IEEE154_SUCCESS if PIB attribute was updated, INVALID_PARAMETER if + * parameter value is out of valid range and PIB was not updated */ + command ieee154_status_t phyCCAMode(ieee154_phyCCAMode_t value); + + /** @param value new PIB attribute value for phyCurrentPage (0x04) + * @returns IEEE154_SUCCESS if PIB attribute was updated, INVALID_PARAMETER if + * parameter value is out of valid range and PIB was not updated */ + command ieee154_status_t phyCurrentPage(ieee154_phyCurrentPage_t value); + + /** @param value new PIB attribute value for macAssociationPermit (0x41) + * @returns IEEE154_SUCCESS if PIB attribute was updated, INVALID_PARAMETER if + * parameter value is out of valid range and PIB was not updated */ + command ieee154_status_t macAssociationPermit(ieee154_macAssociationPermit_t value); + + /** @param value new PIB attribute value for macAutoRequest (0x42) + * @returns IEEE154_SUCCESS if PIB attribute was updated, INVALID_PARAMETER if + * parameter value is out of valid range and PIB was not updated */ + command ieee154_status_t macAutoRequest(ieee154_macAutoRequest_t value); + + /** @param value new PIB attribute value for macBattLifeExt (0x43) + * @returns IEEE154_SUCCESS if PIB attribute was updated, INVALID_PARAMETER if + * parameter value is out of valid range and PIB was not updated */ + command ieee154_status_t macBattLifeExt(ieee154_macBattLifeExt_t value); + + /** @param value new PIB attribute value for macBattLifeExtPeriods (0x44) + * @returns IEEE154_SUCCESS if PIB attribute was updated, INVALID_PARAMETER if + * parameter value is out of valid range and PIB was not updated */ + command ieee154_status_t macBattLifeExtPeriods(ieee154_macBattLifeExtPeriods_t value); + + /* macBeaconPayload (0x45) and macBeaconPayloadLength (0x46) are set + * through the IEEE154TxBeaconPayload<\code> interface. */ + + /** @param value new PIB attribute value for macBeaconOrder (0x47) + * @returns IEEE154_SUCCESS if PIB attribute was updated, INVALID_PARAMETER if + * parameter value is out of valid range and PIB was not updated */ + command ieee154_status_t macBeaconOrder(ieee154_macBeaconOrder_t value); + + /** @param value new PIB attribute value for macBSN (0x49) + * @returns IEEE154_SUCCESS if PIB attribute was updated, INVALID_PARAMETER if + * parameter value is out of valid range and PIB was not updated */ + command ieee154_status_t macBSN(ieee154_macBSN_t value); + + /** @param value new PIB attribute value for macCoordExtendedAddress (0x4A) + * @returns IEEE154_SUCCESS if PIB attribute was updated, INVALID_PARAMETER if + * parameter value is out of valid range and PIB was not updated */ + command ieee154_status_t macCoordExtendedAddress(ieee154_macCoordExtendedAddress_t value); + + /** @param value new PIB attribute value for macCoordShortAddress (0x4B) + * @returns IEEE154_SUCCESS if PIB attribute was updated, INVALID_PARAMETER if + * parameter value is out of valid range and PIB was not updated */ + command ieee154_status_t macCoordShortAddress(ieee154_macCoordShortAddress_t value); + + /** @param value new PIB attribute value for macDSN (0x4C) + * @returns IEEE154_SUCCESS if PIB attribute was updated, INVALID_PARAMETER if + * parameter value is out of valid range and PIB was not updated */ + command ieee154_status_t macDSN(ieee154_macDSN_t value); + + /** @param value new PIB attribute value for macGTSPermit (0x4D) + * @returns IEEE154_SUCCESS if PIB attribute was updated, INVALID_PARAMETER if + * parameter value is out of valid range and PIB was not updated */ + command ieee154_status_t macGTSPermit(ieee154_macGTSPermit_t value); + + /** @param value new PIB attribute value for macMaxCSMABackoffs (0x4E) + * @returns IEEE154_SUCCESS if PIB attribute was updated, INVALID_PARAMETER if + * parameter value is out of valid range and PIB was not updated */ + command ieee154_status_t macMaxCSMABackoffs(ieee154_macMaxCSMABackoffs_t value); + + /** @param value new PIB attribute value for macMinBE (0x4F) + * @returns IEEE154_SUCCESS if PIB attribute was updated, INVALID_PARAMETER if + * parameter value is out of valid range and PIB was not updated */ + command ieee154_status_t macMinBE(ieee154_macMinBE_t value); + + /** @param value new PIB attribute value for macPANId (0x50) + * @returns IEEE154_SUCCESS if PIB attribute was updated, INVALID_PARAMETER if + * parameter value is out of valid range and PIB was not updated */ + command ieee154_status_t macPANId(ieee154_macPANId_t value); + + /* macPromiscuousMode (0x51) is (re-)set through the + * PromiscuousMode<\code> (SplitControl) interface. */ + + /** @param value new PIB attribute value for macRxOnWhenIdle (0x52) + * @returns IEEE154_SUCCESS if PIB attribute was updated, INVALID_PARAMETER if + * parameter value is out of valid range and PIB was not updated */ + command ieee154_status_t macRxOnWhenIdle(ieee154_macRxOnWhenIdle_t value); + + /** @param value new PIB attribute value for macShortAddress (0x53) + * @returns IEEE154_SUCCESS if PIB attribute was updated, INVALID_PARAMETER if + * parameter value is out of valid range and PIB was not updated */ + command ieee154_status_t macShortAddress(ieee154_macShortAddress_t value); + + /** @param value new PIB attribute value for macTransactionPersistenceTime (0x55) + * @returns IEEE154_SUCCESS if PIB attribute was updated, INVALID_PARAMETER if + * parameter value is out of valid range and PIB was not updated */ + command ieee154_status_t macTransactionPersistenceTime(ieee154_macTransactionPersistenceTime_t value); + + /** @param value new PIB attribute value for macAssociatedPANCoord (0x56) + * @returns IEEE154_SUCCESS if PIB attribute was updated, INVALID_PARAMETER if + * parameter value is out of valid range and PIB was not updated */ + command ieee154_status_t macAssociatedPANCoord(ieee154_macAssociatedPANCoord_t value); + + /** @param value new PIB attribute value for macMaxBE (0x57) + * @returns IEEE154_SUCCESS if PIB attribute was updated, INVALID_PARAMETER if + * parameter value is out of valid range and PIB was not updated */ + command ieee154_status_t macMaxBE(ieee154_macMaxBE_t value); + + /** @param value new PIB attribute value for macMaxFrameTotalWaitTime (0x58) + * @returns IEEE154_SUCCESS if PIB attribute was updated, INVALID_PARAMETER if + * parameter value is out of valid range and PIB was not updated */ + command ieee154_status_t macMaxFrameTotalWaitTime(ieee154_macMaxFrameTotalWaitTime_t value); + + /** @param value new PIB attribute value for macMaxFrameRetries (0x59) + * @returns IEEE154_SUCCESS if PIB attribute was updated, INVALID_PARAMETER if + * parameter value is out of valid range and PIB was not updated */ + command ieee154_status_t macMaxFrameRetries(ieee154_macMaxFrameRetries_t value); + + /** @param value new PIB attribute value for macResponseWaitTime (0x5A) + * @returns IEEE154_SUCCESS if PIB attribute was updated, INVALID_PARAMETER if + * parameter value is out of valid range and PIB was not updated */ + command ieee154_status_t macResponseWaitTime(ieee154_macResponseWaitTime_t value); + + /** @param value new PIB attribute value for macSecurityEnabled (0x5D) + * @returns IEEE154_SUCCESS if PIB attribute was updated, INVALID_PARAMETER if + * parameter value is out of valid range and PIB was not updated */ + command ieee154_status_t macSecurityEnabled(ieee154_macSecurityEnabled_t value); +} diff --git a/tos/lib/mac/tkn154/interfaces/MLME/MLME_START.nc b/tos/lib/mac/tkn154/interfaces/MLME/MLME_START.nc new file mode 100644 index 00000000..b5e44b25 --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/MLME/MLME_START.nc @@ -0,0 +1,107 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +#include "TKN154.h" +interface MLME_START { + + /** + * Requests to start using a new superframe configuration. + * + * @param PANId The PAN identifier to be used by the device + * @param LogicalChannel The logical channel on which to start transmitting + * beacons + * @param ChannelPage The channel page on which to begin using the new + * superframe configuration. + * @param StartTime The time at which to begin transmitting beacons. If this + * parameter is equal to 0x000000, beacon transmissions + * will begin immediately. Otherwise, the specified time is + * relative to the received beacon of the coordinator with + * which the device synchronizes. + * This parameter is ignored if either the beaconOrder + * parameter has a value of 15 or the panCoordinator + * parameter is TRUE.The time is specified in symbols and + * is rounded to a backoff slot boundary. This is a 24-bit + * value, and the precision of this value shall be a + * minimum of 20 bits, with the lowest 4 bits being the + * least significant. + * @param BeaconOrder The beacon order of the superframe + * @param SuperframeOrder The superframe order of the superframe + * @param PanCoordinator If TRUE, the device will become the PAN coordinator + * of a new PAN. If FALSE, the device will begin + * transmitting beacons on the PAN with which it + * is associated + * @param BatteryLifeExtension If TRUE, the receiver of the beaconing + * device is disabled after the IFS period + * @param CoordRealignment TRUE if a coordinator realignment command is to + * be transmitted prior to changing the superframe + * configuration + * @param coordRealignSecurity The security options for the coordinator + * realignment command (NULL means security + * is disabled) + * @param coordRealignSecurity The security options for beacon frames + * (NULL means security is disabled) + * + * @return IEEE154_SUCCESS if the request succeeded and a confirm event + * will be signalled, an appropriate error code otherwise + * (no confirm event will be signalled in this case) + * @see confirm + */ + command ieee154_status_t request ( + uint16_t PANId, + uint8_t LogicalChannel, + uint8_t ChannelPage, + uint32_t StartTime, + uint8_t BeaconOrder, + uint8_t SuperframeOrder, + bool PanCoordinator, + bool BatteryLifeExtension, + bool CoordRealignment, + ieee154_security_t *coordRealignSecurity, + ieee154_security_t *beaconSecurity + ); + + /** + * Signalled in response to a successful request. + * Reports the results of the attempt to start using a new superframe + * configuration + * + * @param status The result of the attempt to start using an + * updated superframe configuration + */ + event void confirm ( + ieee154_status_t status + ); + +} diff --git a/tos/lib/mac/tkn154/interfaces/MLME/MLME_SYNC.nc b/tos/lib/mac/tkn154/interfaces/MLME/MLME_SYNC.nc new file mode 100644 index 00000000..f10ab9f3 --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/MLME/MLME_SYNC.nc @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ +interface MLME_SYNC { + + /** + * Requests to synchronize with the coordinator by acquiring and, if + * specified, tracking its beacons. + * + * @param LogicalChannel Logical channel on which to attempt coordinator + * synchronization + * @param ChannelPage The channel page on which to attempt coordinator + * synchronization. + * @param TrackBeacon TRUE if the MLME is to synchronize with the next + * beacon and attempt to track all future beacons. + * FALSE if the MLME is to synchronize with only the + * next beacon. + * @return IEEE154_SUCCESS if the request succeeded and the device + * is now trying to acquire synchronization with the coordinator. + * Note: the MLME_SYNC_LOSS interface is used to signal + * when synchronization was lost (or never acquired) + */ + command ieee154_status_t request ( + uint8_t LogicalChannel, + uint8_t ChannelPage, + bool TrackBeacon + ); + +} diff --git a/tos/lib/mac/tkn154/interfaces/MLME/MLME_SYNC_LOSS.nc b/tos/lib/mac/tkn154/interfaces/MLME/MLME_SYNC_LOSS.nc new file mode 100644 index 00000000..9266822b --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/MLME/MLME_SYNC_LOSS.nc @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +#include "TKN154.h" +interface MLME_SYNC_LOSS { + + /** + * Indicates the loss of synchronization with a coordinator + * + * @param lossReason The reason that synchronization was lost + * @param PANId The PAN identifier with which the device lost + * synchronization or to which it was realigned. + * @param LogicalChannel The logical channel on which the device lost + synchronization or to which it was realigned. + * @param ChannelPage The channel page on which the device lost + * synchronization or to which it was realigned. + * @param security The security options, NULL means security is + * disabled. + */ + event void indication ( + ieee154_status_t lossReason, + uint16_t PANId, + uint8_t LogicalChannel, + uint8_t ChannelPage, + ieee154_security_t *security + ); + +} diff --git a/tos/lib/mac/tkn154/interfaces/private/DataRequest.nc b/tos/lib/mac/tkn154/interfaces/private/DataRequest.nc new file mode 100644 index 00000000..996d43e9 --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/private/DataRequest.nc @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. - Redistributions in + * binary form must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other + * materials provided with the distribution. - Neither the name of the + * Technische Universitaet Berlin nor the names of its contributors may be used + * to endorse or promote products derived from this software without specific + * prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ +interface DataRequest +{ + /** + * Sends a data request frame to the coordinator. + * + * @param CoordAddrMode coordinator address mode + * @param CoordPANId coordinator PAN ID + * @param CoordAddressLE points to coordinator address stored in + * little endian format + * @param SrcAddrMode source address mode + * @returns IEEE154_SUCCESS if a data request frame will be transmitted and + * only then pollDone will be signalled. + **/ + command ieee154_status_t poll(uint8_t CoordAddrMode, uint16_t CoordPANId, uint8_t *CoordAddressLE, uint8_t SrcAddrMode); + + + /** + * Signalled in response to a successful poll command + **/ + event void pollDone(); +} diff --git a/tos/lib/mac/tkn154/interfaces/private/EnergyDetection.nc b/tos/lib/mac/tkn154/interfaces/private/EnergyDetection.nc new file mode 100644 index 00000000..fb17fe46 --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/private/EnergyDetection.nc @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ +#include "TKN154_MAC.h" +interface EnergyDetection +{ + /** + * Requests to measure the energy level on the current channel; the + * measurement should last for duration<\code> symbols and the + * maximum energy level is signalled through the done<\code> + * event. + * + * @param duration Duration of the energy detection measurement + * (in symbol time) + * @return SUCCESS if the request was accepted and only then + * the done<\code> event will be signalled, FAIL otherwise + **/ + command error_t start(uint32_t duration); + + /** + * Signalled in response to a call to start<\code>; + * returns the maximum energy measured on the channel over the + * specified period of time. + * + * @param status SUCCESS if the measurement succeeded + * and only then EnergyLevel<\code> is valid, FAIL + * otherwise + * @param EnergyLevel The maximum energy on the channel + **/ + event void done(error_t status, int8_t EnergyLevel); +} diff --git a/tos/lib/mac/tkn154/interfaces/private/FrameExtracted.nc b/tos/lib/mac/tkn154/interfaces/private/FrameExtracted.nc new file mode 100644 index 00000000..951a179d --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/private/FrameExtracted.nc @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. - Redistributions in + * binary form must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other + * materials provided with the distribution. - Neither the name of the + * Technische Universitaet Berlin nor the names of its contributors may be used + * to endorse or promote products derived from this software without specific + * prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ +#include "TKN154_MAC.h" +interface FrameExtracted +{ + /** + * A frame was extracted from the coordinator. + * + * @param rxFrame The frame received from the coordinator + * @param txFrame The data request frame sent to the coordinator + * @return A frame buffer for the stack to use for the next received frame + **/ + event message_t* received(message_t* rxFrame, ieee154_txframe_t *txFrame); +} diff --git a/tos/lib/mac/tkn154/interfaces/private/FrameRx.nc b/tos/lib/mac/tkn154/interfaces/private/FrameRx.nc new file mode 100644 index 00000000..29fa071a --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/private/FrameRx.nc @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. - Redistributions in + * binary form must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other + * materials provided with the distribution. - Neither the name of the + * Technische Universitaet Berlin nor the names of its contributors may be used + * to endorse or promote products derived from this software without specific + * prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ +#include "TKN154_MAC.h" +interface FrameRx +{ + /** + * Received a frame buffer, returning a buffer for the signaling + * component to use for the next reception. + * + * @param frame the received frame + * @return a buffer to be used by the stack for the next + * incoming frame + */ + event message_t* received(message_t* frame); +} diff --git a/tos/lib/mac/tkn154/interfaces/private/FrameTx.nc b/tos/lib/mac/tkn154/interfaces/private/FrameTx.nc new file mode 100644 index 00000000..d9e3aef6 --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/private/FrameTx.nc @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. - Redistributions in + * binary form must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other + * materials provided with the distribution. - Neither the name of the + * Technische Universitaet Berlin nor the names of its contributors may be used + * to endorse or promote products derived from this software without specific + * prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ +#include "TKN154_MAC.h" +interface FrameTx +{ + /** + * Transmits a frame buffer. + * + * @param txFrame the frame to transmit + * @return IEEE154_SUCCESS if the request was accepted and + * only then transmitDone() will be signalled + */ + command ieee154_status_t transmit(ieee154_txframe_t *txFrame); + + /** + * Signals the completion of the transmission of a frame buffer. + * + * @param txFrame the frame that was transmitted + * @param status the result of the transmission + */ + event void transmitDone(ieee154_txframe_t *txFrame, ieee154_status_t status); +} diff --git a/tos/lib/mac/tkn154/interfaces/private/FrameTxNow.nc b/tos/lib/mac/tkn154/interfaces/private/FrameTxNow.nc new file mode 100644 index 00000000..ce876296 --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/private/FrameTxNow.nc @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. - Redistributions in + * binary form must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other + * materials provided with the distribution. - Neither the name of the + * Technische Universitaet Berlin nor the names of its contributors may be used + * to endorse or promote products derived from this software without specific + * prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ +#include "TKN154_MAC.h" +interface FrameTxNow +{ + /** + * Transmits a frame buffer. + * + * @param txFrame the frame to transmit + * @return IEEE154_SUCCESS if the request was accepted and + * only then transmitDone() will be signalled + */ + async command ieee154_status_t transmitNow(ieee154_txframe_t *frame); + + + /** + * Signals the completion of the transmission of a frame buffer. + * + * @param txFrame the frame that was transmitted + * @param status the result of the transmission + */ + + async event void transmitNowDone(ieee154_txframe_t *frame, ieee154_status_t status); +} diff --git a/tos/lib/mac/tkn154/interfaces/private/FrameUtility.nc b/tos/lib/mac/tkn154/interfaces/private/FrameUtility.nc new file mode 100644 index 00000000..2705fcfb --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/private/FrameUtility.nc @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. - Redistributions in + * binary form must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other + * materials provided with the distribution. - Neither the name of the + * Technische Universitaet Berlin nor the names of its contributors may be used + * to endorse or promote products derived from this software without specific + * prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ $Date$ + * @author Jan Hauer + * ======================================================================== + */ +#include "TKN154.h" +interface FrameUtility +{ + /* Writes the addressing fields in the MAC header of a frame + * and returns number of bytes in the MAC header.*/ + async command uint8_t writeHeader( + uint8_t* mhr, + uint8_t DstAddrMode, + uint16_t DstPANId, + ieee154_address_t* DstAddr, + uint8_t SrcAddrMode, + uint16_t SrcPANId, + const ieee154_address_t* SrcAddr, + bool PANIDCompression); + + /* Determines the lenght of the MAC header depending on the frame control field*/ + async command error_t getMHRLength(uint8_t fcf1, uint8_t fcf2, uint8_t *len); + + /* Returns TRUE if source address is the current coordinator and + * src PAN is current PAN */ + command bool isBeaconFromCoord(message_t *frame); + + /* writes the local extended address in little endian format */ + async command void copyLocalExtendedAddressLE(uint8_t *destLE); + + /* writes the coordinator's extended address in little endian format */ + command void copyCoordExtendedAddressLE(uint8_t *destLE); + + /* converts a uint64_t to little endian */ + async command void convertToLE(uint8_t *destLE, const uint64_t *srcNative); + + /* converts little endian to a uint64_t */ + async command void convertToNative(uint64_t *destNative, const uint8_t *srcLE); +} diff --git a/tos/lib/mac/tkn154/interfaces/private/Ieee802154Debug.nc b/tos/lib/mac/tkn154/interfaces/private/Ieee802154Debug.nc new file mode 100644 index 00000000..c25e8cfc --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/private/Ieee802154Debug.nc @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ +interface Ieee802154Debug +{ + async command void log(uint8_t priority, uint8_t eventID, uint32_t param1, uint32_t param2, uint32_t param3); + command void flush(); +} diff --git a/tos/lib/mac/tkn154/interfaces/private/Purge.nc b/tos/lib/mac/tkn154/interfaces/private/Purge.nc new file mode 100644 index 00000000..9038e570 --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/private/Purge.nc @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. - Redistributions in + * binary form must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other + * materials provided with the distribution. - Neither the name of the + * Technische Universitaet Berlin nor the names of its contributors may be used + * to endorse or promote products derived from this software without specific + * prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ +#include "TKN154.h" +interface Purge { + /* purges a frame from the transaction queue */ + command ieee154_status_t purge(uint8_t msduHandle); + event void purgeDone(ieee154_txframe_t *txFrame, ieee154_status_t status); +} + diff --git a/tos/lib/mac/tkn154/interfaces/private/RadioOff.nc b/tos/lib/mac/tkn154/interfaces/private/RadioOff.nc new file mode 100644 index 00000000..24317842 --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/private/RadioOff.nc @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +interface RadioOff +{ + + /** + * Switches the radio off and changes the radio state to RADIO_OFF. This + * command will succeed only if the current state of the radio is either + * TX_LOADED, RX_PREPARED or RECEIVING. + * + * @return EALREADY if radio is already switched off
FAIL if radio the + * current radio state is neither TX_LOADED, RX_PREPARED nor RECEIVING
+ * SUCCESS if the command was accepted and the offDone() event will + * be signalled. + */ + async command error_t off(); + + /** + * Signalled in response to a successful call to off(). The radio is + * now in the state RADIO_OFF. + **/ + async event void offDone(); + + /** @return TRUE if the radio is in the state RADIO_OFF, FALSE otherwise */ + async command bool isOff(); +} diff --git a/tos/lib/mac/tkn154/interfaces/private/RadioRx.nc b/tos/lib/mac/tkn154/interfaces/private/RadioRx.nc new file mode 100644 index 00000000..e548e20f --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/private/RadioRx.nc @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ +#include "TKN154_platform.h" +interface RadioRx +{ + + /** + * Prepares the radio for receive mode. This command will fail, if the radio + * is not in the state RADIO_OFF. The actual receive operation will be + * triggered through a call to receive(). + * + * @return SUCCESS if the command was accepted and prepareDone() + * will be signalled; EALREADY if the radio is already in state RX_PREPARED, + * FAIL otherwise + **/ + async command error_t prepare(); + + /** + * Signalled in response to a successful call to prepare(). This + * event is completing the preparation of a receive operation, the radio is + * now in the state RX_PREPARED. The actual receive operation will be + * triggered through a call to receive(). + **/ + async event void prepareDone(); + + /** @return TRUE if the radio is in the state RX_PREPARED, FALSE otherwise */ + async command bool isPrepared(); + + /** + * Switches the radio to receive mode at time t0 + dt. If + * t0 is NULL, then the callee interprets t0 as the current + * time. + * + * @param t0 Reference time for receive operation (NULL means now) + * + * @param dt A positive offset relative to t0. + * + * @return SUCCESS if the the command was accepted and the radio will be + * switched to receive mode; FAIL, if the radio is not in the state + * RX_PREPARED + */ + async command error_t receive(ieee154_reftime_t *t0, uint32_t dt); + + /** @return TRUE if the radio is in the state RECEIVING, FALSE otherwise */ + async command bool isReceiving(); + + /** + * A frame was received and passed the filters described in + * IEEE 802.15.4-2006 Sec. 7.5.6.2 ("Reception and rejection"). + * + * @param timestamp The point in time when the first bit of the PPDU + * was received or NULL if timestamp is not available. + * + * @param frame The received frame + * + * @return a buffer to be used by the driver for the next + * incoming frame + */ + event message_t* received(message_t *frame, ieee154_reftime_t *timestamp); +} + diff --git a/tos/lib/mac/tkn154/interfaces/private/RadioTx.nc b/tos/lib/mac/tkn154/interfaces/private/RadioTx.nc new file mode 100644 index 00000000..7229b192 --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/private/RadioTx.nc @@ -0,0 +1,166 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ +#include "TKN154_MAC.h" +#include "TKN154_PHY.h" + +interface RadioTx +{ + + /** + * Prepares the transmission of a frame. This command will fail, if the + * radio is neither in state RADIO_OFF nor in state TX_LOADED. The actual + * transmission will be triggered through a call to transmit(). Any + * frame that was previously prepared for transmission ("loaded") will be + * overwritten. The loadDone() event signals the completion of the + * load() command. + * + * The frame will be loaded (and the radio will stay in the state + * TX_LOADED) until either the transmission was successful, i.e. + * transmitDone() was signalled with a status IEEE154_SUCCESS, or + * the radio is explicitly switched off through the RadioOff + * interface. Until then the callee might have to reserve certain resources + * (e.g. the bus connected to the radio), so the caller should keep the time + * while a frame is loaded as short as possible. + * + * @param frame The frame to transmit. + * + * @return SUCCESS if the command was accepted and loadDone() will + * be signalled; FAIL otherwise + **/ + async command error_t load(ieee154_txframe_t *frame); + + /** + * Signalled in response to a successful call to load(). This + * event is completing the preparation of a transmission, the radio is + * now in the state TX_LOADED. The actual transmission is triggered + * through a call to transmit(). + **/ + async event void loadDone(); + + /** + * If the radio is in state TX_LOADED then this commands returns the + * the frame that was loaded last; it returns NULL otherwise. + * + * @return last frame loaded if radio is in the state TX_LOADED, + * NULL otherwise + **/ + async command ieee154_txframe_t* getLoadedFrame(); + + /** + * Transmits the frame whose transmission has previously been prepared + * through a call to load(). The actual time of transmission -- the + * point in time when the first symbol of the PPDU is transmitted -- is + * defined by: t0 + dt. The data type of the t0 parameter + * is platform-specific (symbol precision or better) while dt is + * expressed in 802.15.4 symbols. If t0 is NULL, then the callee + * interprets t0 as the current time. The caller guarantees (through + * platform-specific guard times and by calling transmit in an + * atomic block) that the callee can start the transmission on time, taking + * any prior clear channel assesment(s) into consideration. + * + * A transmission may require 0, 1 or 2 prior clear channel assesments + * (numCCA parameter) to be performed 0, 20 or 40 symbols, + * respectively, before the actual transmission. If a CCA determines a busy + * channel, then the frame will not be transmitted. + * + * A successful transmission may also require an acknowledgement from the + * destination (indicated through the ackRequest parameter); then, + * the callee has to perform the necessary steps for receiving that + * acknowledgement (switching the radio to Rx mode immediately after + * transmission, etc.; for details see IEEE 802.15.4-2006). + * + * The transmit() command will succeed iff the radio is in state + * TX_LOADED. The transmitDone() event will then signal the result + * of the transmission. + * + * @param t0 Reference time for transmission (NULL means now) + * + * @param dt A positive offset relative to t0. + * + * @param numCCA Number of clear channel assesments. + * + * @param ackRequest TRUE means an acknowledgement is required, FALSE means + * no acknowledgement is not required + * + * @return SUCCESS if the transmission was triggered successfully and only + * then transmitDone() will be signalled; FAIL, if the transmission + * was not triggered because no frame was loaded. + */ + async command error_t transmit(ieee154_reftime_t *t0, uint32_t dt, + uint8_t numCCA, bool ackRequest); + + /** + * Signalled in response to a call to transmit(). Depending on the + * error parameter the radio is now in state RADIO_OFF + * (error == IEEE154_SUCCESS) or still in state TX_LOADED + * (error != IEEE154_SUCCESS). If the transmission succeeded then + * the time of transmission -- the point in time when the first symbol of the + * PPDU was transmitted -- will be stored in the metadata field of the frame. + * In addition, the t0 parameter will hold a platform-specific + * representation of the same point in time (possibly with higher precision) + * to be used as future reference time in a transmit() command. If + * the transmission did not succeed no timestamp will be stored in the + * metadata portion, but t0 will still represent the hypothetical + * transmission time. + * + * If error has a value other than IEEE154_SUCCESS the frame will + * stay loaded and a subsequent call to transmit will (re-)transmit + * the same frame again. If error has a value of + * IEEE154_SUCCESS then the frame was automatically un-loaded and a new frame + * has to be loaded before the transmit() command will succeed. + * + * When the transmit() command was called with an + * ackRequest parameter with value TRUE, and error has a + * value of IEEE154_SUCCESS, then this means that a corresponding + * acknowledgement was successfully received. In this case, the + * ackPendingFlag represents the "pending" flag in the header of the + * acknowledgement frame (TRUE means set, FALSE means reset). + * + * @param frame The frame that was transmitted. + * + * @param t0 The (hypothetical) transmission time; the pointer is only valid + * until the eventhandler returns. + * + * @param ackPendingFlag TRUE if an acknowledgement was received and the + * "pending" flag is set in the header of the ACK frame, FALSE otherwise + * + * @param error SUCCESS if the transmission succeeded (including successful + * CCA and acknowledgement reception, if requested); EBUSY if CCA was + * unsuccessful (frame was not transmitted); ENOACK if frame was transmitted + * but no matching acknowledgement was received. + **/ + async event void transmitDone(ieee154_txframe_t *frame, ieee154_reftime_t *t0, + bool ackPendingFlag, error_t error); +} diff --git a/tos/lib/mac/tkn154/interfaces/private/ResourceTransfer.nc b/tos/lib/mac/tkn154/interfaces/private/ResourceTransfer.nc new file mode 100644 index 00000000..ac224e9f --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/private/ResourceTransfer.nc @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. - Redistributions in + * binary form must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other + * materials provided with the distribution. - Neither the name of the + * Technische Universitaet Berlin nor the names of its contributors may be used + * to endorse or promote products derived from this software without specific + * prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +interface ResourceTransfer +{ + + /** + * Transfer control of a resource to another client. Conceptually, this + * command is similar to calling Resource.release() and then forcing the + * arbiter to signal the Resource.granted() event to the target client. But + * there is one difference: when a resource that was transferred through this + * command is released, it is released on behalf of the "original" client, + * i.e. who was last signalled the Resource.granted() event. Releasing a + * transferred resource is thus equivalent to first transferring it back to + * the original client and then forcing the latter to release the resource + * through a call to Resource.release() -- this ensures that the arbitration + * policy can continue properly (and avoids possible starvation). + * + * Note that a resource may be transferred multiple times, before it is + * released. Then the current owner will change, but the "original" client + * will stay the same. + * + * @return SUCCESS If ownership has been transferred.
FAIL ownership has + * not been transferred, because the caller is not owner of the resource + */ + + async command error_t transfer(); +} diff --git a/tos/lib/mac/tkn154/interfaces/private/ResourceTransferConnector.nc b/tos/lib/mac/tkn154/interfaces/private/ResourceTransferConnector.nc new file mode 100644 index 00000000..ec8c8aca --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/private/ResourceTransferConnector.nc @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. - Redistributions in + * binary form must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other + * materials provided with the distribution. - Neither the name of the + * Technische Universitaet Berlin nor the names of its contributors may be used + * to endorse or promote products derived from this software without specific + * prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +interface ResourceTransferConnector +{ + async command uint8_t getUserId(); + async command void transfer(); +} diff --git a/tos/lib/mac/tkn154/interfaces/private/ResourceTransferControl.nc b/tos/lib/mac/tkn154/interfaces/private/ResourceTransferControl.nc new file mode 100644 index 00000000..06013582 --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/private/ResourceTransferControl.nc @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. - Redistributions in + * binary form must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other + * materials provided with the distribution. - Neither the name of the + * Technische Universitaet Berlin nor the names of its contributors may be used + * to endorse or promote products derived from this software without specific + * prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +interface ResourceTransferControl +{ + async command error_t transfer(uint8_t fromClient, uint8_t toClient); + async command error_t release(uint8_t client); +} diff --git a/tos/lib/mac/tkn154/interfaces/private/ResourceTransferred.nc b/tos/lib/mac/tkn154/interfaces/private/ResourceTransferred.nc new file mode 100644 index 00000000..4c7c8a97 --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/private/ResourceTransferred.nc @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. - Redistributions in + * binary form must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other + * materials provided with the distribution. - Neither the name of the + * Technische Universitaet Berlin nor the names of its contributors may be used + * to endorse or promote products derived from this software without specific + * prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + +interface ResourceTransferred +{ + + /** + * Control of a resource was transferred to this component from another + * client. This event is similar to the Resource.granted() event, but when a + * the resource is released, it is released on behalf of the client who was + * last signalled the Resource.granted() event. + * + * @see ResourceTransfer interface + */ + async event void transferred(); + + /** + * + * Release control of a resource - this command is equivalent to calling + * Resource.release() and included for convenience. + * + * @return SUCCESS The resource has been released
FAIL You tried to + * release but you are not the owner of the resource + * + * @see ResourceTransfer interface + */ + + async command error_t release(); +} diff --git a/tos/lib/mac/tkn154/interfaces/private/TimeCalc.nc b/tos/lib/mac/tkn154/interfaces/private/TimeCalc.nc new file mode 100644 index 00000000..9be09b34 --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/private/TimeCalc.nc @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. - Redistributions in + * binary form must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other + * materials provided with the distribution. - Neither the name of the + * Technische Universitaet Berlin nor the names of its contributors may be used + * to endorse or promote products derived from this software without specific + * prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ +interface TimeCalc +{ + /** + * Returns the interval between time t1 and time t0 assuming + * that t0 happened before t1. + * @return interval between t1 and t0 + */ + async command uint32_t timeElapsed(uint32_t t0, uint32_t t1); + + /** + * Assuming that t0 lies in the past, this command returns TRUE + * iff t0+dt lies also in the past. + * @return TRUE if t0+dt is later than "now" + */ + async command bool hasExpired(uint32_t t0, uint32_t dt); +} diff --git a/tos/lib/mac/tkn154/interfaces/private/WriteBeaconField.nc b/tos/lib/mac/tkn154/interfaces/private/WriteBeaconField.nc new file mode 100644 index 00000000..cf68081e --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/private/WriteBeaconField.nc @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. - Redistributions in + * binary form must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other + * materials provided with the distribution. - Neither the name of the + * Technische Universitaet Berlin nor the names of its contributors may be used + * to endorse or promote products derived from this software without specific + * prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ +interface WriteBeaconField +{ + // returns length of bytes written + command uint8_t write(uint8_t *dest, uint8_t maxlen); + // *current* length in byte + command uint8_t getLength(); +} diff --git a/tos/lib/mac/tkn154/interfaces/public/IEEE154BeaconFrame.nc b/tos/lib/mac/tkn154/interfaces/public/IEEE154BeaconFrame.nc new file mode 100644 index 00000000..aae98efc --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/public/IEEE154BeaconFrame.nc @@ -0,0 +1,137 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + + +#include + +interface IEEE154BeaconFrame +{ + + /** + * Reads the Pending Address Specification of a beacon frame. + * + * @param frame the beacon frame + * @param pendAddrSpec a pointer to where the Pending Address + * Specification should be written + * @return FAIL if the frame is not a beacon frame, + * SUCCESS otherwise + */ + command error_t getPendAddrSpec(message_t* frame, uint8_t* pendAddrSpec); + + /** + * Reads the Pending Addresses of a given type (short or extended) from a + * beacon frame. + * + * @param frame the beacon frame + * @param addrMode the address mode of the sought addresses, either + * ADDR_MODE_SHORT_ADDRESS or ADDR_MODE_EXTENDED_ADDRESS + * @param buffer a pointer to an array of "bufferSize" addresses + * @param bufferSize number of address entries in the buffer + * + * @return FAIL if the frame is not a beacon frame, + * SUCCESS otherwise + */ + command error_t getPendAddr(message_t* frame, uint8_t addrMode, + ieee154_address_t buffer[], uint8_t bufferSize); + + /** + * Determines whether the local macShortAddress or aExtendedAddress + * (as currently registered in the PIB) is part of the pending + * address list of a beacon. + * + * @param frame the beacon frame + * + * @return ADDR_MODE_NOT_PRESENT if the frame is not a beacon + * beacon frame, or the local address is not part of + * the pending address list, + * ADDR_MODE_SHORT_ADDRESS if the local macShortAddress + * is part of the pending address list, + * ADDR_MODE_EXTENDED_ADDRESS if the local aExtendedAddress + * is part of the pending address list + */ + command uint8_t isLocalAddrPending(message_t* frame); + + /** + * Parses the PAN Descriptor of a beacon frame. Since a frame + * does not include information about the channel that it was + * received on this information must be provided by the caller. + * + * @param frame the beacon frame + * @param LogicalChannel will be written to PANDescriptor->LogicalChannel + * @param ChannelPage will be written to PANDescriptor->ChannelPage + * @param PANDescriptor a pointer to a PAN Descriptor, that will hold + * the PAN Descriptor as parsed of the beacon frame + * @param bufferSize number of address entries in the buffer + * + * @return SUCCESS if the frame is a valid beacon frame and the + * PANDescriptor was successfully parsed, FAIL + * otherwise + */ + command error_t parsePANDescriptor(message_t *frame, uint8_t LogicalChannel, + uint8_t ChannelPage, ieee154_PANDescriptor_t *PANDescriptor); + + /** + * Returns a pointer to the beacon payload. + * + * @param frame the beacon frame + * @return a pointer to the beacon payload, or, if the + * frame is not a beacon frame, a pointer to + * the MAC payload. If the frame was received + * while in promiscuous mode, then this command + * returns a pointer to the first byte of the MHR. + */ + command void* getBeaconPayload(message_t* frame); + + /** + * Returns the length of the beacon payload portion of the frame + * (in byte). + * + * @param frame the frame + * @return the length (in byte) of the frame's beacon payload + * portion, or, if the frame is not a beacon frame + * the length of the MAC payload. If the frame + * was received while in promiscuous mode, then + * this command returns the length of MHR + MAC Payload. + */ + command uint8_t getBeaconPayloadLength(message_t* frame); + + /** + * Returns the (beacon) sequence number of the frame. + * + * @param frame the frame + * @return sequence number of the frame + */ + command uint8_t getBSN(message_t* frame); +} diff --git a/tos/lib/mac/tkn154/interfaces/public/IEEE154Frame.nc b/tos/lib/mac/tkn154/interfaces/public/IEEE154Frame.nc new file mode 100644 index 00000000..01d59541 --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/public/IEEE154Frame.nc @@ -0,0 +1,245 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + + +#include +#include + +interface IEEE154Frame +{ + + /** + * Returns the source addressing mode of the frame. + * + * @param frame the frame + * @return source addressing mode of the frame; either + * ADDR_MODE_NOT_PRESENT, ADDR_MODE_RESERVED, + * ADDR_MODE_SHORT_ADDRESS or ADDR_MODE_EXTENDED_ADDRESS + */ + command uint8_t getSrcAddrMode(message_t* frame); + + /** + * Reads the source address (to be interpreted + * as specified by the source addressing mode) of the frame. + * + * @param frame the frame + * @param address a pointer to where the source address + * will be written + * @return SUCCESS, if the source address is present + * and was written to "address", + * FAIL otherwise (source address remains + * unmodified) + */ + command error_t getSrcAddr(message_t* frame, ieee154_address_t *address); + + /** + * Reads the source PAN identifier of the frame. + * + * @param frame the frame + * @param PANID a pointer to where the source PAN identifier + * will be written + * @return SUCCESS, if the source PAN identifier is present + * and was written to "PANID", + * FAIL otherwise (PANID remains unmodified) + */ + command error_t getSrcPANId(message_t* frame, uint16_t* PANID); + + /** + * Returns the destination addressing mode of the frame. + * + * @param frame the frame + * @return destination addressing mode of the frame; either + * ADDR_MODE_NOT_PRESENT, ADDR_MODE_RESERVED, + * ADDR_MODE_SHORT_ADDRESS or ADDR_MODE_EXTENDED_ADDRESS + */ + command uint8_t getDstAddrMode(message_t* frame); + + /** + * Reads the destination address (to be interpreted + * as specified by the destination addressing mode) of the frame. + * + * @param frame the frame + * @param address a pointer to where the destination address + * will be written + * @return SUCCESS, if the destination address is present + * and was written to "address", + * FAIL otherwise (destination address + * remains unmodified) + */ + command error_t getDstAddr(message_t* frame, ieee154_address_t *address); + + /** + * Reads the destination PAN identifier of the frame. + * + * @param PANID a pointer to where the destination + * PAN identifier should be written + * @param frame the frame + * @return SUCCESS, if the destination PAN identifier + * is present and was copied to "PANID", + * FAIL otherwise (PANID remains unmodified) + */ + command error_t getDstPANId(message_t* frame, uint16_t* PANID); + + /** + * Sets the addressing fields in the MAC header of a frame. The source + * PAN identifier and the source address will be set automatically, their + * values depend on the SrcAddrMode parameter: if + * SrcAddrMode is a short or extended address, then + * the current PIB attributes macShortAddress or + * aExtendedAddress and macPANId are used. + * + * @param frame the frame + * @param srcAddrMode the source addressing mode + * @param dstAddrMode the destination addressing mode + * @param dstPANID the 16 bit PAN identifier of the destination + * @param dstAddr individual device address of the destination as per + * the dstAddrMode + * @param security the security options (NULL means security is + * disabled) + * + * @return SUCCESS if the addressing fields where written, + * FAIL if a wrong addressing mode was specified + */ + command error_t setAddressingFields(message_t* frame, + uint8_t SrcAddrMode, + uint8_t DstAddrMode, + uint16_t DstPANID, + ieee154_address_t *DstAddr, + ieee154_security_t *security); + + /** + * Returns a pointer to the MAC payload portion of a frame. + * + * @param frame the frame + * @return a pointer to the frame's payload + */ + command void* getPayload(message_t* frame); + + /** + * Returns the length of the MAC payload portion of the frame (in byte). + * + * @param frame the frame + * @return the length of the frame's payload (in byte) + */ + command uint8_t getPayloadLength(message_t* frame); + + /** + * Returns the point in time when the frame was received. If + * isTimestampValid()<\code> returns FALSE then the + * timestamp is not valid and must be ignored. + * + * @param frame the frame + * @return timestamp of the frame + */ + command uint32_t getTimestamp(message_t* frame); + + /** + * Tells whether the timestamp is valid. + * + * @return TRUE if timestamp is valid, FALSE otherwise. + */ + command bool isTimestampValid(message_t* frame); + + /** + * Returns the sequence number of the frame. + * + * @param frame the frame + * @return sequence number of the frame + */ + command uint8_t getDSN(message_t* frame); + + /** + * Returns the link quality level at which the frame was received. + * + * @param frame the frame + * @return link quality level + */ + command uint8_t getLinkQuality(message_t* frame); + + /** + * Returns the type of the frame + * BEACON=0, DATA=1, ACK=2, COMMAND=3. + * + * Note: For beacon frames one can use the IEEE154BeaconFrame<\code> + * interface to inspect additional fields of the frame. + * + * @param frame the frame + * @return the type of the frame + */ + command uint8_t getFrameType(message_t* frame); + + /** + * Returns a pointer to the MAC header (i.e. to the first byte of + * the Frame Control field). + * + * @param frame the frame + * @return a pointer to the frame's header + */ + command void* getHeader(message_t* frame); + + /** + * Returns the length of the MAC header. + * + * @param frame the frame + * @return the length of the MAC header (in byte) + */ + command uint8_t getHeaderLength(message_t* frame); + + /** + * Tells whether or not the frame was received while + * promiscuous mode was enabled. + * + * @param frame the frame + * @return TRUE if frame was received while in promiscuous + * mode, FALSE otherwise + */ + command bool wasPromiscuousModeEnabled(message_t* frame); + + /** + * Tells whether or not the frame has a standard compliant + * IEEE 802.15.4 header - this will only be relevant for frames + * received while in promiscuous mode, because then no filtering + * (except CRC check) was applied. Note: if this command returns + * FALSE, then all other commands in this interface (except + * wasPromiscuousModeEnabled()) and the + * IEEE154BeaconFrame interface return undefined values! + * + * @param frame the frame + * @return TRUE if frame has a standard compliant header, + * FALSE otherwise + */ + command bool hasStandardCompliantHeader(message_t* frame); + +} diff --git a/tos/lib/mac/tkn154/interfaces/public/IEEE154TxBeaconPayload.nc b/tos/lib/mac/tkn154/interfaces/public/IEEE154TxBeaconPayload.nc new file mode 100644 index 00000000..4415ee60 --- /dev/null +++ b/tos/lib/mac/tkn154/interfaces/public/IEEE154TxBeaconPayload.nc @@ -0,0 +1,133 @@ +/* + * Copyright (c) 2008, Technische Universitaet Berlin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - Neither the name of the Technische Universitaet Berlin nor the names + * of its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * - Revision ------------------------------------------------------------- + * $Revision$ + * $Date$ + * @author Jan Hauer + * ======================================================================== + */ + + +#include + +interface IEEE154TxBeaconPayload +{ + /** + * Sets the beacon payload portion for all subsequently transmitted beacons. + * This command replaces the MLME-SET command for the PIB attribute values + * 0x45 (macBeaconPayload) and 0x46 (macBeaconPayloadLength). The + * setBeaconPayloadDone()<\code> event will be signalled when the + * beacon payload has been set -- until then beaconPayload<\code> must + * not be modified. + * + * @param beaconPayload the new beacon payload + * @param length the length of the new beacon payload (in byte) + * + * @return EBUSY if another transaction is pending, ESIZE if length is too big, + * SUCCESS otherwise (and only then the setBeaconPayloadDone<\code> event + * will be signalled) + */ + command error_t setBeaconPayload(void *beaconPayload, uint8_t length); + + /** + * Signalled in response to a setBeaconPayload()<\code> request. + * Indicates that the beacon payload has been copied and returns the + * ownership of the buffer to the next higher layer. + * + * @param beaconPayload the beaconPayload<\code> passed in the + * setBeaconPayload()<\code> command + * @param length the length<\code> passed in the + * setBeaconPayload()<\code> command + */ + event void setBeaconPayloadDone(void *beaconPayload, uint8_t length); + + /** + * Returns a pointer to the current beacon payload. + * + * @return the current beacon payload + */ + command const void* getBeaconPayload(); + + /** + * Returns the length of the current beacon payload (in byte). + * + * @return length of the current beacon payload + */ + command uint8_t getBeaconPayloadLength(); + + /** + * Replaces (overwrites) a portion of the current beacon payload. Whenever + * possible, to minimize overhead, the next higher layer should prefer this + * command over the setBeaconPayload()<\code> command. The + * modifyBeaconPayloadDone()<\code> event will be signalled when the + * beacon payload has been updated -- until then buffer<\code> must + * not be modified. + * + * @param offset offset into the current beacon payload + * @param buffer the buffer to be written + * @param length the length of the buffer + * + * @return EBUSY if another transaction is pending, ESIZE if offset+length is too big, + * SUCCESS otherwise (and only then the modifyBeaconPayloadDone<\code> event + * will be signalled) + */ + command error_t modifyBeaconPayload(uint8_t offset, void *buffer, uint8_t bufferLength); + + /** + * Signalled in response to a modifyBeaconPayload()<\code> request. + * Indicates that the beacon payload has been updated. + * + * @param offset the offset<\code> passed in the + * modifyBeaconPayload()<\code> command + * @param buffer the buffer<\code> passed in the + * modifyBeaconPayload()<\code> command + * @param bufferLength the bufferLength<\code> passed in the + * modifyBeaconPayload()<\code> command + */ + event void modifyBeaconPayloadDone(uint8_t offset, void *buffer, uint8_t bufferLength); + + /** + * Indicates that a beacon frame will be transmitted "soon" and now is a good + * time to update the beacon payload (if desired). + * + * The usual policy is that (1) this event is signalled before every beacon + * transmission, and (2) that a subsequent call to setPayload<\code> + * will update the beacon payload portion of this beacon. However, + * because of tight timing constraints in beacon-enabled mode neither can be + * guaranteed! + */ + event void aboutToTransmit(); + + /** + * Indicates that a beacon frame has been transmitted (the + * getBeaconPayload<\code> command can be used to inspect the + * beacon payload). + */ + event void beaconTransmitted(); +} -- 2.39.2