2232 lines
61 KiB
C
2232 lines
61 KiB
C
#include "SGCP.h"
|
|
#include "main.h"
|
|
#include "UartDebug.h"
|
|
#include "Update.h"
|
|
#include "sx127x.h"
|
|
#include "Algorithm.h"
|
|
|
|
/*烧录时配置项
|
|
IROM1起始地址 0x00 0x20000
|
|
IROM1串口升级地址 0x2A00 0x1D600
|
|
串口升级打开USE_BOOTLOADER和点s文件中的LDR R2, =new_vect_table ;升级时打开
|
|
*/
|
|
|
|
uint32_t LocalType; //本机设备类型
|
|
uint32_t CommWay; //本机通讯方式
|
|
uint32_t DeviceSign; //本机设备标志
|
|
uint32_t AddNumber; //本机地址编号，数字部分对应唯一地址编号
|
|
//09 00 01 00 00 00
|
|
uint8_t LocalMAC[6] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};//本机MAC地址
|
|
uint8_t GatewayMAC[6] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; //网关MAC地址，注册时全为0
|
|
uint8_t LocalDataPack[sizeof(SGCP.DevData.LaserTracing)]; //本机数据包
|
|
uint8_t LocalDataLen = sizeof(SGCP.DevData.LaserTracing); //本机设备数据长度
|
|
|
|
SGCP_t SGCP;
|
|
|
|
/**
|
|
*******************************************************************************
|
|
** \brief 设备数据信息获取
|
|
**
|
|
** \param Devtype 设备类型
|
|
**
|
|
** \param PayLoad 数据体
|
|
**
|
|
** \retval Len 数据长度
|
|
******************************************************************************/
|
|
static uint8_t DevGetDataMess(DEVICE_TYPE_M Devtype, uint8_t *PayLoad)
|
|
{
|
|
uint8_t Len;
|
|
switch(Devtype)
|
|
{
|
|
case NUL: break;
|
|
case FORCE_6D: break;
|
|
case OSMOTIC_PRESSURE: break;
|
|
case ELASTIC_WAVEGUIDE: break;
|
|
case DIELECTRIC_MASS: break;
|
|
case _0x0005:break;
|
|
case CONT_DEFOR_3D:{
|
|
if(PayLoad == NULL)
|
|
memset(&SGCP.DevData.ContDefor3D, 0x00, sizeof(SGCP.DevData.ContDefor3D));
|
|
else
|
|
memcpy(&SGCP.DevData.ContDefor3D, &PayLoad[0], sizeof(SGCP.DevData.ContDefor3D));
|
|
DBG_LOG("\tDevice Type:%04X, PitchSkew:%06d, RollSkew:%06d, YawSkew:%06d\r\n",
|
|
Devtype,
|
|
(SGCP.DevData.ContDefor3D.PitchAngle),
|
|
(SGCP.DevData.ContDefor3D.RollAngle),
|
|
(SGCP.DevData.ContDefor3D.YawAngle));
|
|
Len = sizeof(SGCP.DevData.ContDefor3D);
|
|
break;}
|
|
case COMM_UNIT: {
|
|
DBG_LOG("\tDevice Type:%04X\r\n",Devtype);
|
|
Len = sizeof(SGCP.DevData.CommUnit);
|
|
break;}
|
|
case FORCE_3D:{
|
|
if(PayLoad == NULL)
|
|
memset(&SGCP.DevData.Force3D, 0x00, sizeof(SGCP.DevData.Force3D));
|
|
else
|
|
memcpy(&SGCP.DevData.Force3D, &PayLoad[0], sizeof(SGCP.DevData.Force3D));
|
|
DBG_LOG("\tDevice Type:%04X, PitchSkew:%06d, RollSkew:%06d, YawSkew:%06d, Strain1:%09d, Strain2:%09d, Strain3:%09d\r\n",
|
|
Devtype,
|
|
(SGCP.DevData.Force3D.PitchAngle),
|
|
(SGCP.DevData.Force3D.RollAngle),
|
|
(SGCP.DevData.Force3D.YawAngle),
|
|
(SGCP.DevData.Force3D.Strain1),
|
|
(SGCP.DevData.Force3D.Strain2),
|
|
(SGCP.DevData.Force3D.Strain3));
|
|
Len = sizeof(SGCP.DevData.Force3D);
|
|
break;}
|
|
case LASER_TRACING: {
|
|
if(PayLoad == NULL)
|
|
memset(&SGCP.DevData.LaserTracing, 0x00, sizeof(SGCP.DevData.LaserTracing));
|
|
else
|
|
|
|
memcpy(&SGCP.DevData.LaserTracing, &PayLoad[0], sizeof(SGCP.DevData.LaserTracing));
|
|
DBG_LOG("\tBatLevel:%03d, RSSI:%02d, Nsr:%02d\r\n",SGCP.DevData.LaserTracing.MasterDev.BatLevel, SGCP.DevData.LaserTracing.MasterDev.RSSI,SGCP.DevData.LaserTracing.MasterDev.Nsr);
|
|
DBG_LOG("\tDevice Type:%04X, PitchSkew:%04d, RollSkew:%04d, YawSkew:%04d\r\n",
|
|
Devtype,
|
|
(SGCP.DevData.LaserTracing.PitchAngle),
|
|
(SGCP.DevData.LaserTracing.RollAngle),
|
|
(SGCP.DevData.LaserTracing.YawAngle));
|
|
Len = sizeof(SGCP.DevData.LaserTracing);
|
|
break;}
|
|
case _0x000A: break;
|
|
case _0x000B: break;
|
|
case _0x000C: break;
|
|
case MULTI_PARAMETER_FUSION: break;
|
|
case CRACK_DETECTION: break;
|
|
case _0x000F: break;
|
|
case ATTITUDE_MONITOR: break;
|
|
case LASER_DISPLACE: break;
|
|
case REBAR_STRESS: break;
|
|
case ANCHOR_ROD_STRESS: break;
|
|
case SURFACE_STRESS: break;
|
|
case PRESSURE: break;
|
|
case MICROWAVE_DISPLACE: break;
|
|
}
|
|
|
|
return Len;
|
|
}
|
|
/**
|
|
*******************************************************************************
|
|
** \brief 子设备校准指令
|
|
**
|
|
** \param [in] Addr 子设备地址
|
|
**
|
|
** \param [in] PayLoad 数据体
|
|
**
|
|
** \retval 无
|
|
******************************************************************************/
|
|
static void ToSDCali(uint8_t Addr)
|
|
{
|
|
uint8_t Pack[50];
|
|
uint16_t Crc16;
|
|
uint8_t len;
|
|
|
|
SubsetFrameHeader SFHeader = (SubsetFrameHeader)Pack;
|
|
|
|
SFHeader->Header = 0x7C;
|
|
SFHeader->Addr = Addr;
|
|
SFHeader->Cmd = MDTOSD_CMD_CALI;
|
|
SFHeader->PayloadLen = 0;
|
|
|
|
len = sizeof(SubsetFrameHeader_t);
|
|
|
|
Crc16 = CRC_Modbus(CRC16_BASE, Pack, len);
|
|
Pack[len++] = Crc16 & 0x00ff;
|
|
Pack[len++] = (Crc16 >> 8) & 0x00ff;
|
|
|
|
SGCP.SDRS485Rx.sCmdMDToSD = (MDTOSD_CMD_M)SFHeader->Cmd;
|
|
Uart1SendArray(Pack, len);
|
|
}
|
|
/**
|
|
*******************************************************************************
|
|
** \brief 子设备读取数据指令
|
|
**
|
|
** \param [in] Addr 子设备地址
|
|
**
|
|
** \param [in] PayLoad 数据体
|
|
**
|
|
** \retval 无
|
|
******************************************************************************/
|
|
static void ToSDReadData(uint8_t Addr)
|
|
{
|
|
uint8_t Pack[50];
|
|
uint16_t Crc16;
|
|
uint8_t len;
|
|
|
|
SubsetFrameHeader SFHeader = (SubsetFrameHeader)Pack;
|
|
|
|
SFHeader->Header = 0x7C;
|
|
SFHeader->Addr = Addr;
|
|
SFHeader->Cmd = MDTOSD_CMD_READ_DATA;
|
|
SFHeader->PayloadLen = 0;
|
|
|
|
len = sizeof(SubsetFrameHeader_t);
|
|
|
|
Crc16 = CRC_Modbus(CRC16_BASE, Pack, len);
|
|
Pack[len++] = Crc16 & 0x00ff;
|
|
Pack[len++] = (Crc16 >> 8) & 0x00ff;
|
|
|
|
SGCP.SDRS485Rx.sCmdMDToSD = (MDTOSD_CMD_M)SFHeader->Cmd;
|
|
Uart1SendArray(Pack, len);
|
|
}
|
|
/**
|
|
*******************************************************************************
|
|
** \brief 子设备查询指令
|
|
**
|
|
** \param [in] Addr 子设备485地址
|
|
**
|
|
** \param [in] PayLoad 数据体
|
|
**
|
|
** \retval 无
|
|
******************************************************************************/
|
|
static void ToSDInquire(uint8_t Addr)
|
|
{
|
|
uint8_t Pack[50];
|
|
uint16_t Crc16;
|
|
uint8_t len;
|
|
|
|
SubsetFrameHeader SFHeader = (SubsetFrameHeader)Pack;
|
|
|
|
SFHeader->Header = 0x7C;
|
|
SFHeader->Addr = Addr;
|
|
SFHeader->Cmd = MDTOSD_CMD_INQUIRE;
|
|
SFHeader->PayloadLen = 0;
|
|
|
|
len = sizeof(SubsetFrameHeader_t);
|
|
|
|
Crc16 = CRC_Modbus(CRC16_BASE, Pack, len);
|
|
Pack[len++] = Crc16 & 0x00ff;
|
|
Pack[len++] = (Crc16 >> 8) & 0x00ff;
|
|
|
|
SGCP.SDRS485Rx.sCmdMDToSD = (MDTOSD_CMD_M)SFHeader->Cmd;
|
|
Uart1SendArray(Pack, len);
|
|
}
|
|
/**
|
|
*******************************************************************************
|
|
** \brief 子设备设置采集时间间隔指令
|
|
**
|
|
** \param [in] Addr 子设备地址
|
|
**
|
|
** \param [in] CollTime 采集时间间隔
|
|
**
|
|
** \retval 无
|
|
******************************************************************************/
|
|
static void ToSDSetColTime(uint8_t Addr, uint16_t CollectInterval)
|
|
{
|
|
uint8_t Pack[50];
|
|
uint16_t Crc16;
|
|
uint8_t len;
|
|
|
|
SubsetFrameHeader SFHeader = (SubsetFrameHeader)Pack;
|
|
|
|
SFHeader->Header = 0x7C;
|
|
SFHeader->Addr = Addr;
|
|
SFHeader->Cmd = MDTOSD_CMD_SET_COL_TIME;
|
|
SFHeader->PayloadLen = sizeof(CollectInterval);
|
|
|
|
len = sizeof(SubsetFrameHeader_t);
|
|
|
|
Pack[len++] = CollectInterval & 0xFF;
|
|
Pack[len++] = (CollectInterval >> 8) & 0xFF;
|
|
|
|
Crc16 = CRC_Modbus(CRC16_BASE, Pack, len);
|
|
Pack[len++] = Crc16 & 0x00ff;
|
|
Pack[len++] = (Crc16 >> 8) & 0x00ff;
|
|
|
|
SGCP.SDRS485Rx.sCmdMDToSD = (MDTOSD_CMD_M)SFHeader->Cmd;
|
|
Uart1SendArray(Pack, len);
|
|
}
|
|
/**
|
|
*******************************************************************************
|
|
** \brief 子设备时间同步指令
|
|
**
|
|
** \param [in] Addr 子设备地址
|
|
**
|
|
** \param [in] PayLoad 数据体
|
|
**
|
|
** \retval 无
|
|
******************************************************************************/
|
|
static void ToSDSyncTime(uint8_t Addr, uint32_t TimeStamp)
|
|
{
|
|
uint8_t Pack[50];
|
|
uint16_t Crc16;
|
|
uint8_t len;
|
|
|
|
SubsetFrameHeader SFHeader = (SubsetFrameHeader)Pack;
|
|
|
|
SFHeader->Header = 0x7C;
|
|
SFHeader->Addr = Addr;
|
|
SFHeader->Cmd = MDTOSD_CMD_SYNC_TIME;
|
|
SFHeader->PayloadLen = sizeof(TimeStamp);
|
|
|
|
len = sizeof(SubsetFrameHeader_t);
|
|
|
|
Pack[len++] = TimeStamp & 0xFF;
|
|
Pack[len++] = (TimeStamp >> 8) & 0xFF;
|
|
Pack[len++] = (TimeStamp >> 16) & 0xFF;
|
|
Pack[len++] = (TimeStamp >> 24) & 0xFF;
|
|
|
|
Crc16 = CRC_Modbus(CRC16_BASE, Pack, len);
|
|
Pack[len++] = Crc16 & 0x00ff;
|
|
Pack[len++] = (Crc16 >> 8) & 0x00ff;
|
|
|
|
SGCP.SDRS485Rx.sCmdMDToSD = (MDTOSD_CMD_M)SFHeader->Cmd;
|
|
Uart1SendArray(Pack, len);
|
|
}
|
|
|
|
/**
|
|
*******************************************************************************
|
|
** \brief 子设备校准回应
|
|
**
|
|
** \param [in] Addr 子设备地址
|
|
**
|
|
** \param [in] Ok_Err 成功失败标志位
|
|
**
|
|
** \retval 无
|
|
******************************************************************************/
|
|
static void ToMDCaliRes(uint8_t Addr, bool Ok_Err)
|
|
{
|
|
uint8_t Pack[50];
|
|
uint16_t Crc16;
|
|
uint8_t len;
|
|
|
|
SubsetFrameHeader SFHeader = (SubsetFrameHeader)Pack;
|
|
|
|
SFHeader->Header = 0x7C;
|
|
SFHeader->Addr = Addr;
|
|
SFHeader->Cmd = MDTOSD_CMD_CALI;
|
|
SFHeader->PayloadLen = sizeof(Ok_Err);
|
|
|
|
len = sizeof(SubsetFrameHeader_t);
|
|
|
|
Pack[len++] = Ok_Err;
|
|
|
|
Crc16 = CRC_Modbus(CRC16_BASE, Pack, len);
|
|
Pack[len++] = Crc16 & 0x00ff;
|
|
Pack[len++] = (Crc16 >> 8) & 0x00ff;
|
|
|
|
SGCP.SDRS485Rx.sCmdMDToSD = (MDTOSD_CMD_M)SFHeader->Cmd;
|
|
LPUart0SendArray(Pack, len);
|
|
}
|
|
/**
|
|
*******************************************************************************
|
|
** \brief 子设备读取数据指令回应
|
|
**
|
|
** \param [in] Addr 子设备地址
|
|
**
|
|
** \param [in] PayLoad 数据体
|
|
**
|
|
** \retval 无
|
|
******************************************************************************/
|
|
static void ToMDReadDataRes(uint8_t Addr, uint8_t *PayLoad, uint8_t Len)
|
|
{
|
|
uint8_t Pack[50];
|
|
uint16_t Crc16;
|
|
uint8_t len;
|
|
|
|
SubsetFrameHeader SFHeader = (SubsetFrameHeader)Pack;
|
|
|
|
SFHeader->Header = 0x7C;
|
|
SFHeader->Addr = Addr;
|
|
SFHeader->Cmd = MDTOSD_CMD_READ_DATA;
|
|
SFHeader->PayloadLen = Len;
|
|
|
|
len = sizeof(SubsetFrameHeader_t);
|
|
|
|
for(uint8_t i = 0; i < SFHeader->PayloadLen; i++)
|
|
{
|
|
Pack[len++] = PayLoad[i];
|
|
}
|
|
|
|
Crc16 = CRC_Modbus(CRC16_BASE, Pack, len);
|
|
Pack[len++] = Crc16 & 0x00ff;
|
|
Pack[len++] = (Crc16 >> 8) & 0x00ff;
|
|
|
|
SGCP.SDRS485Rx.sCmdMDToSD = (MDTOSD_CMD_M)SFHeader->Cmd;
|
|
LPUart0SendArray(Pack, len);
|
|
}
|
|
/**
|
|
*******************************************************************************
|
|
** \brief 子设备查询指令回应
|
|
**
|
|
** \param [in] Addr 子设备485地址
|
|
**
|
|
** \param [in] PayLoad 数据体
|
|
**
|
|
** \retval 无
|
|
******************************************************************************/
|
|
static void ToMDInquireRes(uint8_t Addr)
|
|
{
|
|
uint8_t Pack[50];
|
|
uint16_t Crc16;
|
|
uint8_t len;
|
|
|
|
SubsetFrameHeader SFHeader = (SubsetFrameHeader)Pack;
|
|
|
|
SFHeader->Header = 0x7C;
|
|
SFHeader->Addr = Addr;
|
|
SFHeader->Cmd = MDTOSD_CMD_INQUIRE;
|
|
SFHeader->PayloadLen = 6;
|
|
|
|
len = sizeof(SubsetFrameHeader_t);
|
|
|
|
for(uint8_t i = 0; i < SFHeader->PayloadLen; i++)
|
|
{
|
|
Pack[len++] = LocalMAC[i];
|
|
}
|
|
|
|
Crc16 = CRC_Modbus(CRC16_BASE, Pack, len);
|
|
Pack[len++] = Crc16 & 0x00ff;
|
|
Pack[len++] = (Crc16 >> 8) & 0x00ff;
|
|
|
|
SGCP.SDRS485Rx.sCmdMDToSD = (MDTOSD_CMD_M)SFHeader->Cmd;
|
|
LPUart0SendArray(Pack, len);
|
|
}
|
|
/**
|
|
*******************************************************************************
|
|
** \brief 子设备设置采集时间间隔指令回应
|
|
**
|
|
** \param [in] Addr 子设备地址
|
|
**
|
|
** \param [in] Ok_Err 成功失败标志位
|
|
**
|
|
** \retval 无
|
|
******************************************************************************/
|
|
static void ToMDSetColTimeRes(uint8_t Addr, bool Ok_Err)
|
|
{
|
|
uint8_t Pack[50];
|
|
uint16_t Crc16;
|
|
uint8_t len;
|
|
|
|
SubsetFrameHeader SFHeader = (SubsetFrameHeader)Pack;
|
|
|
|
SFHeader->Header = 0x7C;
|
|
SFHeader->Addr = Addr;
|
|
SFHeader->Cmd = MDTOSD_CMD_SET_COL_TIME;
|
|
SFHeader->PayloadLen = sizeof(Ok_Err);
|
|
|
|
len = sizeof(SubsetFrameHeader_t);
|
|
|
|
Pack[len++] = Ok_Err;
|
|
|
|
Crc16 = CRC_Modbus(CRC16_BASE, Pack, len);
|
|
Pack[len++] = Crc16 & 0x00ff;
|
|
Pack[len++] = (Crc16 >> 8) & 0x00ff;
|
|
|
|
SGCP.SDRS485Rx.sCmdMDToSD = (MDTOSD_CMD_M)SFHeader->Cmd;
|
|
LPUart0SendArray(Pack, len);
|
|
}
|
|
/**
|
|
*******************************************************************************
|
|
** \brief 子设备时间同步指令回应
|
|
**
|
|
** \param [in] Addr 子设备地址
|
|
**
|
|
** \param [in] Ok_Err 成功失败标志位
|
|
**
|
|
** \retval 无
|
|
******************************************************************************/
|
|
static void ToMDSyncTimeRes(uint8_t Addr, bool Ok_Err)
|
|
{
|
|
uint8_t Pack[50];
|
|
uint16_t Crc16;
|
|
uint8_t len;
|
|
|
|
SubsetFrameHeader SFHeader = (SubsetFrameHeader)Pack;
|
|
|
|
SFHeader->Header = 0x7C;
|
|
SFHeader->Addr = Addr;
|
|
SFHeader->Cmd = MDTOSD_CMD_SYNC_TIME;
|
|
SFHeader->PayloadLen = sizeof(Ok_Err);
|
|
|
|
len = sizeof(SubsetFrameHeader_t);
|
|
|
|
Pack[len++] = Ok_Err;
|
|
|
|
Crc16 = CRC_Modbus(CRC16_BASE, Pack, len);
|
|
Pack[len++] = Crc16 & 0x00ff;
|
|
Pack[len++] = (Crc16 >> 8) & 0x00ff;
|
|
|
|
SGCP.SDRS485Rx.sCmdMDToSD = (MDTOSD_CMD_M)SFHeader->Cmd;
|
|
LPUart0SendArray(Pack, len);
|
|
}
|
|
|
|
|
|
/**
|
|
*******************************************************************************
|
|
** \brief 向网关申请注册
|
|
**
|
|
** \param PayLoad 数据体
|
|
**
|
|
** \retval 无
|
|
******************************************************************************/
|
|
static void ToGWDevLogin(void)
|
|
{
|
|
uint8_t Pack[512];
|
|
uint16_t Crc16, Len;
|
|
|
|
GatewayFrameHeader GFHeader = (GatewayFrameHeader)Pack;
|
|
|
|
GFHeader->Header = 0x7B;
|
|
memset(&GFHeader->GWAddr[0], 0x00, sizeof(GFHeader->GWAddr));
|
|
memcpy(&GFHeader->MDAddr[0], &LocalMAC[0], sizeof(GFHeader->MDAddr));
|
|
GFHeader->Cmd = GWTOMD_CMD_LOGIN;
|
|
GFHeader->PayloadLen = (SGCP.DeviceN * 6 + 1);
|
|
|
|
Len = sizeof(GatewayFrameHeader_t);
|
|
|
|
Pack[Len++] = SGCP.DeviceN;
|
|
for(uint8_t i = 0; i < SGCP.DeviceN; i++)
|
|
{
|
|
for(uint8_t j = 0; j < 6; j++)
|
|
{
|
|
Pack[Len++] = SGCP.DeviceMAC[i][j];
|
|
}
|
|
}
|
|
|
|
Crc16 = CRC_Modbus(CRC16_BASE, Pack, Len);
|
|
Pack[Len++] = Crc16 & 0x00ff;
|
|
Pack[Len++] = (Crc16 >> 8) & 0x00ff;
|
|
|
|
SGCP.GWRS485Rx.sCmdMDToGW = (GWTOMD_CMD_M)GFHeader->Cmd;
|
|
#if(SGCP_SELECT == 1 || SGCP_SELECT == 2)
|
|
Sx1276LoRaSendBuffer(Pack, Len);
|
|
#endif
|
|
#if(SGCP_SELECT == 3)
|
|
LPUart0SendArray(Pack, Len);
|
|
#endif
|
|
}
|
|
/**
|
|
*******************************************************************************
|
|
** \brief 网关校准指令回应
|
|
**
|
|
** \param Ok_Err 成功失败标志位
|
|
**
|
|
** \retval 无
|
|
******************************************************************************/
|
|
static void ToGWCaliRes(bool Ok_Err)
|
|
{
|
|
uint8_t Pack[256];
|
|
uint16_t Crc16;
|
|
uint8_t Len;
|
|
|
|
GatewayFrameHeader GFHeader = (GatewayFrameHeader)Pack;
|
|
|
|
GFHeader->Header = 0x7B;
|
|
memcpy(&GFHeader->GWAddr[0], &GatewayMAC[0], sizeof(GFHeader->GWAddr));
|
|
memcpy(&GFHeader->MDAddr[0], &LocalMAC[0], sizeof(GFHeader->MDAddr));
|
|
GFHeader->Cmd = GWTOMD_CMD_CALI;
|
|
GFHeader->PayloadLen = sizeof(Ok_Err);
|
|
|
|
Len = sizeof(GatewayFrameHeader_t);
|
|
|
|
Pack[Len++] = Ok_Err;
|
|
|
|
Crc16 = CRC_Modbus(CRC16_BASE, Pack, Len);
|
|
Pack[Len++] = Crc16 & 0x00ff;
|
|
Pack[Len++] = (Crc16 >> 8) & 0x00ff;
|
|
|
|
SGCP.GWRS485Rx.sCmdMDToGW = (GWTOMD_CMD_M)GFHeader->Cmd;
|
|
#if(SGCP_SELECT == 1 || SGCP_SELECT == 2)
|
|
Sx1276LoRaSendBuffer(Pack, Len);
|
|
#endif
|
|
#if(SGCP_SELECT == 3)
|
|
LPUart0SendArray(Pack, Len);
|
|
#endif
|
|
}
|
|
/**
|
|
*******************************************************************************
|
|
** \brief 网关读取数据指令回应
|
|
**
|
|
** \param PayLoad 数据体
|
|
**
|
|
** \retval 无
|
|
******************************************************************************/
|
|
static void ToGWReadDataRes(uint8_t *PayLoad)
|
|
{
|
|
uint8_t Pack[512];
|
|
uint16_t Crc16, Len;
|
|
|
|
GatewayFrameHeader GFHeader = (GatewayFrameHeader)Pack;
|
|
|
|
GFHeader->Header = 0x7B;
|
|
memcpy(&GFHeader->GWAddr[0], &GatewayMAC[0], sizeof(GFHeader->GWAddr));
|
|
memcpy(&GFHeader->MDAddr[0], &LocalMAC[0], sizeof(GFHeader->MDAddr));
|
|
GFHeader->Cmd = GWTOMD_CMD_READ_UPLOAD_SENSOR;
|
|
GFHeader->PayloadLen = SGCP.DeviceDataLen;
|
|
|
|
Len = sizeof(GatewayFrameHeader_t);
|
|
|
|
for(uint8_t i = 0; i < GFHeader->PayloadLen; i++)
|
|
{
|
|
Pack[Len++] = PayLoad[i];
|
|
}
|
|
|
|
Crc16 = CRC_Modbus(CRC16_BASE, Pack, Len);
|
|
Pack[Len++] = Crc16 & 0x00ff;
|
|
Pack[Len++] = (Crc16 >> 8) & 0x00ff;
|
|
|
|
SGCP.GWRS485Rx.sCmdMDToGW = (GWTOMD_CMD_M)GFHeader->Cmd;
|
|
#if(SGCP_SELECT == 1 || SGCP_SELECT == 2)
|
|
Sx1276LoRaSendBuffer(Pack, Len);
|
|
#endif
|
|
#if(SGCP_SELECT == 3)
|
|
LPUart0SendArray(Pack, Len);
|
|
#endif
|
|
}
|
|
|
|
/**
|
|
*******************************************************************************
|
|
** \brief 网关设置采集时间间隔指令回应
|
|
**
|
|
** \param Ok_Err 成功失败标志位
|
|
**
|
|
** \retval 无
|
|
******************************************************************************/
|
|
static void ToGWSetColTimeRes(bool Ok_Err)
|
|
{
|
|
uint8_t Pack[256];
|
|
uint16_t Crc16;
|
|
uint8_t Len;
|
|
|
|
GatewayFrameHeader GFHeader = (GatewayFrameHeader)Pack;
|
|
|
|
GFHeader->Header = 0x7B;
|
|
memcpy(&GFHeader->GWAddr[0], &GatewayMAC[0], sizeof(GFHeader->GWAddr));
|
|
memcpy(&GFHeader->MDAddr[0], &LocalMAC[0], sizeof(GFHeader->MDAddr));
|
|
GFHeader->Cmd = GWTOMD_CMD_SET_COL_TIME;
|
|
GFHeader->PayloadLen = sizeof(Ok_Err);
|
|
|
|
Len = sizeof(GatewayFrameHeader_t);
|
|
|
|
Pack[Len++] = Ok_Err;
|
|
|
|
Crc16 = CRC_Modbus(CRC16_BASE, Pack, Len);
|
|
Pack[Len++] = Crc16 & 0x00ff;
|
|
Pack[Len++] = (Crc16 >> 8) & 0x00ff;
|
|
|
|
SGCP.GWRS485Rx.sCmdMDToGW = (GWTOMD_CMD_M)GFHeader->Cmd;
|
|
#if(SGCP_SELECT == 1 || SGCP_SELECT == 2)
|
|
Sx1276LoRaSendBuffer(Pack, Len);
|
|
#endif
|
|
#if(SGCP_SELECT == 3)
|
|
LPUart0SendArray(Pack, Len);
|
|
#endif
|
|
}
|
|
|
|
/**
|
|
*******************************************************************************
|
|
** \brief 网关时间同步指令回应
|
|
**
|
|
** \param Ok_Err 成功失败标志位
|
|
**
|
|
** \retval 无
|
|
******************************************************************************/
|
|
static void ToGWSyncTimeRes(bool Ok_Err)
|
|
{
|
|
uint8_t Pack[256];
|
|
uint16_t Crc16;
|
|
uint8_t Len;
|
|
|
|
GatewayFrameHeader GFHeader = (GatewayFrameHeader)Pack;
|
|
|
|
GFHeader->Header = 0x7B;
|
|
memcpy(&GFHeader->GWAddr[0], &GatewayMAC[0], sizeof(GFHeader->GWAddr));
|
|
memcpy(&GFHeader->MDAddr[0], &LocalMAC[0], sizeof(GFHeader->MDAddr));
|
|
GFHeader->Cmd = GWTOMD_CMD_SYNC_TIME;
|
|
GFHeader->PayloadLen = sizeof(Ok_Err);
|
|
|
|
Len = sizeof(GatewayFrameHeader_t);
|
|
|
|
Pack[Len++] = Ok_Err;
|
|
|
|
Crc16 = CRC_Modbus(CRC16_BASE, Pack, Len);
|
|
Pack[Len++] = Crc16 & 0x00ff;
|
|
Pack[Len++] = (Crc16 >> 8) & 0x00ff;
|
|
|
|
SGCP.GWRS485Rx.sCmdMDToGW = (GWTOMD_CMD_M)GFHeader->Cmd;
|
|
#if(SGCP_SELECT == 1 || SGCP_SELECT == 2)
|
|
Sx1276LoRaSendBuffer(Pack, Len);
|
|
#endif
|
|
#if(SGCP_SELECT == 3)
|
|
LPUart0SendArray(Pack, Len);
|
|
#endif
|
|
}
|
|
/**
|
|
*******************************************************************************
|
|
** \brief 内部指令修改RS485地址回应
|
|
**
|
|
** \param PayLoad 数据体
|
|
**
|
|
** \retval 无
|
|
******************************************************************************/
|
|
static void Alter485AddrRes(uint8_t *MAC, bool Ok_Err)
|
|
{
|
|
uint8_t Pack[50];
|
|
uint16_t Crc16;
|
|
uint8_t len;
|
|
|
|
InsideFrameHeader IFHeader = (InsideFrameHeader)Pack;
|
|
|
|
IFHeader->Header = 0x7D;
|
|
memcpy(&IFHeader->MAC[0], &MAC[0], sizeof(IFHeader->MAC));
|
|
IFHeader->Cmd = INSIDE_CMD_ALTER_485ADDR;
|
|
IFHeader->PayloadLen = sizeof(Ok_Err);
|
|
|
|
len = sizeof(InsideFrameHeader_t);
|
|
|
|
Pack[len++] = Ok_Err;
|
|
|
|
Crc16 = CRC_Modbus(CRC16_BASE, Pack, len);
|
|
Pack[len++] = Crc16 & 0x00ff;
|
|
Pack[len++] = (Crc16 >> 8) & 0x00ff;
|
|
|
|
LPUart0SendArray(Pack, len);
|
|
}
|
|
/**
|
|
*******************************************************************************
|
|
** \brief 主设备接收子设备数据处理
|
|
**
|
|
** \param 无
|
|
**
|
|
** \retval 无
|
|
******************************************************************************/
|
|
static void SubsetRevHandler(void)
|
|
{
|
|
uint16_t crc16, Check;
|
|
uint8_t *PayLoad;
|
|
|
|
SubsetFrameHeader SFHeader = (SubsetFrameHeader)SGCP.SubsetBuff;
|
|
|
|
crc16 = (SGCP.SubsetBuff[SGCP.SubsetBuffLen - 1] << 8) | SGCP.SubsetBuff[SGCP.SubsetBuffLen - 2];
|
|
Check = CRC_Modbus(CRC16_BASE, SGCP.SubsetBuff, SGCP.SubsetBuffLen - 2);
|
|
|
|
if(crc16 != Check){
|
|
DBG_LOG("Subset CRC Err...\r\n");
|
|
return;
|
|
}
|
|
|
|
|
|
SGCP.SDRS485Rx.rCmdSDToMD = (MDTOSD_CMD_M)SFHeader->Cmd;
|
|
PayLoad = &SGCP.SubsetBuff[sizeof(SubsetFrameHeader_t)];
|
|
|
|
switch(SGCP.SDRS485Rx.rCmdSDToMD) {
|
|
case MDTOSD_CMD_CALI:{
|
|
SGCP.SubsetCaliOk = PayLoad[0];
|
|
break;}
|
|
|
|
case MDTOSD_CMD_READ_DATA:{
|
|
memcpy(&SGCP.DeviceDataBuff[SGCP.DeviceDataLen], PayLoad, SGCP.SDRS485Rx.rPayLen);
|
|
SGCP.SubsetReadDataOk = true;
|
|
break;}
|
|
|
|
case MDTOSD_CMD_INQUIRE:{
|
|
memcpy(&SGCP.DeviceMAC[SGCP.DeviceN], PayLoad, sizeof(SGCP.DeviceMAC[SGCP.DeviceN]));//子设备MAC
|
|
SGCP.SubsetMACOk = true;
|
|
break;}
|
|
|
|
case MDTOSD_CMD_SET_COL_TIME:{
|
|
SGCP.CollTimeSetOk = PayLoad[0];
|
|
break;}
|
|
|
|
case MDTOSD_CMD_SYNC_TIME:{
|
|
SGCP.SyncTimeOk = PayLoad[0];
|
|
break;}
|
|
}
|
|
}
|
|
/**
|
|
*******************************************************************************
|
|
** \brief 子设备接收主设备数据处理
|
|
**
|
|
** \param 无
|
|
**
|
|
** \retval 无
|
|
******************************************************************************/
|
|
static void MasRevHandler(void)
|
|
{
|
|
uint16_t crc16, Check;
|
|
uint8_t *PayLoad;
|
|
|
|
SubsetFrameHeader SFHeader = (SubsetFrameHeader)SGCP.SubsetBuff;
|
|
|
|
crc16 = (SGCP.SubsetBuff[SGCP.SubsetBuffLen - 1] << 8) | SGCP.SubsetBuff[SGCP.SubsetBuffLen - 2];
|
|
Check = CRC_Modbus(CRC16_BASE, SGCP.SubsetBuff, SGCP.SubsetBuffLen - 2);
|
|
|
|
if(crc16 != Check){
|
|
DBG_LOG("Master CRC Err...\r\n");
|
|
return;
|
|
}
|
|
|
|
if(SFHeader->Addr != App.Para.RS485Addr)
|
|
{
|
|
if(SFHeader->Addr != 0x00)
|
|
{
|
|
DBG_LOG("Master RS485Addr Err...\r\n");
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
SGCP.BroadCmd = true;
|
|
}
|
|
}
|
|
|
|
SGCP.SDRS485Rx.rCmdSDToMD = (MDTOSD_CMD_M)SFHeader->Cmd;
|
|
PayLoad = &SGCP.SubsetBuff[sizeof(SubsetFrameHeader_t)];
|
|
|
|
switch(SGCP.SDRS485Rx.rCmdSDToMD) {
|
|
case MDTOSD_CMD_CALI:{
|
|
if(SGCP.MasStatus == MAS_STATUS_IDLE)
|
|
{
|
|
SGCP.SubsetCaliOk = true;
|
|
SGCP.MasStatus = MAS_STATUS_CALI;
|
|
}
|
|
break;}
|
|
|
|
case MDTOSD_CMD_READ_DATA:{
|
|
if(SGCP.BroadCmd == true)
|
|
{
|
|
SGCP.BroadCmd = false;
|
|
return;
|
|
}
|
|
if(SGCP.MasStatus == MAS_STATUS_IDLE)
|
|
{
|
|
SGCP.MasStatus = MAS_STATUS_READ_SENSOR;
|
|
}
|
|
break;}
|
|
|
|
case MDTOSD_CMD_INQUIRE:{
|
|
if(SGCP.BroadCmd == true)
|
|
{
|
|
SGCP.BroadCmd = false;
|
|
return;
|
|
}
|
|
if(SGCP.MasStatus == MAS_STATUS_IDLE)
|
|
{
|
|
SGCP.MasStatus = MAS_STATUS_DEVICE_INQUIRE;
|
|
}
|
|
break;}
|
|
|
|
case MDTOSD_CMD_SET_COL_TIME:{
|
|
uint32_t temp;
|
|
temp = PayLoad[0];
|
|
temp |= (PayLoad[1] << 8);
|
|
if(temp < 1 || temp > 7200)
|
|
{
|
|
DBG_LOG("CollectInterval Err\r\n");
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
App.Para.Layout.CollectTime = temp;
|
|
SAVE_APP_PARA((uint32_t *)&App.Para);
|
|
if(App.Para.Layout.CollectTime >= 30)
|
|
RTCInit(30);//定时采集时间重新初始化
|
|
else
|
|
RTCInit(App.Para.Layout.CollectTime);//定时采集时间重新初始化
|
|
if(SGCP.MasStatus == MAS_STATUS_IDLE)
|
|
{
|
|
SGCP.MasStatus = MAS_STATUS_SET_COL_TIME;
|
|
}
|
|
}
|
|
break;}
|
|
|
|
case MDTOSD_CMD_SYNC_TIME:{
|
|
uint32_t temp;
|
|
temp = PayLoad[0];
|
|
temp |= (PayLoad[1] << 8);
|
|
temp |= (PayLoad[2] << 16);
|
|
temp |= (PayLoad[3] << 24);
|
|
if(temp < 1701173083 || temp > 4102372799)
|
|
{
|
|
DBG_LOG("TimeStamp Err\r\n");
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
App.Para.Layout.TimeStamp = temp;
|
|
SAVE_APP_PARA((uint32_t *)&App.Para);
|
|
TimeSync(App.Para.Layout.TimeStamp); //设置时间
|
|
if(SGCP.MasStatus == MAS_STATUS_IDLE)
|
|
{
|
|
SGCP.MasStatus = MAS_STATUS_SYNC_TIME;
|
|
}
|
|
}
|
|
break;}
|
|
}
|
|
}
|
|
/**
|
|
*******************************************************************************
|
|
** \brief 主设备接收网关数据处理
|
|
**
|
|
** \param 无
|
|
**
|
|
** \retval 无
|
|
******************************************************************************/
|
|
static void GWRevHandler(void)
|
|
{
|
|
uint16_t crc16,Check;
|
|
uint8_t *PayLoad;
|
|
uint16_t PayLoadLen;
|
|
|
|
GatewayFrameHeader GFHeader = (GatewayFrameHeader)SGCP.GatewayBuff;
|
|
|
|
crc16 = (SGCP.GatewayBuff[SGCP.GatewayBuffLen - 1] << 8) | SGCP.GatewayBuff[SGCP.GatewayBuffLen - 2];
|
|
Check = CRC_Modbus(CRC16_BASE, SGCP.GatewayBuff, SGCP.GatewayBuffLen - 2);
|
|
|
|
if(crc16 != Check){
|
|
DBG_LOG("Gateway CRC Err...\r\n");
|
|
return;
|
|
}
|
|
|
|
if(memcmp(GFHeader->MDAddr, LocalMAC, sizeof(GFHeader->MDAddr)) != false)
|
|
{
|
|
if(is_all_byte(GFHeader->MDAddr, sizeof(GFHeader->MDAddr), 0x00) != true)
|
|
{
|
|
DBG_LOG("Gateway Master Device MAC Err...\r\n");
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
SGCP.BroadCmd = true;
|
|
}
|
|
}
|
|
|
|
|
|
SGCP.GWRS485Rx.rCmdGWToMD = (GWTOMD_CMD_M)GFHeader->Cmd;
|
|
PayLoad = &SGCP.GatewayBuff[sizeof(GatewayFrameHeader_t)];
|
|
LayoutPara LPay = (LayoutPara)PayLoad;
|
|
PayLoadLen = GFHeader->PayloadLen;
|
|
|
|
switch(SGCP.GWRS485Rx.rCmdGWToMD) {
|
|
case GWTOMD_CMD_LOGIN:{
|
|
SGCP.LoginOk = PayLoad[0];
|
|
if(SGCP.LoginOk == true)
|
|
{
|
|
memcpy(GatewayMAC, GFHeader->GWAddr, sizeof(GatewayMAC));
|
|
}
|
|
break;}
|
|
|
|
case GWTOMD_CMD_CALI:{
|
|
if(SGCP.LoginOk == true)
|
|
{
|
|
SGCP.MasterCaliOk = true;
|
|
if(SGCP.GWStatus == GW_STATUS_WAIT_UPLOAD)
|
|
{
|
|
SGCP.UploadOk = true;
|
|
SGCP.NextGWStatus = GW_STATUS_CALI;
|
|
}
|
|
else
|
|
SGCP.GWStatus = GW_STATUS_CALI;
|
|
}
|
|
break;}
|
|
|
|
case GWTOMD_CMD_READ_UPLOAD_SENSOR:{
|
|
if(SGCP.LoginOk == true)
|
|
{
|
|
if(WORK_MODE == 0)
|
|
SGCP.GWStatus = GW_STATUS_READ_SENSOR;
|
|
else if(WORK_MODE == 1)
|
|
{
|
|
if(PayLoadLen == 4)
|
|
{
|
|
App.Para.Layout.TimeStamp = LPay->TimeStamp;
|
|
|
|
int8_t TimeDiff;//时间差
|
|
int RTCTimes = TimeTs();
|
|
TimeDiff = App.Para.Layout.TimeStamp - RTCTimes;
|
|
if(TimeDiff > 1 || TimeDiff < -1)
|
|
{
|
|
TimeSync(App.Para.Layout.TimeStamp); //向通讯单元RTC时间寄存器写入时间网关下发的时间
|
|
}
|
|
SGCP.UploadOk = true;
|
|
SGCP.NextGWStatus = GW_STATUS_IDLE;
|
|
}
|
|
else if(PayLoadLen == 10)
|
|
{
|
|
App.Para.Layout.CollectTime = LPay->CollectTime/30;
|
|
App.Para.Layout.ReportInterval = LPay->ReportInterval * 2;
|
|
App.Para.Layout.ERInterval = LPay->ERInterval * 2;
|
|
App.Para.Layout.ERTime = LPay->ERTime * 2;
|
|
App.Para.Layout.TimeStamp = LPay->TimeStamp;
|
|
|
|
DBG_LOG("The parameters have been updated. CI:%ds, RI:%dmin, EI:%dmin, ET:%dmin\r\n",
|
|
LPay->CollectTime,
|
|
LPay->ReportInterval,
|
|
LPay->ERInterval,
|
|
LPay->ERTime);
|
|
|
|
int8_t TimeDiff;//时间差
|
|
int RTCTimes = TimeTs();
|
|
TimeDiff = App.Para.Layout.TimeStamp - RTCTimes;
|
|
if(TimeDiff > 1 || TimeDiff < -1)
|
|
{
|
|
TimeSync(App.Para.Layout.TimeStamp); //向通讯单元RTC时间寄存器写入时间网关下发的时间
|
|
}
|
|
SGCP.UploadOk = true;
|
|
SGCP.NextGWStatus = GW_STATUS_UPLOAD_SENSOR;
|
|
}
|
|
}
|
|
}
|
|
break;}
|
|
|
|
case GWTOMD_CMD_SET_COL_TIME:{
|
|
if(SGCP.LoginOk == true)
|
|
{
|
|
uint16_t temp;
|
|
temp = PayLoad[0];
|
|
temp |= (PayLoad[1] << 8);
|
|
if(temp < 1 || temp > 7200)
|
|
{
|
|
DBG_LOG("CollectInterval Err\r\n");
|
|
if(SGCP.GWStatus == GW_STATUS_WAIT_UPLOAD)
|
|
{
|
|
SGCP.UploadOk = true;
|
|
SGCP.NextGWStatus = GW_STATUS_IDLE;
|
|
}
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
if(SGCP.GWStatus == GW_STATUS_WAIT_UPLOAD)
|
|
{
|
|
SGCP.UploadOk = true;
|
|
SGCP.NextGWStatus = GW_STATUS_SET_COL_TIME;
|
|
}
|
|
else
|
|
{
|
|
SGCP.GWStatus = GW_STATUS_SET_COL_TIME;
|
|
}
|
|
App.Para.Layout.CollectTime = temp;
|
|
SAVE_APP_PARA((uint32_t *)&App.Para);
|
|
}
|
|
}
|
|
break;}
|
|
|
|
case GWTOMD_CMD_SYNC_TIME:{
|
|
if(SGCP.LoginOk == true)
|
|
{
|
|
uint32_t temp;
|
|
temp = PayLoad[0];
|
|
temp |= (PayLoad[1] << 8);
|
|
temp |= (PayLoad[2] << 16);
|
|
temp |= (PayLoad[3] << 24);
|
|
if(temp < 1701173083 || temp > 4102372799)
|
|
{
|
|
DBG_LOG("TimeStamp Err\r\n");
|
|
if(SGCP.GWStatus == GW_STATUS_WAIT_UPLOAD)
|
|
{
|
|
SGCP.UploadOk = true;
|
|
SGCP.NextGWStatus = GW_STATUS_IDLE;
|
|
}
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
if(SGCP.GWStatus == GW_STATUS_WAIT_UPLOAD)
|
|
{
|
|
SGCP.UploadOk = true;
|
|
SGCP.NextGWStatus = GW_STATUS_SYNC_TIME;
|
|
}
|
|
else
|
|
{
|
|
SGCP.GWStatus = GW_STATUS_SYNC_TIME;
|
|
}
|
|
App.Para.Layout.TimeStamp = temp;
|
|
SAVE_APP_PARA((uint32_t *)&App.Para);
|
|
TimeSync(App.Para.Layout.TimeStamp); //设置时间
|
|
}
|
|
}
|
|
break;}
|
|
|
|
case GWTOMD_CMD_SET_LASER:{
|
|
if(SGCP.LoginOk == true)
|
|
{
|
|
int8_t temp = PayLoad[0];
|
|
if(temp == 1)
|
|
{
|
|
LASER1_ON();
|
|
SGCP.LaserOnOff = true;
|
|
if(SGCP.GWStatus == GW_STATUS_WAIT_UPLOAD)
|
|
{
|
|
SGCP.UploadOk = true;
|
|
SGCP.NextGWStatus = GW_STATUS_LASER_STARES;
|
|
}
|
|
else
|
|
SGCP.GWStatus = GW_STATUS_LASER_STARES;
|
|
}
|
|
else if(temp == 0)
|
|
{
|
|
LASER1_OFF();
|
|
SGCP.LaserOnOff = false;
|
|
if(SGCP.GWStatus == GW_STATUS_WAIT_UPLOAD)
|
|
{
|
|
SGCP.UploadOk = true;
|
|
SGCP.NextGWStatus = GW_STATUS_LASER_STARES;
|
|
}
|
|
else
|
|
SGCP.GWStatus = GW_STATUS_LASER_STARES;
|
|
}
|
|
}
|
|
break;}
|
|
}
|
|
SGCP.Gateway_IRQ_Status = true;
|
|
}
|
|
/**
|
|
*******************************************************************************
|
|
** \brief 内部指令指令数据接收处理
|
|
**
|
|
** \param 无
|
|
**
|
|
** \retval 无
|
|
******************************************************************************/
|
|
static void InRevHandler(void)
|
|
{
|
|
uint16_t crc16,Check;
|
|
uint8_t *PayLoad;
|
|
|
|
InsideFrameHeader IFHeader = (InsideFrameHeader)SGCP.InsideBuff;
|
|
|
|
crc16 = (SGCP.InsideBuff[SGCP.InsideBuffLen - 1] << 8) | SGCP.InsideBuff[SGCP.InsideBuffLen - 2];
|
|
Check = CRC_Modbus(CRC16_BASE, SGCP.InsideBuff, SGCP.InsideBuffLen - 2);
|
|
|
|
if(crc16 != Check)
|
|
{
|
|
DBG_LOG("Inside CRC Err...\r\n");
|
|
return;
|
|
}
|
|
|
|
if(memcmp(IFHeader->MAC, LocalMAC, sizeof(IFHeader->MAC)) != false)
|
|
{
|
|
DBG_LOG("Inside MAC Err...\r\n");
|
|
return;
|
|
}
|
|
|
|
PayLoad = &SGCP.InsideBuff[sizeof(InsideFrameHeader_t)];
|
|
|
|
switch((INSIDE_CMD_M)IFHeader->Cmd) {
|
|
case INSIDE_CMD_UPDATE:{
|
|
memcpy(SGCP.InsidePay, PayLoad, SGCP.InsidePayLen);
|
|
SGCP.InStatus = IN_STATUS_UPDATE;
|
|
break;}
|
|
|
|
case INSIDE_CMD_ALTER_485ADDR:{
|
|
uint8_t temp;
|
|
temp = PayLoad[0];
|
|
if(temp > 16 || temp < 1)
|
|
{
|
|
DBG_LOG("RS485Addr Err\r\n");
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
App.Para.RS485Addr = temp;
|
|
SAVE_APP_PARA((uint32_t *)&App.Para);
|
|
if(SGCP.InStatus == IN_STATUS_IDLE)
|
|
{
|
|
SGCP.InStatus = IN_STATUS_ALTER_485ADDR;
|
|
}
|
|
}
|
|
break;}
|
|
}
|
|
}
|
|
#if (SGCP_SELECT == 0)//本机为单个主设备接多个子设备
|
|
/**
|
|
*******************************************************************************
|
|
** \brief 接收子设备数据状态机
|
|
**
|
|
** \param 无
|
|
**
|
|
** \retval 无
|
|
******************************************************************************/
|
|
void SubRevLoopHandler(void)
|
|
{
|
|
switch(SGCP.SubStatus)
|
|
{
|
|
case SUB_STATUS_IDLE:{
|
|
break;}
|
|
|
|
case SUB_STATUS_BROADCAST_CALI:{
|
|
ToSDCali(0x00);
|
|
SGCP.SubStatus = SUB_STATUS_IDLE;
|
|
break;}
|
|
|
|
case SUB_STATUS_READMASTER_DATA:{
|
|
DBG_LOG("<----------- Cache Updating ----------->\r\n");
|
|
memset(SGCP.DeviceDataBuff, NULL, sizeof(SGCP.DeviceDataBuff));
|
|
SGCP.DeviceReadDataOk = false;
|
|
SGCP.DeviceDataLen = 0;
|
|
SGCP.ReadDataAdd = 0;
|
|
#if (USE_VBAT_AD == 1)
|
|
SGCP.DevData.MasterDev.BatLevel = VBAT_Percentage;
|
|
#else
|
|
SGCP.DevData.MasterDev.BatLevel = 0x00;
|
|
#endif
|
|
#if (SGCP_SELECT == 1 || SGCP_SELECT == 2)
|
|
SX1276LoCalcRssiSnr(&SGCP.DevData.MasterDev.RSSI, &SGCP.DevData.MasterDev.Nsr);
|
|
#else
|
|
SGCP.DevData.MasterDev.RSSI = 0x00;
|
|
SGCP.DevData.MasterDev.Nsr = 0x00;
|
|
#endif
|
|
memcpy(&SGCP.DeviceDataBuff[0], &SGCP.DevData.MasterDev, sizeof(SGCP.DevData.MasterDev));
|
|
|
|
DBG_LOG("Master Device MAC:%02X %02X %02X %02X %02X %02X\r\n",
|
|
SGCP.DeviceMAC[SGCP.ReadDataAdd][0],SGCP.DeviceMAC[SGCP.ReadDataAdd][1],SGCP.DeviceMAC[SGCP.ReadDataAdd][2],
|
|
SGCP.DeviceMAC[SGCP.ReadDataAdd][3],SGCP.DeviceMAC[SGCP.ReadDataAdd][4],SGCP.DeviceMAC[SGCP.ReadDataAdd][5]);
|
|
DBG_LOG("\tBatLevel:%03d, RSSI:%05.2f, Nsr:%05.2f\r\n",SGCP.DevData.MasterDev.BatLevel, SGCP.DevData.MasterDev.RSSI,SGCP.DevData.MasterDev.Nsr);
|
|
SGCP.DeviceDataLen = SGCP.DeviceDataLen + sizeof(SGCP.DevData.MasterDev);
|
|
if(sizeof(LocalDataPack) != 0x00)
|
|
{
|
|
memcpy(&SGCP.DeviceDataBuff[SGCP.DeviceDataLen], LocalDataPack, sizeof(LocalDataPack));
|
|
SGCP.DeviceDataLen = SGCP.DeviceDataLen + DevGetDataMess(LocalType, LocalDataPack);;
|
|
}
|
|
|
|
SGCP.ReadDataAdd++;
|
|
SGCP.SubStatus = SUB_STATUS_READSUBSET_DATA;
|
|
break;}
|
|
|
|
case SUB_STATUS_READSUBSET_DATA:{
|
|
SGCP.SubsetReadDataOk = false;
|
|
SGCP.Subset_IRQ_Status = false;
|
|
ToSDReadData(SGCP.Dev485Addrs[SGCP.ReadDataAdd]);
|
|
SGCP.SD1mSDelayCnt = 100;
|
|
SGCP.SubStatus = SUB_STATUS_WAIT_READSUBSET;
|
|
break;}
|
|
|
|
case SUB_STATUS_WAIT_READSUBSET:{
|
|
if(SGCP.SD1mSDelayCnt <= 0)
|
|
{
|
|
DBG_LOG("\r\nSub485Addrs:%02X\r\n",SGCP.Dev485Addrs[SGCP.ReadDataAdd]);
|
|
DBG_LOG("Subset Device MAC:%02X %02X %02X %02X %02X %02X\r\n",
|
|
SGCP.DeviceMAC[SGCP.ReadDataAdd][0],SGCP.DeviceMAC[SGCP.ReadDataAdd][1],SGCP.DeviceMAC[SGCP.ReadDataAdd][2],
|
|
SGCP.DeviceMAC[SGCP.ReadDataAdd][3],SGCP.DeviceMAC[SGCP.ReadDataAdd][4],SGCP.DeviceMAC[SGCP.ReadDataAdd][5]);
|
|
DBG_LOG("\tDevice Read Data TimeOut!");
|
|
|
|
uint16_t Devtype;
|
|
Devtype = (SGCP.DeviceMAC[SGCP.ReadDataAdd][1] << 8) + SGCP.DeviceMAC[SGCP.ReadDataAdd][0];
|
|
SGCP.DeviceDataLen += DevGetDataMess((DEVICE_TYPE_M)Devtype, NULL);
|
|
SGCP.ReadDataAdd++;
|
|
SGCP.SubStatus = SUB_STATUS_READSUBSET_DATA;
|
|
}
|
|
if(SGCP.Subset_IRQ_Status == true)
|
|
{
|
|
SGCP.Subset_IRQ_Status = false;
|
|
DBG_LOG("\r\nSub485Addrs:%02X\r\n",SGCP.Dev485Addrs[SGCP.ReadDataAdd]);
|
|
DBG_LOG("Subset Device MAC:%02X %02X %02X %02X %02X %02X\r\n",
|
|
SGCP.DeviceMAC[SGCP.ReadDataAdd][0],SGCP.DeviceMAC[SGCP.ReadDataAdd][1],SGCP.DeviceMAC[SGCP.ReadDataAdd][2],
|
|
SGCP.DeviceMAC[SGCP.ReadDataAdd][3],SGCP.DeviceMAC[SGCP.ReadDataAdd][4],SGCP.DeviceMAC[SGCP.ReadDataAdd][5]);
|
|
SubsetRevHandler();
|
|
|
|
uint16_t Devtype;
|
|
Devtype = (SGCP.DeviceMAC[SGCP.ReadDataAdd][1] << 8) + SGCP.DeviceMAC[SGCP.ReadDataAdd][0];
|
|
|
|
if(SGCP.SubsetReadDataOk == false)
|
|
{
|
|
SGCP.DeviceDataLen += DevGetDataMess((DEVICE_TYPE_M)Devtype, NULL);
|
|
DBG_LOG("\tDevice Read Data Err!\r\n");
|
|
}
|
|
if(SGCP.SubsetReadDataOk == true)
|
|
{
|
|
SGCP.SubsetReadDataOk = false;
|
|
SGCP.DeviceDataLen += DevGetDataMess((DEVICE_TYPE_M)Devtype, &SGCP.DeviceDataBuff[SGCP.DeviceDataLen]);
|
|
DBG_LOG("\tDevice Read Data Ok!\r\n");
|
|
}
|
|
SGCP.ReadDataAdd++;
|
|
SGCP.SubStatus = SUB_STATUS_READSUBSET_DATA;
|
|
}
|
|
if(SGCP.ReadDataAdd >= SGCP.DeviceN)
|
|
{
|
|
SGCP.DeviceReadDataOk = true;
|
|
memcpy(SGCP.DeviceData, SGCP.DeviceDataBuff, sizeof(SGCP.DeviceData));
|
|
SGCP.SubStatus = SUB_STATUS_IDLE;
|
|
DBG_LOG("<----------- Cache Updat End ----------->\r\n");
|
|
}
|
|
break;}
|
|
|
|
case SUB_STATUS_MASTER_QUERY:{
|
|
DBG_LOG("<----------- Device Scaning ----------->\r\n");
|
|
SGCP.DeviceN = 0;
|
|
SGCP.Dev485Addr = 0;
|
|
SGCP.DeviceMACOk = false;
|
|
SGCP.Subset_IRQ_Status = false;
|
|
memset(&SGCP.Dev485Addrs, NULL, sizeof(SGCP.Dev485Addrs));
|
|
memset(&SGCP.DeviceMAC, NULL, sizeof(SGCP.DeviceMAC));
|
|
SGCP.Dev485Addrs[SGCP.DeviceN] = SGCP.Dev485Addr;//主设备485
|
|
memcpy(SGCP.DeviceMAC[SGCP.DeviceN], LocalMAC, sizeof(LocalMAC));//主设备MAC
|
|
DBG_LOG("Master Device MAC:%02X %02X %02X %02X %02X %02X\r\n",
|
|
SGCP.DeviceMAC[SGCP.DeviceN][0],SGCP.DeviceMAC[SGCP.DeviceN][1],SGCP.DeviceMAC[SGCP.DeviceN][2],
|
|
SGCP.DeviceMAC[SGCP.DeviceN][3],SGCP.DeviceMAC[SGCP.DeviceN][4],SGCP.DeviceMAC[SGCP.DeviceN][5]);
|
|
SGCP.DeviceN++;
|
|
SGCP.Dev485Addr++;
|
|
SGCP.SubStatus = SUB_STATUS_SUBSET_QUERY;
|
|
break;}
|
|
|
|
case SUB_STATUS_SUBSET_QUERY:{
|
|
SGCP.Subset_IRQ_Status = false;
|
|
SGCP.SubsetMACOk = false;
|
|
ToSDInquire(SGCP.Dev485Addr);
|
|
SGCP.SD1mSDelayCnt = 100;
|
|
SGCP.SubStatus = SUB_STATUS_WAIT_SUBSET_QUERY;
|
|
break;}
|
|
|
|
case SUB_STATUS_WAIT_SUBSET_QUERY:{
|
|
if(SGCP.SD1mSDelayCnt <= 0)
|
|
{
|
|
DBG_LOG("Sub485Addrs:%02X No Device!\r\n",SGCP.Dev485Addr);
|
|
SGCP.Dev485Addr++;
|
|
SGCP.SubStatus = SUB_STATUS_SUBSET_QUERY;
|
|
}
|
|
if(SGCP.Subset_IRQ_Status == true)
|
|
{
|
|
SGCP.Subset_IRQ_Status = false;
|
|
SubsetRevHandler();
|
|
|
|
if(SGCP.SubsetMACOk == false)
|
|
{
|
|
DBG_LOG("Sub485Addrs:%02X Error In Data!",SGCP.Dev485Addr);
|
|
}
|
|
if(SGCP.SubsetMACOk == true)
|
|
{
|
|
SGCP.SubsetMACOk = false;
|
|
SGCP.Dev485Addrs[SGCP.DeviceN] = SGCP.Dev485Addr;
|
|
DBG_LOG("Sub485Addrs:%02X\r\n",SGCP.Dev485Addrs[SGCP.DeviceN]);
|
|
DBG_LOG("Subset MAC:%02X %02X %02X %02X %02X %02X\r\n",
|
|
SGCP.DeviceMAC[SGCP.DeviceN][0],SGCP.DeviceMAC[SGCP.DeviceN][1],SGCP.DeviceMAC[SGCP.DeviceN][2],
|
|
SGCP.DeviceMAC[SGCP.DeviceN][3],SGCP.DeviceMAC[SGCP.DeviceN][4],SGCP.DeviceMAC[SGCP.DeviceN][5]);
|
|
SGCP.DeviceN++;
|
|
}
|
|
SGCP.Dev485Addr++;
|
|
SGCP.SubStatus = SUB_STATUS_SUBSET_QUERY;
|
|
}
|
|
if(SGCP.Dev485Addr >= 16)
|
|
{
|
|
SGCP.SubStatus = SUB_STATUS_IDLE;
|
|
SGCP.DeviceMACOk = true;
|
|
DBG_LOG("Device Number:%02d\r\n",SGCP.DeviceN);
|
|
DBG_LOG("<----------- Device Scan End ----------->\r\n");
|
|
}
|
|
break;}
|
|
|
|
case SUB_STATUS_BROADCAST_SET_COLTIME:{
|
|
ToSDSetColTime(0x00, App.Para.Layout.CollectTime);
|
|
SGCP.SubStatus = SUB_STATUS_IDLE;
|
|
break;}
|
|
|
|
case SUB_STATUS_BROADCAST_SYNC_TIME:{
|
|
ToSDSetColTime(0x00, App.Para.Layout.TimeStamp);
|
|
SGCP.SubStatus = SUB_STATUS_IDLE;
|
|
break;}
|
|
}
|
|
}
|
|
|
|
/**
|
|
*******************************************************************************
|
|
** \brief 接收网关数据状态机
|
|
**
|
|
** \param 无
|
|
**
|
|
** \retval 无
|
|
******************************************************************************/
|
|
void GwRevLoopHandler(void)
|
|
{
|
|
switch(SGCP.GWStatus)
|
|
{
|
|
case GW_STATUS_IDLE:{
|
|
break;}
|
|
|
|
case GW_STATUS_WAIT_SUBIDLE:{
|
|
if(SGCP.GW1mSDelayCnt <= 0)
|
|
{
|
|
DBG_LOG("Subset Be busy!\r\n");
|
|
SGCP.NextSubStatus = SUB_STATUS_IDLE;
|
|
SGCP.GWStatus = GW_STATUS_IDLE;
|
|
}
|
|
if(SGCP.SubStatus == SUB_STATUS_IDLE)
|
|
{
|
|
SGCP.GW1mSDelayCnt = 0;
|
|
SGCP.SubStatus = SGCP.NextSubStatus;
|
|
SGCP.NextSubStatus = SUB_STATUS_IDLE;
|
|
SGCP.GWStatus = GW_STATUS_IDLE;
|
|
}
|
|
break;}
|
|
|
|
case GW_STATUS_LOGIN:{
|
|
SGCP.LoginOk = false;
|
|
SGCP.LoginMess = false;
|
|
SGCP.Gateway_IRQ_Status = false;
|
|
ToGWDevLogin();
|
|
SGCP.GW1mSDelayCnt = 2000;
|
|
SGCP.GWStatus = GW_STATUS_WAIT_LOGIN;
|
|
break;}
|
|
|
|
case GW_STATUS_WAIT_LOGIN:{
|
|
if(SGCP.GW1mSDelayCnt <= 0)
|
|
{
|
|
SGCP.LoginMess = true;
|
|
DBG_LOG("Login Timeout!\r\n");
|
|
SGCP.GWStatus = GW_STATUS_IDLE;
|
|
}
|
|
if(SGCP.Gateway_IRQ_Status == true)
|
|
{
|
|
SGCP.Gateway_IRQ_Status = false;
|
|
|
|
if(SGCP.LoginOk == true)
|
|
{
|
|
DBG_LOG("Login Ok!\r\n");
|
|
}
|
|
else if(SGCP.LoginOk == false)
|
|
{
|
|
DBG_LOG("Login Err!\r\n");
|
|
}
|
|
SGCP.LoginMess = true;
|
|
SGCP.GWStatus = GW_STATUS_IDLE;
|
|
}
|
|
break;}
|
|
|
|
case GW_STATUS_CALI:{
|
|
PrintfMess();
|
|
if(SGCP.BroadCmd == true)
|
|
{
|
|
SGCP.GWStatus = GW_STATUS_WAIT_SUBIDLE;
|
|
SGCP.NextSubStatus = SUB_STATUS_BROADCAST_CALI;
|
|
SGCP.GW1mSDelayCnt = 5000;
|
|
SGCP.BroadCmd = false;
|
|
DBG_LOG("Broad Cali Ok!\r\n");
|
|
}
|
|
else
|
|
{
|
|
SGCP.GWStatus = GW_STATUS_IDLE;
|
|
ToGWCaliRes(SGCP.MasterCaliOk);
|
|
DBG_LOG("Alone Cali Ok!\r\n");
|
|
}
|
|
SGCP.TimingAcquisition = true;//采集新的传感器数据
|
|
break;}
|
|
|
|
case GW_STATUS_READ_SENSOR:{
|
|
PrintfMess();
|
|
ToGWReadDataRes(SGCP.DeviceData);
|
|
DBG_LOG("Upload data Ok!\r\n");
|
|
SGCP.TimingAcquisition = true;//采集新的传感器数据
|
|
SGCP.GWStatus = GW_STATUS_WAIT_SUBIDLE;
|
|
SGCP.NextSubStatus = SUB_STATUS_READMASTER_DATA;
|
|
SGCP.GW1mSDelayCnt = 5000;
|
|
break;}
|
|
|
|
case GW_STATUS_SET_COL_TIME:{
|
|
PrintfMess();
|
|
if(SGCP.BroadCmd == true)
|
|
{
|
|
SGCP.BroadCmd = false;
|
|
DBG_LOG("Broad CollectInterval Set as %04d\r\n",0x00, App.Para.Layout.CollectTime);
|
|
}
|
|
else
|
|
{
|
|
ToGWSetColTimeRes(NULL);
|
|
DBG_LOG("Alone CollectInterval Set as %04d\r\n",0x00, App.Para.Layout.CollectTime);
|
|
}
|
|
SGCP.GWStatus = GW_STATUS_WAIT_SUBIDLE;
|
|
SGCP.NextSubStatus = SUB_STATUS_BROADCAST_SET_COLTIME;
|
|
SGCP.GW1mSDelayCnt = 5000;
|
|
break;}
|
|
|
|
case GW_STATUS_SYNC_TIME:{
|
|
PrintfMess();
|
|
if(SGCP.BroadCmd == true)
|
|
{
|
|
SGCP.BroadCmd = false;
|
|
DBG_LOG("Broad CollectInterval Set as %08d\r\n",App.Para.Layout.TimeStamp);
|
|
}
|
|
|
|
else
|
|
{
|
|
ToGWSyncTimeRes(true);
|
|
DBG_LOG("Alone CollectInterval Set as %08d\r\n",App.Para.Layout.TimeStamp);
|
|
}
|
|
SGCP.GWStatus = GW_STATUS_WAIT_SUBIDLE;
|
|
SGCP.NextSubStatus = SUB_STATUS_BROADCAST_SYNC_TIME;
|
|
SGCP.GW1mSDelayCnt = 5000;
|
|
break;}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/* 中断回调函数 */
|
|
/*****************************************************************************************
|
|
* 函数名称: LORA_RxCallBack
|
|
* 功能描述: Lora数据接收函数
|
|
* 参 数: *rBuff，接收到的字符串
|
|
rlen，接收到的字符串长度
|
|
* 返 回 值: 无
|
|
*****************************************************************************************/
|
|
void LORA_RxCallBack(uint8_t *rBuff, uint8_t rlen)
|
|
{
|
|
// if (rlen > 0 && rBuff[0] == 0x7C && memcmp(&rBuff[7],&Comm_DevAddr[0],6) == 0) // 如果接收到了数据,并且设备地址相同则处理接收到的数据
|
|
// {
|
|
// //< 处理接收到的数据
|
|
// memcpy(App.UpperBuff, rBuff, rlen);
|
|
// App.UpperBuffLen = rlen;
|
|
// App.Upper_IRQ_Status = true;//上位机串口中断
|
|
// }
|
|
}
|
|
|
|
/*****************************************************************************************
|
|
* 函数名称: LPUartRx_CallBack
|
|
* 功能描述: 低功耗串口数据接收函数
|
|
* 参 数: rData，接收到的字节
|
|
* 返 回 值: 无
|
|
*****************************************************************************************/
|
|
void LPUartRx_CallBack(uint8_t rData)
|
|
{
|
|
if(SGCP.LpUart0Delay1mSCnt == 0) {
|
|
SGCP.GWRS485Rx.HeaderFrame = false;
|
|
}
|
|
SGCP.LpUart0Delay1mSCnt = 5;
|
|
if(SGCP.GWRS485Rx.HeaderFrame == false) {
|
|
if(rData == 0x7B || rData == 0x7D) {
|
|
SGCP.GWRS485Rx.HeaderFrame = true;
|
|
SGCP.GWRS485Rx.RxLen = 0;
|
|
SGCP.GWRS485Rx.rPayLen = 0;
|
|
SGCP.InsideBuffLen = 0;
|
|
SGCP.InsidePayLen = 0;
|
|
SGCP.GWRS485Rx.RxBuff[SGCP.GWRS485Rx.RxLen++] = rData;
|
|
}
|
|
}
|
|
else {
|
|
if(SGCP.GWRS485Rx.RxBuff[0] == 0x7B)
|
|
{
|
|
if(SGCP.GWRS485Rx.RxLen == 14) {
|
|
SGCP.GWRS485Rx.rPayLen = rData;
|
|
}
|
|
if(SGCP.GWRS485Rx.RxLen == 15) {
|
|
SGCP.GWRS485Rx.rPayLen |= (rData << 8);
|
|
}
|
|
if(SGCP.GWRS485Rx.rPayLen > 10) { //大于最大负载长度，认为错误
|
|
SGCP.GWRS485Rx.HeaderFrame = false;
|
|
return;
|
|
}
|
|
|
|
SGCP.GWRS485Rx.RxBuff[SGCP.GWRS485Rx.RxLen++] = rData;
|
|
if(SGCP.GWRS485Rx.RxLen >= SGCP.GWRS485Rx.rPayLen + 18) {
|
|
SGCP.GWRS485Rx.HeaderFrame = false;
|
|
if(SGCP.GWRS485Rx.RxLen > 100)
|
|
return;
|
|
|
|
memcpy(SGCP.GatewayBuff, SGCP.GWRS485Rx.RxBuff, SGCP.GWRS485Rx.RxLen);
|
|
SGCP.GatewayBuffLen = SGCP.GWRS485Rx.RxLen;
|
|
if(SGCP.GWRS485Rx.RxBuff[0] == 0x7B) GWRevHandler();//网关数据接收处理
|
|
}
|
|
}
|
|
if(SGCP.GWRS485Rx.RxBuff[0] == 0x7D)
|
|
{
|
|
if(SGCP.GWRS485Rx.RxLen == 8)
|
|
{
|
|
SGCP.InsidePayLen = rData;
|
|
}
|
|
SGCP.GWRS485Rx.RxBuff[SGCP.GWRS485Rx.RxLen++] = rData;
|
|
if(SGCP.GWRS485Rx.RxLen >= SGCP.InsidePayLen + 11)
|
|
{
|
|
SGCP.GWRS485Rx.HeaderFrame = false;
|
|
|
|
memcpy(SGCP.InsideBuff, SGCP.GWRS485Rx.RxBuff, SGCP.GWRS485Rx.RxLen);
|
|
SGCP.InsideBuffLen = SGCP.GWRS485Rx.RxLen;
|
|
if(SGCP.InsideBuff[0] == 0x7D) InRevHandler();//内部指令
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************************
|
|
* 函数名称: Uart1Rx_CallBack
|
|
* 功能描述: 串口1数据接收函数
|
|
* 参 数: rData，接收到的字节
|
|
* 返 回 值: 无
|
|
*****************************************************************************************/
|
|
void Uart1Rx_CallBack(uint8_t rData)
|
|
{
|
|
if(SGCP.Uart1Delay1mSCnt == 0) {
|
|
SGCP.SDRS485Rx.HeaderFrame = false;
|
|
}
|
|
SGCP.Uart1Delay1mSCnt = 5;
|
|
if(SGCP.SDRS485Rx.HeaderFrame == false) {
|
|
if(rData == 0x7C) {
|
|
SGCP.SDRS485Rx.HeaderFrame = true;
|
|
SGCP.SDRS485Rx.RxLen = 0;
|
|
SGCP.SDRS485Rx.rPayLen = 0;
|
|
SGCP.SDRS485Rx.RxBuff[SGCP.SDRS485Rx.RxLen++] = rData;
|
|
}
|
|
}
|
|
else {
|
|
if(SGCP.SDRS485Rx.RxLen == 3) {
|
|
if(rData > 36) { //大于最大负载长度，认为错误
|
|
SGCP.SDRS485Rx.HeaderFrame = false;
|
|
return;
|
|
}
|
|
SGCP.SDRS485Rx.rPayLen = rData;
|
|
}
|
|
|
|
SGCP.SDRS485Rx.RxBuff[SGCP.SDRS485Rx.RxLen++] = rData;
|
|
if(SGCP.SDRS485Rx.RxLen >= SGCP.SDRS485Rx.rPayLen + 6) {
|
|
SGCP.SDRS485Rx.HeaderFrame = false;
|
|
if(SGCP.SDRS485Rx.RxLen > 100)
|
|
return;
|
|
|
|
memcpy(SGCP.SubsetBuff, SGCP.SDRS485Rx.RxBuff, SGCP.SDRS485Rx.RxLen);
|
|
SGCP.SubsetBuffLen = SGCP.SDRS485Rx.RxLen;
|
|
if(SGCP.SDRS485Rx.RxBuff[0] == 0x7C) SGCP.Subset_IRQ_Status = true;//子设备串口中断
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if (SGCP_SELECT == 1)//本机为单个主设备
|
|
#if (LocalType == LASER_TRACING)
|
|
/**
|
|
*******************************************************************************
|
|
** \brief 网关激光状态回应
|
|
**
|
|
** \param Ok_Err 成功失败标志位
|
|
**
|
|
** \retval 无
|
|
******************************************************************************/
|
|
static void ToGWLaserRes(bool Ok_Err)
|
|
{
|
|
uint8_t Pack[256];
|
|
uint16_t Crc16;
|
|
uint8_t Len;
|
|
|
|
GatewayFrameHeader GFHeader = (GatewayFrameHeader)Pack;
|
|
|
|
GFHeader->Header = 0x7B;
|
|
memcpy(&GFHeader->GWAddr[0], &GatewayMAC[0], sizeof(GFHeader->GWAddr));
|
|
memcpy(&GFHeader->MDAddr[0], &LocalMAC[0], sizeof(GFHeader->MDAddr));
|
|
GFHeader->Cmd = GWTOMD_CMD_SET_LASER;
|
|
GFHeader->PayloadLen = sizeof(Ok_Err);
|
|
|
|
Len = sizeof(GatewayFrameHeader_t);
|
|
|
|
Pack[Len++] = Ok_Err;
|
|
|
|
Crc16 = CRC_Modbus(CRC16_BASE, Pack, Len);
|
|
Pack[Len++] = Crc16 & 0x00ff;
|
|
Pack[Len++] = (Crc16 >> 8) & 0x00ff;
|
|
|
|
SGCP.GWRS485Rx.sCmdMDToGW = (GWTOMD_CMD_M)GFHeader->Cmd;
|
|
#if(SGCP_SELECT == 1 || SGCP_SELECT == 2)
|
|
Sx1276LoRaSendBuffer(Pack, Len);
|
|
#endif
|
|
#if(SGCP_SELECT == 3)
|
|
LPUart0SendArray(Pack, Len);
|
|
#endif
|
|
}
|
|
#endif
|
|
/**
|
|
*******************************************************************************
|
|
** \brief 接收网关数据状态机
|
|
**
|
|
** \param 无
|
|
**
|
|
** \retval 无
|
|
******************************************************************************/
|
|
void GwRevLoopHandler(void)
|
|
{
|
|
switch(SGCP.GWStatus)
|
|
{
|
|
case GW_STATUS_IDLE:{
|
|
break;}
|
|
|
|
case GW_STATUS_WAIT_SUBIDLE:{
|
|
SGCP.GWStatus = GW_STATUS_IDLE;
|
|
break;}
|
|
|
|
case GW_STATUS_LOGIN:{
|
|
SGCP.DeviceN = 0;
|
|
SGCP.Dev485Addr = 0;
|
|
memset(&SGCP.Dev485Addrs, NULL, sizeof(SGCP.Dev485Addrs));
|
|
memset(&SGCP.DeviceMAC, NULL, sizeof(SGCP.DeviceMAC));
|
|
SGCP.Dev485Addrs[SGCP.DeviceN] = SGCP.Dev485Addr;//主设备485
|
|
memcpy(SGCP.DeviceMAC[SGCP.DeviceN], LocalMAC, sizeof(LocalMAC));//主设备MAC
|
|
DBG_LOG("Master Device MAC:%02X %02X %02X %02X %02X %02X\r\n",
|
|
SGCP.DeviceMAC[SGCP.DeviceN][0],SGCP.DeviceMAC[SGCP.DeviceN][1],SGCP.DeviceMAC[SGCP.DeviceN][2],
|
|
SGCP.DeviceMAC[SGCP.DeviceN][3],SGCP.DeviceMAC[SGCP.DeviceN][4],SGCP.DeviceMAC[SGCP.DeviceN][5]);
|
|
SGCP.DeviceN++;
|
|
SGCP.LoginOk = false;
|
|
SGCP.LoginMess = false;
|
|
SGCP.Gateway_IRQ_Status = false;
|
|
ToGWDevLogin();
|
|
SGCP.GW1mSDelayCnt = 2000;
|
|
SGCP.GWStatus = GW_STATUS_WAIT_LOGIN;
|
|
break;}
|
|
|
|
case GW_STATUS_WAIT_LOGIN:{
|
|
if(SGCP.GW1mSDelayCnt <= 0)
|
|
{
|
|
SGCP.LoginMess = true;
|
|
DBG_LOG("Login Timeout!\r\n");
|
|
SGCP.GWStatus = GW_STATUS_IDLE;
|
|
break;
|
|
}
|
|
if(SGCP.Gateway_IRQ_Status == true)
|
|
{
|
|
SGCP.Gateway_IRQ_Status = false;
|
|
if(SGCP.LoginOk == true)
|
|
{
|
|
DBG_LOG("Login Ok!\r\n");
|
|
/*注册后传感器需立即更新数据*/
|
|
SGCP.TimingAcquisition = true;//采集新的传感器数据
|
|
}
|
|
if(SGCP.LoginOk == false)
|
|
{
|
|
DBG_LOG("Login Err!\r\n");
|
|
}
|
|
SGCP.LoginMess = true;
|
|
SGCP.GWStatus = GW_STATUS_IDLE;
|
|
}
|
|
break;}
|
|
|
|
case GW_STATUS_CALI:{
|
|
PrintfMess();
|
|
if(SGCP.BroadCmd == true)
|
|
{
|
|
SGCP.BroadCmd = false;
|
|
DBG_LOG("Broad Cali Ok!\r\n");
|
|
}
|
|
else
|
|
{
|
|
ToGWCaliRes(SGCP.MasterCaliOk);
|
|
DBG_LOG("Alone Cali Ok!\r\n");
|
|
}
|
|
SGCP.TimingAcquisition = true;//采集新的传感器数据
|
|
SGCP.GWStatus = GW_STATUS_IDLE;
|
|
break;}
|
|
|
|
case GW_STATUS_READ_SENSOR:{
|
|
PrintfMess();
|
|
|
|
SGCP.DeviceDataLen = 0;
|
|
memset(SGCP.DeviceData, NULL, sizeof(SGCP.DeviceData));
|
|
#if (USE_VBAT_AD == 1)
|
|
SGCP.DevData.LaserTracing.MasterDev.BatLevel = VBAT_Percentage;
|
|
#else
|
|
SGCP.DevData.LaserTracing.MasterDev.BatLevel = 0x00;
|
|
#endif
|
|
#if (SGCP_SELECT == 1 || SGCP_SELECT == 2)
|
|
SX1276LoCalcRssiSnr(&SGCP.DevData.LaserTracing.MasterDev.RSSI, &SGCP.DevData.LaserTracing.MasterDev.Nsr);//获取信号强度
|
|
#else
|
|
SGCP.DevData.LaserTracing.MasterDev.RSSI = 0x00;
|
|
SGCP.DevData.LaserTracing.MasterDev.Nsr = 0x00;
|
|
#endif
|
|
memcpy(&SGCP.DeviceData[0], &SGCP.DevData.LaserTracing.MasterDev, sizeof(SGCP.DevData.LaserTracing.MasterDev));
|
|
|
|
DBG_LOG("Master Device MAC:%02X %02X %02X %02X %02X %02X\r\n",
|
|
SGCP.DeviceMAC[SGCP.ReadDataAdd][0],SGCP.DeviceMAC[SGCP.ReadDataAdd][1],SGCP.DeviceMAC[SGCP.ReadDataAdd][2],
|
|
SGCP.DeviceMAC[SGCP.ReadDataAdd][3],SGCP.DeviceMAC[SGCP.ReadDataAdd][4],SGCP.DeviceMAC[SGCP.ReadDataAdd][5]);
|
|
DBG_LOG("\tBatLevel:%03d, RSSI:%05.2f, Nsr:%05.2f\r\n",SGCP.DevData.LaserTracing.MasterDev.BatLevel, SGCP.DevData.LaserTracing.MasterDev.RSSI,SGCP.DevData.LaserTracing.MasterDev.Nsr);
|
|
memcpy(&SGCP.DeviceData[SGCP.DeviceDataLen], &SGCP.DevData.LaserTracing.MasterDev, sizeof(SGCP.DevData.LaserTracing.MasterDev));
|
|
SGCP.DeviceDataLen += sizeof(SGCP.DevData.LaserTracing.MasterDev);
|
|
|
|
if(is_all_byte(LocalDataPack, LocalDataLen, 0x00) == false)
|
|
{
|
|
memcpy(&SGCP.DeviceData[SGCP.DeviceDataLen], LocalDataPack, sizeof(LocalDataPack));
|
|
SGCP.DeviceDataLen = SGCP.DeviceDataLen + DevGetDataMess(LocalType, LocalDataPack);;
|
|
}
|
|
ToGWReadDataRes(SGCP.DeviceData);
|
|
DBG_LOG("Upload data Ok!\r\n");
|
|
/*上传完数据后传感器需立即更新数据*/
|
|
SGCP.TimingAcquisition = true;//采集新的传感器数据
|
|
SGCP.GWStatus = GW_STATUS_IDLE;
|
|
break;}
|
|
|
|
case GW_STATUS_SET_COL_TIME:{
|
|
PrintfMess();
|
|
if(SGCP.BroadCmd == true)
|
|
{
|
|
SGCP.BroadCmd = false;
|
|
DBG_LOG("Broad CollectInterval Set as %04d\r\n",0x00, App.Para.Layout.CollectTime);
|
|
}
|
|
else
|
|
{
|
|
ToGWSetColTimeRes(true);
|
|
DBG_LOG("Alone CollectInterval Set as %04d\r\n",0x00, App.Para.Layout.CollectTime);
|
|
}
|
|
/*GWRevHandler函数中已经缓存了接收到的采集时间间隔*/
|
|
SGCP.GWStatus = GW_STATUS_IDLE;
|
|
break;}
|
|
|
|
case GW_STATUS_SYNC_TIME:{
|
|
PrintfMess();
|
|
if(SGCP.BroadCmd == true)
|
|
{
|
|
SGCP.BroadCmd = false;
|
|
DBG_LOG("Broad time synchronization %08d\r\n",App.Para.Layout.TimeStamp);
|
|
}
|
|
else
|
|
{
|
|
ToGWSyncTimeRes(true);
|
|
DBG_LOG("Alone time synchronization %08d\r\n",App.Para.Layout.TimeStamp);
|
|
}
|
|
/*GWRevHandler函数中已经同步了接收到的时间戳*/
|
|
SGCP.GWStatus = GW_STATUS_IDLE;
|
|
break;}
|
|
|
|
case GW_STATUS_UPLOAD_SENSOR:{
|
|
DBG_LOG("Uploading data...\r\n");
|
|
SGCP.DeviceDataLen = 0;
|
|
memset(SGCP.DeviceData, NULL, sizeof(SGCP.DeviceData));
|
|
|
|
DBG_LOG("Master Device MAC:%02X %02X %02X %02X %02X %02X\r\n",
|
|
SGCP.DeviceMAC[SGCP.ReadDataAdd][0],SGCP.DeviceMAC[SGCP.ReadDataAdd][1],SGCP.DeviceMAC[SGCP.ReadDataAdd][2],
|
|
SGCP.DeviceMAC[SGCP.ReadDataAdd][3],SGCP.DeviceMAC[SGCP.ReadDataAdd][4],SGCP.DeviceMAC[SGCP.ReadDataAdd][5]);
|
|
|
|
if(is_all_byte(LocalDataPack, LocalDataLen, 0x00) == false)
|
|
{
|
|
memcpy(&SGCP.DeviceData[SGCP.DeviceDataLen], LocalDataPack, sizeof(LocalDataPack));
|
|
SGCP.DeviceDataLen = DevGetDataMess(LocalType, LocalDataPack);
|
|
}
|
|
SGCP.UploadOk = false;
|
|
SGCP.UploadMess = false;
|
|
SGCP.Gateway_IRQ_Status = false;
|
|
ToGWReadDataRes(SGCP.DeviceData);
|
|
SGCP.GW1mSDelayCnt = 2000;
|
|
SGCP.GWStatus = GW_STATUS_WAIT_UPLOAD;
|
|
break;}
|
|
|
|
case GW_STATUS_WAIT_UPLOAD:{
|
|
if(SGCP.GW1mSDelayCnt <= 0)
|
|
{
|
|
SGCP.UploadMess = true;
|
|
DBG_LOG("\r\nUpload timeout!\r\n");
|
|
SGCP.GWStatus = SGCP.NextGWStatus;
|
|
break;
|
|
}
|
|
if(SGCP.Gateway_IRQ_Status == true)
|
|
{
|
|
SGCP.Gateway_IRQ_Status = false;
|
|
if(SGCP.UploadOk == true)
|
|
{
|
|
DBG_LOG("\r\nUpload data ok!\r\n");
|
|
/*上传完数据后传感器需立即更新数据*/
|
|
SGCP.TimingAcquisition = true;//采集新的传感器数据
|
|
}
|
|
else if(SGCP.UploadOk == false)
|
|
{
|
|
DBG_LOG("\r\nUpload data err!\r\n");
|
|
}
|
|
SGCP.UploadMess = true;
|
|
SGCP.GWStatus = SGCP.NextGWStatus;
|
|
}
|
|
break;}
|
|
|
|
case GW_STATUS_LASER_STARES:{
|
|
PrintfMess();
|
|
if(SGCP.LaserOnOff == true)
|
|
{
|
|
ToGWLaserRes(SGCP.LaserOnOff);
|
|
DBG_LOG("The laser has been activated!\r\n");
|
|
}
|
|
else if(SGCP.LaserOnOff == false)
|
|
{
|
|
ToGWLaserRes(SGCP.LaserOnOff);
|
|
DBG_LOG("The laser has been turned off!\r\n");
|
|
}
|
|
SGCP.GWStatus = GW_STATUS_IDLE;
|
|
break;}
|
|
}
|
|
}
|
|
|
|
/* 中断回调函数 */
|
|
/*****************************************************************************************
|
|
* 函数名称: LORA_RxCallBack
|
|
* 功能描述: Lora数据接收函数
|
|
* 参 数: *rBuff，接收到的字符串
|
|
rlen，接收到的字符串长度
|
|
* 返 回 值: 无
|
|
*****************************************************************************************/
|
|
void LORA_RxCallBack(uint8_t *rBuff, uint8_t rlen)
|
|
{
|
|
if (rlen > 0 && rBuff[0] == 0x7B && memcmp(&rBuff[7],&LocalMAC[0],6) == 0) // 如果接收到了数据,并且设备地址相同则处理接收到的数据
|
|
{
|
|
//< 处理接收到的数据
|
|
memcpy(SGCP.GatewayBuff, rBuff, rlen);
|
|
SGCP.GatewayBuffLen = rlen;
|
|
GWRevHandler();//网关数据接收处理
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************************
|
|
* 函数名称: LPUartRx_CallBack
|
|
* 功能描述: 低功耗串口数据接收函数
|
|
* 参 数: rData，接收到的字节
|
|
* 返 回 值: 无
|
|
*****************************************************************************************/
|
|
void LPUartRx_CallBack(uint8_t rData)
|
|
{
|
|
if(SGCP.LpUart0Delay1mSCnt == 0) {
|
|
SGCP.GWRS485Rx.HeaderFrame = false;
|
|
}
|
|
SGCP.LpUart0Delay1mSCnt = 5;
|
|
if(SGCP.GWRS485Rx.HeaderFrame == false) {
|
|
if(rData == 0x7B || rData == 0x7D) {
|
|
SGCP.GWRS485Rx.HeaderFrame = true;
|
|
SGCP.GWRS485Rx.RxLen = 0;
|
|
SGCP.GWRS485Rx.rPayLen = 0;
|
|
SGCP.InsideBuffLen = 0;
|
|
SGCP.InsidePayLen = 0;
|
|
SGCP.GWRS485Rx.RxBuff[SGCP.GWRS485Rx.RxLen++] = rData;
|
|
}
|
|
}
|
|
else {
|
|
if(SGCP.GWRS485Rx.RxBuff[0] == 0x7B)
|
|
{
|
|
if(SGCP.GWRS485Rx.RxLen == 14) {
|
|
SGCP.GWRS485Rx.rPayLen = rData;
|
|
}
|
|
if(SGCP.GWRS485Rx.RxLen == 15) {
|
|
SGCP.GWRS485Rx.rPayLen |= (rData << 8);
|
|
}
|
|
if(SGCP.GWRS485Rx.rPayLen > 10) { //大于最大负载长度，认为错误
|
|
SGCP.GWRS485Rx.HeaderFrame = false;
|
|
return;
|
|
}
|
|
|
|
SGCP.GWRS485Rx.RxBuff[SGCP.GWRS485Rx.RxLen++] = rData;
|
|
if(SGCP.GWRS485Rx.RxLen >= SGCP.GWRS485Rx.rPayLen + 18) {
|
|
SGCP.GWRS485Rx.HeaderFrame = false;
|
|
if(SGCP.GWRS485Rx.RxLen > 100)
|
|
return;
|
|
|
|
memcpy(SGCP.GatewayBuff, SGCP.GWRS485Rx.RxBuff, SGCP.GWRS485Rx.RxLen);
|
|
SGCP.GatewayBuffLen = SGCP.GWRS485Rx.RxLen;
|
|
if(SGCP.GWRS485Rx.RxBuff[0] == 0x7B) GWRevHandler();//网关数据接收处理
|
|
}
|
|
}
|
|
if(SGCP.GWRS485Rx.RxBuff[0] == 0x7D)
|
|
{
|
|
if(SGCP.GWRS485Rx.RxLen == 8)
|
|
{
|
|
SGCP.InsidePayLen = rData;
|
|
}
|
|
SGCP.GWRS485Rx.RxBuff[SGCP.GWRS485Rx.RxLen++] = rData;
|
|
if(SGCP.GWRS485Rx.RxLen >= SGCP.InsidePayLen + 11)
|
|
{
|
|
SGCP.GWRS485Rx.HeaderFrame = false;
|
|
|
|
memcpy(SGCP.InsideBuff, SGCP.GWRS485Rx.RxBuff, SGCP.GWRS485Rx.RxLen);
|
|
SGCP.InsideBuffLen = SGCP.GWRS485Rx.RxLen;
|
|
if(SGCP.GWRS485Rx.RxBuff[0] == 0x7D) InRevHandler();//内部指令
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************************
|
|
* 函数名称: Uart1Rx_CallBack
|
|
* 功能描述: 串口1数据接收函数
|
|
* 参 数: rData，接收到的字节
|
|
* 返 回 值: 无
|
|
*****************************************************************************************/
|
|
void Uart1Rx_CallBack(uint8_t rData)
|
|
{
|
|
// if(SGCP.Uart1Delay1mSCnt == 0) {
|
|
// SGCP.SDRS485Rx.HeaderFrame = false;
|
|
// }
|
|
// SGCP.Uart1Delay1mSCnt = 5;
|
|
// if(SGCP.SDRS485Rx.HeaderFrame == false) {
|
|
// if(rData == 0x7C) {
|
|
// SGCP.SDRS485Rx.HeaderFrame = true;
|
|
// SGCP.SDRS485Rx.RxLen = 0;
|
|
// SGCP.SDRS485Rx.rPayLen = 0;
|
|
// SGCP.SDRS485Rx.RxBuff[SGCP.SDRS485Rx.RxLen++] = rData;
|
|
// }
|
|
// }
|
|
// else {
|
|
// if(SGCP.SDRS485Rx.RxLen == 3) {
|
|
// if(rData > 36) { //大于最大负载长度，认为错误
|
|
// SGCP.SDRS485Rx.HeaderFrame = false;
|
|
// return;
|
|
// }
|
|
// SGCP.SDRS485Rx.rPayLen = rData;
|
|
// }
|
|
//
|
|
// SGCP.SDRS485Rx.RxBuff[SGCP.SDRS485Rx.RxLen++] = rData;
|
|
// if(SGCP.SDRS485Rx.RxLen >= SGCP.SDRS485Rx.rPayLen + 6) {
|
|
// SGCP.SDRS485Rx.HeaderFrame = false;
|
|
// if(SGCP.SDRS485Rx.RxLen > 100)
|
|
// return;
|
|
|
|
// memcpy(SGCP.SubsetBuff, SGCP.SDRS485Rx.RxBuff, SGCP.SDRS485Rx.RxLen);
|
|
// SGCP.SubsetBuffLen = SGCP.SDRS485Rx.RxLen;
|
|
// if(SGCP.SDRS485Rx.RxBuff[0] == 0x7C) SGCP.Subset_IRQ_Status = true;//子设备串口中断
|
|
// }
|
|
// }
|
|
}
|
|
#endif
|
|
|
|
#if (SGCP_SELECT == 2)//本机为单个子设备
|
|
/**
|
|
*******************************************************************************
|
|
** \brief 接收主设备数据状态机
|
|
**
|
|
** \param 无
|
|
**
|
|
** \retval 无
|
|
******************************************************************************/
|
|
void MasRevLoopHandler(void)
|
|
{
|
|
switch(SGCP.MasStatus)
|
|
{
|
|
case MAS_STATUS_IDLE:{
|
|
break;}
|
|
|
|
case MAS_STATUS_CALI:{
|
|
PrintfMess();
|
|
if(SGCP.BroadCmd == true)
|
|
{
|
|
SGCP.BroadCmd = false;
|
|
DBG_LOG("Broad Cail!\r\n");
|
|
}
|
|
else
|
|
{
|
|
ToMDCaliRes(App.Para.Layout.RS485Addr, SGCP.SubsetCaliOk);
|
|
DBG_LOG("Alone Cail!\r\n");
|
|
}
|
|
SGCP.TimingAcquisition = true;//采集新的传感器数据
|
|
SGCP.MasStatus = MAS_STATUS_IDLE;
|
|
break;}
|
|
|
|
case MAS_STATUS_READ_SENSOR:{
|
|
PrintfMess();
|
|
|
|
SGCP.DeviceDataLen = 0;
|
|
memset(SGCP.DeviceData, NULL, sizeof(SGCP.DeviceData));
|
|
DBG_LOG("Sub485Addr:%02X\r\n",App.Para.Layout.RS485Addr);
|
|
|
|
if(sizeof(LocalDataPack) != 0x00)
|
|
{
|
|
memcpy(&SGCP.DeviceData[SGCP.DeviceDataLen], LocalDataPack, sizeof(LocalDataPack));
|
|
SGCP.DeviceDataLen = SGCP.DeviceDataLen + DevGetDataMess(LocalType, LocalDataPack);;
|
|
}
|
|
|
|
ToMDReadDataRes(App.Para.Layout.RS485Addr, SGCP.DeviceData, SGCP.DeviceDataLen);
|
|
DBG_LOG("Upload Sensor Data Ok!\r\n");
|
|
SGCP.TimingAcquisition = true;//采集新的传感器数据
|
|
SGCP.MasStatus = MAS_STATUS_IDLE;
|
|
break;}
|
|
|
|
case MAS_STATUS_DEVICE_INQUIRE:{
|
|
PrintfMess();
|
|
ToMDInquireRes(App.Para.Layout.RS485Addr);
|
|
DBG_LOG("Device Inquire!\r\n");
|
|
SGCP.MasStatus = MAS_STATUS_IDLE;
|
|
break;}
|
|
|
|
case MAS_STATUS_SET_COL_TIME:{
|
|
PrintfMess();
|
|
if(SGCP.BroadCmd == true)
|
|
{
|
|
SGCP.BroadCmd = false;
|
|
DBG_LOG("Broad Set Col Time!\r\n");
|
|
}
|
|
else
|
|
{
|
|
|
|
ToMDSetColTimeRes(App.Para.Layout.RS485Addr, true);
|
|
DBG_LOG("Alone Set Col Time!\r\n");
|
|
}
|
|
SGCP.MasStatus = MAS_STATUS_IDLE;
|
|
break;}
|
|
|
|
case MAS_STATUS_SYNC_TIME:{
|
|
PrintfMess();
|
|
if(SGCP.BroadCmd == true)
|
|
{
|
|
SGCP.BroadCmd = false;
|
|
DBG_LOG("Broad Sync Time!\r\n");
|
|
}
|
|
else
|
|
{
|
|
ToMDSyncTimeRes(App.Para.Layout.RS485Addr, true);
|
|
DBG_LOG("Alone Sync Time!\r\n");
|
|
}
|
|
SGCP.MasStatus = MAS_STATUS_IDLE;
|
|
break;}
|
|
}
|
|
}
|
|
/* 中断回调函数 */
|
|
/*****************************************************************************************
|
|
* 函数名称: LORA_RxCallBack
|
|
* 功能描述: Lora数据接收函数
|
|
* 参 数: *rBuff，接收到的字符串
|
|
rlen，接收到的字符串长度
|
|
* 返 回 值: 无
|
|
*****************************************************************************************/
|
|
void LORA_RxCallBack(uint8_t *rBuff, uint8_t rlen)
|
|
{
|
|
// if (rlen > 0 && rBuff[0] == 0x7C && memcmp(&rBuff[7],&Comm_DevAddr[0],6) == 0) // 如果接收到了数据,并且设备地址相同则处理接收到的数据
|
|
// {
|
|
// //< 处理接收到的数据
|
|
// memcpy(App.UpperBuff, rBuff, rlen);
|
|
// App.UpperBuffLen = rlen;
|
|
// App.Upper_IRQ_Status = true;//上位机串口中断
|
|
// }
|
|
}
|
|
|
|
/*****************************************************************************************
|
|
* 函数名称: LPUartRx_CallBack
|
|
* 功能描述: 低功耗串口数据接收函数
|
|
* 参 数: rData，接收到的字节
|
|
* 返 回 值: 无
|
|
*****************************************************************************************/
|
|
void LPUartRx_CallBack(uint8_t rData)
|
|
{
|
|
if(SGCP.LpUart0Delay1mSCnt == 0) {
|
|
SGCP.SDRS485Rx.HeaderFrame = false;
|
|
}
|
|
SGCP.LpUart0Delay1mSCnt = 5;
|
|
if(SGCP.SDRS485Rx.HeaderFrame == false) {
|
|
if(rData == 0x7C || rData == 0x7D) {
|
|
SGCP.SDRS485Rx.HeaderFrame = true;
|
|
SGCP.SDRS485Rx.RxLen = 0;
|
|
SGCP.SDRS485Rx.rPayLen = 0;
|
|
SGCP.InsideBuffLen = 0;
|
|
SGCP.InsidePayLen = 0;
|
|
SGCP.SDRS485Rx.RxBuff[SGCP.SDRS485Rx.RxLen++] = rData;
|
|
}
|
|
}
|
|
else {
|
|
if(SGCP.SDRS485Rx.RxBuff[0] == 0x7C)
|
|
{
|
|
if(SGCP.SDRS485Rx.RxLen == 3) {
|
|
if(rData > 36) { //大于最大负载长度，认为错误
|
|
SGCP.SDRS485Rx.HeaderFrame = false;
|
|
return;
|
|
}
|
|
SGCP.SDRS485Rx.rPayLen = rData;
|
|
}
|
|
|
|
SGCP.SDRS485Rx.RxBuff[SGCP.SDRS485Rx.RxLen++] = rData;
|
|
if(SGCP.SDRS485Rx.RxLen >= SGCP.SDRS485Rx.rPayLen + 6) {
|
|
SGCP.SDRS485Rx.HeaderFrame = false;
|
|
if(SGCP.SDRS485Rx.RxLen > 100)
|
|
return;
|
|
|
|
memcpy(SGCP.SubsetBuff, SGCP.SDRS485Rx.RxBuff, SGCP.SDRS485Rx.RxLen);
|
|
SGCP.SubsetBuffLen = SGCP.SDRS485Rx.RxLen;
|
|
if(SGCP.SDRS485Rx.RxBuff[0] == 0x7C) MasRevHandler();//子设备串口中断
|
|
}
|
|
}
|
|
if(SGCP.SDRS485Rx.RxBuff[0] == 0x7D)
|
|
{
|
|
if(SGCP.SDRS485Rx.RxLen == 8)
|
|
{
|
|
SGCP.InsidePayLen = rData;
|
|
}
|
|
SGCP.SDRS485Rx.RxBuff[SGCP.SDRS485Rx.RxLen++] = rData;
|
|
if(SGCP.SDRS485Rx.RxLen >= SGCP.InsidePayLen + 11)
|
|
{
|
|
SGCP.SDRS485Rx.HeaderFrame = false;
|
|
|
|
memcpy(SGCP.InsideBuff, SGCP.SDRS485Rx.RxBuff, SGCP.SDRS485Rx.RxLen);
|
|
SGCP.InsideBuffLen = SGCP.SDRS485Rx.RxLen;
|
|
if(SGCP.SDRS485Rx.RxBuff[0] == 0x7D) InRevHandler();//内部指令
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/*****************************************************************************************
|
|
* 函数名称: Uart1Rx_CallBack
|
|
* 功能描述: 串口1数据接收函数
|
|
* 参 数: rData，接收到的字节
|
|
* 返 回 值: 无
|
|
*****************************************************************************************/
|
|
void Uart1Rx_CallBack(uint8_t rData)
|
|
{
|
|
// if(SGCP.Uart1Delay1mSCnt == 0) {
|
|
// SGCP.SDRS485Rx.HeaderFrame = false;
|
|
// }
|
|
// SGCP.Uart1Delay1mSCnt = 5;
|
|
// if(SGCP.SDRS485Rx.HeaderFrame == false) {
|
|
// if(rData == 0x7C) {
|
|
// SGCP.SDRS485Rx.HeaderFrame = true;
|
|
// SGCP.SDRS485Rx.RxLen = 0;
|
|
// SGCP.SDRS485Rx.rPayLen = 0;
|
|
// SGCP.SDRS485Rx.RxBuff[SGCP.SDRS485Rx.RxLen++] = rData;
|
|
// }
|
|
// }
|
|
// else {
|
|
// if(SGCP.SDRS485Rx.RxLen == 3) {
|
|
// if(rData > 36) { //大于最大负载长度，认为错误
|
|
// SGCP.SDRS485Rx.HeaderFrame = false;
|
|
// return;
|
|
// }
|
|
// SGCP.SDRS485Rx.rPayLen = rData;
|
|
// }
|
|
//
|
|
// SGCP.SDRS485Rx.RxBuff[SGCP.SDRS485Rx.RxLen++] = rData;
|
|
// if(SGCP.SDRS485Rx.RxLen >= SGCP.SDRS485Rx.rPayLen + 6) {
|
|
// SGCP.SDRS485Rx.HeaderFrame = false;
|
|
// if(SGCP.SDRS485Rx.RxLen > 100)
|
|
// return;
|
|
|
|
// memcpy(SGCP.SubsetBuff, SGCP.SDRS485Rx.RxBuff, SGCP.SDRS485Rx.RxLen);
|
|
// SGCP.SubsetBuffLen = SGCP.SDRS485Rx.RxLen;
|
|
// if(SGCP.SDRS485Rx.RxBuff[0] == 0x7C) SGCP.Subset_IRQ_Status = true;//子设备串口中断
|
|
// }
|
|
// }
|
|
}
|
|
|
|
#endif
|
|
|
|
/**
|
|
*******************************************************************************
|
|
** \brief 内部指令数据状态机
|
|
**
|
|
** \param 无
|
|
**
|
|
** \retval 无
|
|
******************************************************************************/
|
|
void InRevLoopHandler(void)
|
|
{
|
|
switch(SGCP.InStatus)
|
|
{
|
|
case IN_STATUS_IDLE:{
|
|
break;}
|
|
|
|
case IN_STATUS_ALTER_485ADDR:{
|
|
PrintfMess();
|
|
Alter485AddrRes(LocalMAC, true);
|
|
DBG_LOG("Alter RS485Addr:%X\r\n", App.Para.RS485Addr);
|
|
SGCP.InStatus = IN_STATUS_IDLE;
|
|
break;}
|
|
|
|
case IN_STATUS_UPDATE:{
|
|
Update(SGCP.InsidePay);//固件更新.
|
|
memset(SGCP.InsidePay, NULL, sizeof(SGCP.InsidePay));
|
|
SGCP.InStatus = IN_STATUS_IDLE;
|
|
break;}
|
|
}
|
|
}
|
|
/*****************************************************************************************
|
|
* 函数名称: SGCP1mSRoutine
|
|
* 功能描述: SGCP时基循环处理函数
|
|
* 参 数: 无
|
|
* 返 回 值: 无
|
|
*****************************************************************************************/
|
|
void SGCP1mSRoutine(void)
|
|
{
|
|
if(SGCP.LpUart0Delay1mSCnt > 0)
|
|
SGCP.LpUart0Delay1mSCnt--;
|
|
if(SGCP.LoraDelay1mSCnt > 0)
|
|
SGCP.LoraDelay1mSCnt--;
|
|
if(SGCP.Uart1Delay1mSCnt > 0)
|
|
SGCP.Uart1Delay1mSCnt--;
|
|
if(SGCP.SD1mSDelayCnt > 0)
|
|
SGCP.SD1mSDelayCnt--;
|
|
if(SGCP.GW1mSDelayCnt > 0)
|
|
SGCP.GW1mSDelayCnt--;
|
|
if(SGCP.In1mSDelayCnt > 0)
|
|
SGCP.In1mSDelayCnt--;
|
|
}
|
|
|
|
|