LORA 射频自组网 两级中继

基于sx1276lora模块,进行多个模块之间自组网,组网形式为1个集中器加多个终端。模块之间距离较远时,集中器无法直接与某个终端进行通信,其他终端本身可作为中继给该终端作为中继与集中器通信。lora调制方式,发送数据为星型通信方式,为自组网提供了便利。

终端接收心跳存储:

typedef struct
{
    uint32_t     Id;//接收的ID
    uint8_t      Rssi;//信号强度
}RECV_TERMINAL_T;

RECV_TERMINAL_T    RecvTerminal[RECV_NUM];

集中器接收心跳存储、发送路径存储:

typedef struct
{
    uint32_t     Id;//ID设备号
    uint8_t      index;// 
    uint8_t      relay;//
}TERMINAL_ID_LOCATION_T;

typedef struct
{
    uint32_t    Id[ROUTING_LAYERS];//接收的ID
    uint8_t     Rssi[ROUTING_LAYERS];//信号强度
}RECV_TERMINAL_T;

TERMINAL_ID_LOCATION_T  TerminalId[REGISTER_ID_NUM];  // 注册的终端ID 由配置传入   

RECV_TERMINAL_T         RecvTerminal[ ID_ROUTE_NUM];

1.1、路径存储形式:

二维数组RecvTerminal[i].Id[j];使用i表示所有不同的路径信息,j=0表示是直连、j=1即1级中继、j=2即2级中继。

集中器上的注册ID填写至结构体TerminalId;TerminalId.Id为注册ID,TerminalId.index为要发送到改地址的路径信息位置,TerminalId.relay为需要发送到该地址所需经过的中继层数。

1.2、终端处理流程:

终端定义每隔5分钟(时间根据测试修改)发送一次心跳报文。

在接收数据时,判断若是接收到心跳报文,则进行填本终端所接收到的心跳结构体RecvTerminal[n];

判断若是终端发送的非心跳报文,则进行判断,若报文目的地址非本地地址,则进行中继转发判断,判断本地地址是否为该报文中继,若是则进行转发判断到下一中继或者转发到目的地址;

判断若是集中器下发的报文,若目的地址为本地地址,则直接进行解包处理。若目的地址不为本地地址,则进行中继转发判断到下一中继或转发到目的地址。

终端回复集中器报文时,自动根据集中器下发的路径来巡回路径。

1.3、集中器端:

1.3.1 直连通信:

集中器接收到终端的心跳报文,则进行填表处理RecvTerminal[i++].Id[0],TerminalId.index=i,TerminalId.relay=0。若在集中器注册的ID存在接收不到心跳,则需要进行中继召唤处理,若能接收到全部心跳报文,则不进行一下处理。

1.3.2 一级中继:

集中器下发召唤命令到已填表的IDrecv=RecvTerminal[i++].Id[0],要求该IDrecv上送其所能接收到的心跳终端(RecvTerminal[n])。查询RecvTerminal里是否有存在集中器无接收到心跳的Idnorecv,若存在,则填表RecvTerminal[i++].Id[0]=IDrecv,RecvTerminal[i].Id[1]=Idnorecv;该Idnorecv的TerminalId.index=i,TerminalId.relay=1;表示集中器需要与Idnorecv通信时,需要通过终端IDrecv作为中继才能发送成功。

1.3.3 二级中继:

一级中继召唤命令完成后,依旧存在集中器注的IDnorecv接收不到心跳报文也无路径信息,即IDnorecv对应的结构体的index==0。则集中器下发召唤命令到已填表中TerminalId.relay为1的Idrecv,由于Idrecv的relay为1,则该终端本身需要通过一个中继终端RelayId作为中继来进行通信。集中器要求该Idrecv上送其所能接收到的心跳终端(RecvTerminal[n]),再根据终端回应的报文查询RecvTerminal里是否有存在集中器无接收到的心跳IDnorecv,若存在则填表RecvTerminal[i++].Id[0]=RelayId,RecvTerminal[i].Id[1]=Idrecv,

RecvTerminal[i].Id[2]=Idnorecv;该Idnorecv的TerminalId.index=i,TerminalId.relay=2。表示当集中器要与Idnorecv通信时,需要通过RelayId、Idrecv两级作为该终端中继才能通信成功。

1.3.4 集中器下发报文路径:

报文中包含relaynum中继个数,relayID具体的中继ID,即路径。例如需要通信ID=0x0001,0x0001对应的结构体TerminalId.Id=0x0001,TerminalId.index=5;

TerminalId.relay=2. 则集中器下发的报文中relaynum=2,relayID1=RecvTerminal[5].Id[0],

relayID2=RecvTerminal[5].Id[1]。如此集中器即能与0x0001通信。


终端部分代码:

#define    ROUTING_LAYERS     3
#define    REGISTER_ID_NUM    5
#define  RECV_NUM  10
typedef enum
{
    UPLOAD_TERMINAL_RELAY = 0x01,
}COMMAND_OPERATION_TYPE_E; // 命令操作类型


typedef enum
{
    UPLOAD_MESSAGE_FIRST_RELAY,
    UPLOAD_MESSAGE_SECOND_RELAY,

}COMMAND_PROCESSING_E; // 命令处理


typedef struct
{
    uint8_t           DevType;                      /* 设备类型*/    
    uint32_t          DevAddr;                     /* 设备地址 */     
    uint8_t           TypeId;                          /* 操作类型 例如遥控 遥测*/    
    uint8_t           Func;                             /* 功能码,例如具体遥控什么*/     
    uint8_t           RelayNum;//经过中继个数
    uint32_t          RfAddr;                       /* RF 地址*/
    uint8_t           Data[16];                      /* 数据域 */
    uint8_t           Len;                              /* data数据报文长度 */   
}MESSAGE_FORMAT_T; // message format 报文格式

typedef struct
{
    uint8_t           Buf[64]; 
    uint8_t           Len;                        /* 数据长度*/
    uint32_t          Addr;                       /* 远方地址*/
}MESSAGE_BUFFER;

typedef struct
{
    BYTE           Cache[MACRO_RFPROC_RECV_CACHE_SIZE];
    CircleQueue    Queue; 
}MESSAGE_QUEUE;

typedef struct
{
    uint32_t     Id;//接收的ID
    uint8_t      Rssi;//信号强度
}RECV_TERMINAL_T;

typedef struct
{
    uint8_t                 Num; // 注册终端ID个数 由配置传入
    uint8_t                 index; // 检测注册终端第index个是否收到心跳
    uint8_t                 Route;
    uint8_t                 NetworkFlag;// 开启组网标志
}REGISTER_TERMINAL_T;
    
typedef struct
{

    RECV_TERMINAL_T    RecvTerminal[RECV_NUM];

    uint8_t                 n;
    MESSAGE_FORMAT_T        SendFrame;              /* 发送帧数据*/
    MESSAGE_FORMAT_T        RecvFrame;                 /* 接收存放帧*/      
    MESSAGE_BUFFER          SendBuf;
    MESSAGE_QUEUE           RecvQueue;
}PROTOCOL_T;
extern __no_init PROTOCOL_T   g_ProData;

/*
 * 函数名称    :   HeartBeatPackets
 * 函数功能    :   心跳
 * 输入参数    :   无
 * 输出参数    :   无
 * 返 回 值    :   无
 * 其它说明    :   5s发送一次
 * */
static void  HeartBeatPackets(void)
{
    uint8_t index = 0;
    uint8_t i = 0;
    uint8_t cs = 0;
    uint8_t TypeId = 0x55;
    g_ProData.SendBuf.Buf[index++] = 0x10;    
    g_ProData.SendBuf.Buf[index++] = TypeId;
    uint8_t *pAddr = (uint8_t *)&g_ProData.SendFrame.DevAddr;
    for(i = 0;i < 3;i++)
    {
        g_ProData.SendBuf.Buf[index++] = pAddr[3-i];
    }
    for(i = 1;i < index;i++)
    {
        cs += g_ProData.SendBuf.Buf[i];
    }
    g_ProData.SendBuf.Buf[index++] = cs;
    g_ProData.SendBuf.Buf[index++] = 0x16;    
    g_ProData.SendBuf.Addr = 0x00;
    g_ProData.SendBuf.Len = index;
    SX1276_Data->G_LoRaConfig.PayloadLength = g_ProData.SendBuf.Len;    
    Send();
}

/*
 * 函数名称    :   RF436_Unpack10
 * 函数功能    :   解包
 * 输入参数    :   无
 * 输出参数    :   无
 * 返 回 值    :   成功返回true 失败返回FALSE
 * 其它说明    :   无
 * */
static bool Unpack10(void)
{   
    uint8_t cs = 0;
    uint32_t RfAddr = 0;
    static uint8_t i=0;
    
    ..........
     RfAddr = RF436_GetULongFromCache(&g_ProData.RecvQueue.Queue,2,3);
    if(i!=0)
    {
        for(int j=0;j<i;j++)
        {        
            if(RfAddr == g_ProData.RecvTerminal[j].Id) // 已存在 刷新数据
            {
                g_ProData.RecvTerminal[j].Id = RfAddr;
                g_ProData.RecvTerminal[j].Rssi = g_Sx1276.LoraParam.Rssi;
                
                CircleQueue_Remove(&g_ProData.RecvQueue.Queue,7);/* 读取完成一包,下移一包*/
                return TRUE;
            }   
        }  
        // 不存在 增加填表
        g_ProData.RecvTerminal[i++].Id = RfAddr;
        g_ProData.RecvTerminal[i].Rssi = g_Sx1276.LoraParam.Rssi;
        g_ProData.n = i;
    } 
    else
    {
        g_ProData.RecvTerminal[0].Id = RfAddr;
        g_ProData.RecvTerminal[0].Rssi = g_Sx1276.LoraParam.Rssi;
        i++;
        g_ProData.n = 1;
    }
    
    CircleQueue_Remove(&g_ProData.RecvQueue.Queue,7);/* 读取完成一包,下移一包*/
    return TRUE;
}  

/*
 * 函数名称    :   SendHeartBeatId
 * 函数功能    :   发送接收的心跳终端地址
 * 输入参数    :   无
 * 输出参数    :   无
 * 返 回 值    :   无
 * 其它说明    :   集中器召唤时发送
 * */
static void SendHeartBeatId(uint8_t TypeId,uint8_t Func)
{
    uint8_t  index = 0;
    uint8_t  i = 0;
    uint8_t  cs = 0;
    g_ProData.SendFrame.DevType = 0x5e; 
    g_ProData.SendFrame.TypeId = UPLOAD_TERMINAL_RELAY;
    g_ProData.SendFrame.Func = UPLOAD_MESSAGE_FIRST_RELAY;
    g_ProData.SendFrame.RelayNum = 0;    
    g_ProData.SendFrame.Len = (g_ProData.n)*(sizeof(RECV_TERMINAL_T));    
    g_ProData.SendBuf.Buf[index++] = 0x68;
    index+=2;
    g_ProData.SendBuf.Buf[index++] = 0x68;
    g_ProData.SendBuf.Buf[index++] = g_ProData.SendFrame.DevType;
    index += RF436_GetBytesFromOther(&g_ProData.SendFrame.DevAddr,sizeof(ULONG), g_ProData.SendBuf.Buf + index,3); 
    g_ProData.SendBuf.Buf[index++] = g_ProData.SendFrame.TypeId;
    g_ProData.SendBuf.Buf[index++] = g_ProData.SendFrame.Func;
    g_ProData.SendBuf.Buf[index++] = g_ProData.SendFrame.RelayNum;
    index += RF436_GetBytesFromOther(&g_ProData.SendFrame.RfAddr,sizeof(uint32_t),g_ProData.SendBuf.Buf + index, 3);    
    memcpy(g_ProData.SendFrame.Data,&g_ProData.RecvTerminal,(g_ProData.n)*(sizeof(RECV_TERMINAL_T)));
    for(i = 0;i < g_ProData.SendFrame.Len;i++)
    {
        g_ProData.SendBuf.Buf[index++] = g_ProData.SendFrame.Data[i];/* pframedata[i];,..... */
    }
    for(i = 4;i < index;i++)
    {
        cs += g_ProData.SendBuf.Buf[i];
    }    
    g_ProData.SendBuf.Buf[index++] = cs;
    g_ProData.SendBuf.Buf[index++] = 0x16;
    g_ProData.SendBuf.Buf[1] = index-6;
    g_ProData.SendBuf.Buf[2] = index-6;
    g_ProData.SendBuf.Len = index;
    g_ProData.SendBuf.Addr = g_ProData.SendFrame.RfAddr;    
    Send();     
}

///

集中器部分代码

#define    ID_ROUTE_NUM       30 
#define    ROUTING_LAYERS     3
#define    REGISTER_ID_NUM    5
typedef enum
{
    UPLOAD_TERMINAL_RELAY = 0x01;
    
}COMMAND_OPERATION_TYPE_E; // 命令操作类型

typedef enum
{
    UPLOAD_MESSAGE_FIRST_RELAY = 0x10,
    UPLOAD_MESSAGE_SECOND_RELAY = 0x11,

}COMMAND_PROCESSING_E; // 命令处理

typedef enum
{
    COMMUNICATION_NONE,
    COMMUNICATION_NETWORK,
    
}COMMUNICATION_STATE_E; // 

typedef struct
{
    uint8_t           DevType;                    /* 设备类型*/   
    uint32_t          DevAddr;                    /* 设备地址 */     
    uint8_t           TypeId;                     /* 操作类型 例如遥控 遥测*/    
    uint8_t           Func;                       /* 功能码,例如具体遥控什么*/     
    uint8_t           RelayNum;//经过中继个数
    uint32_t          RfAddr;                     /* RF 地址*/
    uint8_t           Data[16]; /* 数据域 */
    uint8_t           Len;                        /* data数据报文长度 */   
}MESSAGE_FORMAT_T; // message format 报文格式
typedef struct
{
    uint8_t           Buf[64]; 
    uint8_t           Len;                        /* 数据长度*/
    uint32_t          Addr;                       /* 远方地址*/
}MESSAGE_BUFFER;
typedef struct
{
    BYTE           Cache[MACRO_RFPROC_RECV_CACHE_SIZE];
    CircleQueue    Queue; 
}MESSAGE_QUEUE;

typedef struct
{
    uint32_t    Id[ROUTING_LAYERS];//接收的ID
    uint8_t     Rssi[ROUTING_LAYERS];//信号强度
}RECV_TERMINAL_T;

typedef struct
{
    uint32_t     Id;//ID设备号
    uint8_t      index;// 
    uint8_t      relay;//

}TERMINAL_ID_LOCATION_T;

typedef struct
{
    TERMINAL_ID_LOCATION_T  TerminalId[REGISTER_ID_NUM];  // 注册的终端ID 由配置传入  
    uint8_t                 Num; // 注册终端ID个数 由配置传入
    uint8_t                 index; // 检测注册终端第index个是否收到心跳
    uint8_t                 Route;
    uint8_t                 NetworkFlag;// 开启组网标志
}REGISTER_TERMINAL_T;
    
typedef struct
{
    RECV_TERMINAL_T         RecvTerminal[ ID_ROUTE_NUM];
    REGISTER_TERMINAL_T     Register;
    
    COMMUNICATION_STATE_E   CommunicationState;
    MESSAGE_FORMAT_T        SendFrame;              /* 发送帧数据*/
    MESSAGE_FORMAT_T        RecvFrame;                 /* 接收存放帧*/      
    MESSAGE_BUFFER          SendBuf;
    MESSAGE_QUEUE           RecvQueue;
}PROTOCOL_T;
    
extern __no_init PROTOCOL_T   g_ProData;

/*
 * 函数名称    :   Unpack10
 * 函数功能    :   解包
 * 输入参数    :   无
 * 输出参数    :   无
 * 返 回 值    :   成功返回true 失败返回FALSE
 * 其它说明    :   解包与终端填充方式不同
 * */
static bool Unpack10(void)
{   
    uint8_t cs = 0;
    uint32_t RfAddr = 0;

   ........................
    RfAddr = RF436_GetULongFromCache(&g_ProData.RecvQueue.Queue,2,3);
    SX1276_GetRecvRSSI();
    
    for(int j = 1;j < g_ProData.Register.Route;j++)
    {        
        if(RfAddr == g_ProData.RecvTerminal[j].Id[0]) // 已存在 刷新数据
        {
            g_ProData.RecvTerminal[j].Id[0] = RfAddr;
            g_ProData.RecvTerminal[j].Rssi[0] = g_Sx1276.LoraParam.Rssi;
                
            CircleQueue_Remove(&g_ProData.RecvQueue.Queue,7);/* 读取完成一包,下移一包*/
            return TRUE;
        }   
    }  
    // 不存在 增加填表
    g_ProData.RecvTerminal[g_ProData.Register.Route].Id[0] = RfAddr;
    g_ProData.RecvTerminal[g_ProData.Register.Route].Rssi[0] = g_Sx1276.LoraParam.Rssi;
    for(int j = 0;j < g_ProData.Register.Num;j++) // 填写直连通信路径
    {
        if(RfAddr == g_ProData.Register.TerminalId[j].Id )
        {
            g_ProData.Register.TerminalId[j].index = g_ProData.Register.Route;
            g_ProData.Register.TerminalId[j].relay = 0;
        }
    }
    g_ProData.Register.Route++; 
   
    CircleQueue_Remove(&g_ProData.RecvQueue.Queue,7);/* 读取完成一包,下移一包*/
    return TRUE;
}    

/*
 * 函数名称    :   
 * 函数功能    :   写入绑定终端ID
 * 输入参数    :   无
 * 输出参数    :   无
 * 返 回 值    :   
 * 其它说明    :   无
 * */
static void RegisterId(void)
{
    
    g_ProData.Register.Num = 5;
    g_ProData.Register.TerminalId[0].Id = 0xA00001;
    g_ProData.Register.TerminalId[1].Id = 0xA00002;
    g_ProData.Register.TerminalId[2].Id = 0xA00003;
    g_ProData.Register.TerminalId[3].Id = 0xA00004;
    g_ProData.Register.TerminalId[4].Id = 0xA00005;
        
}
void StartNetwork(void)
{
    
    g_Data.Run.NetWorkTime = 120000; //120s
    g_Data.Run.Section1time = 30000; 
    
}
/*
 * 函数名称    :   NetworkContinueTime
 * 函数功能    :   组网持续时间
 * 输入参数    :   无
 * 输出参数    :   无
 * 返 回 值    :   
 * 其它说明    :  
 * */
static void NetworkContinueTime(void)
{
    if(g_Data.Run.NetWorkTime)
    {
        g_ProData.Register.NetworkFlag = true;
    }
    else
    {
        g_ProData.Register.NetworkFlag = false;
    }  
}

/*
 * 函数名称    :   
 * 函数功能    :   
 * 输入参数    :   无
 * 输出参数    :   无
 * 返 回 值    :   
 * 其它说明    :  
 * */
static void CheckAndCallTerminal(uint8_t i)
{
    if(g_ProData.Register.TerminalId[i].index == 0)// 判断是否存在有注册ID没收到心跳
    {
        if(g_Data.Run.Section1time)
        {
            Level1relay(); // 发送一级中继召唤
        }
        else
        {
            g_Data.Run.Section2time = 30000;
        }
         // 等待30s 后进行二级中继召唤     
        if(g_Data.Run.Section2time)// 阶段二
        {
             Level2relay(); // 发送二级中继召唤
        }
    }
}
/*
 * 函数名称    :   NetWorking
 * 函数功能    :   组网
 * 输入参数    :   无
 * 输出参数    :   无
 * 返 回 值    :   
 * 其它说明    :   间隔5分钟,或者在长时间无接收到某终端数据后进行调用 
                        组网时,阶段时间切换 3个时间,1、一级中继召唤时间 2、二级中继召唤时间 3、组网共花费时间
 * */
static void NetWorking(void)
{
    if(g_Data.Run.SystemTick < 15000) // 开机后接收15s心跳后在进行组网
    {
        return;
    }
    NetworkContinueTime();
    if((!g_Data.Run.DetectionTime) && (g_ProData.Register.NetworkFlag))
    {
        if(g_ProData.Register.index < g_ProData.Register.Num)
        {
            CheckAndCallTerminal(g_ProData.Register.index);
            g_ProData.Register.index++;
        }
        else
        {
            g_ProData.Register.index = 0;
        }
        g_Data.Run.DetectionTime = 3000; // 开启组网后 3s一次进入检测组网 
    }
}


评论 11
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值