app_receiver.c

CC2430 上面运行TinyOS&nbsp2.0 测试程序 可以在CC2430上面运行TinyOS&nbsp2.0无线传感器网络操作系统 具体使用见下载包里面的使用说明。

}


 /*inline*/  static   error_t HalCC2430RadioP__InterruptFIFOP__disable(void){

  unsigned char result;



  result = HplCC2430InterruptsC__InterruptFIFOP__disable();



  return result;

}


static  /*inline*/  void HalCC2430RadioP__CC2430RxDisable(void)
{
  RFST = 0xE5;


  HalCC2430RadioP__InterruptFIFOP__disable();

  HalCC2430RadioP__rxEnabled = FALSE;
}


static  /*inline*/   void HalCC2430RadioP__flushBufferTask__runTask(void)
{
  if (HalCC2430RadioP__rxEnabled) 
    {

      HalCC2430RadioP__CC2430RxDisable();


      RFST = 0xE6;
      RFST = 0xE6;


      HalCC2430RadioP__CC2430RxEnable();
    }
  else {

      RFST = 0xE6;
      RFST = 0xE6;
    }

  { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();

    HalCC2430RadioP__flushBufferTaskPosted = FALSE;

    __nesc_atomic_end(__nesc_atomic); }

  HalCC2430RadioP__StdOut__print("MAC: Buffer flushed\r\n");
}


static  /*inline*/    error_t HplCC2430InterruptsC__InterruptFIFOP__enableRisingEdge(void)

{

  { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();

    {

      RFIM |= 1 << CC2430_RFIM_FIFOP;

      RFIF &= ~(1 << CC2430_RFIF_FIFOP);

      IEN2 |= 1 << CC2430_IEN2_RFIE;
    }

    __nesc_atomic_end(__nesc_atomic); }

  return SUCCESS;
}


 /*inline*/  static   error_t HalCC2430RadioP__InterruptFIFOP__enableRisingEdge(void){

  unsigned char result;



  result = HplCC2430InterruptsC__InterruptFIFOP__enableRisingEdge();



  return result;

}


 /*inline*/  static   error_t HalCC2430RadioP__flushBufferTask__postTask(void){

  unsigned char result;



  result = SchedulerBasicP__TaskBasic__postTask(HalCC2430RadioP__flushBufferTask);



  return result;

}

 /*inline*/  static   error_t HalCC2430RadioP__receivedPacketTask__postTask(void){

  unsigned char result;



  result = SchedulerBasicP__TaskBasic__postTask(HalCC2430RadioP__receivedPacketTask);



  return result;

}


static  /*inline*/    void HplMcs51GeneralIOC__P11__toggle(void)

{

  { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();

    {

      P1_1 = ~P1_1;
    }

    __nesc_atomic_end(__nesc_atomic); }
}


 /*inline*/  static   void /*PlatformLedsC.Led1Impl*/Mcs51GpioC__1__HplGeneralIO__toggle(void){

  HplMcs51GeneralIOC__P11__toggle();

}


static  /*inline*/    void /*PlatformLedsC.Led1Impl*/Mcs51GpioC__1__GeneralIO__toggle(void)

{

  /*PlatformLedsC.Led1Impl*/Mcs51GpioC__1__HplGeneralIO__toggle();
}


 /*inline*/  static   void LedsP__Led1__toggle(void){

  /*PlatformLedsC.Led1Impl*/Mcs51GpioC__1__GeneralIO__toggle();

}


static  /*inline*/    void LedsP__Leds__led1Toggle(void)

{
  LedsP__Led1__toggle();
  ;

  ;
}


 /*inline*/  static   void ReceiverP__Leds__led1Toggle(void){

  LedsP__Leds__led1Toggle();

}


static  /*inline*/   packet_t *ReceiverP__SimpleMac__receivedPacket(packet_t *packet)

{
  ReceiverP__Leds__led1Toggle();
  return packet;
}


 /*inline*/  static  packet_t *SimpleMacM__SimpleMac__receivedPacket(packet_t *arg_0x7ea34758){

  struct packet *result;



  result = ReceiverP__SimpleMac__receivedPacket(arg_0x7ea34758);



  return result;

}


static  /*inline*/   uint8_t *SimpleMacM__HALCC2420__receivedPacket(uint8_t *packet)
{
  uint8_t length;

  uint8_t i;
  uint16_t tmp;


  length = packet[0];

  SimpleMacM__receivedPacketPtr->length = length;

  tmp = packet[2];
  tmp = (tmp << 8) + packet[1];
  SimpleMacM__receivedPacketPtr->fcf = tmp;

  SimpleMacM__receivedPacketPtr->_data_seq_no = packet[3];

  tmp = packet[5];
  tmp = (tmp << 8) + packet[4];
  SimpleMacM__receivedPacketPtr->dest = tmp;

  tmp = packet[7];
  tmp = (tmp << 8) + packet[6];
  SimpleMacM__receivedPacketPtr->src = tmp;

  for (i = 8; i < length - 1; i++) 
    {
      SimpleMacM__receivedPacketPtr->_data[i - 8] = packet[i];
    }

  SimpleMacM__receivedPacketPtr->fcs.rssi = packet[length - 1];
  SimpleMacM__receivedPacketPtr->fcs.correlation = packet[length];

  SimpleMacM__receivedPacketPtr = SimpleMacM__SimpleMac__receivedPacket(SimpleMacM__receivedPacketPtr);

  return packet;
}


 /*inline*/  static  uint8_t *HalCC2430RadioP__HALCC2420__receivedPacket(uint8_t *arg_0x7e9d67e0){

  unsigned char *result;



  result = SimpleMacM__HALCC2420__receivedPacket(arg_0x7e9d67e0);



  return result;

}


static  /*inline*/   void HalCC2430RadioP__receivedPacketTask__runTask(void)
{
  uint8_t correlation;

  uint8_t i;




  if (HalCC2430RadioP__frameLength == 0) 
    {
      HalCC2430RadioP__frameLength = RFD;

      if (HalCC2430RadioP__frameLength < 127) {
        HalCC2430RadioP__receivedPacketPtr[0] = HalCC2430RadioP__frameLength;
        }
      else 

        {


          HalCC2430RadioP__flushBufferTask__postTask();
          { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();

            HalCC2430RadioP__receivedPacketTaskPosted = FALSE;

            __nesc_atomic_end(__nesc_atomic); }
          HalCC2430RadioP__frameLength = 0;
          HalCC2430RadioP__receivedPacketTaskRetries = 0;
          return;
        }
    }


  if (HalCC2430RadioP__frameLength > * (uint8_t xdata *)0xDF53) 
    {



      { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();

        {
          if (HalCC2430RadioP__flushBufferTaskPosted || HalCC2430RadioP__receivedPacketTaskRetries > 10) 
            {
              HalCC2430RadioP__flushBufferTask__postTask();
              HalCC2430RadioP__receivedPacketTaskPosted = FALSE;
              HalCC2430RadioP__frameLength = 0;
              HalCC2430RadioP__receivedPacketTaskRetries = 0;
            }
          else 

            {
              HalCC2430RadioP__receivedPacketTask__postTask();
              HalCC2430RadioP__receivedPacketTaskRetries++;
            }
        }

        __nesc_atomic_end(__nesc_atomic); }

      return;
    }


  HalCC2430RadioP__receivedPacketTaskRetries = 0;


  for (i = 0; i < HalCC2430RadioP__frameLength; i++) {
      if (* (uint8_t xdata *)0xDF53 > 0 && * (uint8_t xdata *)0xDF53 < 129) {
        HalCC2430RadioP__receivedPacketPtr[i + 1] = RFD;
        }
      else 

        {
          HalCC2430RadioP__receivedPacketPtr[HalCC2430RadioP__frameLength] = 0;
          break;
        }
    }


  correlation = HalCC2430RadioP__receivedPacketPtr[HalCC2430RadioP__frameLength];


  HalCC2430RadioP__frameLength = 0;






  if (correlation & FCS_CRC_OK_MASK) 
    {
      HalCC2430RadioP__receivedPacketPtr = HalCC2430RadioP__HALCC2420__receivedPacket(HalCC2430RadioP__receivedPacketPtr);
    }
  else {

      HalCC2430RadioP__StdOut__print("MAC: CRC Failed\n\r");


      { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();

        HalCC2430RadioP__receivedPacketTaskPosted = FALSE;

        __nesc_atomic_end(__nesc_atomic); }
      HalCC2430RadioP__flushBufferTask__postTask();
    }




  { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();

    {


      if (* (uint8_t xdata *)0xDF53 > 0 && * (uint8_t xdata *)0xDF53 < 129) {
        HalCC2430RadioP__receivedPacketTask__postTask();
        }
      else {
          HalCC2430RadioP__receivedPacketTaskPosted = FALSE;



          if (HalCC2430RadioP__flushBufferTaskPosted) {
            HalCC2430RadioP__flushBufferTask__postTask();
            }
        }
    }

    __nesc_atomic_end(__nesc_atomic); }

  HalCC2430RadioP__RFIF &= ~(1 << CC2430_RFIF_FIFOP);
}


static   /*inline*/   void HalCC2430RadioP__wait(uint16_t u)
{
  uint8_t j;
  uint16_t i;

  u = u >> 3;



  for (i = 0; i < u; i++) {
      for (j = 0; j < 32; ) {
          j++;
        }
    }
}


static  /*inline*/  void HalCC2430RadioP__CC2430TxWait(void)
{
  uint8_t i = 0;

  while (* (uint8_t xdata *)0xDF62 & (1 << CC2430_RFSTATUS_TX_ACTIVE) && i < 50) 
    {
      HalCC2430RadioP__wait(100);
      i++;
    }

  return;
}


static  /*inline*/   void HalCC2430RadioP__setChannelTask__runTask(void)
{

  HalCC2430RadioP__CC2430TxWait();
  if (HalCC2430RadioP__rxEnabled) 
    {
      HalCC2430RadioP__CC2430RxDisable();

      HalCC2430RadioP__CC2430ChannelSet(HalCC2430RadioP__currentChannel);
      HalCC2430RadioP__CC2430RxEnable();
    }
  else {
    HalCC2430RadioP__CC2430ChannelSet(HalCC2430RadioP__currentChannel);
    }
}


static  /*inline*/   void HalCC2430RadioP__transmitTask__runTask(void)
{
  bool oldRxEnabled;
  uint8_t i;

  uint8_t status;

  uint8_t counter;





  oldRxEnabled = HalCC2430RadioP__rxEnabled;
  if (!HalCC2430RadioP__rxEnabled) 
    {

      HalCC2430RadioP__CC2430RxEnable();
    }


  HalCC2430RadioP__wait(128);


  if (!(* (uint8_t xdata *)0xDF62 & (1 << CC2430_RFSTATUS_CCA))) {


      if (!HalCC2430RadioP__rxEnabled) 
        {

          HalCC2430RadioP__CC2430RxDisable();
        }

      HalCC2430RadioP__HALCC2420__sendPacketDone(HalCC2430RadioP__transmitPacketPtr, 0x02);

      return;
    }







  RFST = 0xE7;


  RFD = HalCC2430RadioP__transmitPacketPtr[0];

  for (i = 0; i < HalCC2430RadioP__transmitPacketPtr[0]; i++) {
      RFD = HalCC2430RadioP__transmitPacketPtr[i + 1];
    }


  i = 0;
  while (i++ < 3) 
    {
      RFST = 0xE3;
      counter = 0;

      do {
          status = * (uint8_t xdata *)0xDF62;
        }
      while (

      !(status & (1 << CC2430_RFSTATUS_TX_ACTIVE)) && counter++ < 200);

      if (status & (1 << CC2430_RFSTATUS_TX_ACTIVE)) {
        break;
        }
    }



  if (!(status & (1 << CC2430_RFSTATUS_TX_ACTIVE))) {


      RFST = 0xE7;

      HalCC2430RadioP__HALCC2420__sendPacketDone(HalCC2430RadioP__transmitPacketPtr, 0x03);

      return;
    }

  { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();

    HalCC2430RadioP__transmitInProgress = TRUE;

    __nesc_atomic_end(__nesc_atomic); }

  return;
}


static  /*inline*/    error_t HplCC2430InterruptsC__InterruptRFErr__enableRisingEdge(void)

{
  { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();

    {
      RFERRIF = 0;
      RFERRIE = 1;
    }

    __nesc_atomic_end(__nesc_atomic); }
  return SUCCESS;
}


 /*inline*/  static   error_t HalCC2430RadioP__InterruptRFErr__enableRisingEdge(void){

  unsigned char result;



  result = HplCC2430InterruptsC__InterruptRFErr__enableRisingEdge();



  return result;

}


static  /*inline*/    error_t HplCC2430InterruptsC__InterruptTXDone__enableRisingEdge(void)

{

  { __nesc_atomic_t __nesc_atomic = __nesc_atomic_start();

    {

      RFIM |= 1 << CC2430_RFIM_TXDONE;

      RFIF &= ~(1 << CC2430_RFIF_TXDONE);

      IEN2 |= 1 << CC2430_IEN2_RFIE;
    }

    __nesc_atomic_end(__nesc_atomic); }

  return SUCCESS;
}


 /*inline*/  static   error_t HalCC2430RadioP__InterruptTXDone__enableRisingEdge(void){

  unsigned char result;



  result = HplCC2430InterruptsC__InterruptTXDone__enableRisingEdge();



  return result;

}


static  /*inline*/  void HalCC2430RadioP__CC2430PALevelSet(uint8_t new_power)
{
  uint16_t power;

  power = new_power * 0x1F;
  power /= 100;

  * (uint16_t xdata *)0xDF0A = (* (uint16_t xdata *)0xDF0A & ~0x1F) | (power & 0x1F);
}






static  /*inline*/  void HalCC2430RadioP__CC2430ControlSet(void)
{

  * (uint8_t xdata *)0xDF02 &= ~(1 << CC2430_MDMCTRL0H_ADDR_DECODE);



  * (uint8_t xdata *)0xDF03 |= 1 << CC2430_MDMCTRL0L_AUTOCRC;





  * (uint8_t xdata *)0xDF4F = 0x7F;


  * (uint16_t xdata *)0xDF0A = 0x050F;

  return;
}


static  /*inline*/  void HalCC2430RadioP__CC2430SetPanid(uint16_t id)
{
  * (uint16_t xdata *)0xDF4B = id;
}

static  /*inline*/  void HalCC2430RadioP__CC2430SetShortaddr(uint16_t shortAddr)
{
  * (uint16_t xdata *)0xDF4D = shortAddr;
}

static  /*inline*/  void HalCC2430RadioP__CC2420SetIEEEAddr(ieee_mac_addr_t extAddress)
{
  * (uint8_t xdata *)0xDF4A = extAddress[7];
  * (uint8_t xdata *)0xDF49 = extAddress[6];
  * (uint8_t xdata *)0xDF48 = extAddress[5];
  * (uint8_t xdata *)0xDF47 = extAddress[4];
  * (uint8_t xdata *)0xDF46 = extAddress[3];
  * (uint8_t xdata *)0xDF45 = extAddress[2];
  * (uint8_t xdata *)0xDF44 = extAddress[1];
  * (uint8_t xdata *)0xDF43 = extAddress[0];
}


static  /*inline*/  void HalCC2430RadioP__CC2430Ext