开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 网络 > 查看源码
MultiHopWMEWMA.nc
资源名称：zmacForRelease.tar.gz　[点击查看]
上传用户：joranyuan
上传日期：2022-06-23
资源大小：3306k
文件大小：23k
源码类别：

网络

开发平台：

Others

MultiHopWMEWMA.nc：源码内容
  1. // $Id: MultiHopWMEWMA.nc,v 1.10 2005/04/28 19:25:05 jwhui Exp $
  3. /* tab:4
  4.  * "Copyright (c) 2000-2003 The Regents of the University  of California.  
  5.  * All rights reserved.
  6.  *
  7.  * Permission to use, copy, modify, and distribute this software and its
  8.  * documentation for any purpose, without fee, and without written agreement is
  9.  * hereby granted, provided that the above copyright notice, the following
  10.  * two paragraphs and the author appear in all copies of this software.
  11.  * 
  12.  * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
  13.  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
  14.  * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
  15.  * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  16.  * 
  17.  * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  18.  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  19.  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  20.  * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
  21.  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS."
  22.  *
  23.  * Copyright (c) 2002-2003 Intel Corporation
  24.  * All rights reserved.
  25.  *
  26.  * This file is distributed under the terms in the attached INTEL-LICENSE     
  27.  * file. If you do not find these files, copies can be found by writing to
  28.  * Intel Research Berkeley, 2150 Shattuck Avenue, Suite 1300, Berkeley, CA, 
  29.  * 94704.  Attention:  Intel License Inquiry.
  30.  */
  32. /*
  33.  *
  34.  * Authors: Philip Buonadonna, Alec Woo, Terence Tong, Crossbow
  35.  * Date last modified:  2/20/03
  36.  *
  37.  */
  40. includes AM;
  41. includes MultiHop;
  44. //#define MULTI_HOP_DEBUG 1
  46. module MultiHopWMEWMA {
  48.   provides {
  49.     interface StdControl;
  50.     interface RouteSelect;
  51.     interface RouteControl;
  52.   }
  54.   uses {
  55.     interface Leds;
  56.     interface Timer;
  57.     interface Timer as ATimer;
  58.     interface ReceiveMsg;
  59.     interface Intercept as Snoop[uint8_t id];
  60.     interface SendMsg;
  61.     interface Send as DebugSendMsg;
  62. #ifdef USE_WATCHDOG
  63. interface StdControl as PoochHandler;
  64. interface WDT;
  65. #endif
  66.   }
  67. }
  69. implementation {
  71.   enum {
  72.     NBRFLAG_VALID    = 0x01,
  73.     NBRFLAG_NEW      = 0x02,
  74.     NBRFLAG_EST_INIT = 0x04
  75.   };
  77.   enum {
  78.     BASE_STATION_ADDRESS        = 0,
  79.     ROUTE_TABLE_SIZE            = 16,
  80.     ESTIMATE_TO_ROUTE_RATIO     = 10,
  81.     ACCEPTABLE_MISSED           = -20,
  82.     DATA_TO_ROUTE_RATIO         = 1,
  83.     DATA_FREQ                   = 8192,
  84.     SWITCH_THRESHOLD      = 384,
  85.     MAX_ALLOWABLE_LINK_COST     = 256*6,
  86.     LIVELINESS               = 5,
  87.     MAX_DESCENDANT_LIVE = 5
  89.   };
  91.   enum {
  92.     ROUTE_INVALID    = 0xff
  93.   };
  95.   struct SortEntry {
  96.     uint16_t id;
  97.     uint8_t  receiveEst;
  98.   };
  100.   struct SortDbgEntry {
  101.     uint16_t id;
  102.     uint8_t  sendEst;
  103.     uint8_t  hopcount; 
  104.   };
  106.   typedef struct RPEstEntry {
  107.     uint16_t id;
  108.     uint8_t receiveEst;
  109.   } __attribute__ ((packed)) RPEstEntry;
  111.   typedef struct RoutePacket {
  112.     uint16_t parent;
  113.     uint16_t cost;
  114.     uint8_t estEntries;
  115.     RPEstEntry estList[1];
  116.   } __attribute__ ((packed)) RoutePacket;
  118.   typedef struct TableEntry {
  119.     uint16_t id;  // Node Address
  120.     uint16_t parent;
  121.     uint16_t cost;
  122.     uint8_t childLiveliness;
  123.     uint16_t missed;
  124.     uint16_t received;
  125.     int16_t lastSeqno;
  126.     uint8_t flags;
  127.     uint8_t liveliness;
  128.     uint8_t hop;
  129.     uint8_t receiveEst;
  130.     uint8_t sendEst;
  131.   } TableEntry;
  133.   TOS_Msg debugMsg; 
  134.   TOS_Msg routeMsg; 
  135.   bool gfSendRouteBusy;
  136.   bool gSelfTimer;
  138.   TableEntry BaseStation;
  139.   TableEntry NeighborTbl[ROUTE_TABLE_SIZE];
  140.   TableEntry *gpCurrentParent;
  141.   uint8_t gbCurrentHopCount;
  142.   uint16_t gbCurrentCost;
  143.   int16_t gCurrentSeqNo;
  144.   uint16_t gwEstTicks;
  145.   uint32_t gUpdateInterval;
  148.   /*////////////////////////////////////////////////////////*/
  149.   /**
  150.    * Return index into neighbor table of the given node addr
  151.    * @author terence
  152.    * @param id
  153.    * @return index, if not found return ROUTE_INVALID
  154.    */
  156.   uint8_t findEntry(uint16_t id) {
  157.     uint8_t i = 0;
  158.     for (i = 0; i < ROUTE_TABLE_SIZE; i++) {
  159.       if ((NeighborTbl[i].flags & NBRFLAG_VALID) && NeighborTbl[i].id == id) {
  160.         return i;
  161.       }
  162.     }
  163.     return ROUTE_INVALID;
  164.   }
  165.   /*////////////////////////////////////////////////////////*/
  166.   /**
  167.    * This function determines which entry should be replace
  168.    * in this case, we find the one with the lease send estimate
  169.    * @author terence
  170.    * @param void
  171.    * @return index of the table
  172.    */
  174.   uint8_t findEntryToBeReplaced() {
  175.     uint8_t i = 0;
  176.     uint8_t minSendEst = -1;
  177.     uint8_t minSendEstIndex = ROUTE_INVALID;
  178.     for (i = 0; i < ROUTE_TABLE_SIZE; i++) {
  179.       if ((NeighborTbl[i].flags & NBRFLAG_VALID) == 0) {
  180.         return i;
  181.       }
  182.       if (minSendEst >= NeighborTbl[i].sendEst) {
  183.         minSendEst = NeighborTbl[i].sendEst;
  184.         minSendEstIndex = i;
  185.       }
  186.     }
  187.     return minSendEstIndex;
  188.   }
  189.   /*////////////////////////////////////////////////////////*/
  190.   /**
  191.    * This is going to make a new entry give an index and a id
  192.    * @author terence
  193.    * @param index, the index of the table
  194.    * @param id, the node id 
  195.    * @return void
  196.    */
  198.   void newEntry(uint8_t indes, uint16_t id) {
  199.     NeighborTbl[indes].id = id;
  200.     NeighborTbl[indes].flags = (NBRFLAG_VALID | NBRFLAG_NEW);
  201.     NeighborTbl[indes].liveliness = 0;
  202.     NeighborTbl[indes].parent = ROUTE_INVALID;
  203.     NeighborTbl[indes].cost = ROUTE_INVALID;
  204.     NeighborTbl[indes].childLiveliness = 0;
  205.     NeighborTbl[indes].hop = ROUTE_INVALID;
  206.     NeighborTbl[indes].missed = 0;
  207.     NeighborTbl[indes].received = 0;
  208.     NeighborTbl[indes].receiveEst = 0;
  209.     NeighborTbl[indes].sendEst = 0;
  210.     //call Estimator.clearTrackInfo(NeighborTbl[indes].trackInfo);
  211.   }
  214.   /*////////////////////////////////////////////////////////*/
  215.   /**
  216.    * Get neighbor table entry corresponding to the given address.
  217.    * If current entry doesn't exist, then create one, possibly
  218.    * evicting a previous entry. 
  219.    * XXX - what if it evicts the parent???
  220.    *
  221.    * @author terence
  222.    * @param id, node id
  223.    * @return index
  224.    */
  226.   uint8_t findPreparedIndex(uint16_t id) {
  227.     uint8_t indes = findEntry(id);
  228.     if (indes == (uint8_t) ROUTE_INVALID) {
  229.       indes = findEntryToBeReplaced();
  230.       newEntry(indes, id);
  231.     }
  232.     return indes;
  233.   }
  236.   int sortByReceiveEstFcn(const void *x, const void *y) {
  237.     struct SortEntry *nx = (struct SortEntry *) x;
  238.     struct SortEntry *ny = (struct SortEntry *) y;
  239.     uint8_t xReceiveEst = nx->receiveEst, yReceiveEst = ny->receiveEst;
  240.     if (xReceiveEst > yReceiveEst) return -1;
  241.     if (xReceiveEst == yReceiveEst) return 0;
  242.     if (xReceiveEst < yReceiveEst) return 1;
  243.     return 0; // shouldn't reach here becasue it covers all the cases
  244.   }
  246.   int sortDebugEstFcn(const void *x, const void *y) {
  247.     struct SortDbgEntry *nx = (struct SortDbgEntry *) x;
  248.     struct SortDbgEntry *ny = (struct SortDbgEntry *) y;
  249.     uint8_t xReceiveEst = nx->sendEst, yReceiveEst = ny->sendEst;
  250.     if (xReceiveEst > yReceiveEst) return -1;
  251.     if (xReceiveEst == yReceiveEst) return 0;
  252.     if (xReceiveEst < yReceiveEst) return 1;
  253.     return 0; // shouldn't reach here becasue it covers all the cases
  254.   }
  256.   uint32_t evaluateCost(uint16_t cost, uint8_t sendEst, uint8_t receiveEst) {
  257.     uint32_t transEst = (uint32_t) sendEst * (uint32_t) receiveEst;
  258.     uint32_t immed = ((uint32_t) 1 << 24);
  260.     if (transEst == 0) return ((uint32_t) 1 << (uint32_t) 16);
  261.     // DO NOT change this LINE! mica compiler is WEIRD!
  262.     immed = immed / transEst;
  263.     immed += ((uint32_t) cost << 6);
  264.     return immed;
  265.   }
  268.   void updateEst(TableEntry *Nbr) {
  269.     uint16_t usExpTotal, usActTotal, newAve;
  271.     if (Nbr->flags & NBRFLAG_NEW)
  272.       return;
  273.     
  274.     usExpTotal = ESTIMATE_TO_ROUTE_RATIO;
  275.     //if (pNbr->hop != 0) {
  276.     //  usExpTotal *= (1 + DATA_TO_ROUTE_RATIO);
  277.     //}
  278.     dbg(DBG_ROUTE,"MultiHopWMEWMA: Updating Nbr %d. ExpTotl = %d, rcvd= %d, missed = %dn",
  279.         Nbr->id, usExpTotal, Nbr->received, Nbr->missed);
  281.     atomic {
  282.       usActTotal = Nbr->received + Nbr->missed;
  283.       
  284.       if (usActTotal < usExpTotal) {
  285.         usActTotal = usExpTotal;
  286.       }
  287.       
  288.       newAve = ((uint16_t) 255 * (uint16_t)Nbr->received) / (uint16_t)usActTotal;
  289.       Nbr->missed = 0;
  290.       Nbr->received = 0;
  292.       // If we haven't seen a recieveEst for us from our neighbor, decay our sendEst
  293.       // exponentially
  294.       if (Nbr->liveliness  == 0) {
  295.         Nbr->sendEst >>= 1;
  296.       }else{
  297.        Nbr->liveliness --;
  298.       }
  299.     
  300.     }
  301.  
  303.     if (Nbr->flags & NBRFLAG_EST_INIT) {
  304.       uint16_t tmp;
  305.       tmp = ((2 * ((uint16_t)Nbr->receiveEst) + (uint16_t)newAve * 6) / 8);
  306.       Nbr->receiveEst = (uint8_t)tmp;
  307.     }
  308.     else {
  309.       Nbr->receiveEst = (uint8_t) newAve;
  310.       Nbr->flags ^= NBRFLAG_EST_INIT;
  311.     }
  313.      if(Nbr->childLiveliness > 0) Nbr->childLiveliness --;
  314.   }
  316.   void updateTable() {
  317.     TableEntry *pNbr;
  318.     uint8_t i = 0;
  320.     gwEstTicks++;
  321.     gwEstTicks %= ESTIMATE_TO_ROUTE_RATIO;
  323.     for(i = 0; i < ROUTE_TABLE_SIZE; i++) {
  324.       pNbr = &NeighborTbl[i];
  325.       if (pNbr->flags & NBRFLAG_VALID) {
  326.         if (gwEstTicks == 0) 
  327.           updateEst(pNbr);
  328.       }
  329.     }
  330.   }
  332.   bool updateNbrCounters(uint16_t saddr, int16_t seqno, uint8_t *NbrIndex) {
  333.     TableEntry *pNbr;
  334.     int16_t sDelta;
  335.     uint8_t iNbr;
  336.     bool Result = FALSE;  // Result is TRUE if message is a duplicate
  338.     iNbr = findPreparedIndex(saddr);
  339.     pNbr = &NeighborTbl[iNbr];
  341.     sDelta = (seqno - NeighborTbl[iNbr].lastSeqno - 1);
  343.     if (pNbr->flags & NBRFLAG_NEW) {
  344.       pNbr->received++;
  345.       pNbr->lastSeqno = seqno;
  346.       pNbr->flags ^= NBRFLAG_NEW;
  347.     }
  348.     else if (sDelta >= 0) {
  349.       pNbr->missed += sDelta;
  350.       pNbr->received++;
  351.       pNbr->lastSeqno = seqno;
  352.     }
  353.     else if (sDelta < ACCEPTABLE_MISSED) {
  354.       // Something happend to this node.  Reinitialize it's state
  355.       newEntry(iNbr,saddr);
  356.       pNbr->received++;
  357.       pNbr->lastSeqno = seqno;
  358.       pNbr->flags ^= NBRFLAG_NEW;
  359.     }
  360.     else {
  361.       Result = TRUE;
  362.     }
  364.     *NbrIndex = iNbr;
  365.     return Result;
  367.   }
  369.   void chooseParent() {
  370.     TableEntry *pNbr;
  371.     uint32_t ulNbrLinkCost = (uint32_t) -1;
  372.     uint32_t ulNbrTotalCost = (uint32_t) -1;
  373.     uint32_t oldParentCost = (uint32_t) -1;
  374.     uint32_t oldParentLinkCost = (uint32_t) -1;
  375.     uint32_t ulMinTotalCost = (uint32_t) -1;
  376.     TableEntry* pNewParent = NULL;
  377.     TableEntry* pOldParent = NULL;
  378.     uint8_t i;
  380.     if (TOS_LOCAL_ADDRESS == BASE_STATION_ADDRESS) return;
  382.     // Choose the parent based on minimal hopcount and cost.  
  383.     // There is a special case for choosing a base-station as it's 
  384.     // receiveEst may be zero (it's not sending any packets)
  386.     for (i = 0;i < ROUTE_TABLE_SIZE;i++) {
  387.       pNbr = &NeighborTbl[i];
  389.       if (!(pNbr->flags & NBRFLAG_VALID)) continue;
  390.       if (pNbr->parent == TOS_LOCAL_ADDRESS) continue;
  391.       if (pNbr->parent == ROUTE_INVALID) continue;
  392.       if (pNbr->hop == ROUTE_INVALID) continue;
  393.       if (pNbr->cost == (uint16_t) ROUTE_INVALID) continue;
  394.       if (pNbr->sendEst < 25 || pNbr->receiveEst < 25) continue;
  395.       if (pNbr->childLiveliness > 0) continue;
  397.       ulNbrLinkCost = evaluateCost(0, pNbr->sendEst,pNbr->receiveEst);
  398.       ulNbrTotalCost = evaluateCost(pNbr->cost, pNbr->sendEst,pNbr->receiveEst);
  400.       call Leds.greenToggle();
  401.       if (ulNbrLinkCost > MAX_ALLOWABLE_LINK_COST) continue;
  402.       dbg(DBG_ROUTE,"MultiHopWMEWMA node: %d, Cost %d, link Cost, %dn", pNbr->id, ulNbrTotalCost, ulNbrLinkCost);
  403.       if (pNbr == gpCurrentParent) {
  404. pOldParent = pNbr;
  405.    oldParentCost = ulNbrTotalCost;
  406.    oldParentLinkCost = ulNbrLinkCost;
  407.    continue;
  408.       }
  409.       
  410.       if (ulMinTotalCost > ulNbrTotalCost) {
  411.         ulMinTotalCost = ulNbrTotalCost;
  412.         pNewParent = pNbr;
  413.       }
  415.     }
  417.     //now pick between old and new.
  418.     if(pNewParent == NULL) {
  419. //use the old parent unless it is null;
  420. pNewParent = pOldParent;
  421.         ulMinTotalCost = oldParentCost;
  422.     } else if((pOldParent != NULL) &&
  423.               (oldParentCost < (SWITCH_THRESHOLD + ulMinTotalCost))){
  424. //both valid, but use the old parent 
  425. pNewParent = pOldParent;
  426.         ulMinTotalCost = oldParentCost;
  427.     }
  429.     if (pNewParent) {
  430.       atomic {
  431.         gpCurrentParent = pNewParent;
  432.         gbCurrentHopCount = pNewParent->hop + 1;
  433.         gbCurrentCost = ulMinTotalCost >> 6;
  434.       }
  435.     } else {
  436.       atomic {
  437.         gpCurrentParent = NULL;
  438.         gbCurrentHopCount = ROUTE_INVALID;
  439.         gbCurrentCost = ROUTE_INVALID;
  440.       }
  442.     }
  443.   }
  445.   uint8_t last_entry_sent;
  447.   task void SendRouteTask() {
  448.     TOS_MHopMsg *pMHMsg = (TOS_MHopMsg *) &routeMsg.data[0];
  449.     RoutePacket *pRP = (RoutePacket *)&pMHMsg->data[0];
  450.     uint8_t length = offsetof(TOS_MHopMsg,data) + offsetof(RoutePacket,estList);
  451.     uint8_t maxEstEntries;
  452.     uint8_t i,j;
  453.     uint8_t last_index_added = 0;
  455.     if (gfSendRouteBusy) {
  456.       return;
  457.     }
  459.     dbg(DBG_ROUTE,"MultiHopWMEWMA Sending route update msg.n");
  460.     dbg(DBG_ROUTE,"Current cost: %d.n", gbCurrentCost);
  462.     maxEstEntries = TOSH_DATA_LENGTH - length;
  463.     maxEstEntries = maxEstEntries / sizeof(RPEstEntry);
  466.     pRP->parent = (gpCurrentParent) ? gpCurrentParent->id : ROUTE_INVALID;
  467.     pRP->cost = gbCurrentCost; 
  469.     for (i = 0,j = 0;i < ROUTE_TABLE_SIZE && j < maxEstEntries; i++) {
  470.       uint8_t table_index = i + last_entry_sent + 1;
  471.       if(table_index >= ROUTE_TABLE_SIZE) table_index -=ROUTE_TABLE_SIZE;
  472.       if (NeighborTbl[table_index].flags & NBRFLAG_VALID && NeighborTbl[table_index].receiveEst > 100) {
  473.         pRP->estList[j].id = NeighborTbl[table_index].id;
  474.         pRP->estList[j].receiveEst = NeighborTbl[table_index].receiveEst;
  475. j ++;
  476.         length += sizeof(RPEstEntry);
  477. last_index_added = table_index;
  478.         dbg(DBG_ROUTE,"Adding %d to route msg.n", pRP->estList[j].id);
  479.       }
  480.     }
  481.     last_entry_sent = last_index_added;
  482.     dbg(DBG_ROUTE,"Added total of %d entries to route msg.n", j);
  483.     pRP->estEntries = j;
  484.     pMHMsg->sourceaddr = pMHMsg->originaddr = TOS_LOCAL_ADDRESS;
  485.     pMHMsg->hopcount = gbCurrentHopCount;
  486.     pMHMsg->seqno = gCurrentSeqNo++;
  488.     if (call SendMsg.send(TOS_BCAST_ADDR, length, &routeMsg) == SUCCESS) {
  489.       gfSendRouteBusy = TRUE;
  490.     }
  492.   }
  495. #ifdef MULTI_HOP_DEBUG
  496.   task void SendDebugTask() {
  497.     struct SortDbgEntry sortTbl[ROUTE_TABLE_SIZE];
  498.     uint16_t max_length;
  499.     uint8_t length = offsetof(DebugPacket,estList);
  500.     DebugPacket *pRP = (DebugPacket *)call DebugSendMsg.getBuffer(&debugMsg,&max_length);
  501.     uint8_t maxEstEntries;
  502.     uint16_t parent;
  503.     uint8_t i,j;
  505.     dbg(DBG_ROUTE,"MultiHopWMEWMA Sending route debug msg.n");
  507.     maxEstEntries = max_length / sizeof(DBGEstEntry);
  508.     maxEstEntries --;
  509.     parent = (gpCurrentParent) ? gpCurrentParent->id : ROUTE_INVALID;
  511.     for (i = 0,j = 0;i < ROUTE_TABLE_SIZE; i++) {
  512.       if (NeighborTbl[i].flags & NBRFLAG_VALID && NeighborTbl[i].id != parent) {
  513.         sortTbl[j].id = NeighborTbl[i].id;
  514.         sortTbl[j].sendEst = NeighborTbl[i].sendEst;
  515.         sortTbl[j].hopcount = NeighborTbl[i].hop;
  516.         j++;
  517.       }
  518.     }
  519.     qsort (sortTbl,j,sizeof(struct SortDbgEntry),sortDebugEstFcn);
  521.     pRP->estEntries = (j > maxEstEntries) ? maxEstEntries : j;
  522.     pRP->estList[0].id = parent;
  523.     if(gpCurrentParent){
  524. pRP->estList[0].sendEst = gpCurrentParent->sendEst;
  525. pRP->estList[0].hopcount = gpCurrentParent->hop;
  526.     }
  527.     length += sizeof(DBGEstEntry);
  529.     for (i = 0; i < pRP->estEntries; i++) {
  530.       pRP->estList[i+1].id = sortTbl[i].id;
  531.       pRP->estList[i+1].sendEst = sortTbl[i].sendEst;
  532.       pRP->estList[i+1].hopcount = sortTbl[i].hopcount;
  533.       length += sizeof(DBGEstEntry);
  534.     }
  535.     pRP->estEntries ++;
  536.     call DebugSendMsg.send(&debugMsg, length);
  538.   }
  540.   int debugCounter;
  541. #endif
  543.   task void TimerTask() {
  545.     call Leds.redToggle();
  546.     dbg(DBG_ROUTE,"MultiHopWMEWMA timer task.n");
  547.     updateTable();
  549. #ifndef NDEBUG
  550.     {
  551.       int i;
  552.       dbg(DBG_ROUTE,"taddrtprnttcosttmisdtrcvdtlstSthoptrEsttsEsttDescn");
  553.       for (i = 0;i < ROUTE_TABLE_SIZE;i++) {
  554.         if (NeighborTbl[i].flags) {
  555.           dbg(DBG_ROUTE,"t%dt%dt%dt%dt%dt%dt%dt%dt%dt%dn",
  556.               NeighborTbl[i].id,
  557.               NeighborTbl[i].parent,
  558.               NeighborTbl[i].cost,
  559.               NeighborTbl[i].missed,
  560.               NeighborTbl[i].received,
  561.               NeighborTbl[i].lastSeqno,
  562.               NeighborTbl[i].hop,
  563.               NeighborTbl[i].receiveEst,
  564.               NeighborTbl[i].sendEst,
  565.               NeighborTbl[i].childLiveliness);
  566.         }
  567.       }
  568.       if (gpCurrentParent) {
  569.         dbg(DBG_ROUTE,"MultiHopWMEWMA: Parent = %dn",gpCurrentParent->id);
  570.       }
  571.     }
  572. #endif
  573.     chooseParent();
  574. #ifdef MULTI_HOP_DEBUG
  575.     if(TOS_LOCAL_ADDRESS != BASE_STATION_ADDRESS) debugCounter ++;
  576.     if(debugCounter > 1){
  577. post SendDebugTask();
  578. debugCounter = 0;
  579.     }else{
  580. #endif //MULTI_HOP_DEBUG
  581.       call ATimer.start(TIMER_ONE_SHOT, 32);
  582.       //post SendRouteTask();
  583. #ifdef MULTI_HOP_DEBUG
  584.     }
  585. #endif //MULTI_HOP_DEBUG
  587.   }
  589.   event result_t ATimer.fired(){
  590.     post SendRouteTask();
  591.     return SUCCESS;
  592.   }
  594.   command result_t StdControl.init() {
  596.     memset((void *)NeighborTbl,0,(sizeof(TableEntry) * ROUTE_TABLE_SIZE));
  597.     BaseStation.id = TOS_UART_ADDR;
  598.     BaseStation.parent = TOS_UART_ADDR;
  599.     BaseStation.flags = NBRFLAG_VALID;
  600.     BaseStation.hop = 0;
  601.     gpCurrentParent = NULL;
  602.     gbCurrentHopCount = ROUTE_INVALID;
  603.     gCurrentSeqNo = 0;
  604.     gwEstTicks = 0;
  605.     gUpdateInterval = DATA_TO_ROUTE_RATIO * DATA_FREQ;
  606.     gfSendRouteBusy = FALSE;
  607.     gSelfTimer = TRUE;
  609.     return SUCCESS;
  610.   }
  612.   command result_t StdControl.start() {
  614.     if (TOS_LOCAL_ADDRESS == BASE_STATION_ADDRESS) {
  616.       gpCurrentParent = &BaseStation;
  617.       gbCurrentHopCount = 0;
  618.       gbCurrentCost = 0;
  620.     }
  622.     if (gSelfTimer){
  623.       post TimerTask();
  624.       call Timer.start(TIMER_REPEAT,gUpdateInterval);
  625. #ifdef USE_WATCHDOG
  626.   call PoochHandler.start();
  627.   call WDT.start(gUpdateInterval * 5);
  628. #endif
  629.     }
  630.     //  post TimerTask();
  631.     //  call Timer.start(TIMER_REPEAT,gUpdateInterval);
  632.     //}
  633.     //call Leds.redToggle();
  634.     return SUCCESS;
  635.   }
  637.   command result_t StdControl.stop() {
  638.     call Timer.stop();
  639.     return SUCCESS;
  640.   }
  642.   command bool RouteSelect.isActive() {
  643. #if 0
  644.     bool Result = FALSE;
  646.     if (gpCurrentParent != NULL) {
  647.       Result = TRUE;
  648.     }
  650.     return Result;
  651. #endif
  653.     return TRUE;
  654.   }
  657.   void updateDescendant(uint16_t id){
  658. uint8_t indes = findEntry(id);
  659. if (indes == (uint8_t) ROUTE_INVALID) { return;}
  660. else{
  661. NeighborTbl[indes].childLiveliness = MAX_DESCENDANT_LIVE;
  662. }
  663.   }
  665.   command result_t RouteSelect.selectRoute(TOS_MsgPtr Msg, uint8_t id) {
  666.     TOS_MHopMsg *pMHMsg = (TOS_MHopMsg *)&Msg->data[0];
  668.     uint8_t iNbr;
  669.     bool fIsDuplicate;
  670.     result_t Result = SUCCESS;
  673.     if (gpCurrentParent == NULL) {
  674.       // If the msg is locally generated, then send it to the broadcast address
  675.       // This is necessary to seed the network.
  676.       if ((pMHMsg->sourceaddr == TOS_LOCAL_ADDRESS) &&
  677.           (pMHMsg->originaddr == TOS_LOCAL_ADDRESS)) {
  678.         pMHMsg->sourceaddr = TOS_LOCAL_ADDRESS;
  679.         pMHMsg->hopcount = gbCurrentHopCount;
  680.         pMHMsg->seqno = gCurrentSeqNo++;
  681.         Msg->addr = TOS_BCAST_ADDR;
  682.         return SUCCESS;
  683.       }
  684.       else {
  685.         return FAIL;
  686.       }
  687.     }
  689.     if (gbCurrentHopCount >= pMHMsg->hopcount) {
  690.       // Possible cycle??
  691.       return FAIL;
  692.     }
  693.     
  694.     if ((pMHMsg->sourceaddr == TOS_LOCAL_ADDRESS) &&
  695.         (pMHMsg->originaddr == TOS_LOCAL_ADDRESS)) {
  696.       fIsDuplicate = FALSE;
  697.     }
  698.     else {
  699.       fIsDuplicate = updateNbrCounters(pMHMsg->sourceaddr,pMHMsg->seqno,&iNbr);
  700.     }
  702.     if (!fIsDuplicate) {
  703.       pMHMsg->sourceaddr = TOS_LOCAL_ADDRESS;
  704.       pMHMsg->hopcount = gbCurrentHopCount;
  705.       if (gpCurrentParent->id != TOS_UART_ADDR) {
  706.         pMHMsg->seqno = gCurrentSeqNo++;
  707.       }
  708.       Msg->addr = gpCurrentParent->id;
  709.       if(pMHMsg->originaddr != TOS_LOCAL_ADDRESS){
  710.   updateDescendant(pMHMsg->originaddr);
  711.       }
  712.     }
  713.     else {
  714.       Result = FAIL;
  715.     }
  716.     dbg(DBG_ROUTE,"MultiHopWMEWMA: Sequence Number: %dn", pMHMsg->seqno);
  718.     return Result;
  720.   }
  722.   command result_t RouteSelect.initializeFields(TOS_MsgPtr Msg, uint8_t id) {
  723.     TOS_MHopMsg *pMHMsg = (TOS_MHopMsg *)&Msg->data[0];
  725.     pMHMsg->sourceaddr = pMHMsg->originaddr = TOS_LOCAL_ADDRESS;
  726.     pMHMsg->hopcount = ROUTE_INVALID;
  728.     return SUCCESS;
  729.   }
  731.   command uint8_t* RouteSelect.getBuffer(TOS_MsgPtr Msg, uint16_t* Len) {
  733.   }
  735.   command uint16_t RouteControl.getParent() {
  737.     uint16_t addr;
  739.     addr = (gpCurrentParent != NULL) ? gpCurrentParent->id : 0xffff;
  741.     return addr;
  742.   }
  744.   command uint8_t RouteControl.getQuality() {
  745.     uint8_t val;
  747.     val = (gpCurrentParent != NULL) ? gpCurrentParent->sendEst : 0x00;
  749.     return val;
  750.   }
  752.   command uint8_t RouteControl.getDepth() {
  753.     return gbCurrentHopCount;
  754.   }
  756.   command uint8_t RouteControl.getOccupancy() {
  757.     return 0;
  758.   }
  760.   command uint16_t RouteControl.getSender(TOS_MsgPtr msg) {
  761.     TOS_MHopMsg *pMHMsg = (TOS_MHopMsg *)msg->data;
  762.     return pMHMsg->sourceaddr;
  763.   }
  765.   command result_t RouteControl.setUpdateInterval(uint16_t Interval) {
  766.     result_t Result;
  768.     call Timer.stop();
  769.     gUpdateInterval = (Interval * 1024L);  // * 1024 to make the math simpler
  770. gSelfTimer = TRUE;
  771.     Result = call Timer.start(TIMER_REPEAT,gUpdateInterval);
  772. #ifdef USE_WATCHDOG
  773. call PoochHandler.stop();
  774. call PoochHandler.start();
  775. call WDT.start(gUpdateInterval * 5);
  776. #endif
  778.     return Result;
  779.   }
  781.   command result_t RouteControl.manualUpdate() {
  782.     result_t Result;
  783.     
  784.     gSelfTimer = FALSE;
  785.     call Timer.stop();
  786.     Result = post TimerTask();
  787.     return Result;
  788.   }
  792.   event result_t Timer.fired() {
  793.     post TimerTask();
  794.     return SUCCESS;
  795.   }
  797.   event TOS_MsgPtr ReceiveMsg.receive(TOS_MsgPtr Msg) {
  798.     TOS_MHopMsg *pMHMsg = (TOS_MHopMsg *)&Msg->data[0];
  799.     RoutePacket *pRP = (RoutePacket *)&pMHMsg->data[0];
  800.     uint16_t saddr;
  801.     uint8_t i, iNbr;
  803.     call Leds.yellowToggle();
  804. #ifdef USE_WATCHDOG
  805. call WDT.reset();
  806. #endif
  808.     saddr = pMHMsg->sourceaddr;
  810.     updateNbrCounters(saddr,pMHMsg->seqno,&iNbr);
  811.     //    iNbr = findPreparedIndex(saddr);
  813.     NeighborTbl[iNbr].parent = pRP->parent;
  814.     NeighborTbl[iNbr].hop = pMHMsg->hopcount;
  815.     NeighborTbl[iNbr].cost = pRP->cost;
  817.     // If it is no longer my child, clear it
  818.     if (NeighborTbl[iNbr].childLiveliness > 0 && pRP->parent != TOS_LOCAL_ADDRESS)
  819.       NeighborTbl[iNbr].childLiveliness = 0;
  821.     // find out my address, extract the estimation
  822.     for (i = 0; i < pRP->estEntries; i++) {
  823.       if (pRP->estList[i].id == TOS_LOCAL_ADDRESS) {
  824.         NeighborTbl[iNbr].sendEst = pRP->estList[i].receiveEst;
  825.         NeighborTbl[iNbr].liveliness = LIVELINESS;
  826.       }
  827.     }
  829.     return Msg;
  830.   }
  831.   
  832.   event result_t Snoop.intercept[uint8_t id](TOS_MsgPtr Msg, void *Payload, uint16_t Len) {
  833.     TOS_MHopMsg *pMHMsg = (TOS_MHopMsg *)&Msg->data[0];
  834.     uint8_t iNbr;
  836.     updateNbrCounters(pMHMsg->sourceaddr,pMHMsg->seqno,&iNbr);
  837.     
  838.     // Extract routing information if we know this is a multihop message
  839.     // Something in the future.
  841.     return SUCCESS;
  842.   }
  845.   event result_t SendMsg.sendDone(TOS_MsgPtr pMsg, result_t success) {
  846.     gfSendRouteBusy = FALSE;
  848.     return SUCCESS;
  849.   }
  850.   event result_t DebugSendMsg.sendDone(TOS_MsgPtr pMsg, result_t success) {
  851.     return SUCCESS;
  852.   }
  854. }