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

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

网络

开发平台：

Others

app.c：源码内容
  1.     }
  2. #line 199
  3.   TimerM$queue_head++;
  4.   TimerM$queue_size--;
  5.   return TimerM$queue[(uint8_t )TimerM$queue_head];
  6. }
  8. static inline  void TimerM$signalOneTimer(void)
  9. #line 204
  10. {
  11.   uint8_t itimer = TimerM$dequeue();
  13. #line 206
  14.   if (itimer < NUM_TIMERS) {
  15.     TimerM$Timer$fired(itimer);
  16.     }
  17. }
  19. static inline  
  20. #line 210
  21. void TimerM$HandleFire(void)
  22. #line 210
  23. {
  24.   uint8_t i;
  25.   uint16_t int_out;
  27. #line 213
  28.   TimerM$setIntervalFlag = 1;
  31.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  32. #line 216
  33.     {
  34.       int_out = TimerM$interval_outstanding;
  35.       TimerM$interval_outstanding = 0;
  36.     }
  37. #line 219
  38.     __nesc_atomic_end(__nesc_atomic); }
  39.   if (TimerM$mState) {
  40.       for (i = 0; i < NUM_TIMERS; i++) {
  41.           if (TimerM$mState & (0x1L << i)) {
  42.               TimerM$mTimerList[i].ticksLeft -= int_out;
  43.               if (TimerM$mTimerList[i].ticksLeft <= 2) {
  46.                   if (TOS_post(TimerM$signalOneTimer)) {
  47.                       if (TimerM$mTimerList[i].type == TIMER_REPEAT) {
  48.                           TimerM$mTimerList[i].ticksLeft += TimerM$mTimerList[i].ticks;
  49.                         }
  50.                       else 
  51. #line 230
  52.                         {
  53.                           TimerM$mState &= ~(0x1L << i);
  54.                         }
  55.                       TimerM$enqueue(i);
  56.                     }
  57.                   else {
  58.                       {
  59.                       }
  60. #line 236
  61.                       ;
  64.                       TimerM$mTimerList[i].ticksLeft = TimerM$mInterval;
  65.                     }
  66.                 }
  67.             }
  68.         }
  69.     }
  72.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  73. #line 247
  74.     int_out = TimerM$interval_outstanding;
  75. #line 247
  76.     __nesc_atomic_end(__nesc_atomic); }
  77.   if (int_out == 0) {
  78.     TimerM$adjustInterval();
  79.     }
  80. }
  82. static inline   result_t TimerM$Clock$fire(void)
  83. #line 253
  84. {
  85.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  86. #line 254
  87.     {
  91.       if (TimerM$interval_outstanding == 0) {
  92.         TOS_post(TimerM$HandleFire);
  93.         }
  94.       else {
  95.         }
  96. #line 261
  97.       ;
  99.       TimerM$interval_outstanding += TimerM$Clock$getInterval() + 1;
  100.     }
  101. #line 264
  102.     __nesc_atomic_end(__nesc_atomic); }
  103.   return SUCCESS;
  104. }
  106. # 180 "/home/testuser/tinyos-1.x/tos/interfaces/Clock.nc"
  107. inline static   result_t HPLClock$Clock$fire(void){
  108. #line 180
  109.   unsigned char result;
  110. #line 180
  112. #line 180
  113.   result = TimerM$Clock$fire();
  114. #line 180
  116. #line 180
  117.   return result;
  118. #line 180
  119. }
  120. #line 180
  121. static inline 
  122. # 321 "../../tos/system/DrandM.nc"
  123. void DrandM$fillGrantSendInfo(uint8_t *array)
  124. #line 321
  125. {
  126.   uint8_t i;
  127. #line 322
  128.   uint8_t j;
  130. #line 323
  131.   for (i = 0, j = 0; i < MAX_NBR && DrandM$nbrInfo[i].nodeID != 0xFF; i++) 
  132.     if (DrandM$nbrInfo[i].bitMap & ONE_HOP && !(DrandM$nbrInfo[i].bitMap & GRANT_SENT)) {
  133.       array[j++] = DrandM$nbrInfo[i].nodeID;
  134.       }
  135. #line 326
  136.   for (; j < MAX_NBR; j++) 
  137.     array[j] = 0xFF;
  138. }
  140. # 48 "/home/testuser/tinyos-1.x/tos/interfaces/SendMsg.nc"
  141. inline static  result_t DrandM$SendRequestMsg$send(uint16_t arg_0x857ab18, uint8_t arg_0x857ac60, TOS_MsgPtr arg_0x857adb0){
  142. #line 48
  143.   unsigned char result;
  144. #line 48
  146. #line 48
  147.   result = AMStandard$SendMsg$send(AM_REQUEST, arg_0x857ab18, arg_0x857ac60, arg_0x857adb0);
  148. #line 48
  150. #line 48
  151.   return result;
  152. #line 48
  153. }
  154. #line 48
  155. # 42 "../../tos/platform/mica2/SpiByteFifo.nc"
  156. inline static   result_t HPLSpiM$SpiByteFifo$dataReady(uint8_t arg_0x8713520){
  157. #line 42
  158.   unsigned char result;
  159. #line 42
  161. #line 42
  162.   result = CC1000RadioIntM$SpiByteFifo$dataReady(arg_0x8713520);
  163. #line 42
  165. #line 42
  166.   return result;
  167. #line 42
  168. }
  169. #line 42
  170. # 53 "../../tos/platform/mica2/HPLSpiM.nc"
  171. void __attribute((signal))   __vector_17(void)
  172. #line 53
  173. {
  174.   register uint8_t temp = * (volatile uint8_t *)(0x0F + 0x20);
  176. #line 55
  177.   * (volatile uint8_t *)(0x0F + 0x20) = HPLSpiM$OutgoingByte;
  178.   HPLSpiM$SpiByteFifo$dataReady(temp);
  179. }
  181. static inline    
  182. # 1789 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  183. void CC1000RadioIntM$RadioSendCoordinator$default$blockTimer(void)
  184. #line 1789
  185. {
  186. }
  188. # 43 "../../tos/platform/mica2/RadioCoordinator.nc"
  189. inline static   void CC1000RadioIntM$RadioSendCoordinator$blockTimer(void){
  190. #line 43
  191.   CC1000RadioIntM$RadioSendCoordinator$default$blockTimer();
  192. #line 43
  193. }
  194. #line 43
  195. static inline    
  196. # 1794 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  197. void CC1000RadioIntM$RadioReceiveCoordinator$default$blockTimer(void)
  198. #line 1794
  199. {
  200. }
  202. # 43 "../../tos/platform/mica2/RadioCoordinator.nc"
  203. inline static   void CC1000RadioIntM$RadioReceiveCoordinator$blockTimer(void){
  204. #line 43
  205.   CC1000RadioIntM$RadioReceiveCoordinator$default$blockTimer();
  206. #line 43
  207. }
  208. #line 43
  209. static inline    
  210. # 1786 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  211. void CC1000RadioIntM$RadioSendCoordinator$default$startSymbol(uint8_t bitsPerBlock, uint8_t offset, 
  212. TOS_MsgPtr msgBuff)
  213. #line 1787
  214. {
  215. }
  217. # 31 "../../tos/platform/mica2/RadioCoordinator.nc"
  218. inline static   void CC1000RadioIntM$RadioSendCoordinator$startSymbol(uint8_t arg_0x86d4858, uint8_t arg_0x86d49a0, TOS_MsgPtr arg_0x86d4af0){
  219. #line 31
  220.   CC1000RadioIntM$RadioSendCoordinator$default$startSymbol(arg_0x86d4858, arg_0x86d49a0, arg_0x86d4af0);
  221. #line 31
  222. }
  223. #line 31
  224. static inline 
  225. # 264 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  226. void CC1000RadioIntM$AddTime(GTime *C, GTime *A, GTime *B)
  227. #line 264
  228. {
  229.   if (CC1000RadioIntM$MAX_VAL - B->sticks < A->sticks) {
  230.       C->sticks = A->sticks - (CC1000RadioIntM$MAX_VAL - B->sticks);
  231.       C->mticks = A->mticks + B->mticks + 1;
  232.     }
  233.   else {
  234.       C->sticks = A->sticks + B->sticks;
  235.       C->mticks = A->mticks + B->mticks;
  236.     }
  237. }
  239. static inline    
  240. #line 1788
  241. void CC1000RadioIntM$RadioSendCoordinator$default$byte(TOS_MsgPtr msg, uint8_t byteCount)
  242. #line 1788
  243. {
  244. }
  246. # 36 "../../tos/platform/mica2/RadioCoordinator.nc"
  247. inline static   void CC1000RadioIntM$RadioSendCoordinator$byte(TOS_MsgPtr arg_0x86d4f68, uint8_t arg_0x86d50b8){
  248. #line 36
  249.   CC1000RadioIntM$RadioSendCoordinator$default$byte(arg_0x86d4f68, arg_0x86d50b8);
  250. #line 36
  251. }
  252. #line 36
  253. static inline  
  254. # 210 "/home/testuser/tinyos-1.x/tos/system/AMStandard.nc"
  255. result_t AMStandard$RadioSend$sendDone(TOS_MsgPtr msg, result_t success)
  256. #line 210
  257. {
  258.   return AMStandard$reportSendDone(msg, success);
  259. }
  261. # 67 "/home/testuser/tinyos-1.x/tos/interfaces/BareSendMsg.nc"
  262. inline static  result_t CC1000RadioIntM$Send$sendDone(TOS_MsgPtr arg_0x86bed88, result_t arg_0x86beed8){
  263. #line 67
  264.   unsigned char result;
  265. #line 67
  267. #line 67
  268.   result = AMStandard$RadioSend$sendDone(arg_0x86bed88, arg_0x86beed8);
  269. #line 67
  271. #line 67
  272.   return result;
  273. #line 67
  274. }
  275. #line 67
  276. static inline  
  277. # 506 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  278. void CC1000RadioIntM$PacketSent(void)
  279. #line 506
  280. {
  281.   TOS_MsgPtr pBuf;
  283. #line 508
  284.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  285. #line 508
  286.     {
  287.       CC1000RadioIntM$txbufptr->time = 0;
  288.       pBuf = CC1000RadioIntM$txbufptr;
  289.     }
  290. #line 511
  291.     __nesc_atomic_end(__nesc_atomic); }
  293.   if (CC1000RadioIntM$txbufptr->type != 222 && CC1000RadioIntM$txbufptr->type != 223) {
  296.       CC1000RadioIntM$Send$sendDone((TOS_MsgPtr )pBuf, SUCCESS);
  297.     }
  298.   else {
  299. #line 517
  300.     if (CC1000RadioIntM$txbufptr->type == 223) {
  301.       }
  302.     else {
  304.       if (CC1000RadioIntM$txbufptr->type == 222) {
  305.         }
  306.       }
  307.     }
  310.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  311. #line 527
  312.     CC1000RadioIntM$bTxBusy = FALSE;
  313. #line 527
  314.     __nesc_atomic_end(__nesc_atomic); }
  315.   if (CC1000RadioIntM$pktsLastSync > 100) {
  316.       { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  317. #line 529
  318.         {
  319.           CC1000RadioIntM$ackOrig = CC1000RadioIntM$bAckEnable;
  320.           CC1000RadioIntM$bAckEnable = FALSE;
  321.         }
  322. #line 532
  323.         __nesc_atomic_end(__nesc_atomic); }
  324.       CC1000RadioIntM$Send$send(&CC1000RadioIntM$syncMsgHdr);
  325.       CC1000RadioIntM$pktsLastSync = 0;
  326.     }
  327.   else {
  328. #line 535
  329.     if (CC1000RadioIntM$currentMAC == CC1000RadioIntM$ZMAC && CC1000RadioIntM$ecnforward == TRUE) {
  330.         { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  331. #line 536
  332.           {
  333.             CC1000RadioIntM$ackOrig = CC1000RadioIntM$bAckEnable;
  334.             CC1000RadioIntM$bAckEnable = FALSE;
  335.           }
  336. #line 539
  337.           __nesc_atomic_end(__nesc_atomic); }
  338.         CC1000RadioIntM$Send$send(&CC1000RadioIntM$ecnForwardMsgHdr);
  339.         { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  340. #line 541
  341.           CC1000RadioIntM$ecnforward = FALSE;
  342. #line 541
  343.           __nesc_atomic_end(__nesc_atomic); }
  344.       }
  345.     else {
  347.       if (CC1000RadioIntM$currentMAC == CC1000RadioIntM$ZMAC && CC1000RadioIntM$ecnPending == TRUE) {
  348.           { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  349. #line 546
  350.             {
  351.               CC1000RadioIntM$ackOrig = CC1000RadioIntM$bAckEnable;
  352.               CC1000RadioIntM$bAckEnable = FALSE;
  353.             }
  354. #line 549
  355.             __nesc_atomic_end(__nesc_atomic); }
  356.           CC1000RadioIntM$Send$send(&CC1000RadioIntM$ecnMsgHdr);
  357.           { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  358. #line 551
  359.             CC1000RadioIntM$ecnPending = FALSE;
  360. #line 551
  361.             __nesc_atomic_end(__nesc_atomic); }
  362.           { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  363. #line 552
  364.             CC1000RadioIntM$slots_since_ecnsend = 0;
  365. #line 552
  366.             __nesc_atomic_end(__nesc_atomic); }
  367.         }
  368.       }
  369.     }
  370. }
  372. static inline 
  373. #line 329
  374. bool CC1000RadioIntM$IsHCL(uint32_t gSlot)
  375. #line 329
  376. {
  377.   uint32_t tempHCL = 0x1;
  378.   bool flag;
  380. #line 332
  381.   tempHCL = tempHCL << gSlot;
  382.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  383. #line 333
  384.     {
  385.       if (tempHCL & CC1000RadioIntM$curHCLlist) {
  386.         flag = TRUE;
  387.         }
  388.       else {
  389. #line 337
  390.         flag = FALSE;
  391.         }
  392.     }
  393. #line 339
  394.     __nesc_atomic_end(__nesc_atomic); }
  395. #line 339
  396.   return flag;
  397. }
  399. static inline   
  400. # 63 "/home/testuser/tinyos-1.x/tos/system/NoLeds.nc"
  401. result_t NoLeds$Leds$redToggle(void)
  402. #line 63
  403. {
  404.   return SUCCESS;
  405. }
  407. # 81 "/home/testuser/tinyos-1.x/tos/interfaces/Leds.nc"
  408. inline static   result_t CC1000RadioIntM$Leds$redToggle(void){
  409. #line 81
  410.   unsigned char result;
  411. #line 81
  413. #line 81
  414.   result = NoLeds$Leds$redToggle();
  415. #line 81
  417. #line 81
  418.   return result;
  419. #line 81
  420. }
  421. #line 81
  422. static inline    
  423. # 1791 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  424. void CC1000RadioIntM$RadioReceiveCoordinator$default$startSymbol(uint8_t bitsPerBlock, uint8_t offset, 
  425. TOS_MsgPtr msgBuff)
  426. #line 1792
  427. {
  428. }
  430. # 31 "../../tos/platform/mica2/RadioCoordinator.nc"
  431. inline static   void CC1000RadioIntM$RadioReceiveCoordinator$startSymbol(uint8_t arg_0x86d4858, uint8_t arg_0x86d49a0, TOS_MsgPtr arg_0x86d4af0){
  432. #line 31
  433.   CC1000RadioIntM$RadioReceiveCoordinator$default$startSymbol(arg_0x86d4858, arg_0x86d49a0, arg_0x86d4af0);
  434. #line 31
  435. }
  436. #line 31
  437. static inline    
  438. # 1793 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  439. void CC1000RadioIntM$RadioReceiveCoordinator$default$byte(TOS_MsgPtr msg, uint8_t byteCount)
  440. #line 1793
  441. {
  442. }
  444. # 36 "../../tos/platform/mica2/RadioCoordinator.nc"
  445. inline static   void CC1000RadioIntM$RadioReceiveCoordinator$byte(TOS_MsgPtr arg_0x86d4f68, uint8_t arg_0x86d50b8){
  446. #line 36
  447.   CC1000RadioIntM$RadioReceiveCoordinator$default$byte(arg_0x86d4f68, arg_0x86d50b8);
  448. #line 36
  449. }
  450. #line 36
  451. static inline 
  452. # 253 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  453. void CC1000RadioIntM$DivTime2(GTime *B, GTime *A)
  454. #line 253
  455. {
  456.   if (A->mticks % 2 == 1) {
  457.       B->mticks = A->mticks >> 1;
  458.       B->sticks = (A->sticks >> 1) + (CC1000RadioIntM$MAX_VAL >> 1);
  459.     }
  460.   else {
  461.       B->mticks = A->mticks >> 1;
  462.       B->sticks = A->sticks >> 1;
  463.     }
  464. }
  466. static inline 
  467. #line 306
  468. uint8_t CC1000RadioIntM$ModSubTime(GTime *C, GTime *A, GTime *B)
  469. #line 306
  470. {
  471.   uint8_t retval;
  473. #line 308
  474.   if (A->mticks > B->mticks) {
  475.     retval = CC1000RadioIntM$POSITIVE;
  476.     }
  477.   else {
  478. #line 310
  479.     if (A->mticks < B->mticks) {
  480.       retval = CC1000RadioIntM$NEGATIVE;
  481.       }
  482.     else 
  483. #line 312
  484.       {
  485.         if (A->sticks > B->sticks) {
  486.           retval = CC1000RadioIntM$POSITIVE;
  487.           }
  488.         else {
  489. #line 315
  490.           if (A->sticks < B->sticks) {
  491.             retval = CC1000RadioIntM$NEGATIVE;
  492.             }
  493.           else {
  494. #line 318
  495.             retval = CC1000RadioIntM$ZERO;
  496.             }
  497.           }
  498.       }
  499.     }
  500. #line 320
  501.   if (retval == CC1000RadioIntM$POSITIVE) {
  502. #line 320
  503.     CC1000RadioIntM$SubTime(C, A, B);
  504.     }
  505.   else {
  506. #line 321
  507.     if (retval == CC1000RadioIntM$NEGATIVE) {
  508. #line 321
  509.       CC1000RadioIntM$SubTime(C, B, A);
  510.       }
  511.     else 
  512. #line 322
  513.       {
  514.         C->sticks = 0;
  515.         C->mticks = 0;
  516.       }
  517.     }
  518. #line 326
  519.   return retval;
  520. }
  522. # 63 "../../tos/interfaces/SClock.nc"
  523. inline static   void CC1000RadioIntM$SClock$getTime(GTime *arg_0x8584228){
  524. #line 63
  525.   HPLSClock$SClock$getTime(arg_0x8584228);
  526. #line 63
  527. }
  528. #line 63
  529. static inline 
  530. # 387 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  531. void CC1000RadioIntM$getTimeDiff(void)
  532. #line 387
  533. {
  534.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  535. #line 388
  536.     {
  537.       uint16_t i;
  538. #line 389
  539.       uint16_t trust;
  540.       GTime loctime;
  541. #line 390
  542.       GTime timeStamp;
  543.       syncMsgType *syncMsgPtr = (syncMsgType *)CC1000RadioIntM$rxbufptr->data;
  545. #line 392
  546.       timeStamp.mticks = syncMsgPtr->mticks;
  547.       timeStamp.sticks = syncMsgPtr->sticks;
  548.       trust = syncMsgPtr->trust;
  549.       CC1000RadioIntM$currentSender = syncMsgPtr->sender;
  550.       CC1000RadioIntM$SClock$getTime(&loctime);
  551.       CC1000RadioIntM$currentSign = CC1000RadioIntM$ModSubTime(&CC1000RadioIntM$currentDiff, &timeStamp, &loctime);
  553.       if (trust < 1) {
  554.         trust = 1;
  555.         }
  556. #line 401
  557.       if (trust < 8) {
  558.           for (i = 0; i < trust; i++) {
  559.               CC1000RadioIntM$DivTime2(&CC1000RadioIntM$currentDiff, &CC1000RadioIntM$currentDiff);
  560.             }
  561.         }
  562.     }
  563. #line 406
  564.     __nesc_atomic_end(__nesc_atomic); }
  565. }
  567. static inline   
  568. # 107 "../../tos/platform/mica2/HPLSClock.nc"
  569. void HPLSClock$SClock$setTime(uint8_t PosOrNeg, GTime *t)
  570. #line 107
  571. {
  572.   HPLSClock$sign = PosOrNeg;
  573.   HPLSClock$Update.mticks = t->mticks;
  574.   HPLSClock$Update.sticks = t->sticks;
  575.   HPLSClock$needupdate = 1;
  576. }
  578. # 69 "../../tos/interfaces/SClock.nc"
  579. inline static   void CC1000RadioIntM$SClock$setTime(uint8_t arg_0x8584670, GTime *arg_0x85847d0){
  580. #line 69
  581.   HPLSClock$SClock$setTime(arg_0x8584670, arg_0x85847d0);
  582. #line 69
  583. }
  584. #line 69
  585. static inline  
  586. # 424 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  587. void CC1000RadioIntM$adjustTime(void)
  588. #line 424
  589. {
  590.   CC1000RadioIntM$needTimeSync = TRUE;
  591.   CC1000RadioIntM$SClock$setTime(CC1000RadioIntM$currentSign, &CC1000RadioIntM$currentDiff);
  592. }
  594. static inline  
  595. # 252 "/home/testuser/tinyos-1.x/tos/system/AMStandard.nc"
  596. TOS_MsgPtr AMStandard$RadioReceive$receive(TOS_MsgPtr packet)
  597. #line 252
  598. {
  599.   return received(packet);
  600. }
  602. # 75 "/home/testuser/tinyos-1.x/tos/interfaces/ReceiveMsg.nc"
  603. inline static  TOS_MsgPtr CC1000RadioIntM$Receive$receive(TOS_MsgPtr arg_0x856c0f0){
  604. #line 75
  605.   struct TOS_Msg *result;
  606. #line 75
  608. #line 75
  609.   result = AMStandard$RadioReceive$receive(arg_0x856c0f0);
  610. #line 75
  612. #line 75
  613.   return result;
  614. #line 75
  615. }
  616. #line 75
  617. static inline   
  618. # 1601 "../../tos/system/DrandM.nc"
  619. result_t DrandM$SClock$syncDone(void)
  620. #line 1601
  621. {
  622. #line 1601
  623.   return SUCCESS;
  624. }
  626. static inline   
  627. # 1806 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  628. result_t CC1000RadioIntM$SClock$syncDone(void)
  629. #line 1806
  630. {
  631.   if (CC1000RadioIntM$needTimeSync) {
  632.       GTime loctime;
  633.       uint32_t globalTimeStamp;
  634. #line 1809
  635.       uint32_t slotOffset;
  637. #line 1810
  638.       CC1000RadioIntM$SClock$getTime(&loctime);
  639.       globalTimeStamp = (uint32_t )(loctime.mticks * 568.889 + loctime.sticks * 0.00868056);
  640.       slotOffset = (uint32_t )(1.024 * (CC1000RadioIntM$slotSize - globalTimeStamp % CC1000RadioIntM$slotSize));
  641.       CC1000RadioIntM$slotNum = (uint32_t )(globalTimeStamp / CC1000RadioIntM$slotSize);
  642.       CC1000RadioIntM$currentSlot = CC1000RadioIntM$slotNum & (CC1000RadioIntM$localFrameLength - 1);
  643.       CC1000RadioIntM$globalSlot = CC1000RadioIntM$slotNum & (CC1000RadioIntM$globalFrameLength - 1);
  645.       if (CC1000RadioIntM$currentMAC == CC1000RadioIntM$ZMAC) {
  646.         CC1000RadioIntM$TDMATimer$start(TIMER_ONE_SHOT, slotOffset);
  647.         }
  648. #line 1819
  649.       CC1000RadioIntM$needTimeSync = FALSE;
  650.     }
  651.   return SUCCESS;
  652. }
  654. # 94 "../../tos/interfaces/SClock.nc"
  655. inline static   result_t HPLSClock$SClock$syncDone(void){
  656. #line 94
  657.   unsigned char result;
  658. #line 94
  660. #line 94
  661.   result = CC1000RadioIntM$SClock$syncDone();
  662. #line 94
  663.   result = rcombine(result, DrandM$SClock$syncDone());
  664. #line 94
  666. #line 94
  667.   return result;
  668. #line 94
  669. }
  670. #line 94
  671. # 66 "/home/testuser/tinyos-1.x/tos/interfaces/ByteComm.nc"
  672. inline static   result_t UARTM$ByteComm$rxByteReady(uint8_t arg_0x8978308, bool arg_0x8978450, uint16_t arg_0x89785a8){
  673. #line 66
  674.   unsigned char result;
  675. #line 66
  677. #line 66
  678.   result = FramerM$ByteComm$rxByteReady(arg_0x8978308, arg_0x8978450, arg_0x89785a8);
  679. #line 66
  681. #line 66
  682.   return result;
  683. #line 66
  684. }
  685. #line 66
  686. static inline   
  687. # 77 "/home/testuser/tinyos-1.x/tos/system/UARTM.nc"
  688. result_t UARTM$HPLUART$get(uint8_t data)
  689. #line 77
  690. {
  695.   UARTM$ByteComm$rxByteReady(data, FALSE, 0);
  696.   {
  697.   }
  698. #line 83
  699.   ;
  700.   return SUCCESS;
  701. }
  703. # 88 "/home/testuser/tinyos-1.x/tos/interfaces/HPLUART.nc"
  704. inline static   result_t HPLUART0M$UART$get(uint8_t arg_0x89be800){
  705. #line 88
  706.   unsigned char result;
  707. #line 88
  709. #line 88
  710.   result = UARTM$HPLUART$get(arg_0x89be800);
  711. #line 88
  713. #line 88
  714.   return result;
  715. #line 88
  716. }
  717. #line 88
  718. # 90 "../../tos/platform/mica2/HPLUART0M.nc"
  719. void __attribute((signal))   __vector_18(void)
  720. #line 90
  721. {
  722.   if (* (volatile uint8_t *)(0x0B + 0x20) & (1 << 7)) {
  723.     HPLUART0M$UART$get(* (volatile uint8_t *)(0x0C + 0x20));
  724.     }
  725. }
  727. static inline  
  728. # 202 "/home/testuser/tinyos-1.x/tos/system/FramerM.nc"
  729. void FramerM$PacketUnknown(void)
  730. #line 202
  731. {
  732.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  733. #line 203
  734.     {
  735.       FramerM$gFlags |= FramerM$FLAGS_UNKNOWN;
  736.     }
  737. #line 205
  738.     __nesc_atomic_end(__nesc_atomic); }
  740.   FramerM$StartTx();
  741. }
  743. static inline  
  744. # 246 "/home/testuser/tinyos-1.x/tos/system/AMStandard.nc"
  745. TOS_MsgPtr AMStandard$UARTReceive$receive(TOS_MsgPtr packet)
  746. #line 246
  747. {
  750.   packet->group = TOS_AM_GROUP;
  751.   return received(packet);
  752. }
  754. # 75 "/home/testuser/tinyos-1.x/tos/interfaces/ReceiveMsg.nc"
  755. inline static  TOS_MsgPtr FramerAckM$ReceiveCombined$receive(TOS_MsgPtr arg_0x856c0f0){
  756. #line 75
  757.   struct TOS_Msg *result;
  758. #line 75
  760. #line 75
  761.   result = AMStandard$UARTReceive$receive(arg_0x856c0f0);
  762. #line 75
  764. #line 75
  765.   return result;
  766. #line 75
  767. }
  768. #line 75
  769. static inline  
  770. # 91 "/home/testuser/tinyos-1.x/tos/system/FramerAckM.nc"
  771. TOS_MsgPtr FramerAckM$ReceiveMsg$receive(TOS_MsgPtr Msg)
  772. #line 91
  773. {
  774.   TOS_MsgPtr pBuf;
  776.   pBuf = FramerAckM$ReceiveCombined$receive(Msg);
  778.   return pBuf;
  779. }
  781. # 75 "/home/testuser/tinyos-1.x/tos/interfaces/ReceiveMsg.nc"
  782. inline static  TOS_MsgPtr FramerM$ReceiveMsg$receive(TOS_MsgPtr arg_0x856c0f0){
  783. #line 75
  784.   struct TOS_Msg *result;
  785. #line 75
  787. #line 75
  788.   result = FramerAckM$ReceiveMsg$receive(arg_0x856c0f0);
  789. #line 75
  791. #line 75
  792.   return result;
  793. #line 75
  794. }
  795. #line 75
  796. static inline  
  797. # 328 "/home/testuser/tinyos-1.x/tos/system/FramerM.nc"
  798. result_t FramerM$TokenReceiveMsg$ReflectToken(uint8_t Token)
  799. #line 328
  800. {
  801.   result_t Result = SUCCESS;
  803.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  804. #line 331
  805.     {
  806.       if (!(FramerM$gFlags & FramerM$FLAGS_TOKENPEND)) {
  807.           FramerM$gFlags |= FramerM$FLAGS_TOKENPEND;
  808.           FramerM$gTxTokenBuf = Token;
  809.         }
  810.       else {
  811.           Result = FAIL;
  812.         }
  813.     }
  814. #line 339
  815.     __nesc_atomic_end(__nesc_atomic); }
  817.   if (Result == SUCCESS) {
  818.       Result = FramerM$StartTx();
  819.     }
  821.   return Result;
  822. }
  824. # 88 "/home/testuser/tinyos-1.x/tos/interfaces/TokenReceiveMsg.nc"
  825. inline static  result_t FramerAckM$TokenReceiveMsg$ReflectToken(uint8_t arg_0x897a0e8){
  826. #line 88
  827.   unsigned char result;
  828. #line 88
  830. #line 88
  831.   result = FramerM$TokenReceiveMsg$ReflectToken(arg_0x897a0e8);
  832. #line 88
  834. #line 88
  835.   return result;
  836. #line 88
  837. }
  838. #line 88
  839. static inline  
  840. # 74 "/home/testuser/tinyos-1.x/tos/system/FramerAckM.nc"
  841. void FramerAckM$SendAckTask(void)
  842. #line 74
  843. {
  845.   FramerAckM$TokenReceiveMsg$ReflectToken(FramerAckM$gTokenBuf);
  846. }
  848. static inline  TOS_MsgPtr FramerAckM$TokenReceiveMsg$receive(TOS_MsgPtr Msg, uint8_t token)
  849. #line 79
  850. {
  851.   TOS_MsgPtr pBuf;
  853.   FramerAckM$gTokenBuf = token;
  855.   TOS_post(FramerAckM$SendAckTask);
  857.   pBuf = FramerAckM$ReceiveCombined$receive(Msg);
  859.   return pBuf;
  860. }
  862. # 75 "/home/testuser/tinyos-1.x/tos/interfaces/TokenReceiveMsg.nc"
  863. inline static  TOS_MsgPtr FramerM$TokenReceiveMsg$receive(TOS_MsgPtr arg_0x897f970, uint8_t arg_0x897fab8){
  864. #line 75
  865.   struct TOS_Msg *result;
  866. #line 75
  868. #line 75
  869.   result = FramerAckM$TokenReceiveMsg$receive(arg_0x897f970, arg_0x897fab8);
  870. #line 75
  872. #line 75
  873.   return result;
  874. #line 75
  875. }
  876. #line 75
  877. static inline  
  878. # 210 "/home/testuser/tinyos-1.x/tos/system/FramerM.nc"
  879. void FramerM$PacketRcvd(void)
  880. #line 210
  881. {
  882.   FramerM$MsgRcvEntry_t *pRcv = &FramerM$gMsgRcvTbl[FramerM$gRxTailIndex];
  883.   TOS_MsgPtr pBuf = pRcv->pMsg;
  886.   if (pRcv->Length >= (size_t )& ((TOS_Msg *)0)->data) {
  888.       switch (pRcv->Proto) {
  889.           case FramerM$PROTO_ACK: 
  890.             break;
  891.           case FramerM$PROTO_PACKET_ACK: 
  892.             pBuf->crc = 1;
  893.           pBuf = FramerM$TokenReceiveMsg$receive(pBuf, pRcv->Token);
  894.           break;
  895.           case FramerM$PROTO_PACKET_NOACK: 
  896.             pBuf->crc = 1;
  897.           pBuf = FramerM$ReceiveMsg$receive(pBuf);
  898.           break;
  899.           default: 
  900.             FramerM$gTxUnknownBuf = pRcv->Proto;
  901.           TOS_post(FramerM$PacketUnknown);
  902.           break;
  903.         }
  904.     }
  906.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  907. #line 235
  908.     {
  909.       if (pBuf) {
  910.           pRcv->pMsg = pBuf;
  911.         }
  912.       pRcv->Length = 0;
  913.       pRcv->Token = 0;
  914.       FramerM$gRxTailIndex++;
  915.       FramerM$gRxTailIndex %= FramerM$HDLC_QUEUESIZE;
  916.     }
  917. #line 243
  918.     __nesc_atomic_end(__nesc_atomic); }
  919. }
  921. # 96 "/home/testuser/tinyos-1.x/tos/interfaces/HPLUART.nc"
  922. inline static   result_t HPLUART0M$UART$putDone(void){
  923. #line 96
  924.   unsigned char result;
  925. #line 96
  927. #line 96
  928.   result = UARTM$HPLUART$putDone();
  929. #line 96
  931. #line 96
  932.   return result;
  933. #line 96
  934. }
  935. #line 96
  936. # 100 "../../tos/platform/mica2/HPLUART0M.nc"
  937. void __attribute((interrupt))   __vector_20(void)
  938. #line 100
  939. {
  940.   HPLUART0M$UART$putDone();
  941. }
  943. static inline   
  944. # 552 "/home/testuser/tinyos-1.x/tos/system/FramerM.nc"
  945. result_t FramerM$ByteComm$txDone(void)
  946. #line 552
  947. {
  949.   if (FramerM$gTxState == FramerM$TXSTATE_FINISH) {
  950.       FramerM$gTxState = FramerM$TXSTATE_IDLE;
  951.       TOS_post(FramerM$PacketSent);
  952.     }
  954.   return SUCCESS;
  955. }
  957. # 83 "/home/testuser/tinyos-1.x/tos/interfaces/ByteComm.nc"
  958. inline static   result_t UARTM$ByteComm$txDone(void){
  959. #line 83
  960.   unsigned char result;
  961. #line 83
  963. #line 83
  964.   result = FramerM$ByteComm$txDone();
  965. #line 83
  967. #line 83
  968.   return result;
  969. #line 83
  970. }
  971. #line 83
  972. #line 55
  973. inline static   result_t FramerM$ByteComm$txByte(uint8_t arg_0x897bdd8){
  974. #line 55
  975.   unsigned char result;
  976. #line 55
  978. #line 55
  979.   result = UARTM$ByteComm$txByte(arg_0x897bdd8);
  980. #line 55
  982. #line 55
  983.   return result;
  984. #line 55
  985. }
  986. #line 55
  987. static inline 
  988. # 66 "/home/testuser/tinyos-1.x/tos/platform/avrmote/crc.h"
  989. uint16_t crcByte(uint16_t oldCrc, uint8_t byte)
  990. {
  992.   uint16_t *table = crcTable;
  993.   uint16_t newCrc;
  995.    __asm ("eor %1,%B3n"
  996.   "tlsl %1n"
  997.   "tadc %B2, __zero_reg__n"
  998.   "tadd %A2, %1n"
  999.   "tadc %B2, __zero_reg__n"
  1000.   "tlpmn"
  1001.   "tmov %B0, %A3n"
  1002.   "tmov %A0, r0n"
  1003.   "tadiw r30,1n"
  1004.   "tlpmn"
  1005.   "teor %B0, r0" : 
  1006.   "=r"(newCrc), "+r"(byte), "+z"(table) : "r"(oldCrc));
  1007.   return newCrc;
  1008. }
  1010. static inline   
  1011. # 482 "/home/testuser/tinyos-1.x/tos/system/FramerM.nc"
  1012. result_t FramerM$ByteComm$txByteReady(bool LastByteSuccess)
  1013. #line 482
  1014. {
  1015.   result_t TxResult = SUCCESS;
  1016.   uint8_t nextByte;
  1018.   if (LastByteSuccess != TRUE) {
  1019.       { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1020. #line 487
  1021.         FramerM$gTxState = FramerM$TXSTATE_ERROR;
  1022. #line 487
  1023.         __nesc_atomic_end(__nesc_atomic); }
  1024.       TOS_post(FramerM$PacketSent);
  1025.       return SUCCESS;
  1026.     }
  1028.   switch (FramerM$gTxState) {
  1030.       case FramerM$TXSTATE_PROTO: 
  1031.         FramerM$gTxState = FramerM$TXSTATE_INFO;
  1032.       FramerM$gTxRunningCRC = crcByte(FramerM$gTxRunningCRC, (uint8_t )(FramerM$gTxProto & 0x0FF));
  1033.       TxResult = FramerM$ByteComm$txByte((uint8_t )(FramerM$gTxProto & 0x0FF));
  1034.       break;
  1036.       case FramerM$TXSTATE_INFO: 
  1037.         nextByte = FramerM$gpTxBuf[FramerM$gTxByteCnt];
  1039.       FramerM$gTxRunningCRC = crcByte(FramerM$gTxRunningCRC, nextByte);
  1040.       FramerM$gTxByteCnt++;
  1041.       if (FramerM$gTxByteCnt >= FramerM$gTxLength) {
  1042.           FramerM$gTxState = FramerM$TXSTATE_FCS1;
  1043.         }
  1045.       TxResult = FramerM$TxArbitraryByte(nextByte);
  1046.       break;
  1048.       case FramerM$TXSTATE_ESC: 
  1050.         TxResult = FramerM$ByteComm$txByte(FramerM$gTxEscByte ^ 0x20);
  1051.       FramerM$gTxState = FramerM$gPrevTxState;
  1052.       break;
  1054.       case FramerM$TXSTATE_FCS1: 
  1055.         nextByte = (uint8_t )(FramerM$gTxRunningCRC & 0xff);
  1056.       FramerM$gTxState = FramerM$TXSTATE_FCS2;
  1057.       TxResult = FramerM$TxArbitraryByte(nextByte);
  1058.       break;
  1060.       case FramerM$TXSTATE_FCS2: 
  1061.         nextByte = (uint8_t )((FramerM$gTxRunningCRC >> 8) & 0xff);
  1062.       FramerM$gTxState = FramerM$TXSTATE_ENDFLAG;
  1063.       TxResult = FramerM$TxArbitraryByte(nextByte);
  1064.       break;
  1066.       case FramerM$TXSTATE_ENDFLAG: 
  1067.         FramerM$gTxState = FramerM$TXSTATE_FINISH;
  1068.       TxResult = FramerM$ByteComm$txByte(FramerM$HDLC_FLAG_BYTE);
  1070.       break;
  1072.       case FramerM$TXSTATE_FINISH: 
  1073.         case FramerM$TXSTATE_ERROR: 
  1075.           default: 
  1076.             break;
  1077.     }
  1080.   if (TxResult != SUCCESS) {
  1081.       FramerM$gTxState = FramerM$TXSTATE_ERROR;
  1082.       TOS_post(FramerM$PacketSent);
  1083.     }
  1085.   return SUCCESS;
  1086. }
  1088. # 75 "/home/testuser/tinyos-1.x/tos/interfaces/ByteComm.nc"
  1089. inline static   result_t UARTM$ByteComm$txByteReady(bool arg_0x8978ad8){
  1090. #line 75
  1091.   unsigned char result;
  1092. #line 75
  1094. #line 75
  1095.   result = FramerM$ByteComm$txByteReady(arg_0x8978ad8);
  1096. #line 75
  1098. #line 75
  1099.   return result;
  1100. #line 75
  1101. }
  1102. #line 75
  1103. # 102 "/home/testuser/tinyos-1.x/tos/system/sched.c"
  1104. bool  TOS_post(void (*tp)(void))
  1105. #line 102
  1106. {
  1107.   __nesc_atomic_t fInterruptFlags;
  1108.   uint8_t tmp;
  1112.   fInterruptFlags = __nesc_atomic_start();
  1114.   tmp = TOSH_sched_free;
  1116.   if (TOSH_queue[tmp].tp == (void *)0) {
  1117.       TOSH_sched_free = (tmp + 1) & TOSH_TASK_BITMASK;
  1118.       TOSH_queue[tmp].tp = tp;
  1119.       __nesc_atomic_end(fInterruptFlags);
  1121.       return TRUE;
  1122.     }
  1123.   else {
  1124.       __nesc_atomic_end(fInterruptFlags);
  1126.       return FALSE;
  1127.     }
  1128. }
  1130. # 54 "/home/testuser/tinyos-1.x/tos/system/RealMain.nc"
  1131. int   main(void)
  1132. #line 54
  1133. {
  1134.   RealMain$hardwareInit();
  1135.   RealMain$Pot$init(10);
  1136.   TOSH_sched_init();
  1138.   RealMain$StdControl$init();
  1139.   RealMain$StdControl$start();
  1140.   __nesc_enable_interrupt();
  1142.   while (1) {
  1143.       TOSH_run_task();
  1144.     }
  1145. }
  1147. static  
  1148. # 77 "/home/testuser/tinyos-1.x/tos/system/TimerM.nc"
  1149. result_t TimerM$StdControl$init(void)
  1150. #line 77
  1151. {
  1152.   TimerM$mState = 0;
  1153.   TimerM$setIntervalFlag = 0;
  1154.   TimerM$queue_head = TimerM$queue_tail = -1;
  1155.   TimerM$queue_size = 0;
  1156.   TimerM$mScale = 3;
  1157.   TimerM$mInterval = TimerM$maxTimerInterval;
  1158.   return TimerM$Clock$setRate(TimerM$mInterval, TimerM$mScale);
  1159. }
  1161. static 
  1162. # 268 "/home/testuser/tinyos-1.x/tos/system/FramerM.nc"
  1163. void FramerM$HDLCInitialize(void)
  1164. #line 268
  1165. {
  1166.   int i;
  1168. #line 270
  1169.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1170. #line 270
  1171.     {
  1172.       for (i = 0; i < FramerM$HDLC_QUEUESIZE; i++) {
  1173.           FramerM$gMsgRcvTbl[i].pMsg = &FramerM$gMsgRcvBuf[i];
  1174.           FramerM$gMsgRcvTbl[i].Length = 0;
  1175.           FramerM$gMsgRcvTbl[i].Token = 0;
  1176.         }
  1177.       FramerM$gTxState = FramerM$TXSTATE_IDLE;
  1178.       FramerM$gTxByteCnt = 0;
  1179.       FramerM$gTxLength = 0;
  1180.       FramerM$gTxRunningCRC = 0;
  1181.       FramerM$gpTxMsg = (void *)0;
  1183.       FramerM$gRxState = FramerM$RXSTATE_NOSYNC;
  1184.       FramerM$gRxHeadIndex = 0;
  1185.       FramerM$gRxTailIndex = 0;
  1186.       FramerM$gRxByteCnt = 0;
  1187.       FramerM$gRxRunningCRC = 0;
  1188.       FramerM$gpRxBuf = (uint8_t *)FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].pMsg;
  1189.     }
  1190. #line 288
  1191.     __nesc_atomic_end(__nesc_atomic); }
  1192. }
  1194. static   
  1195. # 75 "../../tos/platform/mica2/HPLCC1000M.nc"
  1196. result_t HPLCC1000M$HPLCC1000$write(uint8_t addr, uint8_t data)
  1197. #line 75
  1198. {
  1199.   char cnt = 0;
  1202.   addr <<= 1;
  1203.   TOSH_CLR_CC_PALE_PIN();
  1204.   for (cnt = 0; cnt < 7; cnt++) 
  1205.     {
  1206.       if (addr & 0x80) {
  1207.         TOSH_SET_CC_PDATA_PIN();
  1208.         }
  1209.       else {
  1210. #line 86
  1211.         TOSH_CLR_CC_PDATA_PIN();
  1212.         }
  1213. #line 87
  1214.       TOSH_CLR_CC_PCLK_PIN();
  1215.       TOSH_SET_CC_PCLK_PIN();
  1216.       addr <<= 1;
  1217.     }
  1218.   TOSH_SET_CC_PDATA_PIN();
  1219.   TOSH_CLR_CC_PCLK_PIN();
  1220.   TOSH_SET_CC_PCLK_PIN();
  1222.   TOSH_SET_CC_PALE_PIN();
  1225.   for (cnt = 0; cnt < 8; cnt++) 
  1226.     {
  1227.       if (data & 0x80) {
  1228.         TOSH_SET_CC_PDATA_PIN();
  1229.         }
  1230.       else {
  1231. #line 103
  1232.         TOSH_CLR_CC_PDATA_PIN();
  1233.         }
  1234. #line 104
  1235.       TOSH_CLR_CC_PCLK_PIN();
  1236.       TOSH_SET_CC_PCLK_PIN();
  1237.       data <<= 1;
  1238.     }
  1239.   TOSH_SET_CC_PALE_PIN();
  1240.   TOSH_SET_CC_PDATA_PIN();
  1241.   TOSH_SET_CC_PCLK_PIN();
  1242.   return SUCCESS;
  1243. }
  1245. static   
  1246. #line 128
  1247. uint8_t HPLCC1000M$HPLCC1000$read(uint8_t addr)
  1248. #line 128
  1249. {
  1250.   int cnt;
  1251.   uint8_t din;
  1252.   uint8_t data = 0;
  1255.   addr <<= 1;
  1256.   TOSH_CLR_CC_PALE_PIN();
  1257.   for (cnt = 0; cnt < 7; cnt++) 
  1258.     {
  1259.       if (addr & 0x80) {
  1260.         TOSH_SET_CC_PDATA_PIN();
  1261.         }
  1262.       else {
  1263. #line 141
  1264.         TOSH_CLR_CC_PDATA_PIN();
  1265.         }
  1266. #line 142
  1267.       TOSH_CLR_CC_PCLK_PIN();
  1268.       TOSH_SET_CC_PCLK_PIN();
  1269.       addr <<= 1;
  1270.     }
  1271.   TOSH_CLR_CC_PDATA_PIN();
  1272.   TOSH_CLR_CC_PCLK_PIN();
  1273.   TOSH_SET_CC_PCLK_PIN();
  1275.   TOSH_MAKE_CC_PDATA_INPUT();
  1276.   TOSH_SET_CC_PALE_PIN();
  1279.   for (cnt = 7; cnt >= 0; cnt--) 
  1280.     {
  1281.       TOSH_CLR_CC_PCLK_PIN();
  1282.       din = TOSH_READ_CC_PDATA_PIN();
  1283.       if (din) {
  1284.         data = (data << 1) | 0x01;
  1285.         }
  1286.       else {
  1287. #line 161
  1288.         data = (data << 1) & 0xfe;
  1289.         }
  1290. #line 162
  1291.       TOSH_SET_CC_PCLK_PIN();
  1292.     }
  1294.   TOSH_SET_CC_PALE_PIN();
  1295.   TOSH_MAKE_CC_PDATA_OUTPUT();
  1296.   TOSH_SET_CC_PDATA_PIN();
  1298.   return data;
  1299. }
  1301. static 
  1302. # 63 "../../tos/platform/mica2/HPLADCM.nc"
  1303. void HPLADCM$init_portmap(void)
  1304. #line 63
  1305. {
  1307.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1308. #line 65
  1309.     {
  1310.       if (HPLADCM$init_portmap_done == FALSE) {
  1311.           int i;
  1313. #line 68
  1314.           for (i = 0; i < TOSH_ADC_PORTMAPSIZE; i++) 
  1315.             HPLADCM$TOSH_adc_portmap[i] = i;
  1318.           HPLADCM$TOSH_adc_portmap[TOS_ADC_BANDGAP_PORT] = TOSH_ACTUAL_BANDGAP_PORT;
  1319.           HPLADCM$TOSH_adc_portmap[TOS_ADC_GND_PORT] = TOSH_ACTUAL_GND_PORT;
  1320.           HPLADCM$init_portmap_done = TRUE;
  1321.         }
  1322.     }
  1323. #line 76
  1324.     __nesc_atomic_end(__nesc_atomic); }
  1325. }
  1327. static   
  1328. # 95 "../../tos/platform/mica2/HPLSClock.nc"
  1329. void HPLSClock$SClock$getTime(GTime *t)
  1330. #line 95
  1331. {
  1332.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1333. #line 96
  1334.     {
  1335.       t->sticks = * (volatile uint16_t *)0x88;
  1336.       if (* (volatile uint8_t *)(uint16_t )& * (volatile uint8_t *)0x7C & (1 << 4)) {
  1337.           HPLSClock$MTicks++;
  1338.           * (volatile uint8_t *)0x7C |= 1 << 4;
  1339.           HPLSClock$SClock$fire(HPLSClock$MTicks);
  1340.         }
  1341.       t->mticks = HPLSClock$MTicks;
  1342.     }
  1343. #line 104
  1344.     __nesc_atomic_end(__nesc_atomic); }
  1345. }
  1347. static   
  1348. # 435 "../../tos/platform/mica2/CC1000ControlM.nc"
  1349. result_t CC1000ControlM$CC1000Control$RxMode(void)
  1350. #line 435
  1351. {
  1354.   CC1000ControlM$HPLChipcon$write(0x09, CC1000ControlM$gCurrentParameters[0x09]);
  1355.   CC1000ControlM$HPLChipcon$write(0x0B, 0x00);
  1356.   CC1000ControlM$HPLChipcon$write(0x00, (
  1357.   1 << 4) | (1 << 0));
  1359.   TOSH_uwait(125);
  1360.   return SUCCESS;
  1361. }
  1363. static  
  1364. # 98 "/home/testuser/tinyos-1.x/tos/system/TimerM.nc"
  1365. result_t TimerM$Timer$start(uint8_t id, char type, 
  1366. uint32_t interval)
  1367. #line 99
  1368. {
  1369.   uint8_t diff;
  1371. #line 101
  1372.   if (id >= NUM_TIMERS) {
  1373. #line 101
  1374.     return FAIL;
  1375.     }
  1376. #line 102
  1377.   if (type > TIMER_ONE_SHOT) {
  1378. #line 102
  1379.     return FAIL;
  1380.     }
  1386.   if (type == TIMER_REPEAT && interval <= 2) {
  1387. #line 109
  1388.     return FAIL;
  1389.     }
  1390.   TimerM$mTimerList[id].ticks = interval;
  1391.   TimerM$mTimerList[id].type = type;
  1393.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1394. #line 114
  1395.     {
  1396.       diff = TimerM$Clock$readCounter();
  1397.       interval += diff;
  1398.       TimerM$mTimerList[id].ticksLeft = interval;
  1399.       TimerM$mState |= 0x1L << id;
  1400.       if (interval < TimerM$mInterval) {
  1401.           TimerM$mInterval = interval;
  1402.           TimerM$Clock$setInterval(TimerM$mInterval);
  1403.           TimerM$setIntervalFlag = 0;
  1404.           TimerM$PowerManagement$adjustPower();
  1405.         }
  1406.     }
  1407. #line 125
  1408.     __nesc_atomic_end(__nesc_atomic); }
  1409.   return SUCCESS;
  1410. }
  1412. static   
  1413. # 102 "../../tos/platform/mica2/HPLPowerManagementM.nc"
  1414. uint8_t HPLPowerManagementM$PowerManagement$adjustPower(void)
  1415. #line 102
  1416. {
  1417.   uint8_t mcu;
  1419. #line 104
  1420.   if (HPLPowerManagementM$disableCount <= 0) {
  1421.     TOS_post(HPLPowerManagementM$doAdjustment);
  1422.     }
  1423.   else 
  1424. #line 106
  1425.     {
  1426.       mcu = * (volatile uint8_t *)(0x35 + 0x20);
  1427.       mcu &= 0xe3;
  1428.       mcu |= HPLPowerManagementM$IDLE;
  1429.       * (volatile uint8_t *)(0x35 + 0x20) = mcu;
  1430.       * (volatile uint8_t *)(0x35 + 0x20) |= 1 << 5;
  1431.     }
  1432.   return 0;
  1433. }
  1435. static 
  1436. # 501 "../../tos/system/DrandM.nc"
  1437. uint16_t DrandM$randNew(void)
  1438. #line 501
  1439. {
  1440.   bool endbit;
  1441.   uint16_t tmpShiftReg;
  1443. #line 504
  1444.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1445. #line 504
  1446.     {
  1447.       tmpShiftReg = DrandM$shiftReg;
  1448.       endbit = (tmpShiftReg & 0x8000) != 0;
  1449.       tmpShiftReg <<= 1;
  1450.       if (endbit) {
  1451.         tmpShiftReg ^= 0x100b;
  1452.         }
  1453. #line 510
  1454.       tmpShiftReg++;
  1455.       DrandM$shiftReg = tmpShiftReg;
  1456.       tmpShiftReg = tmpShiftReg ^ DrandM$mask;
  1457.     }
  1458. #line 513
  1459.     __nesc_atomic_end(__nesc_atomic); }
  1460.   return tmpShiftReg;
  1461. }
  1463. # 215 "/home/testuser/tinyos-1.x/tos/system/AMStandard.nc"
  1464. TOS_MsgPtr   received(TOS_MsgPtr packet)
  1465. #line 215
  1466. {
  1467.   uint16_t addr = TOS_LOCAL_ADDRESS;
  1469. #line 217
  1470.   AMStandard$counter++;
  1471.   {
  1472.   }
  1473. #line 218
  1474.   ;
  1477.   if (
  1478. #line 220
  1479.   packet->crc == 1 && 
  1480.   packet->group == TOS_AM_GROUP && (
  1481.   packet->addr == TOS_BCAST_ADDR || 
  1482.   packet->addr == addr)) 
  1483.     {
  1485.       uint8_t type = packet->type;
  1486.       TOS_MsgPtr tmp;
  1488.       {
  1489.       }
  1490. #line 229
  1491.       ;
  1492.       AMStandard$dbgPacket(packet);
  1493.       {
  1494.       }
  1495. #line 231
  1496.       ;
  1499.       tmp = AMStandard$ReceiveMsg$receive(type, packet);
  1500.       if (tmp) {
  1501.         packet = tmp;
  1502.         }
  1503.     }
  1504. #line 238
  1505.   return packet;
  1506. }
  1508. static 
  1509. # 204 "../../tos/system/DrandM.nc"
  1510. int DrandM$isPresentHelloID(uint8_t node, uint8_t *array, uint8_t max)
  1511. #line 204
  1512. {
  1514.   uint8_t i;
  1516. #line 207
  1517.   for (i = 0; i < max; i++) 
  1518.     if (array[i] == node) {
  1519.       return i;
  1520.       }
  1521. #line 210
  1522.   return -1;
  1523. }
  1525. static 
  1526. #line 366
  1527. void DrandM$addHelloID(uint8_t node, uint8_t *array)
  1528. #line 366
  1529. {
  1530.   uint8_t i;
  1532. #line 368
  1533.   if (node == TOS_LOCAL_ADDRESS) {
  1534. #line 368
  1535.     return;
  1536.     }
  1537. #line 369
  1538.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1539. #line 369
  1540.     {
  1541.       for (i = 0; i < MAX_NBR && array[i] != 0xFF && array[i] != node; i++) ;
  1542.       if (i == MAX_NBR) {
  1544.           {
  1545. #line 373
  1546.             char bStatus;
  1548. #line 373
  1549.             if (DBG_USR2 != 0) {
  1550. #line 373
  1551.                 bStatus = * (volatile uint8_t *)(uint16_t )& * (volatile uint8_t *)(0x3F + 0x20) & (1 << 7);
  1552. #line 373
  1553.                  __asm volatile ("cli");DrandM$sprintf(DrandM$debugbuf, "addNode: No space to add noden");
  1554. #line 373
  1555.                 DrandM$writedebug();
  1556. #line 373
  1557.                 if (bStatus) {
  1558. #line 373
  1559.                    __asm volatile ("sei");
  1560.                   }
  1561.               }
  1562.           }
  1563. #line 373
  1564.           ;
  1565.         }
  1566.       else {
  1567. #line 375
  1568.         if (array[i] != node) {
  1569.           array[i] = node;
  1570.           }
  1571.         }
  1572.     }
  1573. #line 379
  1574.     __nesc_atomic_end(__nesc_atomic); }
  1575. }
  1577. static 
  1578. # 52 "../../tos/interfaces/SODebug.h"
  1579. int DrandM$sprintf(uint8_t *buf, const uint8_t *format, ...)
  1581. {
  1582.   uint8_t scratch[64];
  1583.   uint8_t format_flag;
  1584.   uint16_t u_val = 0;
  1585. #line 57
  1586.   uint16_t base;
  1587.   uint8_t *ptr;
  1588.   DrandM$va_list ap;
  1589.   bool b_ChkForNegInt = FALSE;
  1591.   __builtin_va_start(ap, format);
  1592.   for (; ; ) {
  1593.       while ((format_flag = * format++) != '%') {
  1594.           if (!format_flag) {
  1595. #line 65
  1596.               __builtin_va_end(ap);
  1597. #line 65
  1598.               return 0;
  1599.             }
  1600. #line 66
  1601.           *buf = format_flag;
  1602. #line 66
  1603.           buf++;
  1604. #line 66
  1605.           *buf = 0;
  1606.         }
  1607.       b_ChkForNegInt = FALSE;
  1608.       switch ((format_flag = * format++)) {
  1610.           case 'c': 
  1611.             format_flag = (__builtin_va_arg(ap, int ));
  1612.           default: 
  1613.             *buf = format_flag;
  1614. #line 74
  1615.           buf++;
  1616. #line 74
  1617.           *buf = 0;
  1618.           continue;
  1619.           case 'S': 
  1620.             case 's': 
  1621.               ptr = (__builtin_va_arg(ap, char *));
  1622.           strcat(buf, ptr);
  1623.           continue;
  1624.           case 'o': 
  1625.             base = 8;
  1626.           *buf = '0';
  1627. #line 83
  1628.           buf++;
  1629. #line 83
  1630.           *buf = 0;
  1631.           goto CONVERSION_LOOP;
  1632.           case 'i': 
  1633.             b_ChkForNegInt = TRUE;
  1639.           case 'u': 
  1640.             base = 10;
  1641.           goto CONVERSION_LOOP;
  1642.           case 'x': 
  1643.             base = 16;
  1645.           CONVERSION_LOOP: 
  1646.             u_val = (__builtin_va_arg(ap, int ));
  1647.           if (b_ChkForNegInt) {
  1648.               if ((int )u_val < 0) {
  1649.                   u_val = -u_val;
  1650.                   *buf = '-';
  1651. #line 103
  1652.                   buf++;
  1653. #line 103
  1654.                   *buf = 0;
  1655.                 }
  1656.             }
  1658.           ptr = scratch + 64;
  1659.           * --ptr = 0;
  1660.           do {
  1661.               char ch = u_val % base + '0';
  1663. #line 111
  1664.               if (ch > '9') {
  1665.                 ch += 'a' - '9' - 1;
  1666.                 }
  1667. #line 113
  1668.               * --ptr = ch;
  1669.               u_val /= base;
  1670.             }
  1671.           while (
  1672. #line 115
  1673.           u_val);
  1674.           strcat(buf, ptr);
  1675.           buf += strlen(ptr);
  1676.         }
  1677.     }
  1678. }
  1680. static 
  1681. #line 42
  1682. void DrandM$writedebug(void)
  1683. #line 42
  1684. {
  1685.   int i = 0;
  1687. #line 44
  1688.   DrandM$UARTPutChar('n');
  1689.   while (DrandM$debugbuf[i] != 'n') 
  1690.     DrandM$UARTPutChar(DrandM$debugbuf[i++]);
  1691. }
  1693. static 
  1694. #line 35
  1695. void DrandM$UARTPutChar(char c)
  1696. #line 35
  1697. {
  1698.   if (c == 'n') {
  1699.     DrandM$UARTPutChar('r');
  1700.     }
  1701. #line 38
  1702.   do {
  1703.     }
  1704.   while (
  1705. #line 38
  1706.   !(* (volatile uint8_t *)(uint16_t )& * (volatile uint8_t *)(0x0B + 0x20) & (1 << 5)));
  1707.   * (volatile uint8_t *)(0x0C + 0x20) = c;
  1708. }
  1710. static 
  1711. # 380 "../../tos/system/DrandM.nc"
  1712. void DrandM$removeHelloID(uint8_t node, uint8_t *array)
  1713. #line 380
  1714. {
  1715.   uint8_t i;
  1717. #line 382
  1718.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1719. #line 382
  1720.     {
  1721.       for (i = 0; i < MAX_NBR && array[i] != 0xFF && array[i] != node; i++) ;
  1722.       if (i != MAX_NBR && array[i] == node) {
  1723.           for (; i < MAX_NBR - 1; i++) 
  1724.             array[i] = array[i + 1];
  1725.           array[MAX_NBR - 1] = 0xFF;
  1726.         }
  1727.     }
  1728. #line 389
  1729.     __nesc_atomic_end(__nesc_atomic); }
  1730. }
  1732. static 
  1733. #line 579
  1734. void DrandM$sendHelloMsg(void)
  1735. #line 579
  1736. {
  1737.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1738. #line 580
  1739.     {
  1740.       if (!DrandM$sendBusy) {
  1741.           uint8_t i = 0;
  1742. #line 582
  1743.           uint8_t j = 0;
  1744.           helloMsg *helloMsgData = (helloMsg *)DrandM$DataPkt.data;
  1746. #line 584
  1747.           helloMsgData->sendID = TOS_LOCAL_ADDRESS;
  1748.           for (i = 0; i < MAX_NBR; i++) 
  1749.             helloMsgData->OneWayId[i] = 0xFF;
  1751.           for (i = 0; i < MAX_NBR && DrandM$OneWayId[i] != 0xFF; i++) 
  1752.             helloMsgData->OneWayId[i] = DrandM$OneWayId[i];
  1753.           if (i == MAX_NBR) {
  1755.               {
  1756. #line 592
  1757.                 char bStatus;
  1759. #line 592
  1760.                 if (DBG_USR2 != 0) {
  1761. #line 592
  1762.                     bStatus = * (volatile uint8_t *)(uint16_t )& * (volatile uint8_t *)(0x3F + 0x20) & (1 << 7);
  1763. #line 592
  1764.                      __asm volatile ("cli");DrandM$sprintf(DrandM$debugbuf, "SendHelloMsg: Too many neighbors, abort !!!!n");
  1765. #line 592
  1766.                     DrandM$writedebug();
  1767. #line 592
  1768.                     if (bStatus) {
  1769. #line 592
  1770.                        __asm volatile ("sei");
  1771.                       }
  1772.                   }
  1773.               }
  1774. #line 592
  1775.               ;
  1776.             }
  1778.           helloMsgData->OneWayLen = i;
  1779.           for (j = 0; j < MAX_NBR && i < MAX_NBR && DrandM$TwoWayId[j] != 0xFF; j++, i++) 
  1780.             helloMsgData->OneWayId[i] = DrandM$TwoWayId[j];
  1782.           if (DrandM$SendHelloMsg$send(TOS_BCAST_ADDR, sizeof(helloMsg ), &DrandM$DataPkt) == SUCCESS) {
  1783.             DrandM$sendBusy = TRUE;
  1784.             }
  1785.           else 
  1786. #line 601
  1787.             {
  1791.               DrandM$reXTimer$start(TIMER_ONE_SHOT, DrandM$randNew() % HELLO_INTERVAL);
  1792.             }
  1793.         }
  1794.       else 
  1795. #line 607
  1796.         {
  1800.           DrandM$reXTimer$start(TIMER_ONE_SHOT, DrandM$randNew() % HELLO_INTERVAL);
  1801.         }
  1802.     }
  1803. #line 613
  1804.     __nesc_atomic_end(__nesc_atomic); }
  1805. }
  1807. static  
  1808. # 179 "/home/testuser/tinyos-1.x/tos/system/AMStandard.nc"
  1809. result_t AMStandard$SendMsg$send(uint8_t id, uint16_t addr, uint8_t length, TOS_MsgPtr data)
  1810. #line 179
  1811. {
  1812.   if (!AMStandard$state) {
  1813.       AMStandard$state = TRUE;
  1814.       if (length > DATA_LENGTH) {
  1815.           {
  1816.           }
  1817. #line 183
  1818.           ;
  1819.           AMStandard$state = FALSE;
  1820.           return FAIL;
  1821.         }
  1822.       if (!TOS_post(AMStandard$sendTask)) {
  1823.           {
  1824.           }
  1825. #line 188
  1826.           ;
  1827.           AMStandard$state = FALSE;
  1828.           return FAIL;
  1829.         }
  1830.       else {
  1831.           AMStandard$buffer = data;
  1832.           data->length = length;
  1833.           data->addr = addr;
  1834.           data->type = id;
  1835.           AMStandard$buffer->group = TOS_AM_GROUP;
  1836.           {
  1837.           }
  1838. #line 198
  1839.           ;
  1840.           AMStandard$dbgPacket(data);
  1841.         }
  1842.       return SUCCESS;
  1843.     }
  1845.   return FAIL;
  1846. }
  1848. static 
  1849. # 158 "/home/testuser/tinyos-1.x/tos/system/FramerM.nc"
  1850. result_t FramerM$StartTx(void)
  1851. #line 158
  1852. {
  1853.   result_t Result = SUCCESS;
  1854.   bool fInitiate = FALSE;
  1856.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1857. #line 162
  1858.     {
  1859.       if (FramerM$gTxState == FramerM$TXSTATE_IDLE) {
  1860.           if (FramerM$gFlags & FramerM$FLAGS_TOKENPEND) {
  1861.               FramerM$gpTxBuf = (uint8_t *)&FramerM$gTxTokenBuf;
  1862.               FramerM$gTxProto = FramerM$PROTO_ACK;
  1863.               FramerM$gTxLength = sizeof FramerM$gTxTokenBuf;
  1864.               fInitiate = TRUE;
  1865.               FramerM$gTxState = FramerM$TXSTATE_PROTO;
  1866.             }
  1867.           else {
  1868. #line 171
  1869.             if (FramerM$gFlags & FramerM$FLAGS_DATAPEND) {
  1870.                 FramerM$gpTxBuf = (uint8_t *)FramerM$gpTxMsg;
  1871.                 FramerM$gTxProto = FramerM$PROTO_PACKET_NOACK;
  1872.                 FramerM$gTxLength = FramerM$gpTxMsg->length + (MSG_DATA_SIZE - DATA_LENGTH - 2);
  1873.                 fInitiate = TRUE;
  1874.                 FramerM$gTxState = FramerM$TXSTATE_PROTO;
  1875.               }
  1876.             else {
  1877. #line 178
  1878.               if (FramerM$gFlags & FramerM$FLAGS_UNKNOWN) {
  1879.                   FramerM$gpTxBuf = (uint8_t *)&FramerM$gTxUnknownBuf;
  1880.                   FramerM$gTxProto = FramerM$PROTO_UNKNOWN;
  1881.                   FramerM$gTxLength = sizeof FramerM$gTxUnknownBuf;
  1882.                   fInitiate = TRUE;
  1883.                   FramerM$gTxState = FramerM$TXSTATE_PROTO;
  1884.                 }
  1885.               }
  1886.             }
  1887.         }
  1888.     }
  1889. #line 188
  1890.     __nesc_atomic_end(__nesc_atomic); }
  1891. #line 188
  1892.   if (fInitiate) {
  1893.       { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1894. #line 189
  1895.         {
  1896.           FramerM$gTxRunningCRC = 0;
  1897. #line 190
  1898.           FramerM$gTxByteCnt = 0;
  1899.         }
  1900. #line 191
  1901.         __nesc_atomic_end(__nesc_atomic); }
  1902.       Result = FramerM$ByteComm$txByte(FramerM$HDLC_FLAG_BYTE);
  1903.       if (Result != SUCCESS) {
  1904.           { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1905. #line 194
  1906.             FramerM$gTxState = FramerM$TXSTATE_ERROR;
  1907. #line 194
  1908.             __nesc_atomic_end(__nesc_atomic); }
  1909.           TOS_post(FramerM$PacketSent);
  1910.         }
  1911.     }
  1913.   return Result;
  1914. }
  1916. static   
  1917. # 110 "/home/testuser/tinyos-1.x/tos/system/UARTM.nc"
  1918. result_t UARTM$ByteComm$txByte(uint8_t data)
  1919. #line 110
  1920. {
  1921.   bool oldState;
  1923.   {
  1924.   }
  1925. #line 113
  1926.   ;
  1928.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1929. #line 115
  1930.     {
  1931.       oldState = UARTM$state;
  1932.       UARTM$state = TRUE;
  1933.     }
  1934. #line 118
  1935.     __nesc_atomic_end(__nesc_atomic); }
  1936.   if (oldState) {
  1937.     return FAIL;
  1938.     }
  1939.   UARTM$HPLUART$put(data);
  1941.   return SUCCESS;
  1942. }
  1944. static  
  1945. # 246 "/home/testuser/tinyos-1.x/tos/system/FramerM.nc"
  1946. void FramerM$PacketSent(void)
  1947. #line 246
  1948. {
  1949.   result_t TxResult = SUCCESS;
  1951.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1952. #line 249
  1953.     {
  1954.       if (FramerM$gTxState == FramerM$TXSTATE_ERROR) {
  1955.           TxResult = FAIL;
  1956.           FramerM$gTxState = FramerM$TXSTATE_IDLE;
  1957.         }
  1958.     }
  1959. #line 254
  1960.     __nesc_atomic_end(__nesc_atomic); }
  1961.   if (FramerM$gTxProto == FramerM$PROTO_ACK) {
  1962.       { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1963. #line 256
  1964.         FramerM$gFlags ^= FramerM$FLAGS_TOKENPEND;
  1965. #line 256
  1966.         __nesc_atomic_end(__nesc_atomic); }
  1967.     }
  1968.   else {
  1969.       { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1970. #line 259
  1971.         FramerM$gFlags ^= FramerM$FLAGS_DATAPEND;
  1972. #line 259
  1973.         __nesc_atomic_end(__nesc_atomic); }
  1974.       FramerM$BareSendMsg$sendDone((TOS_MsgPtr )FramerM$gpTxMsg, TxResult);
  1975.       { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  1976. #line 261
  1977.         FramerM$gpTxMsg = (void *)0;
  1978. #line 261
  1979.         __nesc_atomic_end(__nesc_atomic); }
  1980.     }
  1983.   FramerM$StartTx();
  1984. }
  1986. static 
  1987. # 143 "/home/testuser/tinyos-1.x/tos/system/AMStandard.nc"
  1988. result_t AMStandard$reportSendDone(TOS_MsgPtr msg, result_t success)
  1989. #line 143
  1990. {
  1991.   AMStandard$state = FALSE;
  1992.   AMStandard$SendMsg$sendDone(msg->type, msg, success);
  1993.   AMStandard$sendDone();
  1995.   return SUCCESS;
  1996. }
  1998. static  
  1999. # 1102 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  2000. result_t CC1000RadioIntM$Send$send(TOS_MsgPtr pMsg)
  2001. #line 1102
  2002. {
  2003.   result_t Result = SUCCESS;
  2004.   uint8_t currentRadioState = 0;
  2006.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  2007. #line 1106
  2008.     {
  2009.       if (CC1000RadioIntM$bTxBusy) {
  2010.           Result = FAIL;
  2011.         }
  2012.       else 
  2014.         {
  2015.           CC1000RadioIntM$bTxBusy = TRUE;
  2016.           CC1000RadioIntM$txbufptr = pMsg;
  2017.           CC1000RadioIntM$txlength = pMsg->length + (MSG_DATA_SIZE - DATA_LENGTH - 2);
  2019.           if (CC1000RadioIntM$bCCAEnable) {
  2020.               if (CC1000RadioIntM$currentMAC == CC1000RadioIntM$BMAC) {
  2021.                 CC1000RadioIntM$sMacDelay = CC1000RadioIntM$MacBackoff$initialBackoff(pMsg);
  2022.                 }
  2023.               else {
  2024. #line 1121
  2025.                 CC1000RadioIntM$sMacDelay = CC1000RadioIntM$getZMACBackoff(0);
  2026.                 }
  2027.             }
  2028.           else {
  2029. #line 1123
  2030.             CC1000RadioIntM$sMacDelay = 0;
  2031.             }
  2035.           CC1000RadioIntM$bTxPending = TRUE;
  2036.         }
  2037.       currentRadioState = CC1000RadioIntM$RadioState;
  2038.     }
  2039. #line 1131
  2040.     __nesc_atomic_end(__nesc_atomic); }
  2042.   if (Result) {
  2043.       if (currentRadioState == CC1000RadioIntM$POWER_DOWN_STATE) {
  2044.           { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  2045. #line 1135
  2046.             CC1000RadioIntM$RadioState = CC1000RadioIntM$IDLE_STATE;
  2047. #line 1135
  2048.             __nesc_atomic_end(__nesc_atomic); }
  2049.           CC1000RadioIntM$WakeupTimer$stop();
  2050.           CC1000RadioIntM$CC1000StdControl$start();
  2051.           CC1000RadioIntM$CC1000Control$BIASOn();
  2052.           CC1000RadioIntM$CC1000Control$RxMode();
  2053.           CC1000RadioIntM$SpiByteFifo$rxMode();
  2054.           CC1000RadioIntM$SpiByteFifo$enableIntr();
  2055.           if (CC1000RadioIntM$iSquelchCount > 30) {
  2056.             CC1000RadioIntM$SquelchTimer$start(TIMER_REPEAT, 2560);
  2057.             }
  2058.           else {
  2059. #line 1145
  2060.             CC1000RadioIntM$SquelchTimer$start(TIMER_REPEAT, 128);
  2061.             }
  2062. #line 1146
  2063.           CC1000RadioIntM$WakeupTimer$start(TIMER_ONE_SHOT, 16 * 2);
  2064.         }
  2065.     }
  2066.   return Result;
  2067. }
  2069. static   
  2070. # 70 "/home/testuser/tinyos-1.x/tos/system/RandomLFSR.nc"
  2071. uint16_t RandomLFSR$Random$rand(void)
  2072. #line 70
  2073. {
  2074.   bool endbit;
  2075.   uint16_t tmpShiftReg;
  2077. #line 73
  2078.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  2079. #line 73
  2080.     {
  2081.       tmpShiftReg = RandomLFSR$shiftReg;
  2082.       endbit = (tmpShiftReg & 0x8000) != 0;
  2083.       tmpShiftReg <<= 1;
  2084.       if (endbit) {
  2085.         tmpShiftReg ^= 0x100b;
  2086.         }
  2087. #line 79
  2088.       tmpShiftReg++;
  2089.       RandomLFSR$shiftReg = tmpShiftReg;
  2090.       tmpShiftReg = tmpShiftReg ^ RandomLFSR$mask;
  2091.     }
  2092. #line 82
  2093.     __nesc_atomic_end(__nesc_atomic); }
  2094.   return tmpShiftReg;
  2095. }
  2097. static 
  2098. # 286 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  2099. uint16_t CC1000RadioIntM$getZMACBackoff(uint16_t residualBackoff)
  2100. #line 286
  2101. {
  2102.   if (residualBackoff > 0) {
  2103.       CC1000RadioIntM$congBackOffs++;
  2104.       if (CC1000RadioIntM$currentSlot == CC1000RadioIntM$ownSlot && residualBackoff >= 8) {
  2105.           return CC1000RadioIntM$getOwnerBackoff();
  2106.         }
  2107.       else {
  2108. #line 291
  2109.         if (CC1000RadioIntM$currentSlot != CC1000RadioIntM$ownSlot && residualBackoff < 8) {
  2110.             if (residualBackoff + 8 < 8 + 32) {
  2111.               return residualBackoff + 8;
  2112.               }
  2113.             else {
  2114. #line 295
  2115.               return CC1000RadioIntM$getNonOwnerBackoff();
  2116.               }
  2117.           }
  2118.         else {
  2119. #line 297
  2120.           return residualBackoff;
  2121.           }
  2122.         }
  2123.     }
  2124.   else 
  2125. #line 298
  2126.     {
  2127.       if (CC1000RadioIntM$currentSlot == CC1000RadioIntM$ownSlot) {
  2128.         return CC1000RadioIntM$getOwnerBackoff();
  2129.         }
  2130.       else {
  2131. #line 302
  2132.         return CC1000RadioIntM$getNonOwnerBackoff();
  2133.         }
  2134.     }
  2135. }
  2137. static  
  2138. # 168 "/home/testuser/tinyos-1.x/tos/system/TimerM.nc"
  2139. result_t TimerM$Timer$stop(uint8_t id)
  2140. #line 168
  2141. {
  2143.   if (id >= NUM_TIMERS) {
  2144. #line 170
  2145.     return FAIL;
  2146.     }
  2147. #line 171
  2148.   if (TimerM$mState & (0x1L << id)) {
  2149.       { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  2150. #line 172
  2151.         TimerM$mState &= ~(0x1L << id);
  2152. #line 172
  2153.         __nesc_atomic_end(__nesc_atomic); }
  2154.       if (!TimerM$mState) {
  2155.           TimerM$setIntervalFlag = 1;
  2156.         }
  2157.       return SUCCESS;
  2158.     }
  2159.   return FAIL;
  2160. }
  2162. static 
  2163. # 253 "../../tos/system/DrandM.nc"
  2164. void DrandM$addNode(uint8_t nodeID, uint8_t type)
  2165. #line 253
  2166. {
  2167.   uint8_t i;
  2169. #line 255
  2170.   if (nodeID == TOS_LOCAL_ADDRESS || nodeID == 0xFF) {
  2171. #line 255
  2172.     return;
  2173.     }
  2174. #line 256
  2175.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  2176. #line 256
  2177.     {
  2178.       for (i = 0; i < MAX_NBR && DrandM$nbrInfo[i].nodeID != 0xFF && DrandM$nbrInfo[i].nodeID != nodeID; i++) ;
  2179.       if (i == MAX_NBR) {
  2181.           {
  2182. #line 260
  2183.             char bStatus;
  2185. #line 260
  2186.             if (DBG_USR2 != 0) {
  2187. #line 260
  2188.                 bStatus = * (volatile uint8_t *)(uint16_t )& * (volatile uint8_t *)(0x3F + 0x20) & (1 << 7);
  2189. #line 260
  2190.                  __asm volatile ("cli");DrandM$sprintf(DrandM$debugbuf, "addNode: No space to add noden");
  2191. #line 260
  2192.                 DrandM$writedebug();
  2193. #line 260
  2194.                 if (bStatus) {
  2195. #line 260
  2196.                    __asm volatile ("sei");
  2197.                   }
  2198.               }
  2199.           }
  2200. #line 260
  2201.           ;
  2202.         }
  2203.       else {
  2204. #line 262
  2205.         if (DrandM$nbrInfo[i].nodeID != nodeID) {
  2206.             DrandM$nbrInfo[i].nodeID = nodeID;
  2207.             DrandM$nbrInfo[i].bitMap = type;
  2208.             DrandM$nbrInfo[i].slot = 0xFF;
  2209.             DrandM$nbrInfo[i].frame = 0xFF;
  2210.           }
  2211.         }
  2212.     }
  2213. #line 269
  2214.     __nesc_atomic_end(__nesc_atomic); }
  2215. }
  2217. static 
  2218. #line 271
  2219. void DrandM$removeNode(uint8_t nodeID, uint8_t type)
  2220. #line 271
  2221. {
  2222.   uint8_t i;
  2224. #line 273
  2225.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  2226. #line 273
  2227.     {
  2228.       for (i = 0; i < MAX_NBR && DrandM$nbrInfo[i].nodeID != 0xFF && DrandM$nbrInfo[i].nodeID != nodeID; i++) ;
  2229.       if (i != MAX_NBR && DrandM$nbrInfo[i].nodeID == nodeID && DrandM$nbrInfo[i].bitMap & type) {
  2230.           for (; i < MAX_NBR - 1; i++) 
  2231.             DrandM$nbrInfo[i] = DrandM$nbrInfo[i + 1];
  2232.           DrandM$nbrInfo[MAX_NBR - 1].nodeID = 0xFF;
  2233.         }
  2234.     }
  2235. #line 280
  2236.     __nesc_atomic_end(__nesc_atomic); }
  2237. }
  2239. static 
  2240. #line 392
  2241. int DrandM$isPresent(uint8_t nodeID, uint8_t type)
  2242. #line 392
  2243. {
  2244.   uint8_t i;
  2246. #line 394
  2247.   if (nodeID == 0xFF) {
  2248. #line 394
  2249.     return -1;
  2250.     }
  2251. #line 395
  2252.   for (i = 0; i < MAX_NBR && DrandM$nbrInfo[i].nodeID != 0xFF; i++) 
  2253.     if (DrandM$nbrInfo[i].nodeID == nodeID && DrandM$nbrInfo[i].bitMap & type) {
  2254.       return i;
  2255.       }
  2256. #line 398
  2257.   return -1;
  2258. }
  2260. static 
  2261. #line 670
  2262. void DrandM$sendReleaseMsg(uint8_t slot)
  2263. #line 670
  2264. {
  2265.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  2266. #line 671
  2267.     {
  2268.       if (!DrandM$sendBusy) {
  2269.           releaseMsg *releaseMsgData = (releaseMsg *)DrandM$DataPkt.data;
  2271. #line 674
  2272.           releaseMsgData->sendID = TOS_LOCAL_ADDRESS;
  2273.           releaseMsgData->slot = slot;
  2275.           releaseMsgData->myState = DrandM$globalState;
  2276.           releaseMsgData->lastRequestID = DrandM$lastReqID;
  2277.           releaseMsgData->roundNum = DrandM$roundNum;
  2279.           if (DrandM$SendReleaseMsg$send(TOS_BCAST_ADDR, sizeof(releaseMsg ), &DrandM$DataPkt) == SUCCESS) {
  2280.               DrandM$sendBusy = TRUE;
  2281.             }
  2282.           else {
  2283.             }
  2284.         }
  2285.     }
  2286. #line 687
  2287.     __nesc_atomic_end(__nesc_atomic); }
  2288. }
  2290. static  
  2291. #line 1177
  2292. TOS_MsgPtr DrandM$ReceiveReleaseMsg$receive(TOS_MsgPtr m)
  2293. #line 1177
  2294. {
  2295.   int nIndex;
  2296.   releaseMsg *recvReleasePtr = (releaseMsg *)m->data;
  2302.   if (((
  2303. #line 1184
  2304.   nIndex = DrandM$isPresent(recvReleasePtr->sendID, ONE_HOP)) == -1 || 
  2305.   DrandM$globalState != GRANT_STATE) || DrandM$lastReqID != recvReleasePtr->sendID) {
  2306.     return m;
  2307.     }
  2308. #line 1187
  2309.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  2310. #line 1187
  2311.     {
  2312.       DrandM$reXTimer$stop();
  2313.       if (DrandM$updateNeighborInfo(recvReleasePtr->sendID, recvReleasePtr->slot)) {
  2314.         DrandM$sendTwoHopMsg(recvReleasePtr->slot, recvReleasePtr->sendID);
  2315.         }
  2319.       if (DrandM$setMySlot) {
  2320.           DrandM$globalState = RELEASE_STATE;
  2321.         }
  2322.       else 
  2324.         {
  2325.           DrandM$globalState = IDLE_STATE2;
  2326.           DrandM$drandRoundTimer$start(TIMER_ONE_SHOT, 100);
  2327.         }
  2332.       DrandM$graX = FALSE;
  2334.       DrandM$lastReqID = 0xFF;
  2335.     }
  2336. #line 1211
  2337.     __nesc_atomic_end(__nesc_atomic); }
  2338.   return m;
  2339. }
  2341. static 
  2342. #line 310
  2343. bool DrandM$updateNeighborInfo(uint8_t nID, uint8_t slot)
  2344. #line 310
  2345. {
  2346.   uint8_t i;
  2348. #line 312
  2349.   if (slot == 0xFF || nID == 0xFF) {
  2350. #line 312
  2351.     return FALSE;
  2352.     }
  2353. #line 313
  2354.   for (i = 0; i < MAX_NBR && DrandM$nbrInfo[i].nodeID != 0xFF; i++) 
  2355.     if (DrandM$nbrInfo[i].nodeID == nID && DrandM$nbrInfo[i].slot == 0xFF) {
  2356.         DrandM$nbrInfo[i].slot = slot;
  2357.         return TRUE;
  2358.       }
  2359.   return FALSE;
  2360. }
  2362. static 
  2363. #line 67
  2364. GTime DrandM$timeDiff(GTime A, GTime B)
  2365. #line 67
  2366. {
  2367.   GTime diff;
  2369. #line 69
  2370.   if (A.sticks >= B.sticks) {
  2371.       diff.mticks = A.mticks - B.mticks;
  2372.       diff.sticks = A.sticks - B.sticks;
  2373.     }
  2374.   else {
  2375.       uint32_t temp = 65536;
  2377. #line 75
  2378.       diff.mticks = A.mticks - 1 - B.mticks;
  2379.       diff.sticks = (uint16_t )(temp + A.sticks - B.sticks);
  2380.     }
  2381.   return diff;
  2382. }
  2384. static 
  2385. #line 290
  2386. uint8_t DrandM$numGrantsRemaining(void)
  2387. #line 290
  2388. {
  2389.   uint8_t i;
  2390. #line 291
  2391.   uint8_t count;
  2393. #line 292
  2394.   for (i = 0, count = 0; i < MAX_NBR && DrandM$nbrInfo[i].nodeID != 0xFF; i++) 
  2395.     if (DrandM$nbrInfo[i].bitMap & ONE_HOP && !(DrandM$nbrInfo[i].bitMap & GRANT_SENT)) {
  2399.         count++;
  2400.       }
  2401.   return count;
  2402. }
  2404. static 
  2405. #line 693
  2406. void DrandM$setSlot(void)
  2407. #line 693
  2408. {
  2409.   uint8_t i;
  2410.   uint32_t slotField;
  2412. #line 696
  2413.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  2414. #line 696
  2415.     {
  2416.       for (i = 0, slotField = 0x0; i < MAX_NBR && DrandM$nbrInfo[i].nodeID != 0xFF; i++) 
  2417.         if (DrandM$nbrInfo[i].slot != 0xFF) {
  2418.           slotField = slotField | (0x1 << DrandM$nbrInfo[i].slot);
  2419.           }
  2420. #line 700
  2421.       for (i = 0; i < 32; i++) 
  2422.         if (!(slotField & (0x1 << i))) {
  2423.             DrandM$myInfo.slot = i;
  2424.             DrandM$setMySlot = TRUE;
  2425.             break;
  2426.           }
  2428.       if (!DrandM$setMySlot) {
  2430.           {
  2431. #line 709
  2432.             char bStatus;
  2434. #line 709
  2435.             if (DBG_USR2 != 0) {
  2436. #line 709
  2437.                 bStatus = * (volatile uint8_t *)(uint16_t )& * (volatile uint8_t *)(0x3F + 0x20) & (1 << 7);
  2438. #line 709
  2439.                  __asm volatile ("cli");DrandM$sprintf(DrandM$debugbuf, "SetSlot: Could not set slot, something wrong, abort !!!n");
  2440. #line 709
  2441.                 DrandM$writedebug();
  2442. #line 709
  2443.                 if (bStatus) {
  2444. #line 709
  2445.                    __asm volatile ("sei");
  2446.                   }
  2447.               }
  2448.           }
  2449. #line 709
  2450.           ;
  2451.         }
  2452.       else {
  2456.           DrandM$globalState = RELEASE_STATE;
  2457.           DrandM$sendReleaseMsg(DrandM$myInfo.slot);
  2458.           DrandM$reXTimer$stop();
  2459.         }
  2460.     }
  2461. #line 719
  2462.     __nesc_atomic_end(__nesc_atomic); }
  2463. }
  2465. static 
  2466. #line 146
  2467. void DrandM$timeCheck(void)
  2468. #line 146
  2469. {
  2470.   GTime roundTime;
  2472. #line 148
  2473.   DrandM$SClock$getTime(&DrandM$locTime);
  2474.   DrandM$drandRunTime = DrandM$timeDiff(DrandM$locTime, DrandM$drandStartTime);
  2475.   roundTime = DrandM$timeDiff(DrandM$locTime, DrandM$roundStartTime);
  2477.   {
  2478. #line 152
  2479.     char bStatus;
  2481. #line 152
  2482.     if (DBG_USR2 != 0) {
  2483. #line 152
  2484.         bStatus = * (volatile uint8_t *)(uint16_t )& * (volatile uint8_t *)(0x3F + 0x20) & (1 << 7);
  2485. #line 152
  2486.          __asm volatile ("cli");DrandM$sprintf(DrandM$debugbuf, "MESSAGE sID %u mCt %u rReq %u rGra %u mTime %u sTime %un", TOS_LOCAL_ADDRESS, DrandM$reqCount + DrandM$graCount + DrandM$rejCount + DrandM$relCount + DrandM$twoCount, DrandM$reqXCount, DrandM$graXCount, (uint16_t )DrandM$drandRunTime.mticks, (uint16_t )DrandM$drandRunTime.sticks);
  2487. #line 152
  2488.         DrandM$writedebug();
  2489. #line 152
  2490.         if (bStatus) {
  2491. #line 152
  2492.            __asm volatile ("sei");
  2493.           }
  2494.       }
  2495.   }
  2496. #line 152
  2497.   ;
  2500.   {
  2501. #line 155
  2502.     char bStatus;
  2504. #line 155
  2505.     if (DBG_USR2 != 0) {
  2506. #line 155
  2507.         bStatus = * (volatile uint8_t *)(uint16_t )& * (volatile uint8_t *)(0x3F + 0x20) & (1 << 7);
  2508. #line 155
  2509.          __asm volatile ("cli");DrandM$sprintf(DrandM$debugbuf, "MESSAGE sID %u reqCt %u graCt %u rejCt %u relCt %u twoCt %un", TOS_LOCAL_ADDRESS, DrandM$reqCount, DrandM$graCount, DrandM$rejCount, DrandM$relCount, DrandM$twoCount);
  2510. #line 155
  2511.         DrandM$writedebug();
  2512. #line 155
  2513.         if (bStatus) {
  2514. #line 155
  2515.            __asm volatile ("sei");
  2516.           }
  2517.       }
  2518.   }
  2519. #line 155
  2520.   ;
  2522.   {
  2523. #line 157
  2524.     char bStatus;
  2526. #line 157
  2527.     if (DBG_USR2 != 0) {
  2528. #line 157
  2529.         bStatus = * (volatile uint8_t *)(uint16_t )& * (volatile uint8_t *)(0x3F + 0x20) & (1 << 7);
  2530. #line 157
  2531.          __asm volatile ("cli");DrandM$sprintf(DrandM$debugbuf, "MESSAGE sID %u Round %u slotNum %u mRound %u sRound %un", TOS_LOCAL_ADDRESS, DrandM$roundNum, DrandM$myInfo.slot, roundTime.mticks, roundTime.sticks);
  2532. #line 157
  2533.         DrandM$writedebug();
  2534. #line 157
  2535.         if (bStatus) {
  2536. #line 157
  2537.            __asm volatile ("sei");
  2538.           }
  2539.       }
  2540.   }
  2541. #line 157
  2542.   ;
  2543. }
  2545. static 
  2546. #line 109
  2547. void DrandM$printNbrInfo(void)
  2548. #line 109
  2549. {
  2550.   uint8_t i;
  2552. #line 111
  2553.   {
  2554. #line 111
  2555.     char bStatus;
  2557. #line 111
  2558.     if (DBG_USR2 != 0) {
  2559. #line 111
  2560.         bStatus = * (volatile uint8_t *)(uint16_t )& * (volatile uint8_t *)(0x3F + 0x20) & (1 << 7);
  2561. #line 111
  2562.          __asm volatile ("cli");DrandM$sprintf(DrandM$debugbuf, "*******************************************************n");
  2563. #line 111
  2564.         DrandM$writedebug();
  2565. #line 111
  2566.         if (bStatus) {
  2567. #line 111
  2568.            __asm volatile ("sei");
  2569.           }
  2570.       }
  2571.   }
  2572. #line 111
  2573.   ;
  2574.   for (i = 0; i < MAX_NBR && DrandM$nbrInfo[i].nodeID != 0xFF; i++) {
  2575.       switch (DrandM$globalState) {
  2576.           case IDLE_STATE2: 
  2577.             if (DrandM$nbrInfo[i].bitMap & ONE_HOP) {
  2578.                 {
  2579. #line 116
  2580.                   char bStatus;
  2582. #line 116
  2583.                   if (DBG_USR2 != 0) {
  2584. #line 116
  2585.                       bStatus = * (volatile uint8_t *)(uint16_t )& * (volatile uint8_t *)(0x3F + 0x20) & (1 << 7);
  2586. #line 116
  2587.                        __asm volatile ("cli");DrandM$sprintf(DrandM$debugbuf, "OneHopNodeID(HELLO) : %u  %u  %un", DrandM$nbrInfo[i].nodeID, DrandM$nbrInfo[i].slot, DrandM$nbrInfo[i].frame);
  2588. #line 116
  2589.                       DrandM$writedebug();
  2590. #line 116
  2591.                       if (bStatus) {
  2592. #line 116
  2593.                          __asm volatile ("sei");
  2594.                         }
  2595.                     }
  2596.                 }
  2597. #line 116
  2598.                 ;
  2599.               }
  2600.             else {
  2601. #line 118
  2602.               if (DrandM$nbrInfo[i].bitMap & TWO_HOP) {
  2603.                   {
  2604. #line 119
  2605.                     char bStatus;
  2607. #line 119
  2608.                     if (DBG_USR2 != 0) {
  2609. #line 119
  2610.                         bStatus = * (volatile uint8_t *)(uint16_t )& * (volatile uint8_t *)(0x3F + 0x20) & (1 << 7);
  2611. #line 119
  2612.                          __asm volatile ("cli");DrandM$sprintf(DrandM$debugbuf, "TwoHopNodeID(HELLO) : %u  %u  %un", DrandM$nbrInfo[i].nodeID, DrandM$nbrInfo[i].slot, DrandM$nbrInfo[i].frame);
  2613. #line 119
  2614.                         DrandM$writedebug();
  2615. #line 119
  2616.                         if (bStatus) {
  2617. #line 119
  2618.                            __asm volatile ("sei");
  2619.                           }
  2620.                       }
  2621.                   }
  2622. #line 119
  2623.                   ;
  2624.                 }
  2625.               }
  2626.           break;
  2627.           case RELEASE_STATE: 
  2628.             if (DrandM$nbrInfo[i].bitMap & ONE_HOP) {
  2629.                 {
  2630. #line 125
  2631.                   char bStatus;
  2633. #line 125
  2634.                   if (DBG_USR2 != 0) {
  2635. #line 125
  2636.                       bStatus = * (volatile uint8_t *)(uint16_t )& * (volatile uint8_t *)(0x3F + 0x20) & (1 << 7);
  2637. #line 125
  2638.                        __asm volatile ("cli");DrandM$sprintf(DrandM$debugbuf, "OneHopNodeID(DRAND) : %u  %u  %un", DrandM$nbrInfo[i].nodeID, DrandM$nbrInfo[i].slot, DrandM$nbrInfo[i].frame);
  2639. #line 125
  2640.                       DrandM$writedebug();
  2641. #line 125
  2642.                       if (bStatus) {
  2643. #line 125
  2644.                          __asm volatile ("sei");
  2645.                         }
  2646.                     }
  2647.                 }
  2648. #line 125
  2649.                 ;
  2650.               }
  2651.             else {
  2652. #line 127
  2653.               if (DrandM$nbrInfo[i].bitMap & TWO_HOP) {
  2654.                   {
  2655. #line 128
  2656.                     char bStatus;
  2658. #line 128
  2659.                     if (DBG_USR2 != 0) {
  2660. #line 128
  2661.                         bStatus = * (volatile uint8_t *)(uint16_t )& * (volatile uint8_t *)(0x3F + 0x20) & (1 << 7);
  2662. #line 128
  2663.                          __asm volatile ("cli");DrandM$sprintf(DrandM$debugbuf, "TwoHopNodeID(DRAND) : %u  %u  %un", DrandM$nbrInfo[i].nodeID, DrandM$nbrInfo[i].slot, DrandM$nbrInfo[i].frame);
  2664. #line 128
  2665.                         DrandM$writedebug();
  2666. #line 128
  2667.                         if (bStatus) {
  2668. #line 128
  2669.                            __asm volatile ("sei");
  2670.                           }
  2671.                       }
  2672.                   }
  2673. #line 128
  2674.                   ;
  2675.                 }
  2676.               }
  2677.           break;
  2678.           case FRAME_STATE: 
  2679.             if (DrandM$nbrInfo[i].bitMap & ONE_HOP) {
  2680.                 {
  2681. #line 134
  2682.                   char bStatus;
  2684. #line 134
  2685.                   if (DBG_USR2 != 0) {
  2686. #line 134
  2687.                       bStatus = * (volatile uint8_t *)(uint16_t )& * (volatile uint8_t *)(0x3F + 0x20) & (1 << 7);
  2688. #line 134
  2689.                        __asm volatile ("cli");DrandM$sprintf(DrandM$debugbuf, "OneHopNodeID(FRAME) : %u  %u  %un", DrandM$nbrInfo[i].nodeID, DrandM$nbrInfo[i].slot, DrandM$nbrInfo[i].frame);
  2690. #line 134
  2691.                       DrandM$writedebug();
  2692. #line 134
  2693.                       if (bStatus) {
  2694. #line 134
  2695.                          __asm volatile ("sei");
  2696.                         }
  2697.                     }
  2698.                 }
  2699. #line 134
  2700.                 ;
  2701.               }
  2702.             else {
  2703. #line 136
  2704.               if (DrandM$nbrInfo[i].bitMap & TWO_HOP) {
  2705.                   {
  2706. #line 137
  2707.                     char bStatus;
  2709. #line 137
  2710.                     if (DBG_USR2 != 0) {
  2711. #line 137
  2712.                         bStatus = * (volatile uint8_t *)(uint16_t )& * (volatile uint8_t *)(0x3F + 0x20) & (1 << 7);
  2713. #line 137
  2714.                          __asm volatile ("cli");DrandM$sprintf(DrandM$debugbuf, "TwoHopNodeID(FRAME) : %u  %u  %un", DrandM$nbrInfo[i].nodeID, DrandM$nbrInfo[i].slot, DrandM$nbrInfo[i].frame);
  2715. #line 137
  2716.                         DrandM$writedebug();
  2717. #line 137
  2718.                         if (bStatus) {
  2719. #line 137
  2720.                            __asm volatile ("sei");
  2721.                           }
  2722.                       }
  2723.                   }
  2724. #line 137
  2725.                   ;
  2726.                 }
  2727.               }
  2728.           break;
  2729.         }
  2730.     }
  2731.   {
  2732. #line 143
  2733.     char bStatus;
  2735. #line 143
  2736.     if (DBG_USR2 != 0) {
  2737. #line 143
  2738.         bStatus = * (volatile uint8_t *)(uint16_t )& * (volatile uint8_t *)(0x3F + 0x20) & (1 << 7);
  2739. #line 143
  2740.          __asm volatile ("cli");DrandM$sprintf(DrandM$debugbuf, "*******************************************************n");
  2741. #line 143
  2742.         DrandM$writedebug();
  2743. #line 143
  2744.         if (bStatus) {
  2745. #line 143
  2746.            __asm volatile ("sei");
  2747.           }
  2748.       }
  2749.   }
  2750. #line 143
  2751.   ;
  2752. }
  2754. static 
  2755. #line 1331
  2756. void DrandM$reXReport(void)
  2757. #line 1331
  2758. {
  2759.   if (DrandM$reportFireCount > MAX_REPORT) {
  2760.     DrandM$removeNodesForReport();
  2761.     }
  2762.   else {
  2763. #line 1335
  2764.     DrandM$reportFireCount++;
  2765.     }
  2766.   if (!DrandM$checkForRetransReport()) {
  2767.     DrandM$setFrame();
  2768.     }
  2769.   else 
  2770. #line 1339
  2771.     {
  2772.       DrandM$sendReportMsg(REPORT_REQUEST);
  2773.     }
  2774. }
  2776. static 
  2777. #line 440
  2778. void DrandM$removeNodesForReport(void)
  2779. #line 440
  2780. {
  2781.   int i;
  2783. #line 442
  2784.   for (i = MAX_NBR - 1; i >= 0; i--) {
  2785.       if (DrandM$nbrInfo[i].nodeID == 0xFF) {
  2786.         continue;
  2787.         }
  2788.       else {
  2789. #line 445
  2790.         if (DrandM$nbrInfo[i].slot == 0xFF) {
  2792.             {
  2793. #line 447
  2794.               char bStatus;
  2796. #line 447
  2797.               if (DBG_USR2 != 0) {
  2798. #line 447
  2799.                   bStatus = * (volatile uint8_t *)(uint16_t )& * (volatile uint8_t *)(0x3F + 0x20) & (1 << 7);
  2800. #line 447
  2801.                    __asm volatile ("cli");DrandM$sprintf(DrandM$debugbuf, "RemoveNodesForReport: Removed node %un", DrandM$nbrInfo[i].nodeID);
  2802. #line 447
  2803.                   DrandM$writedebug();
  2804. #line 447
  2805.                   if (bStatus) {
  2806. #line 447
  2807.                      __asm volatile ("sei");
  2808.                     }
  2809.                 }
  2810.             }
  2811. #line 447
  2812.             ;
  2814.             DrandM$removeNode(DrandM$nbrInfo[i].nodeID, DrandM$nbrInfo[i].bitMap);
  2815.           }
  2816.         }
  2817.     }
  2818. }
  2820. static 
  2821. #line 722
  2822. void DrandM$setFrame(void)
  2823. #line 722
  2824. {
  2825.   uint8_t maxSlot;
  2826. #line 723
  2827.   uint8_t frameLen;
  2829. #line 724
  2830.   DrandM$removeNodesForReport();
  2831.   DrandM$reXTimer$stop();
  2832.   maxSlot = DrandM$getMaxSlot();
  2833.   frameLen = 0;
  2834.   while (maxSlot != 0) {
  2835.       maxSlot = (int )(maxSlot / 2);
  2836.       frameLen++;
  2837.     }
  2838.   DrandM$myInfo.frame = 0x1 << frameLen;
  2840.   {
  2841. #line 734
  2842.     char bStatus;
  2844. #line 734
  2845.     if (DBG_USR2 != 0) {
  2846. #line 734
  2847.         bStatus = * (volatile uint8_t *)(uint16_t )& * (volatile uint8_t *)(0x3F + 0x20) & (1 << 7);
  2848. #line 734
  2849.          __asm volatile ("cli");DrandM$sprintf(DrandM$debugbuf, "Local Frame Size = %u for maxSlot = %un", DrandM$myInfo.frame, DrandM$getMaxSlot());
  2850. #line 734
  2851.         DrandM$writedebug();
  2852. #line 734
  2853.         if (bStatus) {
  2854. #line 734
  2855.            __asm volatile ("sei");
  2856.           }
  2857.       }
  2858.   }
  2859. #line 734
  2860.   ;
  2861. }
  2863. static 
  2864. #line 245
  2865. uint8_t DrandM$getMaxSlot(void)
  2866. #line 245
  2867. {
  2868.   uint8_t i;
  2869. #line 246
  2870.   uint8_t maxSlot = DrandM$myInfo.slot;
  2872. #line 247
  2873.   for (i = 0; i < MAX_NBR && DrandM$nbrInfo[i].nodeID != 0xFF; i++) 
  2874.     if (DrandM$nbrInfo[i].slot > maxSlot) {
  2875.       maxSlot = DrandM$nbrInfo[i].slot;
  2876.       }
  2877. #line 250
  2878.   return maxSlot;
  2879. }
  2881. static 
  2882. #line 792
  2883. void DrandM$sendReportMsg(uint8_t type)
  2884. #line 792
  2885. {
  2886.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  2887. #line 793
  2888.     {
  2889.       if (!DrandM$sendBusy) {
  2890.           reportMsg *reportMsgData = (reportMsg *)DrandM$DataPkt.data;
  2892. #line 796
  2893.           reportMsgData->slot = DrandM$myInfo.slot;
  2894.           reportMsgData->sendID = TOS_LOCAL_ADDRESS;
  2895.           reportMsgData->type = type;
  2896.           DrandM$fillTimeSlotInfoForReport(reportMsgData->timeSlot);
  2897.           if (DrandM$SendReportMsg$send(TOS_BCAST_ADDR, sizeof(reportMsg ), &DrandM$DataPkt) != SUCCESS) {
  2898.               DrandM$reXTimer$start(TIMER_ONE_SHOT, REPORT_XPERIOD + DrandM$randNew() % REPORT_INTERVAL);
  2899.             }
  2900.           else 
  2902.             {
  2903.               DrandM$sendBusy = TRUE;
  2904.             }
  2905.         }
  2906.       else 
  2907. #line 808
  2908.         {
  2909.           DrandM$reXTimer$start(TIMER_ONE_SHOT, REPORT_XPERIOD + DrandM$randNew() % REPORT_INTERVAL);
  2910.         }
  2911.     }
  2912. #line 811
  2913.     __nesc_atomic_end(__nesc_atomic); }
  2914. }
  2916. static 
  2917. #line 1308
  2918. void DrandM$reXFrame(void)
  2919. #line 1308
  2920. {
  2921.   if (DrandM$frameFireCount > MAX_FRAME) {
  2922.     DrandM$removeNodesForFrame();
  2923.     }
  2924.   else {
  2925. #line 1312
  2926.     DrandM$frameFireCount++;
  2927.     }
  2928.   if (!DrandM$checkForRetransFrame()) {
  2929.       DrandM$reXTimer$stop();
  2930.       if (!DrandM$gotAllFrames) {
  2931.           DrandM$Drand$gotFrame();
  2932.           DrandM$gotAllFrames = TRUE;
  2934.           DrandM$printNbrInfo();
  2935.         }
  2936.     }
  2937.   else {
  2941.       DrandM$sendFrameMsg(FRAME_REQUEST);
  2942.     }
  2943. }
  2945. static 
  2946. #line 817
  2947. void DrandM$sendFrameMsg(uint8_t frameType)
  2948. #line 817
  2949. {
  2950.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  2951. #line 818
  2952.     {
  2953.       if (!DrandM$sendBusy) {
  2954.           frameMsg *frameMsgData = (frameMsg *)DrandM$DataPkt.data;
  2956. #line 821
  2957.           frameMsgData->sendID = TOS_LOCAL_ADDRESS;
  2958.           frameMsgData->frame = DrandM$myInfo.frame;
  2959.           frameMsgData->type = frameType;
  2960.           DrandM$fillFrameInfo(frameMsgData);
  2961.           if (DrandM$SendFrameMsg$send(TOS_BCAST_ADDR, sizeof(frameMsg ), &DrandM$DataPkt) == SUCCESS) {
  2962.               DrandM$sendBusy = TRUE;
  2963.             }
  2964.           else 
  2965. #line 827
  2966.             {
  2970.               DrandM$reXTimer$start(TIMER_ONE_SHOT, FRAME_XPERIOD + DrandM$randNew() % FRAME_INTERVAL);
  2971.             }
  2972.         }
  2973.       else 
  2974. #line 833
  2975.         {
  2979.           DrandM$reXTimer$start(TIMER_ONE_SHOT, FRAME_XPERIOD + DrandM$randNew() % FRAME_INTERVAL);
  2980.         }
  2981.     }
  2982. #line 839
  2983.     __nesc_atomic_end(__nesc_atomic); }
  2984. }
  2986. # 144 "../../tos/platform/mica2/HPLADCM.nc"
  2987. void __attribute((signal))   __vector_21(void)
  2988. #line 144
  2989. {
  2990.   uint16_t data = * (volatile uint16_t *)& * (volatile uint8_t *)(0x04 + 0x20);
  2992. #line 146
  2993.   data &= 0x3ff;
  2994.   * (volatile uint8_t *)(0x06 + 0x20) |= 1 << 4;
  2995.   * (volatile uint8_t *)(0x06 + 0x20) &= ~(1 << 7);
  2996.   __nesc_enable_interrupt();
  2997.   HPLADCM$ADC$dataReady(data);
  2998. }
  3000. static   
  3001. #line 122
  3002. result_t HPLADCM$ADC$samplePort(uint8_t port)
  3003. #line 122
  3004. {
  3005.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3006. #line 123
  3007.     {
  3008.       * (volatile uint8_t *)(0x07 + 0x20) = HPLADCM$TOSH_adc_portmap[port] & 0x1F;
  3009.     }
  3010. #line 125
  3011.     __nesc_atomic_end(__nesc_atomic); }
  3012.   * (volatile uint8_t *)(0x06 + 0x20) |= 1 << 7;
  3013.   * (volatile uint8_t *)(0x06 + 0x20) |= 1 << 6;
  3015.   return SUCCESS;
  3016. }
  3018. static  
  3019. # 342 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  3020. void CC1000RadioIntM$adjustSquelch(void)
  3021. #line 342
  3022. {
  3023.   uint16_t tempArray[9];
  3024.   char i;
  3025. #line 344
  3026.   char j;
  3027. #line 344
  3028.   char min;
  3029.   uint16_t min_value;
  3030.   uint32_t tempsquelch;
  3032.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3033. #line 348
  3034.     {
  3035.       CC1000RadioIntM$usSquelchTable[CC1000RadioIntM$usSquelchIndex] = CC1000RadioIntM$usTempSquelch;
  3036.       CC1000RadioIntM$usSquelchIndex++;
  3037.       if (CC1000RadioIntM$usSquelchIndex >= 9) {
  3038.         CC1000RadioIntM$usSquelchIndex = 0;
  3039.         }
  3040. #line 353
  3041.       if (CC1000RadioIntM$iSquelchCount <= 30) {
  3042.         CC1000RadioIntM$iSquelchCount++;
  3043.         }
  3044.     }
  3045. #line 356
  3046.     __nesc_atomic_end(__nesc_atomic); }
  3047.   for (i = 0; i < 9; i++) {
  3048.       tempArray[(int )i] = CC1000RadioIntM$usSquelchTable[(int )i];
  3049.     }
  3051.   min = 0;
  3053.   for (j = 0; j < 3; j++) {
  3054.       for (i = 1; i < 9; i++) {
  3055.           if (tempArray[(int )i] != 0xFFFF && (
  3056.           tempArray[(int )i] > tempArray[(int )min] || 
  3057.           tempArray[(int )min] == 0xFFFF)) {
  3058.               min = i;
  3059.             }
  3060.         }
  3061.       min_value = tempArray[(int )min];
  3062.       tempArray[(int )min] = 0xFFFF;
  3063.     }
  3065.   tempsquelch = (uint32_t )(CC1000RadioIntM$usSquelchVal << 5) + (uint32_t )(min_value << 1);
  3066.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3067. #line 376
  3068.     CC1000RadioIntM$usSquelchVal = (uint16_t )(tempsquelch / 34 & 0x0FFFF);
  3069. #line 376
  3070.     __nesc_atomic_end(__nesc_atomic); }
  3071. }
  3073. static   
  3074. # 422 "../../tos/platform/mica2/CC1000ControlM.nc"
  3075. result_t CC1000ControlM$CC1000Control$TxMode(void)
  3076. #line 422
  3077. {
  3079.   CC1000ControlM$HPLChipcon$write(0x00, (((
  3080.   1 << 7) | (1 << 6)) | (1 << 5)) | (
  3081.   1 << 0));
  3083.   CC1000ControlM$HPLChipcon$write(0x09, CC1000ControlM$gCurrentParameters[29]);
  3084.   TOSH_uwait(250);
  3085.   CC1000ControlM$HPLChipcon$write(0x0B, CC1000ControlM$gCurrentParameters[0xb]);
  3086.   TOSH_uwait(20);
  3087.   return SUCCESS;
  3088. }
  3090. static 
  3091. # 198 "../../tos/platform/mica2/ADCREFM.nc"
  3092. result_t ADCREFM$startGet(uint8_t port)
  3093. #line 198
  3094. {
  3095.   uint16_t PortMask;
  3096. #line 199
  3097.   uint16_t oldReqVector = 1;
  3098.   result_t Result = SUCCESS;
  3100.   PortMask = 1 << port;
  3102.   if ((PortMask & ADCREFM$ReqVector) != 0) {
  3104.       Result = FAIL;
  3105.     }
  3106.   else {
  3107.       oldReqVector = ADCREFM$ReqVector;
  3108.       ADCREFM$ReqVector |= PortMask;
  3109.       if (oldReqVector == 0) {
  3110.           if ((Result = ADCREFM$HPLADC$samplePort(port))) {
  3111.               ADCREFM$ReqPort = port;
  3112.             }
  3113.         }
  3114.     }
  3116.   return Result;
  3117. }
  3119. static  
  3120. # 1586 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  3121. void CC1000RadioIntM$IdleTimerTask(void)
  3122. #line 1586
  3123. {
  3124.   if (CC1000RadioIntM$iSquelchCount > 30) {
  3125.     CC1000RadioIntM$SquelchTimer$start(TIMER_REPEAT, 2560);
  3126.     }
  3127.   else {
  3128. #line 1590
  3129.     CC1000RadioIntM$SquelchTimer$start(TIMER_REPEAT, 128);
  3130.     }
  3131. #line 1591
  3132.   CC1000RadioIntM$WakeupTimer$start(TIMER_ONE_SHOT, CC1000RadioIntM$TIME_AFTER_CHECK);
  3133. }
  3135. static   
  3136. # 82 "../../tos/platform/mica2/HPLSpiM.nc"
  3137. result_t HPLSpiM$SpiByteFifo$disableIntr(void)
  3138. #line 82
  3139. {
  3140.   * (volatile uint8_t *)(0x0D + 0x20) &= ~(1 << 7);
  3141.   * (volatile uint8_t *)(0x17 + 0x20) |= 1 << 0;
  3142.   * (volatile uint8_t *)(0x18 + 0x20) &= ~(1 << 0);
  3143.   HPLSpiM$PowerManagement$adjustPower();
  3144.   return SUCCESS;
  3145. }
  3147. # 167 "/home/testuser/tinyos-1.x/tos/platform/mica/HPLClock.nc"
  3148. void __attribute((interrupt))   __vector_15(void)
  3149. #line 167
  3150. {
  3151.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3152. #line 168
  3153.     {
  3154.       if (HPLClock$set_flag) {
  3155.           HPLClock$mscale = HPLClock$nextScale;
  3156.           HPLClock$nextScale |= 0x8;
  3157.           * (volatile uint8_t *)(0x33 + 0x20) = HPLClock$nextScale;
  3159.           * (volatile uint8_t *)(0x31 + 0x20) = HPLClock$minterval;
  3160.           HPLClock$set_flag = 0;
  3161.         }
  3162.     }
  3163. #line 177
  3164.     __nesc_atomic_end(__nesc_atomic); }
  3165.   HPLClock$Clock$fire();
  3166. }
  3168. static 
  3169. # 401 "../../tos/system/DrandM.nc"
  3170. uint8_t DrandM$getContenders(void)
  3171. #line 401
  3172. {
  3173.   uint8_t i;
  3174. #line 402
  3175.   uint8_t contenders = 0;
  3177. #line 403
  3178.   for (i = 0; i < MAX_NBR && DrandM$nbrInfo[i].nodeID != 0xFF; i++) 
  3179.     if (DrandM$nbrInfo[i].slot == 0xFF) {
  3180.       contenders++;
  3181.       }
  3182. #line 406
  3183.   return contenders + 1;
  3184. }
  3186. static 
  3187. #line 616
  3188. void DrandM$sendRequestMsg(void)
  3189. #line 616
  3190. {
  3191.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3192. #line 617
  3193.     {
  3194.       if (!DrandM$sendBusy) {
  3195.           requestMsg *requestMsgData = (requestMsg *)DrandM$DataPkt.data;
  3197. #line 620
  3198.           requestMsgData->sendID = TOS_LOCAL_ADDRESS;
  3199.           DrandM$SClock$getTime(& requestMsgData->timestamp);
  3201.           requestMsgData->myState = DrandM$globalState;
  3202.           requestMsgData->roundNum = DrandM$roundNum;
  3203.           requestMsgData->lastRequestID = DrandM$lastReqID;
  3205.           DrandM$fillGrantSendInfo(requestMsgData->idMap);
  3206.           requestMsgData->numRemaining = DrandM$numGrantsRemaining();
  3207.           requestMsgData->OTT = DrandM$OTT;
  3209.           if (DrandM$SendRequestMsg$send(TOS_BCAST_ADDR, sizeof(requestMsg ), &DrandM$DataPkt) != SUCCESS) {
  3213.               DrandM$reXTimer$start(TIMER_ONE_SHOT, DrandM$REQUEST_TIME);
  3214.             }
  3215.           else 
  3216. #line 636
  3217.             {
  3218.               DrandM$sendBusy = TRUE;
  3219.             }
  3220.         }
  3221.       else 
  3222. #line 639
  3223.         {
  3227.           DrandM$reXTimer$start(TIMER_ONE_SHOT, DrandM$REQUEST_TIME);
  3228.         }
  3229.     }
  3230. #line 645
  3231.     __nesc_atomic_end(__nesc_atomic); }
  3232. }
  3234. static   
  3235. # 1166 "../../tos/platform/mica2/CC1000RadioIntM.nc"
  3236. result_t CC1000RadioIntM$SpiByteFifo$dataReady(uint8_t data_in)
  3237. #line 1166
  3238. {
  3239.   GTime loctime;
  3241. #line 1168
  3242.   CC1000RadioIntM$RadioSendCoordinator$blockTimer();
  3243.   CC1000RadioIntM$RadioReceiveCoordinator$blockTimer();
  3245.   if (CC1000RadioIntM$bInvertRxData) {
  3246.     data_in = ~data_in;
  3247.     }
  3250.   switch (CC1000RadioIntM$RadioState) {
  3252.       case CC1000RadioIntM$TX_STATE: 
  3253.         {
  3254.           CC1000RadioIntM$SpiByteFifo$writeByte(CC1000RadioIntM$NextTxByte);
  3255.           CC1000RadioIntM$TxByteCnt++;
  3256.           switch (CC1000RadioIntM$RadioTxState) {
  3258.               case CC1000RadioIntM$TXSTATE_PREAMBLE: 
  3259.                 CC1000RadioIntM$send_sum++;
  3260.               if (!(CC1000RadioIntM$TxByteCnt < CC1000RadioIntM$preamblelen) || (
  3261.               CC1000RadioIntM$txbufptr->strength == 0xffff && CC1000RadioIntM$TxByteCnt >= CC1000RadioIntM$PREAMBLE_LENGTH_TO_BASE)) {
  3262.                   CC1000RadioIntM$NextTxByte = CC1000RadioIntM$SYNC_BYTE;
  3263.                   CC1000RadioIntM$RadioTxState = CC1000RadioIntM$TXSTATE_SYNC;
  3264.                 }
  3269.               break;
  3271.               case CC1000RadioIntM$TXSTATE_SYNC: 
  3272.                 CC1000RadioIntM$send_sum++;
  3273.               CC1000RadioIntM$NextTxByte = CC1000RadioIntM$NSYNC_BYTE;
  3274.               CC1000RadioIntM$RadioTxState = CC1000RadioIntM$TXSTATE_DATA;
  3275.               CC1000RadioIntM$TxByteCnt = -1;
  3276.               if (CC1000RadioIntM$txbufptr->type == 223) {
  3277.                   syncMsgType *syncMsgPtr = (syncMsgType *)CC1000RadioIntM$txbufptr->data;
  3279. #line 1204
  3280.                   CC1000RadioIntM$SClock$getTime(&loctime);
  3281.                   syncMsgPtr->mticks = loctime.mticks;
  3282.                   syncMsgPtr->sticks = loctime.sticks;
  3283.                   syncMsgPtr->trust = 1;
  3284.                   syncMsgPtr->sender = TOS_LOCAL_ADDRESS;
  3285.                 }
  3287.               CC1000RadioIntM$RadioSendCoordinator$startSymbol(8, 0, CC1000RadioIntM$txbufptr);
  3288.               break;
  3290.               case CC1000RadioIntM$TXSTATE_DATA: 
  3291.                 CC1000RadioIntM$send_sum++;
  3292.               if ((uint8_t )CC1000RadioIntM$TxByteCnt < CC1000RadioIntM$txlength) {
  3293.                   if (CC1000RadioIntM$txbufptr->type == 223 && CC1000RadioIntM$TxByteCnt == 5) {
  3294.                       syncMsgType *syncMsgPtr = (syncMsgType *)CC1000RadioIntM$txbufptr->data;
  3296. #line 1219
  3297.                       CC1000RadioIntM$SClock$getTime(&loctime);
  3298.                       CC1000RadioIntM$AddTime(&loctime, &loctime, &CC1000RadioIntM$constOffset);
  3299.                       syncMsgPtr->mticks = loctime.mticks;
  3300.                       syncMsgPtr->sticks = loctime.sticks;
  3301.                     }
  3302.                   CC1000RadioIntM$NextTxByte = ((uint8_t *)CC1000RadioIntM$txbufptr)[CC1000RadioIntM$TxByteCnt];
  3303.                   CC1000RadioIntM$usRunningCRC = crcByte(CC1000RadioIntM$usRunningCRC, CC1000RadioIntM$NextTxByte);
  3304.                   CC1000RadioIntM$RadioSendCoordinator$byte(CC1000RadioIntM$txbufptr, (uint8_t )CC1000RadioIntM$TxByteCnt);
  3305.                 }
  3306.               else {
  3307.                   CC1000RadioIntM$NextTxByte = (uint8_t )CC1000RadioIntM$usRunningCRC;
  3308.                   CC1000RadioIntM$RadioTxState = CC1000RadioIntM$TXSTATE_CRC;
  3309.                 }
  3310.               break;
  3312.               case CC1000RadioIntM$TXSTATE_CRC: 
  3313.                 CC1000RadioIntM$send_sum++;
  3314.               CC1000RadioIntM$NextTxByte = (uint8_t )(CC1000RadioIntM$usRunningCRC >> 8);
  3315.               CC1000RadioIntM$RadioTxState = CC1000RadioIntM$TXSTATE_FLUSH;
  3316.               CC1000RadioIntM$TxByteCnt = 0;
  3317.               break;
  3319.               case CC1000RadioIntM$TXSTATE_FLUSH: 
  3320.                 CC1000RadioIntM$send_sum++;
  3321.               if (CC1000RadioIntM$TxByteCnt > 3) {
  3322.                   CC1000RadioIntM$TxByteCnt = 0;
  3326.                   if (CC1000RadioIntM$bAckEnable) {
  3327.                     CC1000RadioIntM$RadioTxState = CC1000RadioIntM$TXSTATE_WAIT_FOR_ACK;
  3328.                     }
  3329.                   else 
  3330. #line 1250
  3331.                     {
  3335.                       CC1000RadioIntM$packetsSent++;
  3336.                       CC1000RadioIntM$SpiByteFifo$rxMode();
  3337.                       CC1000RadioIntM$CC1000Control$RxMode();
  3338.                       CC1000RadioIntM$RadioTxState = CC1000RadioIntM$TXSTATE_DONE;
  3339.                     }
  3340.                 }
  3341.               break;
  3343.               case CC1000RadioIntM$TXSTATE_WAIT_FOR_ACK: 
  3344.                 if (CC1000RadioIntM$TxByteCnt == 1) {
  3345.                     CC1000RadioIntM$send_sum++;
  3346.                     CC1000RadioIntM$SpiByteFifo$rxMode();
  3347.                     CC1000RadioIntM$CC1000Control$RxMode();
  3348.                     break;
  3349.                   }
  3350.               CC1000RadioIntM$receive_sum++;
  3351.               if (CC1000RadioIntM$TxByteCnt > 3) {
  3352.                   CC1000RadioIntM$RadioTxState = CC1000RadioIntM$TXSTATE_READ_ACK;
  3353.                   CC1000RadioIntM$TxByteCnt = 0;
  3354.                   CC1000RadioIntM$search_word = 0;
  3355.                 }
  3356.               break;
  3358.               case CC1000RadioIntM$TXSTATE_READ_ACK: 
  3359.                 {
  3360.                   uint8_t i;
  3362. #line 1280
  3363.                   CC1000RadioIntM$receive_sum++;
  3364.                   for (i = 0; i < 8; i++) {
  3365.                       CC1000RadioIntM$search_word <<= 1;
  3366.                       if (data_in & 0x80) {
  3367. #line 1283
  3368.                         CC1000RadioIntM$search_word |= 0x1;
  3369.                         }
  3370. #line 1284
  3371.                       data_in <<= 1;
  3372.                       if (CC1000RadioIntM$search_word == 0xba83) {
  3373.                           CC1000RadioIntM$txbufptr->ack = 1;
  3374.                           CC1000RadioIntM$RadioTxState = CC1000RadioIntM$TXSTATE_DONE;
  3378.                           return SUCCESS;
  3379.                         }
  3380.                     }
  3381.                 }
  3382.               if (CC1000RadioIntM$TxByteCnt >= CC1000RadioIntM$MAX_ACK_WAIT) {
  3383.                   CC1000RadioIntM$txbufptr->ack = 0;
  3387.                   CC1000RadioIntM$RadioTxState = CC1000RadioIntM$TXSTATE_DONE;
  3388.                 }
  3389.               break;
  3391.               case CC1000RadioIntM$TXSTATE_DONE: 
  3392.                 default: 
  3393.                   CC1000RadioIntM$bTxPending = FALSE;
  3394.               if (CC1000RadioIntM$txbufptr->type == 222 || CC1000RadioIntM$txbufptr->type == 223) {
  3400.                   CC1000RadioIntM$bAckEnable = CC1000RadioIntM$ackOrig;
  3401.                 }
  3406.               if (TOS_post(CC1000RadioIntM$PacketSent)) {
  3412.                   CC1000RadioIntM$RadioState = CC1000RadioIntM$IDLE_STATE;
  3413.                   CC1000RadioIntM$pktsLastSync++;
  3414.                   CC1000RadioIntM$RSSIInitState = CC1000RadioIntM$RadioState;
  3415.                   CC1000RadioIntM$RSSIADC$getData();
  3416.                 }
  3417.               break;
  3418.             }
  3419.         }
  3420.       break;
  3422.       case CC1000RadioIntM$DISABLED_STATE: 
  3423.         break;
  3425.       case CC1000RadioIntM$IDLE_STATE: 
  3426.         {
  3427.           CC1000RadioIntM$receive_sum++;
  3428.           if (data_in == 0xaa || data_in == 0x55) {
  3429.               CC1000RadioIntM$PreambleCount++;
  3430.               if (CC1000RadioIntM$PreambleCount > 2) {
  3431.                   CC1000RadioIntM$PreambleCount = CC1000RadioIntM$SOFCount = 0;
  3432.                   CC1000RadioIntM$RxBitOffset = CC1000RadioIntM$RxByteCnt = 0;
  3433.                   CC1000RadioIntM$usRunningCRC = 0;
  3434.                   CC1000RadioIntM$rxlength = MSG_DATA_SIZE - 2;
  3435.                   CC1000RadioIntM$RadioState = CC1000RadioIntM$SYNC_STATE;
  3436.                 }
  3437.             }
  3438.           else 
  3439. #line 1350
  3440.             {
  3441.               if ((CC1000RadioIntM$currentMAC == CC1000RadioIntM$BMAC || CC1000RadioIntM$enableHCL == FALSE) || !CC1000RadioIntM$IsHCL(CC1000RadioIntM$currentSlot)) {
  3442.                   if (CC1000RadioIntM$bTxPending && --CC1000RadioIntM$sMacDelay <= 0) {
  3443.                       CC1000RadioIntM$RadioState = CC1000RadioIntM$PRETX_STATE;
  3444.                       CC1000RadioIntM$RSSIInitState = CC1000RadioIntM$PRETX_STATE;
  3445.                       CC1000RadioIntM$bRSSIValid = FALSE;
  3446.                       CC1000RadioIntM$iRSSIcount = 0;
  3447.                       CC1000RadioIntM$PreambleCount = 0;
  3448.                       CC1000RadioIntM$RSSIADC$getData();
  3449.                     }
  3450.                 }
  3451.               else 
  3452. #line 1360
  3453.                 {
  3454.                 }
  3455.             }
  3456.         }
  3460.       break;
  3462.       case CC1000RadioIntM$PRETX_STATE: 
  3463.         {
  3464.           CC1000RadioIntM$receive_sum++;
  3465.           if (data_in == 0xaa || data_in == 0x55) {
  3467.               CC1000RadioIntM$sMacDelay = CC1000RadioIntM$MacBackoff$congestionBackoff(CC1000RadioIntM$txbufptr);
  3471.               CC1000RadioIntM$RadioState = CC1000RadioIntM$IDLE_STATE;
  3472.             }
  3473.         }
  3474.       break;
  3476.       case CC1000RadioIntM$SYNC_STATE: 
  3477.         {
  3485.           uint8_t i;
  3487.           CC1000RadioIntM$receive_sum++;
  3488.           if (data_in == 0xaa || data_in == 0x55) {
  3493.               CC1000RadioIntM$RxShiftBuf.MSB = data_in;
  3494.             }
  3495.           else {
  3497.               uint16_t usTmp;
  3499. #line 1405
  3500.               switch (CC1000RadioIntM$SOFCount) {
  3501.                   case 0: 
  3502.                     CC1000RadioIntM$RxShiftBuf.LSB = data_in;
  3503.                   break;
  3505.                   case 1: 
  3506.                     case 2: 
  3507.                       case 3: 
  3508.                         case 4: 
  3509.                           case 5: 
  3511.                             usTmp = CC1000RadioIntM$RxShiftBuf.W;
  3512.                   CC1000RadioIntM$RxShiftBuf.W <<= 8;
  3513.                   CC1000RadioIntM$RxShiftBuf.LSB = data_in;
  3515.                   for (i = 0; i < 8; i++) {
  3516.                       usTmp <<= 1;
  3517.                       if (data_in & 0x80) {
  3518.                         usTmp |= 0x1;
  3519.                         }
  3520. #line 1424
  3521.                       data_in <<= 1;
  3523.                       if (usTmp == CC1000RadioIntM$SYNC_WORD) {
  3524.                           if (CC1000RadioIntM$rxbufptr->length != 0) {
  3525.                               CC1000RadioIntM$Leds$redToggle();
  3526.                               CC1000RadioIntM$RadioState = CC1000RadioIntM$IDLE_STATE;
  3527.                             }
  3528.                           else {
  3529.                               CC1000RadioIntM$RadioState = CC1000RadioIntM$RX_STATE;
  3530.                               CC1000RadioIntM$RSSIInitState = CC1000RadioIntM$RX_STATE;
  3531.                               CC1000RadioIntM$RSSIADC$getData();
  3532.                               CC1000RadioIntM$RxBitOffset = 7 - i;
  3534.                               CC1000RadioIntM$RadioReceiveCoordinator$startSymbol(8, CC1000RadioIntM$RxBitOffset, CC1000RadioIntM$rxbufptr);
  3535.                             }
  3536.                           break;
  3537.                         }
  3538.                     }
  3539.                   break;
  3541.                   default: 
  3543.                     CC1000RadioIntM$RadioState = CC1000RadioIntM$IDLE_STATE;
  3544.                   break;
  3545.                 }
  3546.               CC1000RadioIntM$SOFCount++;
  3547.             }
  3548.         }
  3549.       break;
  3556.       case CC1000RadioIntM$RX_STATE: 
  3557.         {
  3558.           char Byte;
  3560. #line 1462
  3561.           CC1000RadioIntM$receive_sum++;
  3563.           CC1000RadioIntM$RxShiftBuf.W <<= 8;
  3564.           CC1000RadioIntM$RxShiftBuf.LSB = data_in;
  3566.           Byte = CC1000RadioIntM$RxShiftBuf.W >> CC1000RadioIntM$RxBitOffset;
  3567.           ((char *)CC1000RadioIntM$rxbufptr)[(int )CC1000RadioIntM$RxByteCnt] = Byte;
  3568.           CC1000RadioIntM$RxByteCnt++;
  3570.           CC1000RadioIntM$RadioReceiveCoordinator$byte(CC1000RadioIntM$rxbufptr, (uint8_t )CC1000RadioIntM$RxByteCnt);
  3572.           if (CC1000RadioIntM$RxByteCnt < CC1000RadioIntM$rxlength) {
  3573.               CC1000RadioIntM$usRunningCRC = crcByte(CC1000RadioIntM$usRunningCRC, Byte);
  3575.               if (CC1000RadioIntM$RxByteCnt == (size_t )& ((struct TOS_Msg *)0)->length + 
  3576.               sizeof  ((struct TOS_Msg *)0)->length) {
  3577.                   CC1000RadioIntM$rxlength = CC1000RadioIntM$rxbufptr->length;
  3578.                   if (CC1000RadioIntM$rxlength > 29) {
  3580.                       CC1000RadioIntM$rxbufptr->length = 0;
  3581.                       CC1000RadioIntM$RadioState = CC1000RadioIntM$IDLE_STATE;
  3582.                       return SUCCESS;
  3583.                     }
  3585.                   CC1000RadioIntM$rxlength += (size_t )& ((struct TOS_Msg *)0)->data;
  3586.                 }
  3587.             }
  3588.           else {
  3589. #line 1489
  3590.             if (CC1000RadioIntM$RxByteCnt == CC1000RadioIntM$rxlength) {
  3591.                 if (CC1000RadioIntM$rxbufptr->type == 223) {
  3592.                   CC1000RadioIntM$getTimeDiff();
  3593.                   }
  3594. #line 1492
  3595.                 CC1000RadioIntM$usRunningCRC = crcByte(CC1000RadioIntM$usRunningCRC, Byte);
  3597.                 CC1000RadioIntM$RxByteCnt = (size_t )& ((struct TOS_Msg *)0)->crc;
  3598.               }
  3599.             else {
  3600. #line 1496
  3601.               if (CC1000RadioIntM$RxByteCnt >= MSG_DATA_SIZE) {
  3605.                   if (CC1000RadioIntM$rxbufptr->crc == CC1000RadioIntM$usRunningCRC) {
  3606.                       if (CC1000RadioIntM$rxbufptr->type == 223) {
  3607.                         TOS_post(CC1000RadioIntM$adjustTime);
  3608.                         }
  3609. #line 1503
  3610.                       CC1000RadioIntM$rxbufptr->crc = 1;
  3612.                       if (CC1000RadioIntM$bAckEnable && CC1000RadioIntM$rxbufptr->addr == TOS_LOCAL_ADDRESS) {
  3614.                           CC1000RadioIntM$RadioState = CC1000RadioIntM$SENDING_ACK;
  3615.                           CC1000RadioIntM$CC1000Control$TxMode();
  3616.                           CC1000RadioIntM$SpiByteFifo$txMode();
  3617.                           CC1000RadioIntM$SpiByteFifo$writeByte(0xaa);
  3618.                           CC1000RadioIntM$RxByteCnt = 0;
  3619.                           return SUCCESS;
  3620.                         }
  3621.                     }
  3622.                   else {
  3623.                       CC1000RadioIntM$rxbufptr->crc = 0;
  3624.                     }
  3626.                   CC1000RadioIntM$SpiByteFifo$disableIntr();
  3628.                   CC1000RadioIntM$RadioState = CC1000RadioIntM$IDLE_STATE;
  3629.                   if (CC1000RadioIntM$currentMAC == CC1000RadioIntM$ZMAC && CC1000RadioIntM$bTxPending) {
  3630.                       CC1000RadioIntM$sMacDelay = CC1000RadioIntM$getZMACBackoff(CC1000RadioIntM$sMacDelay);
  3631.                     }
  3636.                   CC1000RadioIntM$rxbufptr->strength = CC1000RadioIntM$usRSSIVal;
  3637.                   if (!TOS_post(CC1000RadioIntM$PacketRcvd)) {
  3640.                       CC1000RadioIntM$rxbufptr->length = 0;
  3641.                       CC1000RadioIntM$RadioState = CC1000RadioIntM$IDLE_STATE;
  3642.                       CC1000RadioIntM$SpiByteFifo$enableIntr();
  3643.                     }
  3644.                   CC1000RadioIntM$RSSIInitState = CC1000RadioIntM$RadioState;
  3645.                   CC1000RadioIntM$RSSIADC$getData();
  3646.                 }
  3647.               }
  3648.             }
  3649.         }
  3650. #line 1541
  3651.       break;
  3653.       case CC1000RadioIntM$SENDING_ACK: 
  3654.         {
  3655.           CC1000RadioIntM$send_sum++;
  3656.           CC1000RadioIntM$RxByteCnt++;
  3657.           if (CC1000RadioIntM$RxByteCnt >= CC1000RadioIntM$ACK_LENGTH) {
  3658.               CC1000RadioIntM$CC1000Control$RxMode();
  3659.               CC1000RadioIntM$SpiByteFifo$rxMode();
  3660.               CC1000RadioIntM$SpiByteFifo$disableIntr();
  3661.               CC1000RadioIntM$RadioState = CC1000RadioIntM$IDLE_STATE;
  3662.               CC1000RadioIntM$rxbufptr->strength = CC1000RadioIntM$usRSSIVal;
  3663.               if (!TOS_post(CC1000RadioIntM$PacketRcvd)) {
  3664.                   CC1000RadioIntM$rxbufptr->length = 0;
  3665.                   CC1000RadioIntM$RadioState = CC1000RadioIntM$IDLE_STATE;
  3666.                   CC1000RadioIntM$SpiByteFifo$enableIntr();
  3667.                 }
  3668.             }
  3669.           else {
  3670. #line 1558
  3671.             if (CC1000RadioIntM$RxByteCnt >= CC1000RadioIntM$ACK_LENGTH - sizeof CC1000RadioIntM$ack_code) {
  3672.                 CC1000RadioIntM$SpiByteFifo$writeByte(CC1000RadioIntM$ack_code[CC1000RadioIntM$RxByteCnt + sizeof CC1000RadioIntM$ack_code - CC1000RadioIntM$ACK_LENGTH]);
  3673.               }
  3674.             }
  3675.         }
  3676. #line 1562
  3677.       break;
  3679.       default: 
  3680.         break;
  3681.     }
  3683.   if (CC1000RadioIntM$pulse_check_sum > CC1000RadioIntM$CHECK_MA_COUNT) {
  3684.       CC1000RadioIntM$power_sum++;
  3685.       CC1000RadioIntM$sp_sum++;
  3686.       CC1000RadioIntM$pulse_check_sum -= CC1000RadioIntM$CHECK_MA_COUNT;
  3687.     }
  3688.   if (CC1000RadioIntM$send_sum > CC1000RadioIntM$SEND_MA_COUNT) {
  3689.       CC1000RadioIntM$power_sum++;
  3690.       CC1000RadioIntM$tx_sum++;
  3691.       CC1000RadioIntM$send_sum -= CC1000RadioIntM$SEND_MA_COUNT;
  3692.     }
  3693.   if (CC1000RadioIntM$receive_sum > CC1000RadioIntM$RECEIVE_MA_COUNT) {
  3694.       CC1000RadioIntM$power_sum++;
  3695.       CC1000RadioIntM$rx_sum++;
  3696.       CC1000RadioIntM$receive_sum -= CC1000RadioIntM$RECEIVE_MA_COUNT;
  3697.     }
  3698.   return SUCCESS;
  3699. }
  3701. static 
  3702. #line 275
  3703. void CC1000RadioIntM$SubTime(GTime *C, GTime *A, GTime *B)
  3704. #line 275
  3705. {
  3706.   if (B->sticks > A->sticks) {
  3707.       C->sticks = CC1000RadioIntM$MAX_VAL - (B->sticks - A->sticks);
  3708.       C->mticks = A->mticks - (B->mticks + 1);
  3709.     }
  3710.   else {
  3711.       C->sticks = A->sticks - B->sticks;
  3712.       C->mticks = A->mticks - B->mticks;
  3713.     }
  3714. }
  3716. static  
  3717. #line 432
  3718. void CC1000RadioIntM$PacketRcvd(void)
  3719. #line 432
  3720. {
  3721.   TOS_MsgPtr pBuf;
  3722.   ecnForwardMsgType *recvEcnMsgPtr;
  3723.   ecnForwardMsgType *ecnForwardMsgPtr;
  3725. #line 436
  3726.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3727. #line 436
  3728.     {
  3729.       if (CC1000RadioIntM$pktsLastSync > 100) {
  3730.           {
  3731.             CC1000RadioIntM$ackOrig = CC1000RadioIntM$bAckEnable;
  3732.             CC1000RadioIntM$bAckEnable = FALSE;
  3733.           }
  3734.           CC1000RadioIntM$Send$send(&CC1000RadioIntM$syncMsgHdr);
  3735.           CC1000RadioIntM$pktsLastSync = 0;
  3736.         }
  3738.       CC1000RadioIntM$pktsLastSync++;
  3739.       CC1000RadioIntM$rxbufptr->time = 0;
  3740.       pBuf = CC1000RadioIntM$rxbufptr;
  3741.       recvEcnMsgPtr = (ecnForwardMsgType *)CC1000RadioIntM$rxbufptr->data;
  3742.       ecnForwardMsgPtr = (ecnForwardMsgType *)CC1000RadioIntM$ecnForwardMsgHdr.data;
  3751.       if (CC1000RadioIntM$currentMAC == CC1000RadioIntM$ZMAC && CC1000RadioIntM$HCLselect && pBuf->type == 222 && pBuf->crc != 0 && 
  3752.       recvEcnMsgPtr->senderAddress != TOS_LOCAL_ADDRESS) {
  3753.           if (recvEcnMsgPtr->hopCount == 0 && recvEcnMsgPtr->nextHop == TOS_LOCAL_ADDRESS) {
  3757.               ecnForwardMsgPtr->hopCount = 1;
  3758.               ecnForwardMsgPtr->nextHop = CC1000RadioIntM$nextHop;
  3759.               ecnForwardMsgPtr->senderAddress = TOS_LOCAL_ADDRESS;
  3760.               if (!CC1000RadioIntM$bTxBusy) {
  3761.                   CC1000RadioIntM$ackOrig = CC1000RadioIntM$bAckEnable;
  3762.                   CC1000RadioIntM$bAckEnable = FALSE;
  3763.                   CC1000RadioIntM$Send$send(&CC1000RadioIntM$ecnForwardMsgHdr);
  3764.                 }
  3765.               else {
  3768.                 CC1000RadioIntM$ecnforward = TRUE;
  3769.                 }
  3770.             }
  3771.           else {
  3772. #line 477
  3773.             if (recvEcnMsgPtr->hopCount == 1) {
  3777.                 CC1000RadioIntM$enableHCL = TRUE;
  3778.                 if (recvEcnMsgPtr->senderAddress == CC1000RadioIntM$nextHop) {
  3783.                     CC1000RadioIntM$ecnPending = FALSE;
  3784.                     CC1000RadioIntM$slots_since_ecnsend = 0;
  3785.                     CC1000RadioIntM$slots_since_ecnrecv = 0;
  3786.                   }
  3787.               }
  3788.             }
  3789.         }
  3790.       else {
  3791. #line 492
  3792.         if (pBuf->type != 223 && pBuf->type != 222) {
  3796.             pBuf = CC1000RadioIntM$Receive$receive((TOS_MsgPtr )pBuf);
  3797.           }
  3798.         }
  3799.       if (pBuf) {
  3800.         CC1000RadioIntM$rxbufptr = pBuf;
  3801.         }
  3802. #line 501
  3803.       CC1000RadioIntM$rxbufptr->length = 0;
  3804.     }
  3805. #line 502
  3806.     __nesc_atomic_end(__nesc_atomic); }
  3807.   CC1000RadioIntM$SpiByteFifo$enableIntr();
  3808. }
  3810. # 124 "../../tos/platform/mica2/HPLSClock.nc"
  3811. void __attribute((interrupt))   __vector_26(void)
  3812. #line 124
  3813. {
  3814.   if (HPLSClock$needupdate) {
  3815.       if (HPLSClock$sign == NEGATIVE) {
  3816.           * (volatile uint16_t *)0x88 = MAX_VAL - HPLSClock$Update.sticks;
  3817.           HPLSClock$MTicks = HPLSClock$MTicks - HPLSClock$Update.mticks;
  3818.         }
  3819.       else {
  3820. #line 130
  3821.         if (HPLSClock$sign == POSITIVE) {
  3822.             * (volatile uint16_t *)0x88 = HPLSClock$Update.sticks;
  3823.             HPLSClock$MTicks = HPLSClock$MTicks + HPLSClock$Update.mticks + 1;
  3824.             HPLSClock$SClock$fire(HPLSClock$MTicks);
  3825.           }
  3826.         }
  3827. #line 135
  3828.       HPLSClock$needupdate = 0;
  3829.       HPLSClock$SClock$syncDone();
  3830.     }
  3831.   else {
  3832.       HPLSClock$MTicks++;
  3833.       HPLSClock$SClock$fire(HPLSClock$MTicks);
  3834.     }
  3835. }
  3837. static   
  3838. # 348 "/home/testuser/tinyos-1.x/tos/system/FramerM.nc"
  3839. result_t FramerM$ByteComm$rxByteReady(uint8_t data, bool error, uint16_t strength)
  3840. #line 348
  3841. {
  3843.   switch (FramerM$gRxState) {
  3845.       case FramerM$RXSTATE_NOSYNC: 
  3846.         if (data == FramerM$HDLC_FLAG_BYTE && FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Length == 0) {
  3847.             FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Token = 0;
  3848.             FramerM$gRxByteCnt = FramerM$gRxRunningCRC = 0;
  3849.             FramerM$gpRxBuf = (uint8_t *)FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].pMsg;
  3850.             FramerM$gRxState = FramerM$RXSTATE_PROTO;
  3851.           }
  3852.       break;
  3854.       case FramerM$RXSTATE_PROTO: 
  3855.         if (data == FramerM$HDLC_FLAG_BYTE) {
  3856.             break;
  3857.           }
  3858.       FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Proto = data;
  3859.       FramerM$gRxRunningCRC = crcByte(FramerM$gRxRunningCRC, data);
  3860.       switch (data) {
  3861.           case FramerM$PROTO_PACKET_ACK: 
  3862.             FramerM$gRxState = FramerM$RXSTATE_TOKEN;
  3863.           break;
  3864.           case FramerM$PROTO_PACKET_NOACK: 
  3865.             FramerM$gRxState = FramerM$RXSTATE_INFO;
  3866.           break;
  3867.           default: 
  3868.             FramerM$gRxState = FramerM$RXSTATE_NOSYNC;
  3869.           break;
  3870.         }
  3871.       break;
  3873.       case FramerM$RXSTATE_TOKEN: 
  3874.         if (data == FramerM$HDLC_FLAG_BYTE) {
  3875.             FramerM$gRxState = FramerM$RXSTATE_NOSYNC;
  3876.           }
  3877.         else {
  3878. #line 384
  3879.           if (data == FramerM$HDLC_CTLESC_BYTE) {
  3880.               FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Token = 0x20;
  3881.             }
  3882.           else {
  3883.               FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Token ^= data;
  3884.               FramerM$gRxRunningCRC = crcByte(FramerM$gRxRunningCRC, FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Token);
  3885.               FramerM$gRxState = FramerM$RXSTATE_INFO;
  3886.             }
  3887.           }
  3888. #line 392
  3889.       break;
  3892.       case FramerM$RXSTATE_INFO: 
  3893.         if (FramerM$gRxByteCnt > FramerM$HDLC_MTU) {
  3894.             FramerM$gRxByteCnt = FramerM$gRxRunningCRC = 0;
  3895.             FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Length = 0;
  3896.             FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Token = 0;
  3897.             FramerM$gRxState = FramerM$RXSTATE_NOSYNC;
  3898.           }
  3899.         else {
  3900. #line 402
  3901.           if (data == FramerM$HDLC_CTLESC_BYTE) {
  3902.               FramerM$gRxState = FramerM$RXSTATE_ESC;
  3903.             }
  3904.           else {
  3905. #line 405
  3906.             if (data == FramerM$HDLC_FLAG_BYTE) {
  3907.                 if (FramerM$gRxByteCnt >= 2) {
  3908.                     uint16_t usRcvdCRC = FramerM$gpRxBuf[FramerM$gRxByteCnt - 1] & 0xff;
  3910. #line 408
  3911.                     usRcvdCRC = (usRcvdCRC << 8) | (FramerM$gpRxBuf[FramerM$gRxByteCnt - 2] & 0xff);
  3912.                     if (usRcvdCRC == FramerM$gRxRunningCRC) {
  3913.                         FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Length = FramerM$gRxByteCnt - 2;
  3914.                         TOS_post(FramerM$PacketRcvd);
  3915.                         FramerM$gRxHeadIndex++;
  3916. #line 412
  3917.                         FramerM$gRxHeadIndex %= FramerM$HDLC_QUEUESIZE;
  3918.                       }
  3919.                     else {
  3920.                         FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Length = 0;
  3921.                         FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Token = 0;
  3922.                       }
  3923.                     if (FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Length == 0) {
  3924.                         FramerM$gpRxBuf = (uint8_t *)FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].pMsg;
  3925.                         FramerM$gRxState = FramerM$RXSTATE_PROTO;
  3926.                       }
  3927.                     else {
  3928.                         FramerM$gRxState = FramerM$RXSTATE_NOSYNC;
  3929.                       }
  3930.                   }
  3931.                 else {
  3932.                     FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Length = 0;
  3933.                     FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Token = 0;
  3934.                     FramerM$gRxState = FramerM$RXSTATE_NOSYNC;
  3935.                   }
  3936.                 FramerM$gRxByteCnt = FramerM$gRxRunningCRC = 0;
  3937.               }
  3938.             else {
  3939.                 FramerM$gpRxBuf[FramerM$gRxByteCnt] = data;
  3940.                 if (FramerM$gRxByteCnt >= 2) {
  3941.                     FramerM$gRxRunningCRC = crcByte(FramerM$gRxRunningCRC, FramerM$gpRxBuf[FramerM$gRxByteCnt - 2]);
  3942.                   }
  3943.                 FramerM$gRxByteCnt++;
  3944.               }
  3945.             }
  3946.           }
  3947. #line 440
  3948.       break;
  3950.       case FramerM$RXSTATE_ESC: 
  3951.         if (data == FramerM$HDLC_FLAG_BYTE) {
  3953.             FramerM$gRxByteCnt = FramerM$gRxRunningCRC = 0;
  3954.             FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Length = 0;
  3955.             FramerM$gMsgRcvTbl[FramerM$gRxHeadIndex].Token = 0;
  3956.             FramerM$gRxState = FramerM$RXSTATE_NOSYNC;
  3957.           }
  3958.         else {
  3959.             data = data ^ 0x20;
  3960.             FramerM$gpRxBuf[FramerM$gRxByteCnt] = data;
  3961.             if (FramerM$gRxByteCnt >= 2) {
  3962.                 FramerM$gRxRunningCRC = crcByte(FramerM$gRxRunningCRC, FramerM$gpRxBuf[FramerM$gRxByteCnt - 2]);
  3963.               }
  3964.             FramerM$gRxByteCnt++;
  3965.             FramerM$gRxState = FramerM$RXSTATE_INFO;
  3966.           }
  3967.       break;
  3969.       default: 
  3970.         FramerM$gRxState = FramerM$RXSTATE_NOSYNC;
  3971.       break;
  3972.     }
  3974.   return SUCCESS;
  3975. }
  3977. static   
  3978. # 87 "/home/testuser/tinyos-1.x/tos/system/UARTM.nc"
  3979. result_t UARTM$HPLUART$putDone(void)
  3980. #line 87
  3981. {
  3982.   bool oldState;
  3984.   { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  3985. #line 90
  3986.     {
  3987.       {
  3988.       }
  3989. #line 91
  3990.       ;
  3991.       oldState = UARTM$state;
  3992.       UARTM$state = FALSE;
  3993.     }
  3994. #line 94
  3995.     __nesc_atomic_end(__nesc_atomic); }
  4004.   if (oldState) {
  4005.       UARTM$ByteComm$txDone();
  4006.       UARTM$ByteComm$txByteReady(TRUE);
  4007.     }
  4008.   return SUCCESS;
  4009. }
  4011. static 
  4012. # 469 "/home/testuser/tinyos-1.x/tos/system/FramerM.nc"
  4013. result_t FramerM$TxArbitraryByte(uint8_t inByte)
  4014. #line 469
  4015. {
  4016.   if (inByte == FramerM$HDLC_FLAG_BYTE || inByte == FramerM$HDLC_CTLESC_BYTE) {
  4017.       { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
  4018. #line 471
  4019.         {
  4020.           FramerM$gPrevTxState = FramerM$gTxState;
  4021.           FramerM$gTxState = FramerM$TXSTATE_ESC;
  4022.           FramerM$gTxEscByte = inByte;
  4023.         }
  4024. #line 475
  4025.         __nesc_atomic_end(__nesc_atomic); }
  4026.       inByte = FramerM$HDLC_CTLESC_BYTE;
  4027.     }
  4029.   return FramerM$ByteComm$txByte(inByte);
  4030. }