zdcache.lst

来自「CC2430上开关控制灯和温度传感器采集两个例子」· LST 代码 · 共 1,345 行 · 第 1/5 页

    401          /*********************************************************************
    402           * @fn      getIdxExt
    403           *
    404           * @brief   Find the idx into the Discovery Cache Arrays corresponding to
    405           *          the given IEEE address.
    406           *
    407           * @param   byte * - a valid buffer containing an extended IEEE address.
    408           *
    409           * @return  If address found, return the valid index, else CACHE_DEV_MAX.
    410           *
    411           */
    412          static byte getIdxExt( byte *ieee )
    413          {
    414            byte idx;
    415          
    416            for ( idx = 0; idx < CACHE_DEV_MAX; idx++ )
    417            {
    418              if ( osal_ExtAddrEqual( ieee, ExtAddr[idx] ) &&
    419                                                    (NwkAddr[idx] != INVALID_NODE_ADDR) )
    420              {
    421                break;
    422              }
    423            }
    424          
    425            return idx;
    426          }
    427          
    428          /*********************************************************************
    429           * @fn      getIdxEP
    430           *
    431           * @brief   Find the idx into the EndPoint Array corresponding to the idx of a
    432           *          cached short address.
    433           *
    434           * @param   byte - a valid index of a cached 16 bit short address.
    435           * @param   byte - the EndPoint of interest.
    436           *
    437           * @return  If EndPoint found, return the valid index, else CACHE_EP_MAX.
    438           *
    439           */
    440          static byte getIdxEP( byte idx, byte ep )
    441          {
    442            byte epIdx;
    443          
    444            for ( epIdx = 0; epIdx < EPCnt[idx]; epIdx++ )
    445            {
    446              if ( ep == EPArr[idx][epIdx] )
    447              {
    448                break;
    449              }
    450            }
    451          
    452            if ( epIdx == EPCnt[idx] )
    453            {
    454              epIdx = CACHE_EP_MAX;
    455            }
    456          
    457            return epIdx;
    458          }
    459          
    460          /*********************************************************************
    461           * @fn      purgeAddr
    462           *
    463           * @brief   Purge every instance of given network address from Discovery Cache.
    464           *
    465           * @param   uint16 - a 16-bit network address.
    466           *
    467           */
    468          static byte purgeAddr( uint16 addr )
    469          {
    470            byte idx, cnt = 0;
    471          
    472            for ( idx = 0; idx < CACHE_DEV_MAX; idx++ )
    473            {
    474              if ( NwkAddr[idx] == addr )
    475              {
    476                NwkAddr[idx] = INVALID_NODE_ADDR;
    477                cnt++;
    478              }
    479            }
    480          
    481            return cnt;
    482          }
    483          
    484          /*********************************************************************
    485           * @fn      purgeIEEE
    486           *
    487           * @brief   Purge every instance of given IEEE from Discovery Cache.
    488           *
    489           * @param   ZLongAddr_t - a valid IEEE address.
    490           *
    491           */
    492          static byte purgeIEEE( byte *ieee )
    493          {
    494            byte idx, cnt = 0;
    495          
    496            for ( idx = 0; idx < CACHE_DEV_MAX; idx++ )
    497            {
    498              if ( osal_ExtAddrEqual( ieee, ExtAddr[idx] ) &&
    499                                                    (NwkAddr[idx] != INVALID_NODE_ADDR) )
    500              {
    501                NwkAddr[idx] = INVALID_NODE_ADDR;
    502                cnt++;
    503              }
    504            }
    505          
    506            return cnt;
    507          }
    508          #endif
    509          
    510          /*********************************************************************
    511           * @fn          ZDCacheInit
    512           *
    513           * @brief       Initialize ZDO Cache environment.
    514           *
    515           */
    516          void ZDCacheInit( void )
    517          {
    518          
    519            msgAddr.endPoint = ZDO_EP;
    520            msgAddr.addrMode = afAddr16Bit;
    521            msgAddr.addr.shortAddr = INVALID_NODE_ADDR;
    522            radius = AF_DEFAULT_RADIUS;
    523            (void)secUse;
    524          
    525          #if ( CACHE_DEV_MAX > 0 )
    526            byte idx;
    527          
    528            for ( idx = 0; idx < CACHE_DEV_MAX; idx++ )
    529            {
    530              byte epIdx;
    531              NwkAddr[idx] = INVALID_NODE_ADDR;
    532          
    533              for ( epIdx = 0; epIdx < CACHE_EP_MAX; epIdx++ )
    534              {
    535                SimpDesc[idx][epIdx].pAppInClusterList = InClusters[idx][epIdx];
    536                SimpDesc[idx][epIdx].pAppOutClusterList= OutClusters[idx][epIdx];
    537              }
    538            }
    539          #elif ( CACHE_DEV_MAX == 0 )
    540            // Client cache work done by ZDCacheTimerEvent, driven by NWK_AUTO_POLL_EVT.
    541          #endif
    542          }
    543          
    544          /*********************************************************************
    545           * @fn          ZDCacheTimerEvent
    546           *
    547           * @brief       ZDP maintenance, aging discovery cache.
    548           *              Invoked at RTG_TIMER_INTERVAL.
    549           */
    550          void ZDCacheTimerEvent( void )
    551          {
    552          #if ( CACHE_DEV_MAX > 0 )
    553            byte idx;
    554          
    555            for ( idx = 0; idx < CACHE_DEV_MAX; idx++ )
    556            {
    557              if ( NwkAddr[idx] != INVALID_NODE_ADDR )
    558              {
    559                if ( --Expiry[idx] == 0 )
    560                {
    561                  NwkAddr[idx] = INVALID_NODE_ADDR;
    562                }
    563              }
    564            }
    565          #elif ( CACHE_DEV_MAX == 0 )
    566            static eCacheState state = eCacheWait;
    567            static byte reqIdx = 0;
    568            static byte wCnt = 0;
    569          
    570            byte strtFind = FALSE;
    571            byte cmd = 0;
    572            byte len = 2 + Z_EXTADDR_LEN;
    573            byte *msg, *ptr;
    574          
    575            wCnt++;
    576            if ( state == eCacheWait )
    577            {
    578              if ( wCnt < WAIT_TO_STORE_CACHE )
    579              {
    580                return;
    581              }
    582            }
    583            else if ( wCnt < WAIT_ON_RESP_CACHE )
    584            {
    585              return;
    586            }
    587          
    588            msg = osal_mem_alloc( MAX_PKT_LEN );
    589            if ( msg == NULL )
    590            {
    591              return;
    592            }
    593          
    594            msg[0] = LO_UINT16( ZDAppNwkAddr.addr.shortAddr );
    595            msg[1] = HI_UINT16( ZDAppNwkAddr.addr.shortAddr );
    596            osal_cpyExtAddr( msg+2, saveExtAddr );
    597            ptr = msg+2+Z_EXTADDR_LEN;
    598          
    599            switch ( state )
    600            {
    601            case eCacheWait:
    602              state = eCacheClean;
    603              msgAddr.addr.shortAddr = NWK_BROADCAST_SHORTADDR;
    604              cmd = Find_node_cache_req;
    605              cacheCnt = 0;
    606              reqIdx = 0;
    607              break;
    608          
    609            case eCacheClean:
    610              if ( reqIdx < cacheCnt )
    611              {
    612                msgAddr.addr.shortAddr = cacheFindAddr[reqIdx++];
    613                cmd = Remove_node_cache_req;
    614              }
    615              else
    616              {
    617                strtFind = TRUE;
    618                radius = 0;
    619              }
    620              break;
    621          
    622            case eCacheFind:
    623              if ( cacheCnt != 0 )
    624              {
    625                state = eCacheRequest;
    626                reqIdx = 0;
    627              }
    628              else
    629              {
    630                strtFind = TRUE;
    631              }
    632              break;
    633          
    634            case eCacheRequest:
    635              if ( (cacheRsp == ZDP_SUCCESS) && (reqIdx != 0) )
    636              {
    637                cmd = Node_Desc_store_req;
    638                len += sizeof( NodeDescriptorFormat_t );
    639                ptr = osal_memcpy( ptr, &ZDO_Config_Node_Descriptor,
    640                                                      sizeof( NodeDescriptorFormat_t ) );
    641                state = eNodeDescStore;
    642              }
    643              else if ( reqIdx < cacheCnt )
    644              {
    645                EPCnt = afNumEndPoints() - 1;  // -1 for ZDO endpoint descriptor.
    646          
    647                if ( EPCnt < CACHE_EP_MAX )
    648                {
    649                  byte idx;
    650                  afEndPoints( EPArr, true );
    651          
    652                  msgAddr.addr.shortAddr = cacheFindAddr[reqIdx++];
    653          
    654                  cmd = Discovery_store_req;
    655                  len += (4 + EPCnt);
    656                  *ptr++ = sizeof( NodeDescriptorFormat_t );
    657                  *ptr++ = sizeof( NodePowerDescriptorFormat_t );
    658                  *ptr++ = EPCnt + 1;  // NOT -1 for size in bytes of EP list.
    659                  *ptr++ = EPCnt;
    660          
    661                  for ( idx = 0; idx < EPCnt; idx++ )
    662                  {
    663                    SimpleDescriptionFormat_t *sDesc;
    664                    byte free = afFindSimpleDesc( &sDesc, EPArr[idx] );
    665          
    666                    if ( sDesc != NULL )
    667                    {
    668                      *ptr++ = 8 + sDesc->AppNumInClusters + sDesc->AppNumOutClusters;
    669