A7139 无线通信驱动(STM32) 增加FIFO扩展模式，可以发送超大...

1万 · 2021-8-2 14:08

/*************************************************************************************************************************
* 函数 : u8 A7139_WritePackToFIFO(u8 *pData, u16 ResidueDataLen)
* 功能 : FIFO外延模式发送后续数据包(不能是第一包)
* 参数 : pData:数据缓冲区;ResidueDataLen：剩余需要发送的数长度(不是当前包长度)
* 返回 : 发送的数据长度
* 依赖 : 底层宏定义
* 作者 : cp1300@139.com
* 时间 : 2015-12-30
* 最后修改 : 2015-12-30
* 说明 : 如果剩余数据小于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);
}
for(i = 0;i < (48-ResidueDataLen);i ++) //填充不足的字节数
{
A7139_WriteByte(0x00); //填充
}
}
else //超出一包数据
{
for(i = 0;i < 48;i ++) //发送数据包
{
A7139_WriteByte(pData);
}
ResidueDataLen = 48; //返回发送的数据长度
}

A7139_CS_H();
return ResidueDataLen; //返回发送的数据长度
}

1万 · 2021-8-2 14:10

/*************************************************************************************************************************
* 函数 : u8 A7139_ReadPackToFIFO(u8 *pDataBuff, u16 ResidueDataLen, u16 ResidueBuffSize)
* 功能 : FIFO外延模式读取后续数据（非首包）
* 参数 : pDataBuff:接收数据缓冲区;ResidueDataLen：未接受的数据长度；ResidueBuffSize：剩余接收数据缓冲区大小
* 返回 : 接收到的数据长度（当前接收的）
* 依赖 : 底层宏定义
* 作者 : cp1300@139.com
* 时间 : 2015-12-30
* 最后修改 : 2015-12-30
* 说明 : 如果数据包小于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 = A7139_ReadByte(); //读取有效数据
}
for(i = 0;i < (48-ResidueDataLen);i ++) //丢弃
{
A7139_ReadByte();
}
}
else //超过一包
{
for(i = 0;i < 48;i ++)
{
pDataBuff = A7139_ReadByte(); //读取有效数据
}
ResidueDataLen = 48;
}
}
else //缓冲区不够
{
if(ResidueBuffSize < 48) //不足一包
{
for(i = 0;i < ResidueBuffSize;i ++)
{
pDataBuff = A7139_ReadByte(); //读取有效数据
}
for(i = 0;i < (48-ResidueBuffSize);i ++) //丢弃
{
A7139_ReadByte();
}
ResidueDataLen = ResidueBuffSize;
}
else //超过一包
{
for(i = 0;i < 48;i ++)
{
pDataBuff = A7139_ReadByte(); //读取有效数据
}
ResidueDataLen = 48;
}
}

A7139_CS_H();
return ResidueDataLen; //返回发送的数据长度
}

1万 · 2021-8-2 14:11

/*************************************************************************************************************************
* 函数 : bool A7139_SendData(u8 *pData, u16 DataLen)
* 功能 : A7139 发送数据(FIFO外延模式最大16KB-4)
* 参数 : pData:发送数据缓冲区,最大16KB-4;DataLen：发送数据长度
* 返回 : TRUE:发送成功;FALSE:发送失败
* 依赖 : 底层宏定义
* 作者 : cp1300@139.com
* 时间 : 2015-12-29
* 最后修改 : 2015-12-29
* 说明 : 用于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;
}

1万 · 2021-8-2 14:11

/*************************************************************************************************************************
* 函数 : bool A7139_SetRevListen(u8 *pRevBuff, u16 RevBuffSize)
* 功能 : A7139 进入数据监听状态(FIFO外延模式最大16KB)
* 参数 : pRevBuff:接收数据缓冲区,最大16KB;RevBuffSize：接收数据缓冲区大小
* 返回 : 无
* 依赖 : 底层宏定义
* 作者 : cp1300@139.com
* 时间 : 2015-12-29
* 最后修改 : 2015-12-29
* 说明 : 用于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;
}

1万 · 2021-8-2 14:12

/*************************************************************************************************************************
* 函数 : int A7139_GetRxLen(void)
* 功能 : 获取接收数据长度
* 参数 : 无
* 返回 : -1：接收错误，>0接收到的数据长度
* 依赖 : 底层宏定义
* 作者 : cp1300@139.com
* 时间 : 2016-01-02
* 最后修改 : 2016-01-02
* 说明 : 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
* 返回 : 无
* 依赖 : 底层宏定义
* 作者 : cp1300@139.com
* 时间 : 2015-07-19
* 最后修改 : 2015-07-19
* 说明 : 初始化配置
*************************************************************************************************************************/
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
}

1万 · 2021-8-2 14:19

/*************************************************************************************************************************
* 函数 : bool A7139_Cali(void)
* 功能 : A7139 校准
* 参数 : 无
* 返回 : TRUE:校准成功;FALSE:校准失败
* 依赖 : 底层宏定义
* 作者 : cp1300@139.com
* 时间 : 2015-07-19
* 最后修改 : 2015-01-02
* 说明 : 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;
}

1万 · 2021-8-2 14:20

//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(); //总中断开启
}

1万 · 2021-8-2 14:22

头文件
/*************************************************************************************************************
* 文件名: A7139.h
* 功能: STM32 A7139驱动
* 作者: cp1300@139.com
* 创建时间: 2015-07-19
* 最后修改时间:2015-07-19
* 详细: A7139驱动
*************************************************************************************************************/
#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万 · 2021-8-2 14:23

//发送方测试
/任务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();
}
}

1万 · 2021-8-2 14:24

接收方测试
//初始化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);
}

1万 · 2021-8-2 14:25

发送调试信息

接收方调试信息