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）;
}
发送调试信息
接收方调试信息
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）