RF4463F30半双工模组，伪全双工透传方案（STM32平台）（第二章，业务逻辑）
前言
环境已经搭建完毕，接下来逐步移植模块
核心代码编写
宏定义和变量声明
相关宏定义
//通用移植
#define OUTSIDE USART3
#define O_2_I_BUFF USART3_RX_BUFF //外部数据导入缓存
#define O_2_I_LEN USART3_RX_LEN //外部数据当前缓存指针
#define I_2_O_BUFF USART3_TX_BUFF //内部数据对外发出缓存
#define I_2_O_LEN USART3_TX_LEN //内部数据当前缓存指针
#define I_2_O_QUEUE_LEN USART3_TX_QUEUE_LEN
#define I_2_O_END_LEN USART3_TX_END_LEN
上面这部分是用于对接stm32平台
#define MasterFlag //主从机标志位，有这个标志位表示是主机(如果是从机则需要注释)
#define FRAME_CLUB_MAX 20 //最大帧组队列长度
#define BUFF_LEN 100
#define BUFF_LEN_I 2000 //输入缓存区域
#define BUFF_LEN_O 3000 //输出缓存区域
#define BUFF_LEN_B BUFF_LEN_I
上面这部分是用于划分存储空间
#define PACK_MAX_DATA_LEN 35 //设定433模组间发送最大数据长度
#define PACK_LEN_lEN 1 //设定包的长度字节长度
#define PACK_NUMBER_lEN 2 //设定包的序号字节长度
#define PACK_FUNCTION_lEN 1 //设定包的类别字节长度
#define PACK_CHECK_lEN 1 //设定包的校验字节长度
#define MAX_PACK_NUMBER 0xfe //设定包序号的最大值为0xfe
#define PACK_OUTDATA_LEN (PACK_LEN_lEN+\
PACK_NUMBER_lEN+\
PACK_FUNCTION_lEN+\
PACK_CHECK_lEN)
//设定433模组间除数据外的长度
#define PACK_MAX_LEN (PACK_OUTDATA_LEN + PACK_MAX_DATA_LEN)
//设定433模组最大的数据长度
上面这部分是用于分配协议的字段
这部分可以自定义，我暂时是设计了4个字段，核心字段是长度和序号，其他都可有可无
但是我建议也基本按我这一套的设计走，至少包含：
长度，序号，功能码，校验
#define payload_length PACK_MAX_LEN+4 //44
#define freq_channel 0
struct FlagType{
unsigned char reach_1s ;
unsigned char is_tx ;
unsigned char rf_reach_timeout ;
unsigned char run ;
unsigned char is_rx ;
};
上面这部分是用于声明通用的标志位的
相关变量定义
#define tdata {'s','w','w','x',\
0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01 \
,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01 \
,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01 }
static unsigned char tx__data[220] = tdata ;
extern U8 rx_buf[100];
上面这部分是用于分配发送和接受缓存区域
长度和内容不重要，但是至少要大于等于发送长度，内存够用的话就暂时不必要优化一般可以把 220 替换成 payload_length 。
extern uint16_t frame_club[FRAME_CLUB_MAX+1][2]; //最大帧组 (新增的最后一位表示上一帧发送的数据)
extern __IO uint16_t frame_index_n; //当前的帧序号
extern __IO uint16_t frame_index_s; //准备发送的帧序号
extern __IO uint16_t frame_index_l; //奇数表示还在接受，偶数表示等待接受
extern uint8_t O_2_I_BUFF[BUFF_LEN_I];
extern uint8_t I_2_O_BUFF[BUFF_LEN_O];
extern uint16_t O_2_I_LEN;
extern uint16_t I_2_O_LEN;
extern uint16_t I_2_O_QUEUE_LEN;
extern uint16_t I_2_O_END_LEN;
extern __IO u32 g_sysUsartTime;
extern __IO u32 g_sysUsartTime_start;
extern __IO u32 g_buff_len;
extern __IO uint8_t saveFrameFlag;
extern uint8_t INSIDE_TX_BUFF[PACK_MAX_LEN]; //对内发送所需的临时缓存区域
extern uint16_t INSIDE_TX_LEN; //对内发送所需数据长度
extern __IO uint8_t outPutFlag; //对外输出标志位
extern __IO uint8_t setDataFlag; //编辑串口数据标志位
extern struct FlagType Flag;
上面这部分是用于分配数据队列缓存区域
主要有两个队列：
帧队列 frame_club
对外输出队列 I_2_O_BUFF
其中帧队列 存储的是指针 数据还是放在这里 O_2_I_BUFF
到此为止，主要的全局变量和宏定义已经声明了，接下来就是实现功能的代码了
工具函数
两个主要的工具函数
//***********************************************************************
//将发送区数数据重新按着433私有协议个格式重新打包
//***********************************************************************
void pack433Data (u8 *pData,u16 len,u8 mode)
{
u8 temporary[PACK_MAX_LEN] ={0};
//-存入帧长度
temporary[0]=len; // 存入帧长度低字节
//-存入帧序号（——）还未启用
temporary[1]=0; // 存入帧序号高字节
temporary[2]=0; // 存入帧序号低字节
//-存入帧功能
temporary[3]=mode; // 存入帧功能
//-存入校验
temporary[4]=0; // 存入校验（——）还未启用
memcpy(&temporary[5],pData,len); //-存入帧数据
// //-存入校验
// temporary[7+len]=0-packSumCheck(temporary,9+len);//存入校验
memcpy(pData,temporary,PACK_OUTDATA_LEN+len);//打包完成
}
//***********************************************************************
//将接收区数据重新按着帧格式封存
//***********************************************************************
//static u16 len=0;
void saveFrameToBUFF(u16 pointnNumber,u8 timeoutFlag)
{
if(saveFrameFlag) //存帧标志位
return;
else
saveFrameFlag=1;
if(frame_club[frame_index_n][0]>pointnNumber) //获取帧长度
pointnNumber+=BUFF_LEN_B;
if(timeoutFlag==TRUE)
{ //2是，帧组没有帧且要求立刻生成一帧
if(frame_index_l>0) //清理非逻辑异常
{
saveFrameFlag=0;
return;
}
frame_index_l=frame_index_l+2; //帧长度加2
if(pointnNumber>=BUFF_LEN_B)
{
pointnNumber-=BUFF_LEN_B;
}
frame_club[frame_index_n][1]=pointnNumber; //存入当前帧的结束位（后一位）
frame_index_n=frame_index_n+1;
if(frame_index_n>=FRAME_CLUB_MAX)
frame_index_n=0; //帧组循环存储
frame_club[frame_index_n][0]=pointnNumber; //存入当前帧（起始帧） 1
if(frame_index_n==frame_index_s) //帧组出现覆盖
{
#ifdef DEBUG_433
printf("[E] i=%d,l=%d\n",frame_index_s,frame_index_l);
#endif
frame_index_n=frame_index_n==0?FRAME_CLUB_MAX-1:frame_index_n-1;
//取消当前帧
frame_club[frame_index_n][0]=pointnNumber;//跳过帧
saveFrameFlag=0;
frame_index_l-=2; //取消队列增长
return; //阻止封帧
}
if(frame_index_l>2) //清理非逻辑异常
{
#ifdef DEBUG_433
printf("[E],2\n");
#endif
frame_index_n=frame_index_n==0?FRAME_CLUB_MAX-1:frame_index_n-1;
frame_index_l-=2; //取消队列增长
saveFrameFlag=0;
return;
}
frame_club[frame_index_n][0]=pointnNumber; //存入当前帧（起始帧）2
saveFrameFlag=0;
return;
}
if(pointnNumber-frame_club[frame_index_n][0]>=PACK_MAX_DATA_LEN-5) //收到封帧请求时在2种情况下可以封帧
//1是，当前帧长度满足要求
{
//len=pointnNumber-frame_club[frame_index_n][0];
frame_index_l=frame_index_l+2; //帧长度加2
#ifdef DEBUG_433
//printf("[T] add pack len:%d,%d,%d,%d,%d\n",len,pointnNumber,frame_club[frame_index_n][0],frame_club[frame_index_n-1][0],frame_index_n);
#endif
if(pointnNumber>=BUFF_LEN_B)
{
pointnNumber-=BUFF_LEN_B;
}
frame_club[frame_index_n][1]=pointnNumber; //存入当前帧的结束位（后一位）
frame_index_n=frame_index_n+1;
if(frame_index_n>=FRAME_CLUB_MAX)
frame_index_n=0; //帧组循环存储
if((frame_index_l>>1)>=FRAME_CLUB_MAX-2||
(frame_index_n==frame_index_s)) //帧组出现覆盖
{
#ifdef DEBUG_433
// printf("[E] i=%d,l=%d\n",frame_index_s,frame_index_l);
#endif
frame_index_n=frame_index_n==0?FRAME_CLUB_MAX-1:frame_index_n-1;
//取消当前帧
frame_index_l-=2; //取消队列增长
frame_club[frame_index_n][0]=pointnNumber;//跳过帧
saveFrameFlag=0;
return; //阻止封帧
}
frame_club[frame_index_n][0]=pointnNumber; //存入当前帧（起始帧）
saveFrameFlag=0;
return;
}
saveFrameFlag=0;
}
第一个函数是帧队列里的数据或者其他特殊数据，按着协议格式进行封装
第二个函数是将 O_2_I_BUFF 的缓存队列指针根据情况封入帧队列中。在这个函数里有一个关键的标志位： saveFrameFlag 用于防止被中断干扰队列。
功能函数
发送数据函数
void test_tx_data2(u8 *pdata)
{
//delay_ms(1);
Flag.is_tx = 1;
Flag.run=0;
fifo_reset();
m_spi_write_fifo(pdata);
enable_tx_interrupt();
clr_interrupt();
tx_start();
rf_timeout = 0;
Flag.rf_reach_timeout = 0;
while(Flag.run!=2) //等待发送成功
{
if(Flag.rf_reach_timeout)
{
printf("send data timeout\n");
sdn_all_reset(); //
}
}
Flag.run=0;
//clr_interrupt();
Flag.is_tx=0; //转换为接收模式
rx_init(); //接收模式初始化
Flag.run=0;
}
发送数据，并且发送完成后自动转为接受模式，如果发送动作超时，则完全复位模块。
时间管理函数
//**************************************************
//函数名 ：时间戳管理函数
//功能 ：判断超时，管理标志位
//输入 ：null
//输出 ：null
//作者 ：Bao
//**************************************************
void TIME_Process(void)
{
u32 nowSysTime=0;
nowSysTime= GetTickCount(); //获取当前时间戳
if(CompareTimeBase(m_time.recevie_Time,nowSysTime)>RECEVICE_TIME_OUT)//接收间隔超时
{
Flag.is_tx=1; //(简单操作)转换为发送模式
m_test.Count++; //记录错误次数
m_time.recevie_Time =nowSysTime;
printf("time out,%d,%d,%d\n",m_time.recevie_Time,m_test.Count,m_test.Count2);
}
}
主机用于判断是否出现接收超时，如果有则则转换为接受模式并且准备进行重连接
模块工作状态函数
//**************************************************
//函数名 ：数据管理函数
//功能 ：进行状态位切换
//输入 ：null
//输出 ：null
//作者 ：Bao
//**************************************************
void SI4463_Process(void)
{
//--------------------数据收发--------------------
if(Flag.is_tx)
{
test_tx_data2(tx__data); //发送
}
else
{
//test_Receive2(); //接受
receiveFramefrom433(); //数据接收
}
}
根据标志位选择数据的收发情况
将数据帧提取放入发送区的函数
//**************************************************
//函数名 ：对内发送数据打包函数
//功能 ：将缓存区域数据转移一部分进行封包,存入数据发送缓存区域中
//输入 ：null
//输出 ：null
//作者 ：Bao
//**************************************************
void pack_O_2_I_Frame(void)
{
uint16_t frame_head = 0;
uint16_t frame_end = 0;
uint16_t frame_rhead = 0; //考虑到循环存储，因此把发送数据做个分段提取
uint16_t frame_rend = 0;
uint16_t i = 0; //测试用序号
do{
saveFrameToBUFF(O_2_I_LEN,TRUE); //强制封一帧
}
while(frame_index_l==0); //防止中断引起封帧失败
if(frame_index_l>>1) //也就是已经存储了若干帧
{
frame_index_l-=2; //取出1帧
frame_head=frame_club[frame_index_s][0];//取出帧头
frame_end =frame_club[frame_index_s][1];//取出帧尾
frame_club[FRAME_CLUB_MAX][0]=
frame_club[frame_index_s][0];//保存帧头
frame_club[FRAME_CLUB_MAX][1]=
frame_club[frame_index_s][1];//保存帧尾
frame_club[frame_index_s][0]=0; //清除旧数据
frame_club[frame_index_s][1]=0; //清除旧数据
frame_index_s++; //发送帧组序号进1
if(frame_index_s>=FRAME_CLUB_MAX)
frame_index_s=0; //发送帧序号复位
//暂时不做帧组管理和相关校验 2019.10.15
if(frame_head>frame_end) //帧头序号大于帧尾序号
{
frame_rhead= BUFF_LEN_B ; //头的结尾
frame_rend = 0; //尾的开头
}
else
{
frame_rhead=frame_end; //头的结尾是尾
frame_rend =frame_end ; //尾是尾
}
INSIDE_TX_LEN=(frame_rhead-frame_head)+
(frame_end-frame_rend); //获取发送长度
if(INSIDE_TX_LEN>PACK_MAX_DATA_LEN)
{
#ifdef DEBUG_433
printf("[e] frame_head=%d\n",frame_head);
printf("[e] frame_end =%d\n",frame_end);
printf("[e] frame_index_s =%d\n",frame_index_s);
printf("[e] frame_index_n =%d\n",frame_index_n);
#endif
INSIDE_TX_LEN=PACK_MAX_DATA_LEN+20; //临时处理长度错误问题
memset(INSIDE_TX_BUFF,0,INSIDE_TX_LEN); //清除发送区数据
}
else
{
memcpy(&INSIDE_TX_BUFF[0],
&O_2_I_BUFF[frame_head],
frame_rhead-frame_head); //复制第一段数据
memcpy(&INSIDE_TX_BUFF[frame_rhead-frame_head],
&O_2_I_BUFF[frame_rend],
frame_end-frame_rend); //复制第二段数据
}
#ifdef DEBUG_433
printf("%2d,%3d\n",INSIDE_TX_LEN,frame_index_l);
#endif
pack433Data(INSIDE_TX_BUFF,INSIDE_TX_LEN,PACK_FUNCTION_DATA);//重新打包数据
INSIDE_TX_LEN += PACK_OUTDATA_LEN; //打包数据的长度
//test
memcpy(&tx__data[4],INSIDE_TX_BUFF,PACK_MAX_LEN); //转移数据
memset(INSIDE_TX_BUFF,0,PACK_MAX_LEN); //清除发送缓存区数据
INSIDE_TX_LEN=0;
}
i = i; //去除编译的warning，无意义
}
这部分移植了E70 半双工方案里的读取帧的部分。
主业务流程为：
确保帧队列里有帧，然后把最老的帧提取出来，根据头和尾的指针位置，复制这一段数据到发送缓存区域
接收数据函数
//**************************************************
//函数名 ：获取来自于433模块的帧数据
//功能 ：将获取的帧数据进行解包转发操作
//输入 ：null
//输出 ：null
//作者 ：Bao
//**************************************************
void receiveFramefrom433 (void) //获取433模组的数据
{
if(Flag.run==2)
{
Flag.run=0;
clr_interrupt(); // clear interrupt
if((spi_read_buf[4] &0x08) == 0) // crc error check
{
spi_read_fifo();
fifo_reset();
m_test.Count2++;
Flag.is_rx=1; //接收动作喂狗
unpackFrame(); //解包函数
m_time.recevie_Time=GetTickCount();
//printf(",%d,%d,%d\n",m_time.recevie_Time,m_test.Count,m_test.Count2);
Flag.is_tx=1; //转换为发送模式
}
else
{
printf("---------------crc error-------------\n");
packSpecialFrame(PACK_FUNCTION_RESEND); //封包：请求重发
Flag.is_tx=1; //转换为发送模式
}
}
i=i;
}
接受数据，如果正确接受则对数据包进行解包，如果不正确接受，则一帧特殊数据包到发送区域。
解包函数
//**************************************************
//函数名 ：对于帧进行解包
//功能 ：对于帧数据进行解包处理
//输入 ：null
//输出 ：null
//作者 ：Bao
//**************************************************
void unpackFrame (void) //解包函数
{
u16 len =0;
u16 number =0;
u16 function =0;
u16 check =0;
u8 dataBuff[PACK_MAX_LEN]={0}; //划分缓存区域
u16 add_queue_len=0; //数据队列新增
memcpy(dataBuff,&rx_buf[4],PACK_MAX_LEN); //读取数据
len = dataBuff[0]; //获取帧长度
number = (dataBuff[1]<<8)+dataBuff[2]; //获取帧序号 //暂时未启用
function = dataBuff[3]; //获取帧功能
check = dataBuff[4]; //获取帧校验
number = number;
check = check;
switch(function) //根据帧功能进行分拣
{
case PACK_FUNCTION_RESEND: //数据需要重新发送
//空操作
//发送组里的数据不会因为发送而改变
//因此重新只需要重新进入发送姿态即可
break;
case PACK_FUNCTION_DATA:
add_queue_len=len ;
setDataFlag=1; //正在载入串口数据
I_2_O_QUEUE_LEN+=add_queue_len; //对外输出队列加长 (公共数据，线程锁包含)
setDataFlag=0; //串口数据载入完成
if(I_2_O_QUEUE_LEN>=BUFF_LEN_O)
{
I_2_O_QUEUE_LEN=add_queue_len;
#ifdef DEBUG_433
printf("[ERROR_433] Too late to outgoing,give up\n");
#endif
}
else
{
for(i=0;i<add_queue_len;i++) //中断发送数据
{
I_2_O_BUFF[I_2_O_END_LEN++]=dataBuff[i+PACK_OUTDATA_LEN];
if(I_2_O_END_LEN>=BUFF_LEN_O)
I_2_O_END_LEN=0;
}
}
#ifdef DEBUG_433
printf("T,%d,%d,%d\n",I_2_O_LEN,I_2_O_QUEUE_LEN,I_2_O_END_LEN);
#endif
if(outPutFlag==0) //如果没在对外输出则开启中断
USART_ITConfig(OUTSIDE,USART_IT_TXE, ENABLE); //获取数据完毕,开启中断进行发送
pack_O_2_I_Frame(); //向4463模块发送区封入数据帧
break;
case PACK_FUNCTION_START: //如果功能码字段为空表示此包是启动包（临时处理）
#ifdef DEBUG_433
printf("[ERROR_433] pack function == 0\n");
#endif
packSpecialFrame (PACK_FUNCTION_DATA); //临时处理
break;
default:;
}
}
业务逻辑如下
获取数据包的功能字节段，
根据长度字节段搬运数据。
根据功能字节段选择合适的执行动作
其中如果是重新回包请求，则无视，如果是正常数据包，则把数据转移到对外发送队列里，修改相关参数，这里有一个关键点：setDataFlag 同样是为了不让中断影响队列。
特殊功能封包函数
//**************************************************
//函数名 ：打包特殊功能的数据帧
//功能 ：打包特殊功能的空数据帧
//输入 ：null
//输出 ：null
//作者 ：Bao
//**************************************************
void packSpecialFrame (u8 function)
{
memset(INSIDE_TX_BUFF,0,PACK_MAX_LEN); //清除缓存区域数据
INSIDE_TX_LEN=0;
pack433Data(INSIDE_TX_BUFF,INSIDE_TX_LEN,function); //重新打包数据
INSIDE_TX_LEN += PACK_OUTDATA_LEN; //打包数据的长度
//test
memcpy(&tx__data[4],INSIDE_TX_BUFF,INSIDE_TX_LEN); //转移数据
}
用于特殊情况下不进行数据通讯时，封印专用的功能包，并放入发送缓存区域。
外侧数据处理函数（串口中断）
void USART3_IRQHandler(void) //串口3中断
{
u8 res;
if(USART_GetITStatus(OUTSIDE,USART_IT_TXE)!=RESET)//发送完成标志 //保证发送的第一优先级别
{
if(setDataFlag) //如果正在载入数据，先关闭中断
{
USART_ClearITPendingBit(OUTSIDE,USART_IT_TXE);//先清除中断标志位
USART_ITConfig(OUTSIDE,USART_IT_TXE, DISABLE);//无数据则关闭中断
outPutFlag=0;
}
else if(I_2_O_QUEUE_LEN>0) //队列里有数据
{
I_2_O_QUEUE_LEN--; //队列长度减1
USART_SendData(OUTSIDE, I_2_O_BUFF[I_2_O_LEN++]);//send
if(I_2_O_LEN>=BUFF_LEN_O)
I_2_O_LEN=0;
USART_ClearITPendingBit(OUTSIDE,USART_IT_TXE);//先清除中断标志位
outPutFlag=1;
}
else
{
USART_ClearITPendingBit(OUTSIDE,USART_IT_TXE);//先清除中断标志位
USART_ITConfig(OUTSIDE,USART_IT_TXE, DISABLE);//无数据则关闭中断
outPutFlag=0;
}
}
if(USART_GetITStatus(OUTSIDE,USART_IT_RXNE)) //收到一个字就立刻发送
{
res= USART_ReceiveData(OUTSIDE);
//USART_SendData(USART1,res); //2转1
// USART_SendData(USART3,res); //转3
O_2_I_BUFF[O_2_I_LEN++]=res; //存入收区
if(O_2_I_LEN>=BUFF_LEN_I)
O_2_I_LEN=0;
saveFrameToBUFF(O_2_I_LEN,FALSE); //封帧
}
}
主函数基础操作
//read_Version(); //读版本号测试
TIME_Process(); //超时判别
SI4463_Process(); //业务逻辑
代码写的好就是主页面就是这么简洁┗( ▔, ▔ )┛
结语
这个方案，我经过测试，发现稳定性很好，但是速度不是很满意。我调出单向最快空速9KB的时候，双向空速近似是2KB 所以后续代码和结构以及一些优化我就放弃制作了。如果有这方面的开发的问题可以问我。我目前研究了E70伪全双工，E62全双工，双E70全双工，4463伪全双工，下一步是双4463 全双工。
也欢迎大佬来讨论远距离双向传输方案。
