A7139 无线模块驱动(STM32)增加FIFO扩展模式的底层代码

A7139 无线模块驱动(STM32)增加FIFO扩展模式的底层代码,第1张

  A7139 拥有电磁波唤醒以及10mW的发射功率,非常容易实现长距离通信,目前测试有障碍物可以轻松达到300m以上。

  通过几天的调试,目前可以发送任意大小的数据包,大小为1-16KB,全部使用中断收发,效率极高。

  增加波特率设置2Kbps-100Kbps任意设置

  增加通信信道设置0-255

  增加发送功率设置0-7

  #include “SYSTEM.H”

  #include “GPIO_INIT.H”

  #include “a7139.H”

  #include “LED.H”

  //晶振寄存器,用于设置晶振以及PAGE地址

  //用于缓存寄存器7的值

  staTIc u16 A7139_CRYSTAL_REG = 0x18;

  //单包数据发送超时时间

  #define A7139_SEND_TIME_OUT 5 //单位10ms

  //基础频率,设置频率范围为420.500MHZ~452.375MHZ ,频道差为125KHZ

  #define A7139_BASE_FRE 420.5f

  //调试开关

  #define A7193_DBUG 1

  #if A7193_DBUG

  #include “system.h”

  #define A7193_debug(format,。。。) uart_printf(format,##__VA_ARGS__)

  #else

  #define A7193_debug(format,。。。) /\

  /

  #endif //A7193_DBUG

  vu8 IntCnt = 0;

  //寄存器配置

  typedef struct

  {

  u16 SCLOCK; //系统时钟寄存器

  u16 PLL1; //PLL1

  u16 PLL2; //PLL2

  u16 PLL3; //PLL3

  u16 PLL4; //PLL4

  u16 PLL5; //PLL5

  u16 PLL6; //PLL6

  u16 CRYSTAL; //晶振设置

  u16 PREG8S; //寄存器组,由CRYSTAL控制切换

  u16 PREG9S; //寄存器组,由CRYSTAL控制切换

  u16 RX1; //接收设置1

  u16 RX2; //接收设置2

  u16 ADC; //ADC

  u16 PIN; //PIN

  u16 CALIB; //CalibraTIon

  u16 MODE; //模式控制

  } A7139_CONFIG_YPTE;

  const u16 A7139Config[]=

  {

  0x0021, //SYSTEM CLOCK register,

  0x0A21, //PLL1 register,

  0xDA05, //PLL2 register, 433.301MHz

  0x0000, //PLL3 register,

  0x0A20, //PLL4 register,

  0x0024, //PLL5 register,

  0x0000, //PLL6 register,

  0x0001, //CRYSTAL register,

  0x0000, //PAGEA,

  0x0000, //PAGEB,

  0x18D4, //RX1 register, IFBW=100KHz, ETH=1

  0x7009, //RX2 register, by preamble

  0x4400, //ADC register,

  0x0800, //PIN CONTROL register, Use Strobe CMD

  0x4845, //CALIBRATION register,

  0x20C0 //MODE CONTROL register, Use FIFO mode

  };

  const u16 A7139Config_PageA[]=

  {

  0xF706, //TX1 register, Fdev = 37.5kHz

  0x0000, //WOR1 register,

  0xF800, //WOR2 register,

  0x1107, //RFI register, Enable Tx Ramp up/down

  0x0170, //PM register,

  0x0201, //RTH register,

  0x400F, //AGC1 register,

  0x2AC0, //AGC2 register,

  0x0041, //GIO register GIO1-》WTR GIO2-》WTR

  0xD281, //CKO register

  0x0004, //VCB register,

  0x0A21, //CHG1 register, 430MHz

  0x0022, //CHG2 register, 435MHz

  0x003F, //FIFO register, FEP=63+1=64bytes

  0x1507, //CODE register, Preamble=4bytes, ID=4bytes

  0x0000 //WCAL register,

  };

  const u16 A7139Config_PageB[]=

  {

  0x0337, //TX2 register,

  0x8400, //IF1 register, Enable Auto-IF, IF=200KHz

  0x0000, //IF2 register, 频率偏移为0

  0x0000, //ACK register,

  0x0000 //ART register,

  };

  //GPIO1功能设置

  #define A7139_SetGIO_WTR() A7139_WritePageA(A7139_REG8_GPIO, 0x0041) //WTR模式,单包收发提示

  #define A7139_SetGIO_FPF() A7139_WritePageA(A7139_REG8_GPIO, 0x0035) //FPF模式,多包收发状态提示

  #define A7139_SetGIO_NULL() A7139_WritePageA(A7139_REG8_GPIO, 0x0000) //关闭GPIO1指示

  //发送数据结构

  typedef struct

  {

  u8 *pSendData; //发送数据缓冲区指针

  u16 SendLen; //需要发送数据长度

  u16 TranLen; //已经发送数据长度

  bool isSendOK; //发送完成

  bool isSendError;//发送失败

  }A7139_SEND_TYPE;

  volatile A7139_SEND_TYPE SendConfig; //发送数据的信息

  //接收数据结构

  typedef struct

  {

  u8 *pRevData; //接收数据缓冲区指针

  u16 RevLen; //需要接收数据长度

  u16 TranLen; //已经接收数据长度

  u16 RevBuffSize;//接收缓冲区大小

  bool isRevOK; //接收完成

  bool isRevError;//接收失败

  }A7139_REV_TYPE;

  volatile A7139_REV_TYPE RevConfig; //发送数据的信息

  //收发模式记录,用于中断处理发送或接收模式

  static bool isSendMode = FALSE; //默认为接收模式

  #define A7139_SendMode(x) (isSendMode=x)

  /*命令选择

  地址格式

  BIT7 BIT6-BIT4 BIT3-BIT0

  R/W Command Address

  0:写 000 读写控制寄存器

  1:读 010 读写ID

  100 读写FIFO

  110 复位FIFO

  111 RF复位

  */

  void A7139_SetBaseFreq(float RfFreq); //基础频率设置

  bool A7139_Cali(void); //频率校准

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

  * 函数 : void A7139_SetTrafficRate(u8 Rate)

  * 功能 : A7139设置通信速率,单位Kbps

  * 参数 : Rate:通信速率,单位Kbps

  * 返回 : 无

  * 依赖 : 底层宏定义

  * 说明 : 用于设置通信速率

  范围2-100Kbps

  设置系统时钟2分频,设置为12.8MHZ后如果IFBW设置过小会导致初始化时自动校准失败

  如果设置为50会出现校准失败

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

  void A7139_SetTrafficRate(u8 Rate)

  {

  u16 SDR;

  if(Rate 《 2) Rate = 2;

  if(Rate 》 100) Rate = 100;

  //IFBW设置 DMOS=1 64分频 ETH=1 CSC=0 FCSCK=12.8MHZ

  if(Rate 《= 50) //IFBW=100KHZ

  {

  A7139_WriteReg(A7139_RX1, 0x18D0 | (1《《2));

  }

  else //IFBW=100KHZ

  {

  A7139_WriteReg(A7139_RX1, 0x18D0 | (1《《2));

  }

  SDR = 100/Rate;

  SDR -= 1; //计算波特率分频值

  A7139_WriteReg(A7139_SCLOCK,0x0021|(SDR《《9)); //CSC=1 GRC=1 SDR

  }

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

  * 函数 : void A7139_SetChannel(u8 Channel)

  * 功能 : A7139设置通信信道

  * 参数 : Channel:通信信道0-255

  * 返回 : 无

  * 依赖 : 底层宏定义

  * 说明 : 用于设置通信频道

  Channel*0.125/0.0125,最小频率偏差为12.5KHZ,设置通道间隔为125KHZ(最少为100KHZ)

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

  void A7139_SetChannel(u8 Channel)

  {

  A7139_WritePageB(A7139_REG9_IF2,Channel*10);

  }

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

  * 函数 : void A7139_SetTxPowerSupply(u8 PowerSupply)

  * 功能 : 设置A7139发射功率

  * 参数 : PowerSupply:功率等级0-7

  * 返回 : 无

  * 依赖 : 底层宏定义

  * 说明 : 用于设置发射功率

  由于不同频率下TX驱动电流与PA驱动电流并不相同,因此按照文档设置

  目前只支持433频段设置,其它频段请按照文档进行设置。

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

  void A7139_SetTxPowerSupply(u8 PowerSupply)

  {

  if(PowerSupply》6)PowerSupply=6; //最大功率为6

  if(PowerSupply == 0)

  {

  A7139_WritePageB(A7139_REG9_TX2, 0x0300); //功率最小-34dBm,PAC=0,TDC=0,TBG=增益

  }

  else

  {

  A7139_WritePageB(A7139_REG9_TX2, 0x0300|(1《《5)|(1《《3)|PowerSupply); //PAC=1,TDC=1,TBG=增益

  }

  }

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

  * 函数 : bool A7139_Init(u8 Channel, u16 RfID, u8 PowerSupply, u8 Rate)

  * 功能 : A7139初始化

  * 参数 : Channel:通信信道0-80,RfID:RF ID,PowerSupply:发射功率0-7;Rate:通信波特率2-100Kbps

  * 返回 : TRUE:成功;FALSE:失败

  * 依赖 : 底层宏定义

  * 说明 : RF_ID:用于区分网络

  2-100Kbps频率间隔至少为100KHZ,150~200KHZ频道间隔必须大于200KHZ

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

  bool A7139_Init(u8 Channel, u16 RfID, u8 PowerSupply, u8 Rate)

  {

  u32 ID;

  u32 temp;

  if(Rate 《 2) Rate = 2;

  if(Rate 》 100) Rate = 100;

  A7139_DisableInt(); //关闭中断

  A7139_DisableNVIC(); //关闭总中断

  A7139_IO_INIT(); //初始化IO

  A7139_CS_H();

  A7139_CLK_L();

  A7139_DIO_H();

  ID = RfID;

  ID 《《= 16;

  ID |= RfID;

  A7193_debug(“[RF]频率:%dKHz, 通信速率:%dKbps, RFID:%X!\r\n”,(u32)(A7139_BASE_FRE*1000+Channel*0.125*1000),Rate, ID);

  A7139_CRYSTAL_REG = 0x0001;

  A7139_SoftReset(); //软复位

  if(A7139_ReadID() != 0)

  {

  A7139_SoftReset(); //软复位

  }

  A7139_DelayMS(1);

  A7139_Config(); //初始化寄存器

  A7139_SetBaseFreq(A7139_BASE_FRE); //设置基础频率

  A7139_SetChannel(Channel); //设置信道

  A7139_SetTrafficRate(Rate); //设置通信速率

  A7139_WriteID(ID); //写入ID

  temp = A7139_ReadID(); //读取用户ID

  if(temp != ID)

  {

  A7193_debug(“A7139 初始化失败,芯片检测错误!\r\n”);

  return FALSE;

  }

  A7193_debug(“A7139 用户ID:%X\t硬件ID:%X\r\n”,ID, A7139_ReadDeverID());

  A7139_DelayMS(5);

  if(A7139_Cali()==FALSE) //校准

  {

  A7193_debug(“A7139 初始化失败,校准失败!\r\n”);

  return FALSE;

  }

  A7193_debug(“A7139 初始化成功!\r\n”);

  A7139_SetTxPowerSupply(PowerSupply); //设置发射功率

  A7139_EnableInt(); //开启上升沿触发中断

  return TRUE;

  }

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

  * 函数 : void A7139_WriteByte(u8 data)

  * 功能 : A7139写一字节

  * 参数 : data:需要写入的数据

  * 返回 : 无

  * 依赖 : 底层宏定义

  * 说明 : 不带片选,最底层写入1B

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

  void A7139_WriteByte(u8 data)

  {

  u8 i;

  for(i = 0;i 《 8;i ++)

  {

  if(data & 0x80)

  {

  A7139_DIO_H();

  }

  else

  {

  A7139_DIO_L();

  }

  nop;nop;

  A7139_CLK_H();

  data 《《= 1;

  nop;nop;

  A7139_CLK_L();

  }

  }

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

  * 函数 : u8 A7139_ReadByte(void)

  * 功能 : A7139读取一字节

  * 参数 : 无

  * 返回 : 读取的数据

  * 依赖 : 底层宏定义

  * 说明 : 不带片选,最底层读取1B

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

  u8 A7139_ReadByte(void)

  {

  u8 i;

  u8 data = 0;

  for(i = 0;i 《 8;i ++)

  {

  A7139_CLK_H();

  data 《《= 1;

  if(A7139_DIO_IN())

  {

  data |= 1;

  }

  nop;

  A7139_CLK_L();

  nop;nop;nop;

  }

  return data;

  }

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

  * 函数 : u16 A7139_ReadReg(A7139_CREG RegAddr)

  * 功能 : 读取控制寄存器

  * 参数 : RegAddr:寄存器地址

  * 返回 : 寄存器值

  * 依赖 : 底层宏定义

  * 说明 :

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

  u16 A7139_ReadReg(A7139_CREG RegAddr)

  {

  u16 data;

  RegAddr &= 0x0f; //地址限制为BIT0-BIT3

  RegAddr |= A7139_RCR_CMD; //读命令

  A7139_CS_L();

  A7139_OutMode();

  A7139_WriteByte(RegAddr);

  A7139_InMode(); //输入

  data = A7139_ReadByte();

  data 《《= 8;

  data |= A7139_ReadByte();

  A7139_CS_H();

  return data;

  }

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

  * 函数 : void A7139_WriteReg(u8 RegAddr, u16 data)

  * 功能 : 写入控制寄存器

  * 参数 : RegAddr:寄存器地址,data:要写入的值

  * 返回 : 无

  * 依赖 : 底层宏定义

  * 说明 :

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

  void A7139_WriteReg(A7139_CREG RegAddr, u16 data)

  {

  RegAddr &= 0x0f; //地址限制为BIT0-BIT3

  RegAddr |= A7139_WCR_CMD; //写命令

  A7139_CS_L();

  A7139_OutMode();

  A7139_WriteByte(RegAddr);

  A7139_WriteByte(data》》8);

  A7139_WriteByte(data);

  A7139_CS_H();

  }

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

  * 函数 : u16 A7139_ReadPageA(A7139_PAGE_A RegAddr)

  * 功能 : 读取控制寄存器组寄存器A

  * 参数 : RegAddr:寄存器组地址

  * 返回 : 寄存器值

  * 依赖 : 底层宏定义

  * 说明 : 寄存器组8

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

  u16 A7139_ReadPageA(A7139_PAGE_A RegAddr)

  {

  u16 data;

  //先选择组

  A7139_CRYSTAL_REG &= ~(0xf 《《 12); //清除寄存器组8地址

  A7139_CRYSTAL_REG |= (RegAddr 《《 12); //存储寄存器组8地址

  A7139_WriteReg(A7139_CRYSTAL, A7139_CRYSTAL_REG); //重新设置此存器组8地址

  data = A7139_ReadReg(A7139_PREG8S); //读取寄存器组数据

  return data;

  }

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

  * 函数 : void A7139_WritePageA(A7139_PAGE_A RegAddr, u16 data)

  * 功能 : 写入控制寄存器组寄存器

  * 参数 : RegAddr:寄存器组地址,data:寄存器值

  * 返回 : 寄存器值

  * 依赖 : 底层宏定义

  * 说明 : 寄存器组8

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

  void A7139_WritePageA(A7139_PAGE_A RegAddr, u16 data)

  {

  //先选择组

  A7139_CRYSTAL_REG &= ~(0xf 《《 12); //清除寄存器组8地址

  A7139_CRYSTAL_REG |= (RegAddr 《《 12); //存储寄存器组8地址

  A7139_WriteReg(A7139_CRYSTAL, A7139_CRYSTAL_REG); //重新设置此存器组8地址

  A7139_WriteReg(A7139_PREG8S, data); //设置寄存器组数据

  }

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

  * 函数 : u16 A7139_ReadPageB(A7139_PAGE_B RegAddr)

  * 功能 : 读取控制寄存器组寄存器

  * 参数 : RegAddr:寄存器组地址

  * 返回 : 寄存器值

  * 依赖 : 底层宏定义

  * 说明 : 寄存器组9

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

  u16 A7139_ReadPageB(A7139_PAGE_B RegAddr)

  {

  u16 data;

  A7139_CRYSTAL_REG &= ~(0x7 《《 7); //清除寄存器组9地址

  A7139_CRYSTAL_REG |= ((RegAddr&0x7) 《《 7); //存储寄存器组9地址

  A7139_WriteReg(A7139_CRYSTAL, A7139_CRYSTAL_REG); //重新设置此存器组9地址

  data = A7139_ReadReg(A7139_PREG9S); //读取寄存器组数据

  return data;

  }

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

  * 函数 : void A7139_WritePageB(A7139_PAGE_B RegAddr, u16 data)

  * 功能 : 写入控制寄存器组寄存器

  * 参数 : RegAddr:寄存器组地址,data:寄存器值

  * 返回 : 寄存器值

  * 依赖 : 底层宏定义

  * 说明 : 寄存器组9

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

  void A7139_WritePageB(A7139_PAGE_B RegAddr, u16 data)

  {

  //先选择组

  A7139_CRYSTAL_REG &= ~(0x7 《《 7); //清除寄存器组9地址

  A7139_CRYSTAL_REG |= ((RegAddr&0x7) 《《 7); //存储寄存器组9地址

  A7139_WriteReg(A7139_CRYSTAL, A7139_CRYSTAL_REG); //重新设置此存器组9地址

  A7139_WriteReg(A7139_PREG9S, data); //设置寄存器组数据

  }

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

  * 函数 : u32 A7139_ReadID(void)

  * 功能 : 读取A7139 ID

  * 参数 : 无

  * 返回 : ID值

  * 依赖 : 底层宏定义

  * 说明 : 读取ID

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

  u32 A7139_ReadID(void)

  {

  u32 data;

  u8 i;

  A7139_CS_L();

  A7139_OutMode();

  A7139_WriteByte(A7139_RID_CMD); //读ID命令

  A7139_InMode(); //输入

  data = 0;

  for(i = 0;i 《 4;i ++)

  {

  data 《《= 8;

  data |= A7139_ReadByte();

  }

  A7139_CS_H();

  return data;

  }

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

  * 函数 : void A7139_WriteID(u32 ID)

  * 功能 : 设置A7139 ID

  * 参数 : 无ID值

  * 返回 : 无

  * 依赖 : 底层宏定义

  * 说明 : 设置ID

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

  void A7139_WriteID(u32 ID)

  {

  A7139_CS_L();

  A7139_OutMode();

  A7139_WriteByte(A7139_WID_CMD); //写ID命令

  A7139_WriteByte(ID 》》 24);

  A7139_WriteByte(ID 》》 16);

  A7139_WriteByte(ID 》》 8);

  A7139_WriteByte(ID 》》 0);

  A7139_CS_H();

  }

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

  * 函数 : void A7139_StrobeCmd(A7139_STROBE_CMD StrobeCmd)

  * 功能 : A7139发送Strobe命令

  * 参数 : 无

  * 返回 : 无

  * 依赖 : 底层宏定义

  * 说明 :

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

  void A7139_StrobeCmd(A7139_STROBE_CMD StrobeCmd)

  {

  A7139_CS_L();

  A7139_OutMode();

  A7139_WriteByte(StrobeCmd);

  A7139_CS_H();

  }

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

  * 函数 : void A7139_ReadFIFO(u8 *pData, u8 DataLen)

  * 功能 : A7139读取FIFO

  * 参数 : 无

  * 返回 : 无

  * 依赖 : 底层宏定义

  * 说明 :

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

  void A7139_ReadFIFO(u8 *pData, u8 DataLen)

  {

  u8 i;

  A7139_CS_L();

  A7139_OutMode();

  A7139_WriteByte(A7139_RFIFO_CMD);

  A7139_InMode();

  //循环读取FIFO

  for(i = 0;i 《 DataLen;i ++)

  {

  pData[i] = A7139_ReadByte();

  }

  A7139_CS_H();

  }

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

  * 函数 : void A7139_WriteFIFO(u8 *pData, u8 DataLen)

  * 功能 : A7139写FIFO

  * 参数 : 无

  * 返回 : 无

  * 依赖 : 底层宏定义

  * 说明 :

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

  void A7139_WriteFIFO(u8 *pData, u8 DataLen)

  {

  u8 i;

  A7139_CS_L();

  A7139_OutMode();

  A7139_WriteByte(A7139_WFIFO_CMD);

  //循环写入FIFO

  for(i = 0;i 《 DataLen;i ++)

  {

  A7139_WriteByte(pData[i]);

  }

  A7139_CS_H();

  }

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

  * 函数 : void A7139_Config(void)

  * 功能 : A7139 配置

  * 参数 : 无

  * 返回 : 无

  * 依赖 : 底层宏定义

  * 说明 : 初始化配置

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

  void A7139_Config(void)

  {

  u8 i;

  for(i=0; i《8; i++)

  A7139_WriteReg((A7139_CREG)i, A7139Config[i]);

  for(i=10; i《16; i++)

  A7139_WriteReg((A7139_CREG)i, A7139Config[i]);

  for(i=0; i《16; i++)

  A7139_WritePageA((A7139_PAGE_A)i, A7139Config_PageA[i]);

  for(i=0; i《5; i++)

  A7139_WritePageB((A7139_PAGE_B)i, A7139Config_PageB[i]);

  }

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

  * 函数 : void A7139_SetSendDataLen(u16 DataLen)

  * 功能 : A7139 设置发送数据长度(只针对FIFO外延模式有效)

  * 参数 : DataLen:数据长度,最大16KB

  * 返回 : 无

  * 依赖 : 底层宏定义

  * 说明 : 用于FIFO外延模式下设置发送数据长度

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

  void A7139_SetSendDataLen(u16 DataLen)

  {

  if(DataLen 》 16*1024) DataLen = 16*1024; //限制最大长度为16KB

  //将要发送的数据长度写入到FEP[13:0]寄存器中

  A7139_WritePageA(A7139_REG8_VCO, (DataLen&0x3F00) | 0x04); //FEP【13:8】

  A7139_WritePageA(A7139_REG8_FIFO, (3《《14) | (DataLen&0xFF)); //FPM=3;PSA=0,FEP【7:0】

  }

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

  * 函数 : u8 A7139_WriteFistPackToFIFO(u8 *pData, u16 SnedDataLen)

  * 功能 : FIFO外延模式发送首包数据

  * 参数 : pData:数据缓冲区;SnedDataLen:需要发送的数据总长度(不是当前包长度)

  * 返回 : 发送的数据长度

  * 依赖 : 底层宏定义

  * 说明 : 用于FIFO外延模式发送第一包,前面2个字节为总包长度,后面62B为数据包有效大小

  如果数据包小于62B后面补充无效数据0x00

  FIFO外延模式,64B.。.48B.。.48B.。。

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

  u8 A7139_WriteFistPackToFIFO(u8 *pData, u16 SnedDataLen)

  {

  u16 i;

  u8 temp;

  A7139_CS_L();

  A7139_OutMode();

  A7139_WriteByte(A7139_WFIFO_CMD);

  //循环写入FIFO

  A7139_WriteByte(0xA5); //数据包起始字节1

  A7139_WriteByte(0xB6); //数据包起始字节2

  A7139_WriteByte(SnedDataLen》》8); //数据包总长度,高位

  A7139_WriteByte(SnedDataLen); //数据包总长度,低位

  if(SnedDataLen 《 60) //不足一包,需要填充

  {

  for(i = 0;i 《 SnedDataLen;i ++) //发送数据包

  {

  A7139_WriteByte(pData[i]);

  }

  for(i = 0;i 《 (60-SnedDataLen);i ++) //填充不足的字节数

  {

  A7139_WriteByte(0x00); //填充

  }

  }

  else //超出一包数据

  {

  for(i = 0;i 《 60;i ++) //发送数据包

  {

  A7139_WriteByte(pData[i]);

  }

  SnedDataLen = 60; //返回发送的数据长度

  }

  A7139_CS_H();

  return SnedDataLen; //返回发送的数据长度

  }

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

  * 函数 : u8 A7139_WritePackToFIFO(u8 *pData, u16 ResidueDataLen)

  * 功能 : FIFO外延模式发送后续数据包(不能是第一包)

  * 参数 : pData:数据缓冲区;ResidueDataLen:剩余需要发送的数长度(不是当前包长度)

  * 返回 : 发送的数据长度

  * 依赖 : 底层宏定义

  * 说明 : 如果剩余数据小于48B后面补充无效数据0x00

  FIFO外延模式,64B.。.48B.。.48B.。。

  BUG:如果外延模式下,写数据中断触发后立即写数据则会再次产生一次写数据中断

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

  u8 A7139_WritePackToFIFO(u8 *pData, u16 ResidueDataLen)

  {

  u8 i;

  if(ResidueDataLen == 0) return 0;

  A7139_CS_L();

  A7139_OutMode();

  A7139_WriteByte(A7139_WFIFO_CMD);

  //循环写入FIFO

  if(ResidueDataLen 《 48) //不足一包,需要填充

  {

  for(i = 0;i 《 ResidueDataLen;i ++) //发送数据包

  {

  A7139_WriteByte(pData[i]);

  }

  for(i = 0;i 《 (48-ResidueDataLen);i ++) //填充不足的字节数

  {

  A7139_WriteByte(0x00); //填充

  }

  }

  else //超出一包数据

  {

  for(i = 0;i 《 48;i ++) //发送数据包

  {

  A7139_WriteByte(pData[i]);

  }

  ResidueDataLen = 48; //返回发送的数据长度

  }

  A7139_CS_H();

  return ResidueDataLen; //返回发送的数据长度

  }

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

  * 函数 : u8 A7139_ReadFistPackToFIFO(u8 *pDataBuff, u16 *pRevDataLen, u16 ResidueBuffSize)

  * 功能 : FIFO外延模式读取首包数据

  * 参数 : pDataBuff:接收数据缓冲区;pRevDataLen:需要接收的数据总长度(不是当前包长度);ResidueBuffSize:剩余接收数据缓冲区大小

  * 返回 : 接收到的数据长度(当前接收的)

  * 依赖 : 底层宏定义

  * 说明 : 用于FIFO外延模式接收第一包,前面2个字节为总包长度,后面48-2B为数据包有效大小

  如果数据包小于48-2B后面数据将丢弃

  FIFO外延模式,48B.。.48B.。.48B.。。

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

  vu8 A7139_ReadFistPackToFIFO(vu8 *pDataBuff, vu16 *pRevDataLen, vu16 ResidueBuffSize)

  {

  u8 i;

  u16 len;

  A7139_CS_L();

  A7139_OutMode();

  A7139_WriteByte(A7139_RFIFO_CMD);

  A7139_InMode();

  //循环读取FIFO

  if((A7139_ReadByte()!=0xA5) || ((A7139_ReadByte()!=0xB6)))

  {

  uart_printf(“帧头错误\r\n”);

  *pRevDataLen = 0; //获取需要接收的总长度

  return 0;

  }

  len = A7139_ReadByte(); //高位

  len 《《= 8;

  len |= A7139_ReadByte(); //低位

  *pRevDataLen = len; //获取需要接收的总长度

  if(len == 0)

  {

  uart_printf(“长度错误\r\n”);

  return 0; //长度错误

  }

  if(len 《 ResidueBuffSize) //数据缓冲区足够大

  {

  if(len 《 44) //不足一包

  {

  for(i = 0;i 《 len;i ++)

  {

  pDataBuff[i] = A7139_ReadByte(); //读取有效数据

  }

  for(i = 0;i 《 (44-len);i ++) //丢弃

  {

  A7139_ReadByte();

  }

  }

  else //超过一包

  {

  for(i = 0;i 《 44;i ++)

  {

  pDataBuff[i] = A7139_ReadByte(); //读取有效数据

  }

  len = 44;

  }

  }

  else //缓冲区不够

  {

  if(ResidueBuffSize 《 44) //不足一包

  {

  for(i = 0;i 《 ResidueBuffSize;i ++)

  {

  pDataBuff[i] = A7139_ReadByte(); //读取有效数据

  }

  for(i = 0;i 《 (44-ResidueBuffSize);i ++) //丢弃

  {

  A7139_ReadByte();

  }

  len = ResidueBuffSize;

  }

  else //超过一包

  {

  for(i = 0;i 《 44;i ++)

  {

  pDataBuff[i] = A7139_ReadByte(); //读取有效数据

  }

  len = 44;

  }

  }

  A7139_CS_H();

  return len; //返回发送的数据长度

  }

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

  * 函数 : u8 A7139_ReadPackToFIFO(u8 *pDataBuff, u16 ResidueDataLen, u16 ResidueBuffSize)

  * 功能 : FIFO外延模式读取后续数据(非首包)

  * 参数 : pDataBuff:接收数据缓冲区;ResidueDataLen:未接受的数据长度;ResidueBuffSize:剩余接收数据缓冲区大小

  * 返回 : 接收到的数据长度(当前接收的)

  * 依赖 : 底层宏定义

  * 说明 : 如果数据包小于48后面数据将丢弃

  FIFO外延模式,48B.。.48B.。.48B.。。

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

  vu8 A7139_ReadPackToFIFO(vu8 *pDataBuff, vu16 ResidueDataLen, vu16 ResidueBuffSize)

  {

  u8 i;

  A7139_CS_L();

  A7139_OutMode();

  A7139_WriteByte(A7139_RFIFO_CMD);

  A7139_InMode();

  //循环读取FIFO

  if(ResidueDataLen 《 ResidueBuffSize) //数据缓冲区足够大

  {

  if(ResidueDataLen 《 48) //不足一包

  {

  for(i = 0;i 《 ResidueDataLen;i ++)

  {

  pDataBuff[i] = A7139_ReadByte(); //读取有效数据

  }

  for(i = 0;i 《 (48-ResidueDataLen);i ++) //丢弃

  {

  A7139_ReadByte();

  }

  }

  else //超过一包

  {

  for(i = 0;i 《 48;i ++)

  {

  pDataBuff[i] = A7139_ReadByte(); //读取有效数据

  }

  ResidueDataLen = 48;

  }

  }

  else //缓冲区不够

  {

  if(ResidueBuffSize 《 48) //不足一包

  {

  for(i = 0;i 《 ResidueBuffSize;i ++)

  {

  pDataBuff[i] = A7139_ReadByte(); //读取有效数据

  }

  for(i = 0;i 《 (48-ResidueBuffSize);i ++) //丢弃

  {

  A7139_ReadByte();

  }

  ResidueDataLen = ResidueBuffSize;

  }

  else //超过一包

  {

  for(i = 0;i 《 48;i ++)

  {

  pDataBuff[i] = A7139_ReadByte(); //读取有效数据

  }

  ResidueDataLen = 48;

  }

  }

  A7139_CS_H();

  return ResidueDataLen; //返回发送的数据长度

  }

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

  * 函数 : bool A7139_SendData(u8 *pData, u16 DataLen)

  * 功能 : A7139 发送数据(FIFO外延模式最大16KB-4)

  * 参数 : pData:发送数据缓冲区,最大16KB-4;DataLen:发送数据长度

  * 返回 : TRUE:发送成功;FALSE:发送失败

  * 依赖 : 底层宏定义

  * 说明 : 用于FIFO外延模式下发送数据

  FIFO外延模式,64B.。.48B.。.48B.。。

  至少需要发送64B以上的数据

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

  bool A7139_SendData(u8 *pData, u16 DataLen)

  {

  u8 retry = 0;

  u16 len = 0;

  A7139_DisableNVIC(); //总中断关闭

  if(DataLen 》 (16*1024-4)) DataLen = (16*1024-4); //限制最大长度为(16KB-4)

  if(DataLen 《= 60)

  {

  A7139_SetSendDataLen(64-1); //设置发送数据长度

  }

  else

  {

  len = ((DataLen-60)%48)?((DataLen-60)/48*48+48):((DataLen-60)/48*48);

  A7139_SetSendDataLen(64+len-1); //设置发送数据长度

  }

  A7139_StrobeCmd(A7139_STBY_CMD);

  A7139_DelayMS(1);

  A7139_StrobeCmd(A7139_RESTFIFO_CMD);

  A7139_DelayMS(1);

  A7139_SetGIO_FPF(); //FPF模式

  A7139_SendMode(TRUE); //发送模式

  SendConfig.isSendError = FALSE; //清除发送错误状态

  SendConfig.isSendOK = FALSE; //清除发送成功状态

  SendConfig.pSendData = pData; //设置发送数据缓冲区

  SendConfig.SendLen = DataLen; //设置发送数据长度

  SendConfig.TranLen = A7139_WriteFistPackToFIFO(&SendConfig.pSendData[0], SendConfig.SendLen); //发送首包数据

  A7139_StrobeCmd(A7139_TX_CMD); //发送命令牌,使A7139进入“发送”状态,其后A7139会将数据打包后自动发送

  // //定时器主要用来进行调试,可以计算进入中断的时间,进而查出问题所在

  // DeviceClockEnable(DEV_TIM6, ENABLE); //使能定时器6时钟

  // TIM6-》CNT = 0;

  // TIM6-》ARR=60000; //设定计数器自动重装值

  // TIM6-》PSC=SYSTEM_GetClkSpeed()/1000000-1; //预分频器

  // TIM6-》SR = 0; //清除中断标志位

  // TIM6-》CR1|=0x01; //使能定时器6

  // IntCnt = 0;

  if(SendConfig.TranLen 》= SendConfig.SendLen)

  {

  SendConfig.isSendOK = TRUE; //发送完成

  }

  else

  {

  A7139_ClearRxInt();

  A7139_EnableNVIC(); //总中断开启

  while(SendConfig.isSendOK != TRUE)

  {

  A7139_DelayMS(10);

  retry ++;

  if(retry 》 200)

  {

  A7139_DisableNVIC();//总中断关闭

  return FALSE;

  }

  }

  A7139_DisableNVIC();//总中断关闭

  }

  //需要等待最后一包数据发送完毕,一般需要等待至少3ms以上

  A7139_DelayMS(1);

  return TRUE;

  }

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

  * 函数 : bool A7139_SetRevListen(u8 *pRevBuff, u16 RevBuffSize)

  * 功能 : A7139 进入数据监听状态(FIFO外延模式最大16KB)

  * 参数 : pRevBuff:接收数据缓冲区,最大16KB;RevBuffSize:接收数据缓冲区大小

  * 返回 : 无

  * 依赖 : 底层宏定义

  * 说明 : 用于FIFO外延模式下接收数据

  FIFO外延模式,48B.。.48B.。.48B.。。

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

  bool A7139_SetRevListen(u8 *pRevBuff, u16 RevBuffSize)

  {

  A7139_SetGIO_FPF(); //FPF模式,FPF信号空闲为低电平

  A7139_DisableNVIC(); //总中断关闭

  A7139_SetSendDataLen(0x3fff); //设置发送数据长度

  A7139_StrobeCmd(A7139_IDLE_CMD);

  A7139_DelayMS(1);

  A7139_StrobeCmd(A7139_RESRFIFO_CMD);

  A7139_DelayMS(1);

  A7139_StrobeCmd(A7139_RX_CMD);

  RevConfig.pRevData = pRevBuff; //接收数据缓冲区指针

  RevConfig.TranLen = 0; //已经接收数据长度

  RevConfig.RevLen = 0; //需接收数据长度为0

  RevConfig.RevBuffSize = RevBuffSize;//接收缓冲区大小

  RevConfig.isRevOK = FALSE; //接收完成无效

  RevConfig.isRevError = FALSE; //接收失败无效

  A7139_SendMode(FALSE); //接收模式

  A7139_ClearRxInt();

  A7139_EnableNVIC(); //总中断开启

  uart_printf(“接收监控模式!\r\n”);

  return TRUE;

  }

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

  * 函数 : int A7139_GetRxLen(void)

  * 功能 : 获取接收数据长度

  * 参数 : 无

  * 返回 : -1:接收错误,》0接收到的数据长度

  * 依赖 : 底层宏定义

  * 说明 : A7139 进入接收模式后,使用中断进行接收

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

  int A7139_GetRxLen(void)

  {

  if(RevConfig.isRevError == TRUE) return -1;

  else if(RevConfig.isRevOK == TRUE) return RevConfig.TranLen;

  else return 0;

  }

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

  * 函数 : void A7139_SetBaseFreq(float RfFreq)

  * 功能 : A7139 配置RF基础频率

  * 参数 : rfFreq:RF频率,单位MHz

  * 返回 : 无

  * 依赖 : 底层宏定义

  * 说明 : 初始化配置

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

  void A7139_SetBaseFreq(float RfFreq)

  {

  float divFreq = RfFreq / 12.800f;

  u8 intFreq = (u8)(divFreq); //integer part

  float fltFreq = divFreq - intFreq * 1.000f; //fraction part

  u16 fpFreg = (u16)(fltFreq * 65536); //FP register val

  u16 orgVal;

  A7139_StrobeCmd(A7139_STBY_CMD); //enter stand-by mode

  //AFC[15:15] = 0

  orgVal = A7139Config[A7139_PLL3] & 0x7FFF;

  A7139_WriteReg(A7139_PLL3,orgVal);

  //RFC[15:12] = 0000

  orgVal = A7139Config[A7139_PLL6] & 0x0FFF;

  A7139_WriteReg(A7139_PLL6,orgVal);

  //MD1[12:12]=0,1

  if(RfFreq 《 860) //433-510

  orgVal = A7139Config[A7139_PLL4] & 0xEFFF;

  else //868-915

  orgVal = A7139Config[A7139_PLL4] | 0x1000;

  A7139_WriteReg(A7139_PLL4,orgVal);

  //IP[8:0] = intg

  orgVal = A7139Config[A7139_PLL1] & 0xFF00;

  A7139_WriteReg(A7139_PLL1,orgVal|intFreq);

  //FP[15:0] = fpFreg

  A7139_WriteReg(A7139_PLL2,fpFreg);

  //FPA[15:0] = 0x0000,

  A7139_WritePageB(A7139_REG9_IF2,0x0000); //偏移为0

  }

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

  * 函数 : bool A7139_Cali(void)

  * 功能 : A7139 校准

  * 参数 : 无

  * 返回 : TRUE:校准成功;FALSE:校准失败

  * 依赖 : 底层宏定义

  * 说明 : A7139 频率校准

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

  bool A7139_Cali(void)

  {

  u16 fbcf; //IF Filter

  u16 vbcf; //VCO Current

  u16 vccf; //VCO Band

  u16 tmp;

  //IF calibration procedure @STB state

  A7139_WriteReg(A7139_MODE, A7139Config[A7139_MODE] | 0x0802); //IF Filter & VCO Current Calibration

  do{

  tmp = A7139_ReadReg(A7139_MODE);

  }while(tmp & 0x0802);

  //for check(IF Filter)

  tmp = A7139_ReadReg(A7139_CALIB);

  //fb = tmp & 0x0F;

  //fcd = (tmp》》11) & 0x1F;

  fbcf = (tmp》》4) & 0x01;

  if(fbcf)

  {

  //FBCF:IF 滤波器自动校准标志(只读)

  return FALSE;

  }

  //for check(VCO Current)

  tmp = A7139_ReadPageA(A7139_REG8_VCO);

  //vcb = tmp & 0x0F;

  vccf = (tmp》》4) & 0x01;

  if(vccf)

  {

  return FALSE;

  }

  //RSSI Calibration procedure @STB state

  A7139_WriteReg(A7139_ADC, 0x4C00); //set ADC average=64

  A7139_WritePageA(A7139_REG8_WOR2, 0xF800); //set RSSC_D=40us and RS_DLY=80us

  A7139_WritePageA(A7139_REG8_TX1, A7139Config_PageA[A7139_REG8_TX1] | 0xE000); //set RC_DLY=1.5ms

  A7139_WriteReg(A7139_MODE, A7139Config[A7139_MODE] | 0x1000); //RSSI Calibration

  do{

  tmp = A7139_ReadReg(A7139_MODE);

  }while(tmp & 0x1000);

  A7139_WriteReg(A7139_ADC, A7139Config[A7139_ADC]);

  A7139_WritePageA(A7139_REG8_WOR2, A7139Config_PageA[A7139_REG8_WOR2]);

  A7139_WritePageA(A7139_REG8_TX1, A7139Config_PageA[A7139_REG8_TX1]);

  //VCO calibration procedure @STB state

  A7139_WriteReg(A7139_MODE, A7139Config[A7139_MODE] | 0x0004); //VCO Band Calibration

  do{

  tmp = A7139_ReadReg(A7139_MODE);

  }while(tmp & 0x0004);

  //for check(VCO Band)

  tmp = A7139_ReadReg(A7139_CALIB);

  //vb = (tmp 》》5) & 0x07;

  vbcf = (tmp 》》8) & 0x01;

  if(vbcf)

  {

  return FALSE;

  }

  return TRUE;

  }

  //PB1接收中断程序

  //警告:如果缓冲区大小设置错误将产生意想不到的混乱,造成溢出后程序将不受控

  //接收完毕后一定要退出接收模式,否则会一直受到FPF信号,原因是在不知道数据包大小的情况下将数据包设置为无限大小

  void EXTI1_IRQHandler(void)

  {

  A7139_DisableNVIC(); //关闭总中断

  A7139_ClearRxInt(); //清除中断

  LED1_ON();

  //uart_printf(“%d时间:%duS\r\n”,IntCnt,TIM6-》CNT);

  if(isSendMode == TRUE) //发送模式

  {

  if(SendConfig.TranLen 《 SendConfig.SendLen) //没发送完才发送

  {

  SendConfig.TranLen += A7139_WritePackToFIFO(&SendConfig.pSendData[SendConfig.TranLen], SendConfig.SendLen-SendConfig.TranLen); //发送剩下数据包

  if(SendConfig.TranLen 》= SendConfig.SendLen)

  {

  LED1_OFF();

  SendConfig.isSendOK = TRUE; //发送完成

  A7139_DisableNVIC(); //总中断关闭

  A7139_ClearRxInt(); //清除中断

  return;

  }

  }

  else //正常情况下不会执行到此

  {

  LED1_OFF();

  //uart_printf(“发送有错误\r\n”);

  SendConfig.isSendError = TRUE; //发送完成

  A7139_DisableNVIC(); //总中断关闭

  A7139_ClearRxInt(); //清除中断

  return;

  }

  }

  else

  {

  if(RevConfig.RevLen == 0) //还没获取到需要接收数据长度

  {

  RevConfig.TranLen = A7139_ReadFistPackToFIFO(&RevConfig.pRevData[0], &RevConfig.RevLen, RevConfig.RevBuffSize);

  if(RevConfig.RevLen == 0) //接收数据长度为0,无效,退出接收

  {

  LED1_OFF();

  A7139_StrobeCmd(A7139_IDLE_CMD);

  RevConfig.isRevError = TRUE; //接收有误,结束接收

  A7139_DisableNVIC(); //总中断关闭

  A7139_ClearRxInt(); //清除中断

  return;

  }

  }

  else

  {

  RevConfig.TranLen += A7139_ReadPackToFIFO(&RevConfig.pRevData[RevConfig.TranLen], RevConfig.RevLen-RevConfig.TranLen, RevConfig.RevBuffSize-RevConfig.TranLen);

  }

  if(RevConfig.TranLen 》= RevConfig.RevBuffSize) //缓冲区满了

  {

  LED1_OFF();

  A7139_StrobeCmd(A7139_IDLE_CMD);

  RevConfig.isRevOK = TRUE; //接收完成了,结束接收

  A7139_DisableNVIC(); //总中断关闭

  A7139_ClearRxInt(); //清除中断

  return;

  }

  else if((RevConfig.TranLen 》= RevConfig.RevLen)&&(RevConfig.RevLen!=0)) //接收完成了

  {

  LED1_OFF();

  A7139_StrobeCmd(A7139_IDLE_CMD);

  RevConfig.isRevOK = TRUE; //接收完成了,结束接收

  A7139_DisableNVIC(); //总中断关闭

  A7139_ClearRxInt(); //清除中断

  return;

  }

  }

  LED1_OFF();

  A7139_ClearRxInt(); //清除中断

  A7139_EnableNVIC(); //总中断开启

  }

  头文件

  #ifndef __A7139_H__

  #define __A7139_H__

  #include “system.h”

  #if(BOARD_SUPPORT) //需要板级支持

  #include “board.h”

  #else //默认支持

  //三线spi

  #define A7139_DIO_OUT PBout(10)

  #define A7139_DIO_IN() PBin(10)

  #define A7139_CS PBout(0)

  #define A7139_CLK PBout(11)

  #define A7139_OutMode() GPIOx_OneInit(GPIOB,10,OUT_PP,SPEED_50M)

  #define A7139_InMode() GPIOx_OneInit(GPIOB,10,IN_IPU,IN_IN)

  #define A7139_GIO1 PBin(1)

  #define A7139_IO_INIT() \

  DeviceClockEnable(DEV_GPIOB,ENABLE);/*使能GPIOA时钟*/\

  GPIOx_Init(GPIOB,BIT0|BIT10|BIT11, OUT_PP, SPEED_50M);\

  GPIOx_Init(GPIOB,BIT1, IN_IPT, IN_IN);\

  #define A7139_IO_POWER_DOWN() \

  DeviceClockEnable(DEV_GPIOB,ENABLE);/*使能GPIOA时钟*/\

  GPIOx_Init(GPIOB,BIT0|BIT10|BIT11, IN_IPT, IN_IN);\

  //接口

  //DIO

  #define A7139_DIO_H() (A7139_DIO_OUT=1) //输出1

  #define A7139_DIO_L() (A7139_DIO_OUT=0) //输出0

  #define A7139_CS_H() (A7139_CS=1)

  #define A7139_CS_L() (A7139_CS=0)

  #define A7139_CLK_H() (A7139_CLK=1)

  #define A7139_CLK_L() (A7139_CLK=0)

  #define A7139_GIO1_IN() (A7139_GIO1)

  //中断

  #define A7139_EnableNVIC() NVIC_IntEnable(IRQ_EXTI1,ENABLE) //总中断开启

  #define A7139_DisableNVIC() NVIC_IntEnable(IRQ_EXTI1,DISABLE) //总中断关闭

  #define A7139_EnableInt() EXTI_IntConfig(GPIO_B,1,PosEdge) //上升沿触发中断

  #define A7139_DisableInt() EXTI_IntConfig(GPIO_B,1,OFF_INT) //关闭接收中断

  //清除接收中断

  #define A7139_ClearRxInt() EXTI_ClearInt(1) //清除中断

  #endif

  //控制寄存器

  typedef enum

  {

  A7139_SCLOCK = 0x00, //系统时钟寄存器

  A7139_PLL1 = 0x01, //PLL1

  A7139_PLL2 = 0x02, //PLL2

  A7139_PLL3 = 0x03, //PLL3

  A7139_PLL4 = 0x04, //PLL4

  A7139_PLL5 = 0x05, //PLL5

  A7139_PLL6 = 0x06, //PLL6

  A7139_CRYSTAL = 0x07, //晶振设置

  A7139_PREG8S = 0x08, //寄存器组,由CRYSTAL控制切换

  A7139_PREG9S = 0x09, //寄存器组,由CRYSTAL控制切换

  A7139_RX1 = 0x0A, //接收设置1

  A7139_RX2 = 0x0B, //接收设置2

  A7139_ADC = 0x0C, //ADC

  A7139_PIN = 0x0D, //PIN

  A7139_CALIB = 0x0E, //Calibration

  A7139_MODE = 0x0F, //模式控制

  }A7139_CREG;

  //控制寄存器组A

  typedef enum

  {

  //寄存器8

  A7139_REG8_TX1 = 0, //addr8 page0,

  A7139_REG8_WOR1 = 1, //addr8 page1,

  A7139_REG8_WOR2 = 2, //addr8 page2,

  A7139_REG8_RF = 3, //addr8 page3,

  A7139_REG8_POWER = 4, //addr8 page4,

  A7139_REG8_AGCRC = 5, //addr8 page5,

  A7139_REG8_AGCCON1 = 6, //addr8 page6,

  A7139_REG8_AGCCON2 = 7, //addr8 page7,

  A7139_REG8_GPIO = 8, //addr8 page8,

  A7139_REG8_CKO = 9, //addr8 page9,

  A7139_REG8_VCO = 10, //addr8 page10,

  A7139_REG8_CHG1 = 11, //addr8 page11,

  A7139_REG8_CHG2 = 12, //addr8 page12,

  A7139_REG8_FIFO = 13, //addr8 page13,

  A7139_REG8_CODE = 14, //addr8 page14,

  A7139_REG8_WCAL = 15, //addr8 page15,

  }A7139_PAGE_A;

  //控制寄存器组B

  typedef enum

  {

  //寄存器9

  A7139_REG9_TX2 = 0, //addr9 page0,

  A7139_REG9_IF1 = 1, //addr9 page1,

  A7139_REG9_IF2 = 2, //addr9 page2,

  A7139_REG9_ACK = 3, //addr9 page3,

  A7139_REG9_ART = 4, //addr9 page4,

  }A7139_PAGE_B;

  //Strobe命令

  typedef enum

  {

  A7139_WCR_CMD = 0x00, //写控制寄存器

  A7139_RCR_CMD = 0x80, //读控制寄存器

  A7139_WID_CMD = 0x20, //写ID

  A7139_RID_CMD = 0xA0, //读ID

  A7139_WFIFO_CMD = 0x40, //写FIFO

  A7139_RFIFO_CMD = 0xC0, //读FIFO

  A7139_RESRF_CMD = 0x70, //复位RF

  A7139_RESTFIFO_CMD = 0x60, //复位发送FIFO

  A7139_RESRFIFO_CMD = 0xE0, //复位接收FIFO

  A7139_SLEEP_CMD = 0x10, //SLEEP模式

  A7139_IDLE_CMD = 0x12, //IDLE模式

  A7139_STBY_CMD = 0x14, //Standby模式

  A7139_PLL_CMD = 0x16, //PLL模式

  A7139_RX_CMD = 0x18, //RX模式

  A7139_TX_CMD = 0x1A, //TX模式

  A7139_TSLEEP_CMD = 0x1C, //Deep sleep 模式 三态

  A7139_PSLEEP_CMD = 0x1F, //Deep sleep 模式 上拉

  }A7139_STROBE_CMD;

  //宏定义接口

  #ifdef _UCOS_II_

  #include “ucos_ii.h”

  #define A7139_DelayMS(x) OSTimeDlyHMSM(0,0,0,x) //ms延时,最大999ms

  #else

  #include “delay.h”

  #define A7139_DelayMS(x) Delay_MS(x)

  #endif

  //相关函数

  void A7139_SoftReset(void); //A7139软复位

  bool A7139_Init(u8 Channel, u16 RfID, u8 PowerSupply, u8 Rate); //A7139 初始化

  void A7139_WriteReg(A7139_CREG RegAddr, u16 data); //写入控制寄存器

  u16 A7139_ReadReg(A7139_CREG RegAddr); //读取控制寄存器

  u32 A7139_ReadID(void); //读取A7139 ID

  void A7139_WriteID(u32 ID); //设置A7139 ID

  u16 A7139_ReadPageA(A7139_PAGE_A RegAddr); //读取控制寄存器组寄存器A

  void A7139_WritePageA(A7139_PAGE_A RegAddr, u16 data);//写入控制寄存器组寄存器A

  u16 A7139_ReadPageB(A7139_PAGE_B RegAddr); //读取控制寄存器组寄存器B

  void A7139_WritePageB(A7139_PAGE_B RegAddr, u16 data);//写入控制寄存器组寄存器B

  void A7139_RestRxFIFO(void); //A7139复位接收FIFO指针

  void A7139_RestTxFIFO(void); //A7139复位发送FIFO指针

  void A7139_ReadFIFO(u8 *pData, u8 DataLen); //A7139读取FIFO

  void A7139_WriteFIFO(u8 *pData, u8 DataLen); //A7139写FIFO

  void A7139_StrobeCmd(A7139_STROBE_CMD StrobeCmd); //A7139发送Strobe命令

  void A7139_Config(void); //配置A7139

  void A7139_SetFreq(float RfFreq); //A7139 配置RF频率

  bool A7139_WaitRxData(u8 pData[64], u16 TimeOut); //等待接收数据

  int A7139_GetRxLen(void);

  bool A7139_SetRev(u8 *pRevBuff, u16 RevBuffSize);

  bool A7139_SendData(u8 *pData, u16 DataLen); //A7139发送数据

  void A7139_SetTxPowerSupply(u8 PowerSupply); //发射功率设置

  #define A7139_ReadDeverID() (A7139_ReadPageB(A7139_REG9_TX2)) //读取设备硬件ID,只读

  #define A7139_RestRxFIFO() A7139_StrobeCmd(A7139_RESRFIFO_CMD) //A7139复位接收FIFO指针

  #define A7139_RestTxFIFO() A7139_StrobeCmd(A7139_RESTFIFO_CMD) //A7139复位发送FIFO指针

  #define A7139_SoftReset() A7139_StrobeCmd(A7139_RESRF_CMD) //A7139软复位

  #endif //A7139

  //发送方测试

  /任务1:

  //系统任务

  u8 TempBuff[2048];

  void TaskSystem(void *pdata)

  {

  u16 crc16;

  u16 i;

  //初始化相关线程

  //uart_printf(“新建线程:TaskLED(%d)\r\n”,OSTaskCreate(TaskLED, (void *)0,&TASK_LED_STK[LED_STK_SIZE-1], LED_TASK_Prio));//通信

  //uart_printf(“新建线程:TaskPAIR(%d)\r\n”,OSTaskCreate(TaskPAIR, (void *)0,&TASK_PAIR_STK[PAIR_STK_SIZE-1], PAIR_TASK_Prio));//配对

  OSTimeDlyHMSM(0,0,0,10);

  for(i = 0;i 《 2048;i ++)

  {

  TempBuff[i] = i&0xff;

  }

  i = 320;

  //初始化A7139

  if(A7139_Init(101, 0x0123, 0, 80) == TRUE)

  {

  while(1)

  {

  LED2_ON();

  crc16 = CRC16(TempBuff, i);

  uart_printf(“发送数据%dB,最后1B:0x%02X 校验:0x%04X\r\n”,i, TempBuff[i-1], crc16);

  if(A7139_SendData(TempBuff,i) == TRUE)

  {

  uart_printf(“发送成功\r\n”);

  }

  else

  {

  uart_printf(“发送超时\r\n”);

  }

  LED2_OFF();

  OSTimeDlyHMSM(0,0,2,0);

  IWDG_Feed();

  }

  }

  else //初始化失败

  {

  LED2_ON();

  uart_printf(“通信初始化失!\r\n”);

  OSTimeDlyHMSM(0,0,1,500);

  LED2_OFF();

  }

  while(1)

  {

  LED2_OFF();

  OSTimeDlyHMSM(0,0,0,100);

  IWDG_Feed();

  }

  }

  接收方测试

  [cpp] view plain copy//初始化A7139

  if(A7139_Init(101, 0x0123, 0, 80) == TRUE)

  {

  for(i = 0;i 《 10;i ++)

  {

  LED_FLASH();

  OSTimeDlyHMSM(0,0,0,10);

  }

  LED_OFF();

  if(A7139_SetRevListen(A433Buff, 6000) == FALSE) //重新初始化

  {

  uart_printf(“接收初始化失败\r\n”);

  }

  i = 0;

  while(1)

  {

  len = A7139_GetRxLen();

  if(len 《 0) //接收错误

  {

  uart_printf(“接收错误\r\n”);

  if(A7139_SetRevListen(A433Buff, 6000) == FALSE) //重新初始化

  {

  uart_printf(“接收初始化失败\r\n”);

  }

  i= 0;

  }

  else if(len)

  {

  //LED_ON();

  crc16 = CRC16(A433Buff, len);

  uart_printf(“接收数据%dB,校验:0x%04X\r\n”,len, crc16);

  for(i = 0;i 《 len;i ++)

  {

  uart_printf(“%02X ”, A433Buff[i]);

  }

  uart_printf(“\r\n”);

  //uart_printf(“接收成:%dB\r\n”, len);

  OSTimeDlyHMSM(0,0,0,100);

  //LED_OFF();

  if(A7139_SetRevListen(A433Buff, 6000) == FALSE) //重新初始化

  {

  uart_printf(“接收初始化失败\r\n”);

  }

  i = 0;

  }

  else

  {

  i ++;

  if(i 》 50)

  {

  i = 0;

  uart_printf(“接收超时\r\n”);

  if(A7139_SetRevListen(A433Buff, 6000) == FALSE) //重新初始化

  {

  uart_printf(“接收初始化失败\r\n”);

  }

  }

  }

  OSTimeDlyHMSM(0,0,0,100);

  IWDG_Feed(); //喂狗

  }

  }

  else //初始化失败

  {

  LED_FLASH();

  OSTimeDlyHMSM(0,0,0,100);

  }

  发送调试信息

  A7139 无线模块驱动(STM32)增加FIFO扩展模式的底层代码,A7139 无线模块驱动(STM32)增加FIFO扩展模式的底层代码,第2张

  接收方调试信息

  A7139 无线模块驱动(STM32)增加FIFO扩展模式的底层代码,A7139 无线模块驱动(STM32)增加FIFO扩展模式的底层代码,第3张

欢迎分享,转载请注明来源:内存溢出

原文地址: http://outofmemory.cn/dianzi/2573897.html

(0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2022-08-07
下一篇 2022-08-07

发表评论

登录后才能评论

评论列表(0条)

保存