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

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

网络

开发平台：

Others

app.c：源码内容
  2.       CC1000RadioIntM$ecnForwardMsgHdr.type = 222;
  3.       CC1000RadioIntM$ecnForwardMsgHdr.addr = TOS_BCAST_ADDR;
  4.       CC1000RadioIntM$ecnForwardMsgHdr.length = sizeof(ecnMsgType );
  5.       CC1000RadioIntM$ecnForwardMsgHdr.group = 125;
  6.       CC1000RadioIntM$ecnForwardMsgHdr.crc = 0;
  8.       CC1000RadioIntM$syncMsgHdr.type = 223;
  9.       CC1000RadioIntM$syncMsgHdr.addr = TOS_BCAST_ADDR;
  10.       CC1000RadioIntM$syncMsgHdr.length = sizeof(syncMsgType );
  11.       CC1000RadioIntM$syncMsgHdr.group = 125;
  12.       CC1000RadioIntM$syncMsgHdr.crc = 0;
  14.       ecnMsgPtr->hopCount = 0;
  15.       ecnMsgPtr->nextHop = CC1000RadioIntM$nextHop;
  16.       ecnMsgPtr->senderAddress = TOS_LOCAL_ADDRESS;
  17.     }
  18. #line 727
  19.     __nesc_atomic_end(__nesc_atomic); }
  21.   for (i = 0; i < 9; i++) 
  22.     CC1000RadioIntM$usSquelchTable[(int )i] = 0x120;
  24.   CC1000RadioIntM$SpiByteFifo$initSlave();
  26.   CC1000RadioIntM$CC1000StdControl$init();
  27.   CC1000RadioIntM$CC1000Control$SelectLock(0x9);
  28.   CC1000RadioIntM$bInvertRxData = CC1000RadioIntM$CC1000Control$GetLOStatus();
  30.   CC1000RadioIntM$ADCControl$bindPort(TOS_ADC_CC_RSSI_PORT, TOSH_ACTUAL_CC_RSSI_PORT);
  31.   CC1000RadioIntM$ADCControl$init();
  33.   CC1000RadioIntM$Random$init();
  34.   CC1000RadioIntM$TimerControl$init();
  39.   CC1000RadioIntM$LocalAddr = TOS_LOCAL_ADDRESS;
  41.   return SUCCESS;
  42. }
  44. # 63 "/home/testuser/tinyos-1.x/tos/interfaces/StdControl.nc"
  45. inline static  result_t AMStandard$RadioControl$init(void){
  46. #line 63
  47.   unsigned char result;
  48. #line 63
  50. #line 63
  51.   result = CC1000RadioIntM$StdControl$init();
  52. #line 63
  54. #line 63
  55.   return result;
  56. #line 63
  57. }
  58. #line 63
  59. static inline  
  60. # 60 "/home/testuser/tinyos-1.x/tos/system/UARTM.nc"
  61. result_t UARTM$Control$init(void)
  62. #line 60
  63. {
  64.   {
  65.   }
  66. #line 61
  67.   ;
  68.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  69. #line 62
  70.     {
  71.       UARTM$state = FALSE;
  72.     }
  73. #line 64
  74.     __nesc_atomic_end(__nesc_atomic); }
  75.   return SUCCESS;
  76. }
  78. # 63 "/home/testuser/tinyos-1.x/tos/interfaces/StdControl.nc"
  79. inline static  result_t FramerM$ByteControl$init(void){
  80. #line 63
  81.   unsigned char result;
  82. #line 63
  84. #line 63
  85.   result = UARTM$Control$init();
  86. #line 63
  88. #line 63
  89.   return result;
  90. #line 63
  91. }
  92. #line 63
  93. static inline  
  94. # 291 "/home/testuser/tinyos-1.x/tos/system/FramerM.nc"
  95. result_t FramerM$StdControl$init(void)
  96. #line 291
  97. {
  98.   FramerM$HDLCInitialize();
  99.   return FramerM$ByteControl$init();
  100. }
  102. # 63 "/home/testuser/tinyos-1.x/tos/interfaces/StdControl.nc"
  103. inline static  result_t AMStandard$UARTControl$init(void){
  104. #line 63
  105.   unsigned char result;
  106. #line 63
  108. #line 63
  109.   result = FramerM$StdControl$init();
  110. #line 63
  112. #line 63
  113.   return result;
  114. #line 63
  115. }
  116. #line 63
  117. inline static  result_t AMStandard$TimerControl$init(void){
  118. #line 63
  119.   unsigned char result;
  120. #line 63
  122. #line 63
  123.   result = TimerM$StdControl$init();
  124. #line 63
  126. #line 63
  127.   return result;
  128. #line 63
  129. }
  130. #line 63
  131. static inline  
  132. # 87 "/home/testuser/tinyos-1.x/tos/system/AMStandard.nc"
  133. bool AMStandard$Control$init(void)
  134. #line 87
  135. {
  136.   result_t ok1;
  137. #line 88
  138.   result_t ok2;
  140.   AMStandard$TimerControl$init();
  141.   ok1 = AMStandard$UARTControl$init();
  142.   ok2 = AMStandard$RadioControl$init();
  144.   AMStandard$state = FALSE;
  145.   AMStandard$lastCount = 0;
  146.   AMStandard$counter = 0;
  147.   {
  148.   }
  149. #line 97
  150.   ;
  152.   return rcombine(ok1, ok2);
  153. }
  155. # 63 "/home/testuser/tinyos-1.x/tos/interfaces/StdControl.nc"
  156. inline static  result_t RealMain$StdControl$init(void){
  157. #line 63
  158.   unsigned char result;
  159. #line 63
  161. #line 63
  162.   result = TimerM$StdControl$init();
  163. #line 63
  164.   result = rcombine(result, TimerM$StdControl$init());
  165. #line 63
  166.   result = rcombine(result, AMStandard$Control$init());
  167. #line 63
  168.   result = rcombine(result, TestBedTopologyM$StdControl$init());
  169. #line 63
  171. #line 63
  172.   return result;
  173. #line 63
  174. }
  175. #line 63
  176. static inline   
  177. # 149 "/home/testuser/tinyos-1.x/tos/platform/mica/HPLClock.nc"
  178. result_t HPLClock$Clock$setRate(char interval, char scale)
  179. #line 149
  180. {
  181.   scale &= 0x7;
  182.   scale |= 0x8;
  183.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  184. #line 152
  185.     {
  186.       * (volatile uint8_t *)(0x37 + 0x20) &= ~(1 << 0);
  187.       * (volatile uint8_t *)(0x37 + 0x20) &= ~(1 << 1);
  188.       * (volatile uint8_t *)(0x30 + 0x20) |= 1 << 3;
  191.       * (volatile uint8_t *)(0x33 + 0x20) = scale;
  192.       * (volatile uint8_t *)(0x32 + 0x20) = 0;
  193.       * (volatile uint8_t *)(0x31 + 0x20) = interval;
  194.       * (volatile uint8_t *)(0x37 + 0x20) |= 1 << 1;
  195.     }
  196. #line 162
  197.     __nesc_atomic_end(__nesc_atomic); }
  198.   return SUCCESS;
  199. }
  201. # 96 "/home/testuser/tinyos-1.x/tos/interfaces/Clock.nc"
  202. inline static   result_t TimerM$Clock$setRate(char arg_0x8913d88, char arg_0x8913ec8){
  203. #line 96
  204.   unsigned char result;
  205. #line 96
  207. #line 96
  208.   result = HPLClock$Clock$setRate(arg_0x8913d88, arg_0x8913ec8);
  209. #line 96
  211. #line 96
  212.   return result;
  213. #line 96
  214. }
  215. #line 96
  216. # 128 "../../tos/platform/mica2/hardware.h"
  217. static __inline void TOSH_CLR_CC_PALE_PIN(void)
  218. #line 128
  219. {
  220. #line 128
  221.   * (volatile uint8_t *)(0x12 + 0x20) &= ~(1 << 4);
  222. }
  224. #line 126
  225. static __inline void TOSH_CLR_CC_PDATA_PIN(void)
  226. #line 126
  227. {
  228. #line 126
  229.   * (volatile uint8_t *)(0x12 + 0x20) &= ~(1 << 7);
  230. }
  232. #line 127
  233. static __inline void TOSH_CLR_CC_PCLK_PIN(void)
  234. #line 127
  235. {
  236. #line 127
  237.   * (volatile uint8_t *)(0x12 + 0x20) &= ~(1 << 6);
  238. }
  240. #line 126
  241. static __inline void TOSH_MAKE_CC_PDATA_INPUT(void)
  242. #line 126
  243. {
  244. #line 126
  245.   * (volatile uint8_t *)(0x11 + 0x20) &= ~(1 << 7);
  246. }
  248. #line 126
  249. static __inline int TOSH_READ_CC_PDATA_PIN(void)
  250. #line 126
  251. {
  252. #line 126
  253.   return (* (volatile uint8_t *)(0x10 + 0x20) & (1 << 7)) != 0;
  254. }
  256. static inline   
  257. # 1602 "../../tos/system/DrandM.nc"
  258. result_t DrandM$SClock$fire(uint16_t mticks)
  259. #line 1602
  260. {
  261. #line 1602
  262.   return SUCCESS;
  263. }
  265. static inline   
  266. # 1823 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  267. result_t CC1000RadioIntM$SClock$fire(uint16_t mticks)
  268. #line 1823
  269. {
  270. #line 1823
  271.   return SUCCESS;
  272. }
  274. # 88 "../../tos/interfaces/SClock.nc"
  275. inline static   result_t HPLSClock$SClock$fire(uint16_t arg_0x8585230){
  276. #line 88
  277.   unsigned char result;
  278. #line 88
  280. #line 88
  281.   result = CC1000RadioIntM$SClock$fire(arg_0x8585230);
  282. #line 88
  283.   result = rcombine(result, DrandM$SClock$fire(arg_0x8585230));
  284. #line 88
  286. #line 88
  287.   return result;
  288. #line 88
  289. }
  290. #line 88
  291. static inline  
  292. # 494 "../../tos/platform/mica2/CC1000ControlM.nc"
  293. result_t CC1000ControlM$CC1000Control$SetRFPower(uint8_t power)
  294. #line 494
  295. {
  296.   CC1000ControlM$gCurrentParameters[0xb] = power;
  299.   return SUCCESS;
  300. }
  302. # 150 "../../tos/platform/mica2/CC1000Control.nc"
  303. inline static  result_t TestBedTopologyM$RFset$SetRFPower(uint8_t arg_0x85440e8){
  304. #line 150
  305.   unsigned char result;
  306. #line 150
  308. #line 150
  309.   result = CC1000ControlM$CC1000Control$SetRFPower(arg_0x85440e8);
  310. #line 150
  312. #line 150
  313.   return result;
  314. #line 150
  315. }
  316. #line 150
  317. # 59 "/home/testuser/tinyos-1.x/tos/interfaces/Timer.nc"
  318. inline static  result_t DrandM$roundTimer$start(char arg_0x85800e0, uint32_t arg_0x8580238){
  319. #line 59
  320.   unsigned char result;
  321. #line 59
  323. #line 59
  324.   result = TimerM$Timer$start(0, arg_0x85800e0, arg_0x8580238);
  325. #line 59
  327. #line 59
  328.   return result;
  329. #line 59
  330. }
  331. #line 59
  332. # 59 "/home/testuser/tinyos-1.x/tos/interfaces/Timer.nc"
  333. inline static  result_t DrandM$reXTimer$start(char arg_0x85800e0, uint32_t arg_0x8580238){
  334. #line 59
  335.   unsigned char result;
  336. #line 59
  338. #line 59
  339.   result = TimerM$Timer$start(1, arg_0x85800e0, arg_0x8580238);
  340. #line 59
  342. #line 59
  343.   return result;
  344. #line 59
  345. }
  346. #line 59
  347. static inline  
  348. # 565 "../../tos/system/DrandM.nc"
  349. result_t DrandM$StdControl$start(void)
  350. #line 565
  351. {
  352.   DrandM$globalState = HELLO_STATE;
  353.   DrandM$reXTimer$start(TIMER_ONE_SHOT, DrandM$randNew() % HELLO_INTERVAL);
  354.   DrandM$roundTimer$start(TIMER_ONE_SHOT, HELLO_PERIOD);
  355.   return SUCCESS;
  356. }
  358. # 70 "/home/testuser/tinyos-1.x/tos/interfaces/StdControl.nc"
  359. inline static  result_t TestBedTopologyM$SubControl$start(void){
  360. #line 70
  361.   unsigned char result;
  362. #line 70
  364. #line 70
  365.   result = DrandM$StdControl$start();
  366. #line 70
  368. #line 70
  369.   return result;
  370. #line 70
  371. }
  372. #line 70
  373. static inline  
  374. # 20 "TestBedTopologyM.nc"
  375. result_t TestBedTopologyM$StdControl$start(void)
  376. #line 20
  377. {
  378.   TestBedTopologyM$SubControl$start();
  379.   TestBedTopologyM$RFset$SetRFPower(255);
  381.   return SUCCESS;
  382. }
  384. static inline 
  385. # 133 "/home/testuser/tinyos-1.x/tos/system/tos.h"
  386. result_t rcombine4(result_t r1, result_t r2, result_t r3, 
  387. result_t r4)
  388. {
  389.   return rcombine(r1, rcombine(r2, rcombine(r3, r4)));
  390. }
  392. # 41 "/home/testuser/tinyos-1.x/tos/interfaces/PowerManagement.nc"
  393. inline static   uint8_t AMStandard$PowerManagement$adjustPower(void){
  394. #line 41
  395.   unsigned char result;
  396. #line 41
  398. #line 41
  399.   result = HPLPowerManagementM$PowerManagement$adjustPower();
  400. #line 41
  402. #line 41
  403.   return result;
  404. #line 41
  405. }
  406. #line 41
  407. # 59 "/home/testuser/tinyos-1.x/tos/interfaces/Timer.nc"
  408. inline static  result_t AMStandard$ActivityTimer$start(char arg_0x85800e0, uint32_t arg_0x8580238){
  409. #line 59
  410.   unsigned char result;
  411. #line 59
  413. #line 59
  414.   result = TimerM$Timer$start(3, arg_0x85800e0, arg_0x8580238);
  415. #line 59
  417. #line 59
  418.   return result;
  419. #line 59
  420. }
  421. #line 59
  422. # 59 "/home/testuser/tinyos-1.x/tos/interfaces/Timer.nc"
  423. inline static  result_t CC1000RadioIntM$WakeupTimer$start(char arg_0x85800e0, uint32_t arg_0x8580238){
  424. #line 59
  425.   unsigned char result;
  426. #line 59
  428. #line 59
  429.   result = TimerM$Timer$start(5, arg_0x85800e0, arg_0x8580238);
  430. #line 59
  432. #line 59
  433.   return result;
  434. #line 59
  435. }
  436. #line 59
  437. # 41 "/home/testuser/tinyos-1.x/tos/interfaces/PowerManagement.nc"
  438. inline static   uint8_t HPLSpiM$PowerManagement$adjustPower(void){
  439. #line 41
  440.   unsigned char result;
  441. #line 41
  443. #line 41
  444.   result = HPLPowerManagementM$PowerManagement$adjustPower();
  445. #line 41
  447. #line 41
  448.   return result;
  449. #line 41
  450. }
  451. #line 41
  452. static inline   
  453. # 74 "../../tos/platform/mica2/HPLSpiM.nc"
  454. result_t HPLSpiM$SpiByteFifo$enableIntr(void)
  455. #line 74
  456. {
  458.   * (volatile uint8_t *)(0x0D + 0x20) = 0xC0;
  459.   * (volatile uint8_t *)(0x17 + 0x20) &= ~(1 << 0);
  460.   HPLSpiM$PowerManagement$adjustPower();
  461.   return SUCCESS;
  462. }
  464. # 36 "../../tos/platform/mica2/SpiByteFifo.nc"
  465. inline static   result_t CC1000RadioIntM$SpiByteFifo$enableIntr(void){
  466. #line 36
  467.   unsigned char result;
  468. #line 36
  470. #line 36
  471.   result = HPLSpiM$SpiByteFifo$enableIntr();
  472. #line 36
  474. #line 36
  475.   return result;
  476. #line 36
  477. }
  478. #line 36
  479. # 59 "/home/testuser/tinyos-1.x/tos/interfaces/Timer.nc"
  480. inline static  result_t CC1000RadioIntM$SquelchTimer$start(char arg_0x85800e0, uint32_t arg_0x8580238){
  481. #line 59
  482.   unsigned char result;
  483. #line 59
  485. #line 59
  486.   result = TimerM$Timer$start(4, arg_0x85800e0, arg_0x8580238);
  487. #line 59
  489. #line 59
  490.   return result;
  491. #line 59
  492. }
  493. #line 59
  494. # 116 "../../tos/platform/mica2/CC1000Control.nc"
  495. inline static   result_t CC1000RadioIntM$CC1000Control$RxMode(void){
  496. #line 116
  497.   unsigned char result;
  498. #line 116
  500. #line 116
  501.   result = CC1000ControlM$CC1000Control$RxMode();
  502. #line 116
  504. #line 116
  505.   return result;
  506. #line 116
  507. }
  508. #line 116
  509. static inline   
  510. # 109 "../../tos/platform/mica2/HPLSpiM.nc"
  511. result_t HPLSpiM$SpiByteFifo$rxMode(void)
  512. #line 109
  513. {
  514.   TOSH_MAKE_MISO_INPUT();
  515.   TOSH_MAKE_MOSI_INPUT();
  516.   return SUCCESS;
  517. }
  519. # 40 "../../tos/platform/mica2/SpiByteFifo.nc"
  520. inline static   result_t CC1000RadioIntM$SpiByteFifo$rxMode(void){
  521. #line 40
  522.   unsigned char result;
  523. #line 40
  525. #line 40
  526.   result = HPLSpiM$SpiByteFifo$rxMode();
  527. #line 40
  529. #line 40
  530.   return result;
  531. #line 40
  532. }
  533. #line 40
  534. static inline  
  535. # 457 "../../tos/platform/mica2/CC1000ControlM.nc"
  536. result_t CC1000ControlM$CC1000Control$BIASOn(void)
  537. #line 457
  538. {
  540.   CC1000ControlM$HPLChipcon$write(0x00, (((
  541.   1 << 5) | (1 << 4)) | (
  542.   1 << 3)) | (
  543.   1 << 0));
  545.   TOSH_uwait(200);
  546.   return SUCCESS;
  547. }
  549. # 137 "../../tos/platform/mica2/CC1000Control.nc"
  550. inline static  result_t CC1000RadioIntM$CC1000Control$BIASOn(void){
  551. #line 137
  552.   unsigned char result;
  553. #line 137
  555. #line 137
  556.   result = CC1000ControlM$CC1000Control$BIASOn();
  557. #line 137
  559. #line 137
  560.   return result;
  561. #line 137
  562. }
  563. #line 137
  564. static inline  
  565. # 480 "../../tos/platform/mica2/CC1000ControlM.nc"
  566. result_t CC1000ControlM$StdControl$start(void)
  567. #line 480
  568. {
  570.   CC1000ControlM$HPLChipcon$write(0x00, ((((
  571.   1 << 5) | (1 << 4)) | (
  572.   1 << 3)) | (1 << 1)) | (
  573.   1 << 0));
  578.   return SUCCESS;
  579. }
  581. # 70 "/home/testuser/tinyos-1.x/tos/interfaces/StdControl.nc"
  582. inline static  result_t CC1000RadioIntM$CC1000StdControl$start(void){
  583. #line 70
  584.   unsigned char result;
  585. #line 70
  587. #line 70
  588.   result = CC1000ControlM$StdControl$start();
  589. #line 70
  591. #line 70
  592.   return result;
  593. #line 70
  594. }
  595. #line 70
  596. static inline   
  597. # 66 "../../tos/platform/mica2/HPLSClock.nc"
  598. result_t HPLSClock$SClock$SetRate(uint16_t interval, char scale)
  599. #line 66
  600. {
  601.   scale &= 0x7;
  602.   scale |= 0x8;
  603.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  604. #line 69
  605.     {
  606.       * (volatile uint8_t *)0x7D &= ~(1 << 4);
  607.       * (volatile uint8_t *)0x8A = scale;
  608.       * (volatile uint16_t *)0x88 = 0x0000;
  609.       * (volatile uint16_t *)0x86 = interval;
  610.       * (volatile uint8_t *)0x8B = 0x00;
  611.       * (volatile uint8_t *)0x8B |= 1 << 6;
  612.       * (volatile uint8_t *)(0x02 + 0x20) |= 1 << 3;
  613.       * (volatile uint8_t *)0x8C = 0x00;
  614.       * (volatile uint8_t *)0x7D |= 1 << 4;
  615.     }
  616. #line 79
  617.     __nesc_atomic_end(__nesc_atomic); }
  618.   HPLSClock$needupdate = 0;
  619.   return SUCCESS;
  620. }
  622. # 45 "../../tos/interfaces/SClock.nc"
  623. inline static   result_t CC1000RadioIntM$SClock$SetRate(uint16_t arg_0x857f4a8, char arg_0x857f5e8){
  624. #line 45
  625.   unsigned char result;
  626. #line 45
  628. #line 45
  629.   result = HPLSClock$SClock$SetRate(arg_0x857f4a8, arg_0x857f5e8);
  630. #line 45
  632. #line 45
  633.   return result;
  634. #line 45
  635. }
  636. #line 45
  637. static inline  
  638. # 1056 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  639. result_t CC1000RadioIntM$StdControl$start(void)
  640. #line 1056
  641. {
  642.   uint8_t currentRadioState;
  644. #line 1058
  645.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  646. #line 1058
  647.     currentRadioState = CC1000RadioIntM$RadioState;
  648. #line 1058
  649.     __nesc_atomic_end(__nesc_atomic); }
  651.   CC1000RadioIntM$SClock$SetRate(CC1000RadioIntM$MAX_VAL, CLK_DIV_64);
  652.   if (currentRadioState == CC1000RadioIntM$DISABLED_STATE) {
  653.       { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  654. #line 1062
  655.         {
  656.           CC1000RadioIntM$rxbufptr->length = 0;
  657.           CC1000RadioIntM$RadioState = CC1000RadioIntM$IDLE_STATE;
  658.           CC1000RadioIntM$bTxPending = CC1000RadioIntM$bTxBusy = FALSE;
  659.           CC1000RadioIntM$sMacDelay = -1;
  660.           if (0 > 0) {
  661.               CC1000RadioIntM$sleeptime = 0;
  662.               CC1000RadioIntM$preamblelen = 0;
  663.             }
  664.           else 
  665. #line 1070
  666.             {
  667.               CC1000RadioIntM$lplpower = CC1000RadioIntM$lplpowertx = 0;
  668.               CC1000RadioIntM$sleeptime = (({
  669. #line 1072
  670.                 uint16_t __addr16 = (uint16_t )(uint16_t )&CC1K_LPL_SleepTime[CC1000RadioIntM$lplpower * 2];
  671. #line 1072
  672.                 uint8_t __result;
  674. #line 1072
  675.                  __asm ("lpm %0, Z""nt" : "=r"(__result) : "z"(__addr16));__result;
  676.               }
  677.               )
  678. #line 1072
  679.                << 8) | 
  680.               ({
  681. #line 1073
  682.                 uint16_t __addr16 = (uint16_t )(uint16_t )&CC1K_LPL_SleepTime[CC1000RadioIntM$lplpower * 2 + 1];
  683. #line 1073
  684.                 uint8_t __result;
  686. #line 1073
  687.                  __asm ("lpm %0, Z""nt" : "=r"(__result) : "z"(__addr16));__result;
  688.               }
  689.               );
  690. #line 1074
  691.               CC1000RadioIntM$preamblelen = (({
  692. #line 1074
  693.                 uint16_t __addr16 = (uint16_t )(uint16_t )&CC1K_LPL_PreambleLength[CC1000RadioIntM$lplpowertx * 2];
  694. #line 1074
  695.                 uint8_t __result;
  697. #line 1074
  698.                  __asm ("lpm %0, Z""nt" : "=r"(__result) : "z"(__addr16));__result;
  699.               }
  700.               )
  701. #line 1074
  702.                << 8) | 
  703.               ({
  704. #line 1075
  705.                 uint16_t __addr16 = (uint16_t )(uint16_t )&CC1K_LPL_PreambleLength[CC1000RadioIntM$lplpowertx * 2 + 1];
  706. #line 1075
  707.                 uint8_t __result;
  709. #line 1075
  710.                  __asm ("lpm %0, Z""nt" : "=r"(__result) : "z"(__addr16));__result;
  711.               }
  712.               );
  713.             }
  714.         }
  715. #line 1079
  716.         __nesc_atomic_end(__nesc_atomic); }
  720.       CC1000RadioIntM$rxbufptr->length = 0;
  721.       { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  722. #line 1084
  723.         CC1000RadioIntM$RadioState = CC1000RadioIntM$IDLE_STATE;
  724. #line 1084
  725.         __nesc_atomic_end(__nesc_atomic); }
  726.       CC1000RadioIntM$CC1000StdControl$start();
  727.       CC1000RadioIntM$CC1000Control$BIASOn();
  728.       CC1000RadioIntM$SpiByteFifo$rxMode();
  729.       CC1000RadioIntM$CC1000Control$RxMode();
  730.       if (CC1000RadioIntM$iSquelchCount > 30) {
  731.         CC1000RadioIntM$SquelchTimer$start(TIMER_REPEAT, 2560);
  732.         }
  733.       else {
  734. #line 1092
  735.         CC1000RadioIntM$SquelchTimer$start(TIMER_REPEAT, 128);
  736.         }
  737. #line 1093
  738.       CC1000RadioIntM$SpiByteFifo$enableIntr();
  739.       if (CC1000RadioIntM$lplpower > 0) {
  741.           CC1000RadioIntM$WakeupTimer$start(TIMER_ONE_SHOT, 2560);
  742.         }
  743.     }
  744.   return SUCCESS;
  745. }
  747. # 70 "/home/testuser/tinyos-1.x/tos/interfaces/StdControl.nc"
  748. inline static  result_t AMStandard$RadioControl$start(void){
  749. #line 70
  750.   unsigned char result;
  751. #line 70
  753. #line 70
  754.   result = CC1000RadioIntM$StdControl$start();
  755. #line 70
  757. #line 70
  758.   return result;
  759. #line 70
  760. }
  761. #line 70
  762. static inline   
  763. # 60 "../../tos/platform/mica2/HPLUART0M.nc"
  764. result_t HPLUART0M$UART$init(void)
  765. #line 60
  766. {
  772.   * (volatile uint8_t *)0x90 = 0;
  773.   * (volatile uint8_t *)(0x09 + 0x20) = 15;
  776.   * (volatile uint8_t *)(0x0B + 0x20) = 1 << 1;
  779.   * (volatile uint8_t *)0x95 = (1 << 2) | (1 << 1);
  782.   * (volatile uint8_t *)(0x0A + 0x20) = (((1 << 7) | (1 << 6)) | (1 << 4)) | (1 << 3);
  785.   return SUCCESS;
  786. }
  788. # 62 "/home/testuser/tinyos-1.x/tos/interfaces/HPLUART.nc"
  789. inline static   result_t UARTM$HPLUART$init(void){
  790. #line 62
  791.   unsigned char result;
  792. #line 62
  794. #line 62
  795.   result = HPLUART0M$UART$init();
  796. #line 62
  798. #line 62
  799.   return result;
  800. #line 62
  801. }
  802. #line 62
  803. static inline  
  804. # 68 "/home/testuser/tinyos-1.x/tos/system/UARTM.nc"
  805. result_t UARTM$Control$start(void)
  806. #line 68
  807. {
  808.   return UARTM$HPLUART$init();
  809. }
  811. # 70 "/home/testuser/tinyos-1.x/tos/interfaces/StdControl.nc"
  812. inline static  result_t FramerM$ByteControl$start(void){
  813. #line 70
  814.   unsigned char result;
  815. #line 70
  817. #line 70
  818.   result = UARTM$Control$start();
  819. #line 70
  821. #line 70
  822.   return result;
  823. #line 70
  824. }
  825. #line 70
  826. static inline  
  827. # 296 "/home/testuser/tinyos-1.x/tos/system/FramerM.nc"
  828. result_t FramerM$StdControl$start(void)
  829. #line 296
  830. {
  831.   FramerM$HDLCInitialize();
  832.   return FramerM$ByteControl$start();
  833. }
  835. # 70 "/home/testuser/tinyos-1.x/tos/interfaces/StdControl.nc"
  836. inline static  result_t AMStandard$UARTControl$start(void){
  837. #line 70
  838.   unsigned char result;
  839. #line 70
  841. #line 70
  842.   result = FramerM$StdControl$start();
  843. #line 70
  845. #line 70
  846.   return result;
  847. #line 70
  848. }
  849. #line 70
  850. static inline  
  851. # 87 "/home/testuser/tinyos-1.x/tos/system/TimerM.nc"
  852. result_t TimerM$StdControl$start(void)
  853. #line 87
  854. {
  855.   return SUCCESS;
  856. }
  858. # 70 "/home/testuser/tinyos-1.x/tos/interfaces/StdControl.nc"
  859. inline static  result_t AMStandard$TimerControl$start(void){
  860. #line 70
  861.   unsigned char result;
  862. #line 70
  864. #line 70
  865.   result = TimerM$StdControl$start();
  866. #line 70
  868. #line 70
  869.   return result;
  870. #line 70
  871. }
  872. #line 70
  873. static inline  
  874. # 103 "/home/testuser/tinyos-1.x/tos/system/AMStandard.nc"
  875. bool AMStandard$Control$start(void)
  876. #line 103
  877. {
  878.   result_t ok0 = AMStandard$TimerControl$start();
  879.   result_t ok1 = AMStandard$UARTControl$start();
  880.   result_t ok2 = AMStandard$RadioControl$start();
  881.   result_t ok3 = AMStandard$ActivityTimer$start(TIMER_REPEAT, 1000);
  885.   AMStandard$state = FALSE;
  887.   AMStandard$PowerManagement$adjustPower();
  889.   return rcombine4(ok0, ok1, ok2, ok3);
  890. }
  892. # 70 "/home/testuser/tinyos-1.x/tos/interfaces/StdControl.nc"
  893. inline static  result_t RealMain$StdControl$start(void){
  894. #line 70
  895.   unsigned char result;
  896. #line 70
  898. #line 70
  899.   result = TimerM$StdControl$start();
  900. #line 70
  901.   result = rcombine(result, TimerM$StdControl$start());
  902. #line 70
  903.   result = rcombine(result, AMStandard$Control$start());
  904. #line 70
  905.   result = rcombine(result, TestBedTopologyM$StdControl$start());
  906. #line 70
  908. #line 70
  909.   return result;
  910. #line 70
  911. }
  912. #line 70
  913. static inline 
  914. # 64 "../../tos/platform/mica2/HPLPowerManagementM.nc"
  915. uint8_t HPLPowerManagementM$getPowerLevel(void)
  916. #line 64
  917. {
  918.   uint8_t diff;
  920. #line 66
  921.   if (* (volatile uint8_t *)(0x37 + 0x20) & ~((1 << 1) | (1 << 0))) {
  923.       return HPLPowerManagementM$IDLE;
  924.     }
  925.   else {
  926. #line 69
  927.     if (* (volatile uint8_t *)(uint16_t )& * (volatile uint8_t *)(0x0D + 0x20) & (1 << 7)) {
  928.         return HPLPowerManagementM$IDLE;
  929.       }
  930.     else {
  931.       if (* (volatile uint8_t *)(uint16_t )& * (volatile uint8_t *)(0x06 + 0x20) & (1 << 7)) {
  932.           return HPLPowerManagementM$ADC_NR;
  933.         }
  934.       else {
  935. #line 75
  936.         if (* (volatile uint8_t *)(0x37 + 0x20) & ((1 << 1) | (1 << 0))) {
  937.             diff = * (volatile uint8_t *)(0x31 + 0x20) - * (volatile uint8_t *)(0x32 + 0x20);
  938.             if (diff < 16) {
  939.               return HPLPowerManagementM$EXT_STANDBY;
  940.               }
  941. #line 79
  942.             return HPLPowerManagementM$POWER_SAVE;
  943.           }
  944.         else 
  945. #line 80
  946.           {
  947.             return HPLPowerManagementM$POWER_DOWN;
  948.           }
  949.         }
  950.       }
  951.     }
  952. }
  954. static inline  
  955. #line 85
  956. void HPLPowerManagementM$doAdjustment(void)
  957. #line 85
  958. {
  959.   uint8_t foo;
  960. #line 86
  961.   uint8_t mcu;
  963. #line 87
  964.   HPLPowerManagementM$powerLevel = foo = HPLPowerManagementM$getPowerLevel();
  965.   mcu = * (volatile uint8_t *)(0x35 + 0x20);
  966.   mcu &= 0xe3;
  967.   if (foo == HPLPowerManagementM$EXT_STANDBY || foo == HPLPowerManagementM$POWER_SAVE) {
  968.       mcu |= HPLPowerManagementM$IDLE;
  969.       while ((* (volatile uint8_t *)(0x30 + 0x20) & 0x7) != 0) {
  970.            __asm volatile ("nop");}
  972.       mcu &= 0xe3;
  973.     }
  974.   mcu |= foo;
  975.   * (volatile uint8_t *)(0x35 + 0x20) = mcu;
  976.   * (volatile uint8_t *)(0x35 + 0x20) |= 1 << 5;
  977. }
  979. static 
  980. # 187 "/home/testuser/tinyos-1.x/tos/platform/avrmote/avrhardware.h"
  981. __inline void __nesc_enable_interrupt(void)
  982. #line 187
  983. {
  984.    __asm volatile ("sei");}
  986. #line 172
  987. __inline void  __nesc_atomic_end(__nesc_atomic_t oldSreg)
  988. {
  989.   * (volatile uint8_t *)(0x3F + 0x20) = oldSreg;
  990. }
  992. static inline 
  993. #line 150
  994. void TOSH_wait(void)
  995. {
  996.    __asm volatile ("nop");
  997.    __asm volatile ("nop");}
  999. static 
  1000. #line 179
  1001. __inline void __nesc_atomic_sleep(void)
  1002. {
  1004.    __asm volatile ("sei");
  1005.    __asm volatile ("sleep");
  1006.   TOSH_wait();
  1007. }
  1009. #line 165
  1010. __inline __nesc_atomic_t  __nesc_atomic_start(void )
  1011. {
  1012.   __nesc_atomic_t result = * (volatile uint8_t *)(0x3F + 0x20);
  1014. #line 168
  1015.    __asm volatile ("cli");
  1016.   return result;
  1017. }
  1019. static inline 
  1020. # 136 "/home/testuser/tinyos-1.x/tos/system/sched.c"
  1021. bool TOSH_run_next_task(void)
  1022. {
  1023.   __nesc_atomic_t fInterruptFlags;
  1024.   uint8_t old_full;
  1025.   void (*func)(void );
  1027.   fInterruptFlags = __nesc_atomic_start();
  1028.   old_full = TOSH_sched_full;
  1029.   func = TOSH_queue[old_full].tp;
  1030.   if (func == (void *)0) 
  1031.     {
  1032.       __nesc_atomic_sleep();
  1033.       return 0;
  1034.     }
  1036.   TOSH_queue[old_full].tp = (void *)0;
  1037.   TOSH_sched_full = (old_full + 1) & TOSH_TASK_BITMASK;
  1038.   __nesc_atomic_end(fInterruptFlags);
  1039.   func();
  1041.   return 1;
  1042. }
  1044. static inline void TOSH_run_task(void)
  1045. #line 159
  1046. {
  1047.   for (; ; ) 
  1048.     TOSH_run_next_task();
  1049. }
  1051. static inline 
  1052. # 132 "/home/testuser/tinyos-1.x/tos/system/AMStandard.nc"
  1053. void AMStandard$dbgPacket(TOS_MsgPtr data)
  1054. #line 132
  1055. {
  1056.   uint8_t i;
  1058.   for (i = 0; i < sizeof(TOS_Msg ); i++) 
  1059.     {
  1060.       {
  1061.       }
  1062. #line 137
  1063.       ;
  1064.     }
  1065.   {
  1066.   }
  1067. #line 139
  1068.   ;
  1069. }
  1071. static inline 
  1072. # 485 "../../tos/system/DrandM.nc"
  1073. void DrandM$updateNeighborInfoForFrame(uint8_t nIndex, frameMsg *pkt)
  1074. #line 485
  1075. {
  1076.   uint8_t i;
  1077.   int n;
  1081.   DrandM$nbrInfo[nIndex].frame = pkt->frame;
  1082.   for (i = 0; i < MAX_ONE_HOP && pkt->oneHopNodeID[i] != 0xFF; i++) 
  1083.     if ((n = DrandM$isPresent(pkt->oneHopNodeID[i], ONE_HOP | TWO_HOP)) != -1) {
  1084.         DrandM$nbrInfo[n].frame = pkt->frameArray[i];
  1086.         {
  1087. #line 496
  1088.           char bStatus;
  1090. #line 496
  1091.           if (DBG_USR2 != 0) {
  1092. #line 496
  1093.               bStatus = * (volatile uint8_t *)(uint16_t )& * (volatile uint8_t *)(0x3F + 0x20) & (1 << 7);
  1094. #line 496
  1095.                __asm volatile ("cli");DrandM$sprintf(DrandM$debugbuf, "updating for node = %u, Frame = %un", DrandM$nbrInfo[n].nodeID, DrandM$nbrInfo[n].frame);
  1096. #line 496
  1097.               DrandM$writedebug();
  1098. #line 496
  1099.               if (bStatus) {
  1100. #line 496
  1101.                  __asm volatile ("sei");
  1102.                 }
  1103.             }
  1104.         }
  1105. #line 496
  1106.         ;
  1107.       }
  1108. }
  1110. static inline  
  1111. #line 1373
  1112. TOS_MsgPtr DrandM$ReceiveFrameMsg$receive(TOS_MsgPtr m)
  1113. #line 1373
  1114. {
  1115.   if (DrandM$globalState != FRAME_STATE && !DrandM$gotAllFrames) {
  1116. #line 1374
  1117.     return m;
  1118.     }
  1119. #line 1375
  1120.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1121. #line 1375
  1122.     {
  1123.       frameMsg *recvFramePtr = (frameMsg *)m->data;
  1124.       int nIndex = DrandM$isPresent(recvFramePtr->sendID, ONE_HOP);
  1129.       DrandM$updateNeighborInfoForFrame(nIndex, recvFramePtr);
  1130.       if (DrandM$globalState == REPORT_STATE) {
  1131.           DrandM$globalState = FRAME_STATE;
  1132.           DrandM$reXFrame();
  1133.         }
  1134.       if (recvFramePtr->type == FRAME_REQUEST) {
  1135.         DrandM$sendFrameMsg(FRAME_REPLY);
  1136.         }
  1137.     }
  1138. #line 1390
  1139.     __nesc_atomic_end(__nesc_atomic); }
  1140. #line 1390
  1141.   return m;
  1142. }
  1144. static inline 
  1145. #line 468
  1146. void DrandM$updateNeighborInfoForReport(int nIndex, reportMsg *pkt)
  1147. #line 468
  1148. {
  1149.   uint8_t i;
  1150.   int n;
  1154.   if (nIndex != -1) {
  1155.     DrandM$nbrInfo[nIndex].slot = pkt->slot;
  1156.     }
  1157. #line 476
  1158.   for (i = 0; i < MAX_NBR; i++) 
  1159.     if ((n = DrandM$isPresent(pkt->timeSlot[i], ONE_HOP | TWO_HOP)) != -1) {
  1160.         DrandM$nbrInfo[n].slot = i;
  1161.       }
  1162. }
  1164. static inline  
  1165. #line 1347
  1166. TOS_MsgPtr DrandM$ReceiveReportMsg$receive(TOS_MsgPtr m)
  1167. #line 1347
  1168. {
  1169.   if (!DrandM$setMySlot) {
  1170. #line 1348
  1171.     return m;
  1172.     }
  1173. #line 1349
  1174.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1175. #line 1349
  1176.     {
  1177.       reportMsg *recvReportPtr = (reportMsg *)m->data;
  1178.       int nIndex = DrandM$isPresent(recvReportPtr->sendID, ONE_HOP);
  1183.       DrandM$updateNeighborInfoForReport(nIndex, recvReportPtr);
  1184.       if (DrandM$globalState == RELEASE_STATE) {
  1185.           DrandM$globalState = REPORT_STATE;
  1186.           DrandM$reXReport();
  1187.           DrandM$roundTimer$start(TIMER_ONE_SHOT, REPORT_PERIOD);
  1188.         }
  1190.       if (recvReportPtr->type == REPORT_REQUEST) {
  1191.           DrandM$sendReportMsg(REPORT_REPLY);
  1192.         }
  1193.     }
  1194. #line 1366
  1195.     __nesc_atomic_end(__nesc_atomic); }
  1199.   return m;
  1200. }
  1202. static inline 
  1203. #line 302
  1204. uint8_t DrandM$numOneHop(void)
  1205. #line 302
  1206. {
  1207.   uint8_t i;
  1208. #line 303
  1209.   uint8_t count;
  1211. #line 304
  1212.   for (i = 0, count = 0; i < MAX_NBR && DrandM$nbrInfo[i].nodeID != 0xFF; i++) 
  1213.     if (DrandM$nbrInfo[i].bitMap & ONE_HOP) {
  1214.       count++;
  1215.       }
  1216. #line 307
  1217.   return count;
  1218. }
  1220. static inline  
  1221. #line 1236
  1222. TOS_MsgPtr DrandM$ReceiveGrantMsg$receive(TOS_MsgPtr m)
  1223. #line 1236
  1224. {
  1225.   uint8_t i;
  1226.   GTime rttTime;
  1227.   double currOTT;
  1228.   bool dup = FALSE;
  1229.   grantMsg *recvGrantPtr = (grantMsg *)m->data;
  1230.   int nIndex = DrandM$isPresent(recvGrantPtr->sendID, ONE_HOP);
  1232. #line 1243
  1233.   if (nIndex == -1) {
  1234.     return m;
  1235.     }
  1236. #line 1245
  1237.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1238. #line 1245
  1239.     {
  1240.       for (i = 0; i < MAX_NBR; i++) {
  1241.           if (DrandM$isPresent(recvGrantPtr->timeSlot[i], ONE_HOP) == -1) {
  1242.             DrandM$addNode(recvGrantPtr->timeSlot[i], TWO_HOP);
  1243.             }
  1244. #line 1249
  1245.           DrandM$updateNeighborInfo(recvGrantPtr->timeSlot[i], i);
  1246.         }
  1252.       if (DrandM$setMySlot) {
  1256.           DrandM$sendReleaseMsg(DrandM$myInfo.slot);
  1257.         }
  1258.       else {
  1259. #line 1261
  1260.         if (DrandM$globalState == IDLE_STATE2 || DrandM$globalState == GRANT_STATE) {
  1265.             DrandM$sendReleaseMsg(0xFF);
  1266.             DrandM$sentRelease = TRUE;
  1267.           }
  1268.         else {
  1269. #line 1269
  1270.           if (DrandM$globalState == REQUEST_STATE) {
  1271.               if (!(DrandM$nbrInfo[nIndex].bitMap & GRANT_SENT)) {
  1272.                 DrandM$nbrInfo[nIndex].bitMap |= GRANT_SENT;
  1273.                 }
  1274.               else {
  1275. #line 1273
  1276.                 dup = TRUE;
  1277.                 }
  1278.               if (DrandM$firstGrant) {
  1279.                   DrandM$SClock$getTime(&DrandM$locTime);
  1280.                   rttTime = DrandM$timeDiff(DrandM$locTime, recvGrantPtr->timestamp);
  1281.                   currOTT = (rttTime.mticks * 568.88 + rttTime.sticks * 0.00868) / 2;
  1282.                   DrandM$OTT = (uint16_t )(currOTT * .50 + DrandM$OTT * .50);
  1287.                   DrandM$ROUND_TIME = (DrandM$OTT + DrandM$OTT * DrandM$numOneHop() + DrandM$OTT) * 2;
  1288.                   DrandM$REQUEST_TIME = 2 * DrandM$OTT * 2;
  1289.                   DrandM$firstGrant = FALSE;
  1290.                 }
  1293.               if (DrandM$numGrantsRemaining() == 0 && !DrandM$setMySlot) {
  1294.                   DrandM$setSlot();
  1296.                   DrandM$timeCheck();
  1297.                   DrandM$printNbrInfo();
  1298.                 }
  1299.               else {
  1302.                 if (!dup) {
  1303.                     DrandM$reXTimer$start(TIMER_ONE_SHOT, DrandM$REQUEST_TIME);
  1304.                     DrandM$requestFireCount = 0;
  1305.                   }
  1306.                 }
  1307.             }
  1308.           }
  1309.         }
  1310.     }
  1311. #line 1307
  1312.     __nesc_atomic_end(__nesc_atomic); }
  1313. #line 1305
  1314.   return m;
  1315. }
  1317. static inline  
  1318. #line 1215
  1319. TOS_MsgPtr DrandM$ReceiveTwoHopMsg$receive(TOS_MsgPtr m)
  1320. #line 1215
  1321. {
  1322.   int nIndex;
  1323.   twoHopMsg *recvTwoHopPtr = (twoHopMsg *)m->data;
  1328.   if ((nIndex = DrandM$isPresent(recvTwoHopPtr->sendID, ONE_HOP)) == -1 || 
  1329.   recvTwoHopPtr->slotID == TOS_LOCAL_ADDRESS) {
  1330.     return m;
  1331.     }
  1332. #line 1225
  1333.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1334. #line 1225
  1335.     {
  1336.       if (DrandM$globalState == GRANT_STATE && recvTwoHopPtr->slotID == DrandM$lastReqID) {
  1337.           recvTwoHopPtr->sendID = recvTwoHopPtr->slotID;
  1338.           DrandM$ReceiveReleaseMsg$receive(m);
  1339.         }
  1341.       DrandM$updateNeighborInfo(recvTwoHopPtr->slotID, recvTwoHopPtr->slot);
  1342.     }
  1343. #line 1232
  1344.     __nesc_atomic_end(__nesc_atomic); }
  1345.   return m;
  1346. }
  1348. # 59 "/home/testuser/tinyos-1.x/tos/interfaces/Timer.nc"
  1349. inline static  result_t DrandM$drandRoundTimer$start(char arg_0x85800e0, uint32_t arg_0x8580238){
  1350. #line 59
  1351.   unsigned char result;
  1352. #line 59
  1354. #line 59
  1355.   result = TimerM$Timer$start(2, arg_0x85800e0, arg_0x8580238);
  1356. #line 59
  1358. #line 59
  1359.   return result;
  1360. #line 59
  1361. }
  1362. #line 59
  1363. static inline 
  1364. # 283 "../../tos/system/DrandM.nc"
  1365. void DrandM$initializeGrantSent(void)
  1366. #line 283
  1367. {
  1368.   uint8_t i;
  1370. #line 285
  1371.   for (i = 0; i < MAX_NBR && DrandM$nbrInfo[i].nodeID != 0xFF; i++) 
  1372.     if (DrandM$nbrInfo[i].bitMap & ONE_HOP) {
  1373.       DrandM$nbrInfo[i].bitMap = DrandM$nbrInfo[i].bitMap & ~GRANT_SENT;
  1374.       }
  1375. }
  1377. # 68 "/home/testuser/tinyos-1.x/tos/interfaces/Timer.nc"
  1378. inline static  result_t DrandM$reXTimer$stop(void){
  1379. #line 68
  1380.   unsigned char result;
  1381. #line 68
  1383. #line 68
  1384.   result = TimerM$Timer$stop(1);
  1385. #line 68
  1387. #line 68
  1388.   return result;
  1389. #line 68
  1390. }
  1391. #line 68
  1392. static inline  
  1393. # 1149 "../../tos/system/DrandM.nc"
  1394. TOS_MsgPtr DrandM$ReceiveRejectMsg$receive(TOS_MsgPtr m)
  1395. #line 1149
  1396. {
  1397.   if (DrandM$globalState != REQUEST_STATE) {
  1398. #line 1150
  1399.     return m;
  1400.     }
  1401. #line 1151
  1402.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1403. #line 1151
  1404.     {
  1409.       DrandM$reXTimer$stop();
  1414.       DrandM$sendReleaseMsg(0xFF);
  1415.       DrandM$sentRelease = TRUE;
  1417.       DrandM$initializeGrantSent();
  1418.       DrandM$globalState = IDLE_STATE2;
  1420.       DrandM$reqX = FALSE;
  1422.       DrandM$drandRoundTimer$start(TIMER_ONE_SHOT, 1000);
  1423.     }
  1424. #line 1170
  1425.     __nesc_atomic_end(__nesc_atomic); }
  1429.   return m;
  1430. }
  1432. static inline 
  1433. #line 213
  1434. bool DrandM$checkForRetransGrant(requestMsg *reqMsgPtr)
  1435. #line 213
  1436. {
  1437.   if (DrandM$isPresentHelloID(TOS_LOCAL_ADDRESS, reqMsgPtr->idMap, MAX_NBR) == -1) {
  1438.       return FALSE;
  1439.     }
  1440.   else {
  1441.     return TRUE;
  1442.     }
  1443. }
  1445. # 68 "/home/testuser/tinyos-1.x/tos/interfaces/Timer.nc"
  1446. inline static  result_t DrandM$drandRoundTimer$stop(void){
  1447. #line 68
  1448.   unsigned char result;
  1449. #line 68
  1451. #line 68
  1452.   result = TimerM$Timer$stop(2);
  1453. #line 68
  1455. #line 68
  1456.   return result;
  1457. #line 68
  1458. }
  1459. #line 68
  1460. # 48 "/home/testuser/tinyos-1.x/tos/interfaces/SendMsg.nc"
  1461. inline static  result_t DrandM$SendRejectMsg$send(uint16_t arg_0x857ab18, uint8_t arg_0x857ac60, TOS_MsgPtr arg_0x857adb0){
  1462. #line 48
  1463.   unsigned char result;
  1464. #line 48
  1466. #line 48
  1467.   result = AMStandard$SendMsg$send(AM_REJECT, arg_0x857ab18, arg_0x857ac60, arg_0x857adb0);
  1468. #line 48
  1470. #line 48
  1471.   return result;
  1472. #line 48
  1473. }
  1474. #line 48
  1475. static inline 
  1476. # 648 "../../tos/system/DrandM.nc"
  1477. void DrandM$sendRejectMsg(uint8_t msgADDR)
  1478. #line 648
  1479. {
  1480.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1481. #line 649
  1482.     {
  1483.       if (!DrandM$sendBusy) {
  1484.           rejectMsg *rejectMsgData = (rejectMsg *)DrandM$DataPkt.data;
  1486. #line 652
  1487.           rejectMsgData->sendID = TOS_LOCAL_ADDRESS;
  1489.           rejectMsgData->myState = DrandM$globalState;
  1490.           rejectMsgData->roundNum = DrandM$roundNum;
  1491.           rejectMsgData->lastRequestID = DrandM$lastReqID;
  1493.           if (DrandM$SendRejectMsg$send((uint16_t )msgADDR, sizeof(rejectMsg ), &DrandM$DataPkt) == SUCCESS) {
  1494.               DrandM$sendBusy = TRUE;
  1495.             }
  1496.           else {
  1497.             }
  1498.         }
  1499.     }
  1500. #line 664
  1501.     __nesc_atomic_end(__nesc_atomic); }
  1502. }
  1504. static inline  
  1505. #line 1098
  1506. TOS_MsgPtr DrandM$ReceiveRequestMsg$receive(TOS_MsgPtr m)
  1507. #line 1098
  1508. {
  1509.   uint8_t i;
  1510.   requestMsg *recvRequestPtr = (requestMsg *)m->data;
  1511.   uint16_t reqSentID = recvRequestPtr->sendID;
  1513. #line 1102
  1514.   if (DrandM$isPresent(reqSentID, ONE_HOP) == -1) {
  1515. #line 1102
  1516.     return m;
  1517.     }
  1518. #line 1103
  1519.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1520. #line 1103
  1521.     {
  1522.       DrandM$requestStartTime = recvRequestPtr->timestamp;
  1524.       for (i = 0; i < MAX_NBR && recvRequestPtr->idMap[i] != 0xFF; i++) 
  1525.         if (DrandM$isPresent(recvRequestPtr->idMap[i], ONE_HOP) == -1) {
  1526.           DrandM$addNode(recvRequestPtr->idMap[i], TWO_HOP);
  1527.           }
  1531.       if (reqSentID != DrandM$lastReqID && (DrandM$globalState == GRANT_STATE || 
  1532.       DrandM$globalState == REQUEST_STATE)) {
  1537.           DrandM$sendRejectMsg(reqSentID);
  1538.         }
  1539.       else {
  1541.         if (DrandM$globalState == IDLE_STATE2 || DrandM$setMySlot) {
  1542.             if (!DrandM$setMySlot) {
  1543.               DrandM$drandRoundTimer$stop();
  1544.               }
  1545. #line 1126
  1546.             DrandM$globalState = GRANT_STATE;
  1547.             DrandM$grantFireCount = 0;
  1551.             DrandM$lastReqID = reqSentID;
  1552.             DrandM$GRANT_TIME = (recvRequestPtr->numRemaining * recvRequestPtr->OTT + recvRequestPtr->OTT) * 2;
  1554.             DrandM$reXTimer$start(TIMER_ONE_SHOT, DrandM$randNew() % GRANT_INTERVAL);
  1555.           }
  1556.         else {
  1557. #line 1135
  1558.           if (DrandM$globalState == GRANT_STATE && reqSentID == DrandM$lastReqID) {
  1559.               DrandM$GRANT_TIME = (recvRequestPtr->numRemaining * recvRequestPtr->OTT + recvRequestPtr->OTT) * 2;
  1561.               if (DrandM$checkForRetransGrant(recvRequestPtr)) {
  1562.                   DrandM$reXTimer$start(TIMER_ONE_SHOT, DrandM$randNew() % GRANT_INTERVAL);
  1563.                 }
  1564.               else 
  1565. #line 1140
  1566.                 {
  1567.                   DrandM$reXTimer$start(TIMER_ONE_SHOT, DrandM$GRANT_TIME);
  1568.                   DrandM$grantFireCount = 0;
  1569.                 }
  1570.             }
  1571.           }
  1572.         }
  1573.     }
  1574. #line 1147
  1575.     __nesc_atomic_end(__nesc_atomic); }
  1576. #line 1146
  1577.   return m;
  1578. }
  1580. static inline  
  1581. #line 1017
  1582. TOS_MsgPtr DrandM$ReceiveHelloMsg$receive(TOS_MsgPtr m)
  1583. #line 1017
  1584. {
  1585.   if (DrandM$globalState != HELLO_STATE) {
  1586. #line 1018
  1587.     return m;
  1588.     }
  1589. #line 1019
  1590.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1591. #line 1019
  1592.     {
  1593.       uint8_t PacketOneWayID[MAX_NBR];
  1594. #line 1020
  1595.       uint8_t PacketTwoWayID[MAX_NBR];
  1596.       helloMsg *recvHelloPtr = (helloMsg *)m->data;
  1597.       uint8_t Sender = recvHelloPtr->sendID;
  1598.       uint8_t Me = TOS_LOCAL_ADDRESS;
  1599.       uint8_t i;
  1600. #line 1024
  1601.       uint8_t j;
  1602.       bool SendHelloFlag = FALSE;
  1612.       for (i = 0; i < MAX_NBR; i++) 
  1613.         PacketOneWayID[i] = PacketTwoWayID[i] = 0xFF;
  1615.       for (i = 0; i < recvHelloPtr->OneWayLen; i++) 
  1616.         PacketOneWayID[i] = recvHelloPtr->OneWayId[i];
  1617.       for (j = 0; i < MAX_NBR; i++, j++) 
  1618.         PacketTwoWayID[j] = recvHelloPtr->OneWayId[i];
  1619.       if (DrandM$isPresentHelloID(Me, PacketOneWayID, MAX_NBR) != -1) {
  1620.           if (DrandM$isPresentHelloID(Sender, DrandM$OneWayId, MAX_NBR) != -1) {
  1621.               DrandM$addHelloID(Sender, DrandM$TwoWayId);
  1625.               DrandM$removeHelloID(Sender, DrandM$OneWayId);
  1626.             }
  1627.           else {
  1628. #line 1050
  1629.             if (DrandM$isPresentHelloID(Sender, DrandM$TwoWayId, MAX_NBR) != -1) {
  1630.                 SendHelloFlag = TRUE;
  1631.               }
  1632.             else {
  1633.                 DrandM$addHelloID(Sender, DrandM$TwoWayId);
  1637.                 SendHelloFlag = TRUE;
  1638.               }
  1639.             }
  1640.         }
  1641.       else {
  1642. #line 1061
  1643.         if (DrandM$isPresentHelloID(Me, PacketTwoWayID, MAX_NBR) != -1) {
  1644.             if (DrandM$isPresentHelloID(Sender, DrandM$OneWayId, MAX_NBR) != -1) {
  1645.                 DrandM$addHelloID(Sender, DrandM$TwoWayId);
  1649.                 DrandM$removeHelloID(Sender, DrandM$OneWayId);
  1650.                 SendHelloFlag = TRUE;
  1651.               }
  1652.             else {
  1653. #line 1070
  1654.               if (DrandM$isPresentHelloID(Sender, DrandM$TwoWayId, MAX_NBR) != -1) {
  1655.                 }
  1656.               else {
  1657. #line 1071
  1658.                 if (DrandM$isPresentHelloID(Sender, DrandM$TwoWayId, MAX_NBR) == -1 && 
  1659.                 DrandM$isPresentHelloID(Sender, DrandM$OneWayId, MAX_NBR) == -1) {
  1660.                   }
  1661.                 }
  1662.               }
  1663.           }
  1664.         else {
  1665. #line 1074
  1666.           if (DrandM$isPresentHelloID(Me, PacketOneWayID, MAX_NBR) == -1 && 
  1667.           DrandM$isPresentHelloID(Me, PacketTwoWayID, MAX_NBR) == -1) {
  1668.               if (DrandM$isPresentHelloID(Sender, DrandM$OneWayId, MAX_NBR) == -1) {
  1669.                   DrandM$addHelloID(Sender, DrandM$OneWayId);
  1670.                 }
  1671.               else {
  1672. #line 1079
  1673.                 if (DrandM$isPresentHelloID(Sender, DrandM$OneWayId, MAX_NBR) != -1) {
  1674.                     SendHelloFlag = TRUE;
  1675.                   }
  1676.                 else {
  1677. #line 1082
  1678.                   if (DrandM$isPresentHelloID(Sender, DrandM$TwoWayId, MAX_NBR) != -1) {
  1679.                     }
  1680.                   }
  1681.                 }
  1682.             }
  1683.           }
  1684.         }
  1685. #line 1085
  1686.       if (SendHelloFlag && DrandM$globalState != HELLO_STATE) {
  1687.         DrandM$sendHelloMsg();
  1688.         }
  1689.       for (i = 0; i < MAX_NBR; i++) 
  1690.         if (DrandM$isPresentHelloID(PacketTwoWayID[i], DrandM$TwoWayId, MAX_NBR) == -1) {
  1691.           DrandM$addNode(PacketTwoWayID[i], TWO_HOP);
  1692.           }
  1693.       DrandM$removeNode(recvHelloPtr->sendID, TWO_HOP);
  1694.     }
  1695. #line 1093
  1696.     __nesc_atomic_end(__nesc_atomic); }
  1698.   return m;
  1699. }
  1701. static inline   
  1702. # 242 "/home/testuser/tinyos-1.x/tos/system/AMStandard.nc"
  1703. TOS_MsgPtr AMStandard$ReceiveMsg$default$receive(uint8_t id, TOS_MsgPtr msg)
  1704. #line 242
  1705. {
  1706.   return msg;
  1707. }
  1709. # 75 "/home/testuser/tinyos-1.x/tos/interfaces/ReceiveMsg.nc"
  1710. inline static  TOS_MsgPtr AMStandard$ReceiveMsg$receive(uint8_t arg_0x86aab68, TOS_MsgPtr arg_0x856c0f0){
  1711. #line 75
  1712.   struct TOS_Msg *result;
  1713. #line 75
  1715. #line 75
  1716.   switch (arg_0x86aab68) {
  1717. #line 75
  1718.     case AM_HELLO:
  1719. #line 75
  1720.       result = DrandM$ReceiveHelloMsg$receive(arg_0x856c0f0);
  1721. #line 75
  1722.       break;
  1723. #line 75
  1724.     case AM_REQUEST:
  1725. #line 75
  1726.       result = DrandM$ReceiveRequestMsg$receive(arg_0x856c0f0);
  1727. #line 75
  1728.       break;
  1729. #line 75
  1730.     case AM_GRANT:
  1731. #line 75
  1732.       result = DrandM$ReceiveGrantMsg$receive(arg_0x856c0f0);
  1733. #line 75
  1734.       break;
  1735. #line 75
  1736.     case AM_RELEASE:
  1737. #line 75
  1738.       result = DrandM$ReceiveReleaseMsg$receive(arg_0x856c0f0);
  1739. #line 75
  1740.       break;
  1741. #line 75
  1742.     case AM_REJECT:
  1743. #line 75
  1744.       result = DrandM$ReceiveRejectMsg$receive(arg_0x856c0f0);
  1745. #line 75
  1746.       break;
  1747. #line 75
  1748.     case AM_TWOHOP:
  1749. #line 75
  1750.       result = DrandM$ReceiveTwoHopMsg$receive(arg_0x856c0f0);
  1751. #line 75
  1752.       break;
  1753. #line 75
  1754.     case AM_REPORT:
  1755. #line 75
  1756.       result = DrandM$ReceiveReportMsg$receive(arg_0x856c0f0);
  1757. #line 75
  1758.       break;
  1759. #line 75
  1760.     case AM_FRAME:
  1761. #line 75
  1762.       result = DrandM$ReceiveFrameMsg$receive(arg_0x856c0f0);
  1763. #line 75
  1764.       break;
  1765. #line 75
  1766.     default:
  1767. #line 75
  1768.       result = AMStandard$ReceiveMsg$default$receive(arg_0x86aab68, arg_0x856c0f0);
  1769. #line 75
  1770.     }
  1771. #line 75
  1773. #line 75
  1774.   return result;
  1775. #line 75
  1776. }
  1777. #line 75
  1778. # 48 "/home/testuser/tinyos-1.x/tos/interfaces/SendMsg.nc"
  1779. inline static  result_t DrandM$SendHelloMsg$send(uint16_t arg_0x857ab18, uint8_t arg_0x857ac60, TOS_MsgPtr arg_0x857adb0){
  1780. #line 48
  1781.   unsigned char result;
  1782. #line 48
  1784. #line 48
  1785.   result = AMStandard$SendMsg$send(AM_HELLO, arg_0x857ab18, arg_0x857ac60, arg_0x857adb0);
  1786. #line 48
  1788. #line 48
  1789.   return result;
  1790. #line 48
  1791. }
  1792. #line 48
  1793. # 58 "/home/testuser/tinyos-1.x/tos/interfaces/BareSendMsg.nc"
  1794. inline static  result_t AMStandard$RadioSend$send(TOS_MsgPtr arg_0x86be870){
  1795. #line 58
  1796.   unsigned char result;
  1797. #line 58
  1799. #line 58
  1800.   result = CC1000RadioIntM$Send$send(arg_0x86be870);
  1801. #line 58
  1803. #line 58
  1804.   return result;
  1805. #line 58
  1806. }
  1807. #line 58
  1808. static inline  
  1809. # 306 "/home/testuser/tinyos-1.x/tos/system/FramerM.nc"
  1810. result_t FramerM$BareSendMsg$send(TOS_MsgPtr pMsg)
  1811. #line 306
  1812. {
  1813.   result_t Result = SUCCESS;
  1815.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1816. #line 309
  1817.     {
  1818.       if (!(FramerM$gFlags & FramerM$FLAGS_DATAPEND)) {
  1819.           FramerM$gFlags |= FramerM$FLAGS_DATAPEND;
  1820.           FramerM$gpTxMsg = pMsg;
  1821.         }
  1822.       else 
  1824.         {
  1825.           Result = FAIL;
  1826.         }
  1827.     }
  1828. #line 319
  1829.     __nesc_atomic_end(__nesc_atomic); }
  1831.   if (Result == SUCCESS) {
  1832.       Result = FramerM$StartTx();
  1833.     }
  1835.   return Result;
  1836. }
  1838. # 58 "/home/testuser/tinyos-1.x/tos/interfaces/BareSendMsg.nc"
  1839. inline static  result_t AMStandard$UARTSend$send(TOS_MsgPtr arg_0x86be870){
  1840. #line 58
  1841.   unsigned char result;
  1842. #line 58
  1844. #line 58
  1845.   result = FramerM$BareSendMsg$send(arg_0x86be870);
  1846. #line 58
  1848. #line 58
  1849.   return result;
  1850. #line 58
  1851. }
  1852. #line 58
  1853. static inline  
  1854. # 165 "/home/testuser/tinyos-1.x/tos/system/AMStandard.nc"
  1855. void AMStandard$sendTask(void)
  1856. #line 165
  1857. {
  1858.   result_t ok;
  1859.   TOS_MsgPtr buf;
  1861. #line 168
  1862.   buf = AMStandard$buffer;
  1863.   if (buf->addr == TOS_UART_ADDR) {
  1864.     ok = AMStandard$UARTSend$send(buf);
  1865.     }
  1866.   else {
  1867. #line 172
  1868.     ok = AMStandard$RadioSend$send(buf);
  1869.     }
  1870.   if (ok == FAIL) {
  1871.     AMStandard$reportSendDone(AMStandard$buffer, FAIL);
  1872.     }
  1873. }
  1875. static inline   
  1876. # 105 "../../tos/platform/mica2/HPLUART0M.nc"
  1877. result_t HPLUART0M$UART$put(uint8_t data)
  1878. #line 105
  1879. {
  1880.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1881. #line 106
  1882.     {
  1883.       * (volatile uint8_t *)(0x0C + 0x20) = data;
  1884.       * (volatile uint8_t *)(0x0B + 0x20) |= 1 << 6;
  1885.     }
  1886. #line 109
  1887.     __nesc_atomic_end(__nesc_atomic); }
  1889.   return SUCCESS;
  1890. }
  1892. # 80 "/home/testuser/tinyos-1.x/tos/interfaces/HPLUART.nc"
  1893. inline static   result_t UARTM$HPLUART$put(uint8_t arg_0x89be300){
  1894. #line 80
  1895.   unsigned char result;
  1896. #line 80
  1898. #line 80
  1899.   result = HPLUART0M$UART$put(arg_0x89be300);
  1900. #line 80
  1902. #line 80
  1903.   return result;
  1904. #line 80
  1905. }
  1906. #line 80
  1907. static inline  
  1908. # 207 "/home/testuser/tinyos-1.x/tos/system/AMStandard.nc"
  1909. result_t AMStandard$UARTSend$sendDone(TOS_MsgPtr msg, result_t success)
  1910. #line 207
  1911. {
  1912.   return AMStandard$reportSendDone(msg, success);
  1913. }
  1915. # 67 "/home/testuser/tinyos-1.x/tos/interfaces/BareSendMsg.nc"
  1916. inline static  result_t FramerM$BareSendMsg$sendDone(TOS_MsgPtr arg_0x86bed88, result_t arg_0x86beed8){
  1917. #line 67
  1918.   unsigned char result;
  1919. #line 67
  1921. #line 67
  1922.   result = AMStandard$UARTSend$sendDone(arg_0x86bed88, arg_0x86beed8);
  1923. #line 67
  1925. #line 67
  1926.   return result;
  1927. #line 67
  1928. }
  1929. #line 67
  1930. static inline  
  1931. # 1002 "../../tos/system/DrandM.nc"
  1932. result_t DrandM$SendFrameMsg$sendDone(TOS_MsgPtr msg, result_t success)
  1933. #line 1002
  1934. {
  1935.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1936. #line 1003
  1937.     {
  1938.       if (DrandM$sendBusy) {
  1939.           DrandM$sendBusy = FALSE;
  1940.         }
  1945.       if (DrandM$globalState == FRAME_STATE) {
  1946.         DrandM$reXTimer$start(TIMER_ONE_SHOT, FRAME_XPERIOD + DrandM$randNew() % FRAME_INTERVAL);
  1947.         }
  1948.     }
  1949. #line 1014
  1950.     __nesc_atomic_end(__nesc_atomic); }
  1951. #line 1014
  1952.   return SUCCESS;
  1953. }
  1955. static inline  
  1956. #line 984
  1957. result_t DrandM$SendReportMsg$sendDone(TOS_MsgPtr msg, result_t success)
  1958. #line 984
  1959. {
  1960.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1961. #line 985
  1962.     {
  1966.       if (DrandM$sendBusy) {
  1967.           DrandM$sendBusy = FALSE;
  1968.         }
  1973.       if (DrandM$globalState == REPORT_STATE) {
  1974.         DrandM$reXTimer$start(TIMER_ONE_SHOT, REPORT_XPERIOD + DrandM$randNew() % REPORT_INTERVAL);
  1975.         }
  1976.     }
  1977. #line 999
  1978.     __nesc_atomic_end(__nesc_atomic); }
  1979. #line 999
  1980.   return SUCCESS;
  1981. }
  1983. static inline  
  1984. #line 954
  1985. result_t DrandM$SendGrantMsg$sendDone(TOS_MsgPtr msg, result_t success)
  1986. #line 954
  1987. {
  1988.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1989. #line 955
  1990.     {
  1991.       if (DrandM$sendBusy) {
  1992.           DrandM$sendBusy = FALSE;
  1996.           if (success == FAIL) {
  1997.             }
  1998.           else 
  2000.             {
  2002.               if (DrandM$graX) {
  2003. #line 967
  2004.                 DrandM$graXCount++;
  2005.                 }
  2006.               else {
  2007. #line 968
  2008.                 if (!DrandM$graX) {
  2009. #line 968
  2010.                   DrandM$graX = TRUE;
  2011.                   }
  2012.                 }
  2013. #line 969
  2014.               DrandM$graCount++;
  2015.               DrandM$grantFireCount++;
  2016.             }
  2017.         }
  2023.       if (DrandM$globalState == GRANT_STATE) {
  2024.         DrandM$reXTimer$start(TIMER_ONE_SHOT, DrandM$GRANT_TIME);
  2025.         }
  2026.     }
  2027. #line 981
  2028.     __nesc_atomic_end(__nesc_atomic); }
  2029. #line 981
  2030.   return SUCCESS;
  2031. }
  2033. static inline  
  2034. #line 932
  2035. result_t DrandM$SendTwoHopMsg$sendDone(TOS_MsgPtr msg, result_t success)
  2036. #line 932
  2037. {
  2038.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  2039. #line 933
  2040.     {
  2041.       if (DrandM$sendBusy) {
  2042.           DrandM$sendBusy = FALSE;
  2043.           if (success == SUCCESS) {
  2049.               DrandM$twoCount++;
  2050.             }
  2051.           else {
  2052.             }
  2053.         }
  2054.     }
  2055. #line 947
  2056.     __nesc_atomic_end(__nesc_atomic); }
  2060.   return SUCCESS;
  2061. }
  2063. static inline  
  2064. #line 910
  2065. result_t DrandM$SendReleaseMsg$sendDone(TOS_MsgPtr msg, result_t success)
  2066. #line 910
  2067. {
  2068.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  2069. #line 911
  2070.     {
  2071.       if (DrandM$sendBusy) {
  2072.           DrandM$sendBusy = FALSE;
  2073.           if (success == SUCCESS) {
  2075.               DrandM$relCount++;
  2076.             }
  2077.           else 
  2081.             {
  2082.             }
  2083.         }
  2084.     }
  2085. #line 925
  2086.     __nesc_atomic_end(__nesc_atomic); }
  2090.   return SUCCESS;
  2091. }
  2093. static inline  
  2094. #line 886
  2095. result_t DrandM$SendRejectMsg$sendDone(TOS_MsgPtr msg, result_t success)
  2096. #line 886
  2097. {
  2098.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  2099. #line 887
  2100.     {
  2101.       if (DrandM$sendBusy) {
  2102.           DrandM$sendBusy = FALSE;
  2106.           if (success == SUCCESS) {
  2111.               DrandM$rejCount++;
  2112.             }
  2113.           else {
  2114.             }
  2115.         }
  2116.     }
  2117. #line 903
  2118.     __nesc_atomic_end(__nesc_atomic); }
  2122.   return SUCCESS;
  2123. }
  2125. static inline  
  2126. #line 856
  2127. result_t DrandM$SendRequestMsg$sendDone(TOS_MsgPtr msg, result_t success)
  2128. #line 856
  2129. {
  2130.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  2131. #line 857
  2132.     {
  2133.       if (DrandM$sendBusy) {
  2134.           DrandM$sendBusy = FALSE;
  2138.           if (success == FAIL) {
  2139.             }
  2140.           else 
  2142.             {
  2144.               if (DrandM$reqX) {
  2145. #line 869
  2146.                 DrandM$reqXCount++;
  2147.                 }
  2148.               else {
  2149. #line 870
  2150.                 if (!DrandM$reqX) {
  2151. #line 870
  2152.                   DrandM$reqX = TRUE;
  2153.                   }
  2154.                 }
  2155. #line 871
  2156.               DrandM$reqCount++;
  2158.               DrandM$requestFireCount++;
  2159.             }
  2164.           if (DrandM$globalState == REQUEST_STATE) {
  2165.             DrandM$reXTimer$start(TIMER_ONE_SHOT, DrandM$REQUEST_TIME);
  2166.             }
  2167.         }
  2168.     }
  2169. #line 883
  2170.     __nesc_atomic_end(__nesc_atomic); }
  2171. #line 883
  2172.   return SUCCESS;
  2173. }
  2175. static inline  
  2176. #line 842
  2177. result_t DrandM$SendHelloMsg$sendDone(TOS_MsgPtr msg, result_t success)
  2178. #line 842
  2179. {
  2180.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  2181. #line 843
  2182.     {
  2183.       if (DrandM$sendBusy) {
  2184.           DrandM$sendBusy = FALSE;
  2188.           if (DrandM$globalState == HELLO_STATE) {
  2189.             DrandM$reXTimer$start(TIMER_ONE_SHOT, DrandM$randNew() % HELLO_INTERVAL);
  2190.             }
  2191.         }
  2192.     }
  2193. #line 853
  2194.     __nesc_atomic_end(__nesc_atomic); }
  2195. #line 853
  2196.   return SUCCESS;
  2197. }
  2199. static inline   
  2200. # 157 "/home/testuser/tinyos-1.x/tos/system/AMStandard.nc"
  2201. result_t AMStandard$SendMsg$default$sendDone(uint8_t id, TOS_MsgPtr msg, result_t success)
  2202. #line 157
  2203. {
  2204.   return SUCCESS;
  2205. }
  2207. # 49 "/home/testuser/tinyos-1.x/tos/interfaces/SendMsg.nc"
  2208. inline static  result_t AMStandard$SendMsg$sendDone(uint8_t arg_0x86aa5b0, TOS_MsgPtr arg_0x857b1d0, result_t arg_0x857b320){
  2209. #line 49
  2210.   unsigned char result;
  2211. #line 49
  2213. #line 49
  2214.   switch (arg_0x86aa5b0) {
  2215. #line 49
  2216.     case AM_HELLO:
  2217. #line 49
  2218.       result = DrandM$SendHelloMsg$sendDone(arg_0x857b1d0, arg_0x857b320);
  2219. #line 49
  2220.       break;
  2221. #line 49
  2222.     case AM_REQUEST:
  2223. #line 49
  2224.       result = DrandM$SendRequestMsg$sendDone(arg_0x857b1d0, arg_0x857b320);
  2225. #line 49
  2226.       break;
  2227. #line 49
  2228.     case AM_GRANT:
  2229. #line 49
  2230.       result = DrandM$SendGrantMsg$sendDone(arg_0x857b1d0, arg_0x857b320);
  2231. #line 49
  2232.       break;
  2233. #line 49
  2234.     case AM_RELEASE:
  2235. #line 49
  2236.       result = DrandM$SendReleaseMsg$sendDone(arg_0x857b1d0, arg_0x857b320);
  2237. #line 49
  2238.       break;
  2239. #line 49
  2240.     case AM_REJECT:
  2241. #line 49
  2242.       result = DrandM$SendRejectMsg$sendDone(arg_0x857b1d0, arg_0x857b320);
  2243. #line 49
  2244.       break;
  2245. #line 49
  2246.     case AM_TWOHOP:
  2247. #line 49
  2248.       result = DrandM$SendTwoHopMsg$sendDone(arg_0x857b1d0, arg_0x857b320);
  2249. #line 49
  2250.       break;
  2251. #line 49
  2252.     case AM_REPORT:
  2253. #line 49
  2254.       result = DrandM$SendReportMsg$sendDone(arg_0x857b1d0, arg_0x857b320);
  2255. #line 49
  2256.       break;
  2257. #line 49
  2258.     case AM_FRAME:
  2259. #line 49
  2260.       result = DrandM$SendFrameMsg$sendDone(arg_0x857b1d0, arg_0x857b320);
  2261. #line 49
  2262.       break;
  2263. #line 49
  2264.     default:
  2265. #line 49
  2266.       result = AMStandard$SendMsg$default$sendDone(arg_0x86aa5b0, arg_0x857b1d0, arg_0x857b320);
  2267. #line 49
  2268.     }
  2269. #line 49
  2271. #line 49
  2272.   return result;
  2273. #line 49
  2274. }
  2275. #line 49
  2276. static inline   
  2277. # 160 "/home/testuser/tinyos-1.x/tos/system/AMStandard.nc"
  2278. result_t AMStandard$default$sendDone(void)
  2279. #line 160
  2280. {
  2281.   return SUCCESS;
  2282. }
  2284. #line 65
  2285. inline static  result_t AMStandard$sendDone(void){
  2286. #line 65
  2287.   unsigned char result;
  2288. #line 65
  2290. #line 65
  2291.   result = AMStandard$default$sendDone();
  2292. #line 65
  2294. #line 65
  2295.   return result;
  2296. #line 65
  2297. }
  2298. #line 65
  2299. # 63 "/home/testuser/tinyos-1.x/tos/interfaces/Random.nc"
  2300. inline static   uint16_t CC1000RadioIntM$Random$rand(void){
  2301. #line 63
  2302.   unsigned int result;
  2303. #line 63
  2305. #line 63
  2306.   result = RandomLFSR$Random$rand();
  2307. #line 63
  2309. #line 63
  2310.   return result;
  2311. #line 63
  2312. }
  2313. #line 63
  2314. static inline    
  2315. # 1796 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  2316. int16_t CC1000RadioIntM$MacBackoff$default$initialBackoff(TOS_MsgPtr m)
  2317. #line 1796
  2318. {
  2319.   return (CC1000RadioIntM$Random$rand() & 0x1F) + 1;
  2320. }
  2322. # 39 "../../tos/platform/mica2/MacBackoff.nc"
  2323. inline static   int16_t CC1000RadioIntM$MacBackoff$initialBackoff(TOS_MsgPtr arg_0x86d6c88){
  2324. #line 39
  2325.   int result;
  2326. #line 39
  2328. #line 39
  2329.   result = CC1000RadioIntM$MacBackoff$default$initialBackoff(arg_0x86d6c88);
  2330. #line 39
  2332. #line 39
  2333.   return result;
  2334. #line 39
  2335. }
  2336. #line 39
  2337. static inline 
  2338. # 245 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  2339. uint16_t CC1000RadioIntM$getOwnerBackoff(void)
  2340. #line 245
  2341. {
  2342.   return (CC1000RadioIntM$Random$rand() & (8 - 1)) + 1;
  2343. }
  2345. static inline uint16_t CC1000RadioIntM$getNonOwnerBackoff(void)
  2346. #line 249
  2347. {
  2348.   return (CC1000RadioIntM$Random$rand() & (32 - 1)) + 8 + 1;
  2349. }
  2351. # 68 "/home/testuser/tinyos-1.x/tos/interfaces/Timer.nc"
  2352. inline static  result_t CC1000RadioIntM$WakeupTimer$stop(void){
  2353. #line 68
  2354.   unsigned char result;
  2355. #line 68
  2357. #line 68
  2358.   result = TimerM$Timer$stop(5);
  2359. #line 68
  2361. #line 68
  2362.   return result;
  2363. #line 68
  2364. }
  2365. #line 68
  2366. # 48 "/home/testuser/tinyos-1.x/tos/interfaces/SendMsg.nc"
  2367. inline static  result_t DrandM$SendReleaseMsg$send(uint16_t arg_0x857ab18, uint8_t arg_0x857ac60, TOS_MsgPtr arg_0x857adb0){
  2368. #line 48
  2369.   unsigned char result;
  2370. #line 48
  2372. #line 48
  2373.   result = AMStandard$SendMsg$send(AM_RELEASE, arg_0x857ab18, arg_0x857ac60, arg_0x857adb0);
  2374. #line 48
  2376. #line 48
  2377.   return result;
  2378. #line 48
  2379. }
  2380. #line 48
  2381. # 48 "/home/testuser/tinyos-1.x/tos/interfaces/SendMsg.nc"
  2382. inline static  result_t DrandM$SendTwoHopMsg$send(uint16_t arg_0x857ab18, uint8_t arg_0x857ac60, TOS_MsgPtr arg_0x857adb0){
  2383. #line 48
  2384.   unsigned char result;
  2385. #line 48
  2387. #line 48
  2388.   result = AMStandard$SendMsg$send(AM_TWOHOP, arg_0x857ab18, arg_0x857ac60, arg_0x857adb0);
  2389. #line 48
  2391. #line 48
  2392.   return result;
  2393. #line 48
  2394. }
  2395. #line 48
  2396. static inline 
  2397. # 738 "../../tos/system/DrandM.nc"
  2398. void DrandM$sendTwoHopMsg(uint8_t slot, uint8_t sendID)
  2399. #line 738
  2400. {
  2401.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  2402. #line 739
  2403.     {
  2404.       if (!DrandM$sendBusy) {
  2405.           twoHopMsg *twoHopMsgData = (twoHopMsg *)DrandM$DataPkt.data;
  2407. #line 742
  2408.           twoHopMsgData->sendID = TOS_LOCAL_ADDRESS;
  2409.           twoHopMsgData->slotID = sendID;
  2410.           twoHopMsgData->slot = slot;
  2412.           twoHopMsgData->myState = DrandM$globalState;
  2413.           twoHopMsgData->roundNum = DrandM$roundNum;
  2414.           twoHopMsgData->lastRequestID = DrandM$lastReqID;
  2416.           if (DrandM$SendTwoHopMsg$send(TOS_BCAST_ADDR, sizeof(twoHopMsg ), &DrandM$DataPkt) == SUCCESS) {
  2417.               DrandM$sendBusy = TRUE;
  2418.             }
  2419.           else 
  2420. #line 752
  2421.             {
  2422.             }
  2423.         }
  2424.     }
  2425. #line 755
  2426.     __nesc_atomic_end(__nesc_atomic); }
  2427. }
  2429. static inline 
  2430. #line 221
  2431. bool DrandM$checkForRetransReport(void)
  2432. #line 221
  2433. {
  2434.   uint8_t i;
  2436. #line 223
  2437.   for (i = 0; i < MAX_NBR && DrandM$nbrInfo[i].nodeID != 0xFF; i++) 
  2438.     if (DrandM$nbrInfo[i].slot == 0xFF) {
  2442.         return TRUE;
  2443.       }
  2444.   return FALSE;
  2445. }
  2447. static inline 
  2448. #line 355
  2449. void DrandM$fillTimeSlotInfoForReport(uint8_t *array)
  2450. #line 355
  2451. {
  2452.   uint8_t i;
  2454. #line 357
  2455.   for (i = 0; i < MAX_NBR; i++) 
  2456.     array[i] = 0xFF;
  2457.   for (i = 0; i < MAX_NBR && DrandM$nbrInfo[i].nodeID != 0xFF; i++) 
  2458.     if (DrandM$nbrInfo[i].slot != 0xFF) {
  2459.       array[DrandM$nbrInfo[i].slot] = DrandM$nbrInfo[i].nodeID;
  2460.       }
  2461. #line 362
  2462.   if (DrandM$setMySlot) {
  2463.     array[DrandM$myInfo.slot] = TOS_LOCAL_ADDRESS;
  2464.     }
  2465. }
  2467. # 48 "/home/testuser/tinyos-1.x/tos/interfaces/SendMsg.nc"
  2468. inline static  result_t DrandM$SendReportMsg$send(uint16_t arg_0x857ab18, uint8_t arg_0x857ac60, TOS_MsgPtr arg_0x857adb0){
  2469. #line 48
  2470.   unsigned char result;
  2471. #line 48
  2473. #line 48
  2474.   result = AMStandard$SendMsg$send(AM_REPORT, arg_0x857ab18, arg_0x857ac60, arg_0x857adb0);
  2475. #line 48
  2477. #line 48
  2478.   return result;
  2479. #line 48
  2480. }
  2481. #line 48
  2482. static inline 
  2483. # 454 "../../tos/system/DrandM.nc"
  2484. void DrandM$removeNodesForFrame(void)
  2485. #line 454
  2486. {
  2487.   int i;
  2489. #line 456
  2490.   for (i = MAX_NBR - 1; i >= 0; i--) {
  2491.       if (DrandM$nbrInfo[i].nodeID == 0xFF) {
  2492.         continue;
  2493.         }
  2494.       else {
  2495. #line 459
  2496.         if (DrandM$nbrInfo[i].frame == 0xFF) {
  2498.             {
  2499. #line 461
  2500.               char bStatus;
  2502. #line 461
  2503.               if (DBG_USR2 != 0) {
  2504. #line 461
  2505.                   bStatus = * (volatile uint8_t *)(uint16_t )& * (volatile uint8_t *)(0x3F + 0x20) & (1 << 7);
  2506. #line 461
  2507.                    __asm volatile ("cli");DrandM$sprintf(DrandM$debugbuf, "RemoveNodesForFrame: Removed node %un", DrandM$nbrInfo[i].nodeID);
  2508. #line 461
  2509.                   DrandM$writedebug();
  2510. #line 461
  2511.                   if (bStatus) {
  2512. #line 461
  2513.                      __asm volatile ("sei");
  2514.                     }
  2515.                 }
  2516.             }
  2517. #line 461
  2518.             ;
  2520.             DrandM$removeNode(DrandM$nbrInfo[i].nodeID, DrandM$nbrInfo[i].bitMap);
  2521.           }
  2522.         }
  2523.     }
  2524. }
  2526. static inline 
  2527. #line 233
  2528. bool DrandM$checkForRetransFrame(void)
  2529. #line 233
  2530. {
  2531.   uint8_t i;
  2533. #line 235
  2534.   for (i = 0; i < MAX_NBR && DrandM$nbrInfo[i].nodeID != 0xFF; i++) 
  2535.     if (DrandM$nbrInfo[i].frame == 0xFF) {
  2539.         return TRUE;
  2540.       }
  2541.   return FALSE;
  2542. }
  2544. static inline   
  2545. # 32 "TestBedTopologyM.nc"
  2546. void TestBedTopologyM$Drand$gotFrame(void)
  2547. #line 32
  2548. {
  2549. }
  2551. # 5 "../../tos/interfaces/Drand.nc"
  2552. inline static   void DrandM$Drand$gotFrame(void){
  2553. #line 5
  2554.   TestBedTopologyM$Drand$gotFrame();
  2555. #line 5
  2556. }
  2557. #line 5
  2558. static inline 
  2559. # 341 "../../tos/system/DrandM.nc"
  2560. void DrandM$fillFrameInfo(frameMsg *pkt)
  2561. #line 341
  2562. {
  2563.   uint8_t i;
  2564. #line 342
  2565.   uint8_t j;
  2567. #line 343
  2568.   for (i = 0; i < MAX_ONE_HOP; i++) {
  2569.       pkt->oneHopNodeID[i] = 0xFF;
  2570.       pkt->frameArray[i] = 0xFF;
  2571.     }
  2572.   for (i = 0, j = 0; i < MAX_NBR && DrandM$nbrInfo[i].nodeID != 0xFF; i++) 
  2573.     if (DrandM$nbrInfo[i].bitMap & ONE_HOP && DrandM$nbrInfo[i].frame != 0xFF) {
  2574.         pkt->oneHopNodeID[j] = DrandM$nbrInfo[i].nodeID;
  2575.         pkt->frameArray[j] = DrandM$nbrInfo[i].frame;
  2576.         j++;
  2577.       }
  2578. }
  2580. # 48 "/home/testuser/tinyos-1.x/tos/interfaces/SendMsg.nc"
  2581. inline static  result_t DrandM$SendFrameMsg$send(uint16_t arg_0x857ab18, uint8_t arg_0x857ac60, TOS_MsgPtr arg_0x857adb0){
  2582. #line 48
  2583.   unsigned char result;
  2584. #line 48
  2586. #line 48
  2587.   result = AMStandard$SendMsg$send(AM_FRAME, arg_0x857ab18, arg_0x857ac60, arg_0x857adb0);
  2588. #line 48
  2590. #line 48
  2591.   return result;
  2592. #line 48
  2593. }
  2594. #line 48
  2595. # 37 "../../tos/platform/mica2/SpiByteFifo.nc"
  2596. inline static   result_t CC1000RadioIntM$SpiByteFifo$disableIntr(void){
  2597. #line 37
  2598.   unsigned char result;
  2599. #line 37
  2601. #line 37
  2602.   result = HPLSpiM$SpiByteFifo$disableIntr();
  2603. #line 37
  2605. #line 37
  2606.   return result;
  2607. #line 37
  2608. }
  2609. #line 37
  2610. static inline  
  2611. # 1606 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  2612. void CC1000RadioIntM$SleepTimerTask(void)
  2613. #line 1606
  2614. {
  2615.   CC1000RadioIntM$WakeupTimer$start(TIMER_ONE_SHOT, CC1000RadioIntM$sleeptime);
  2616. }
  2618. static inline  
  2619. # 469 "../../tos/platform/mica2/CC1000ControlM.nc"
  2620. result_t CC1000ControlM$StdControl$stop(void)
  2621. #line 469
  2622. {
  2624.   CC1000ControlM$HPLChipcon$write(0x00, (((((
  2625.   1 << 5) | (1 << 4)) | (
  2626.   1 << 3)) | (1 << 2)) | (1 << 1)) | (
  2627.   1 << 0));
  2629.   CC1000ControlM$HPLChipcon$write(0x0B, 0x00);
  2630.   return SUCCESS;
  2631. }
  2633. # 78 "/home/testuser/tinyos-1.x/tos/interfaces/StdControl.nc"
  2634. inline static  result_t CC1000RadioIntM$CC1000StdControl$stop(void){
  2635. #line 78
  2636.   unsigned char result;
  2637. #line 78
  2639. #line 78
  2640.   result = CC1000ControlM$StdControl$stop();
  2641. #line 78
  2643. #line 78
  2644.   return result;
  2645. #line 78
  2646. }
  2647. #line 78
  2648. static inline   
  2649. # 222 "../../tos/platform/mica2/ADCREFM.nc"
  2650. result_t ADCREFM$ADC$getData(uint8_t port)
  2651. #line 222
  2652. {
  2653.   result_t Result;
  2655. #line 224
  2656.   if (port > TOSH_ADC_PORTMAPSIZE) {
  2657.       return FAIL;
  2658.     }
  2660.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  2661. #line 228
  2662.     {
  2663.       Result = ADCREFM$startGet(port);
  2664.     }
  2665. #line 230
  2666.     __nesc_atomic_end(__nesc_atomic); }
  2667.   return Result;
  2668. }
  2670. # 52 "/home/testuser/tinyos-1.x/tos/interfaces/ADC.nc"
  2671. inline static   result_t CC1000RadioIntM$RSSIADC$getData(void){
  2672. #line 52
  2673.   unsigned char result;
  2674. #line 52
  2676. #line 52
  2677.   result = ADCREFM$ADC$getData(TOS_ADC_CC_RSSI_PORT);
  2678. #line 52
  2680. #line 52
  2681.   return result;
  2682. #line 52
  2683. }
  2684. #line 52
  2685. static inline   
  2686. # 1724 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  2687. uint16_t CC1000RadioIntM$GetSquelch(void)
  2688. #line 1724
  2689. {
  2690.   return CC1000RadioIntM$usSquelchVal;
  2691. }
  2693. static inline    
  2694. #line 1800
  2695. int16_t CC1000RadioIntM$MacBackoff$default$congestionBackoff(TOS_MsgPtr m)
  2696. #line 1800
  2697. {
  2698.   CC1000RadioIntM$congBackOffs++;
  2699.   return (CC1000RadioIntM$Random$rand() & 0xF) + 1;
  2700. }
  2702. # 40 "../../tos/platform/mica2/MacBackoff.nc"
  2703. inline static   int16_t CC1000RadioIntM$MacBackoff$congestionBackoff(TOS_MsgPtr arg_0x86d70b0){
  2704. #line 40
  2705.   int result;
  2706. #line 40
  2708. #line 40
  2709.   result = CC1000RadioIntM$MacBackoff$default$congestionBackoff(arg_0x86d70b0);
  2710. #line 40
  2712. #line 40
  2713.   return result;
  2714. #line 40
  2715. }
  2716. #line 40
  2717. # 143 "../../tos/platform/mica2/hardware.h"
  2718. static __inline void TOSH_MAKE_MOSI_OUTPUT(void)
  2719. #line 143
  2720. {
  2721. #line 143
  2722.   * (volatile uint8_t *)(0x17 + 0x20) |= 1 << 2;
  2723. }
  2725. #line 144
  2726. static __inline void TOSH_MAKE_MISO_OUTPUT(void)
  2727. #line 144
  2728. {
  2729. #line 144
  2730.   * (volatile uint8_t *)(0x17 + 0x20) |= 1 << 3;
  2731. }
  2733. static inline   
  2734. # 103 "../../tos/platform/mica2/HPLSpiM.nc"
  2735. result_t HPLSpiM$SpiByteFifo$txMode(void)
  2736. #line 103
  2737. {
  2738.   TOSH_MAKE_MISO_OUTPUT();
  2739.   TOSH_MAKE_MOSI_OUTPUT();
  2740.   return SUCCESS;
  2741. }
  2743. # 39 "../../tos/platform/mica2/SpiByteFifo.nc"
  2744. inline static   result_t CC1000RadioIntM$SpiByteFifo$txMode(void){
  2745. #line 39
  2746.   unsigned char result;
  2747. #line 39
  2749. #line 39
  2750.   result = HPLSpiM$SpiByteFifo$txMode();
  2751. #line 39
  2753. #line 39
  2754.   return result;
  2755. #line 39
  2756. }
  2757. #line 39
  2758. # 108 "../../tos/platform/mica2/CC1000Control.nc"
  2759. inline static   result_t CC1000RadioIntM$CC1000Control$TxMode(void){
  2760. #line 108
  2761.   unsigned char result;
  2762. #line 108
  2764. #line 108
  2765.   result = CC1000ControlM$CC1000Control$TxMode();
  2766. #line 108
  2768. #line 108
  2769.   return result;
  2770. #line 108
  2771. }
  2772. #line 108
  2773. static inline   
  2774. # 59 "../../tos/platform/mica2/HPLSpiM.nc"
  2775. result_t HPLSpiM$SpiByteFifo$writeByte(uint8_t data)
  2776. #line 59
  2777. {
  2780.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  2781. #line 62
  2782.     HPLSpiM$OutgoingByte = data;
  2783. #line 62
  2784.     __nesc_atomic_end(__nesc_atomic); }
  2785.   return SUCCESS;
  2786. }
  2788. # 33 "../../tos/platform/mica2/SpiByteFifo.nc"
  2789. inline static   result_t CC1000RadioIntM$SpiByteFifo$writeByte(uint8_t arg_0x86fbd50){
  2790. #line 33
  2791.   unsigned char result;
  2792. #line 33
  2794. #line 33
  2795.   result = HPLSpiM$SpiByteFifo$writeByte(arg_0x86fbd50);
  2796. #line 33
  2798. #line 33
  2799.   return result;
  2800. #line 33
  2801. }
  2802. #line 33
  2803. static inline   
  2804. # 1610 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  2805. result_t CC1000RadioIntM$RSSIADC$dataReady(uint16_t data)
  2806. #line 1610
  2807. {
  2808.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  2809. #line 1611
  2810.     {
  2811.       uint8_t currentRadioState;
  2813.       currentRadioState = CC1000RadioIntM$RadioState;
  2815.       switch (currentRadioState) {
  2816.           case CC1000RadioIntM$IDLE_STATE: 
  2817.             if (CC1000RadioIntM$RSSIInitState == CC1000RadioIntM$IDLE_STATE) {
  2818.                 CC1000RadioIntM$usTempSquelch = data;
  2819.                 TOS_post(CC1000RadioIntM$adjustSquelch);
  2820.               }
  2821.           CC1000RadioIntM$RSSIInitState = CC1000RadioIntM$NULL_STATE;
  2822.           break;
  2824.           case CC1000RadioIntM$RX_STATE: 
  2825.             if (CC1000RadioIntM$RSSIInitState == CC1000RadioIntM$RX_STATE) {
  2826.                 CC1000RadioIntM$usRSSIVal = data;
  2827.               }
  2828.           CC1000RadioIntM$RSSIInitState = CC1000RadioIntM$NULL_STATE;
  2829.           break;
  2831.           case CC1000RadioIntM$PRETX_STATE: 
  2832.             CC1000RadioIntM$iRSSIcount++;
  2836.           if ((
  2837. #line 1636
  2838.           data > CC1000RadioIntM$usSquelchVal + 16 || 
  2839.           !CC1000RadioIntM$bCCAEnable) && CC1000RadioIntM$RSSIInitState == CC1000RadioIntM$PRETX_STATE) {
  2840.               CC1000RadioIntM$SpiByteFifo$writeByte(0xaa);
  2841.               CC1000RadioIntM$CC1000Control$TxMode();
  2842.               CC1000RadioIntM$SpiByteFifo$txMode();
  2844.               CC1000RadioIntM$usRSSIVal = data;
  2845.               CC1000RadioIntM$iRSSIcount = 5;
  2846.               CC1000RadioIntM$bRSSIValid = TRUE;
  2847.               CC1000RadioIntM$TxByteCnt = 0;
  2848.               CC1000RadioIntM$usRunningCRC = 0;
  2849.               CC1000RadioIntM$RadioState = CC1000RadioIntM$TX_STATE;
  2850.               CC1000RadioIntM$RadioTxState = CC1000RadioIntM$TXSTATE_PREAMBLE;
  2851.               CC1000RadioIntM$NextTxByte = 0xaa;
  2852.               CC1000RadioIntM$RSSIInitState = CC1000RadioIntM$NULL_STATE;
  2853.             }
  2854.           else {
  2855.               CC1000RadioIntM$RSSIInitState = CC1000RadioIntM$NULL_STATE;
  2856.               if (CC1000RadioIntM$iRSSIcount == 5) {
  2857.                   CC1000RadioIntM$sMacDelay = CC1000RadioIntM$MacBackoff$congestionBackoff(CC1000RadioIntM$txbufptr);
  2861.                   CC1000RadioIntM$RadioState = CC1000RadioIntM$IDLE_STATE;
  2862.                 }
  2863.               else {
  2864.                   CC1000RadioIntM$RSSIInitState = currentRadioState;
  2865.                   CC1000RadioIntM$RSSIADC$getData();
  2866.                 }
  2867.             }
  2868.           break;
  2870.           case CC1000RadioIntM$PULSE_CHECK_STATE: 
  2871.             {
  2872.               uint8_t done = 0;
  2873.               uint16_t threshold = CC1000RadioIntM$GetSquelch();
  2875. #line 1672
  2876.               threshold = threshold - (CC1000RadioIntM$GetSquelch() >> 2);
  2877.               if (data > threshold) {
  2879.                   CC1000RadioIntM$usTempSquelch = data;
  2880.                   TOS_post(CC1000RadioIntM$adjustSquelch);
  2881.                 }
  2882.               else {
  2883. #line 1678
  2884.                 if (CC1000RadioIntM$pulse_check_count > 5) {
  2886.                     CC1000RadioIntM$CC1000Control$RxMode();
  2887.                     CC1000RadioIntM$RadioState = CC1000RadioIntM$IDLE_STATE;
  2888.                     CC1000RadioIntM$SpiByteFifo$rxMode();
  2889.                     CC1000RadioIntM$SpiByteFifo$enableIntr();
  2890.                     TOS_post(CC1000RadioIntM$IdleTimerTask);
  2891.                     done = 1;
  2892.                   }
  2893.                 else {
  2894.                     CC1000RadioIntM$CC1000Control$RxMode();
  2895.                     if (CC1000RadioIntM$RSSIADC$getData()) {
  2896.                         TOSH_uwait(80);
  2897.                         CC1000RadioIntM$pulse_check_count++;
  2898.                         done = 1;
  2899.                       }
  2900.                     CC1000RadioIntM$pulse_check_sum++;
  2901.                     CC1000RadioIntM$CC1000StdControl$stop();
  2902.                   }
  2903.                 }
  2904.               if (CC1000RadioIntM$bTxPending) {
  2906.                   CC1000RadioIntM$CC1000Control$RxMode();
  2907.                   CC1000RadioIntM$RadioState = CC1000RadioIntM$IDLE_STATE;
  2908.                   CC1000RadioIntM$SpiByteFifo$rxMode();
  2909.                   CC1000RadioIntM$SpiByteFifo$enableIntr();
  2910.                   TOS_post(CC1000RadioIntM$IdleTimerTask);
  2911.                   done = 1;
  2912.                 }
  2914.               if (done == 0) {
  2915.                   TOS_post(CC1000RadioIntM$SleepTimerTask);
  2916.                   CC1000RadioIntM$RadioState = CC1000RadioIntM$POWER_DOWN_STATE;
  2917.                   CC1000RadioIntM$SpiByteFifo$disableIntr();
  2918.                 }
  2919.             }
  2921.           break;
  2923.           default: ;
  2924.         }
  2925.     }
  2926. #line 1719
  2927.     __nesc_atomic_end(__nesc_atomic); }
  2928.   return SUCCESS;
  2929. }
  2931. static inline    
  2932. # 118 "../../tos/platform/mica2/ADCREFM.nc"
  2933. result_t ADCREFM$ADC$default$dataReady(uint8_t port, uint16_t data)
  2934. #line 118
  2935. {
  2936.   return FAIL;
  2937. }
  2939. # 70 "/home/testuser/tinyos-1.x/tos/interfaces/ADC.nc"
  2940. inline static   result_t ADCREFM$ADC$dataReady(uint8_t arg_0x86d0c08, uint16_t arg_0x86fa7d8){
  2941. #line 70
  2942.   unsigned char result;
  2943. #line 70
  2945. #line 70
  2946.   switch (arg_0x86d0c08) {
  2947. #line 70
  2948.     case TOS_ADC_CC_RSSI_PORT:
  2949. #line 70
  2950.       result = CC1000RadioIntM$RSSIADC$dataReady(arg_0x86fa7d8);
  2951. #line 70
  2952.       break;
  2953. #line 70
  2954.     default:
  2955. #line 70
  2956.       result = ADCREFM$ADC$default$dataReady(arg_0x86d0c08, arg_0x86fa7d8);
  2957. #line 70
  2958.     }
  2959. #line 70
  2961. #line 70
  2962.   return result;
  2963. #line 70
  2964. }
  2965. #line 70
  2966. static inline    
  2967. # 122 "../../tos/platform/mica2/ADCREFM.nc"
  2968. result_t ADCREFM$CalADC$default$dataReady(uint8_t port, uint16_t data)
  2969. #line 122
  2970. {
  2971.   return FAIL;
  2972. }
  2974. # 70 "/home/testuser/tinyos-1.x/tos/interfaces/ADC.nc"
  2975. inline static   result_t ADCREFM$CalADC$dataReady(uint8_t arg_0x86d1290, uint16_t arg_0x86fa7d8){
  2976. #line 70
  2977.   unsigned char result;
  2978. #line 70
  2980. #line 70
  2981.     result = ADCREFM$CalADC$default$dataReady(arg_0x86d1290, arg_0x86fa7d8);
  2982. #line 70
  2984. #line 70
  2985.   return result;
  2986. #line 70
  2987. }
  2988. #line 70
  2989. # 77 "/home/testuser/tinyos-1.x/tos/interfaces/HPLADC.nc"
  2990. inline static   result_t ADCREFM$HPLADC$samplePort(uint8_t arg_0x88aba00){
  2991. #line 77
  2992.   unsigned char result;
  2993. #line 77
  2995. #line 77
  2996.   result = HPLADCM$ADC$samplePort(arg_0x88aba00);
  2997. #line 77
  2999. #line 77
  3000.   return result;
  3001. #line 77
  3002. }
  3003. #line 77
  3004. static inline   
  3005. # 133 "../../tos/platform/mica2/ADCREFM.nc"
  3006. result_t ADCREFM$HPLADC$dataReady(uint16_t data)
  3007. #line 133
  3008. {
  3009.   uint16_t doneValue = data;
  3010.   uint8_t donePort;
  3011.   uint8_t nextPort = 0xff;
  3012.   bool fCalResult = FALSE;
  3013.   result_t Result = SUCCESS;
  3015. #line 139
  3016.   if (ADCREFM$ReqPort == TOS_ADC_BANDGAP_PORT) {
  3017.       ADCREFM$RefVal = data;
  3018.     }
  3020.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3021. #line 143
  3022.     {
  3023.       donePort = ADCREFM$ReqPort;
  3025.       if (((1 << donePort) & ADCREFM$ContReqMask) == 0) {
  3026.           ADCREFM$ReqVector ^= 1 << donePort;
  3027.         }
  3030.       if ((1 << donePort) & ADCREFM$CalReqMask) {
  3031.           fCalResult = TRUE;
  3032.           if (((1 << donePort) & ADCREFM$ContReqMask) == 0) {
  3033.               ADCREFM$CalReqMask ^= 1 << donePort;
  3034.             }
  3035.         }
  3037.       if (ADCREFM$ReqVector) {
  3040.           do {
  3041.               ADCREFM$ReqPort++;
  3042.               ADCREFM$ReqPort = ADCREFM$ReqPort == TOSH_ADC_PORTMAPSIZE ? 0 : ADCREFM$ReqPort;
  3043.             }
  3044.           while (((
  3045. #line 164
  3046.           1 << ADCREFM$ReqPort) & ADCREFM$ReqVector) == 0);
  3047.           nextPort = ADCREFM$ReqPort;
  3048.         }
  3049.     }
  3050. #line 167
  3051.     __nesc_atomic_end(__nesc_atomic); }
  3054.   if (nextPort != 0xff) {
  3055.       ADCREFM$HPLADC$samplePort(nextPort);
  3056.     }
  3058.   {
  3059.   }
  3060. #line 174
  3061.   ;
  3062.   if (donePort != TOS_ADC_BANDGAP_PORT) {
  3063.       if (fCalResult) {
  3064.           uint32_t tmp = (uint32_t )data;
  3066. #line 178
  3067.           tmp = tmp << 10;
  3068.           tmp = tmp / ADCREFM$RefVal;
  3069.           doneValue = (uint16_t )tmp;
  3070.           Result = ADCREFM$CalADC$dataReady(donePort, doneValue);
  3071.         }
  3072.       else {
  3073.           Result = ADCREFM$ADC$dataReady(donePort, doneValue);
  3074.         }
  3075.     }
  3077.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3078. #line 188
  3079.     {
  3080.       if (ADCREFM$ContReqMask & (1 << donePort) && Result == FAIL) {
  3081.           ADCREFM$ContReqMask ^= 1 << donePort;
  3082.         }
  3083.     }
  3084. #line 192
  3085.     __nesc_atomic_end(__nesc_atomic); }
  3087.   return SUCCESS;
  3088. }
  3090. # 99 "/home/testuser/tinyos-1.x/tos/interfaces/HPLADC.nc"
  3091. inline static   result_t HPLADCM$ADC$dataReady(uint16_t arg_0x88c8548){
  3092. #line 99
  3093.   unsigned char result;
  3094. #line 99
  3096. #line 99
  3097.   result = ADCREFM$HPLADC$dataReady(arg_0x88c8548);
  3098. #line 99
  3100. #line 99
  3101.   return result;
  3102. #line 99
  3103. }
  3104. #line 99
  3105. static inline   
  3106. # 97 "/home/testuser/tinyos-1.x/tos/platform/mica/HPLClock.nc"
  3107. uint8_t HPLClock$Clock$getInterval(void)
  3108. #line 97
  3109. {
  3110.   return * (volatile uint8_t *)(0x31 + 0x20);
  3111. }
  3113. # 121 "/home/testuser/tinyos-1.x/tos/interfaces/Clock.nc"
  3114. inline static   uint8_t TimerM$Clock$getInterval(void){
  3115. #line 121
  3116.   unsigned char result;
  3117. #line 121
  3119. #line 121
  3120.   result = HPLClock$Clock$getInterval();
  3121. #line 121
  3123. #line 121
  3124.   return result;
  3125. #line 121
  3126. }
  3127. #line 121
  3128. # 41 "/home/testuser/tinyos-1.x/tos/interfaces/PowerManagement.nc"
  3129. inline static   uint8_t TimerM$PowerManagement$adjustPower(void){
  3130. #line 41
  3131.   unsigned char result;
  3132. #line 41
  3134. #line 41
  3135.   result = HPLPowerManagementM$PowerManagement$adjustPower();
  3136. #line 41
  3138. #line 41
  3139.   return result;
  3140. #line 41
  3141. }
  3142. #line 41
  3143. static inline   
  3144. # 87 "/home/testuser/tinyos-1.x/tos/platform/mica/HPLClock.nc"
  3145. void HPLClock$Clock$setInterval(uint8_t value)
  3146. #line 87
  3147. {
  3148.   * (volatile uint8_t *)(0x31 + 0x20) = value;
  3149. }
  3151. # 105 "/home/testuser/tinyos-1.x/tos/interfaces/Clock.nc"
  3152. inline static   void TimerM$Clock$setInterval(uint8_t arg_0x88f08c8){
  3153. #line 105
  3154.   HPLClock$Clock$setInterval(arg_0x88f08c8);
  3155. #line 105
  3156. }
  3157. #line 105
  3158. static inline   
  3159. # 134 "/home/testuser/tinyos-1.x/tos/platform/mica/HPLClock.nc"
  3160. uint8_t HPLClock$Clock$readCounter(void)
  3161. #line 134
  3162. {
  3163.   return * (volatile uint8_t *)(0x32 + 0x20);
  3164. }
  3166. # 153 "/home/testuser/tinyos-1.x/tos/interfaces/Clock.nc"
  3167. inline static   uint8_t TimerM$Clock$readCounter(void){
  3168. #line 153
  3169.   unsigned char result;
  3170. #line 153
  3172. #line 153
  3173.   result = HPLClock$Clock$readCounter();
  3174. #line 153
  3176. #line 153
  3177.   return result;
  3178. #line 153
  3179. }
  3180. #line 153
  3181. # 129 "/home/testuser/tinyos-1.x/tos/system/TimerM.nc"
  3182. static void TimerM$adjustInterval(void)
  3183. #line 129
  3184. {
  3185.   uint8_t i;
  3186. #line 130
  3187.   uint8_t val = TimerM$maxTimerInterval;
  3189. #line 131
  3190.   if (TimerM$mState) {
  3191.       for (i = 0; i < NUM_TIMERS; i++) {
  3192.           if (TimerM$mState & (0x1L << i) && TimerM$mTimerList[i].ticksLeft < val) {
  3193.               val = TimerM$mTimerList[i].ticksLeft;
  3194.             }
  3195.         }
  3196. #line 148
  3197.       { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3198. #line 148
  3199.         {
  3200.           i = TimerM$Clock$readCounter() + 3;
  3201.           if (val < i) {
  3202.               val = i;
  3203.             }
  3204.           TimerM$mInterval = val;
  3205.           TimerM$Clock$setInterval(TimerM$mInterval);
  3206.           TimerM$setIntervalFlag = 0;
  3207.         }
  3208. #line 156
  3209.         __nesc_atomic_end(__nesc_atomic); }
  3210.     }
  3211.   else {
  3212.       { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3213. #line 159
  3214.         {
  3215.           TimerM$mInterval = TimerM$maxTimerInterval;
  3216.           TimerM$Clock$setInterval(TimerM$mInterval);
  3217.           TimerM$setIntervalFlag = 0;
  3218.         }
  3219. #line 163
  3220.         __nesc_atomic_end(__nesc_atomic); }
  3221.     }
  3222.   TimerM$PowerManagement$adjustPower();
  3223. }
  3225. static inline 
  3226. #line 186
  3227. void TimerM$enqueue(uint8_t value)
  3228. #line 186
  3229. {
  3230.   if (TimerM$queue_tail == NUM_TIMERS - 1) {
  3231.     TimerM$queue_tail = -1;
  3232.     }
  3233. #line 189
  3234.   TimerM$queue_tail++;
  3235.   TimerM$queue_size++;
  3236.   TimerM$queue[(uint8_t )TimerM$queue_tail] = value;
  3237. }
  3239. static inline 
  3240. # 1498 "../../tos/system/DrandM.nc"
  3241. void DrandM$drandRoundOver(void)
  3242. #line 1498
  3243. {
  3244.   uint8_t randNum;
  3245. #line 1499
  3246.   uint8_t contender;
  3248. #line 1500
  3249.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3250. #line 1500
  3251.     {
  3252.       DrandM$sentRelease = FALSE;
  3253.       DrandM$firstGrant = TRUE;
  3255.       DrandM$roundNum++;
  3257.       randNum = DrandM$randNew();
  3258.       contender = DrandM$getContenders();
  3264.       if (randNum % contender == 0) {
  3265.           DrandM$globalState = REQUEST_STATE;
  3267.           DrandM$SClock$getTime(&DrandM$roundStartTime);
  3269.           DrandM$requestFireCount = 0;
  3276.           DrandM$sendRequestMsg();
  3277.         }
  3278.       else 
  3279. #line 1526
  3280.         {
  3285.           DrandM$drandRoundTimer$start(TIMER_ONE_SHOT, DrandM$ROUND_TIME);
  3286.         }
  3287.       DrandM$lastReqID = 0xff;
  3288.     }
  3289. #line 1534
  3290.     __nesc_atomic_end(__nesc_atomic); }
  3291. }
  3293. static inline  
  3294. #line 1582
  3295. result_t DrandM$drandRoundTimer$fired(void)
  3296. #line 1582
  3297. {
  3298.   if (DrandM$globalState == IDLE_STATE2) {
  3299.     DrandM$drandRoundOver();
  3300.     }
  3301. #line 1585
  3302.   return SUCCESS;
  3303. }
  3305. # 48 "/home/testuser/tinyos-1.x/tos/interfaces/SendMsg.nc"
  3306. inline static  result_t DrandM$SendGrantMsg$send(uint16_t arg_0x857ab18, uint8_t arg_0x857ac60, TOS_MsgPtr arg_0x857adb0){
  3307. #line 48
  3308.   unsigned char result;
  3309. #line 48
  3311. #line 48
  3312.   result = AMStandard$SendMsg$send(AM_GRANT, arg_0x857ab18, arg_0x857ac60, arg_0x857adb0);
  3313. #line 48
  3315. #line 48
  3316.   return result;
  3317. #line 48
  3318. }
  3319. #line 48
  3320. static inline 
  3321. # 330 "../../tos/system/DrandM.nc"
  3322. void DrandM$fillTimeSlotInfo(uint8_t *array)
  3323. #line 330
  3324. {
  3325.   uint8_t i;
  3327. #line 332
  3328.   for (i = 0; i < MAX_NBR; i++) 
  3329.     array[i] = 0xFF;
  3330.   for (i = 0; i < MAX_NBR && DrandM$nbrInfo[i].nodeID != 0xFF; i++) 
  3331.     if (DrandM$nbrInfo[i].slot != 0xFF && DrandM$nbrInfo[i].bitMap & ONE_HOP) {
  3332.       array[DrandM$nbrInfo[i].slot] = DrandM$nbrInfo[i].nodeID;
  3333.       }
  3334. #line 337
  3335.   if (DrandM$setMySlot) {
  3336.     array[DrandM$myInfo.slot] = TOS_LOCAL_ADDRESS;
  3337.     }
  3338. }
  3340. static inline 
  3341. #line 761
  3342. void DrandM$sendGrantMsg(uint8_t msgADDR)
  3343. #line 761
  3344. {
  3345.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3346. #line 762
  3347.     {
  3348.       if (!DrandM$sendBusy) {
  3349.           grantMsg *grantMsgData = (grantMsg *)DrandM$DataPkt.data;
  3351. #line 765
  3352.           grantMsgData->sendID = TOS_LOCAL_ADDRESS;
  3354.           grantMsgData->myState = DrandM$globalState;
  3355.           grantMsgData->lastRequestID = DrandM$lastReqID;
  3356.           grantMsgData->roundNum = DrandM$roundNum;
  3358.           grantMsgData->timestamp = DrandM$requestStartTime;
  3359.           DrandM$fillTimeSlotInfo(grantMsgData->timeSlot);
  3361.           if (DrandM$SendGrantMsg$send((uint16_t )msgADDR, sizeof(grantMsg ), &DrandM$DataPkt) != SUCCESS) {
  3362.               DrandM$reXTimer$start(TIMER_ONE_SHOT, DrandM$GRANT_TIME);
  3363.             }
  3364.           else 
  3367.             {
  3368.               DrandM$sendBusy = TRUE;
  3369.             }
  3370.         }
  3371.       else 
  3372. #line 783
  3373.         {
  3374.           DrandM$reXTimer$start(TIMER_ONE_SHOT, DrandM$GRANT_TIME);
  3375.         }
  3376.     }
  3377. #line 786
  3378.     __nesc_atomic_end(__nesc_atomic); }
  3379. }
  3381. static inline 
  3382. #line 424
  3383. void DrandM$removeNodeForGrant(uint8_t nodeID)
  3384. #line 424
  3385. {
  3386.   int i;
  3388. #line 426
  3389.   for (i = MAX_NBR - 1; i >= 0; i--) {
  3390.       if (DrandM$nbrInfo[i].nodeID == 0xFF) {
  3391.         continue;
  3392.         }
  3393.       else {
  3394. #line 429
  3395.         if (DrandM$nbrInfo[i].nodeID == nodeID) {
  3397.             {
  3398. #line 431
  3399.               char bStatus;
  3401. #line 431
  3402.               if (DBG_USR2 != 0) {
  3403. #line 431
  3404.                   bStatus = * (volatile uint8_t *)(uint16_t )& * (volatile uint8_t *)(0x3F + 0x20) & (1 << 7);
  3405. #line 431
  3406.                    __asm volatile ("cli");DrandM$sprintf(DrandM$debugbuf, "RemoveNodeForGrant: Changed %u to Two Hopn", DrandM$nbrInfo[i].nodeID);
  3407. #line 431
  3408.                   DrandM$writedebug();
  3409. #line 431
  3410.                   if (bStatus) {
  3411. #line 431
  3412.                      __asm volatile ("sei");
  3413.                     }
  3414.                 }
  3415.             }
  3416. #line 431
  3417.             ;
  3420.             DrandM$nbrInfo[i].bitMap = TWO_HOP;
  3421.             return;
  3422.           }
  3423.         }
  3424.     }
  3425. }
  3427. static inline 
  3428. #line 1425
  3429. void DrandM$reXGrant(void)
  3430. #line 1425
  3431. {
  3432.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3433. #line 1426
  3434.     {
  3435.       if (DrandM$grantFireCount > MAX_GRANT) {
  3436.           DrandM$removeNodeForGrant(DrandM$lastReqID);
  3437.           if (DrandM$setMySlot) {
  3438.               DrandM$globalState = RELEASE_STATE;
  3439.             }
  3440.           else 
  3442.             {
  3443.               DrandM$globalState = IDLE_STATE2;
  3444.               DrandM$drandRoundTimer$start(TIMER_ONE_SHOT, 100);
  3445.             }
  3450.           DrandM$graX = FALSE;
  3452.           DrandM$lastReqID = 0xFF;
  3453.         }
  3454.       else 
  3455. #line 1445
  3456.         {
  3460.           DrandM$sendGrantMsg(DrandM$lastReqID);
  3461.         }
  3462.     }
  3463. #line 1451
  3464.     __nesc_atomic_end(__nesc_atomic); }
  3465. }
  3467. static inline 
  3468. #line 409
  3469. void DrandM$removeNodesForRequest(void)
  3470. #line 409
  3471. {
  3472.   int i;
  3474. #line 411
  3475.   for (i = MAX_NBR - 1; i >= 0; i--) {
  3476.       if (DrandM$nbrInfo[i].nodeID == 0xFF) {
  3477.         continue;
  3478.         }
  3479.       else {
  3480. #line 414
  3481.         if (DrandM$nbrInfo[i].bitMap & ONE_HOP && !(DrandM$nbrInfo[i].bitMap & GRANT_SENT)) {
  3483.             {
  3484. #line 416
  3485.               char bStatus;
  3487. #line 416
  3488.               if (DBG_USR2 != 0) {
  3489. #line 416
  3490.                   bStatus = * (volatile uint8_t *)(uint16_t )& * (volatile uint8_t *)(0x3F + 0x20) & (1 << 7);
  3491. #line 416
  3492.                    __asm volatile ("cli");DrandM$sprintf(DrandM$debugbuf, "RemoveNodesForRequest: Changed %u to Two Hopn", DrandM$nbrInfo[i].nodeID);
  3493. #line 416
  3494.                   DrandM$writedebug();
  3495. #line 416
  3496.                   if (bStatus) {
  3497. #line 416
  3498.                      __asm volatile ("sei");
  3499.                     }
  3500.                 }
  3501.             }
  3502. #line 416
  3503.             ;
  3506.             DrandM$nbrInfo[i].bitMap = TWO_HOP;
  3507.           }
  3508.         }
  3509.     }
  3510. }
  3512. static inline 
  3513. #line 1399
  3514. void DrandM$reXRequest(void)
  3515. #line 1399
  3516. {
  3517.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3518. #line 1400
  3519.     {
  3520.       if (DrandM$requestFireCount > MAX_REQUEST) {
  3521.           DrandM$removeNodesForRequest();
  3522.           if (DrandM$numGrantsRemaining() == 0 && !DrandM$setMySlot) {
  3523.               DrandM$setSlot();
  3525.               DrandM$timeCheck();
  3526.               DrandM$printNbrInfo();
  3527.             }
  3528.         }
  3529.       else 
  3535.         {
  3539.           DrandM$sendRequestMsg();
  3540.         }
  3541.     }
  3542. #line 1422
  3543.     __nesc_atomic_end(__nesc_atomic); }
  3544. }
  3546. static inline 
  3547. #line 1393
  3548. void DrandM$reXHello(void)
  3549. #line 1393
  3550. {
  3551.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3552. #line 1394
  3553.     {
  3554.       DrandM$sendHelloMsg();
  3555.     }
  3556. #line 1396
  3557.     __nesc_atomic_end(__nesc_atomic); }
  3558. }
  3560. static inline  
  3561. #line 1537
  3562. result_t DrandM$reXTimer$fired(void)
  3563. #line 1537
  3564. {
  3565.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3566. #line 1538
  3567.     {
  3568.       switch (DrandM$globalState) {
  3569.           case HELLO_STATE: 
  3570.             DrandM$reXHello();
  3571.           break;
  3572.           case REQUEST_STATE: 
  3573.             DrandM$reXRequest();
  3574.           break;
  3575.           case GRANT_STATE: 
  3576.             DrandM$reXGrant();
  3577.           break;
  3578.           case REPORT_STATE: 
  3579.             DrandM$reXReport();
  3580.           break;
  3581.           case FRAME_STATE: 
  3582.             DrandM$reXFrame();
  3583.           break;
  3584.         }
  3585.     }
  3586. #line 1556
  3587.     __nesc_atomic_end(__nesc_atomic); }
  3588.   return SUCCESS;
  3589. }
  3591. static inline   
  3592. # 33 "TestBedTopologyM.nc"
  3593. void TestBedTopologyM$Drand$helloOver(void)
  3594. #line 33
  3595. {
  3596. }
  3598. # 6 "../../tos/interfaces/Drand.nc"
  3599. inline static   void DrandM$Drand$helloOver(void){
  3600. #line 6
  3601.   TestBedTopologyM$Drand$helloOver();
  3602. #line 6
  3603. }
  3604. #line 6
  3605. static inline 
  3606. # 1454 "../../tos/system/DrandM.nc"
  3607. void DrandM$helloOver(void)
  3608. #line 1454
  3609. {
  3610.   uint8_t i;
  3611. #line 1455
  3612.   uint8_t randNum;
  3613. #line 1455
  3614.   uint8_t contender;
  3616. #line 1456
  3617.   DrandM$Drand$helloOver();
  3619.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3620. #line 1458
  3621.     {
  3622.       DrandM$globalState = IDLE_STATE2;
  3623.       DrandM$reXTimer$stop();
  3627.       DrandM$SClock$getTime(&DrandM$drandStartTime);
  3629.       for (i = 0; i < MAX_NBR; i++) 
  3630.         DrandM$addNode(DrandM$TwoWayId[i], ONE_HOP);
  3633.       DrandM$printNbrInfo();
  3635.       contender = DrandM$getContenders();
  3636.       randNum = DrandM$randNew();
  3643.       if (randNum % contender == 0) {
  3644.           DrandM$globalState = REQUEST_STATE;
  3645.           DrandM$requestFireCount = 0;
  3647.           DrandM$SClock$getTime(&DrandM$roundStartTime);
  3655.           DrandM$sendRequestMsg();
  3656.         }
  3657.       else {
  3658. #line 1494
  3659.         DrandM$drandRoundTimer$start(TIMER_ONE_SHOT, DrandM$ROUND_TIME);
  3660.         }
  3661.     }
  3662. #line 1496
  3663.     __nesc_atomic_end(__nesc_atomic); }
  3664. }
  3666. static inline  
  3667. #line 1560
  3668. result_t DrandM$roundTimer$fired(void)
  3669. #line 1560
  3670. {
  3671.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3672. #line 1561
  3673.     {
  3674.       switch (DrandM$globalState) {
  3675.           case HELLO_STATE: 
  3676.             DrandM$helloOver();
  3677.           DrandM$roundTimer$start(TIMER_ONE_SHOT, DRAND_PERIOD);
  3678.           break;
  3679.           case RELEASE_STATE: 
  3680.             DrandM$globalState = REPORT_STATE;
  3681.           DrandM$reXReport();
  3682.           DrandM$roundTimer$start(TIMER_ONE_SHOT, REPORT_PERIOD);
  3683.           break;
  3684.           case REPORT_STATE: 
  3685.             DrandM$setFrame();
  3686.           DrandM$globalState = FRAME_STATE;
  3687.           DrandM$reXFrame();
  3688.           break;
  3689.         }
  3690.     }
  3691. #line 1578
  3692.     __nesc_atomic_end(__nesc_atomic); }
  3693.   return SUCCESS;
  3694. }
  3696. static inline  
  3697. # 151 "/home/testuser/tinyos-1.x/tos/system/AMStandard.nc"
  3698. result_t AMStandard$ActivityTimer$fired(void)
  3699. #line 151
  3700. {
  3701.   AMStandard$lastCount = AMStandard$counter;
  3702.   AMStandard$counter = 0;
  3703.   return SUCCESS;
  3704. }
  3706. # 59 "/home/testuser/tinyos-1.x/tos/interfaces/Timer.nc"
  3707. inline static  result_t CC1000RadioIntM$TDMATimer$start(char arg_0x85800e0, uint32_t arg_0x8580238){
  3708. #line 59
  3709.   unsigned char result;
  3710. #line 59
  3712. #line 59
  3713.   result = TimerM$Timer$start(6, arg_0x85800e0, arg_0x8580238);
  3714. #line 59
  3716. #line 59
  3717.   return result;
  3718. #line 59
  3719. }
  3720. #line 59
  3721. static inline  
  3722. # 980 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  3723. result_t CC1000RadioIntM$TDMATimer$fired(void)
  3724. #line 980
  3725. {
  3726.   CC1000RadioIntM$TDMATimer$start(TIMER_ONE_SHOT, CC1000RadioIntM$slotMultiplier);
  3727.   CC1000RadioIntM$slotNum++;
  3728.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3729. #line 983
  3730.     CC1000RadioIntM$currentMAC = CC1000RadioIntM$ZMAC;
  3731. #line 983
  3732.     __nesc_atomic_end(__nesc_atomic); }
  3733.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3734. #line 984
  3735.     {
  3736.       CC1000RadioIntM$currentSlot = CC1000RadioIntM$slotNum & (CC1000RadioIntM$localFrameLength - 1);
  3737.       CC1000RadioIntM$globalSlot = CC1000RadioIntM$slotNum & (CC1000RadioIntM$globalFrameLength - 1);
  3741.       if (CC1000RadioIntM$HCLselect) {
  3742.           CC1000RadioIntM$slots_since_ecnsend++;
  3743.           CC1000RadioIntM$slots_since_ecnrecv++;
  3744.           CC1000RadioIntM$slots_since_ecncheck++;
  3745.           if (CC1000RadioIntM$packetsSent > 10 && CC1000RadioIntM$slots_since_ecncheck >= 16) {
  3746.               double currentLoss = (double )CC1000RadioIntM$congBackOffs / CC1000RadioIntM$packetsSent;
  3748. #line 996
  3749.               CC1000RadioIntM$avgLoss = 0.25 * currentLoss + (1 - 0.25) * CC1000RadioIntM$avgLoss;
  3753.               CC1000RadioIntM$slots_since_ecncheck = 0;
  3754.               CC1000RadioIntM$congBackOffs = 0;
  3755.               CC1000RadioIntM$packetsSent = 0;
  3756.               if (CC1000RadioIntM$avgLoss > 3.0 && CC1000RadioIntM$slots_since_ecnsend >= 96) {
  3757.                   ecnMsgType *ecnMsgPtr = (ecnMsgType *)CC1000RadioIntM$ecnMsgHdr.data;
  3762.                   CC1000RadioIntM$enableHCL = TRUE;
  3763.                   CC1000RadioIntM$slots_since_ecnrecv = 0;
  3766.                   ecnMsgPtr->nextHop = CC1000RadioIntM$nextHop;
  3767.                   if (!CC1000RadioIntM$pureHCL) {
  3768.                     CC1000RadioIntM$ecnPending = TRUE;
  3769.                     }
  3770.                 }
  3771.             }
  3772. #line 1018
  3773.           if (CC1000RadioIntM$enableHCL && CC1000RadioIntM$slots_since_ecnrecv >= 192) {
  3774.               if (!CC1000RadioIntM$pureHCL) {
  3775.                 CC1000RadioIntM$enableHCL = FALSE;
  3776.                 }
  3777.             }
  3778.         }
  3779. #line 1036
  3780.       if (CC1000RadioIntM$bTxPending) {
  3781.           CC1000RadioIntM$sMacDelay = CC1000RadioIntM$getZMACBackoff(CC1000RadioIntM$sMacDelay);
  3782.         }
  3783.     }
  3784. #line 1039
  3785.     __nesc_atomic_end(__nesc_atomic); }
  3789.   return SUCCESS;
  3790. }
  3792. # 68 "/home/testuser/tinyos-1.x/tos/interfaces/Timer.nc"
  3793. inline static  result_t CC1000RadioIntM$SquelchTimer$stop(void){
  3794. #line 68
  3795.   unsigned char result;
  3796. #line 68
  3798. #line 68
  3799.   result = TimerM$Timer$stop(4);
  3800. #line 68
  3802. #line 68
  3803.   return result;
  3804. #line 68
  3805. }
  3806. #line 68
  3807. static inline  
  3808. # 927 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  3809. result_t CC1000RadioIntM$WakeupTimer$fired(void)
  3810. #line 927
  3811. {
  3812.   uint8_t currentRadioState;
  3814.   if (CC1000RadioIntM$lplpower == 0) {
  3815.     return SUCCESS;
  3816.     }
  3817.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3818. #line 933
  3819.     currentRadioState = CC1000RadioIntM$RadioState;
  3820. #line 933
  3821.     __nesc_atomic_end(__nesc_atomic); }
  3822.   switch (currentRadioState) {
  3824.       case CC1000RadioIntM$IDLE_STATE: 
  3825.         if (!CC1000RadioIntM$bTxPending) {
  3826.             { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3827. #line 938
  3828.               {
  3829.                 CC1000RadioIntM$RadioState = CC1000RadioIntM$POWER_DOWN_STATE;
  3830.                 CC1000RadioIntM$SpiByteFifo$disableIntr();
  3831.               }
  3832. #line 941
  3833.               __nesc_atomic_end(__nesc_atomic); }
  3834.             CC1000RadioIntM$WakeupTimer$start(TIMER_ONE_SHOT, CC1000RadioIntM$sleeptime);
  3835.             CC1000RadioIntM$SquelchTimer$stop();
  3836.             CC1000RadioIntM$CC1000StdControl$stop();
  3837.           }
  3838.         else 
  3839. #line 945
  3840.           {
  3841.             CC1000RadioIntM$WakeupTimer$start(TIMER_ONE_SHOT, CC1000RadioIntM$sleeptime);
  3842.           }
  3843.       break;
  3845.       case CC1000RadioIntM$POWER_DOWN_STATE: 
  3846.         { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3847. #line 951
  3848.           CC1000RadioIntM$RadioState = CC1000RadioIntM$PULSE_CHECK_STATE;
  3849. #line 951
  3850.           __nesc_atomic_end(__nesc_atomic); }
  3851.       CC1000RadioIntM$pulse_check_count = 0;
  3852.       CC1000RadioIntM$CC1000StdControl$start();
  3853.       CC1000RadioIntM$CC1000Control$BIASOn();
  3854.       CC1000RadioIntM$WakeupTimer$start(TIMER_ONE_SHOT, 1);
  3855.       return SUCCESS;
  3856.       break;
  3858.       case CC1000RadioIntM$PULSE_CHECK_STATE: 
  3859.         CC1000RadioIntM$CC1000Control$RxMode();
  3860.       if (!CC1000RadioIntM$RSSIADC$getData()) {
  3861.           CC1000RadioIntM$WakeupTimer$start(TIMER_ONE_SHOT, CC1000RadioIntM$TIME_BETWEEN_CHECKS);
  3862.           { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3863. #line 963
  3864.             CC1000RadioIntM$RadioState = CC1000RadioIntM$POWER_DOWN_STATE;
  3865. #line 963
  3866.             __nesc_atomic_end(__nesc_atomic); }
  3867.         }
  3868.       else {
  3869.           TOSH_uwait(80);
  3870.         }
  3871.       CC1000RadioIntM$CC1000StdControl$stop();
  3872.       CC1000RadioIntM$pulse_check_sum++;
  3873.       break;
  3875.       default: 
  3876.         CC1000RadioIntM$WakeupTimer$start(TIMER_ONE_SHOT, 5);
  3877.     }
  3878.   return SUCCESS;
  3879. }
  3881. static inline  
  3882. #line 916
  3883. result_t CC1000RadioIntM$SquelchTimer$fired(void)
  3884. #line 916
  3885. {
  3886.   char currentRadioState;
  3888. #line 918
  3889.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3890. #line 918
  3891.     currentRadioState = CC1000RadioIntM$RadioState;
  3892. #line 918
  3893.     __nesc_atomic_end(__nesc_atomic); }
  3895.   if (currentRadioState == CC1000RadioIntM$IDLE_STATE) {
  3896.       { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3897. #line 921
  3898.         CC1000RadioIntM$RSSIInitState = currentRadioState;
  3899. #line 921
  3900.         __nesc_atomic_end(__nesc_atomic); }
  3901.       CC1000RadioIntM$RSSIADC$getData();
  3902.     }
  3903.   return SUCCESS;
  3904. }
  3906. static inline   
  3907. # 284 "../../tos/platform/mica2/ADCREFM.nc"
  3908. result_t ADCREFM$ADCControl$manualCalibrate(void)
  3909. #line 284
  3910. {
  3911.   result_t Result;
  3913.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3914. #line 287
  3915.     {
  3916.       Result = ADCREFM$startGet(TOS_ADC_BANDGAP_PORT);
  3917.     }
  3918. #line 289
  3919.     __nesc_atomic_end(__nesc_atomic); }
  3921.   return Result;
  3922. }
  3924. static inline  
  3925. #line 92
  3926. void ADCREFM$CalTask(void)
  3927. #line 92
  3928. {
  3930.   ADCREFM$ADCControl$manualCalibrate();
  3932.   return;
  3933. }
  3935. static inline  
  3936. #line 126
  3937. result_t ADCREFM$Timer$fired(void)
  3938. #line 126
  3939. {
  3941.   TOS_post(ADCREFM$CalTask);
  3943.   return SUCCESS;
  3944. }
  3946. static inline   
  3947. # 182 "/home/testuser/tinyos-1.x/tos/system/TimerM.nc"
  3948. result_t TimerM$Timer$default$fired(uint8_t id)
  3949. #line 182
  3950. {
  3951.   return SUCCESS;
  3952. }
  3954. # 73 "/home/testuser/tinyos-1.x/tos/interfaces/Timer.nc"
  3955. inline static  result_t TimerM$Timer$fired(uint8_t arg_0x88d4158){
  3956. #line 73
  3957.   unsigned char result;
  3958. #line 73
  3960. #line 73
  3961.   switch (arg_0x88d4158) {
  3962. #line 73
  3963.     case 0:
  3964. #line 73
  3965.       result = DrandM$roundTimer$fired();
  3966. #line 73
  3967.       break;
  3968. #line 73
  3969.     case 1:
  3970. #line 73
  3971.       result = DrandM$reXTimer$fired();
  3972. #line 73
  3973.       break;
  3974. #line 73
  3975.     case 2:
  3976. #line 73
  3977.       result = DrandM$drandRoundTimer$fired();
  3978. #line 73
  3979.       break;
  3980. #line 73
  3981.     case 3:
  3982. #line 73
  3983.       result = AMStandard$ActivityTimer$fired();
  3984. #line 73
  3985.       break;
  3986. #line 73
  3987.     case 4:
  3988. #line 73
  3989.       result = CC1000RadioIntM$SquelchTimer$fired();
  3990. #line 73
  3991.       break;
  3992. #line 73
  3993.     case 5:
  3994. #line 73
  3995.       result = CC1000RadioIntM$WakeupTimer$fired();
  3996. #line 73
  3997.       break;
  3998. #line 73
  3999.     case 6:
  4000. #line 73
  4001.       result = CC1000RadioIntM$TDMATimer$fired();
  4002. #line 73
  4003.       break;
  4004. #line 73
  4005.     case 7:
  4006. #line 73
  4007.       result = ADCREFM$Timer$fired();
  4008. #line 73
  4009.       break;
  4010. #line 73
  4011.     default:
  4012. #line 73
  4013.       result = TimerM$Timer$default$fired(arg_0x88d4158);
  4014. #line 73
  4015.     }
  4016. #line 73
  4018. #line 73
  4019.   return result;
  4020. #line 73
  4021. }
  4022. #line 73
  4023. static inline 
  4024. # 194 "/home/testuser/tinyos-1.x/tos/system/TimerM.nc"
  4025. uint8_t TimerM$dequeue(void)
  4026. #line 194
  4027. {
  4028.   if (TimerM$queue_size == 0) {
  4029.     return NUM_TIMERS;
  4030.     }
  4031. #line 197
  4032.   if (TimerM$queue_head == NUM_TIMERS - 1) {
  4033.     TimerM$queue_head = -1;