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

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

网络

开发平台：

Others

app.c：源码内容
  1.   * (volatile uint8_t *)(0x0F + 0x20) = HPLSpiM$OutgoingByte;
  2.   HPLSpiM$SpiByteFifo$dataReady(temp);
  3. }
  5. static inline    
  6. # 1789 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  7. void CC1000RadioIntM$RadioSendCoordinator$default$blockTimer(void)
  8. #line 1789
  9. {
  10. }
  12. # 43 "../../tos/platform/mica2/RadioCoordinator.nc"
  13. inline static   void CC1000RadioIntM$RadioSendCoordinator$blockTimer(void){
  14. #line 43
  15.   CC1000RadioIntM$RadioSendCoordinator$default$blockTimer();
  16. #line 43
  17. }
  18. #line 43
  19. static inline    
  20. # 1794 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  21. void CC1000RadioIntM$RadioReceiveCoordinator$default$blockTimer(void)
  22. #line 1794
  23. {
  24. }
  26. # 43 "../../tos/platform/mica2/RadioCoordinator.nc"
  27. inline static   void CC1000RadioIntM$RadioReceiveCoordinator$blockTimer(void){
  28. #line 43
  29.   CC1000RadioIntM$RadioReceiveCoordinator$default$blockTimer();
  30. #line 43
  31. }
  32. #line 43
  33. static inline    
  34. # 1786 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  35. void CC1000RadioIntM$RadioSendCoordinator$default$startSymbol(uint8_t bitsPerBlock, uint8_t offset, 
  36. TOS_MsgPtr msgBuff)
  37. #line 1787
  38. {
  39. }
  41. # 31 "../../tos/platform/mica2/RadioCoordinator.nc"
  42. inline static   void CC1000RadioIntM$RadioSendCoordinator$startSymbol(uint8_t arg_0x85eba50, uint8_t arg_0x85ebb98, TOS_MsgPtr arg_0x85ebce8){
  43. #line 31
  44.   CC1000RadioIntM$RadioSendCoordinator$default$startSymbol(arg_0x85eba50, arg_0x85ebb98, arg_0x85ebce8);
  45. #line 31
  46. }
  47. #line 31
  48. static inline 
  49. # 264 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  50. void CC1000RadioIntM$AddTime(GTime *C, GTime *A, GTime *B)
  51. #line 264
  52. {
  53.   if (CC1000RadioIntM$MAX_VAL - B->sticks < A->sticks) {
  54.       C->sticks = A->sticks - (CC1000RadioIntM$MAX_VAL - B->sticks);
  55.       C->mticks = A->mticks + B->mticks + 1;
  56.     }
  57.   else {
  58.       C->sticks = A->sticks + B->sticks;
  59.       C->mticks = A->mticks + B->mticks;
  60.     }
  61. }
  63. static inline    
  64. #line 1788
  65. void CC1000RadioIntM$RadioSendCoordinator$default$byte(TOS_MsgPtr msg, uint8_t byteCount)
  66. #line 1788
  67. {
  68. }
  70. # 36 "../../tos/platform/mica2/RadioCoordinator.nc"
  71. inline static   void CC1000RadioIntM$RadioSendCoordinator$byte(TOS_MsgPtr arg_0x85f8180, uint8_t arg_0x85f82d0){
  72. #line 36
  73.   CC1000RadioIntM$RadioSendCoordinator$default$byte(arg_0x85f8180, arg_0x85f82d0);
  74. #line 36
  75. }
  76. #line 36
  77. static inline  
  78. # 239 "/home/testuser/tinyos-1.x/tos/system/AMPromiscuous.nc"
  79. result_t AMPromiscuous$RadioSend$sendDone(TOS_MsgPtr msg, result_t success)
  80. #line 239
  81. {
  82.   return AMPromiscuous$reportSendDone(msg, success);
  83. }
  85. # 67 "/home/testuser/tinyos-1.x/tos/interfaces/BareSendMsg.nc"
  86. inline static  result_t CC1000RadioIntM$Send$sendDone(TOS_MsgPtr arg_0x85bb080, result_t arg_0x85bb1d0){
  87. #line 67
  88.   unsigned char result;
  89. #line 67
  91. #line 67
  92.   result = AMPromiscuous$RadioSend$sendDone(arg_0x85bb080, arg_0x85bb1d0);
  93. #line 67
  95. #line 67
  96.   return result;
  97. #line 67
  98. }
  99. #line 67
  100. static inline  
  101. # 506 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  102. void CC1000RadioIntM$PacketSent(void)
  103. #line 506
  104. {
  105.   TOS_MsgPtr pBuf;
  107. #line 508
  108.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  109. #line 508
  110.     {
  111.       CC1000RadioIntM$txbufptr->time = 0;
  112.       pBuf = CC1000RadioIntM$txbufptr;
  113.     }
  114. #line 511
  115.     __nesc_atomic_end(__nesc_atomic); }
  117.   if (CC1000RadioIntM$txbufptr->type != 222 && CC1000RadioIntM$txbufptr->type != 223) {
  120.       CC1000RadioIntM$Send$sendDone((TOS_MsgPtr )pBuf, SUCCESS);
  121.     }
  122.   else {
  123. #line 517
  124.     if (CC1000RadioIntM$txbufptr->type == 223) {
  125.       }
  126.     else {
  128.       if (CC1000RadioIntM$txbufptr->type == 222) {
  129.         }
  130.       }
  131.     }
  134.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  135. #line 527
  136.     CC1000RadioIntM$bTxBusy = FALSE;
  137. #line 527
  138.     __nesc_atomic_end(__nesc_atomic); }
  139.   if (CC1000RadioIntM$pktsLastSync > 100) {
  140.       { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  141. #line 529
  142.         {
  143.           CC1000RadioIntM$ackOrig = CC1000RadioIntM$bAckEnable;
  144.           CC1000RadioIntM$bAckEnable = FALSE;
  145.         }
  146. #line 532
  147.         __nesc_atomic_end(__nesc_atomic); }
  148.       CC1000RadioIntM$Send$send(&CC1000RadioIntM$syncMsgHdr);
  149.       CC1000RadioIntM$pktsLastSync = 0;
  150.     }
  151.   else {
  152. #line 535
  153.     if (CC1000RadioIntM$currentMAC == CC1000RadioIntM$ZMAC && CC1000RadioIntM$ecnforward == TRUE) {
  154.         { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  155. #line 536
  156.           {
  157.             CC1000RadioIntM$ackOrig = CC1000RadioIntM$bAckEnable;
  158.             CC1000RadioIntM$bAckEnable = FALSE;
  159.           }
  160. #line 539
  161.           __nesc_atomic_end(__nesc_atomic); }
  162.         CC1000RadioIntM$Send$send(&CC1000RadioIntM$ecnForwardMsgHdr);
  163.         { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  164. #line 541
  165.           CC1000RadioIntM$ecnforward = FALSE;
  166. #line 541
  167.           __nesc_atomic_end(__nesc_atomic); }
  168.       }
  169.     else {
  171.       if (CC1000RadioIntM$currentMAC == CC1000RadioIntM$ZMAC && CC1000RadioIntM$ecnPending == TRUE) {
  172.           { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  173. #line 546
  174.             {
  175.               CC1000RadioIntM$ackOrig = CC1000RadioIntM$bAckEnable;
  176.               CC1000RadioIntM$bAckEnable = FALSE;
  177.             }
  178. #line 549
  179.             __nesc_atomic_end(__nesc_atomic); }
  180.           CC1000RadioIntM$Send$send(&CC1000RadioIntM$ecnMsgHdr);
  181.           { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  182. #line 551
  183.             CC1000RadioIntM$ecnPending = FALSE;
  184. #line 551
  185.             __nesc_atomic_end(__nesc_atomic); }
  186.           { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  187. #line 552
  188.             CC1000RadioIntM$slots_since_ecnsend = 0;
  189. #line 552
  190.             __nesc_atomic_end(__nesc_atomic); }
  191.         }
  192.       }
  193.     }
  194. }
  196. static inline 
  197. #line 329
  198. bool CC1000RadioIntM$IsHCL(uint32_t gSlot)
  199. #line 329
  200. {
  201.   uint32_t tempHCL = 0x1;
  202.   bool flag;
  204. #line 332
  205.   tempHCL = tempHCL << gSlot;
  206.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  207. #line 333
  208.     {
  209.       if (tempHCL & CC1000RadioIntM$curHCLlist) {
  210.         flag = TRUE;
  211.         }
  212.       else {
  213. #line 337
  214.         flag = FALSE;
  215.         }
  216.     }
  217. #line 339
  218.     __nesc_atomic_end(__nesc_atomic); }
  219. #line 339
  220.   return flag;
  221. }
  223. # 81 "/home/testuser/tinyos-1.x/tos/interfaces/Leds.nc"
  224. inline static   result_t CC1000RadioIntM$Leds$redToggle(void){
  225. #line 81
  226.   unsigned char result;
  227. #line 81
  229. #line 81
  230.   result = NoLeds$Leds$redToggle();
  231. #line 81
  233. #line 81
  234.   return result;
  235. #line 81
  236. }
  237. #line 81
  238. static inline    
  239. # 1791 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  240. void CC1000RadioIntM$RadioReceiveCoordinator$default$startSymbol(uint8_t bitsPerBlock, uint8_t offset, 
  241. TOS_MsgPtr msgBuff)
  242. #line 1792
  243. {
  244. }
  246. # 31 "../../tos/platform/mica2/RadioCoordinator.nc"
  247. inline static   void CC1000RadioIntM$RadioReceiveCoordinator$startSymbol(uint8_t arg_0x85eba50, uint8_t arg_0x85ebb98, TOS_MsgPtr arg_0x85ebce8){
  248. #line 31
  249.   CC1000RadioIntM$RadioReceiveCoordinator$default$startSymbol(arg_0x85eba50, arg_0x85ebb98, arg_0x85ebce8);
  250. #line 31
  251. }
  252. #line 31
  253. static inline    
  254. # 1793 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  255. void CC1000RadioIntM$RadioReceiveCoordinator$default$byte(TOS_MsgPtr msg, uint8_t byteCount)
  256. #line 1793
  257. {
  258. }
  260. # 36 "../../tos/platform/mica2/RadioCoordinator.nc"
  261. inline static   void CC1000RadioIntM$RadioReceiveCoordinator$byte(TOS_MsgPtr arg_0x85f8180, uint8_t arg_0x85f82d0){
  262. #line 36
  263.   CC1000RadioIntM$RadioReceiveCoordinator$default$byte(arg_0x85f8180, arg_0x85f82d0);
  264. #line 36
  265. }
  266. #line 36
  267. static inline 
  268. # 253 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  269. void CC1000RadioIntM$DivTime2(GTime *B, GTime *A)
  270. #line 253
  271. {
  272.   if (A->mticks % 2 == 1) {
  273.       B->mticks = A->mticks >> 1;
  274.       B->sticks = (A->sticks >> 1) + (CC1000RadioIntM$MAX_VAL >> 1);
  275.     }
  276.   else {
  277.       B->mticks = A->mticks >> 1;
  278.       B->sticks = A->sticks >> 1;
  279.     }
  280. }
  282. static inline 
  283. #line 306
  284. uint8_t CC1000RadioIntM$ModSubTime(GTime *C, GTime *A, GTime *B)
  285. #line 306
  286. {
  287.   uint8_t retval;
  289. #line 308
  290.   if (A->mticks > B->mticks) {
  291.     retval = CC1000RadioIntM$POSITIVE;
  292.     }
  293.   else {
  294. #line 310
  295.     if (A->mticks < B->mticks) {
  296.       retval = CC1000RadioIntM$NEGATIVE;
  297.       }
  298.     else 
  299. #line 312
  300.       {
  301.         if (A->sticks > B->sticks) {
  302.           retval = CC1000RadioIntM$POSITIVE;
  303.           }
  304.         else {
  305. #line 315
  306.           if (A->sticks < B->sticks) {
  307.             retval = CC1000RadioIntM$NEGATIVE;
  308.             }
  309.           else {
  310. #line 318
  311.             retval = CC1000RadioIntM$ZERO;
  312.             }
  313.           }
  314.       }
  315.     }
  316. #line 320
  317.   if (retval == CC1000RadioIntM$POSITIVE) {
  318. #line 320
  319.     CC1000RadioIntM$SubTime(C, A, B);
  320.     }
  321.   else {
  322. #line 321
  323.     if (retval == CC1000RadioIntM$NEGATIVE) {
  324. #line 321
  325.       CC1000RadioIntM$SubTime(C, B, A);
  326.       }
  327.     else 
  328. #line 322
  329.       {
  330.         C->sticks = 0;
  331.         C->mticks = 0;
  332.       }
  333.     }
  334. #line 326
  335.   return retval;
  336. }
  338. # 63 "../../tos/interfaces/SClock.nc"
  339. inline static   void CC1000RadioIntM$SClock$getTime(GTime *arg_0x862b720){
  340. #line 63
  341.   HPLSClock$SClock$getTime(arg_0x862b720);
  342. #line 63
  343. }
  344. #line 63
  345. static inline 
  346. # 387 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  347. void CC1000RadioIntM$getTimeDiff(void)
  348. #line 387
  349. {
  350.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  351. #line 388
  352.     {
  353.       uint16_t i;
  354. #line 389
  355.       uint16_t trust;
  356.       GTime loctime;
  357. #line 390
  358.       GTime timeStamp;
  359.       syncMsgType *syncMsgPtr = (syncMsgType *)CC1000RadioIntM$rxbufptr->data;
  361. #line 392
  362.       timeStamp.mticks = syncMsgPtr->mticks;
  363.       timeStamp.sticks = syncMsgPtr->sticks;
  364.       trust = syncMsgPtr->trust;
  365.       CC1000RadioIntM$currentSender = syncMsgPtr->sender;
  366.       CC1000RadioIntM$SClock$getTime(&loctime);
  367.       CC1000RadioIntM$currentSign = CC1000RadioIntM$ModSubTime(&CC1000RadioIntM$currentDiff, &timeStamp, &loctime);
  369.       if (trust < 1) {
  370.         trust = 1;
  371.         }
  372. #line 401
  373.       if (trust < 8) {
  374.           for (i = 0; i < trust; i++) {
  375.               CC1000RadioIntM$DivTime2(&CC1000RadioIntM$currentDiff, &CC1000RadioIntM$currentDiff);
  376.             }
  377.         }
  378.     }
  379. #line 406
  380.     __nesc_atomic_end(__nesc_atomic); }
  381. }
  383. static inline   
  384. # 107 "../../tos/platform/mica2/HPLSClock.nc"
  385. void HPLSClock$SClock$setTime(uint8_t PosOrNeg, GTime *t)
  386. #line 107
  387. {
  388.   HPLSClock$sign = PosOrNeg;
  389.   HPLSClock$Update.mticks = t->mticks;
  390.   HPLSClock$Update.sticks = t->sticks;
  391.   HPLSClock$needupdate = 1;
  392. }
  394. # 69 "../../tos/interfaces/SClock.nc"
  395. inline static   void CC1000RadioIntM$SClock$setTime(uint8_t arg_0x862bb68, GTime *arg_0x862bcc8){
  396. #line 69
  397.   HPLSClock$SClock$setTime(arg_0x862bb68, arg_0x862bcc8);
  398. #line 69
  399. }
  400. #line 69
  401. static inline  
  402. # 424 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  403. void CC1000RadioIntM$adjustTime(void)
  404. #line 424
  405. {
  406.   CC1000RadioIntM$needTimeSync = TRUE;
  407.   CC1000RadioIntM$SClock$setTime(CC1000RadioIntM$currentSign, &CC1000RadioIntM$currentDiff);
  408. }
  410. static inline  
  411. # 279 "/home/testuser/tinyos-1.x/tos/system/AMPromiscuous.nc"
  412. TOS_MsgPtr AMPromiscuous$RadioReceive$receive(TOS_MsgPtr packet)
  413. #line 279
  414. {
  415.   return prom_received(packet);
  416. }
  418. # 75 "/home/testuser/tinyos-1.x/tos/interfaces/ReceiveMsg.nc"
  419. inline static  TOS_MsgPtr CC1000RadioIntM$Receive$receive(TOS_MsgPtr arg_0x85b1db0){
  420. #line 75
  421.   struct TOS_Msg *result;
  422. #line 75
  424. #line 75
  425.   result = AMPromiscuous$RadioReceive$receive(arg_0x85b1db0);
  426. #line 75
  428. #line 75
  429.   return result;
  430. #line 75
  431. }
  432. #line 75
  433. static inline   
  434. # 1806 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  435. result_t CC1000RadioIntM$SClock$syncDone(void)
  436. #line 1806
  437. {
  438.   if (CC1000RadioIntM$needTimeSync) {
  439.       GTime loctime;
  440.       uint32_t globalTimeStamp;
  441. #line 1809
  442.       uint32_t slotOffset;
  444. #line 1810
  445.       CC1000RadioIntM$SClock$getTime(&loctime);
  446.       globalTimeStamp = (uint32_t )(loctime.mticks * 568.889 + loctime.sticks * 0.00868056);
  447.       slotOffset = (uint32_t )(1.024 * (CC1000RadioIntM$slotSize - globalTimeStamp % CC1000RadioIntM$slotSize));
  448.       CC1000RadioIntM$slotNum = (uint32_t )(globalTimeStamp / CC1000RadioIntM$slotSize);
  449.       CC1000RadioIntM$currentSlot = CC1000RadioIntM$slotNum & (CC1000RadioIntM$localFrameLength - 1);
  450.       CC1000RadioIntM$globalSlot = CC1000RadioIntM$slotNum & (CC1000RadioIntM$globalFrameLength - 1);
  452.       if (CC1000RadioIntM$currentMAC == CC1000RadioIntM$ZMAC) {
  453.         CC1000RadioIntM$TDMATimer$start(TIMER_ONE_SHOT, slotOffset);
  454.         }
  455. #line 1819
  456.       CC1000RadioIntM$needTimeSync = FALSE;
  457.     }
  458.   return SUCCESS;
  459. }
  461. # 94 "../../tos/interfaces/SClock.nc"
  462. inline static   result_t HPLSClock$SClock$syncDone(void){
  463. #line 94
  464.   unsigned char result;
  465. #line 94
  467. #line 94
  468.   result = CC1000RadioIntM$SClock$syncDone();
  469. #line 94
  471. #line 94
  472.   return result;
  473. #line 94
  474. }
  475. #line 94
  476. # 66 "/home/testuser/tinyos-1.x/tos/interfaces/ByteComm.nc"
  477. inline static   result_t UARTM$ByteComm$rxByteReady(uint8_t arg_0x88b0c30, bool arg_0x88b0d78, uint16_t arg_0x88b0ed0){
  478. #line 66
  479.   unsigned char result;
  480. #line 66
  482. #line 66
  483.   result = FramerM$ByteComm$rxByteReady(arg_0x88b0c30, arg_0x88b0d78, arg_0x88b0ed0);
  484. #line 66
  486. #line 66
  487.   return result;
  488. #line 66
  489. }
  490. #line 66
  491. static inline   
  492. # 77 "/home/testuser/tinyos-1.x/tos/system/UARTM.nc"
  493. result_t UARTM$HPLUART$get(uint8_t data)
  494. #line 77
  495. {
  500.   UARTM$ByteComm$rxByteReady(data, FALSE, 0);
  501.   {
  502.   }
  503. #line 83
  504.   ;
  505.   return SUCCESS;
  506. }
  508. # 88 "/home/testuser/tinyos-1.x/tos/interfaces/HPLUART.nc"
  509. inline static   result_t HPLUART0M$UART$get(uint8_t arg_0x88d4fc8){
  510. #line 88
  511.   unsigned char result;
  512. #line 88
  514. #line 88
  515.   result = UARTM$HPLUART$get(arg_0x88d4fc8);
  516. #line 88
  518. #line 88
  519.   return result;
  520. #line 88
  521. }
  522. #line 88
  523. # 90 "../../tos/platform/mica2/HPLUART0M.nc"
  524. void __attribute((signal))   __vector_18(void)
  525. #line 90
  526. {
  527.   if (* (volatile uint8_t *)(0x0B + 0x20) & (1 << 7)) {
  528.     HPLUART0M$UART$get(* (volatile uint8_t *)(0x0C + 0x20));
  529.     }
  530. }
  532. static inline  
  533. # 202 "/home/testuser/tinyos-1.x/tos/system/FramerM.nc"
  534. void FramerM$PacketUnknown(void)
  535. #line 202
  536. {
  537.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  538. #line 203
  539.     {
  540.       FramerM$gFlags |= FramerM$FLAGS_UNKNOWN;
  541.     }
  542. #line 205
  543.     __nesc_atomic_end(__nesc_atomic); }
  545.   FramerM$StartTx();
  546. }
  548. static inline  
  549. # 275 "/home/testuser/tinyos-1.x/tos/system/AMPromiscuous.nc"
  550. TOS_MsgPtr AMPromiscuous$UARTReceive$receive(TOS_MsgPtr packet)
  551. #line 275
  552. {
  553.   packet->group = TOS_AM_GROUP;
  554.   return prom_received(packet);
  555. }
  557. # 75 "/home/testuser/tinyos-1.x/tos/interfaces/ReceiveMsg.nc"
  558. inline static  TOS_MsgPtr FramerAckM$ReceiveCombined$receive(TOS_MsgPtr arg_0x85b1db0){
  559. #line 75
  560.   struct TOS_Msg *result;
  561. #line 75
  563. #line 75
  564.   result = AMPromiscuous$UARTReceive$receive(arg_0x85b1db0);
  565. #line 75
  567. #line 75
  568.   return result;
  569. #line 75
  570. }
  571. #line 75
  572. static inline  
  573. # 91 "/home/testuser/tinyos-1.x/tos/system/FramerAckM.nc"
  574. TOS_MsgPtr FramerAckM$ReceiveMsg$receive(TOS_MsgPtr Msg)
  575. #line 91
  576. {
  577.   TOS_MsgPtr pBuf;
  579.   pBuf = FramerAckM$ReceiveCombined$receive(Msg);
  581.   return pBuf;
  582. }
  584. # 75 "/home/testuser/tinyos-1.x/tos/interfaces/ReceiveMsg.nc"
  585. inline static  TOS_MsgPtr FramerM$ReceiveMsg$receive(TOS_MsgPtr arg_0x85b1db0){
  586. #line 75
  587.   struct TOS_Msg *result;
  588. #line 75
  590. #line 75
  591.   result = FramerAckM$ReceiveMsg$receive(arg_0x85b1db0);
  592. #line 75
  594. #line 75
  595.   return result;
  596. #line 75
  597. }
  598. #line 75
  599. static inline  
  600. # 328 "/home/testuser/tinyos-1.x/tos/system/FramerM.nc"
  601. result_t FramerM$TokenReceiveMsg$ReflectToken(uint8_t Token)
  602. #line 328
  603. {
  604.   result_t Result = SUCCESS;
  606.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  607. #line 331
  608.     {
  609.       if (!(FramerM$gFlags & FramerM$FLAGS_TOKENPEND)) {
  610.           FramerM$gFlags |= FramerM$FLAGS_TOKENPEND;
  611.           FramerM$gTxTokenBuf = Token;
  612.         }
  613.       else {
  614.           Result = FAIL;
  615.         }
  616.     }
  617. #line 339
  618.     __nesc_atomic_end(__nesc_atomic); }
  620.   if (Result == SUCCESS) {
  621.       Result = FramerM$StartTx();
  622.     }
  624.   return Result;
  625. }
  627. # 88 "/home/testuser/tinyos-1.x/tos/interfaces/TokenReceiveMsg.nc"
  628. inline static  result_t FramerAckM$TokenReceiveMsg$ReflectToken(uint8_t arg_0x88b2a98){
  629. #line 88
  630.   unsigned char result;
  631. #line 88
  633. #line 88
  634.   result = FramerM$TokenReceiveMsg$ReflectToken(arg_0x88b2a98);
  635. #line 88
  637. #line 88
  638.   return result;
  639. #line 88
  640. }
  641. #line 88
  642. static inline  
  643. # 74 "/home/testuser/tinyos-1.x/tos/system/FramerAckM.nc"
  644. void FramerAckM$SendAckTask(void)
  645. #line 74
  646. {
  648.   FramerAckM$TokenReceiveMsg$ReflectToken(FramerAckM$gTokenBuf);
  649. }
  651. static inline  TOS_MsgPtr FramerAckM$TokenReceiveMsg$receive(TOS_MsgPtr Msg, uint8_t token)
  652. #line 79
  653. {
  654.   TOS_MsgPtr pBuf;
  656.   FramerAckM$gTokenBuf = token;
  658.   TOS_post(FramerAckM$SendAckTask);
  660.   pBuf = FramerAckM$ReceiveCombined$receive(Msg);
  662.   return pBuf;
  663. }
  665. # 75 "/home/testuser/tinyos-1.x/tos/interfaces/TokenReceiveMsg.nc"
  666. inline static  TOS_MsgPtr FramerM$TokenReceiveMsg$receive(TOS_MsgPtr arg_0x88b2338, uint8_t arg_0x88b2480){
  667. #line 75
  668.   struct TOS_Msg *result;
  669. #line 75
  671. #line 75
  672.   result = FramerAckM$TokenReceiveMsg$receive(arg_0x88b2338, arg_0x88b2480);
  673. #line 75
  675. #line 75
  676.   return result;
  677. #line 75
  678. }
  679. #line 75
  680. static inline  
  681. # 210 "/home/testuser/tinyos-1.x/tos/system/FramerM.nc"
  682. void FramerM$PacketRcvd(void)
  683. #line 210
  684. {
  685.   FramerM$MsgRcvEntry_t *pRcv = &FramerM$gMsgRcvTbl[FramerM$gRxTailIndex];
  686.   TOS_MsgPtr pBuf = pRcv->pMsg;
  689.   if (pRcv->Length >= (size_t )& ((TOS_Msg *)0)->data) {
  691.       switch (pRcv->Proto) {
  692.           case FramerM$PROTO_ACK: 
  693.             break;
  694.           case FramerM$PROTO_PACKET_ACK: 
  695.             pBuf->crc = 1;
  696.           pBuf = FramerM$TokenReceiveMsg$receive(pBuf, pRcv->Token);
  697.           break;
  698.           case FramerM$PROTO_PACKET_NOACK: 
  699.             pBuf->crc = 1;
  700.           pBuf = FramerM$ReceiveMsg$receive(pBuf);
  701.           break;
  702.           default: 
  703.             FramerM$gTxUnknownBuf = pRcv->Proto;
  704.           TOS_post(FramerM$PacketUnknown);
  705.           break;
  706.         }
  707.     }
  709.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  710. #line 235
  711.     {
  712.       if (pBuf) {
  713.           pRcv->pMsg = pBuf;
  714.         }
  715.       pRcv->Length = 0;
  716.       pRcv->Token = 0;
  717.       FramerM$gRxTailIndex++;
  718.       FramerM$gRxTailIndex %= FramerM$HDLC_QUEUESIZE;
  719.     }
  720. #line 243
  721.     __nesc_atomic_end(__nesc_atomic); }
  722. }
  724. # 96 "/home/testuser/tinyos-1.x/tos/interfaces/HPLUART.nc"
  725. inline static   result_t HPLUART0M$UART$putDone(void){
  726. #line 96
  727.   unsigned char result;
  728. #line 96
  730. #line 96
  731.   result = UARTM$HPLUART$putDone();
  732. #line 96
  734. #line 96
  735.   return result;
  736. #line 96
  737. }
  738. #line 96
  739. # 100 "../../tos/platform/mica2/HPLUART0M.nc"
  740. void __attribute((interrupt))   __vector_20(void)
  741. #line 100
  742. {
  743.   HPLUART0M$UART$putDone();
  744. }
  746. static inline   
  747. # 552 "/home/testuser/tinyos-1.x/tos/system/FramerM.nc"
  748. result_t FramerM$ByteComm$txDone(void)
  749. #line 552
  750. {
  752.   if (FramerM$gTxState == FramerM$TXSTATE_FINISH) {
  753.       FramerM$gTxState = FramerM$TXSTATE_IDLE;
  754.       TOS_post(FramerM$PacketSent);
  755.     }
  757.   return SUCCESS;
  758. }
  760. # 83 "/home/testuser/tinyos-1.x/tos/interfaces/ByteComm.nc"
  761. inline static   result_t UARTM$ByteComm$txDone(void){
  762. #line 83
  763.   unsigned char result;
  764. #line 83
  766. #line 83
  767.   result = FramerM$ByteComm$txDone();
  768. #line 83
  770. #line 83
  771.   return result;
  772. #line 83
  773. }
  774. #line 83
  775. #line 55
  776. inline static   result_t FramerM$ByteComm$txByte(uint8_t arg_0x88b07a0){
  777. #line 55
  778.   unsigned char result;
  779. #line 55
  781. #line 55
  782.   result = UARTM$ByteComm$txByte(arg_0x88b07a0);
  783. #line 55
  785. #line 55
  786.   return result;
  787. #line 55
  788. }
  789. #line 55
  790. static inline 
  791. # 66 "/home/testuser/tinyos-1.x/tos/platform/avrmote/crc.h"
  792. uint16_t crcByte(uint16_t oldCrc, uint8_t byte)
  793. {
  795.   uint16_t *table = crcTable;
  796.   uint16_t newCrc;
  798.    __asm ("eor %1,%B3n"
  799.   "tlsl %1n"
  800.   "tadc %B2, __zero_reg__n"
  801.   "tadd %A2, %1n"
  802.   "tadc %B2, __zero_reg__n"
  803.   "tlpmn"
  804.   "tmov %B0, %A3n"
  805.   "tmov %A0, r0n"
  806.   "tadiw r30,1n"
  807.   "tlpmn"
  808.   "teor %B0, r0" : 
  809.   "=r"(newCrc), "+r"(byte), "+z"(table) : "r"(oldCrc));
  810.   return newCrc;
  811. }
  813. static inline   
  814. # 482 "/home/testuser/tinyos-1.x/tos/system/FramerM.nc"
  815. result_t FramerM$ByteComm$txByteReady(bool LastByteSuccess)
  816. #line 482
  817. {
  818.   result_t TxResult = SUCCESS;
  819.   uint8_t nextByte;
  821.   if (LastByteSuccess != TRUE) {
  822.       { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  823. #line 487
  824.         FramerM$gTxState = FramerM$TXSTATE_ERROR;
  825. #line 487
  826.         __nesc_atomic_end(__nesc_atomic); }
  827.       TOS_post(FramerM$PacketSent);
  828.       return SUCCESS;
  829.     }
  831.   switch (FramerM$gTxState) {
  833.       case FramerM$TXSTATE_PROTO: 
  834.         FramerM$gTxState = FramerM$TXSTATE_INFO;
  835.       FramerM$gTxRunningCRC = crcByte(FramerM$gTxRunningCRC, (uint8_t )(FramerM$gTxProto & 0x0FF));
  836.       TxResult = FramerM$ByteComm$txByte((uint8_t )(FramerM$gTxProto & 0x0FF));
  837.       break;
  839.       case FramerM$TXSTATE_INFO: 
  840.         nextByte = FramerM$gpTxBuf[FramerM$gTxByteCnt];
  842.       FramerM$gTxRunningCRC = crcByte(FramerM$gTxRunningCRC, nextByte);
  843.       FramerM$gTxByteCnt++;
  844.       if (FramerM$gTxByteCnt >= FramerM$gTxLength) {
  845.           FramerM$gTxState = FramerM$TXSTATE_FCS1;
  846.         }
  848.       TxResult = FramerM$TxArbitraryByte(nextByte);
  849.       break;
  851.       case FramerM$TXSTATE_ESC: 
  853.         TxResult = FramerM$ByteComm$txByte(FramerM$gTxEscByte ^ 0x20);
  854.       FramerM$gTxState = FramerM$gPrevTxState;
  855.       break;
  857.       case FramerM$TXSTATE_FCS1: 
  858.         nextByte = (uint8_t )(FramerM$gTxRunningCRC & 0xff);
  859.       FramerM$gTxState = FramerM$TXSTATE_FCS2;
  860.       TxResult = FramerM$TxArbitraryByte(nextByte);
  861.       break;
  863.       case FramerM$TXSTATE_FCS2: 
  864.         nextByte = (uint8_t )((FramerM$gTxRunningCRC >> 8) & 0xff);
  865.       FramerM$gTxState = FramerM$TXSTATE_ENDFLAG;
  866.       TxResult = FramerM$TxArbitraryByte(nextByte);
  867.       break;
  869.       case FramerM$TXSTATE_ENDFLAG: 
  870.         FramerM$gTxState = FramerM$TXSTATE_FINISH;
  871.       TxResult = FramerM$ByteComm$txByte(FramerM$HDLC_FLAG_BYTE);
  873.       break;
  875.       case FramerM$TXSTATE_FINISH: 
  876.         case FramerM$TXSTATE_ERROR: 
  878.           default: 
  879.             break;
  880.     }
  883.   if (TxResult != SUCCESS) {
  884.       FramerM$gTxState = FramerM$TXSTATE_ERROR;
  885.       TOS_post(FramerM$PacketSent);
  886.     }
  888.   return SUCCESS;
  889. }
  891. # 75 "/home/testuser/tinyos-1.x/tos/interfaces/ByteComm.nc"
  892. inline static   result_t UARTM$ByteComm$txByteReady(bool arg_0x88b1400){
  893. #line 75
  894.   unsigned char result;
  895. #line 75
  897. #line 75
  898.   result = FramerM$ByteComm$txByteReady(arg_0x88b1400);
  899. #line 75
  901. #line 75
  902.   return result;
  903. #line 75
  904. }
  905. #line 75
  906. # 102 "/home/testuser/tinyos-1.x/tos/system/sched.c"
  907. bool  TOS_post(void (*tp)(void))
  908. #line 102
  909. {
  910.   __nesc_atomic_t fInterruptFlags;
  911.   uint8_t tmp;
  915.   fInterruptFlags = __nesc_atomic_start();
  917.   tmp = TOSH_sched_free;
  919.   if (TOSH_queue[tmp].tp == (void *)0) {
  920.       TOSH_sched_free = (tmp + 1) & TOSH_TASK_BITMASK;
  921.       TOSH_queue[tmp].tp = tp;
  922.       __nesc_atomic_end(fInterruptFlags);
  924.       return TRUE;
  925.     }
  926.   else {
  927.       __nesc_atomic_end(fInterruptFlags);
  929.       return FALSE;
  930.     }
  931. }
  933. # 54 "/home/testuser/tinyos-1.x/tos/system/RealMain.nc"
  934. int   main(void)
  935. #line 54
  936. {
  937.   RealMain$hardwareInit();
  938.   RealMain$Pot$init(10);
  939.   TOSH_sched_init();
  941.   RealMain$StdControl$init();
  942.   RealMain$StdControl$start();
  943.   __nesc_enable_interrupt();
  945.   while (1) {
  946.       TOSH_run_task();
  947.     }
  948. }
  950. static  
  951. # 77 "/home/testuser/tinyos-1.x/tos/system/TimerM.nc"
  952. result_t TimerM$StdControl$init(void)
  953. #line 77
  954. {
  955.   TimerM$mState = 0;
  956.   TimerM$setIntervalFlag = 0;
  957.   TimerM$queue_head = TimerM$queue_tail = -1;
  958.   TimerM$queue_size = 0;
  959.   TimerM$mScale = 3;
  960.   TimerM$mInterval = TimerM$maxTimerInterval;
  961.   return TimerM$Clock$setRate(TimerM$mInterval, TimerM$mScale);
  962. }
  964. static 
  965. # 268 "/home/testuser/tinyos-1.x/tos/system/FramerM.nc"
  966. void FramerM$HDLCInitialize(void)
  967. #line 268
  968. {
  969.   int i;
  971. #line 270
  972.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  973. #line 270
  974.     {
  975.       for (i = 0; i < FramerM$HDLC_QUEUESIZE; i++) {
  976.           FramerM$gMsgRcvTbl[i].pMsg = &FramerM$gMsgRcvBuf[i];
  977.           FramerM$gMsgRcvTbl[i].Length = 0;
  978.           FramerM$gMsgRcvTbl[i].Token = 0;
  979.         }
  980.       FramerM$gTxState = FramerM$TXSTATE_IDLE;
  981.       FramerM$gTxByteCnt = 0;
  982.       FramerM$gTxLength = 0;
  983.       FramerM$gTxRunningCRC = 0;
  984.       FramerM$gpTxMsg = (void *)0;
  986.       FramerM$gRxState = FramerM$RXSTATE_NOSYNC;
  987.       FramerM$gRxHeadIndex = 0;
  988.       FramerM$gRxTailIndex = 0;
  989.       FramerM$gRxByteCnt = 0;
  990.       FramerM$gRxRunningCRC = 0;
  991.       FramerM$gpRxBuf = (uint8_t *)FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].pMsg;
  992.     }
  993. #line 288
  994.     __nesc_atomic_end(__nesc_atomic); }
  995. }
  997. static   
  998. # 75 "../../tos/platform/mica2/HPLCC1000M.nc"
  999. result_t HPLCC1000M$HPLCC1000$write(uint8_t addr, uint8_t data)
  1000. #line 75
  1001. {
  1002.   char cnt = 0;
  1005.   addr <<= 1;
  1006.   TOSH_CLR_CC_PALE_PIN();
  1007.   for (cnt = 0; cnt < 7; cnt++) 
  1008.     {
  1009.       if (addr & 0x80) {
  1010.         TOSH_SET_CC_PDATA_PIN();
  1011.         }
  1012.       else {
  1013. #line 86
  1014.         TOSH_CLR_CC_PDATA_PIN();
  1015.         }
  1016. #line 87
  1017.       TOSH_CLR_CC_PCLK_PIN();
  1018.       TOSH_SET_CC_PCLK_PIN();
  1019.       addr <<= 1;
  1020.     }
  1021.   TOSH_SET_CC_PDATA_PIN();
  1022.   TOSH_CLR_CC_PCLK_PIN();
  1023.   TOSH_SET_CC_PCLK_PIN();
  1025.   TOSH_SET_CC_PALE_PIN();
  1028.   for (cnt = 0; cnt < 8; cnt++) 
  1029.     {
  1030.       if (data & 0x80) {
  1031.         TOSH_SET_CC_PDATA_PIN();
  1032.         }
  1033.       else {
  1034. #line 103
  1035.         TOSH_CLR_CC_PDATA_PIN();
  1036.         }
  1037. #line 104
  1038.       TOSH_CLR_CC_PCLK_PIN();
  1039.       TOSH_SET_CC_PCLK_PIN();
  1040.       data <<= 1;
  1041.     }
  1042.   TOSH_SET_CC_PALE_PIN();
  1043.   TOSH_SET_CC_PDATA_PIN();
  1044.   TOSH_SET_CC_PCLK_PIN();
  1045.   return SUCCESS;
  1046. }
  1048. static   
  1049. #line 128
  1050. uint8_t HPLCC1000M$HPLCC1000$read(uint8_t addr)
  1051. #line 128
  1052. {
  1053.   int cnt;
  1054.   uint8_t din;
  1055.   uint8_t data = 0;
  1058.   addr <<= 1;
  1059.   TOSH_CLR_CC_PALE_PIN();
  1060.   for (cnt = 0; cnt < 7; cnt++) 
  1061.     {
  1062.       if (addr & 0x80) {
  1063.         TOSH_SET_CC_PDATA_PIN();
  1064.         }
  1065.       else {
  1066. #line 141
  1067.         TOSH_CLR_CC_PDATA_PIN();
  1068.         }
  1069. #line 142
  1070.       TOSH_CLR_CC_PCLK_PIN();
  1071.       TOSH_SET_CC_PCLK_PIN();
  1072.       addr <<= 1;
  1073.     }
  1074.   TOSH_CLR_CC_PDATA_PIN();
  1075.   TOSH_CLR_CC_PCLK_PIN();
  1076.   TOSH_SET_CC_PCLK_PIN();
  1078.   TOSH_MAKE_CC_PDATA_INPUT();
  1079.   TOSH_SET_CC_PALE_PIN();
  1082.   for (cnt = 7; cnt >= 0; cnt--) 
  1083.     {
  1084.       TOSH_CLR_CC_PCLK_PIN();
  1085.       din = TOSH_READ_CC_PDATA_PIN();
  1086.       if (din) {
  1087.         data = (data << 1) | 0x01;
  1088.         }
  1089.       else {
  1090. #line 161
  1091.         data = (data << 1) & 0xfe;
  1092.         }
  1093. #line 162
  1094.       TOSH_SET_CC_PCLK_PIN();
  1095.     }
  1097.   TOSH_SET_CC_PALE_PIN();
  1098.   TOSH_MAKE_CC_PDATA_OUTPUT();
  1099.   TOSH_SET_CC_PDATA_PIN();
  1101.   return data;
  1102. }
  1104. static 
  1105. # 63 "../../tos/platform/mica2/HPLADCM.nc"
  1106. void HPLADCM$init_portmap(void)
  1107. #line 63
  1108. {
  1110.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1111. #line 65
  1112.     {
  1113.       if (HPLADCM$init_portmap_done == FALSE) {
  1114.           int i;
  1116. #line 68
  1117.           for (i = 0; i < TOSH_ADC_PORTMAPSIZE; i++) 
  1118.             HPLADCM$TOSH_adc_portmap[i] = i;
  1121.           HPLADCM$TOSH_adc_portmap[TOS_ADC_BANDGAP_PORT] = TOSH_ACTUAL_BANDGAP_PORT;
  1122.           HPLADCM$TOSH_adc_portmap[TOS_ADC_GND_PORT] = TOSH_ACTUAL_GND_PORT;
  1123.           HPLADCM$init_portmap_done = TRUE;
  1124.         }
  1125.     }
  1126. #line 76
  1127.     __nesc_atomic_end(__nesc_atomic); }
  1128. }
  1130. static   
  1131. # 59 "/home/testuser/tinyos-1.x/tos/system/RandomLFSR.nc"
  1132. result_t RandomLFSR$Random$init(void)
  1133. #line 59
  1134. {
  1135.   {
  1136.   }
  1137. #line 60
  1138.   ;
  1139.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1140. #line 61
  1141.     {
  1142.       RandomLFSR$shiftReg = 119 * 119 * (TOS_LOCAL_ADDRESS + 1);
  1143.       RandomLFSR$initSeed = RandomLFSR$shiftReg;
  1144.       RandomLFSR$mask = 137 * 29 * (TOS_LOCAL_ADDRESS + 1);
  1145.     }
  1146. #line 65
  1147.     __nesc_atomic_end(__nesc_atomic); }
  1148.   return SUCCESS;
  1149. }
  1151. static   
  1152. # 1748 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  1153. result_t CC1000RadioIntM$ResetPower(void)
  1154. #line 1748
  1155. {
  1156.   CC1000RadioIntM$power_sum = 0;
  1157.   CC1000RadioIntM$pulse_check_sum = 0;
  1158.   CC1000RadioIntM$send_sum = 0;
  1159.   CC1000RadioIntM$receive_sum = 0;
  1160.   CC1000RadioIntM$sp_sum = 0;
  1161.   CC1000RadioIntM$tx_sum = 0;
  1162.   CC1000RadioIntM$rx_sum = 0;
  1163.   return SUCCESS;
  1164. }
  1166. static   
  1167. # 435 "../../tos/platform/mica2/CC1000ControlM.nc"
  1168. result_t CC1000ControlM$CC1000Control$RxMode(void)
  1169. #line 435
  1170. {
  1173.   CC1000ControlM$HPLChipcon$write(0x09, CC1000ControlM$gCurrentParameters[0x09]);
  1174.   CC1000ControlM$HPLChipcon$write(0x0B, 0x00);
  1175.   CC1000ControlM$HPLChipcon$write(0x00, (
  1176.   1 << 4) | (1 << 0));
  1178.   TOSH_uwait(125);
  1179.   return SUCCESS;
  1180. }
  1182. static  
  1183. # 98 "/home/testuser/tinyos-1.x/tos/system/TimerM.nc"
  1184. result_t TimerM$Timer$start(uint8_t id, char type, 
  1185. uint32_t interval)
  1186. #line 99
  1187. {
  1188.   uint8_t diff;
  1190. #line 101
  1191.   if (id >= NUM_TIMERS) {
  1192. #line 101
  1193.     return FAIL;
  1194.     }
  1195. #line 102
  1196.   if (type > TIMER_ONE_SHOT) {
  1197. #line 102
  1198.     return FAIL;
  1199.     }
  1205.   if (type == TIMER_REPEAT && interval <= 2) {
  1206. #line 109
  1207.     return FAIL;
  1208.     }
  1209.   TimerM$mTimerList[id].ticks = interval;
  1210.   TimerM$mTimerList[id].type = type;
  1212.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1213. #line 114
  1214.     {
  1215.       diff = TimerM$Clock$readCounter();
  1216.       interval += diff;
  1217.       TimerM$mTimerList[id].ticksLeft = interval;
  1218.       TimerM$mState |= 0x1L << id;
  1219.       if (interval < TimerM$mInterval) {
  1220.           TimerM$mInterval = interval;
  1221.           TimerM$Clock$setInterval(TimerM$mInterval);
  1222.           TimerM$setIntervalFlag = 0;
  1223.           TimerM$PowerManagement$adjustPower();
  1224.         }
  1225.     }
  1226. #line 125
  1227.     __nesc_atomic_end(__nesc_atomic); }
  1228.   return SUCCESS;
  1229. }
  1231. static   
  1232. # 102 "../../tos/platform/mica2/HPLPowerManagementM.nc"
  1233. uint8_t HPLPowerManagementM$PowerManagement$adjustPower(void)
  1234. #line 102
  1235. {
  1236.   uint8_t mcu;
  1238. #line 104
  1239.   if (HPLPowerManagementM$disableCount <= 0) {
  1240.     TOS_post(HPLPowerManagementM$doAdjustment);
  1241.     }
  1242.   else 
  1243. #line 106
  1244.     {
  1245.       mcu = * (volatile uint8_t *)(0x35 + 0x20);
  1246.       mcu &= 0xe3;
  1247.       mcu |= HPLPowerManagementM$IDLE;
  1248.       * (volatile uint8_t *)(0x35 + 0x20) = mcu;
  1249.       * (volatile uint8_t *)(0x35 + 0x20) |= 1 << 5;
  1250.     }
  1251.   return 0;
  1252. }
  1254. static  
  1255. # 543 "/home/testuser/tinyos-1.x/tos/lib/MintRoute/MultiHopWMEWMA.nc"
  1256. void MultiHopWMEWMA$TimerTask(void)
  1257. #line 543
  1258. {
  1260.   MultiHopWMEWMA$Leds$redToggle();
  1261.   {
  1262.   }
  1263. #line 546
  1264.   ;
  1265.   MultiHopWMEWMA$updateTable();
  1268.   {
  1269.     int i;
  1271. #line 552
  1272.     {
  1273.     }
  1274. #line 552
  1275.     ;
  1276.     for (i = 0; i < MultiHopWMEWMA$ROUTE_TABLE_SIZE; i++) {
  1277.         if (MultiHopWMEWMA$NeighborTbl[i].flags) {
  1278.             {
  1279.             }
  1280. #line 555
  1281.             ;
  1282.           }
  1283.       }
  1294.     if (MultiHopWMEWMA$gpCurrentParent) {
  1295.         {
  1296.         }
  1297. #line 569
  1298.         ;
  1299.       }
  1300.   }
  1302.   MultiHopWMEWMA$chooseParent();
  1310.   MultiHopWMEWMA$ATimer$start(TIMER_ONE_SHOT, 32);
  1311. }
  1313. static 
  1314. #line 256
  1315. uint32_t MultiHopWMEWMA$evaluateCost(uint16_t cost, uint8_t sendEst, uint8_t receiveEst)
  1316. #line 256
  1317. {
  1318.   uint32_t transEst = (uint32_t )sendEst * (uint32_t )receiveEst;
  1319.   uint32_t immed = (uint32_t )1 << 24;
  1321.   if (transEst == 0) {
  1322. #line 260
  1323.     return (uint32_t )1 << (uint32_t )16;
  1324.     }
  1325.   immed = immed / transEst;
  1326.   immed += (uint32_t )cost << 6;
  1327.   return immed;
  1328. }
  1330. static  
  1331. # 150 "/home/testuser/tinyos-1.x/tos/lib/MintRoute/MultiHopEngineM.nc"
  1332. void *MultiHopEngineM$Send$getBuffer(uint8_t id, TOS_MsgPtr pMsg, uint16_t *length)
  1333. #line 150
  1334. {
  1336.   TOS_MHopMsg *pMHMsg = (TOS_MHopMsg *)pMsg->data;
  1338.   *length = 70 - (size_t )& ((TOS_MHopMsg *)0)->data;
  1340.   return &pMHMsg->data[0];
  1341. }
  1343. static   
  1344. # 70 "/home/testuser/tinyos-1.x/tos/system/RandomLFSR.nc"
  1345. uint16_t RandomLFSR$Random$rand(void)
  1346. #line 70
  1347. {
  1348.   bool endbit;
  1349.   uint16_t tmpShiftReg;
  1351. #line 73
  1352.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1353. #line 73
  1354.     {
  1355.       tmpShiftReg = RandomLFSR$shiftReg;
  1356.       endbit = (tmpShiftReg & 0x8000) != 0;
  1357.       tmpShiftReg <<= 1;
  1358.       if (endbit) {
  1359.         tmpShiftReg ^= 0x100b;
  1360.         }
  1361. #line 79
  1362.       tmpShiftReg++;
  1363.       RandomLFSR$shiftReg = tmpShiftReg;
  1364.       tmpShiftReg = tmpShiftReg ^ RandomLFSR$mask;
  1365.     }
  1366. #line 82
  1367.     __nesc_atomic_end(__nesc_atomic); }
  1368.   return tmpShiftReg;
  1369. }
  1371. # 244 "/home/testuser/tinyos-1.x/tos/system/AMPromiscuous.nc"
  1372. TOS_MsgPtr   prom_received(TOS_MsgPtr packet)
  1373. #line 244
  1374. {
  1375.   AMPromiscuous$counter++;
  1376.   {
  1377.   }
  1378. #line 246
  1379.   ;
  1384.   if (
  1385. #line 248
  1386.   packet->group == TOS_AM_GROUP && ((
  1387.   AMPromiscuous$promiscuous_mode == TRUE || 
  1388.   packet->addr == TOS_BCAST_ADDR) || 
  1389.   packet->addr == TOS_LOCAL_ADDRESS) && (
  1390.   AMPromiscuous$crc_check == FALSE || packet->crc == 1)) 
  1391.     {
  1392.       uint8_t type = packet->type;
  1393.       TOS_MsgPtr tmp;
  1396.       {
  1397.       }
  1398. #line 258
  1399.       ;
  1400.       AMPromiscuous$dbgPacket(packet);
  1401.       {
  1402.       }
  1403. #line 260
  1404.       ;
  1407.       tmp = AMPromiscuous$ReceiveMsg$receive(type, packet);
  1408.       if (tmp) {
  1409.         packet = tmp;
  1410.         }
  1411.     }
  1412. #line 267
  1413.   return packet;
  1414. }
  1416. static 
  1417. # 332 "/home/testuser/tinyos-1.x/tos/lib/MintRoute/MultiHopWMEWMA.nc"
  1418. bool MultiHopWMEWMA$updateNbrCounters(uint16_t saddr, int16_t seqno, uint8_t *NbrIndex)
  1419. #line 332
  1420. {
  1421.   MultiHopWMEWMA$TableEntry *pNbr;
  1422.   int16_t sDelta;
  1423.   uint8_t iNbr;
  1424.   bool Result = FALSE;
  1426.   iNbr = MultiHopWMEWMA$findPreparedIndex(saddr);
  1427.   pNbr = &MultiHopWMEWMA$NeighborTbl[iNbr];
  1429.   sDelta = seqno - MultiHopWMEWMA$NeighborTbl[iNbr].lastSeqno - 1;
  1431.   if (pNbr->flags & MultiHopWMEWMA$NBRFLAG_NEW) {
  1432.       pNbr->received++;
  1433.       pNbr->lastSeqno = seqno;
  1434.       pNbr->flags ^= MultiHopWMEWMA$NBRFLAG_NEW;
  1435.     }
  1436.   else {
  1437. #line 348
  1438.     if (sDelta >= 0) {
  1439.         pNbr->missed += sDelta;
  1440.         pNbr->received++;
  1441.         pNbr->lastSeqno = seqno;
  1442.       }
  1443.     else {
  1444. #line 353
  1445.       if (sDelta < MultiHopWMEWMA$ACCEPTABLE_MISSED) {
  1447.           MultiHopWMEWMA$newEntry(iNbr, saddr);
  1448.           pNbr->received++;
  1449.           pNbr->lastSeqno = seqno;
  1450.           pNbr->flags ^= MultiHopWMEWMA$NBRFLAG_NEW;
  1451.         }
  1452.       else {
  1453.           Result = TRUE;
  1454.         }
  1455.       }
  1456.     }
  1457. #line 364
  1458.   *NbrIndex = iNbr;
  1459.   return Result;
  1460. }
  1462. static 
  1463. #line 156
  1464. uint8_t MultiHopWMEWMA$findEntry(uint16_t id)
  1465. #line 156
  1466. {
  1467.   uint8_t i = 0;
  1469. #line 158
  1470.   for (i = 0; i < MultiHopWMEWMA$ROUTE_TABLE_SIZE; i++) {
  1471.       if (MultiHopWMEWMA$NeighborTbl[i].flags & MultiHopWMEWMA$NBRFLAG_VALID && MultiHopWMEWMA$NeighborTbl[i].id == id) {
  1472.           return i;
  1473.         }
  1474.     }
  1475.   return MultiHopWMEWMA$ROUTE_INVALID;
  1476. }
  1478. static 
  1479. #line 198
  1480. void MultiHopWMEWMA$newEntry(uint8_t indes, uint16_t id)
  1481. #line 198
  1482. {
  1483.   MultiHopWMEWMA$NeighborTbl[indes].id = id;
  1484.   MultiHopWMEWMA$NeighborTbl[indes].flags = MultiHopWMEWMA$NBRFLAG_VALID | MultiHopWMEWMA$NBRFLAG_NEW;
  1485.   MultiHopWMEWMA$NeighborTbl[indes].liveliness = 0;
  1486.   MultiHopWMEWMA$NeighborTbl[indes].parent = MultiHopWMEWMA$ROUTE_INVALID;
  1487.   MultiHopWMEWMA$NeighborTbl[indes].cost = MultiHopWMEWMA$ROUTE_INVALID;
  1488.   MultiHopWMEWMA$NeighborTbl[indes].childLiveliness = 0;
  1489.   MultiHopWMEWMA$NeighborTbl[indes].hop = MultiHopWMEWMA$ROUTE_INVALID;
  1490.   MultiHopWMEWMA$NeighborTbl[indes].missed = 0;
  1491.   MultiHopWMEWMA$NeighborTbl[indes].received = 0;
  1492.   MultiHopWMEWMA$NeighborTbl[indes].receiveEst = 0;
  1493.   MultiHopWMEWMA$NeighborTbl[indes].sendEst = 0;
  1494. }
  1496. static  
  1497. # 182 "/home/testuser/tinyos-1.x/tos/lib/MintRoute/MultiHopEngineM.nc"
  1498. TOS_MsgPtr MultiHopEngineM$ReceiveMsg$receive(uint8_t id, TOS_MsgPtr pMsg)
  1499. #line 182
  1500. {
  1501.   TOS_MHopMsg *pMHMsg = (TOS_MHopMsg *)pMsg->data;
  1502.   uint16_t PayloadLen = pMsg->length - (size_t )& ((TOS_MHopMsg *)0)->data;
  1510.   if (pMsg->addr == TOS_LOCAL_ADDRESS) {
  1511.       if (MultiHopEngineM$Intercept$intercept(id, pMsg, &pMHMsg->data[0], PayloadLen) == SUCCESS) {
  1512.           pMsg = MultiHopEngineM$mForward(pMsg, id);
  1513.         }
  1514.     }
  1515.   else {
  1517.       MultiHopEngineM$Snoop$intercept(id, pMsg, &pMHMsg->data[0], PayloadLen);
  1518.     }
  1520.   return pMsg;
  1521. }
  1523. static  
  1524. # 665 "/home/testuser/tinyos-1.x/tos/lib/MintRoute/MultiHopWMEWMA.nc"
  1525. result_t MultiHopWMEWMA$RouteSelect$selectRoute(TOS_MsgPtr Msg, uint8_t id)
  1526. #line 665
  1527. {
  1528.   TOS_MHopMsg *pMHMsg = (TOS_MHopMsg *)&Msg->data[0];
  1530.   uint8_t iNbr;
  1531.   bool fIsDuplicate;
  1532.   result_t Result = SUCCESS;
  1535.   if (MultiHopWMEWMA$gpCurrentParent == (void *)0) {
  1538.       if (pMHMsg->sourceaddr == TOS_LOCAL_ADDRESS && 
  1539.       pMHMsg->originaddr == TOS_LOCAL_ADDRESS) {
  1540.           pMHMsg->sourceaddr = TOS_LOCAL_ADDRESS;
  1541.           pMHMsg->hopcount = MultiHopWMEWMA$gbCurrentHopCount;
  1542.           pMHMsg->seqno = MultiHopWMEWMA$gCurrentSeqNo++;
  1543.           Msg->addr = TOS_BCAST_ADDR;
  1544.           return SUCCESS;
  1545.         }
  1546.       else {
  1547.           return FAIL;
  1548.         }
  1549.     }
  1551.   if (MultiHopWMEWMA$gbCurrentHopCount >= pMHMsg->hopcount) {
  1553.       return FAIL;
  1554.     }
  1556.   if (pMHMsg->sourceaddr == TOS_LOCAL_ADDRESS && 
  1557.   pMHMsg->originaddr == TOS_LOCAL_ADDRESS) {
  1558.       fIsDuplicate = FALSE;
  1559.     }
  1560.   else {
  1561.       fIsDuplicate = MultiHopWMEWMA$updateNbrCounters(pMHMsg->sourceaddr, pMHMsg->seqno, &iNbr);
  1562.     }
  1564.   if (!fIsDuplicate) {
  1565.       pMHMsg->sourceaddr = TOS_LOCAL_ADDRESS;
  1566.       pMHMsg->hopcount = MultiHopWMEWMA$gbCurrentHopCount;
  1567.       if (MultiHopWMEWMA$gpCurrentParent->id != TOS_UART_ADDR) {
  1568.           pMHMsg->seqno = MultiHopWMEWMA$gCurrentSeqNo++;
  1569.         }
  1570.       Msg->addr = MultiHopWMEWMA$gpCurrentParent->id;
  1571.       if (pMHMsg->originaddr != TOS_LOCAL_ADDRESS) {
  1572.           MultiHopWMEWMA$updateDescendant(pMHMsg->originaddr);
  1573.         }
  1574.     }
  1575.   else {
  1576.       Result = FAIL;
  1577.     }
  1578.   {
  1579.   }
  1580. #line 716
  1581.   ;
  1583.   return Result;
  1584. }
  1586. static  
  1587. # 143 "/home/testuser/tinyos-1.x/tos/lib/Queue/QueuedSendM.nc"
  1588. result_t QueuedSendM$QueueSendMsg$send(uint8_t id, uint16_t address, uint8_t length, TOS_MsgPtr msg)
  1589. #line 143
  1590. {
  1591.   {
  1592.   }
  1593. #line 144
  1594.   ;
  1596.   if ((QueuedSendM$enqueue_next + 1) % QueuedSendM$MESSAGE_QUEUE_SIZE == QueuedSendM$dequeue_next) {
  1598.       {
  1599.       }
  1600. #line 148
  1601.       ;
  1602.       return FAIL;
  1603.     }
  1605.   if (length > 70) {
  1606.       {
  1607.       }
  1608. #line 153
  1609.       ;
  1610.       return FAIL;
  1611.     }
  1613.   if (msg == (void *)0) {
  1614.       {
  1615.       }
  1616. #line 158
  1617.       ;
  1618.       return FAIL;
  1619.     }
  1621.   QueuedSendM$msgqueue[QueuedSendM$enqueue_next].address = address;
  1622.   QueuedSendM$msgqueue[QueuedSendM$enqueue_next].length = length;
  1623.   QueuedSendM$msgqueue[QueuedSendM$enqueue_next].id = id;
  1624.   QueuedSendM$msgqueue[QueuedSendM$enqueue_next].pMsg = msg;
  1625.   QueuedSendM$msgqueue[QueuedSendM$enqueue_next].xmit_count = 0;
  1626.   QueuedSendM$msgqueue[QueuedSendM$enqueue_next].pMsg->ack = 0;
  1628.   QueuedSendM$enqueue_next++;
  1629. #line 169
  1630.   QueuedSendM$enqueue_next %= QueuedSendM$MESSAGE_QUEUE_SIZE;
  1632.   {
  1633.   }
  1634. #line 171
  1635.   ;
  1644.   if (QueuedSendM$fQueueIdle) {
  1645.       QueuedSendM$fQueueIdle = FALSE;
  1646.       TOS_post(QueuedSendM$QueueServiceTask);
  1647.     }
  1648.   return SUCCESS;
  1649. }
  1651. static  
  1652. #line 121
  1653. void QueuedSendM$QueueServiceTask(void)
  1654. #line 121
  1655. {
  1656.   uint8_t id;
  1658.   if (QueuedSendM$msgqueue[QueuedSendM$dequeue_next].pMsg != (void *)0) {
  1659.       QueuedSendM$Leds$greenToggle();
  1660.       {
  1661.       }
  1662. #line 126
  1663.       ;
  1664.       id = QueuedSendM$msgqueue[QueuedSendM$dequeue_next].id;
  1666.       if (!QueuedSendM$SerialSendMsg$send(id, QueuedSendM$msgqueue[QueuedSendM$dequeue_next].address, 
  1667.       QueuedSendM$msgqueue[QueuedSendM$dequeue_next].length, 
  1668.       QueuedSendM$msgqueue[QueuedSendM$dequeue_next].pMsg)) {
  1670.           TOS_post(QueuedSendM$QueueServiceTask);
  1672.           {
  1673.           }
  1674. #line 135
  1675.           ;
  1676.         }
  1677.     }
  1678.   else {
  1679.       QueuedSendM$fQueueIdle = TRUE;
  1680.     }
  1681. }
  1683. static 
  1684. # 158 "/home/testuser/tinyos-1.x/tos/system/FramerM.nc"
  1685. result_t FramerM$StartTx(void)
  1686. #line 158
  1687. {
  1688.   result_t Result = SUCCESS;
  1689.   bool fInitiate = FALSE;
  1691.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1692. #line 162
  1693.     {
  1694.       if (FramerM$gTxState == FramerM$TXSTATE_IDLE) {
  1695.           if (FramerM$gFlags & FramerM$FLAGS_TOKENPEND) {
  1696.               FramerM$gpTxBuf = (uint8_t *)&FramerM$gTxTokenBuf;
  1697.               FramerM$gTxProto = FramerM$PROTO_ACK;
  1698.               FramerM$gTxLength = sizeof FramerM$gTxTokenBuf;
  1699.               fInitiate = TRUE;
  1700.               FramerM$gTxState = FramerM$TXSTATE_PROTO;
  1701.             }
  1702.           else {
  1703. #line 171
  1704.             if (FramerM$gFlags & FramerM$FLAGS_DATAPEND) {
  1705.                 FramerM$gpTxBuf = (uint8_t *)FramerM$gpTxMsg;
  1706.                 FramerM$gTxProto = FramerM$PROTO_PACKET_NOACK;
  1707.                 FramerM$gTxLength = FramerM$gpTxMsg->length + (MSG_DATA_SIZE - DATA_LENGTH - 2);
  1708.                 fInitiate = TRUE;
  1709.                 FramerM$gTxState = FramerM$TXSTATE_PROTO;
  1710.               }
  1711.             else {
  1712. #line 178
  1713.               if (FramerM$gFlags & FramerM$FLAGS_UNKNOWN) {
  1714.                   FramerM$gpTxBuf = (uint8_t *)&FramerM$gTxUnknownBuf;
  1715.                   FramerM$gTxProto = FramerM$PROTO_UNKNOWN;
  1716.                   FramerM$gTxLength = sizeof FramerM$gTxUnknownBuf;
  1717.                   fInitiate = TRUE;
  1718.                   FramerM$gTxState = FramerM$TXSTATE_PROTO;
  1719.                 }
  1720.               }
  1721.             }
  1722.         }
  1723.     }
  1724. #line 188
  1725.     __nesc_atomic_end(__nesc_atomic); }
  1726. #line 188
  1727.   if (fInitiate) {
  1728.       { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1729. #line 189
  1730.         {
  1731.           FramerM$gTxRunningCRC = 0;
  1732. #line 190
  1733.           FramerM$gTxByteCnt = 0;
  1734.         }
  1735. #line 191
  1736.         __nesc_atomic_end(__nesc_atomic); }
  1737.       Result = FramerM$ByteComm$txByte(FramerM$HDLC_FLAG_BYTE);
  1738.       if (Result != SUCCESS) {
  1739.           { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1740. #line 194
  1741.             FramerM$gTxState = FramerM$TXSTATE_ERROR;
  1742. #line 194
  1743.             __nesc_atomic_end(__nesc_atomic); }
  1744.           TOS_post(FramerM$PacketSent);
  1745.         }
  1746.     }
  1748.   return Result;
  1749. }
  1751. static   
  1752. # 110 "/home/testuser/tinyos-1.x/tos/system/UARTM.nc"
  1753. result_t UARTM$ByteComm$txByte(uint8_t data)
  1754. #line 110
  1755. {
  1756.   bool oldState;
  1758.   {
  1759.   }
  1760. #line 113
  1761.   ;
  1763.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1764. #line 115
  1765.     {
  1766.       oldState = UARTM$state;
  1767.       UARTM$state = TRUE;
  1768.     }
  1769. #line 118
  1770.     __nesc_atomic_end(__nesc_atomic); }
  1771.   if (oldState) {
  1772.     return FAIL;
  1773.     }
  1774.   UARTM$HPLUART$put(data);
  1776.   return SUCCESS;
  1777. }
  1779. static  
  1780. # 246 "/home/testuser/tinyos-1.x/tos/system/FramerM.nc"
  1781. void FramerM$PacketSent(void)
  1782. #line 246
  1783. {
  1784.   result_t TxResult = SUCCESS;
  1786.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1787. #line 249
  1788.     {
  1789.       if (FramerM$gTxState == FramerM$TXSTATE_ERROR) {
  1790.           TxResult = FAIL;
  1791.           FramerM$gTxState = FramerM$TXSTATE_IDLE;
  1792.         }
  1793.     }
  1794. #line 254
  1795.     __nesc_atomic_end(__nesc_atomic); }
  1796.   if (FramerM$gTxProto == FramerM$PROTO_ACK) {
  1797.       { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1798. #line 256
  1799.         FramerM$gFlags ^= FramerM$FLAGS_TOKENPEND;
  1800. #line 256
  1801.         __nesc_atomic_end(__nesc_atomic); }
  1802.     }
  1803.   else {
  1804.       { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1805. #line 259
  1806.         FramerM$gFlags ^= FramerM$FLAGS_DATAPEND;
  1807. #line 259
  1808.         __nesc_atomic_end(__nesc_atomic); }
  1809.       FramerM$BareSendMsg$sendDone((TOS_MsgPtr )FramerM$gpTxMsg, TxResult);
  1810.       { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1811. #line 261
  1812.         FramerM$gpTxMsg = (void *)0;
  1813. #line 261
  1814.         __nesc_atomic_end(__nesc_atomic); }
  1815.     }
  1818.   FramerM$StartTx();
  1819. }
  1821. static 
  1822. # 170 "/home/testuser/tinyos-1.x/tos/system/AMPromiscuous.nc"
  1823. result_t AMPromiscuous$reportSendDone(TOS_MsgPtr msg, result_t success)
  1824. #line 170
  1825. {
  1826.   {
  1827.   }
  1828. #line 171
  1829.   ;
  1830.   AMPromiscuous$state = FALSE;
  1831.   AMPromiscuous$SendMsg$sendDone(msg->type, msg, success);
  1832.   AMPromiscuous$sendDone();
  1834.   return SUCCESS;
  1835. }
  1837. static  
  1838. # 205 "/home/testuser/tinyos-1.x/tos/lib/MintRoute/MultiHopEngineM.nc"
  1839. result_t MultiHopEngineM$SendMsg$sendDone(uint8_t id, TOS_MsgPtr pMsg, result_t success)
  1840. #line 205
  1841. {
  1843.   if (pMsg == MultiHopEngineM$FwdBufList[MultiHopEngineM$iFwdBufTail]) {
  1844.       MultiHopEngineM$iFwdBufTail++;
  1845. #line 208
  1846.       MultiHopEngineM$iFwdBufTail %= MultiHopEngineM$FWD_QUEUE_SIZE;
  1847.     }
  1848.   else 
  1849. #line 209
  1850.     {
  1851.       MultiHopEngineM$Send$sendDone(id, pMsg, success);
  1852.     }
  1853.   return SUCCESS;
  1854. }
  1856. static  
  1857. # 1102 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  1858. result_t CC1000RadioIntM$Send$send(TOS_MsgPtr pMsg)
  1859. #line 1102
  1860. {
  1861.   result_t Result = SUCCESS;
  1862.   uint8_t currentRadioState = 0;
  1864.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1865. #line 1106
  1866.     {
  1867.       if (CC1000RadioIntM$bTxBusy) {
  1868.           Result = FAIL;
  1869.         }
  1870.       else 
  1872.         {
  1873.           CC1000RadioIntM$bTxBusy = TRUE;
  1874.           CC1000RadioIntM$txbufptr = pMsg;
  1875.           CC1000RadioIntM$txlength = pMsg->length + (MSG_DATA_SIZE - DATA_LENGTH - 2);
  1877.           if (CC1000RadioIntM$bCCAEnable) {
  1878.               if (CC1000RadioIntM$currentMAC == CC1000RadioIntM$BMAC) {
  1879.                 CC1000RadioIntM$sMacDelay = CC1000RadioIntM$MacBackoff$initialBackoff(pMsg);
  1880.                 }
  1881.               else {
  1882. #line 1121
  1883.                 CC1000RadioIntM$sMacDelay = CC1000RadioIntM$getZMACBackoff(0);
  1884.                 }
  1885.             }
  1886.           else {
  1887. #line 1123
  1888.             CC1000RadioIntM$sMacDelay = 0;
  1889.             }
  1893.           CC1000RadioIntM$bTxPending = TRUE;
  1894.         }
  1895.       currentRadioState = CC1000RadioIntM$RadioState;
  1896.     }
  1897. #line 1131
  1898.     __nesc_atomic_end(__nesc_atomic); }
  1900.   if (Result) {
  1901.       if (currentRadioState == CC1000RadioIntM$POWER_DOWN_STATE) {
  1902.           { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1903. #line 1135
  1904.             CC1000RadioIntM$RadioState = CC1000RadioIntM$IDLE_STATE;
  1905. #line 1135
  1906.             __nesc_atomic_end(__nesc_atomic); }
  1907.           CC1000RadioIntM$WakeupTimer$stop();
  1908.           CC1000RadioIntM$CC1000StdControl$start();
  1909.           CC1000RadioIntM$CC1000Control$BIASOn();
  1910.           CC1000RadioIntM$CC1000Control$RxMode();
  1911.           CC1000RadioIntM$SpiByteFifo$rxMode();
  1912.           CC1000RadioIntM$SpiByteFifo$enableIntr();
  1913.           if (CC1000RadioIntM$iSquelchCount > 30) {
  1914.             CC1000RadioIntM$SquelchTimer$start(TIMER_REPEAT, 2560);
  1915.             }
  1916.           else {
  1917. #line 1145
  1918.             CC1000RadioIntM$SquelchTimer$start(TIMER_REPEAT, 128);
  1919.             }
  1920. #line 1146
  1921.           CC1000RadioIntM$WakeupTimer$start(TIMER_ONE_SHOT, 16 * 2);
  1922.         }
  1923.     }
  1924.   return Result;
  1925. }
  1927. static 
  1928. #line 286
  1929. uint16_t CC1000RadioIntM$getZMACBackoff(uint16_t residualBackoff)
  1930. #line 286
  1931. {
  1932.   if (residualBackoff > 0) {
  1933.       CC1000RadioIntM$congBackOffs++;
  1934.       if (CC1000RadioIntM$currentSlot == CC1000RadioIntM$ownSlot && residualBackoff >= 8) {
  1935.           return CC1000RadioIntM$getOwnerBackoff();
  1936.         }
  1937.       else {
  1938. #line 291
  1939.         if (CC1000RadioIntM$currentSlot != CC1000RadioIntM$ownSlot && residualBackoff < 8) {
  1940.             if (residualBackoff + 8 < 8 + 32) {
  1941.               return residualBackoff + 8;
  1942.               }
  1943.             else {
  1944. #line 295
  1945.               return CC1000RadioIntM$getNonOwnerBackoff();
  1946.               }
  1947.           }
  1948.         else {
  1949. #line 297
  1950.           return residualBackoff;
  1951.           }
  1952.         }
  1953.     }
  1954.   else 
  1955. #line 298
  1956.     {
  1957.       if (CC1000RadioIntM$currentSlot == CC1000RadioIntM$ownSlot) {
  1958.         return CC1000RadioIntM$getOwnerBackoff();
  1959.         }
  1960.       else {
  1961. #line 302
  1962.         return CC1000RadioIntM$getNonOwnerBackoff();
  1963.         }
  1964.     }
  1965. }
  1967. static  
  1968. # 168 "/home/testuser/tinyos-1.x/tos/system/TimerM.nc"
  1969. result_t TimerM$Timer$stop(uint8_t id)
  1970. #line 168
  1971. {
  1973.   if (id >= NUM_TIMERS) {
  1974. #line 170
  1975.     return FAIL;
  1976.     }
  1977. #line 171
  1978.   if (TimerM$mState & (0x1L << id)) {
  1979.       { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1980. #line 172
  1981.         TimerM$mState &= ~(0x1L << id);
  1982. #line 172
  1983.         __nesc_atomic_end(__nesc_atomic); }
  1984.       if (!TimerM$mState) {
  1985.           TimerM$setIntervalFlag = 1;
  1986.         }
  1987.       return SUCCESS;
  1988.     }
  1989.   return FAIL;
  1990. }
  1992. # 144 "../../tos/platform/mica2/HPLADCM.nc"
  1993. void __attribute((signal))   __vector_21(void)
  1994. #line 144
  1995. {
  1996.   uint16_t data = * (volatile uint16_t *)& * (volatile uint8_t *)(0x04 + 0x20);
  1998. #line 146
  1999.   data &= 0x3ff;
  2000.   * (volatile uint8_t *)(0x06 + 0x20) |= 1 << 4;
  2001.   * (volatile uint8_t *)(0x06 + 0x20) &= ~(1 << 7);
  2002.   __nesc_enable_interrupt();
  2003.   HPLADCM$ADC$dataReady(data);
  2004. }
  2006. static   
  2007. #line 122
  2008. result_t HPLADCM$ADC$samplePort(uint8_t port)
  2009. #line 122
  2010. {
  2011.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  2012. #line 123
  2013.     {
  2014.       * (volatile uint8_t *)(0x07 + 0x20) = HPLADCM$TOSH_adc_portmap[port] & 0x1F;
  2015.     }
  2016. #line 125
  2017.     __nesc_atomic_end(__nesc_atomic); }
  2018.   * (volatile uint8_t *)(0x06 + 0x20) |= 1 << 7;
  2019.   * (volatile uint8_t *)(0x06 + 0x20) |= 1 << 6;
  2021.   return SUCCESS;
  2022. }
  2024. static  
  2025. # 342 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  2026. void CC1000RadioIntM$adjustSquelch(void)
  2027. #line 342
  2028. {
  2029.   uint16_t tempArray[9];
  2030.   char i;
  2031. #line 344
  2032.   char j;
  2033. #line 344
  2034.   char min;
  2035.   uint16_t min_value;
  2036.   uint32_t tempsquelch;
  2038.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  2039. #line 348
  2040.     {
  2041.       CC1000RadioIntM$usSquelchTable[CC1000RadioIntM$usSquelchIndex] = CC1000RadioIntM$usTempSquelch;
  2042.       CC1000RadioIntM$usSquelchIndex++;
  2043.       if (CC1000RadioIntM$usSquelchIndex >= 9) {
  2044.         CC1000RadioIntM$usSquelchIndex = 0;
  2045.         }
  2046. #line 353
  2047.       if (CC1000RadioIntM$iSquelchCount <= 30) {
  2048.         CC1000RadioIntM$iSquelchCount++;
  2049.         }
  2050.     }
  2051. #line 356
  2052.     __nesc_atomic_end(__nesc_atomic); }
  2053.   for (i = 0; i < 9; i++) {
  2054.       tempArray[(int )i] = CC1000RadioIntM$usSquelchTable[(int )i];
  2055.     }
  2057.   min = 0;
  2059.   for (j = 0; j < 3; j++) {
  2060.       for (i = 1; i < 9; i++) {
  2061.           if (tempArray[(int )i] != 0xFFFF && (
  2062.           tempArray[(int )i] > tempArray[(int )min] || 
  2063.           tempArray[(int )min] == 0xFFFF)) {
  2064.               min = i;
  2065.             }
  2066.         }
  2067.       min_value = tempArray[(int )min];
  2068.       tempArray[(int )min] = 0xFFFF;
  2069.     }
  2071.   tempsquelch = (uint32_t )(CC1000RadioIntM$usSquelchVal << 5) + (uint32_t )(min_value << 1);
  2072.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  2073. #line 376
  2074.     CC1000RadioIntM$usSquelchVal = (uint16_t )(tempsquelch / 34 & 0x0FFFF);
  2075. #line 376
  2076.     __nesc_atomic_end(__nesc_atomic); }
  2077. }
  2079. static   
  2080. # 422 "../../tos/platform/mica2/CC1000ControlM.nc"
  2081. result_t CC1000ControlM$CC1000Control$TxMode(void)
  2082. #line 422
  2083. {
  2085.   CC1000ControlM$HPLChipcon$write(0x00, (((
  2086.   1 << 7) | (1 << 6)) | (1 << 5)) | (
  2087.   1 << 0));
  2089.   CC1000ControlM$HPLChipcon$write(0x09, CC1000ControlM$gCurrentParameters[29]);
  2090.   TOSH_uwait(250);
  2091.   CC1000ControlM$HPLChipcon$write(0x0B, CC1000ControlM$gCurrentParameters[0xb]);
  2092.   TOSH_uwait(20);
  2093.   return SUCCESS;
  2094. }
  2096. static 
  2097. # 198 "../../tos/platform/mica2/ADCREFM.nc"
  2098. result_t ADCREFM$startGet(uint8_t port)
  2099. #line 198
  2100. {
  2101.   uint16_t PortMask;
  2102. #line 199
  2103.   uint16_t oldReqVector = 1;
  2104.   result_t Result = SUCCESS;
  2106.   PortMask = 1 << port;
  2108.   if ((PortMask & ADCREFM$ReqVector) != 0) {
  2110.       Result = FAIL;
  2111.     }
  2112.   else {
  2113.       oldReqVector = ADCREFM$ReqVector;
  2114.       ADCREFM$ReqVector |= PortMask;
  2115.       if (oldReqVector == 0) {
  2116.           if ((Result = ADCREFM$HPLADC$samplePort(port))) {
  2117.               ADCREFM$ReqPort = port;
  2118.             }
  2119.         }
  2120.     }
  2122.   return Result;
  2123. }
  2125. static  
  2126. # 1586 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  2127. void CC1000RadioIntM$IdleTimerTask(void)
  2128. #line 1586
  2129. {
  2130.   if (CC1000RadioIntM$iSquelchCount > 30) {
  2131.     CC1000RadioIntM$SquelchTimer$start(TIMER_REPEAT, 2560);
  2132.     }
  2133.   else {
  2134. #line 1590
  2135.     CC1000RadioIntM$SquelchTimer$start(TIMER_REPEAT, 128);
  2136.     }
  2137. #line 1591
  2138.   CC1000RadioIntM$WakeupTimer$start(TIMER_ONE_SHOT, CC1000RadioIntM$TIME_AFTER_CHECK);
  2139. }
  2141. static   
  2142. # 82 "../../tos/platform/mica2/HPLSpiM.nc"
  2143. result_t HPLSpiM$SpiByteFifo$disableIntr(void)
  2144. #line 82
  2145. {
  2146.   * (volatile uint8_t *)(0x0D + 0x20) &= ~(1 << 7);
  2147.   * (volatile uint8_t *)(0x17 + 0x20) |= 1 << 0;
  2148.   * (volatile uint8_t *)(0x18 + 0x20) &= ~(1 << 0);
  2149.   HPLSpiM$PowerManagement$adjustPower();
  2150.   return SUCCESS;
  2151. }
  2153. # 167 "/home/testuser/tinyos-1.x/tos/platform/mica/HPLClock.nc"
  2154. void __attribute((interrupt))   __vector_15(void)
  2155. #line 167
  2156. {
  2157.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  2158. #line 168
  2159.     {
  2160.       if (HPLClock$set_flag) {
  2161.           HPLClock$mscale = HPLClock$nextScale;
  2162.           HPLClock$nextScale |= 0x8;
  2163.           * (volatile uint8_t *)(0x33 + 0x20) = HPLClock$nextScale;
  2165.           * (volatile uint8_t *)(0x31 + 0x20) = HPLClock$minterval;
  2166.           HPLClock$set_flag = 0;
  2167.         }
  2168.     }
  2169. #line 177
  2170.     __nesc_atomic_end(__nesc_atomic); }
  2171.   HPLClock$Clock$fire();
  2172. }
  2174. static  
  2175. # 563 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  2176. result_t CC1000RadioIntM$SetDrand$Set(nodeInfo *mInfo, uint8_t nHop, nodeInfo *nInfo, uint16_t sSize)
  2177. #line 563
  2178. {
  2179.   uint32_t slotOffset = 0;
  2180. #line 564
  2181.   uint32_t globalTimeStamp = 0;
  2182.   GTime loctime;
  2183.   uint8_t i = 0;
  2185.   CC1000RadioIntM$slotSize = sSize;
  2186.   CC1000RadioIntM$nextHop = nHop;
  2196.   for (i = 0; i < MAX_NBR; i++) {
  2197.       CC1000RadioIntM$nbrInfo[i].nodeID = 0xFF;
  2198.       CC1000RadioIntM$nbrInfo[i].slot = 0xFF;
  2199.       CC1000RadioIntM$nbrInfo[i].frame = 0xFF;
  2200.       CC1000RadioIntM$nbrInfo[i].bitMap = 0x0;
  2201.     }
  2202. # 1 "../../tos/platform/mica2/nbrTable.h"
  2203.   if (TOS_LOCAL_ADDRESS == 2) {
  2204.       CC1000RadioIntM$ownSlot = 4;
  2205.       CC1000RadioIntM$localFrameLength = 16;
  2206.       CC1000RadioIntM$nbrInfo[0].nodeID = 28;
  2207.       CC1000RadioIntM$nbrInfo[0].bitMap = TWO_HOP;
  2208.       CC1000RadioIntM$nbrInfo[0].frame = 16;
  2209.       CC1000RadioIntM$nbrInfo[0].slot = 3;
  2210.       CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[0].slot, CC1000RadioIntM$nbrInfo[0].frame);
  2211.       CC1000RadioIntM$nbrInfo[1].nodeID = 27;
  2212.       CC1000RadioIntM$nbrInfo[1].bitMap = TWO_HOP;
  2213.       CC1000RadioIntM$nbrInfo[1].frame = 16;
  2214.       CC1000RadioIntM$nbrInfo[1].slot = 5;
  2215.       CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[1].slot, CC1000RadioIntM$nbrInfo[1].frame);
  2216.       CC1000RadioIntM$nbrInfo[2].nodeID = 0;
  2217.       CC1000RadioIntM$nbrInfo[2].bitMap = TWO_HOP;
  2218.       CC1000RadioIntM$nbrInfo[2].frame = 16;
  2219.       CC1000RadioIntM$nbrInfo[2].slot = 9;
  2220.       CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[2].slot, CC1000RadioIntM$nbrInfo[2].frame);
  2221.       CC1000RadioIntM$nbrInfo[3].nodeID = 21;
  2222.       CC1000RadioIntM$nbrInfo[3].bitMap = TWO_HOP;
  2223.       CC1000RadioIntM$nbrInfo[3].frame = 16;
  2224.       CC1000RadioIntM$nbrInfo[3].slot = 13;
  2225.       CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[3].slot, CC1000RadioIntM$nbrInfo[3].frame);
  2226.     }
  2227.   else {
  2228. #line 24
  2229.     if (TOS_LOCAL_ADDRESS == 3) {
  2230.         CC1000RadioIntM$ownSlot = 14;
  2231.         CC1000RadioIntM$localFrameLength = 16;
  2232.         CC1000RadioIntM$nbrInfo[0].nodeID = 31;
  2233.         CC1000RadioIntM$nbrInfo[0].bitMap = TWO_HOP;
  2234.         CC1000RadioIntM$nbrInfo[0].frame = 16;
  2235.         CC1000RadioIntM$nbrInfo[0].slot = 5;
  2236.         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[0].slot, CC1000RadioIntM$nbrInfo[0].frame);
  2237.         CC1000RadioIntM$nbrInfo[1].nodeID = 15;
  2238.         CC1000RadioIntM$nbrInfo[1].bitMap = TWO_HOP;
  2239.         CC1000RadioIntM$nbrInfo[1].frame = 16;
  2240.         CC1000RadioIntM$nbrInfo[1].slot = 6;
  2241.         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[1].slot, CC1000RadioIntM$nbrInfo[1].frame);
  2242.         CC1000RadioIntM$nbrInfo[2].nodeID = 41;
  2243.         CC1000RadioIntM$nbrInfo[2].bitMap = TWO_HOP;
  2244.         CC1000RadioIntM$nbrInfo[2].frame = 16;
  2245.         CC1000RadioIntM$nbrInfo[2].slot = 12;
  2246.         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[2].slot, CC1000RadioIntM$nbrInfo[2].frame);
  2247.         CC1000RadioIntM$nbrInfo[3].nodeID = 40;
  2248.         CC1000RadioIntM$nbrInfo[3].bitMap = TWO_HOP;
  2249.         CC1000RadioIntM$nbrInfo[3].frame = 16;
  2250.         CC1000RadioIntM$nbrInfo[3].slot = 11;
  2251.         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[3].slot, CC1000RadioIntM$nbrInfo[3].frame);
  2252.         CC1000RadioIntM$nbrInfo[4].nodeID = 32;
  2253.         CC1000RadioIntM$nbrInfo[4].bitMap = TWO_HOP;
  2254.         CC1000RadioIntM$nbrInfo[4].frame = 16;
  2255.         CC1000RadioIntM$nbrInfo[4].slot = 2;
  2256.         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[4].slot, CC1000RadioIntM$nbrInfo[4].frame);
  2257.         CC1000RadioIntM$nbrInfo[5].nodeID = 17;
  2258.         CC1000RadioIntM$nbrInfo[5].bitMap = TWO_HOP;
  2259.         CC1000RadioIntM$nbrInfo[5].frame = 16;
  2260.         CC1000RadioIntM$nbrInfo[5].slot = 4;
  2261.         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[5].slot, CC1000RadioIntM$nbrInfo[5].frame);
  2262.         CC1000RadioIntM$nbrInfo[6].nodeID = 42;
  2263.         CC1000RadioIntM$nbrInfo[6].bitMap = TWO_HOP;
  2264.         CC1000RadioIntM$nbrInfo[6].frame = 16;
  2265.         CC1000RadioIntM$nbrInfo[6].slot = 7;
  2266.         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[6].slot, CC1000RadioIntM$nbrInfo[6].frame);
  2267.         CC1000RadioIntM$nbrInfo[7].nodeID = 27;
  2268.         CC1000RadioIntM$nbrInfo[7].bitMap = TWO_HOP;
  2269.         CC1000RadioIntM$nbrInfo[7].frame = 16;
  2270.         CC1000RadioIntM$nbrInfo[7].slot = 5;
  2271.         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[7].slot, CC1000RadioIntM$nbrInfo[7].frame);
  2272.       }
  2273.     else {
  2274. #line 67
  2275.       if (TOS_LOCAL_ADDRESS == 9) {
  2276.           CC1000RadioIntM$ownSlot = 1;
  2277.           CC1000RadioIntM$localFrameLength = 16;
  2278.           CC1000RadioIntM$nbrInfo[0].nodeID = 21;
  2279.           CC1000RadioIntM$nbrInfo[0].bitMap = TWO_HOP;
  2280.           CC1000RadioIntM$nbrInfo[0].frame = 16;
  2281.           CC1000RadioIntM$nbrInfo[0].slot = 13;
  2282.           CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[0].slot, CC1000RadioIntM$nbrInfo[0].frame);
  2283.           CC1000RadioIntM$nbrInfo[1].nodeID = 28;
  2284.           CC1000RadioIntM$nbrInfo[1].bitMap = TWO_HOP;
  2285.           CC1000RadioIntM$nbrInfo[1].frame = 16;
  2286.           CC1000RadioIntM$nbrInfo[1].slot = 3;
  2287.           CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[1].slot, CC1000RadioIntM$nbrInfo[1].frame);
  2288.           CC1000RadioIntM$nbrInfo[2].nodeID = 27;
  2289.           CC1000RadioIntM$nbrInfo[2].bitMap = TWO_HOP;
  2290.           CC1000RadioIntM$nbrInfo[2].frame = 16;
  2291.           CC1000RadioIntM$nbrInfo[2].slot = 5;
  2292.           CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[2].slot, CC1000RadioIntM$nbrInfo[2].frame);
  2293.           CC1000RadioIntM$nbrInfo[3].nodeID = 0;
  2294.           CC1000RadioIntM$nbrInfo[3].bitMap = TWO_HOP;
  2295.           CC1000RadioIntM$nbrInfo[3].frame = 16;
  2296.           CC1000RadioIntM$nbrInfo[3].slot = 9;
  2297.           CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[3].slot, CC1000RadioIntM$nbrInfo[3].frame);
  2298.         }
  2299.       else {
  2300. #line 90
  2301.         if (TOS_LOCAL_ADDRESS == 39) {
  2302.             CC1000RadioIntM$ownSlot = 2;
  2303.             CC1000RadioIntM$localFrameLength = 16;
  2304.             CC1000RadioIntM$nbrInfo[0].nodeID = 0;
  2305.             CC1000RadioIntM$nbrInfo[0].bitMap = TWO_HOP;
  2306.             CC1000RadioIntM$nbrInfo[0].frame = 16;
  2307.             CC1000RadioIntM$nbrInfo[0].slot = 9;
  2308.             CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[0].slot, CC1000RadioIntM$nbrInfo[0].frame);
  2309.           }
  2310.         else {
  2311. #line 98
  2312.           if (TOS_LOCAL_ADDRESS == 10) {
  2313.               CC1000RadioIntM$ownSlot = 0;
  2314.               CC1000RadioIntM$localFrameLength = 16;
  2315.               CC1000RadioIntM$nbrInfo[0].nodeID = 21;
  2316.               CC1000RadioIntM$nbrInfo[0].bitMap = TWO_HOP;
  2317.               CC1000RadioIntM$nbrInfo[0].frame = 16;
  2318.               CC1000RadioIntM$nbrInfo[0].slot = 13;
  2319.               CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[0].slot, CC1000RadioIntM$nbrInfo[0].frame);
  2320.               CC1000RadioIntM$nbrInfo[1].nodeID = 0;
  2321.               CC1000RadioIntM$nbrInfo[1].bitMap = TWO_HOP;
  2322.               CC1000RadioIntM$nbrInfo[1].frame = 16;
  2323.               CC1000RadioIntM$nbrInfo[1].slot = 9;
  2324.               CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[1].slot, CC1000RadioIntM$nbrInfo[1].frame);
  2325.               CC1000RadioIntM$nbrInfo[2].nodeID = 28;
  2326.               CC1000RadioIntM$nbrInfo[2].bitMap = TWO_HOP;
  2327.               CC1000RadioIntM$nbrInfo[2].frame = 16;
  2328.               CC1000RadioIntM$nbrInfo[2].slot = 3;
  2329.               CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[2].slot, CC1000RadioIntM$nbrInfo[2].frame);
  2330.               CC1000RadioIntM$nbrInfo[3].nodeID = 27;
  2331.               CC1000RadioIntM$nbrInfo[3].bitMap = TWO_HOP;
  2332.               CC1000RadioIntM$nbrInfo[3].frame = 16;
  2333.               CC1000RadioIntM$nbrInfo[3].slot = 5;
  2334.               CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[3].slot, CC1000RadioIntM$nbrInfo[3].frame);
  2335.             }
  2336.           else {
  2337. #line 121
  2338.             if (TOS_LOCAL_ADDRESS == 24) {
  2339.                 CC1000RadioIntM$ownSlot = 7;
  2340.                 CC1000RadioIntM$localFrameLength = 16;
  2341.                 CC1000RadioIntM$nbrInfo[0].nodeID = 0;
  2342.                 CC1000RadioIntM$nbrInfo[0].bitMap = TWO_HOP;
  2343.                 CC1000RadioIntM$nbrInfo[0].frame = 16;
  2344.                 CC1000RadioIntM$nbrInfo[0].slot = 9;
  2345.                 CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[0].slot, CC1000RadioIntM$nbrInfo[0].frame);
  2346.               }
  2347.             else {
  2348. #line 129
  2349.               if (TOS_LOCAL_ADDRESS == 1) {
  2350.                   CC1000RadioIntM$ownSlot = 6;
  2351.                   CC1000RadioIntM$localFrameLength = 16;
  2352.                   CC1000RadioIntM$nbrInfo[0].nodeID = 21;
  2353.                   CC1000RadioIntM$nbrInfo[0].bitMap = TWO_HOP;
  2354.                   CC1000RadioIntM$nbrInfo[0].frame = 16;
  2355.                   CC1000RadioIntM$nbrInfo[0].slot = 13;
  2356.                   CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[0].slot, CC1000RadioIntM$nbrInfo[0].frame);
  2357.                   CC1000RadioIntM$nbrInfo[1].nodeID = 37;
  2358.                   CC1000RadioIntM$nbrInfo[1].bitMap = TWO_HOP;
  2359.                   CC1000RadioIntM$nbrInfo[1].frame = 16;
  2360.                   CC1000RadioIntM$nbrInfo[1].slot = 10;
  2361.                   CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[1].slot, CC1000RadioIntM$nbrInfo[1].frame);
  2362.                   CC1000RadioIntM$nbrInfo[2].nodeID = 0;
  2363.                   CC1000RadioIntM$nbrInfo[2].bitMap = TWO_HOP;
  2364.                   CC1000RadioIntM$nbrInfo[2].frame = 16;
  2365.                   CC1000RadioIntM$nbrInfo[2].slot = 9;
  2366.                   CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[2].slot, CC1000RadioIntM$nbrInfo[2].frame);
  2367.                 }
  2368.               else {
  2369. #line 147
  2370.                 if (TOS_LOCAL_ADDRESS == 21) {
  2371.                     CC1000RadioIntM$ownSlot = 13;
  2372.                     CC1000RadioIntM$localFrameLength = 16;
  2373.                     CC1000RadioIntM$nbrInfo[0].nodeID = 28;
  2374.                     CC1000RadioIntM$nbrInfo[0].bitMap = TWO_HOP;
  2375.                     CC1000RadioIntM$nbrInfo[0].frame = 16;
  2376.                     CC1000RadioIntM$nbrInfo[0].slot = 3;
  2377.                     CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[0].slot, CC1000RadioIntM$nbrInfo[0].frame);
  2378.                     CC1000RadioIntM$nbrInfo[1].nodeID = 1;
  2379.                     CC1000RadioIntM$nbrInfo[1].bitMap = TWO_HOP;
  2380.                     CC1000RadioIntM$nbrInfo[1].frame = 16;
  2381.                     CC1000RadioIntM$nbrInfo[1].slot = 6;
  2382.                     CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[1].slot, CC1000RadioIntM$nbrInfo[1].frame);
  2383.                     CC1000RadioIntM$nbrInfo[2].nodeID = 9;
  2384.                     CC1000RadioIntM$nbrInfo[2].bitMap = TWO_HOP;
  2385.                     CC1000RadioIntM$nbrInfo[2].frame = 16;
  2386.                     CC1000RadioIntM$nbrInfo[2].slot = 1;
  2387.                     CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[2].slot, CC1000RadioIntM$nbrInfo[2].frame);
  2388.                     CC1000RadioIntM$nbrInfo[3].nodeID = 27;
  2389.                     CC1000RadioIntM$nbrInfo[3].bitMap = TWO_HOP;
  2390.                     CC1000RadioIntM$nbrInfo[3].frame = 16;
  2391.                     CC1000RadioIntM$nbrInfo[3].slot = 5;
  2392.                     CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[3].slot, CC1000RadioIntM$nbrInfo[3].frame);
  2393.                     CC1000RadioIntM$nbrInfo[4].nodeID = 10;
  2394.                     CC1000RadioIntM$nbrInfo[4].bitMap = TWO_HOP;
  2395.                     CC1000RadioIntM$nbrInfo[4].frame = 16;
  2396.                     CC1000RadioIntM$nbrInfo[4].slot = 0;
  2397.                     CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[4].slot, CC1000RadioIntM$nbrInfo[4].frame);
  2398.                     CC1000RadioIntM$nbrInfo[5].nodeID = 31;
  2399.                     CC1000RadioIntM$nbrInfo[5].bitMap = TWO_HOP;
  2400.                     CC1000RadioIntM$nbrInfo[5].frame = 16;
  2401.                     CC1000RadioIntM$nbrInfo[5].slot = 5;
  2402.                     CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[5].slot, CC1000RadioIntM$nbrInfo[5].frame);
  2403.                     CC1000RadioIntM$nbrInfo[6].nodeID = 15;
  2404.                     CC1000RadioIntM$nbrInfo[6].bitMap = TWO_HOP;
  2405.                     CC1000RadioIntM$nbrInfo[6].frame = 16;
  2406.                     CC1000RadioIntM$nbrInfo[6].slot = 6;
  2407.                     CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[6].slot, CC1000RadioIntM$nbrInfo[6].frame);
  2408.                     CC1000RadioIntM$nbrInfo[7].nodeID = 41;
  2409.                     CC1000RadioIntM$nbrInfo[7].bitMap = TWO_HOP;
  2410.                     CC1000RadioIntM$nbrInfo[7].frame = 16;
  2411.                     CC1000RadioIntM$nbrInfo[7].slot = 12;
  2412.                     CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[7].slot, CC1000RadioIntM$nbrInfo[7].frame);
  2413.                     CC1000RadioIntM$nbrInfo[8].nodeID = 40;
  2414.                     CC1000RadioIntM$nbrInfo[8].bitMap = TWO_HOP;
  2415.                     CC1000RadioIntM$nbrInfo[8].frame = 16;
  2416.                     CC1000RadioIntM$nbrInfo[8].slot = 11;
  2417.                     CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[8].slot, CC1000RadioIntM$nbrInfo[8].frame);
  2418.                     CC1000RadioIntM$nbrInfo[9].nodeID = 32;
  2419.                     CC1000RadioIntM$nbrInfo[9].bitMap = TWO_HOP;
  2420.                     CC1000RadioIntM$nbrInfo[9].frame = 16;
  2421.                     CC1000RadioIntM$nbrInfo[9].slot = 2;
  2422.                     CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[9].slot, CC1000RadioIntM$nbrInfo[9].frame);
  2423.                     CC1000RadioIntM$nbrInfo[10].nodeID = 17;
  2424.                     CC1000RadioIntM$nbrInfo[10].bitMap = TWO_HOP;
  2425.                     CC1000RadioIntM$nbrInfo[10].frame = 16;
  2426.                     CC1000RadioIntM$nbrInfo[10].slot = 4;
  2427.                     CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[10].slot, CC1000RadioIntM$nbrInfo[10].frame);
  2428.                     CC1000RadioIntM$nbrInfo[11].nodeID = 42;
  2429.                     CC1000RadioIntM$nbrInfo[11].bitMap = TWO_HOP;
  2430.                     CC1000RadioIntM$nbrInfo[11].frame = 16;
  2431.                     CC1000RadioIntM$nbrInfo[11].slot = 7;
  2432.                     CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[11].slot, CC1000RadioIntM$nbrInfo[11].frame);
  2433.                     CC1000RadioIntM$nbrInfo[12].nodeID = 2;
  2434.                     CC1000RadioIntM$nbrInfo[12].bitMap = TWO_HOP;
  2435.                     CC1000RadioIntM$nbrInfo[12].frame = 16;
  2436.                     CC1000RadioIntM$nbrInfo[12].slot = 4;
  2437.                     CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[12].slot, CC1000RadioIntM$nbrInfo[12].frame);
  2438.                   }
  2439.                 else {
  2440. #line 215
  2441.                   if (TOS_LOCAL_ADDRESS == 37) {
  2442.                       CC1000RadioIntM$ownSlot = 10;
  2443.                       CC1000RadioIntM$localFrameLength = 16;
  2444.                       CC1000RadioIntM$nbrInfo[0].nodeID = 28;
  2445.                       CC1000RadioIntM$nbrInfo[0].bitMap = TWO_HOP;
  2446.                       CC1000RadioIntM$nbrInfo[0].frame = 16;
  2447.                       CC1000RadioIntM$nbrInfo[0].slot = 3;
  2448.                       CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[0].slot, CC1000RadioIntM$nbrInfo[0].frame);
  2449.                       CC1000RadioIntM$nbrInfo[1].nodeID = 1;
  2450.                       CC1000RadioIntM$nbrInfo[1].bitMap = TWO_HOP;
  2451.                       CC1000RadioIntM$nbrInfo[1].frame = 16;
  2452.                       CC1000RadioIntM$nbrInfo[1].slot = 6;
  2453.                       CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[1].slot, CC1000RadioIntM$nbrInfo[1].frame);
  2454.                       CC1000RadioIntM$nbrInfo[2].nodeID = 27;
  2455.                       CC1000RadioIntM$nbrInfo[2].bitMap = TWO_HOP;
  2456.                       CC1000RadioIntM$nbrInfo[2].frame = 16;
  2457.                       CC1000RadioIntM$nbrInfo[2].slot = 5;
  2458.                       CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[2].slot, CC1000RadioIntM$nbrInfo[2].frame);
  2459.                       CC1000RadioIntM$nbrInfo[3].nodeID = 31;
  2460.                       CC1000RadioIntM$nbrInfo[3].bitMap = TWO_HOP;
  2461.                       CC1000RadioIntM$nbrInfo[3].frame = 16;
  2462.                       CC1000RadioIntM$nbrInfo[3].slot = 5;
  2463.                       CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[3].slot, CC1000RadioIntM$nbrInfo[3].frame);
  2464.                       CC1000RadioIntM$nbrInfo[4].nodeID = 15;
  2465.                       CC1000RadioIntM$nbrInfo[4].bitMap = TWO_HOP;
  2466.                       CC1000RadioIntM$nbrInfo[4].frame = 16;
  2467.                       CC1000RadioIntM$nbrInfo[4].slot = 6;
  2468.                       CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[4].slot, CC1000RadioIntM$nbrInfo[4].frame);
  2469.                       CC1000RadioIntM$nbrInfo[5].nodeID = 41;
  2470.                       CC1000RadioIntM$nbrInfo[5].bitMap = TWO_HOP;
  2471.                       CC1000RadioIntM$nbrInfo[5].frame = 16;
  2472.                       CC1000RadioIntM$nbrInfo[5].slot = 12;
  2473.                       CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[5].slot, CC1000RadioIntM$nbrInfo[5].frame);
  2474.                       CC1000RadioIntM$nbrInfo[6].nodeID = 40;
  2475.                       CC1000RadioIntM$nbrInfo[6].bitMap = TWO_HOP;
  2476.                       CC1000RadioIntM$nbrInfo[6].frame = 16;
  2477.                       CC1000RadioIntM$nbrInfo[6].slot = 11;
  2478.                       CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[6].slot, CC1000RadioIntM$nbrInfo[6].frame);
  2479.                       CC1000RadioIntM$nbrInfo[7].nodeID = 32;
  2480.                       CC1000RadioIntM$nbrInfo[7].bitMap = TWO_HOP;
  2481.                       CC1000RadioIntM$nbrInfo[7].frame = 16;
  2482.                       CC1000RadioIntM$nbrInfo[7].slot = 2;
  2483.                       CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[7].slot, CC1000RadioIntM$nbrInfo[7].frame);
  2484.                       CC1000RadioIntM$nbrInfo[8].nodeID = 17;
  2485.                       CC1000RadioIntM$nbrInfo[8].bitMap = TWO_HOP;
  2486.                       CC1000RadioIntM$nbrInfo[8].frame = 16;
  2487.                       CC1000RadioIntM$nbrInfo[8].slot = 4;
  2488.                       CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[8].slot, CC1000RadioIntM$nbrInfo[8].frame);
  2489.                       CC1000RadioIntM$nbrInfo[9].nodeID = 42;
  2490.                       CC1000RadioIntM$nbrInfo[9].bitMap = TWO_HOP;
  2491.                       CC1000RadioIntM$nbrInfo[9].frame = 16;
  2492.                       CC1000RadioIntM$nbrInfo[9].slot = 7;
  2493.                       CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[9].slot, CC1000RadioIntM$nbrInfo[9].frame);
  2494.                     }
  2495.                   else {
  2496. #line 268
  2497.                     if (TOS_LOCAL_ADDRESS == 27) {
  2498.                         CC1000RadioIntM$ownSlot = 5;
  2499.                         CC1000RadioIntM$localFrameLength = 16;
  2500.                         CC1000RadioIntM$nbrInfo[0].nodeID = 21;
  2501.                         CC1000RadioIntM$nbrInfo[0].bitMap = TWO_HOP;
  2502.                         CC1000RadioIntM$nbrInfo[0].frame = 16;
  2503.                         CC1000RadioIntM$nbrInfo[0].slot = 13;
  2504.                         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[0].slot, CC1000RadioIntM$nbrInfo[0].frame);
  2505.                         CC1000RadioIntM$nbrInfo[1].nodeID = 37;
  2506.                         CC1000RadioIntM$nbrInfo[1].bitMap = TWO_HOP;
  2507.                         CC1000RadioIntM$nbrInfo[1].frame = 16;
  2508.                         CC1000RadioIntM$nbrInfo[1].slot = 10;
  2509.                         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[1].slot, CC1000RadioIntM$nbrInfo[1].frame);
  2510.                         CC1000RadioIntM$nbrInfo[2].nodeID = 9;
  2511.                         CC1000RadioIntM$nbrInfo[2].bitMap = TWO_HOP;
  2512.                         CC1000RadioIntM$nbrInfo[2].frame = 16;
  2513.                         CC1000RadioIntM$nbrInfo[2].slot = 1;
  2514.                         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[2].slot, CC1000RadioIntM$nbrInfo[2].frame);
  2515.                         CC1000RadioIntM$nbrInfo[3].nodeID = 2;
  2516.                         CC1000RadioIntM$nbrInfo[3].bitMap = TWO_HOP;
  2517.                         CC1000RadioIntM$nbrInfo[3].frame = 16;
  2518.                         CC1000RadioIntM$nbrInfo[3].slot = 4;
  2519.                         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[3].slot, CC1000RadioIntM$nbrInfo[3].frame);
  2520.                         CC1000RadioIntM$nbrInfo[4].nodeID = 10;
  2521.                         CC1000RadioIntM$nbrInfo[4].bitMap = TWO_HOP;
  2522.                         CC1000RadioIntM$nbrInfo[4].frame = 16;
  2523.                         CC1000RadioIntM$nbrInfo[4].slot = 0;
  2524.                         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[4].slot, CC1000RadioIntM$nbrInfo[4].frame);
  2525.                         CC1000RadioIntM$nbrInfo[5].nodeID = 38;
  2526.                         CC1000RadioIntM$nbrInfo[5].bitMap = TWO_HOP;
  2527.                         CC1000RadioIntM$nbrInfo[5].frame = 16;
  2528.                         CC1000RadioIntM$nbrInfo[5].slot = 8;
  2529.                         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[5].slot, CC1000RadioIntM$nbrInfo[5].frame);
  2530.                         CC1000RadioIntM$nbrInfo[6].nodeID = 0;
  2531.                         CC1000RadioIntM$nbrInfo[6].bitMap = TWO_HOP;
  2532.                         CC1000RadioIntM$nbrInfo[6].frame = 16;
  2533.                         CC1000RadioIntM$nbrInfo[6].slot = 9;
  2534.                         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[6].slot, CC1000RadioIntM$nbrInfo[6].frame);
  2535.                         CC1000RadioIntM$nbrInfo[7].nodeID = 40;
  2536.                         CC1000RadioIntM$nbrInfo[7].bitMap = TWO_HOP;
  2537.                         CC1000RadioIntM$nbrInfo[7].frame = 16;
  2538.                         CC1000RadioIntM$nbrInfo[7].slot = 11;
  2539.                         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[7].slot, CC1000RadioIntM$nbrInfo[7].frame);
  2540.                         CC1000RadioIntM$nbrInfo[8].nodeID = 17;
  2541.                         CC1000RadioIntM$nbrInfo[8].bitMap = TWO_HOP;
  2542.                         CC1000RadioIntM$nbrInfo[8].frame = 16;
  2543.                         CC1000RadioIntM$nbrInfo[8].slot = 4;
  2544.                         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[8].slot, CC1000RadioIntM$nbrInfo[8].frame);
  2545.                         CC1000RadioIntM$nbrInfo[9].nodeID = 41;
  2546.                         CC1000RadioIntM$nbrInfo[9].bitMap = TWO_HOP;
  2547.                         CC1000RadioIntM$nbrInfo[9].frame = 16;
  2548.                         CC1000RadioIntM$nbrInfo[9].slot = 12;
  2549.                         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[9].slot, CC1000RadioIntM$nbrInfo[9].frame);
  2550.                         CC1000RadioIntM$nbrInfo[10].nodeID = 43;
  2551.                         CC1000RadioIntM$nbrInfo[10].bitMap = TWO_HOP;
  2552.                         CC1000RadioIntM$nbrInfo[10].frame = 16;
  2553.                         CC1000RadioIntM$nbrInfo[10].slot = 0;
  2554.                         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[10].slot, CC1000RadioIntM$nbrInfo[10].frame);
  2555.                         CC1000RadioIntM$nbrInfo[11].nodeID = 15;
  2556.                         CC1000RadioIntM$nbrInfo[11].bitMap = TWO_HOP;
  2557.                         CC1000RadioIntM$nbrInfo[11].frame = 16;
  2558.                         CC1000RadioIntM$nbrInfo[11].slot = 6;
  2559.                         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[11].slot, CC1000RadioIntM$nbrInfo[11].frame);
  2560.                         CC1000RadioIntM$nbrInfo[12].nodeID = 42;
  2561.                         CC1000RadioIntM$nbrInfo[12].bitMap = TWO_HOP;
  2562.                         CC1000RadioIntM$nbrInfo[12].frame = 16;
  2563.                         CC1000RadioIntM$nbrInfo[12].slot = 7;
  2564.                         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[12].slot, CC1000RadioIntM$nbrInfo[12].frame);
  2565.                         CC1000RadioIntM$nbrInfo[13].nodeID = 18;
  2566.                         CC1000RadioIntM$nbrInfo[13].bitMap = TWO_HOP;
  2567.                         CC1000RadioIntM$nbrInfo[13].frame = 16;
  2568.                         CC1000RadioIntM$nbrInfo[13].slot = 8;
  2569.                         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[13].slot, CC1000RadioIntM$nbrInfo[13].frame);
  2570.                         CC1000RadioIntM$nbrInfo[14].nodeID = 5;
  2571.                         CC1000RadioIntM$nbrInfo[14].bitMap = TWO_HOP;
  2572.                         CC1000RadioIntM$nbrInfo[14].frame = 16;
  2573.                         CC1000RadioIntM$nbrInfo[14].slot = 1;
  2574.                         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[14].slot, CC1000RadioIntM$nbrInfo[14].frame);
  2575.                         CC1000RadioIntM$nbrInfo[15].nodeID = 3;
  2576.                         CC1000RadioIntM$nbrInfo[15].bitMap = TWO_HOP;
  2577.                         CC1000RadioIntM$nbrInfo[15].frame = 16;
  2578.                         CC1000RadioIntM$nbrInfo[15].slot = 14;
  2579.                         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[15].slot, CC1000RadioIntM$nbrInfo[15].frame);
  2580.                       }
  2581.                     else {
  2582. #line 351
  2583.                       if (TOS_LOCAL_ADDRESS == 38) {
  2584.                           CC1000RadioIntM$ownSlot = 8;
  2585.                           CC1000RadioIntM$localFrameLength = 16;
  2586.                           CC1000RadioIntM$nbrInfo[0].nodeID = 28;
  2587.                           CC1000RadioIntM$nbrInfo[0].bitMap = TWO_HOP;
  2588.                           CC1000RadioIntM$nbrInfo[0].frame = 16;
  2589.                           CC1000RadioIntM$nbrInfo[0].slot = 3;
  2590.                           CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[0].slot, CC1000RadioIntM$nbrInfo[0].frame);
  2591.                           CC1000RadioIntM$nbrInfo[1].nodeID = 27;
  2592.                           CC1000RadioIntM$nbrInfo[1].bitMap = TWO_HOP;
  2593.                           CC1000RadioIntM$nbrInfo[1].frame = 16;
  2594.                           CC1000RadioIntM$nbrInfo[1].slot = 5;
  2595.                           CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[1].slot, CC1000RadioIntM$nbrInfo[1].frame);
  2596.                           CC1000RadioIntM$nbrInfo[2].nodeID = 31;
  2597.                           CC1000RadioIntM$nbrInfo[2].bitMap = TWO_HOP;
  2598.                           CC1000RadioIntM$nbrInfo[2].frame = 16;
  2599.                           CC1000RadioIntM$nbrInfo[2].slot = 5;
  2600.                           CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[2].slot, CC1000RadioIntM$nbrInfo[2].frame);
  2601.                           CC1000RadioIntM$nbrInfo[3].nodeID = 15;
  2602.                           CC1000RadioIntM$nbrInfo[3].bitMap = TWO_HOP;
  2603.                           CC1000RadioIntM$nbrInfo[3].frame = 16;
  2604.                           CC1000RadioIntM$nbrInfo[3].slot = 6;
  2605.                           CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[3].slot, CC1000RadioIntM$nbrInfo[3].frame);
  2606.                           CC1000RadioIntM$nbrInfo[4].nodeID = 41;
  2607.                           CC1000RadioIntM$nbrInfo[4].bitMap = TWO_HOP;
  2608.                           CC1000RadioIntM$nbrInfo[4].frame = 16;
  2609.                           CC1000RadioIntM$nbrInfo[4].slot = 12;
  2610.                           CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[4].slot, CC1000RadioIntM$nbrInfo[4].frame);
  2611.                           CC1000RadioIntM$nbrInfo[5].nodeID = 40;
  2612.                           CC1000RadioIntM$nbrInfo[5].bitMap = TWO_HOP;
  2613.                           CC1000RadioIntM$nbrInfo[5].frame = 16;
  2614.                           CC1000RadioIntM$nbrInfo[5].slot = 11;
  2615.                           CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[5].slot, CC1000RadioIntM$nbrInfo[5].frame);
  2616.                           CC1000RadioIntM$nbrInfo[6].nodeID = 32;
  2617.                           CC1000RadioIntM$nbrInfo[6].bitMap = TWO_HOP;
  2618.                           CC1000RadioIntM$nbrInfo[6].frame = 16;
  2619.                           CC1000RadioIntM$nbrInfo[6].slot = 2;
  2620.                           CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[6].slot, CC1000RadioIntM$nbrInfo[6].frame);
  2621.                           CC1000RadioIntM$nbrInfo[7].nodeID = 17;
  2622.                           CC1000RadioIntM$nbrInfo[7].bitMap = TWO_HOP;
  2623.                           CC1000RadioIntM$nbrInfo[7].frame = 16;
  2624.                           CC1000RadioIntM$nbrInfo[7].slot = 4;
  2625.                           CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[7].slot, CC1000RadioIntM$nbrInfo[7].frame);
  2626.                           CC1000RadioIntM$nbrInfo[8].nodeID = 42;
  2627.                           CC1000RadioIntM$nbrInfo[8].bitMap = TWO_HOP;
  2628.                           CC1000RadioIntM$nbrInfo[8].frame = 16;
  2629.                           CC1000RadioIntM$nbrInfo[8].slot = 7;
  2630.                           CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[8].slot, CC1000RadioIntM$nbrInfo[8].frame);
  2631.                         }
  2632.                       else {
  2633. #line 399
  2634.                         if (TOS_LOCAL_ADDRESS == 0) {
  2635.                             CC1000RadioIntM$ownSlot = 9;
  2636.                             CC1000RadioIntM$localFrameLength = 16;
  2637.                             CC1000RadioIntM$nbrInfo[0].nodeID = 39;
  2638.                             CC1000RadioIntM$nbrInfo[0].bitMap = TWO_HOP;
  2639.                             CC1000RadioIntM$nbrInfo[0].frame = 16;
  2640.                             CC1000RadioIntM$nbrInfo[0].slot = 2;
  2641.                             CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[0].slot, CC1000RadioIntM$nbrInfo[0].frame);
  2642.                             CC1000RadioIntM$nbrInfo[1].nodeID = 24;
  2643.                             CC1000RadioIntM$nbrInfo[1].bitMap = TWO_HOP;
  2644.                             CC1000RadioIntM$nbrInfo[1].frame = 16;
  2645.                             CC1000RadioIntM$nbrInfo[1].slot = 7;
  2646.                             CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[1].slot, CC1000RadioIntM$nbrInfo[1].frame);
  2647.                             CC1000RadioIntM$nbrInfo[2].nodeID = 9;
  2648.                             CC1000RadioIntM$nbrInfo[2].bitMap = TWO_HOP;
  2649.                             CC1000RadioIntM$nbrInfo[2].frame = 16;
  2650.                             CC1000RadioIntM$nbrInfo[2].slot = 1;
  2651.                             CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[2].slot, CC1000RadioIntM$nbrInfo[2].frame);
  2652.                             CC1000RadioIntM$nbrInfo[3].nodeID = 10;
  2653.                             CC1000RadioIntM$nbrInfo[3].bitMap = TWO_HOP;
  2654.                             CC1000RadioIntM$nbrInfo[3].frame = 16;
  2655.                             CC1000RadioIntM$nbrInfo[3].slot = 0;
  2656.                             CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[3].slot, CC1000RadioIntM$nbrInfo[3].frame);
  2657.                             CC1000RadioIntM$nbrInfo[4].nodeID = 2;
  2658.                             CC1000RadioIntM$nbrInfo[4].bitMap = TWO_HOP;
  2659.                             CC1000RadioIntM$nbrInfo[4].frame = 16;
  2660.                             CC1000RadioIntM$nbrInfo[4].slot = 4;
  2661.                             CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[4].slot, CC1000RadioIntM$nbrInfo[4].frame);
  2662.                             CC1000RadioIntM$nbrInfo[5].nodeID = 43;
  2663.                             CC1000RadioIntM$nbrInfo[5].bitMap = TWO_HOP;
  2664.                             CC1000RadioIntM$nbrInfo[5].frame = 16;
  2665.                             CC1000RadioIntM$nbrInfo[5].slot = 0;
  2666.                             CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[5].slot, CC1000RadioIntM$nbrInfo[5].frame);
  2667.                             CC1000RadioIntM$nbrInfo[6].nodeID = 5;
  2668.                             CC1000RadioIntM$nbrInfo[6].bitMap = TWO_HOP;
  2669.                             CC1000RadioIntM$nbrInfo[6].frame = 16;
  2670.                             CC1000RadioIntM$nbrInfo[6].slot = 1;
  2671.                             CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[6].slot, CC1000RadioIntM$nbrInfo[6].frame);
  2672.                             CC1000RadioIntM$nbrInfo[7].nodeID = 1;
  2673.                             CC1000RadioIntM$nbrInfo[7].bitMap = TWO_HOP;
  2674.                             CC1000RadioIntM$nbrInfo[7].frame = 16;
  2675.                             CC1000RadioIntM$nbrInfo[7].slot = 6;
  2676.                             CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[7].slot, CC1000RadioIntM$nbrInfo[7].frame);
  2677.                             CC1000RadioIntM$nbrInfo[8].nodeID = 28;
  2678.                             CC1000RadioIntM$nbrInfo[8].bitMap = TWO_HOP;
  2679.                             CC1000RadioIntM$nbrInfo[8].frame = 16;
  2680.                             CC1000RadioIntM$nbrInfo[8].slot = 3;
  2681.                             CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[8].slot, CC1000RadioIntM$nbrInfo[8].frame);
  2682.                             CC1000RadioIntM$nbrInfo[9].nodeID = 14;
  2683.                             CC1000RadioIntM$nbrInfo[9].bitMap = TWO_HOP;
  2684.                             CC1000RadioIntM$nbrInfo[9].frame = 16;
  2685.                             CC1000RadioIntM$nbrInfo[9].slot = 10;
  2686.                             CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[9].slot, CC1000RadioIntM$nbrInfo[9].frame);
  2687.                             CC1000RadioIntM$nbrInfo[10].nodeID = 19;
  2688.                             CC1000RadioIntM$nbrInfo[10].bitMap = TWO_HOP;
  2689.                             CC1000RadioIntM$nbrInfo[10].frame = 16;
  2690.                             CC1000RadioIntM$nbrInfo[10].slot = 3;
  2691.                             CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[10].slot, CC1000RadioIntM$nbrInfo[10].frame);
  2692.                             CC1000RadioIntM$nbrInfo[11].nodeID = 18;
  2693.                             CC1000RadioIntM$nbrInfo[11].bitMap = TWO_HOP;
  2694.                             CC1000RadioIntM$nbrInfo[11].frame = 16;
  2695.                             CC1000RadioIntM$nbrInfo[11].slot = 8;
  2696.                             CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[11].slot, CC1000RadioIntM$nbrInfo[11].frame);
  2697.                           }
  2698.                         else {
  2699. #line 462
  2700.                           if (TOS_LOCAL_ADDRESS == 31) {
  2701.                               CC1000RadioIntM$ownSlot = 5;
  2702.                               CC1000RadioIntM$localFrameLength = 16;
  2703.                               CC1000RadioIntM$nbrInfo[0].nodeID = 38;
  2704.                               CC1000RadioIntM$nbrInfo[0].bitMap = TWO_HOP;
  2705.                               CC1000RadioIntM$nbrInfo[0].frame = 16;
  2706.                               CC1000RadioIntM$nbrInfo[0].slot = 8;
  2707.                               CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[0].slot, CC1000RadioIntM$nbrInfo[0].frame);
  2708.                               CC1000RadioIntM$nbrInfo[1].nodeID = 21;
  2709.                               CC1000RadioIntM$nbrInfo[1].bitMap = TWO_HOP;
  2710.                               CC1000RadioIntM$nbrInfo[1].frame = 16;
  2711.                               CC1000RadioIntM$nbrInfo[1].slot = 13;
  2712.                               CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[1].slot, CC1000RadioIntM$nbrInfo[1].frame);
  2713.                               CC1000RadioIntM$nbrInfo[2].nodeID = 19;
  2714.                               CC1000RadioIntM$nbrInfo[2].bitMap = TWO_HOP;
  2715.                               CC1000RadioIntM$nbrInfo[2].frame = 16;
  2716.                               CC1000RadioIntM$nbrInfo[2].slot = 3;
  2717.                               CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[2].slot, CC1000RadioIntM$nbrInfo[2].frame);
  2718.                               CC1000RadioIntM$nbrInfo[3].nodeID = 37;
  2719.                               CC1000RadioIntM$nbrInfo[3].bitMap = TWO_HOP;
  2720.                               CC1000RadioIntM$nbrInfo[3].frame = 16;
  2721.                               CC1000RadioIntM$nbrInfo[3].slot = 10;
  2722.                               CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[3].slot, CC1000RadioIntM$nbrInfo[3].frame);
  2723.                               CC1000RadioIntM$nbrInfo[4].nodeID = 3;
  2724.                               CC1000RadioIntM$nbrInfo[4].bitMap = TWO_HOP;
  2725.                               CC1000RadioIntM$nbrInfo[4].frame = 16;
  2726.                               CC1000RadioIntM$nbrInfo[4].slot = 14;
  2727.                               CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[4].slot, CC1000RadioIntM$nbrInfo[4].frame);
  2728.                             }
  2729.                           else {
  2730. #line 490
  2731.                             if (TOS_LOCAL_ADDRESS == 41) {
  2732.                                 CC1000RadioIntM$ownSlot = 12;
  2733.                                 CC1000RadioIntM$localFrameLength = 16;
  2734.                                 CC1000RadioIntM$nbrInfo[0].nodeID = 38;
  2735.                                 CC1000RadioIntM$nbrInfo[0].bitMap = TWO_HOP;
  2736.                                 CC1000RadioIntM$nbrInfo[0].frame = 16;
  2737.                                 CC1000RadioIntM$nbrInfo[0].slot = 8;
  2738.                                 CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[0].slot, CC1000RadioIntM$nbrInfo[0].frame);
  2739.                                 CC1000RadioIntM$nbrInfo[1].nodeID = 21;
  2740.                                 CC1000RadioIntM$nbrInfo[1].bitMap = TWO_HOP;
  2741.                                 CC1000RadioIntM$nbrInfo[1].frame = 16;
  2742.                                 CC1000RadioIntM$nbrInfo[1].slot = 13;
  2743.                                 CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[1].slot, CC1000RadioIntM$nbrInfo[1].frame);
  2744.                                 CC1000RadioIntM$nbrInfo[2].nodeID = 3;
  2745.                                 CC1000RadioIntM$nbrInfo[2].bitMap = TWO_HOP;
  2746.                                 CC1000RadioIntM$nbrInfo[2].frame = 16;
  2747.                                 CC1000RadioIntM$nbrInfo[2].slot = 14;
  2748.                                 CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[2].slot, CC1000RadioIntM$nbrInfo[2].frame);
  2749.                               }
  2750.                             else {
  2751. #line 508
  2752.                               if (TOS_LOCAL_ADDRESS == 40) {
  2753.                                   CC1000RadioIntM$ownSlot = 11;
  2754.                                   CC1000RadioIntM$localFrameLength = 16;
  2755.                                   CC1000RadioIntM$nbrInfo[0].nodeID = 18;
  2756.                                   CC1000RadioIntM$nbrInfo[0].bitMap = TWO_HOP;
  2757.                                   CC1000RadioIntM$nbrInfo[0].frame = 16;
  2758.                                   CC1000RadioIntM$nbrInfo[0].slot = 8;
  2759.                                   CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[0].slot, CC1000RadioIntM$nbrInfo[0].frame);
  2760.                                   CC1000RadioIntM$nbrInfo[1].nodeID = 38;
  2761.                                   CC1000RadioIntM$nbrInfo[1].bitMap = TWO_HOP;
  2762.                                   CC1000RadioIntM$nbrInfo[1].frame = 16;
  2763.                                   CC1000RadioIntM$nbrInfo[1].slot = 8;
  2764.                                   CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[1].slot, CC1000RadioIntM$nbrInfo[1].frame);
  2765.                                   CC1000RadioIntM$nbrInfo[2].nodeID = 21;
  2766.                                   CC1000RadioIntM$nbrInfo[2].bitMap = TWO_HOP;
  2767.                                   CC1000RadioIntM$nbrInfo[2].frame = 16;
  2768.                                   CC1000RadioIntM$nbrInfo[2].slot = 13;
  2769.                                   CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[2].slot, CC1000RadioIntM$nbrInfo[2].frame);
  2770.                                   CC1000RadioIntM$nbrInfo[3].nodeID = 3;
  2771.                                   CC1000RadioIntM$nbrInfo[3].bitMap = TWO_HOP;
  2772.                                   CC1000RadioIntM$nbrInfo[3].frame = 16;
  2773.                                   CC1000RadioIntM$nbrInfo[3].slot = 14;
  2774.                                   CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[3].slot, CC1000RadioIntM$nbrInfo[3].frame);
  2775.                                 }
  2776.                               else {
  2777. #line 531
  2778.                                 if (TOS_LOCAL_ADDRESS == 28) {
  2779.                                     CC1000RadioIntM$ownSlot = 3;
  2780.                                     CC1000RadioIntM$localFrameLength = 16;
  2781.                                     CC1000RadioIntM$nbrInfo[0].nodeID = 21;
  2782.                                     CC1000RadioIntM$nbrInfo[0].bitMap = TWO_HOP;
  2783.                                     CC1000RadioIntM$nbrInfo[0].frame = 16;
  2784.                                     CC1000RadioIntM$nbrInfo[0].slot = 13;
  2785.                                     CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[0].slot, CC1000RadioIntM$nbrInfo[0].frame);
  2786.                                     CC1000RadioIntM$nbrInfo[1].nodeID = 37;
  2787.                                     CC1000RadioIntM$nbrInfo[1].bitMap = TWO_HOP;
  2788.                                     CC1000RadioIntM$nbrInfo[1].frame = 16;
  2789.                                     CC1000RadioIntM$nbrInfo[1].slot = 10;
  2790.                                     CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[1].slot, CC1000RadioIntM$nbrInfo[1].frame);
  2791.                                     CC1000RadioIntM$nbrInfo[2].nodeID = 9;
  2792.                                     CC1000RadioIntM$nbrInfo[2].bitMap = TWO_HOP;
  2793.                                     CC1000RadioIntM$nbrInfo[2].frame = 16;
  2794.                                     CC1000RadioIntM$nbrInfo[2].slot = 1;
  2795.                                     CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[2].slot, CC1000RadioIntM$nbrInfo[2].frame);
  2796.                                     CC1000RadioIntM$nbrInfo[3].nodeID = 2;
  2797.                                     CC1000RadioIntM$nbrInfo[3].bitMap = TWO_HOP;
  2798.                                     CC1000RadioIntM$nbrInfo[3].frame = 16;
  2799.                                     CC1000RadioIntM$nbrInfo[3].slot = 4;
  2800.                                     CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[3].slot, CC1000RadioIntM$nbrInfo[3].frame);
  2801.                                     CC1000RadioIntM$nbrInfo[4].nodeID = 10;
  2802.                                     CC1000RadioIntM$nbrInfo[4].bitMap = TWO_HOP;
  2803.                                     CC1000RadioIntM$nbrInfo[4].frame = 16;
  2804.                                     CC1000RadioIntM$nbrInfo[4].slot = 0;
  2805.                                     CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[4].slot, CC1000RadioIntM$nbrInfo[4].frame);
  2806.                                     CC1000RadioIntM$nbrInfo[5].nodeID = 38;
  2807.                                     CC1000RadioIntM$nbrInfo[5].bitMap = TWO_HOP;
  2808.                                     CC1000RadioIntM$nbrInfo[5].frame = 16;
  2809.                                     CC1000RadioIntM$nbrInfo[5].slot = 8;
  2810.                                     CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[5].slot, CC1000RadioIntM$nbrInfo[5].frame);
  2811.                                     CC1000RadioIntM$nbrInfo[6].nodeID = 0;
  2812.                                     CC1000RadioIntM$nbrInfo[6].bitMap = TWO_HOP;
  2813.                                     CC1000RadioIntM$nbrInfo[6].frame = 16;
  2814.                                     CC1000RadioIntM$nbrInfo[6].slot = 9;
  2815.                                     CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[6].slot, CC1000RadioIntM$nbrInfo[6].frame);
  2816.                                   }
  2817.                                 else {
  2818. #line 569
  2819.                                   if (TOS_LOCAL_ADDRESS == 15) {
  2820.                                       CC1000RadioIntM$ownSlot = 6;
  2821.                                       CC1000RadioIntM$localFrameLength = 16;
  2822.                                       CC1000RadioIntM$nbrInfo[0].nodeID = 38;
  2823.                                       CC1000RadioIntM$nbrInfo[0].bitMap = TWO_HOP;
  2824.                                       CC1000RadioIntM$nbrInfo[0].frame = 16;
  2825.                                       CC1000RadioIntM$nbrInfo[0].slot = 8;
  2826.                                       CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[0].slot, CC1000RadioIntM$nbrInfo[0].frame);
  2827.                                       CC1000RadioIntM$nbrInfo[1].nodeID = 21;
  2828.                                       CC1000RadioIntM$nbrInfo[1].bitMap = TWO_HOP;
  2829.                                       CC1000RadioIntM$nbrInfo[1].frame = 16;
  2830.                                       CC1000RadioIntM$nbrInfo[1].slot = 13;
  2831.                                       CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[1].slot, CC1000RadioIntM$nbrInfo[1].frame);
  2832.                                       CC1000RadioIntM$nbrInfo[2].nodeID = 19;
  2833.                                       CC1000RadioIntM$nbrInfo[2].bitMap = TWO_HOP;
  2834.                                       CC1000RadioIntM$nbrInfo[2].frame = 16;
  2835.                                       CC1000RadioIntM$nbrInfo[2].slot = 3;
  2836.                                       CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[2].slot, CC1000RadioIntM$nbrInfo[2].frame);
  2837.                                       CC1000RadioIntM$nbrInfo[3].nodeID = 14;
  2838.                                       CC1000RadioIntM$nbrInfo[3].bitMap = TWO_HOP;
  2839.                                       CC1000RadioIntM$nbrInfo[3].frame = 16;
  2840.                                       CC1000RadioIntM$nbrInfo[3].slot = 10;
  2841.                                       CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[3].slot, CC1000RadioIntM$nbrInfo[3].frame);
  2842.                                       CC1000RadioIntM$nbrInfo[4].nodeID = 18;
  2843.                                       CC1000RadioIntM$nbrInfo[4].bitMap = TWO_HOP;
  2844.                                       CC1000RadioIntM$nbrInfo[4].frame = 16;
  2845.                                       CC1000RadioIntM$nbrInfo[4].slot = 8;
  2846.                                       CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[4].slot, CC1000RadioIntM$nbrInfo[4].frame);
  2847.                                       CC1000RadioIntM$nbrInfo[5].nodeID = 3;
  2848.                                       CC1000RadioIntM$nbrInfo[5].bitMap = TWO_HOP;
  2849.                                       CC1000RadioIntM$nbrInfo[5].frame = 16;
  2850.                                       CC1000RadioIntM$nbrInfo[5].slot = 14;
  2851.                                       CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[5].slot, CC1000RadioIntM$nbrInfo[5].frame);
  2852.                                     }
  2853.                                   else {
  2854. #line 602
  2855.                                     if (TOS_LOCAL_ADDRESS == 17) {
  2856.                                         CC1000RadioIntM$ownSlot = 4;
  2857.                                         CC1000RadioIntM$localFrameLength = 16;
  2858.                                         CC1000RadioIntM$nbrInfo[0].nodeID = 38;
  2859.                                         CC1000RadioIntM$nbrInfo[0].bitMap = TWO_HOP;
  2860.                                         CC1000RadioIntM$nbrInfo[0].frame = 16;
  2861.                                         CC1000RadioIntM$nbrInfo[0].slot = 8;
  2862.                                         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[0].slot, CC1000RadioIntM$nbrInfo[0].frame);
  2863.                                         CC1000RadioIntM$nbrInfo[1].nodeID = 21;
  2864.                                         CC1000RadioIntM$nbrInfo[1].bitMap = TWO_HOP;
  2865.                                         CC1000RadioIntM$nbrInfo[1].frame = 16;
  2866.                                         CC1000RadioIntM$nbrInfo[1].slot = 13;
  2867.                                         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[1].slot, CC1000RadioIntM$nbrInfo[1].frame);
  2868.                                         CC1000RadioIntM$nbrInfo[2].nodeID = 19;
  2869.                                         CC1000RadioIntM$nbrInfo[2].bitMap = TWO_HOP;
  2870.                                         CC1000RadioIntM$nbrInfo[2].frame = 16;
  2871.                                         CC1000RadioIntM$nbrInfo[2].slot = 3;
  2872.                                         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[2].slot, CC1000RadioIntM$nbrInfo[2].frame);
  2873.                                         CC1000RadioIntM$nbrInfo[3].nodeID = 37;
  2874.                                         CC1000RadioIntM$nbrInfo[3].bitMap = TWO_HOP;
  2875.                                         CC1000RadioIntM$nbrInfo[3].frame = 16;
  2876.                                         CC1000RadioIntM$nbrInfo[3].slot = 10;
  2877.                                         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[3].slot, CC1000RadioIntM$nbrInfo[3].frame);
  2878.                                         CC1000RadioIntM$nbrInfo[4].nodeID = 18;
  2879.                                         CC1000RadioIntM$nbrInfo[4].bitMap = TWO_HOP;
  2880.                                         CC1000RadioIntM$nbrInfo[4].frame = 16;
  2881.                                         CC1000RadioIntM$nbrInfo[4].slot = 8;
  2882.                                         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[4].slot, CC1000RadioIntM$nbrInfo[4].frame);
  2883.                                         CC1000RadioIntM$nbrInfo[5].nodeID = 3;
  2884.                                         CC1000RadioIntM$nbrInfo[5].bitMap = TWO_HOP;
  2885.                                         CC1000RadioIntM$nbrInfo[5].frame = 16;
  2886.                                         CC1000RadioIntM$nbrInfo[5].slot = 14;
  2887.                                         CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[5].slot, CC1000RadioIntM$nbrInfo[5].frame);
  2888.                                       }
  2889.                                     else {
  2890. #line 635
  2891.                                       if (TOS_LOCAL_ADDRESS == 32) {
  2892.                                           CC1000RadioIntM$ownSlot = 2;
  2893.                                           CC1000RadioIntM$localFrameLength = 16;
  2894.                                           CC1000RadioIntM$nbrInfo[0].nodeID = 38;
  2895.                                           CC1000RadioIntM$nbrInfo[0].bitMap = TWO_HOP;
  2896.                                           CC1000RadioIntM$nbrInfo[0].frame = 16;
  2897.                                           CC1000RadioIntM$nbrInfo[0].slot = 8;
  2898.                                           CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[0].slot, CC1000RadioIntM$nbrInfo[0].frame);
  2899.                                           CC1000RadioIntM$nbrInfo[1].nodeID = 21;
  2900.                                           CC1000RadioIntM$nbrInfo[1].bitMap = TWO_HOP;
  2901.                                           CC1000RadioIntM$nbrInfo[1].frame = 16;
  2902.                                           CC1000RadioIntM$nbrInfo[1].slot = 13;
  2903.                                           CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[1].slot, CC1000RadioIntM$nbrInfo[1].frame);
  2904.                                           CC1000RadioIntM$nbrInfo[2].nodeID = 37;
  2905.                                           CC1000RadioIntM$nbrInfo[2].bitMap = TWO_HOP;
  2906.                                           CC1000RadioIntM$nbrInfo[2].frame = 16;
  2907.                                           CC1000RadioIntM$nbrInfo[2].slot = 10;
  2908.                                           CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[2].slot, CC1000RadioIntM$nbrInfo[2].frame);
  2909.                                           CC1000RadioIntM$nbrInfo[3].nodeID = 19;
  2910.                                           CC1000RadioIntM$nbrInfo[3].bitMap = TWO_HOP;
  2911.                                           CC1000RadioIntM$nbrInfo[3].frame = 16;
  2912.                                           CC1000RadioIntM$nbrInfo[3].slot = 3;
  2913.                                           CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[3].slot, CC1000RadioIntM$nbrInfo[3].frame);
  2914.                                           CC1000RadioIntM$nbrInfo[4].nodeID = 14;
  2915.                                           CC1000RadioIntM$nbrInfo[4].bitMap = TWO_HOP;
  2916.                                           CC1000RadioIntM$nbrInfo[4].frame = 16;
  2917.                                           CC1000RadioIntM$nbrInfo[4].slot = 10;
  2918.                                           CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[4].slot, CC1000RadioIntM$nbrInfo[4].frame);
  2919.                                           CC1000RadioIntM$nbrInfo[5].nodeID = 3;
  2920.                                           CC1000RadioIntM$nbrInfo[5].bitMap = TWO_HOP;
  2921.                                           CC1000RadioIntM$nbrInfo[5].frame = 16;
  2922.                                           CC1000RadioIntM$nbrInfo[5].slot = 14;
  2923.                                           CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[5].slot, CC1000RadioIntM$nbrInfo[5].frame);
  2924.                                         }
  2925.                                       else {
  2926. #line 668
  2927.                                         if (TOS_LOCAL_ADDRESS == 18) {
  2928.                                             CC1000RadioIntM$ownSlot = 8;
  2929.                                             CC1000RadioIntM$localFrameLength = 16;
  2930.                                             CC1000RadioIntM$nbrInfo[0].nodeID = 43;
  2931.                                             CC1000RadioIntM$nbrInfo[0].bitMap = TWO_HOP;
  2932.                                             CC1000RadioIntM$nbrInfo[0].frame = 16;
  2933.                                             CC1000RadioIntM$nbrInfo[0].slot = 0;
  2934.                                             CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[0].slot, CC1000RadioIntM$nbrInfo[0].frame);
  2935.                                             CC1000RadioIntM$nbrInfo[1].nodeID = 17;
  2936.                                             CC1000RadioIntM$nbrInfo[1].bitMap = TWO_HOP;
  2937.                                             CC1000RadioIntM$nbrInfo[1].frame = 16;
  2938.                                             CC1000RadioIntM$nbrInfo[1].slot = 4;
  2939.                                             CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[1].slot, CC1000RadioIntM$nbrInfo[1].frame);
  2940.                                             CC1000RadioIntM$nbrInfo[2].nodeID = 15;
  2941.                                             CC1000RadioIntM$nbrInfo[2].bitMap = TWO_HOP;
  2942.                                             CC1000RadioIntM$nbrInfo[2].frame = 16;
  2943.                                             CC1000RadioIntM$nbrInfo[2].slot = 6;
  2944.                                             CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[2].slot, CC1000RadioIntM$nbrInfo[2].frame);
  2945.                                             CC1000RadioIntM$nbrInfo[3].nodeID = 0;
  2946.                                             CC1000RadioIntM$nbrInfo[3].bitMap = TWO_HOP;
  2947.                                             CC1000RadioIntM$nbrInfo[3].frame = 16;
  2948.                                             CC1000RadioIntM$nbrInfo[3].slot = 9;
  2949.                                             CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[3].slot, CC1000RadioIntM$nbrInfo[3].frame);
  2950.                                             CC1000RadioIntM$nbrInfo[4].nodeID = 40;
  2951.                                             CC1000RadioIntM$nbrInfo[4].bitMap = TWO_HOP;
  2952.                                             CC1000RadioIntM$nbrInfo[4].frame = 16;
  2953.                                             CC1000RadioIntM$nbrInfo[4].slot = 11;
  2954.                                             CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[4].slot, CC1000RadioIntM$nbrInfo[4].frame);
  2955.                                           }
  2956.                                         else {
  2957. #line 696
  2958.                                           if (TOS_LOCAL_ADDRESS == 42) {
  2959.                                               CC1000RadioIntM$ownSlot = 7;
  2960.                                               CC1000RadioIntM$localFrameLength = 16;
  2961.                                               CC1000RadioIntM$nbrInfo[0].nodeID = 38;
  2962.                                               CC1000RadioIntM$nbrInfo[0].bitMap = TWO_HOP;
  2963.                                               CC1000RadioIntM$nbrInfo[0].frame = 16;
  2964.                                               CC1000RadioIntM$nbrInfo[0].slot = 8;
  2965.                                               CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[0].slot, CC1000RadioIntM$nbrInfo[0].frame);
  2966.                                               CC1000RadioIntM$nbrInfo[1].nodeID = 21;
  2967.                                               CC1000RadioIntM$nbrInfo[1].bitMap = TWO_HOP;
  2968.                                               CC1000RadioIntM$nbrInfo[1].frame = 16;
  2969.                                               CC1000RadioIntM$nbrInfo[1].slot = 13;
  2970.                                               CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[1].slot, CC1000RadioIntM$nbrInfo[1].frame);
  2971.                                               CC1000RadioIntM$nbrInfo[2].nodeID = 3;
  2972.                                               CC1000RadioIntM$nbrInfo[2].bitMap = TWO_HOP;
  2973.                                               CC1000RadioIntM$nbrInfo[2].frame = 16;
  2974.                                               CC1000RadioIntM$nbrInfo[2].slot = 14;
  2975.                                               CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[2].slot, CC1000RadioIntM$nbrInfo[2].frame);
  2976.                                             }
  2977.                                           else {
  2978. #line 714
  2979.                                             if (TOS_LOCAL_ADDRESS == 43) {
  2980.                                                 CC1000RadioIntM$ownSlot = 0;
  2981.                                                 CC1000RadioIntM$localFrameLength = 16;
  2982.                                                 CC1000RadioIntM$nbrInfo[0].nodeID = 18;
  2983.                                                 CC1000RadioIntM$nbrInfo[0].bitMap = TWO_HOP;
  2984.                                                 CC1000RadioIntM$nbrInfo[0].frame = 16;
  2985.                                                 CC1000RadioIntM$nbrInfo[0].slot = 8;
  2986.                                                 CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[0].slot, CC1000RadioIntM$nbrInfo[0].frame);
  2987.                                                 CC1000RadioIntM$nbrInfo[1].nodeID = 0;
  2988.                                                 CC1000RadioIntM$nbrInfo[1].bitMap = TWO_HOP;
  2989.                                                 CC1000RadioIntM$nbrInfo[1].frame = 16;
  2990.                                                 CC1000RadioIntM$nbrInfo[1].slot = 9;
  2991.                                                 CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[1].slot, CC1000RadioIntM$nbrInfo[1].frame);
  2992.                                               }
  2993.                                             else {
  2994. #line 727
  2995.                                               if (TOS_LOCAL_ADDRESS == 5) {
  2996.                                                   CC1000RadioIntM$ownSlot = 1;
  2997.                                                   CC1000RadioIntM$localFrameLength = 16;
  2998.                                                   CC1000RadioIntM$nbrInfo[0].nodeID = 0;
  2999.                                                   CC1000RadioIntM$nbrInfo[0].bitMap = TWO_HOP;
  3000.                                                   CC1000RadioIntM$nbrInfo[0].frame = 16;
  3001.                                                   CC1000RadioIntM$nbrInfo[0].slot = 9;
  3002.                                                   CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[0].slot, CC1000RadioIntM$nbrInfo[0].frame);
  3003.                                                 }
  3004.                                               else {
  3005. #line 735
  3006.                                                 if (TOS_LOCAL_ADDRESS == 19) {
  3007.                                                     CC1000RadioIntM$ownSlot = 3;
  3008.                                                     CC1000RadioIntM$localFrameLength = 16;
  3009.                                                     CC1000RadioIntM$nbrInfo[0].nodeID = 31;
  3010.                                                     CC1000RadioIntM$nbrInfo[0].bitMap = TWO_HOP;
  3011.                                                     CC1000RadioIntM$nbrInfo[0].frame = 16;
  3012.                                                     CC1000RadioIntM$nbrInfo[0].slot = 5;
  3013.                                                     CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[0].slot, CC1000RadioIntM$nbrInfo[0].frame);
  3014.                                                     CC1000RadioIntM$nbrInfo[1].nodeID = 17;
  3015.                                                     CC1000RadioIntM$nbrInfo[1].bitMap = TWO_HOP;
  3016.                                                     CC1000RadioIntM$nbrInfo[1].frame = 16;
  3017.                                                     CC1000RadioIntM$nbrInfo[1].slot = 4;
  3018.                                                     CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[1].slot, CC1000RadioIntM$nbrInfo[1].frame);
  3019.                                                     CC1000RadioIntM$nbrInfo[2].nodeID = 15;
  3020.                                                     CC1000RadioIntM$nbrInfo[2].bitMap = TWO_HOP;
  3021.                                                     CC1000RadioIntM$nbrInfo[2].frame = 16;
  3022.                                                     CC1000RadioIntM$nbrInfo[2].slot = 6;
  3023.                                                     CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[2].slot, CC1000RadioIntM$nbrInfo[2].frame);
  3024.                                                     CC1000RadioIntM$nbrInfo[3].nodeID = 32;
  3025.                                                     CC1000RadioIntM$nbrInfo[3].bitMap = TWO_HOP;
  3026.                                                     CC1000RadioIntM$nbrInfo[3].frame = 16;
  3027.                                                     CC1000RadioIntM$nbrInfo[3].slot = 2;
  3028.                                                     CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[3].slot, CC1000RadioIntM$nbrInfo[3].frame);
  3029.                                                     CC1000RadioIntM$nbrInfo[4].nodeID = 0;
  3030.                                                     CC1000RadioIntM$nbrInfo[4].bitMap = TWO_HOP;
  3031.                                                     CC1000RadioIntM$nbrInfo[4].frame = 16;
  3032.                                                     CC1000RadioIntM$nbrInfo[4].slot = 9;
  3033.                                                     CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[4].slot, CC1000RadioIntM$nbrInfo[4].frame);
  3034.                                                   }
  3035.                                                 else {
  3036. #line 763
  3037.                                                   if (TOS_LOCAL_ADDRESS == 14) {
  3038.                                                       CC1000RadioIntM$ownSlot = 10;
  3039.                                                       CC1000RadioIntM$localFrameLength = 16;
  3040.                                                       CC1000RadioIntM$nbrInfo[0].nodeID = 15;
  3041.                                                       CC1000RadioIntM$nbrInfo[0].bitMap = TWO_HOP;
  3042.                                                       CC1000RadioIntM$nbrInfo[0].frame = 16;
  3043.                                                       CC1000RadioIntM$nbrInfo[0].slot = 6;
  3044.                                                       CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[0].slot, CC1000RadioIntM$nbrInfo[0].frame);
  3045.                                                       CC1000RadioIntM$nbrInfo[1].nodeID = 32;
  3046.                                                       CC1000RadioIntM$nbrInfo[1].bitMap = TWO_HOP;
  3047.                                                       CC1000RadioIntM$nbrInfo[1].frame = 16;
  3048.                                                       CC1000RadioIntM$nbrInfo[1].slot = 2;
  3049.                                                       CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[1].slot, CC1000RadioIntM$nbrInfo[1].frame);
  3050.                                                       CC1000RadioIntM$nbrInfo[2].nodeID = 0;
  3051.                                                       CC1000RadioIntM$nbrInfo[2].bitMap = TWO_HOP;
  3052.                                                       CC1000RadioIntM$nbrInfo[2].frame = 16;
  3053.                                                       CC1000RadioIntM$nbrInfo[2].slot = 9;
  3054.                                                       CC1000RadioIntM$Blacklist(CC1000RadioIntM$nbrInfo[2].slot, CC1000RadioIntM$nbrInfo[2].frame);
  3055.                                                     }
  3056.                                                   }
  3057.                                                 }
  3058.                                               }
  3059.                                             }
  3060.                                           }
  3061.                                         }
  3062.                                       }
  3063.                                     }
  3064.                                   }
  3065.                                 }
  3066.                               }
  3067.                             }
  3068.                           }
  3069.                         }
  3070.                       }
  3071.                     }
  3072.                   }
  3073.                 }
  3074.               }
  3075.             }
  3076.           }
  3077.         }
  3078.       }
  3079.     }
  3080. # 630 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  3081.   CC1000RadioIntM$localFrameSize = CC1000RadioIntM$localFrameLength * CC1000RadioIntM$slotSize;
  3082.   CC1000RadioIntM$globalFrameSize = CC1000RadioIntM$globalFrameLength * CC1000RadioIntM$slotSize;
  3083.   CC1000RadioIntM$slotMultiplier = (uint16_t )(CC1000RadioIntM$slotSize * 1.024);
  3085.   CC1000RadioIntM$SClock$getTime(&loctime);
  3086.   globalTimeStamp = (uint32_t )(loctime.mticks * 568.889 + loctime.sticks * 0.00868056);
  3087.   slotOffset = (uint32_t )(1.024 * (CC1000RadioIntM$slotSize - globalTimeStamp % CC1000RadioIntM$slotSize));
  3088.   CC1000RadioIntM$slotNum = (uint32_t )(globalTimeStamp / CC1000RadioIntM$slotSize);
  3089.   CC1000RadioIntM$currentSlot = CC1000RadioIntM$slotNum & (CC1000RadioIntM$localFrameLength - 1);
  3090.   CC1000RadioIntM$globalSlot = CC1000RadioIntM$slotNum & (CC1000RadioIntM$globalFrameLength - 1);
  3092.   CC1000RadioIntM$TDMATimer$start(TIMER_ONE_SHOT, slotOffset);
  3096.   return SUCCESS;
  3097. }
  3099. static 
  3100. #line 409
  3101. void CC1000RadioIntM$Blacklist(uint8_t slot, uint8_t fsize)
  3102. #line 409
  3103. {
  3104.   uint8_t black_slot;
  3106. #line 411
  3107.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3108. #line 411
  3109.     {
  3110.       if (fsize <= CC1000RadioIntM$globalFrameLength) {
  3111.           black_slot = slot;
  3112.           while (black_slot < CC1000RadioIntM$globalFrameLength) {
  3113.               uint32_t tempHCL2 = 0x1;
  3115. #line 416
  3116.               tempHCL2 = tempHCL2 << black_slot;
  3117.               CC1000RadioIntM$curHCLlist = CC1000RadioIntM$curHCLlist | tempHCL2;
  3118.               black_slot = black_slot + fsize;
  3119.             }
  3120.         }
  3121.     }
  3122. #line 421
  3123.     __nesc_atomic_end(__nesc_atomic); }
  3124. }
  3126. static   
  3127. # 95 "../../tos/platform/mica2/HPLSClock.nc"
  3128. void HPLSClock$SClock$getTime(GTime *t)
  3129. #line 95
  3130. {
  3131.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3132. #line 96
  3133.     {
  3134.       t->sticks = * (volatile uint16_t *)0x88;
  3135.       if (* (volatile uint8_t *)(uint16_t )& * (volatile uint8_t *)0x7C & (1 << 4)) {
  3136.           HPLSClock$MTicks++;
  3137.           * (volatile uint8_t *)0x7C |= 1 << 4;
  3138.           HPLSClock$SClock$fire(HPLSClock$MTicks);
  3139.         }
  3140.       t->mticks = HPLSClock$MTicks;
  3141.     }
  3142. #line 104
  3143.     __nesc_atomic_end(__nesc_atomic); }
  3144. }
  3146. static 
  3147. # 52 "../../tos/interfaces/SODebug.h"
  3148. int MultiHopTtestM$sprintf(uint8_t *buf, const uint8_t *format, ...)
  3150. {
  3151.   uint8_t scratch[64];
  3152.   uint8_t format_flag;
  3153.   uint16_t u_val = 0;
  3154. #line 57
  3155.   uint16_t base;
  3156.   uint8_t *ptr;
  3157.   MultiHopTtestM$va_list ap;
  3158.   bool b_ChkForNegInt = FALSE;
  3160.   __builtin_va_start(ap, format);
  3161.   for (; ; ) {
  3162.       while ((format_flag = * format++) != '%') {
  3163.           if (!format_flag) {
  3164. #line 65
  3165.               __builtin_va_end(ap);
  3166. #line 65
  3167.               return 0;
  3168.             }
  3169. #line 66
  3170.           *buf = format_flag;
  3171. #line 66
  3172.           buf++;
  3173. #line 66
  3174.           *buf = 0;
  3175.         }
  3176.       b_ChkForNegInt = FALSE;
  3177.       switch ((format_flag = * format++)) {
  3179.           case 'c': 
  3180.             format_flag = (__builtin_va_arg(ap, int ));
  3181.           default: 
  3182.             *buf = format_flag;
  3183. #line 74
  3184.           buf++;
  3185. #line 74
  3186.           *buf = 0;
  3187.           continue;
  3188.           case 'S': 
  3189.             case 's': 
  3190.               ptr = (__builtin_va_arg(ap, char *));
  3191.           strcat(buf, ptr);
  3192.           continue;
  3193.           case 'o': 
  3194.             base = 8;
  3195.           *buf = '0';
  3196. #line 83
  3197.           buf++;
  3198. #line 83
  3199.           *buf = 0;
  3200.           goto CONVERSION_LOOP;
  3201.           case 'i': 
  3202.             b_ChkForNegInt = TRUE;
  3208.           case 'u': 
  3209.             base = 10;
  3210.           goto CONVERSION_LOOP;
  3211.           case 'x': 
  3212.             base = 16;
  3214.           CONVERSION_LOOP: 
  3215.             u_val = (__builtin_va_arg(ap, int ));
  3216.           if (b_ChkForNegInt) {
  3217.               if ((int )u_val < 0) {
  3218.                   u_val = -u_val;
  3219.                   *buf = '-';
  3220. #line 103
  3221.                   buf++;
  3222. #line 103
  3223.                   *buf = 0;
  3224.                 }
  3225.             }
  3227.           ptr = scratch + 64;
  3228.           * --ptr = 0;
  3229.           do {
  3230.               char ch = u_val % base + '0';
  3232. #line 111
  3233.               if (ch > '9') {
  3234.                 ch += 'a' - '9' - 1;
  3235.                 }
  3236. #line 113
  3237.               * --ptr = ch;
  3238.               u_val /= base;
  3239.             }
  3240.           while (
  3241. #line 115
  3242.           u_val);
  3243.           strcat(buf, ptr);
  3244.           buf += strlen(ptr);
  3245.         }
  3246.     }
  3247. }
  3249. static 
  3250. #line 42
  3251. void MultiHopTtestM$writedebug(void)
  3252. #line 42
  3253. {
  3254.   int i = 0;
  3256. #line 44
  3257.   MultiHopTtestM$UARTPutChar('n');
  3258.   while (MultiHopTtestM$debugbuf[i] != 'n') 
  3259.     MultiHopTtestM$UARTPutChar(MultiHopTtestM$debugbuf[i++]);
  3260. }
  3262. static 
  3263. #line 35
  3264. void MultiHopTtestM$UARTPutChar(char c)
  3265. #line 35
  3266. {
  3267.   if (c == 'n') {
  3268.     MultiHopTtestM$UARTPutChar('r');
  3269.     }
  3270. #line 38
  3271.   do {
  3272.     }
  3273.   while (
  3274. #line 38
  3275.   !(* (volatile uint8_t *)(uint16_t )& * (volatile uint8_t *)(0x0B + 0x20) & (1 << 5)));
  3276.   * (volatile uint8_t *)(0x0C + 0x20) = c;
  3277. }
  3279. static   
  3280. # 1166 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  3281. result_t CC1000RadioIntM$SpiByteFifo$dataReady(uint8_t data_in)
  3282. #line 1166
  3283. {
  3284.   GTime loctime;
  3286. #line 1168
  3287.   CC1000RadioIntM$RadioSendCoordinator$blockTimer();
  3288.   CC1000RadioIntM$RadioReceiveCoordinator$blockTimer();
  3290.   if (CC1000RadioIntM$bInvertRxData) {
  3291.     data_in = ~data_in;
  3292.     }
  3295.   switch (CC1000RadioIntM$RadioState) {
  3297.       case CC1000RadioIntM$TX_STATE: 
  3298.         {
  3299.           CC1000RadioIntM$SpiByteFifo$writeByte(CC1000RadioIntM$NextTxByte);
  3300.           CC1000RadioIntM$TxByteCnt++;
  3301.           switch (CC1000RadioIntM$RadioTxState) {
  3303.               case CC1000RadioIntM$TXSTATE_PREAMBLE: 
  3304.                 CC1000RadioIntM$send_sum++;
  3305.               if (!(CC1000RadioIntM$TxByteCnt < CC1000RadioIntM$preamblelen) || (
  3306.               CC1000RadioIntM$txbufptr->strength == 0xffff && CC1000RadioIntM$TxByteCnt >= CC1000RadioIntM$PREAMBLE_LENGTH_TO_BASE)) {
  3307.                   CC1000RadioIntM$NextTxByte = CC1000RadioIntM$SYNC_BYTE;
  3308.                   CC1000RadioIntM$RadioTxState = CC1000RadioIntM$TXSTATE_SYNC;
  3309.                 }
  3314.               break;
  3316.               case CC1000RadioIntM$TXSTATE_SYNC: 
  3317.                 CC1000RadioIntM$send_sum++;
  3318.               CC1000RadioIntM$NextTxByte = CC1000RadioIntM$NSYNC_BYTE;
  3319.               CC1000RadioIntM$RadioTxState = CC1000RadioIntM$TXSTATE_DATA;
  3320.               CC1000RadioIntM$TxByteCnt = -1;
  3321.               if (CC1000RadioIntM$txbufptr->type == 223) {
  3322.                   syncMsgType *syncMsgPtr = (syncMsgType *)CC1000RadioIntM$txbufptr->data;
  3324. #line 1204
  3325.                   CC1000RadioIntM$SClock$getTime(&loctime);
  3326.                   syncMsgPtr->mticks = loctime.mticks;
  3327.                   syncMsgPtr->sticks = loctime.sticks;
  3328.                   syncMsgPtr->trust = 1;
  3329.                   syncMsgPtr->sender = TOS_LOCAL_ADDRESS;
  3330.                 }
  3332.               CC1000RadioIntM$RadioSendCoordinator$startSymbol(8, 0, CC1000RadioIntM$txbufptr);
  3333.               break;
  3335.               case CC1000RadioIntM$TXSTATE_DATA: 
  3336.                 CC1000RadioIntM$send_sum++;
  3337.               if ((uint8_t )CC1000RadioIntM$TxByteCnt < CC1000RadioIntM$txlength) {
  3338.                   if (CC1000RadioIntM$txbufptr->type == 223 && CC1000RadioIntM$TxByteCnt == 5) {
  3339.                       syncMsgType *syncMsgPtr = (syncMsgType *)CC1000RadioIntM$txbufptr->data;
  3341. #line 1219
  3342.                       CC1000RadioIntM$SClock$getTime(&loctime);
  3343.                       CC1000RadioIntM$AddTime(&loctime, &loctime, &CC1000RadioIntM$constOffset);
  3344.                       syncMsgPtr->mticks = loctime.mticks;
  3345.                       syncMsgPtr->sticks = loctime.sticks;
  3346.                     }
  3347.                   CC1000RadioIntM$NextTxByte = ((uint8_t *)CC1000RadioIntM$txbufptr)[CC1000RadioIntM$TxByteCnt];
  3348.                   CC1000RadioIntM$usRunningCRC = crcByte(CC1000RadioIntM$usRunningCRC, CC1000RadioIntM$NextTxByte);
  3349.                   CC1000RadioIntM$RadioSendCoordinator$byte(CC1000RadioIntM$txbufptr, (uint8_t )CC1000RadioIntM$TxByteCnt);
  3350.                 }
  3351.               else {
  3352.                   CC1000RadioIntM$NextTxByte = (uint8_t )CC1000RadioIntM$usRunningCRC;
  3353.                   CC1000RadioIntM$RadioTxState = CC1000RadioIntM$TXSTATE_CRC;
  3354.                 }
  3355.               break;
  3357.               case CC1000RadioIntM$TXSTATE_CRC: 
  3358.                 CC1000RadioIntM$send_sum++;
  3359.               CC1000RadioIntM$NextTxByte = (uint8_t )(CC1000RadioIntM$usRunningCRC >> 8);
  3360.               CC1000RadioIntM$RadioTxState = CC1000RadioIntM$TXSTATE_FLUSH;
  3361.               CC1000RadioIntM$TxByteCnt = 0;
  3362.               break;
  3364.               case CC1000RadioIntM$TXSTATE_FLUSH: 
  3365.                 CC1000RadioIntM$send_sum++;
  3366.               if (CC1000RadioIntM$TxByteCnt > 3) {
  3367.                   CC1000RadioIntM$TxByteCnt = 0;
  3371.                   if (CC1000RadioIntM$bAckEnable) {
  3372.                     CC1000RadioIntM$RadioTxState = CC1000RadioIntM$TXSTATE_WAIT_FOR_ACK;
  3373.                     }
  3374.                   else 
  3375. #line 1250
  3376.                     {
  3380.                       CC1000RadioIntM$packetsSent++;
  3381.                       CC1000RadioIntM$SpiByteFifo$rxMode();
  3382.                       CC1000RadioIntM$CC1000Control$RxMode();
  3383.                       CC1000RadioIntM$RadioTxState = CC1000RadioIntM$TXSTATE_DONE;
  3384.                     }
  3385.                 }
  3386.               break;
  3388.               case CC1000RadioIntM$TXSTATE_WAIT_FOR_ACK: 
  3389.                 if (CC1000RadioIntM$TxByteCnt == 1) {
  3390.                     CC1000RadioIntM$send_sum++;
  3391.                     CC1000RadioIntM$SpiByteFifo$rxMode();
  3392.                     CC1000RadioIntM$CC1000Control$RxMode();
  3393.                     break;
  3394.                   }
  3395.               CC1000RadioIntM$receive_sum++;
  3396.               if (CC1000RadioIntM$TxByteCnt > 3) {
  3397.                   CC1000RadioIntM$RadioTxState = CC1000RadioIntM$TXSTATE_READ_ACK;
  3398.                   CC1000RadioIntM$TxByteCnt = 0;
  3399.                   CC1000RadioIntM$search_word = 0;
  3400.                 }
  3401.               break;
  3403.               case CC1000RadioIntM$TXSTATE_READ_ACK: 
  3404.                 {
  3405.                   uint8_t i;
  3407. #line 1280
  3408.                   CC1000RadioIntM$receive_sum++;
  3409.                   for (i = 0; i < 8; i++) {
  3410.                       CC1000RadioIntM$search_word <<= 1;
  3411.                       if (data_in & 0x80) {
  3412. #line 1283
  3413.                         CC1000RadioIntM$search_word |= 0x1;
  3414.                         }
  3415. #line 1284
  3416.                       data_in <<= 1;
  3417.                       if (CC1000RadioIntM$search_word == 0xba83) {
  3418.                           CC1000RadioIntM$txbufptr->ack = 1;
  3419.                           CC1000RadioIntM$RadioTxState = CC1000RadioIntM$TXSTATE_DONE;
  3423.                           return SUCCESS;
  3424.                         }
  3425.                     }
  3426.                 }
  3427.               if (CC1000RadioIntM$TxByteCnt >= CC1000RadioIntM$MAX_ACK_WAIT) {
  3428.                   CC1000RadioIntM$txbufptr->ack = 0;
  3432.                   CC1000RadioIntM$RadioTxState = CC1000RadioIntM$TXSTATE_DONE;
  3433.                 }
  3434.               break;
  3436.               case CC1000RadioIntM$TXSTATE_DONE: 
  3437.                 default: 
  3438.                   CC1000RadioIntM$bTxPending = FALSE;
  3439.               if (CC1000RadioIntM$txbufptr->type == 222 || CC1000RadioIntM$txbufptr->type == 223) {
  3445.                   CC1000RadioIntM$bAckEnable = CC1000RadioIntM$ackOrig;
  3446.                 }
  3451.               if (TOS_post(CC1000RadioIntM$PacketSent)) {
  3457.                   CC1000RadioIntM$RadioState = CC1000RadioIntM$IDLE_STATE;
  3458.                   CC1000RadioIntM$pktsLastSync++;
  3459.                   CC1000RadioIntM$RSSIInitState = CC1000RadioIntM$RadioState;
  3460.                   CC1000RadioIntM$RSSIADC$getData();
  3461.                 }
  3462.               break;
  3463.             }
  3464.         }
  3465.       break;
  3467.       case CC1000RadioIntM$DISABLED_STATE: 
  3468.         break;
  3470.       case CC1000RadioIntM$IDLE_STATE: 
  3471.         {
  3472.           CC1000RadioIntM$receive_sum++;
  3473.           if (data_in == 0xaa || data_in == 0x55) {
  3474.               CC1000RadioIntM$PreambleCount++;
  3475.               if (CC1000RadioIntM$PreambleCount > 2) {
  3476.                   CC1000RadioIntM$PreambleCount = CC1000RadioIntM$SOFCount = 0;
  3477.                   CC1000RadioIntM$RxBitOffset = CC1000RadioIntM$RxByteCnt = 0;
  3478.                   CC1000RadioIntM$usRunningCRC = 0;
  3479.                   CC1000RadioIntM$rxlength = MSG_DATA_SIZE - 2;
  3480.                   CC1000RadioIntM$RadioState = CC1000RadioIntM$SYNC_STATE;
  3481.                 }
  3482.             }
  3483.           else 
  3484. #line 1350
  3485.             {
  3486.               if ((CC1000RadioIntM$currentMAC == CC1000RadioIntM$BMAC || CC1000RadioIntM$enableHCL == FALSE) || !CC1000RadioIntM$IsHCL(CC1000RadioIntM$currentSlot)) {
  3487.                   if (CC1000RadioIntM$bTxPending && --CC1000RadioIntM$sMacDelay <= 0) {
  3488.                       CC1000RadioIntM$RadioState = CC1000RadioIntM$PRETX_STATE;
  3489.                       CC1000RadioIntM$RSSIInitState = CC1000RadioIntM$PRETX_STATE;
  3490.                       CC1000RadioIntM$bRSSIValid = FALSE;
  3491.                       CC1000RadioIntM$iRSSIcount = 0;
  3492.                       CC1000RadioIntM$PreambleCount = 0;
  3493.                       CC1000RadioIntM$RSSIADC$getData();
  3494.                     }
  3495.                 }
  3496.               else 
  3497. #line 1360
  3498.                 {
  3499.                 }
  3500.             }
  3501.         }
  3505.       break;
  3507.       case CC1000RadioIntM$PRETX_STATE: 
  3508.         {
  3509.           CC1000RadioIntM$receive_sum++;
  3510.           if (data_in == 0xaa || data_in == 0x55) {
  3512.               CC1000RadioIntM$sMacDelay = CC1000RadioIntM$MacBackoff$congestionBackoff(CC1000RadioIntM$txbufptr);
  3516.               CC1000RadioIntM$RadioState = CC1000RadioIntM$IDLE_STATE;
  3517.             }
  3518.         }
  3519.       break;
  3521.       case CC1000RadioIntM$SYNC_STATE: 
  3522.         {
  3530.           uint8_t i;
  3532.           CC1000RadioIntM$receive_sum++;
  3533.           if (data_in == 0xaa || data_in == 0x55) {
  3538.               CC1000RadioIntM$RxShiftBuf.MSB = data_in;
  3539.             }
  3540.           else {
  3542.               uint16_t usTmp;
  3544. #line 1405
  3545.               switch (CC1000RadioIntM$SOFCount) {
  3546.                   case 0: 
  3547.                     CC1000RadioIntM$RxShiftBuf.LSB = data_in;
  3548.                   break;
  3550.                   case 1: 
  3551.                     case 2: 
  3552.                       case 3: 
  3553.                         case 4: 
  3554.                           case 5: 
  3556.                             usTmp = CC1000RadioIntM$RxShiftBuf.W;
  3557.                   CC1000RadioIntM$RxShiftBuf.W <<= 8;
  3558.                   CC1000RadioIntM$RxShiftBuf.LSB = data_in;
  3560.                   for (i = 0; i < 8; i++) {
  3561.                       usTmp <<= 1;
  3562.                       if (data_in & 0x80) {
  3563.                         usTmp |= 0x1;
  3564.                         }
  3565. #line 1424
  3566.                       data_in <<= 1;
  3568.                       if (usTmp == CC1000RadioIntM$SYNC_WORD) {
  3569.                           if (CC1000RadioIntM$rxbufptr->length != 0) {
  3570.                               CC1000RadioIntM$Leds$redToggle();
  3571.                               CC1000RadioIntM$RadioState = CC1000RadioIntM$IDLE_STATE;
  3572.                             }
  3573.                           else {
  3574.                               CC1000RadioIntM$RadioState = CC1000RadioIntM$RX_STATE;
  3575.                               CC1000RadioIntM$RSSIInitState = CC1000RadioIntM$RX_STATE;
  3576.                               CC1000RadioIntM$RSSIADC$getData();
  3577.                               CC1000RadioIntM$RxBitOffset = 7 - i;
  3579.                               CC1000RadioIntM$RadioReceiveCoordinator$startSymbol(8, CC1000RadioIntM$RxBitOffset, CC1000RadioIntM$rxbufptr);
  3580.                             }
  3581.                           break;
  3582.                         }
  3583.                     }
  3584.                   break;
  3586.                   default: 
  3588.                     CC1000RadioIntM$RadioState = CC1000RadioIntM$IDLE_STATE;
  3589.                   break;
  3590.                 }
  3591.               CC1000RadioIntM$SOFCount++;
  3592.             }
  3593.         }
  3594.       break;
  3601.       case CC1000RadioIntM$RX_STATE: 
  3602.         {
  3603.           char Byte;
  3605. #line 1462
  3606.           CC1000RadioIntM$receive_sum++;
  3608.           CC1000RadioIntM$RxShiftBuf.W <<= 8;
  3609.           CC1000RadioIntM$RxShiftBuf.LSB = data_in;
  3611.           Byte = CC1000RadioIntM$RxShiftBuf.W >> CC1000RadioIntM$RxBitOffset;
  3612.           ((char *)CC1000RadioIntM$rxbufptr)[(int )CC1000RadioIntM$RxByteCnt] = Byte;
  3613.           CC1000RadioIntM$RxByteCnt++;
  3615.           CC1000RadioIntM$RadioReceiveCoordinator$byte(CC1000RadioIntM$rxbufptr, (uint8_t )CC1000RadioIntM$RxByteCnt);
  3617.           if (CC1000RadioIntM$RxByteCnt < CC1000RadioIntM$rxlength) {
  3618.               CC1000RadioIntM$usRunningCRC = crcByte(CC1000RadioIntM$usRunningCRC, Byte);
  3620.               if (CC1000RadioIntM$RxByteCnt == (size_t )& ((struct TOS_Msg *)0)->length + 
  3621.               sizeof  ((struct TOS_Msg *)0)->length) {
  3622.                   CC1000RadioIntM$rxlength = CC1000RadioIntM$rxbufptr->length;
  3623.                   if (CC1000RadioIntM$rxlength > 70) {
  3625.                       CC1000RadioIntM$rxbufptr->length = 0;
  3626.                       CC1000RadioIntM$RadioState = CC1000RadioIntM$IDLE_STATE;
  3627.                       return SUCCESS;
  3628.                     }
  3630.                   CC1000RadioIntM$rxlength += (size_t )& ((struct TOS_Msg *)0)->data;
  3631.                 }
  3632.             }
  3633.           else {
  3634. #line 1489
  3635.             if (CC1000RadioIntM$RxByteCnt == CC1000RadioIntM$rxlength) {
  3636.                 if (CC1000RadioIntM$rxbufptr->type == 223) {
  3637.                   CC1000RadioIntM$getTimeDiff();
  3638.                   }
  3639. #line 1492
  3640.                 CC1000RadioIntM$usRunningCRC = crcByte(CC1000RadioIntM$usRunningCRC, Byte);
  3642.                 CC1000RadioIntM$RxByteCnt = (size_t )& ((struct TOS_Msg *)0)->crc;
  3643.               }
  3644.             else {
  3645. #line 1496
  3646.               if (CC1000RadioIntM$RxByteCnt >= MSG_DATA_SIZE) {
  3650.                   if (CC1000RadioIntM$rxbufptr->crc == CC1000RadioIntM$usRunningCRC) {
  3651.                       if (CC1000RadioIntM$rxbufptr->type == 223) {
  3652.                         TOS_post(CC1000RadioIntM$adjustTime);
  3653.                         }
  3654. #line 1503
  3655.                       CC1000RadioIntM$rxbufptr->crc = 1;
  3657.                       if (CC1000RadioIntM$bAckEnable && CC1000RadioIntM$rxbufptr->addr == TOS_LOCAL_ADDRESS) {
  3659.                           CC1000RadioIntM$RadioState = CC1000RadioIntM$SENDING_ACK;
  3660.                           CC1000RadioIntM$CC1000Control$TxMode();
  3661.                           CC1000RadioIntM$SpiByteFifo$txMode();
  3662.                           CC1000RadioIntM$SpiByteFifo$writeByte(0xaa);
  3663.                           CC1000RadioIntM$RxByteCnt = 0;
  3664.                           return SUCCESS;
  3665.                         }
  3666.                     }
  3667.                   else {
  3668.                       CC1000RadioIntM$rxbufptr->crc = 0;
  3669.                     }
  3671.                   CC1000RadioIntM$SpiByteFifo$disableIntr();
  3673.                   CC1000RadioIntM$RadioState = CC1000RadioIntM$IDLE_STATE;
  3674.                   if (CC1000RadioIntM$currentMAC == CC1000RadioIntM$ZMAC && CC1000RadioIntM$bTxPending) {
  3675.                       CC1000RadioIntM$sMacDelay = CC1000RadioIntM$getZMACBackoff(CC1000RadioIntM$sMacDelay);
  3676.                     }
  3681.                   CC1000RadioIntM$rxbufptr->strength = CC1000RadioIntM$usRSSIVal;
  3682.                   if (!TOS_post(CC1000RadioIntM$PacketRcvd)) {
  3685.                       CC1000RadioIntM$rxbufptr->length = 0;
  3686.                       CC1000RadioIntM$RadioState = CC1000RadioIntM$IDLE_STATE;
  3687.                       CC1000RadioIntM$SpiByteFifo$enableIntr();
  3688.                     }
  3689.                   CC1000RadioIntM$RSSIInitState = CC1000RadioIntM$RadioState;
  3690.                   CC1000RadioIntM$RSSIADC$getData();
  3691.                 }
  3692.               }
  3693.             }
  3694.         }
  3695. #line 1541
  3696.       break;
  3698.       case CC1000RadioIntM$SENDING_ACK: 
  3699.         {
  3700.           CC1000RadioIntM$send_sum++;
  3701.           CC1000RadioIntM$RxByteCnt++;
  3702.           if (CC1000RadioIntM$RxByteCnt >= CC1000RadioIntM$ACK_LENGTH) {
  3703.               CC1000RadioIntM$CC1000Control$RxMode();
  3704.               CC1000RadioIntM$SpiByteFifo$rxMode();
  3705.               CC1000RadioIntM$SpiByteFifo$disableIntr();
  3706.               CC1000RadioIntM$RadioState = CC1000RadioIntM$IDLE_STATE;
  3707.               CC1000RadioIntM$rxbufptr->strength = CC1000RadioIntM$usRSSIVal;
  3708.               if (!TOS_post(CC1000RadioIntM$PacketRcvd)) {
  3709.                   CC1000RadioIntM$rxbufptr->length = 0;
  3710.                   CC1000RadioIntM$RadioState = CC1000RadioIntM$IDLE_STATE;
  3711.                   CC1000RadioIntM$SpiByteFifo$enableIntr();
  3712.                 }
  3713.             }
  3714.           else {
  3715. #line 1558
  3716.             if (CC1000RadioIntM$RxByteCnt >= CC1000RadioIntM$ACK_LENGTH - sizeof CC1000RadioIntM$ack_code) {
  3717.                 CC1000RadioIntM$SpiByteFifo$writeByte(CC1000RadioIntM$ack_code[CC1000RadioIntM$RxByteCnt + sizeof CC1000RadioIntM$ack_code - CC1000RadioIntM$ACK_LENGTH]);
  3718.               }
  3719.             }
  3720.         }
  3721. #line 1562
  3722.       break;
  3724.       default: 
  3725.         break;
  3726.     }
  3728.   if (CC1000RadioIntM$pulse_check_sum > CC1000RadioIntM$CHECK_MA_COUNT) {
  3729.       CC1000RadioIntM$power_sum++;
  3730.       CC1000RadioIntM$sp_sum++;
  3731.       CC1000RadioIntM$pulse_check_sum -= CC1000RadioIntM$CHECK_MA_COUNT;
  3732.     }
  3733.   if (CC1000RadioIntM$send_sum > CC1000RadioIntM$SEND_MA_COUNT) {
  3734.       CC1000RadioIntM$power_sum++;
  3735.       CC1000RadioIntM$tx_sum++;
  3736.       CC1000RadioIntM$send_sum -= CC1000RadioIntM$SEND_MA_COUNT;
  3737.     }
  3738.   if (CC1000RadioIntM$receive_sum > CC1000RadioIntM$RECEIVE_MA_COUNT) {
  3739.       CC1000RadioIntM$power_sum++;
  3740.       CC1000RadioIntM$rx_sum++;
  3741.       CC1000RadioIntM$receive_sum -= CC1000RadioIntM$RECEIVE_MA_COUNT;
  3742.     }
  3743.   return SUCCESS;
  3744. }
  3746. static 
  3747. #line 275
  3748. void CC1000RadioIntM$SubTime(GTime *C, GTime *A, GTime *B)
  3749. #line 275
  3750. {
  3751.   if (B->sticks > A->sticks) {
  3752.       C->sticks = CC1000RadioIntM$MAX_VAL - (B->sticks - A->sticks);
  3753.       C->mticks = A->mticks - (B->mticks + 1);
  3754.     }
  3755.   else {
  3756.       C->sticks = A->sticks - B->sticks;
  3757.       C->mticks = A->mticks - B->mticks;
  3758.     }
  3759. }
  3761. static  
  3762. #line 432
  3763. void CC1000RadioIntM$PacketRcvd(void)
  3764. #line 432
  3765. {
  3766.   TOS_MsgPtr pBuf;
  3767.   ecnForwardMsgType *recvEcnMsgPtr;
  3768.   ecnForwardMsgType *ecnForwardMsgPtr;
  3770. #line 436
  3771.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3772. #line 436
  3773.     {
  3774.       if (CC1000RadioIntM$pktsLastSync > 100) {
  3775.           {
  3776.             CC1000RadioIntM$ackOrig = CC1000RadioIntM$bAckEnable;
  3777.             CC1000RadioIntM$bAckEnable = FALSE;
  3778.           }
  3779.           CC1000RadioIntM$Send$send(&CC1000RadioIntM$syncMsgHdr);
  3780.           CC1000RadioIntM$pktsLastSync = 0;
  3781.         }
  3783.       CC1000RadioIntM$pktsLastSync++;
  3784.       CC1000RadioIntM$rxbufptr->time = 0;
  3785.       pBuf = CC1000RadioIntM$rxbufptr;
  3786.       recvEcnMsgPtr = (ecnForwardMsgType *)CC1000RadioIntM$rxbufptr->data;
  3787.       ecnForwardMsgPtr = (ecnForwardMsgType *)CC1000RadioIntM$ecnForwardMsgHdr.data;
  3796.       if (CC1000RadioIntM$currentMAC == CC1000RadioIntM$ZMAC && CC1000RadioIntM$HCLselect && pBuf->type == 222 && pBuf->crc != 0 && 
  3797.       recvEcnMsgPtr->senderAddress != TOS_LOCAL_ADDRESS) {
  3798.           if (recvEcnMsgPtr->hopCount == 0 && recvEcnMsgPtr->nextHop == TOS_LOCAL_ADDRESS) {
  3802.               ecnForwardMsgPtr->hopCount = 1;
  3803.               ecnForwardMsgPtr->nextHop = CC1000RadioIntM$nextHop;
  3804.               ecnForwardMsgPtr->senderAddress = TOS_LOCAL_ADDRESS;
  3805.               if (!CC1000RadioIntM$bTxBusy) {
  3806.                   CC1000RadioIntM$ackOrig = CC1000RadioIntM$bAckEnable;
  3807.                   CC1000RadioIntM$bAckEnable = FALSE;
  3808.                   CC1000RadioIntM$Send$send(&CC1000RadioIntM$ecnForwardMsgHdr);
  3809.                 }
  3810.               else {
  3813.                 CC1000RadioIntM$ecnforward = TRUE;
  3814.                 }
  3815.             }
  3816.           else {
  3817. #line 477
  3818.             if (recvEcnMsgPtr->hopCount == 1) {
  3822.                 CC1000RadioIntM$enableHCL = TRUE;
  3823.                 if (recvEcnMsgPtr->senderAddress == CC1000RadioIntM$nextHop) {
  3828.                     CC1000RadioIntM$ecnPending = FALSE;
  3829.                     CC1000RadioIntM$slots_since_ecnsend = 0;
  3830.                     CC1000RadioIntM$slots_since_ecnrecv = 0;
  3831.                   }
  3832.               }
  3833.             }
  3834.         }
  3835.       else {
  3836. #line 492
  3837.         if (pBuf->type != 223 && pBuf->type != 222) {
  3841.             pBuf = CC1000RadioIntM$Receive$receive((TOS_MsgPtr )pBuf);
  3842.           }
  3843.         }
  3844.       if (pBuf) {
  3845.         CC1000RadioIntM$rxbufptr = pBuf;
  3846.         }
  3847. #line 501
  3848.       CC1000RadioIntM$rxbufptr->length = 0;
  3849.     }
  3850. #line 502
  3851.     __nesc_atomic_end(__nesc_atomic); }
  3852.   CC1000RadioIntM$SpiByteFifo$enableIntr();
  3853. }
  3855. # 124 "../../tos/platform/mica2/HPLSClock.nc"
  3856. void __attribute((interrupt))   __vector_26(void)
  3857. #line 124
  3858. {
  3859.   if (HPLSClock$needupdate) {
  3860.       if (HPLSClock$sign == NEGATIVE) {
  3861.           * (volatile uint16_t *)0x88 = MAX_VAL - HPLSClock$Update.sticks;
  3862.           HPLSClock$MTicks = HPLSClock$MTicks - HPLSClock$Update.mticks;
  3863.         }
  3864.       else {
  3865. #line 130
  3866.         if (HPLSClock$sign == POSITIVE) {
  3867.             * (volatile uint16_t *)0x88 = HPLSClock$Update.sticks;
  3868.             HPLSClock$MTicks = HPLSClock$MTicks + HPLSClock$Update.mticks + 1;
  3869.             HPLSClock$SClock$fire(HPLSClock$MTicks);
  3870.           }
  3871.         }
  3872. #line 135
  3873.       HPLSClock$needupdate = 0;
  3874.       HPLSClock$SClock$syncDone();
  3875.     }
  3876.   else {
  3877.       HPLSClock$MTicks++;
  3878.       HPLSClock$SClock$fire(HPLSClock$MTicks);
  3879.     }
  3880. }
  3882. static   
  3883. # 348 "/home/testuser/tinyos-1.x/tos/system/FramerM.nc"
  3884. result_t FramerM$ByteComm$rxByteReady(uint8_t data, bool error, uint16_t strength)
  3885. #line 348
  3886. {
  3888.   switch (FramerM$gRxState) {
  3890.       case FramerM$RXSTATE_NOSYNC: 
  3891.         if (data == FramerM$HDLC_FLAG_BYTE && FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Length == 0) {
  3892.             FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Token = 0;
  3893.             FramerM$gRxByteCnt = FramerM$gRxRunningCRC = 0;
  3894.             FramerM$gpRxBuf = (uint8_t *)FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].pMsg;
  3895.             FramerM$gRxState = FramerM$RXSTATE_PROTO;
  3896.           }
  3897.       break;
  3899.       case FramerM$RXSTATE_PROTO: 
  3900.         if (data == FramerM$HDLC_FLAG_BYTE) {
  3901.             break;
  3902.           }
  3903.       FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Proto = data;
  3904.       FramerM$gRxRunningCRC = crcByte(FramerM$gRxRunningCRC, data);
  3905.       switch (data) {
  3906.           case FramerM$PROTO_PACKET_ACK: 
  3907.             FramerM$gRxState = FramerM$RXSTATE_TOKEN;
  3908.           break;
  3909.           case FramerM$PROTO_PACKET_NOACK: 
  3910.             FramerM$gRxState = FramerM$RXSTATE_INFO;
  3911.           break;
  3912.           default: 
  3913.             FramerM$gRxState = FramerM$RXSTATE_NOSYNC;
  3914.           break;
  3915.         }
  3916.       break;
  3918.       case FramerM$RXSTATE_TOKEN: 
  3919.         if (data == FramerM$HDLC_FLAG_BYTE) {
  3920.             FramerM$gRxState = FramerM$RXSTATE_NOSYNC;
  3921.           }
  3922.         else {
  3923. #line 384
  3924.           if (data == FramerM$HDLC_CTLESC_BYTE) {
  3925.               FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Token = 0x20;
  3926.             }
  3927.           else {
  3928.               FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Token ^= data;
  3929.               FramerM$gRxRunningCRC = crcByte(FramerM$gRxRunningCRC, FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Token);
  3930.               FramerM$gRxState = FramerM$RXSTATE_INFO;
  3931.             }
  3932.           }
  3933. #line 392
  3934.       break;
  3937.       case FramerM$RXSTATE_INFO: 
  3938.         if (FramerM$gRxByteCnt > FramerM$HDLC_MTU) {
  3939.             FramerM$gRxByteCnt = FramerM$gRxRunningCRC = 0;
  3940.             FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Length = 0;
  3941.             FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Token = 0;
  3942.             FramerM$gRxState = FramerM$RXSTATE_NOSYNC;
  3943.           }
  3944.         else {
  3945. #line 402
  3946.           if (data == FramerM$HDLC_CTLESC_BYTE) {
  3947.               FramerM$gRxState = FramerM$RXSTATE_ESC;
  3948.             }
  3949.           else {
  3950. #line 405
  3951.             if (data == FramerM$HDLC_FLAG_BYTE) {
  3952.                 if (FramerM$gRxByteCnt >= 2) {
  3953.                     uint16_t usRcvdCRC = FramerM$gpRxBuf[FramerM$gRxByteCnt - 1] & 0xff;
  3955. #line 408
  3956.                     usRcvdCRC = (usRcvdCRC << 8) | (FramerM$gpRxBuf[FramerM$gRxByteCnt - 2] & 0xff);
  3957.                     if (usRcvdCRC == FramerM$gRxRunningCRC) {
  3958.                         FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Length = FramerM$gRxByteCnt - 2;
  3959.                         TOS_post(FramerM$PacketRcvd);
  3960.                         FramerM$gRxHeadIndex++;
  3961. #line 412
  3962.                         FramerM$gRxHeadIndex %= FramerM$HDLC_QUEUESIZE;
  3963.                       }
  3964.                     else {
  3965.                         FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Length = 0;
  3966.                         FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Token = 0;
  3967.                       }
  3968.                     if (FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Length == 0) {
  3969.                         FramerM$gpRxBuf = (uint8_t *)FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].pMsg;
  3970.                         FramerM$gRxState = FramerM$RXSTATE_PROTO;
  3971.                       }
  3972.                     else {
  3973.                         FramerM$gRxState = FramerM$RXSTATE_NOSYNC;
  3974.                       }
  3975.                   }
  3976.                 else {
  3977.                     FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Length = 0;
  3978.                     FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Token = 0;
  3979.                     FramerM$gRxState = FramerM$RXSTATE_NOSYNC;
  3980.                   }
  3981.                 FramerM$gRxByteCnt = FramerM$gRxRunningCRC = 0;
  3982.               }
  3983.             else {
  3984.                 FramerM$gpRxBuf[FramerM$gRxByteCnt] = data;
  3985.                 if (FramerM$gRxByteCnt >= 2) {
  3986.                     FramerM$gRxRunningCRC = crcByte(FramerM$gRxRunningCRC, FramerM$gpRxBuf[FramerM$gRxByteCnt - 2]);
  3987.                   }
  3988.                 FramerM$gRxByteCnt++;
  3989.               }
  3990.             }
  3991.           }
  3992. #line 440
  3993.       break;
  3995.       case FramerM$RXSTATE_ESC: 
  3996.         if (data == FramerM$HDLC_FLAG_BYTE) {
  3998.             FramerM$gRxByteCnt = FramerM$gRxRunningCRC = 0;
  3999.             FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Length = 0;
  4000.             FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Token = 0;
  4001.             FramerM$gRxState = FramerM$RXSTATE_NOSYNC;
  4002.           }
  4003.         else {
  4004.             data = data ^ 0x20;
  4005.             FramerM$gpRxBuf[FramerM$gRxByteCnt] = data;
  4006.             if (FramerM$gRxByteCnt >= 2) {
  4007.                 FramerM$gRxRunningCRC = crcByte(FramerM$gRxRunningCRC, FramerM$gpRxBuf[FramerM$gRxByteCnt - 2]);
  4008.               }
  4009.             FramerM$gRxByteCnt++;
  4010.             FramerM$gRxState = FramerM$RXSTATE_INFO;
  4011.           }
  4012.       break;
  4014.       default: 
  4015.         FramerM$gRxState = FramerM$RXSTATE_NOSYNC;
  4016.       break;
  4017.     }
  4019.   return SUCCESS;
  4020. }
  4022. static   
  4023. # 87 "/home/testuser/tinyos-1.x/tos/system/UARTM.nc"
  4024. result_t UARTM$HPLUART$putDone(void)
  4025. #line 87
  4026. {
  4027.   bool oldState;
  4029.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  4030. #line 90
  4031.     {
  4032.       {
  4033.       }
  4034. #line 91
  4035.       ;
  4036.       oldState = UARTM$state;
  4037.       UARTM$state = FALSE;
  4038.     }
  4039. #line 94
  4040.     __nesc_atomic_end(__nesc_atomic); }
  4049.   if (oldState) {
  4050.       UARTM$ByteComm$txDone();
  4051.       UARTM$ByteComm$txByteReady(TRUE);
  4052.     }
  4053.   return SUCCESS;
  4054. }
  4056. static 
  4057. # 469 "/home/testuser/tinyos-1.x/tos/system/FramerM.nc"
  4058. result_t FramerM$TxArbitraryByte(uint8_t inByte)
  4059. #line 469
  4060. {
  4061.   if (inByte == FramerM$HDLC_FLAG_BYTE || inByte == FramerM$HDLC_CTLESC_BYTE) {
  4062.       { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  4063. #line 471
  4064.         {
  4065.           FramerM$gPrevTxState = FramerM$gTxState;
  4066.           FramerM$gTxState = FramerM$TXSTATE_ESC;
  4067.           FramerM$gTxEscByte = inByte;
  4068.         }
  4069. #line 475
  4070.         __nesc_atomic_end(__nesc_atomic); }
  4071.       inByte = FramerM$HDLC_CTLESC_BYTE;
  4072.     }
  4074.   return FramerM$ByteComm$txByte(inByte);
  4075. }