app.c

来自「无线网络传感器基站通用节点测试程序.包含基站接口和主模块程序.」· C语言 代码 · 共 3,258 行 · 第 1/5 页

#line 67
# 131 "C:/tinyos/cygwin/opt/tinyos-1.x/tos/interfaces/Leds.nc"
inline static   result_t GenericBaseM$Leds$yellowToggle(void){
#line 131
  unsigned char result;
#line 131

#line 131
  result = LedsC$Leds$yellowToggle();
#line 131

#line 131
  return result;
#line 131
}
#line 131
static inline   
# 136 "C:/tinyos/cygwin/opt/tinyos-1.x/tos/system/LedsC.nc"
result_t LedsC$Leds$yellowOff(void)
#line 136
{
  {
  }
#line 137
  ;
  { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
#line 138
    {
      TOSH_SET_YELLOW_LED_PIN();
      LedsC$ledsOn &= ~LedsC$YELLOW_BIT;
    }
#line 141
    __nesc_atomic_end(__nesc_atomic); }
  return SUCCESS;
}

# 36 "C:/tinyos/cygwin/opt/tinyos-1.x/tos/platform/CC2430/hardware.h"
static __inline void TOSH_CLR_YELLOW_LED_PIN(void)
#line 36
{
#line 36
  P1 &= ~(1 << 4);
}

static inline   
# 127 "C:/tinyos/cygwin/opt/tinyos-1.x/tos/system/LedsC.nc"
result_t LedsC$Leds$yellowOn(void)
#line 127
{
  {
  }
#line 128
  ;
  { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
#line 129
    {
      TOSH_CLR_YELLOW_LED_PIN();
      LedsC$ledsOn |= LedsC$YELLOW_BIT;
    }
#line 132
    __nesc_atomic_end(__nesc_atomic); }
  return SUCCESS;
}

static inline    
# 771 "C:/tinyos/cygwin/opt/tinyos-1.x/tos/platform/CC2430/CC2430RadioM.nc"
void CC2430RadioM$RadioReceiveCoordinator$default$startSymbol(uint8_t bitsPerBlock, uint8_t offset, TOS_MsgPtr msgBuff)
#line 771
{
}

# 33 "C:/tinyos/cygwin/opt/tinyos-1.x/tos/platform/CC2430/RadioCoordinator.nc"
inline static   void CC2430RadioM$RadioReceiveCoordinator$startSymbol(uint8_t arg_0xa295ba0, uint8_t arg_0xa295ce8, TOS_MsgPtr arg_0xa295e38){
#line 33
  CC2430RadioM$RadioReceiveCoordinator$default$startSymbol(arg_0xa295ba0, arg_0xa295ce8, arg_0xa295e38);
#line 33
}
#line 33
static inline   
# 39 "C:/tinyos/cygwin/opt/tinyos-1.x/tos/platform/CC2430/CC2430TimerM.nc"
uint16_t CC2430TimerM$Capture2$getEvent(void)
#line 39
{
  return (uint16_t )T2CAPLPL + ((uint16_t )T2CAPHPH << 8);
}

# 13 "C:/tinyos/cygwin/opt/tinyos-1.x/tos/platform/CC2430/CC2430Capture.nc"
inline static   uint16_t HPLCC2430RFInterruptM$SFDCapture$getEvent(void){
#line 13
  unsigned int result;
#line 13

#line 13
  result = CC2430TimerM$Capture2$getEvent();
#line 13

#line 13
  return result;
#line 13
}
#line 13
static inline   
# 33 "C:/tinyos/cygwin/opt/tinyos-1.x/tos/platform/CC2430/HPLCC2430RFInterruptM.nc"
result_t HPLCC2430RFInterruptM$_FIFOP$startWait(void)
#line 33
{
  { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
#line 34
    {
      RFIM |= 0x20;
    }
#line 36
    __nesc_atomic_end(__nesc_atomic); }
  return SUCCESS;
}

# 7 "C:/tinyos/cygwin/opt/tinyos-1.x/tos/platform/CC2430/CC2430RFInterrupt.nc"
inline static   result_t CC2430RadioM$_FIFOP$startWait(void){
#line 7
  unsigned char result;
#line 7

#line 7
  result = HPLCC2430RFInterruptM$_FIFOP$startWait();
#line 7

#line 7
  return result;
#line 7
}
#line 7
static inline   
# 43 "C:/tinyos/cygwin/opt/tinyos-1.x/tos/platform/CC2430/HPLCC2430RFInterruptM.nc"
result_t HPLCC2430RFInterruptM$_FIFOP$disable(void)
#line 43
{
  { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
#line 44
    {
      RFIM &= ~0x20;
      RFIF &= ~0x20;
    }
#line 47
    __nesc_atomic_end(__nesc_atomic); }
  return SUCCESS;
}

# 8 "C:/tinyos/cygwin/opt/tinyos-1.x/tos/platform/CC2430/CC2430RFInterrupt.nc"
inline static   result_t CC2430RadioM$_FIFOP$disable(void){
#line 8
  unsigned char result;
#line 8

#line 8
  result = HPLCC2430RFInterruptM$_FIFOP$disable();
#line 8

#line 8
  return result;
#line 8
}
#line 8
static inline 
# 82 "C:/tinyos/cygwin/opt/tinyos-1.x/tos/platform/CC2430/CC2430RadioM.nc"
void CC2430RadioM$flushRXFIFO(void)
#line 82
{
  CC2430RadioM$_FIFOP$disable();

  do {
#line 85
      RFST = 0xE6;
    }
  while (
#line 85
  0);
  do {
#line 86
      RFST = 0xE6;
    }
  while (
#line 86
  0);
  { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
#line 87
    CC2430RadioM$bPacketReceiving = 0;
#line 87
    __nesc_atomic_end(__nesc_atomic); }
  CC2430RadioM$_FIFOP$startWait();
}

static inline  
#line 540
void CC2430RadioM$delayedRXFIFOtask(void)
#line 540
{
  CC2430RadioM$delayedRXFIFO();
}

static inline   
#line 704
result_t CC2430RadioM$_FIFOP$fired(void)
#line 704
{






  if (CC2430RadioM$bAckEnable && CC2430RadioM$stateRadio == CC2430RadioM$TX_STATE) {
      halSetTimer2Period(0x01, 8);
    }


  if (!(((unsigned char *)0)[0xDF62] & 0x08)) {
      CC2430RadioM$flushRXFIFO();
      return SUCCESS;
    }

  { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
#line 721
    {
      if (TOS_post(CC2430RadioM$delayedRXFIFOtask)) {
          CC2430RadioM$_FIFOP$disable();
        }
      else {
          CC2430RadioM$flushRXFIFO();
        }
    }
#line 728
    __nesc_atomic_end(__nesc_atomic); }


  return SUCCESS;
}

# 10 "C:/tinyos/cygwin/opt/tinyos-1.x/tos/platform/CC2430/CC2430RFInterrupt.nc"
inline static    result_t HPLCC2430RFInterruptM$_FIFOP$fired(void){
#line 10
  unsigned char result;
#line 10

#line 10
  result = CC2430RadioM$_FIFOP$fired();
#line 10

#line 10
  return result;
#line 10
}
#line 10
static inline 
# 55 "C:/tinyos/cygwin/opt/tinyos-1.x/tos/platform/CC2430/HPLCC2430RFInterruptM.nc"
void HPLCC2430RFInterruptM$FIFOPInterruptfired(void)
#line 55
{
  result_t val = SUCCESS;

#line 57
  RFIF &= ~0x20;
  val = HPLCC2430RFInterruptM$_FIFOP$fired();
  if (val == FAIL) {
      RFIM &= ~0x20;
      RFIF &= ~0x20;
    }
}

static inline  
# 150 "GenericBaseM.nc"
TOS_MsgPtr GenericBaseM$RadioReceive$receive(TOS_MsgPtr data)
#line 150
{
  if (data->crc) {
      return GenericBaseM$receive(data, 0);
    }
  else {
      return data;
    }
}

# 75 "C:/tinyos/cygwin/opt/tinyos-1.x/tos/interfaces/ReceiveMsg.nc"
inline static  TOS_MsgPtr CC2430RadioM$Receive$receive(TOS_MsgPtr arg_0xa24f9a8){
#line 75
  struct TOS_Msg *result;
#line 75

#line 75
  result = GenericBaseM$RadioReceive$receive(arg_0xa24f9a8);
#line 75

#line 75
  return result;
#line 75
}
#line 75
static inline  
# 96 "C:/tinyos/cygwin/opt/tinyos-1.x/tos/platform/CC2430/CC2430RadioM.nc"
void CC2430RadioM$PacketRcvd(void)
#line 96
{
  TOS_MsgPtr pBuf;

  { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
#line 99
    {
      pBuf = CC2430RadioM$rxbufptr;
    }
#line 101
    __nesc_atomic_end(__nesc_atomic); }
  pBuf = CC2430RadioM$Receive$receive((TOS_MsgPtr )pBuf);
  { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
#line 103
    {
      if (pBuf) {
#line 104
        CC2430RadioM$rxbufptr = pBuf;
        }
#line 105
      CC2430RadioM$rxbufptr->length = 0;
      CC2430RadioM$bPacketReceiving = 0;
    }
#line 107
    __nesc_atomic_end(__nesc_atomic); }
}

static 
# 12 "C:/tinyos/cygwin/opt/tinyos-1.x/tos/platform/CC2430/byteorder.h"
__inline int is_host_lsb(void)
{
  const uint8_t n[2] = { 1, 0 };

#line 15
  return * (uint16_t *)n == 1;
}

static 




__inline uint16_t fromLSB16(uint16_t a)
{
  return is_host_lsb() ? a : (a << 8) | (a >> 8);
}

static inline 
# 597 "C:/tinyos/cygwin/opt/tinyos-1.x/tos/platform/CC2430/CC2430RadioM.nc"
result_t CC2430RadioM$RXFIFODone(uint8_t length, uint8_t *data)
#line 597
{





  uint8_t currentstate;

#line 604
  { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
#line 604
    {
      currentstate = CC2430RadioM$stateRadio;
    }
#line 606
    __nesc_atomic_end(__nesc_atomic); }





  if (((
#line 610
  !(((unsigned char *)0)[0xDF62] & 0x08) && 
  !(((unsigned char *)0)[0xDF62] & 0x04))
   || length == 0) || length > MSG_DATA_SIZE) {
      CC2430RadioM$flushRXFIFO();
      { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
#line 614
        CC2430RadioM$bPacketReceiving = 0;
#line 614
        __nesc_atomic_end(__nesc_atomic); }
      return SUCCESS;
    }

  CC2430RadioM$rxbufptr = (TOS_MsgPtr )data;




  if (
#line 621
  CC2430RadioM$bAckEnable && currentstate == CC2430RadioM$TX_STATE && (
  CC2430RadioM$rxbufptr->fcfhi & 0x07) == 0x02 && 
  CC2430RadioM$rxbufptr->dsn == CC2430RadioM$currentDSN && 
  data[length - 1] >> 7 == 1) {
      { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
#line 625
        {
          CC2430RadioM$txbufptr->ack = 1;
          CC2430RadioM$txbufptr->strength = data[length - 2];
          CC2430RadioM$txbufptr->lqi = data[length - 1] & 0x7F;

          CC2430RadioM$stateRadio = CC2430RadioM$POST_TX_ACK_STATE;
          CC2430RadioM$bPacketReceiving = 0;
        }
#line 632
        __nesc_atomic_end(__nesc_atomic); }
      if (!TOS_post(CC2430RadioM$PacketSent)) {
        CC2430RadioM$sendFailed();
        }
#line 635
      return SUCCESS;
    }




  if ((CC2430RadioM$rxbufptr->fcfhi & 0x07) != 0x01 || 
  CC2430RadioM$rxbufptr->fcflo != 0x08) {
      CC2430RadioM$flushRXFIFO();
      { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
#line 644
        CC2430RadioM$bPacketReceiving = 0;
#line 644
        __nesc_atomic_end(__nesc_atomic); }
      return SUCCESS;
    }

  CC2430RadioM$rxbufptr->length = CC2430RadioM$rxbufptr->length - MSG_HEADER_SIZE - MSG_FOOTER_SIZE;

  if (CC2430RadioM$rxbufptr->length > 28) {
      CC2430RadioM$flushRXFIFO();
      { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
#line 652
        CC2430RadioM$bPacketReceiving = 0;
#line 652
        __nesc_atomic_end(__nesc_atomic); }
      return SUCCESS;
    }


  CC2430RadioM$rxbufptr->addr = fromLSB16(CC2430RadioM$rxbufptr->addr);


  CC2430RadioM$rxbufptr->crc = data[length - 1] >> 7;

  CC2430RadioM$rxbufptr->strength = data[length - 2];

  CC2430RadioM$rxbufptr->lqi = data[length - 1] & 0x7F;

  { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
#line 666
    {
      if (!TOS_post(CC2430RadioM$PacketRcvd)) {
          CC2430RadioM$bPacketReceiving = 0;
        }
    }
#line 670
    __nesc_atomic_end(__nesc_atomic); }


  if (
#line 672
  !(((unsigned char *)0)[0xDF62] & 0x08)
   && !(((unsigned char *)0)[0xDF62] & 0x04)) {
      CC2430RadioM$flushRXFIFO();
      return SUCCESS;
    }

  if (!(((unsigned char *)0)[0xDF62] & 0x04)) {
      if (TOS_post(CC2430RadioM$delayedRXFIFOtask)) {
        return SUCCESS;
        }
    }
#line 682
  CC2430RadioM$flushRXFIFO();


  return SUCCESS;
}

# 34 "C:/tinyos/cygwin/opt/tinyos-1.x/tos/platform/CC2430/hardware.h"
static __inline void TOSH_CLR_RED_LED_PIN(void)
#line 34
{
#line 34
  P1 &= ~(1 << 1);
}

static inline   
# 69 "C:/tinyos/cygwin/opt/tinyos-1.x/tos/system/LedsC.nc"
result_t LedsC$Leds$redOn(void)
#line 69
{
  {
  }
#line 70
  ;
  { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
#line 71
    {
      TOSH_CLR_RED_LED_PIN();
      LedsC$ledsOn |= LedsC$RED_BIT;
    }
#line 74
    __nesc_atomic_end(__nesc_atomic); }
  return SUCCESS;
}

static inline   result_t LedsC$Leds$redOff(void)
#line 78
{
  {
  }
#line 79
  ;
  { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
#line 80
    {
      TOSH_SET_RED_LED_PIN();
      LedsC$ledsOn &= ~LedsC$RED_BIT;
    }
#line 83
    __nesc_atomic_end(__nesc_atomic); }
  return SUCCESS;
}

static inline   result_t LedsC$Leds$redToggle(void)
#line 87
{
  result_t rval;

#line 89
  { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
#line 89
    {
      if (LedsC$ledsOn & LedsC$RED_BIT) {
        rval = LedsC$Leds$redOff();
        }
      else {
#line 93
        rval = LedsC$Leds$redOn();
        }
    }
#line 95
    __nesc_atomic_end(__nesc_atomic); }
#line 95
  return rval;
}

# 81 "C:/tinyos/cygwin/opt/tinyos-1.x/tos/interfaces/Leds.nc"
inline static   result_t GenericBaseM$Leds$redToggle(void){
#line 81
  unsigned char result;
#line 81

#line 81
  result = LedsC$Leds$redToggle();
#line 81

#line 81
  return result;
#line 81
}
#line 81
# 7 "C:/tinyos/cygwin/opt/tinyos-1.x/tos/platform/CC2430/HPLCC2430Capture.nc"
inline static   result_t CC2430RadioM$_SFD$enableCapture(bool arg_0xa2b2f50){
#line 7
  unsigned char result;
#line 7

#line 7
  result = HPLCC2430RFInterruptM$_SFD$enableCapture(arg_0xa2b2f50);
#line 7

#line 7
  return result;
#line 7
}
#line 7
static 
# 18 "C:/tinyos/cygwin/opt/tinyos-1.x/tos/platform/CC2430/byteorder.h"
__inline uint16_t toLSB16(uint16_t a)
{
  return is_host_lsb() ? a : (a << 8) | (a >> 8);
}

static inline  
# 443 "C:/tinyos/cygwin/opt/tinyos-1.x/tos/platform/CC2430/CC2430RadioM.nc"
result_t CC2430RadioM$Send$send(TOS_MsgPtr pMsg)
#line 443
{
  uint8_t currentstate;
#line 444
  uint8_t i;
  uint8_t *pBuf;

#line 446
  { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();
#line 446
    currentstate = CC2430RadioM$stateRadio;
#line 446
    __nesc_atomic_end(__nesc_atomic); }

  if (currentstate == CC2430RadioM$IDLE_STATE) {

      pMsg->fcflo = 0x08;
      if (CC2430RadioM$bAckEnable) {
        pMsg->fcfhi = 0x21;
        }
      else {
#line 454
        pMsg->fcfhi = 0x01;
        }
      pMsg->destpan = TOS_BCAST_ADDR;

      pMsg->addr = toLSB16(pMsg->addr);

      pMsg->length = pMsg->length + MSG_HEADER_SIZE + MSG_FOOTER_SIZE;

      pMsg->dsn = ++CC2430RadioM$currentDSN;

      pMsg->time = 0;

      CC2430RadioM$txlength = pMsg->length - MSG_FOOTER_SIZE;
      CC2430RadioM$txbufptr = pMsg;
      CC2430RadioM$countRetry = 8;
      pBuf = (uint8_t *)CC2430RadioM$txbufptr;



      do {
#line 473
          RFST = 0xE7;
        }
      while (
#line 473
      0);

      RFIF &= ~0x40;


      for (i = 0; i <= CC2430RadioM$txlength; i++) {
          RFD = pBuf[i];
        }
      CC2430RadioM$_SFD$enableCapture(1);
      RFIM |= 0x40;
      (
      (unsigne