PAN3020 RF433MHz无线收发示例代码 HC32L110低功耗单片机 -

标题: PAN3020 RF433MHz无线收发示例代码 HC32L110低功耗单片机 [打印本页]

作者: hongzhielec 时间: 2021-4-9 18:21
标题: PAN3020 RF433MHz无线收发示例代码 HC32L110低功耗单片机
主控采用HC32L110低功耗单片机，射频芯片PAN3020，SPI接口

//============================================================================//
//  * @file          RF.c
//  * @author       Shi Zheng
//  * @version       V1.1
//  * @date          24/4/2015
//  * @brief       pan3020 communication interface
//  * @modify user: linjianan
//  * @modify date: 28/11/2015
//============================================================================//
#include "stdio.h"
//#include "RFAPI.H"
#include "RF.H"
#include "ddl.h"
#include "SRWF_1E80.h"

extern uint8_t lpUartSend(uint8_t *pBuf,uint8_t len);

const uint8_t TX_ADDRESS_DEF[5] = {0xCC,0xCC,0xCC,0xCC,0xCC};                   //RF 地址：接收端和发送端需一致
//unsigned short Payload_Count = 0;
uint16_t Payload_Count = 0;

uint8_t fb=0,fc=0;
extern void RF_CalVco( uint8_t * ptr_Dem_cal1);
extern uint8_t Dem_cal1_data[];
extern uint8_t RF_cal1_data[];

uint8_t Channel_Index=10;
uint8_t const CHANNEL_TABLE[] = {16,24,32,40,48,56,64,72,80,88};

uint8_t temp = 0;
uint8_t RFmachine = 0;

/******************************************************************************/
//          SPI_init
//             init spi pin and IRQ  CE input/out mode
/******************************************************************************/
void SPI_init(void)
{
      Gpio_InitIO(CSN_PORT, CSN_PIN, GpioDirOut);
      Gpio_InitIO(MISO_PORT, MISO_PIN,  GpioDirIn);
      Gpio_InitIO(MOSI_PORT, MOSI_PIN,  GpioDirOut);
      Gpio_InitIO(SCK_PORT, SCK_PIN, GpioDirOut);
      Gpio_InitIO(SPIIRQ_PORT, SPIIRQ_PIN,GpioDirIn);
      Gpio_InitIO(SPICE_PORT,  SPICE_PIN,  GpioDirOut);
}

/******************************************************************************/
//          SPI_RW
//             SPI Write/Read Data
//          SPI写入一个BYTE的同时，读出一个BYTE返回
/******************************************************************************/
uint8_t SPI_RW( uint8_t       R_REG)
{
uint8_t       i;
for(i = 0; i < 8; i++)
{
      SCK_LOW;
      if(R_REG & 0x80)
      {
         MOSI_HIGH;
      }
      else
      {
         MOSI_LOW;
      }
      R_REG = R_REG << 1;
      SCK_HIGH;
      if( MISO_STATUS )
      {
      R_REG = R_REG | 0x01;
      }
}
SCK_LOW;
return R_REG;
}

/******************************************************************************/
//          RF_WriteReg
//             Write Data(1 Byte Address ,1 byte data)
/******************************************************************************/
void RF_WriteReg( uint8_t reg,  uint8_t wdata)
{
CSN_LOW;
SPI_RW(reg);
SPI_RW(wdata);
CSN_HIGH;
}

/******************************************************************************/
//          RF_ReadReg
//             Read Data(1 Byte Address ,1 byte data return)
/******************************************************************************/
uint8_t       ucRF_ReadReg( uint8_t reg)
{
   uint8_t tmp;

CSN_LOW;
SPI_RW(reg);
tmp = SPI_RW(0);
CSN_HIGH;

return tmp;
}

/******************************************************************************/
//          RF_WriteBuf
//             Write Buffer
/******************************************************************************/
void RF_WriteBuf( uint8_t reg, uint8_t *pBuf, uint8_t length)
{
   uint8_t j;
CSN_LOW;
j = 0;
SPI_RW(reg);
for(j = 0;j < length; j++)
{
      SPI_RW(pBuf[j]);
}
j = 0;
CSN_HIGH;
}

/******************************************************************************/
//          RF_ReadBuf
//          Read Data(1 Byte Address ,length byte data read)
/******************************************************************************/
void RF_ReadBuf( uint8_t reg, unsigned char *pBuf,  uint8_t length)
{
  uint8_t byte_ctr;

  CSN_LOW;

  SPI_RW(reg);
  for(byte_ctr=0;byte_ctr<length;byte_ctr++)
pBuf[byte_ctr] = SPI_RW(0);

  CSN_HIGH;
}

void RF_PwrDwnMode(void)
{
  //关闭RF,PWR_UP 0, CE 0
  CE_LOW;
  //1111 1101
  RF_WriteReg(W_REGISTER+CONFIG,ucRF_ReadReg(CONFIG)&0xFD);
  delay10us(1);

  RFmachine = RFIDLEMODE;
}

void RF_STB1Mode(void)
{
  //RF STB1模式，PWR_UP 1, CE 0
  CE_LOW;
  //0000 0010
  RF_WriteReg(W_REGISTER+CONFIG,ucRF_ReadReg(CONFIG)|0x02);
  delay10us(1);
}

void RF_STB2Mode(void)
{
  //RF STB2模式，PWR_UP 1, CE 1
  CE_HIGH;
  //0000 0010
  RF_WriteReg(W_REGISTER+CONFIG,ucRF_ReadReg(CONFIG)|0x02);
  delay10us(1);
}

/******************************************************************************/
//          RF_TxMode
//             Set RF into TX mode
/******************************************************************************/
void RF_TxMode(void)
{
  uint8_t i;

char tmpstr[64];
CE_LOW;

  // 将RF设置成TX模式,允许发送中断
RF_WriteReg(W_REGISTER + CONFIG,  0X0E);
delay10us(1);

RFmachine = RFTXMODE;
RF_TR_HIGH;

}

/******************************************************************************/
//          RF_RxMode
//          将RF设置成RX模式，准备接收数据
/******************************************************************************/
void RF_RxMode(void)
{
  char tmpstr[64];

  uint8_t    RF_cal3_temp[] = {0x01,0x08,0xD4,0x02,0x64};
  uint8_t    RF_cal3_temp1[] = {0x01,0x08,0xD4,0x02,0x66};
  CE_LOW;
  RF_WriteReg(W_REGISTER + CONFIG,  0X0F );                                                       // 将RF设置成RX模式
  delay1ms(20);
  CE_HIGH;                                                                                     // Set CE pin high
  delay10us(50);             //keep ce high at least 150us
  RF_WriteBuf(W_REGISTER + RF_CAL3, RF_cal3_temp, sizeof(RF_cal3_temp));
  RF_WriteBuf(W_REGISTER + RF_CAL3, RF_cal3_temp1, sizeof(RF_cal3_temp1));
  delay1ms(2);

  RFmachine = RFRXMODE;
  RF_TR_LOW;

//  sprintf(tmpstr,"[RF Rx] sta %02X\r\n",ucRF_ReadReg(STATUS));
//  lpUartSend(tmpstr,strlen(tmpstr));

//  lpUartSend("[RF Rx]\r\n",strlen("[RF Rx]\r\n"));
}

/******************************************************************************/
//          RF_GetStatus
//          read RF IRQ status,3bits return
/******************************************************************************/
uint8_t ucRF_GetStatus(void)
{
return ucRF_ReadReg(STATUS)&0x70;                                                             //读取RF的状态
}

/******************************************************************************/
//          RF_ClearStatus
//             clear RF IRQ
/******************************************************************************/
void RF_ClearStatus(void)
{
RF_WriteReg(W_REGISTER + STATUS,0x70);                                                       //清除RF的状态
}

/******************************************************************************/
//          RF_ClearFIFO
//             clear RF TX/RX FIFO
/******************************************************************************/
void RF_ClearFIFO(void)
{
RF_WriteReg(FLUSH_TX, 0);                                                                      //清除RF 的 TX FIFO
RF_WriteReg(FLUSH_RX, 0);                                                                //清除RF 的 RX FIFO
}

/******************************************************************************/
//          RF_SetPower
//    in: RF_cal1_data
//    in: power ndbm ,define by rf.h
/******************************************************************************/
void RF_SetPower( uint8_t * p,uint8_t power)
{
switch (power)
{
case RF18DBM :
      *(p+1) &= ~0xfe;//8-15
      *(p+1) |= 0xfe;
      *(p+2) &= ~0x07;//16-23
      *(p+2) |= 0x07;
      RF_WriteBuf(W_REGISTER + RF_CAL1, p, 5);
      break;

case RF14DBM:

      *(p+1) &= ~0xfe;
      *(p+1) |= 0xf8;
      *(p+2) &= ~0x07;
      *(p+2) |= 0x01;
      RF_WriteBuf(W_REGISTER + RF_CAL1, p, 5);
      break;

case RF9DBM:
      *(p+1) &= ~0xfe;
      *(p+1) |= 0xf8;
      *(p+2) &= ~0x07;
      *(p+2) |= 0x00;
      RF_WriteBuf(W_REGISTER + RF_CAL1, p, 5);
      break;

case RF1DBM:
      *(p+1) &= ~0xfe;
      *(p+1) |= 0x60;
      *(p+2) &= ~0x07;
      *(p+2) |= 0x00;
      RF_WriteBuf(W_REGISTER + RF_CAL1, p, 5);
      break;

   default:
      break;
   }

}
/******************************************************************************/
//in Fb[5:0], FC[8:1]
// return none
//315 fre = 1/6*8000000*(200+fb+fc/400)hz
//433  fre = 1/4*8000000*(200+fb+fc/400)hz=400Mhz+2fbMhz+50fckHz
//868 915 feq = 1/2*8000000*(200+fb+fc/400)hz=800Mhz+4fbMhz+100kHz
// for example fre= 434.1khz ,Fb=0x11  Fc=0x01.  default fc[0]=0,only set fc[8:1](reg5) .

/******************************************************************************/

void RF_SetChannel(uint8_t bb,uint8_t cc )
{
//       uint8_t RFSetup_temp = 0;
//       Fb &= 0x3f;
//       RFSetup_temp = ucRF_ReadReg(RF_SETUP)&0xc0;
//       RFSetup_temp |= Fb;
      RF_WriteReg(W_REGISTER+RF_SETUP,bb|DATA_RATE);
      RF_WriteReg(W_REGISTER+RF_CH,cc);

}

/******************************************************************************/
//  发送数据
//          参数：
//             1. ucTXPayload：需要发送的数据首地址
//             2. length:  需要发送的数据长度
/******************************************************************************/

void RF_Tx_TransmintData( uint8_t *ucTXPayload,  uint8_t length)
{

uint8_t    RF_cal3_temp[] = {0x01,0x08,0xD4,0x02,0x64};
uint8_t    RF_cal3_temp1[] = {0x01,0x08,0xD4,0x02,0x66};

if(!ucRF_GetStatus())                                                                            // rf 处于空闲状态才发送数据
      {

         RF_WriteBuf(W_TX_PAYLOAD, ucTXPayload, length);                                              //write data to txfifo
         CE_HIGH;                                                                                  //rf entery tx mode start send data
         delay10us(15);                                                                            //keep ce high at least 150us
         RF_WriteBuf(W_REGISTER + RF_CAL3, RF_cal3_temp, sizeof(RF_cal3_temp));                // 切换时钟
         RF_WriteBuf(W_REGISTER + RF_CAL3, RF_cal3_temp1, sizeof(RF_cal3_temp1));
         CE_LOW;
}
}

/******************************************************************************/
//发送结果
//          参数：只在增强型模式下，使能ack带payload有效
//             1. ucAckPayload：ackpayload的首地址
//             2. length:ackpayload 的长度

/*****************************************************************************/
extern uint8_t    lpUartSend(uint8_t *pBuf,uint8_t len);
#include "stdio.h"
#include "stdlib.h"

uint8_t  RF_Tx_CheckResult(uint8_t *ucAckPayload,  uint8_t length)
{
  uint8_t rtnTxResult;
  sMacHeader_t tmpSyncHeader;

  switch(ucRF_GetStatus())
  {
case       TX_DS_FLAG:                                                                      // 普通型发送完成或增强型发送成功
      Payload_Count++;                                                             // 增强型模式，累计ack次数

      rtnTxResult = TX_DS_FLAG;

      RF_ClearFIFO();
      RF_ClearStatus ();
      break;

case       RX_TX_FLAG:                                                                      //增强型发送成功且收到payload
      RF_ReadBuf(R_RX_PAYLOAD,ucAckPayload, length);

      Payload_Count++;

      rtnTxResult = RX_TX_FLAG;

//          //将PAN3020接收到的数据通过串口转发
//          lpUartSend(ucAckPayload, 16);

      RF_ClearFIFO();
      RF_ClearStatus ();
      break;

case       MAX_RT_FLAG:                                                                      // 增强型发送超时失败
      rtnTxResult = MAX_RT_FLAG;

      RF_ClearFIFO();
      RF_ClearStatus ();
      break;
default:
      rtnTxResult = TX_NULL_FLAG;
      break;
  }

  return rtnTxResult;

}

/******************************************************************************/
//          ucRF_DumpRxData
//          读出接收到的数据：
//          参数：
//             1. ucPayload：存储读取到的数据的Buffer
//             2. length: 读取的数据长度
//             Return:
//             1. 0: 没有接收到数据
//             2. 1: 读取接收到的数据成功
//             note: Only use in Rx Mode
//             length 通常等于 PAYLOAD_WIDTH
/******************************************************************************/
uint8_t ucRF_DumpRxData( uint8_t *ucPayload,  uint8_t length)
{
if(ucRF_GetStatus()==0x40)
{
//       RF_ReadBuf(R_RX_PAYLOAD, ucPayload, length);
      return 1;
   }
   return 0;
}

////////////////////////////////////////////////////////////////////////////////
/******************************************************************************/
//          Vco_Calibration
//
/******************************************************************************/
void RF_CalVco( uint8_t * Demod_Cal)
{
  uint8_t i,j,h;
  uint8_t    RF_cal3_temp[] = {0x01,0x08,0xD4,0x02,0x64};
  uint8_t    RF_cal3_temp1[] = {0x01,0x08,0xD4,0x02,0x66};

  uint8_t Dem_cal2_data1[] = {0x0B,0xE7,0x00,0x03};                                     //Dataout_Sel置1
  uint8_t RF_cal3_data1[] = {0x01,0x08,0xD4,0x02,0x76};                               //Vco_Calibration EN
  uint8_t RF_cal3_data2[] = {0x01,0x18,0xD4,0x02,0x76};                               //触发Vco_Calibration_SPI_Triger

  CE_LOW;
  RF_WriteReg(W_REGISTER + CONFIG,  0X0F );                                              //配置为接收模式
  CE_HIGH;

  RF_WriteBuf(W_REGISTER + RF_CAL3, RF_cal3_temp, sizeof(RF_cal3_temp));
  RF_WriteBuf(W_REGISTER + RF_CAL3, RF_cal3_temp1, sizeof(RF_cal3_temp1));

  RF_WriteBuf(W_REGISTER + DEM_CAL2, Dem_cal2_data1, sizeof(Dem_cal2_data1));
  RF_WriteBuf(W_REGISTER + RF_CAL3, RF_cal3_data1, sizeof(RF_cal3_data1));
  RF_WriteBuf(W_REGISTER + RF_CAL3, RF_cal3_data2, sizeof(RF_cal3_data2));

  i=ucRF_ReadReg(RPD);
  j=ucRF_ReadReg(FIFO_STATUS);
  i >>= 2;
  i &= 0x30;
  j &= 0x0C;
  h = i|j;
  Demod_Cal[1] &= 0xC3;
  Demod_Cal[1] |= h;
}
////////////////////////////////////////////////////////////////////////////////
//       以下部分与RF通信相关，不建议修改
////////////////////////////////////////////////////////////////////////////////
/******************************************************************************/
//          pan3020_Initial
//             Initial RF
/******************************************************************************/
//uint16_t rfFreq; ///<ISM 频率配置
//uint16_t rfPower; ///

#if 1
uint8_t firstpwrup = 0;

void RF_Init(uint16_t rfPower)
{
  uint8_t feature =0x00;

  uint8_t BB_cal_data[]    = {0x3f,0xFC,0x1F,0x1F,0x04};
  uint8_t RF_cal3_data[] = {0x01,0x08,0xD4,0x02,0x66};
  uint8_t Dem_cal2_data[] = {0x0B,0xE7,0x00,0x01};          //如果使能动态payload，需要配置为  uint8_t Dem_cal2_data[] = {0x0B,0xE7,0x00,0x00};
  uint8_t  RF_cal2_data[] = {0xC8,0x1E,0x68,0x39,0xF6};

/******************************************************************************/
//          433MHz
/******************************************************************************/
#if((DATA_RATE == DR_400K) && (BAND == B433MHz))
      uint8_t Dem_cal1_data[] = {0x01,0x8e,0x48,0x4c,0x80};
      uint8_t RF_cal1_data[] = {0xC4,0xFF,0xFF,0xDF,0xDB};

#elif((DATA_RATE==DR_40K) && (BAND==B433MHz))

      uint8_t Dem_cal1_data[] = {0x01,0x4D,0x48,0x34,0x8C};
      uint8_t RF_cal1_data[] = {0xC4,0xFF,0xFF,0x5F,0xD8};

#elif((DATA_RATE==DR_80K) && (BAND==B433MHz))

      uint8_t  Dem_cal1_data[]  = {0x01,0x8D,0x48,0x4C,0x8C};
      uint8_t  RF_cal1_data[] = {0xC4,0xFF,0xFF,0xDF,0xD8};

#elif((DATA_RATE==DR_200K) && (BAND==B433MHz))
      uint8_t  Dem_cal1_data[]  = {0x01,0x8C,0x48,0x4C,0x84};
      uint8_t  RF_cal1_data[] = {0xC4,0xFF,0xFF,0xDF,0xD9};

/******************************************************************************/
//          315MHz
/******************************************************************************/

#elif((DATA_RATE==DR_400K) && (BAND == B315MHz))
   uint8_t Dem_cal1_data[] = {0x01,0xea,0x48,0x74,0x80};
   uint8_t RF_cal1_data[] = {0xC5,0xFF,0xFF,0xDF,0xDB};

#elif((DATA_RATE==DR_40K) && (BAND==B315MHz))
      uint8_t Dem_cal1_data[] = {0x01,0x69,0x48,0x44,0x8C};
      uint8_t RF_cal1_data[] = {0xC5,0xFF,0xFF,0x5F,0xD8};

#elif((DATA_RATE==DR_80K) && (BAND==B315MHz))
   uint8_t  Dem_cal1_data[]  = {0x01,0xe9,0x48,0x74,0x8C};
   uint8_t  RF_cal1_data[] = {0xC5,0xFF,0xFF,0xDF,0xD8};

#elif((DATA_RATE==DR_200K) && (BAND==B315MHz))
   uint8_t  Dem_cal1_data[]  = {0x01,0xE8,0x48,0x74,0x84};
   uint8_t  RF_cal1_data[] = {0xC5,0xFF,0xFF,0xDF,0xD9};

/******************************************************************************/
//          868MHz
/******************************************************************************/

#elif((DATA_RATE==DR_400K) && (BAND == B868MHz))
   uint8_t Dem_cal1_data[] = {0x01,0x88,0x48,0x4c,0x94};
   uint8_t RF_cal1_data[] = {0xd0,0xFF,0xFF,0xDF,0xDB};

#elif((DATA_RATE==DR_40K) && (BAND==B868MHz))
      uint8_t Dem_cal1_data[] = {0x01,0x09,0x80,0x19,0x5C};
      uint8_t RF_cal1_data[] = {0xd0,0xFF,0xFF,0x5F,0xD8};

#elif((DATA_RATE==DR_80K) && (BAND==B868MHz))
   uint8_t  Dem_cal1_data[]  = {0x01,0x09,0x00,0x21,0x5C};
   uint8_t  RF_cal1_data[] = {0xD0,0xFF,0xFF,0xDF,0xD8};

#elif((DATA_RATE==DR_200K) && (BAND==B868MHz))
   uint8_t  Dem_cal1_data[]  = {0x01,0x89,0x48,0x4c,0x9c};
   uint8_t  RF_cal1_data[] = {0xd0,0xFF,0xFF,0xDF,0xD9};

/******************************************************************************/
//          915MHz
/******************************************************************************/
#elif((DATA_RATE==DR_400K) && (BAND == B915MHz))
   uint8_t Dem_cal1_data[] = {0x01,0x9c,0x48,0x54,0x84};
   uint8_t RF_cal1_data[] = {0xd0,0xFF,0xFF,0xDF,0xDB};

#elif((DATA_RATE==DR_40K) && (BAND==B915MHz))
      uint8_t Dem_cal1_data[] = {0x01,0x1d,0x48,0x34,0x8C};
      uint8_t RF_cal1_data[] = {0xd0,0xFF,0xFF,0x5F,0xD8};

#elif((DATA_RATE==DR_80K) && (BAND==B915MHz))
   uint8_t  Dem_cal1_data[]  = {0x01,0x1d,0x00,0x44,0x7C};
   uint8_t  RF_cal1_data[] = {0xD0,0xFF,0xFF,0xDF,0xD8};

#elif((DATA_RATE==DR_200K) && (BAND==B915MHz))
   uint8_t  Dem_cal1_data[]  = {0x01,0x9d,0x48,0x54,0x8c};
   uint8_t  RF_cal1_data[] = {0xD0,0xFF,0xFF,0xDF,0xD9};

#endif

#if(BAND == B433MHz)
   fb = 0x12;
   fc = 0x20;

#elif(BAND == B315MHz)
   fb = 0x25;
   fc = 0x20;

#elif(BAND == B868MHz)
   fb = 0x11;
   fc = 0x20;

#elif(BAND == B915MHz)
   fb = 0x1c;
   fc = 0x20;
  // fb = 0x11;
  // fc = 0x20;

#endif

SPI_init();
delay1ms(10);

#if(CE_USE_SPI==1)
      feature |=0x20;
#endif
if(PAYLOAD_WIDTH >32)
      feature |= 0x18;                                                                               // fifo 64 byte

if ( firstpwrup == 0 )
{
      firstpwrup = 1;

      //以下三句，若每次初始化清零，增强模式下，count帧计数器永远为0.
      RF_WriteReg(FLUSH_TX, 0);                                                                      // CLEAR TXFIFO
      RF_WriteReg(FLUSH_RX, 0);                                                                      // CLEAR  RXFIFO
      RF_WriteReg(W_REGISTER + STATUS, 0x70);                                                             // CLEAR  STATUS
}

      RF_WriteReg(W_REGISTER + EN_RXADDR, 0x01);                                                       // Enable Pipe0
      RF_WriteReg(W_REGISTER + SETUP_AW,  0x03);                                                       // address witdth is 5 bytes
      RF_WriteReg(W_REGISTER + RX_PW_P0,  PAYLOAD_WIDTH);                                              // 64bytes
      RF_WriteBuf(W_REGISTER + TX_ADDR, ( uint8_t*)TX_ADDRESS_DEF, sizeof(TX_ADDRESS_DEF));             // Writes TX_Address to pan3020
      RF_WriteBuf(W_REGISTER + RX_ADDR_P0,( uint8_t*)TX_ADDRESS_DEF, sizeof(TX_ADDRESS_DEF));             // RX_Addr0 same as TX_Adr for Auto.Ack

      RF_WriteBuf(W_REGISTER + BB_CAL, BB_cal_data,  sizeof(BB_cal_data));

      RF_WriteBuf(W_REGISTER + DEM_CAL1, Dem_cal1_data, sizeof(Dem_cal1_data));
      RF_WriteBuf(W_REGISTER + DEM_CAL2, Dem_cal2_data, sizeof(Dem_cal2_data));

      RF_WriteBuf(W_REGISTER + RF_CAL1, RF_cal1_data, sizeof(RF_cal1_data));
      RF_WriteBuf(W_REGISTER + RF_CAL2, RF_cal2_data, sizeof(RF_cal2_data));
      RF_WriteBuf(W_REGISTER + RF_CAL3, RF_cal3_data, sizeof(RF_cal3_data));

#if(TRANSMIT_TYPE == TRANS_ENHANCE_MODE)
      //自动传输设置 7:4, 0000 250us, 1111,9530us;  3:0, 0000 不带自动重传 0011 3次重传， 1111 15次重传
      RF_WriteReg(W_REGISTER + SETUP_RETR,0x03);                                                       //传输延迟250us,  3 retrans...
      RF_WriteReg(W_REGISTER + EN_AA,    0x01);                                                       // Enable Auto.Ack:Pipe0
RF_WriteReg(ACTIVATE, 0x73);
#if(1== EN_DYNPLOAD)
      feature |= 0x04;                                                                               //  ENDYNPD
      RF_WriteReg(W_REGISTER +DYNPD, 0x01);
#endif
#if(1==EN_ACK_PAYLOAD)                                                                            // en ack+payload
      feature |= 0x02;
#endif
#elif(TRANSMIT_TYPE == TRANS_BURST_MODE)
      RF_WriteReg(W_REGISTER + SETUP_RETR,0x00);                                                       // Disable retrans...
      RF_WriteReg(W_REGISTER + EN_AA,    0x00);                                                       // Disable AutoAck
#endif
      RF_WriteReg(W_REGISTER +FEATURE, feature);
      RF_WriteReg(W_REGISTER + RF_SETUP,  DATA_RATE|fb);                                           //set datarate
      RF_WriteReg(W_REGISTER + RF_CH,  fc);

      //RF_SetPower(RF_cal1_data,RF_POWER);                                                             // set power
      RF_SetPower(RF_cal1_data,rfPower);                                                             // set power

//       RF_SetChannel(fb,fc);                                                             // set fre
/*    RF_CalVco(Dem_cal1_data);                                                                      //Vco_Calibration
      RF_WriteBuf(W_REGISTER + DEM_CAL1, Dem_cal1_data, sizeof(Dem_cal1_data));
      RF_WriteBuf(W_REGISTER + DEM_CAL2, Dem_cal2_data, sizeof(Dem_cal2_data));
      RF_WriteBuf(W_REGISTER + RF_CAL3, RF_cal3_data, sizeof(RF_cal3_data)); */
}
#endif

/******************************************************************************/
//                         进入载波模式
/******************************************************************************/
void RF_Carrier(uint8_t Fb,uint8_t Fc)
{

  uint8_t  BB_cal_data[] = {0x09,0x04,0x07,0x1F,0x05};
  uint8_t Dem_cal1_data[] = {0xE1,0x8e,0x48,0x4c,0x80};
  uint8_t Dem_cal2_data[] = {0x0B,0xE7,0x00,0x05};
  uint8_t RF_cal1_data[] = {0xC4,0xFF,0xFF,0xDF,0xDB};
  uint8_t RF_cal2_data[] = {0xC8,0x1E,0x68,0x39,0xF6};
  uint8_t RF_cal3_data[] = {0x01,0x08,0xD4,0x02,0x66};
  uint8_t    RF_cal3_temp[] = {0x01,0x08,0xD4,0x02,0x64};
  uint8_t    RF_cal3_temp1[] = {0x01,0x08,0xD4,0x02,0x66};

  SPI_init();
  CE_HIGH;
  delay10us(500);
  RF_WriteReg(W_REGISTER + CONFIG, 0x0E);
  RF_WriteReg(W_REGISTER + RF_SETUP,  0xd2);
  RF_SetChannel(fb,CHANNEL_TABLE[Channel_Index]);
  RF_WriteBuf(W_REGISTER + BB_CAL,  BB_cal_data,  sizeof(BB_cal_data));
  RF_WriteBuf(W_REGISTER + RF_CAL2,  RF_cal2_data,  sizeof(RF_cal2_data));
  RF_WriteBuf(W_REGISTER + RF_CAL3,  RF_cal3_data,  sizeof(RF_cal3_data));
  RF_WriteBuf(W_REGISTER + DEM_CAL2, Dem_cal2_data, sizeof(Dem_cal2_data));
  delay10us(500);
  RF_WriteBuf(W_REGISTER + DEM_CAL1, Dem_cal1_data, sizeof(Dem_cal1_data));
  delay10us(500);
  RF_SetPower(RF_cal1_data,RF_POWER);
  CE_LOW;
  RF_WriteBuf(W_REGISTER + RF_CAL3, RF_cal3_temp, sizeof(RF_cal3_temp));
  RF_WriteBuf(W_REGISTER + RF_CAL3, RF_cal3_temp1, sizeof(RF_cal3_temp1));

}

/***************************************end of file ************************************/

全部代码51hei下载地址：

SNWL433 - change.7z (169.14 KB, 下载次数: 50)

作者: shke2525 时间: 2022-3-1 10:11
您好，请问一下RF_TR是哪一个脚呀

欢迎光临 (http://www.51hei.com/bbs/)