pibp.nc

tinyos-2.x.rar

    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);
  }

  /* ----------------------- 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)
  {
    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 < IEEE154_aMaxMACPayloadSize
#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,