YuanHongbin/LaserTracing_Debug
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
7103c8ddfbee1a1355560073b07edede1deb59d8
LaserTracing_Debug/Project/GateWay/source/User/Src/Public.c
T
YuanHongbin 7103c8ddfb 1、增加ExclCommUint_t结构体，用于排除指定通讯单元的MAC 
2、修复了复位后重复定义各项参数的bug。只有从flash读取到的出厂标志位错误时，才会进入配置默认参数判断，否则会以从flash读取到的数据为配置参数
3、增加CheckCommUnitExcl函数，用于查询mac是否被排除

GateWay_Debug:
1、rs485配置函数增加了boot升级使能功能
2、增加了excu、exdel、exls命令，用于配置排除设备的增、删、查
3、para命令增加显示LpCfg参数

sx127x:
1、lora通道选择取消，通过修改频率来修改通道
2026-05-21 17:30:35 +08:00

1197 lines
44 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#include "main.h"
#include "Public.h"
#include "RS485Task.h"
#include "LoraTask.h"
#include "spiflash.h"
#include "CatOneTask.h"
#include <stdlib.h>
//传感器对应的数据长度
const uint8_t SensorTypeDataLen[] = {
0, //0x0000-保留
30, //0x0001-应力场检测单元
12, //0x0002-渗透压检测单元
14, //0x0003-弹性波导检测单元
10, //0x0004-介电质普检测单元
6, //0x0005-微振动
6, //0x0006-三维连续变形检测单元
3, //0x0007-通讯单元
18, //0x0008-三维应力检测单元
9, //0x0009-激光示踪(主设备)
12, //0x000A-水位计
0, //0x000B-保留
0, //0x000C-保留
14, //0x000D-二维应力场检测单元
9, //0x000E-裂缝检测单元
8, //0x0010-姿态检测单元
4, //0x0011-激光位移检测单元
};
/*****************************************************************************************
* 函数名称: CRC_Modbus
* 功能描述: CRC16计算函数
* 参 数: wBase, 多项式
Para，校验数据入口
Data, 校验数据长度入口
* 返 回 值: crc16校验值
*****************************************************************************************/
uint16_t CRC_Modbus(uint16_t wBase, __IO uint8_t *para, uint16_t length)
{
uint16_t crc = 0xffff;
uint16_t index,i;
for(index = 0 ; index < length;index++) {
crc ^= para[index];
for(i = 0; i < 8; i++) {
if(crc & 1) {
crc >>= 1;
crc ^= wBase;
}
else
crc >>= 1;
}
}
return crc;
}
/*****************************************************************************************
* 函数名称: HexToAscii
* 功能描述: HEX转换为ASCII字符串函数
* 参 数: HexData, 16进制数据入口
ASCData，转换后的ASCII数据
sLen, 需要转的16进制数据长度
* 返 回 值: 无
*****************************************************************************************/
void HexToAscii(uint8_t *HexData, char *ASCData, uint8_t sLen)
{
uint8_t temp;
for(int i = 0; i < sLen; i++) {
temp = (HexData[i] >> 4) & 0x0f;
if(temp < 10)
temp += '0';
else
temp = (temp - 10) + 'A';
ASCData[i * 2] = temp;
temp = HexData[i] & 0x0f;
if(temp < 10)
temp += '0';
else
temp = (temp - 10) + 'A';
ASCData[i * 2 + 1] = temp;
}
ASCData[sLen * 2] = 0;
}
/*****************************************************************************************
* 函数名称: AsciiToHex
* 功能描述: AscII字符串转换为16进制数组
* 参 数: ASCData, AscII字符串入口
HexData，转换后的数据
sLen, 需要转的字符串长度
* 返 回 值: 无
*****************************************************************************************/
uint8_t AsciiToHex(char *ASCData, uint8_t *HexData, uint8_t sLen)
{
char chr;
uint8_t HexLen = 0;
if(sLen % 2 == 1)
return 0;
for(int i = 0; i < sLen; i++) {
chr = ASCData[i];
if(chr >= '0' && chr <= '9') {
HexData[HexLen] |= chr - '0';
}
else if(chr >= 'A' && chr <= 'F') {
HexData[HexLen] |= chr - 'A' + 0x0A;
}
else if(chr >= 'a' && chr <= 'f') {
HexData[HexLen] |= chr - 'a' + 0x0A;
}
if(i % 2 == 0) {
HexData[HexLen] <<= 4;
}
else {
HexLen++;
}
}
return HexLen;
}
/*****************************************************************************************
* 函数名称: ReadHistoryData
* 功能描述: 读取历史数据
* 参 数: rData,输入数据
rLen, 输入数据长度
* 返 回 值: 无
*****************************************************************************************/
int ReadHistoryData(LogHeader LogH, uint8_t **Data, int Idx)
{
return ReadLog(LogH, Data, Idx);
}
/*****************************************************************************************
* 函数名称: NetCommOrgData
* 功能描述: 上报数据组织
* 参 数: MegData, 消息队列数据
OutData, 输出数据出口
* 返 回 值: 数据长度
*****************************************************************************************/
int NetCommOrgData(GateWayPara GateWay, uint8_t *MegData, uint8_t *OutData)
{
uint8_t Cmd, *Meg;
uint16_t check;
uint16_t Len;
uint16_t PayloadLen;
PayloadLen = MegData[0] | (MegData[1] << 8);
Cmd = MegData[2];
Meg = &MegData[3];
NetCommFrameHeader NCHeader = (NetCommFrameHeader)OutData;
NCHeader->Header = 0x7A;
memcpy(NCHeader->GWMac, GateWay->ConfigPara.GwMac, 6);
//memcpy(NCHeader->SvrMac, GateWay->SvrMac, 6);
NCHeader->Cmd = Cmd;
NCHeader->BatLevel = GateWay->Battery;
NCHeader->Timestamp = TimeTs();
NCHeader->PacketNum = 1;
NCHeader->PacketIdx = 1;
NCHeader->PayloadLen = PayloadLen;
Len = sizeof(NetCommFrameHeader_t);
memcpy(&OutData[Len], Meg, NCHeader->PayloadLen);
Len += NCHeader->PayloadLen;
check = CRC_Modbus(0xA001, OutData, Len);
OutData[Len++] = check & 0x00ff;
OutData[Len++] = (check >> 8) & 0x00ff;
return Len;
}
/*****************************************************************************************
* 函数名称: CheckCommUnitReg
* 功能描述: 检查设备是否注册
* 参 数: GateWay,网关句柄
CommUnitMac, 待检查的设备MAC
* 返 回 值: 已注册返回非0,没注册返回-1
*****************************************************************************************/
int CheckCommUnitReg(GateWayPara GateWay, uint8_t *CommUnitMac)
{
for(int i = 0; i < COMMUNIT_NUM_MAX; i++) {
if(memcmp(GateWay->ConfigPara.CommUnitArray[i].Mac[0], CommUnitMac, 6) == 0) {
if(GateWay->ConfigPara.CommUnitArray[i].RegFlag == true)
return i;
}
}
return -1;
}
/*****************************************************************************************
* 函数名称: CheckCommUnitExcl
* 功能描述: 检查设备是否排除
* 参 数: GateWay,网关句柄
CommUnitMac, 待检查的设备MAC
* 返 回 值: 已排除返回非0,没排除返回-1
*****************************************************************************************/
int CheckCommUnitExcl(GateWayPara GateWay, uint8_t *CommUnitMac)
{
for(int i = 0; i < COMMUNIT_NUM_MAX; i++) {//判断是否被排除
if(memcmp(GateWay->ConfigPara.ExclCommUnit[i].ExclMac, CommUnitMac, 6) == 0) {
if(GateWay->ConfigPara.ExclCommUnit[i].ExclFlag == true)
return i;
}
}
return -1;
}
/*****************************************************************************************
* 函数名称: CommUnitSendCmd
* 功能描述: 网关下发通讯单元指令函数
* 参 数: GateWay, 网关句柄
CommUnitMac，通讯单元MAC地址
Cmd, 命令字
Payload, 下发数据
PayloadLen， 下发数据长度
* 返 回 值: 无
*****************************************************************************************/
void CommUnitCmdSend(GateWayPara GateWay, uint8_t *CommUnitMac, CommUnitCmd_m Cmd, uint8_t *Payload, uint16_t PayloadLen, SendData Send)
{
uint8_t SendBuff[50];
uint8_t SendLen;
if(PayloadLen > 10)
return;
CommUnitFrameHeader CUHeader = (CommUnitFrameHeader)SendBuff;
CUHeader->Header = 0x7B;
memcpy(CUHeader->GWMac, GateWay->ConfigPara.GwMac, 6);
if(CommUnitMac == NULL) {
memset(CUHeader->DevMac, 0x00, 6);
//CUHeader->DevType = 0x0000;
}
else {
int ret = CheckCommUnitReg(GateWay, CommUnitMac);
if(ret < 0)
return;
memcpy(CUHeader->DevMac, CommUnitMac, 6);
//CUHeader->DevType = GateWay->ConfigPara.CommUnitArray[ret].CUType;
}
CUHeader->Cmd = Cmd;
CUHeader->PayloadLen = PayloadLen;
SendLen = sizeof(CommUnitFrameHeader_t);
if(PayloadLen > 0) {
memcpy(&SendBuff[SendLen], Payload, PayloadLen);
SendLen += PayloadLen;
}
uint16_t crc16 = CRC_Modbus(0xA001, SendBuff, SendLen);
SendBuff[SendLen++] = crc16 & 0x00ff;
SendBuff[SendLen++] = (crc16 >> 8) & 0x00ff;
if(Send != NULL) {
Send(SendBuff, SendLen);
}
}
/*****************************************************************************************
* 函数名称: CommUintOrgData
* 功能描述: 上传传感器数据函数
* 参 数: GWMac,网关mac地址
CUPara, 通讯单元参数
sData, 数据入口
* 返 回 值: 数据长度
*****************************************************************************************/
int CommUintOrgData(GateWayPara GateWay, CommUnitPara CUPara, CommUnitData CUData, uint8_t *sData)
{
uint16_t Len = 0;
uint8_t SensorN = 0;
Len = 3;
memcpy(&sData[3], CUPara->Mac[0], 6);
Len += 6;
sData[Len++] = CUPara->CommStatus;
// sData[Len++] = CUPara->BatLevel;
// sData[Len++] = CUPara->SensorN;
// for(int i = 0; i < SENSOR_NUM_MAX; i++) {
// if(CUPara->SensorType[i] != 0x0000) {
// sData[Len++] = CUPara->SensorType[i] & 0x00ff;
// sData[Len++] = (CUPara->SensorType[i] >> 8) & 0x00ff;
// SensorN++;
// }
// if(SensorN >= CUPara->SensorN)
// break;
// }
// SensorN = 0;
for(int i = 0; i < SENSOR_NUM_MAX; i++) {
if(CUPara->SensorType[i] != 0x0000) {
switch(CUPara->SensorType[i]) {
case FORCE_6D:
memcpy(&sData[Len], CUData->Data[i], sizeof(Force6D_T));
Len += sizeof(Force6D_T);
break;
case OSMOTIC_PRESSURE:
break;
case ELASTIC_WAVEGUIDE:
break;
case DIELECTRIC_MASS:
break;
case VIBRATE_SENSOR:
break;
case CONT_DEFOR_3D:
break;
case COMM_UNIT:
break;
case FORCE_3D:
break;
case LASER_TRACING:
memcpy(&sData[Len], CUData->Data[i], sizeof(LaserTracingType_T));
Len += sizeof(LaserTracingType_T);
break;
case WATER_LEVEL:
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;
case DISPLACEMENT:
memcpy(&sData[Len], CUData->Data[i], sizeof(Displacement_T));
Len += sizeof(Displacement_T);
break;
}
SensorN++;
}
if(SensorN >= CUPara->SensorN)
break;
}
sData[0] = (Len - 3) & 0x00ff;
sData[1] = ((Len - 3) >> 8) & 0x00ff;
sData[2] = NET_COMM_CMD_UPDATE;
return Len;
}
void DebugDisplaySensorData(int SensorIdx, uint16_t SensorType, uint8_t *SensorData)
{
switch(SensorType) {
case SENSOR_TYPE_NULL: {
break;
}
case FORCE_6D: {
Force6D_T Sensor;
memcpy((uint8_t *)&Sensor, SensorData, sizeof(Force6D_T));
MAIN_DBG_LOG("Sensor%d Type %04x: Accx=%d, Accy=%d, Accz=%d, Strain1=%d, Strain2=%d, Strain3=%d, Strain4=%d, Strain5=%d, Strain6=%d\r\n",
SensorIdx, SensorType, Sensor.AccX, Sensor.AccY, Sensor.AccZ,
Sensor.Strain1, Sensor.Strain2, Sensor.Strain3, Sensor.Strain4, Sensor.Strain5, Sensor.Strain6);
break;
}
case OSMOTIC_PRESSURE: {
break;
}
case ELASTIC_WAVEGUIDE:{
break;
}
case DIELECTRIC_MASS:{
break;
}
case VIBRATE_SENSOR:{
break;
}
case CONT_DEFOR_3D:{
break;}
case COMM_UNIT:{
break;
}
case FORCE_3D: {
break;
}
case LASER_TRACING: {
LaserTracingType_T Sensor;
memcpy((uint8_t *)&Sensor, SensorData, sizeof(LaserTracingType_T));
MAIN_DBG_LOG("Sensor%d Type %04x: PitchAngle=%04d, RollAngle=%04d, YawAngle=%04d\r\n",
SensorIdx, SensorType, Sensor.PitchAngle, Sensor.RollAngle, Sensor.YawAngle);
break;
}
case WATER_LEVEL: {
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;
}
case DISPLACEMENT: {
Displacement_T Sensor;
memcpy((uint8_t *)&Sensor, SensorData, sizeof(Displacement_T));
MAIN_DBG_LOG("Sensor%d Type %04x: PitchAngle=%04d, RollAngle=%04d, YawAngle=%04d, Altitude=%06f, Distance=%04d\r\n",
SensorIdx, SensorType, Sensor.PitchAngle, Sensor.RollAngle, Sensor.YawAngle, Sensor.Altitude, Sensor.Distance);
break;
}
default:
break;
}
}
/*****************************************************************************************
* 函数名称: CommUnitAnalyze
* 功能描述: 通讯单元数据解析，使用于LORA和RS485通讯
* 参 数: rData,输入数据
rLen, 输入数据长度
* 返 回 值: 返回接收到的通讯单元序号，错误返回-1
*****************************************************************************************/
int CommUnitAnalyze(GateWayPara GateWay, uint8_t *rData, uint16_t rLen, SendData Response)
{
uint16_t check, crc16;
int CommUnitIdx, ExclCommUnit;
uint16_t PayLoadLen;
uint8_t *PayLoad;
uint8_t *MegData;
uint16_t len;
//uint8_t *Data;
uint16_t CommUintLen;
CommUnitFrameHeader CUHeader = (CommUnitFrameHeader)rData;
PayLoad = &rData[sizeof(CommUnitFrameHeader_t)];
if(CUHeader->Header != 0x7B)
return -1;
check = CRC_Modbus(0xA001, rData, rLen - 2);
crc16 = rData[rLen - 2] | (rData[rLen - 1] << 8);
if(check != crc16)
return -1;
if((CUHeader->Cmd != COMM_UNIT_CMD_REG) && (memcmp(GateWay->ConfigPara.GwMac, CUHeader->GWMac, 6) != 0))
return -1;
CommUnitIdx = CheckCommUnitReg(GateWay, CUHeader->DevMac);//判断是否是已注册的设备
if(CommUnitIdx < 0) {
if(CUHeader->Cmd != COMM_UNIT_CMD_REG){//判断是否是注册请求
return -1;
}
ExclCommUnit = CheckCommUnitExcl(GateWay, CUHeader->DevMac);//判断是否是被排除的设备
if(ExclCommUnit > -1) {
return -1;
}
}
switch(CUHeader->Cmd) {
case COMM_UNIT_CMD_REG:{
if(PayLoad[0] > SENSOR_NUM_MAX) {
return -1;
}
// if(CUHeader->PayloadLen < 2)
// return -1;
if(CommUnitIdx >= 0) { //设备存在
MAIN_DBG_LOG("\r\nCommUnit has already been registered! Mac:%02X-%02X-%02X-%02X-%02X-%02X\r\n",
CUHeader->DevMac[0], CUHeader->DevMac[1], CUHeader->DevMac[2], CUHeader->DevMac[3], CUHeader->DevMac[4], CUHeader->DevMac[5]);
uint8_t ret = 1;
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].CommErrCnt = 0;
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ConfigFlag = true;
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].CailFlag = false;
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].TimeSyncFlag = false;
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ContLaser = false;
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].LaserOnOff = false;
CommUnitCmdSend(GateWay, CUHeader->DevMac, COMM_UNIT_CMD_REG, &ret, 1, Response);
WritePara((uint8_t *)&GateWay->ConfigPara, sizeof(GWConfigPara_t));
return CommUnitIdx;
}
for(int i = 0; i < COMMUNIT_NUM_MAX; i++) {
if(GateWay->ConfigPara.CommUnitArray[i].RegFlag == false) {
CommUnitIdx = i;
GateWay->ConfigPara.CommUnitArray[i].RegFlag = true;
GateWay->ConfigPara.CommUnitArray[i].CommStatus = true;
GateWay->ConfigPara.CommUnitArray[i].CailFlag = false;
GateWay->ConfigPara.CommUnitArray[i].TimeSyncFlag = false;
GateWay->ConfigPara.CommUnitArray[i].ContLaser = false;
GateWay->ConfigPara.CommUnitArray[i].LaserOnOff = false;
GateWay->ConfigPara.CommUnitArray[i].CUType = DEV_TYPE_EXT_COMMUNIT;//外置通讯单元
MAIN_DBG_LOG("\r\nCommUnit register succeed!\r\n");
memcpy(GateWay->ConfigPara.CommUnitArray[i].MasterMac, &PayLoad[1], 6);
MAIN_DBG_LOG("Mac:%02X-%02X-%02X-%02X-%02X-%02X\r\n",CUHeader->DevMac[0], CUHeader->DevMac[1], CUHeader->DevMac[2], CUHeader->DevMac[3], CUHeader->DevMac[4], CUHeader->DevMac[5]);
GateWay->ConfigPara.CommUnitArray[i].SensorN = PayLoad[0];
MAIN_DBG_LOG("SensorN: %d ", GateWay->ConfigPara.CommUnitArray[i].SensorN);
//memcpy(GateWay->ConfigPara.CommUnitArray[i].SensorType, &PayLoad[1], CUHeader->PayloadLen-1);
MAIN_DBG_LOG("Sensor Type: ");
for(int j = 0; j < GateWay->ConfigPara.CommUnitArray[i].SensorN; j++) {
memcpy(GateWay->ConfigPara.CommUnitArray[i].Mac[j], &PayLoad[(j*6)+1], 6);
GateWay->ConfigPara.CommUnitArray[i].SensorType[j] = PayLoad[(j*6)+1] | (PayLoad[(j*6)+2] << 8);
MAIN_DBG_LOG("0x%04x, ", GateWay->ConfigPara.CommUnitArray[i].SensorType[j]);
}
MAIN_DBG_LOG("\r\n");
GateWay->ConfigPara.CommUnitArray[i].CommErrCnt = 0;
GateWay->ConfigPara.CommUnitArray[i].ConfigFlag = true;
GateWay->ConfigPara.CommUnitArray[i].CollectInterval = LW_DEV_COLLECT_INTERVAL_MAX;
GateWay->ConfigPara.CommUnitArray[i].ReportInterval = LW_DEV_REPORT_INTERVAL_MAX;
GateWay->ConfigPara.CommUnitArray[i].ERInterval = LW_DEV_ER_INTERVAL_MAX;
GateWay->ConfigPara.CommUnitArray[i].ERTime = LW_DEV_ER_TIME_MAX;
WritePara((uint8_t *)&GateWay->ConfigPara, sizeof(GWConfigPara_t));
uint8_t ret = 1;
CommUnitCmdSend(GateWay, CUHeader->DevMac, COMM_UNIT_CMD_REG, &ret, 1, Response);
if(GateWay->SvrRegFlag) { //网关已注册，向服务发送新设备添加指令
PayLoadLen = (GateWay->ConfigPara.CommUnitArray[i].SensorN * 6) + 2;
MegData = rt_malloc(PayLoadLen + 3);
MegData[0] = PayLoadLen & 0x00ff;;
MegData[1] = (PayLoadLen >> 8) & 0x00ff;
MegData[2] = NET_COMM_CMD_ADD_UNIT;
for(uint8_t i = 0; i < GateWay->ConfigPara.CommUnitArray[i].SensorN; i++)
{
memcpy(&MegData[3], GateWay->ConfigPara.CommUnitArray[i].Mac[i], 6);
}
CatOneEthSendQueue(MegData, PayLoadLen+3);
rt_free(MegData);
}
return 0xff;
}
}
MAIN_DBG_LOG("\r\nCommUnit register failed! Mac:%02X-%02X-%02X-%02X-%02X-%02X\r\n",
CUHeader->DevMac[0], CUHeader->DevMac[1], CUHeader->DevMac[2], CUHeader->DevMac[3], CUHeader->DevMac[4], CUHeader->DevMac[5]);
break;}
case COMM_UNIT_CMD_CAIL:{
if(PayLoad[0] == 0) {
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].CailFlag = true;
MAIN_DBG_LOG("CommUnit calibrate failed! Mac:%02X-%02X-%02X-%02X-%02X-%02X\r\n",
CUHeader->DevMac[0], CUHeader->DevMac[1], CUHeader->DevMac[2], CUHeader->DevMac[3], CUHeader->DevMac[4], CUHeader->DevMac[5]);
}
else if(PayLoad[0] == 1){
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].CailFlag = false;
MAIN_DBG_LOG("CommUnit calibrate succeed! Mac:%02X-%02X-%02X-%02X-%02X-%02X\r\n",
CUHeader->DevMac[0], CUHeader->DevMac[1], CUHeader->DevMac[2], CUHeader->DevMac[3], CUHeader->DevMac[4], CUHeader->DevMac[5]);
}
uint32_t ctime = TimeTs();
if(GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ConfigFlag == true) {
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ConfigFlag = false;
LPDevConfigPara_t Config;
Config.CollectInterval = GateWay->ConfigPara.CommUnitArray[CommUnitIdx].CollectInterval;
Config.ReportInterval = GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ReportInterval;
Config.ERInterval = GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ERInterval;
Config.ERTime = GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ERTime;
Config.TimeStamp = ctime;
MAIN_DBG_LOG("CI:%d, RI:%d, EI:%d, ET:%d\r\n", Config.CollectInterval, Config.ReportInterval, Config.ERInterval, Config.ERTime);
CommUnitCmdSend(GateWay, CUHeader->DevMac, COMM_UNIT_CMD_READ, (uint8_t *)&Config, sizeof(LPDevConfigPara_t), Response);
}
else if(GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ContLaser == true)
{
if(GateWay->ConfigPara.CommUnitArray[CommUnitIdx].LaserOnOff == true)
{//打开激光
CommUnitCmdSend(GateWay, CUHeader->DevMac, COMM_UNIT_CMD_CONT_LASER, (uint8_t *)&GateWay->ConfigPara.CommUnitArray[CommUnitIdx].LaserOnOff, 1, Response);
}
MAIN_DBG_LOG("Issue laser control commands.\r\n");
}
else if(GateWay->ConfigPara.CommUnitArray[CommUnitIdx].CailFlag == true)
{
CommUnitCmdSend(GateWay, CUHeader->DevMac, COMM_UNIT_CMD_CAIL, 0, 0, Response);
MAIN_DBG_LOG("Issue calibration instructions.\r\n");
}
else if(GateWay->ConfigPara.CommUnitArray[CommUnitIdx].TimeSyncFlag == true)
{
CommUnitCmdSend(GateWay, CUHeader->DevMac, COMM_UNIT_CMD_TIME_SYNC, (uint8_t *)&ctime, 4, Response);
MAIN_DBG_LOG("Issue a time synchronization command.\r\n");
}
WritePara((uint8_t *)&GateWay->ConfigPara, sizeof(GWConfigPara_t));
break;}
case COMM_UNIT_CMD_READ:{
// if(PayLoad[1] > SENSOR_NUM_MAX) {
// return CommUnitIdx;
// }
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].CommStatus = true;
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].RevNewDataFlag = true;
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].CommErrCnt = 0;
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].BatLevel = PayLoad[0];
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].RSSI = PayLoad[1];
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].Nsr = PayLoad[2];
// memset(GateWay->ConfigPara.CommUnitArray[CommUnitIdx].SensorType, 0x00, sizeof(GateWay->ConfigPara.CommUnitArray[CommUnitIdx].SensorType));
// memcpy(GateWay->ConfigPara.CommUnitArray[CommUnitIdx].SensorType, &PayLoad[2], GateWay->ConfigPara.CommUnitArray[CommUnitIdx].SensorN * 2);
// len = 0;
// Data = &PayLoad[GateWay->ConfigPara.CommUnitArray[CommUnitIdx].SensorN * 2 + 2];
// int16_t Rssi;
// int8_t Snr;
// SX1276LoCalcRssiSnr(&Rssi, &Snr);
MAIN_DBG_LOG("\r\nCUMac:%02X-%02X-%02X-%02X-%02X-%02X, Bat: %d%, SN: %d，Rssi:%d, Snr:%d\r\n",
CUHeader->DevMac[0], CUHeader->DevMac[1], CUHeader->DevMac[2], CUHeader->DevMac[3], CUHeader->DevMac[4], CUHeader->DevMac[5],
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].BatLevel,
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].SensorN,
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].RSSI,
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].Nsr);
for(int i = 0; i < GateWay->ConfigPara.CommUnitArray[CommUnitIdx].SensorN; i++) {
memcpy(GateWay->CUDataArray[CommUnitIdx].Data[i], &PayLoad[0], SensorTypeDataLen[GateWay->ConfigPara.CommUnitArray[CommUnitIdx].SensorType[i]]);
//显示传感器数据
DebugDisplaySensorData(i, GateWay->ConfigPara.CommUnitArray[CommUnitIdx].SensorType[i], GateWay->CUDataArray[CommUnitIdx].Data[i]);
len += SensorTypeDataLen[GateWay->ConfigPara.CommUnitArray[CommUnitIdx].SensorType[i]];
}
#ifdef LORA_LOWPOWER
uint32_t ctime = TimeTs();
LPDevConfigPara_t Config;
if(GateWay->ConfigPara.CommUnitArray[CommUnitIdx].CollectInterval > 7200 || GateWay->ConfigPara.CommUnitArray[CommUnitIdx].CollectInterval < 30)
{
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].CollectInterval = 300;
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ConfigFlag = true;
}
if(GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ReportInterval > 720 || GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ReportInterval < 5)
{
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ReportInterval = 20;
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ConfigFlag = true;
}
if(GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ERInterval > 5 || GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ERInterval < 1)
{
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ERInterval = 2;
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ConfigFlag = true;
}
if(GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ERTime > 120 || GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ERTime < 10)
{
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ERTime = 20;
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ConfigFlag = true;
}
if(GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ConfigFlag == true) {
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ConfigFlag = false;
Config.CollectInterval = GateWay->ConfigPara.CommUnitArray[CommUnitIdx].CollectInterval;
Config.ReportInterval = GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ReportInterval;
Config.ERInterval = GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ERInterval;
Config.ERTime = GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ERTime;
Config.TimeStamp = ctime;
MAIN_DBG_LOG("CI:%d, RI:%d, EI:%d, ET:%d\r\n", Config.CollectInterval, Config.ReportInterval, Config.ERInterval, Config.ERTime);
CommUnitCmdSend(GateWay, CUHeader->DevMac, COMM_UNIT_CMD_READ, (uint8_t *)&Config, sizeof(LPDevConfigPara_t), Response);
}
else if(GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ContLaser == true)
{
if(GateWay->ConfigPara.CommUnitArray[CommUnitIdx].LaserOnOff == true)
{//打开激光
CommUnitCmdSend(GateWay, CUHeader->DevMac, COMM_UNIT_CMD_CONT_LASER, (uint8_t *)&GateWay->ConfigPara.CommUnitArray[CommUnitIdx].LaserOnOff, 1, Response);
}
MAIN_DBG_LOG("Issue laser control commands.\r\n");
}
else if(GateWay->ConfigPara.CommUnitArray[CommUnitIdx].CailFlag == true)
{
CommUnitCmdSend(GateWay, CUHeader->DevMac, COMM_UNIT_CMD_CAIL, 0, 0, Response);
MAIN_DBG_LOG("Issue calibration instructions.\r\n");
}
else if(GateWay->ConfigPara.CommUnitArray[CommUnitIdx].TimeSyncFlag == true)
{
CommUnitCmdSend(GateWay, CUHeader->DevMac, COMM_UNIT_CMD_TIME_SYNC, (uint8_t *)&ctime, 4, Response);
MAIN_DBG_LOG("Issue a time synchronization command.\r\n");
}
else
CommUnitCmdSend(GateWay, CUHeader->DevMac, COMM_UNIT_CMD_READ, (uint8_t *)&ctime, 4, Response);
#endif
MegData = rt_malloc(512);
CommUintLen = CommUintOrgData(GateWay, &GateWay->ConfigPara.CommUnitArray[CommUnitIdx], &GateWay->CUDataArray[CommUnitIdx], MegData);
//AddLog(&MegData[2], CommUintLen);
CatOneEthSendQueue(MegData, CommUintLen);
rt_free(MegData);
WritePara((uint8_t *)&GateWay->ConfigPara, sizeof(GWConfigPara_t));
break;}
case COMM_UNIT_CMD_TIME_SYNC:{
if(PayLoad[0] == 0) {
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].TimeSyncFlag = true;
MAIN_DBG_LOG("CommUnit time synchronization failed! Mac:%02X-%02X-%02X-%02X-%02X-%02X\r\n",
CUHeader->DevMac[0], CUHeader->DevMac[1], CUHeader->DevMac[2], CUHeader->DevMac[3], CUHeader->DevMac[4], CUHeader->DevMac[5]);
}
else if(PayLoad[0] == 1){
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].TimeSyncFlag = false;
MAIN_DBG_LOG("CommUnit time synchronization succeed! Mac:%02X-%02X-%02X-%02X-%02X-%02X\r\n",
CUHeader->DevMac[0], CUHeader->DevMac[1], CUHeader->DevMac[2], CUHeader->DevMac[3], CUHeader->DevMac[4], CUHeader->DevMac[5]);
}
uint32_t ctime = TimeTs();
if(GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ConfigFlag == true) {
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ConfigFlag = false;
LPDevConfigPara_t Config;
Config.CollectInterval = GateWay->ConfigPara.CommUnitArray[CommUnitIdx].CollectInterval;
Config.ReportInterval = GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ReportInterval;
Config.ERInterval = GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ERInterval;
Config.ERTime = GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ERTime;
Config.TimeStamp = ctime;
MAIN_DBG_LOG("CI:%d, RI:%d, EI:%d, ET:%d\r\n", Config.CollectInterval, Config.ReportInterval, Config.ERInterval, Config.ERTime);
CommUnitCmdSend(GateWay, CUHeader->DevMac, COMM_UNIT_CMD_READ, (uint8_t *)&Config, sizeof(LPDevConfigPara_t), Response);
}
else if(GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ContLaser == true)
{
if(GateWay->ConfigPara.CommUnitArray[CommUnitIdx].LaserOnOff == true)
{//打开激光
CommUnitCmdSend(GateWay, CUHeader->DevMac, COMM_UNIT_CMD_CONT_LASER, (uint8_t *)&GateWay->ConfigPara.CommUnitArray[CommUnitIdx].LaserOnOff, 1, Response);
}
MAIN_DBG_LOG("Issue laser control commands.\r\n");
}
else if(GateWay->ConfigPara.CommUnitArray[CommUnitIdx].CailFlag == true)
{
CommUnitCmdSend(GateWay, CUHeader->DevMac, COMM_UNIT_CMD_CAIL, 0, 0, Response);
MAIN_DBG_LOG("Issue calibration instructions.\r\n");
}
else if(GateWay->ConfigPara.CommUnitArray[CommUnitIdx].TimeSyncFlag == true)
{
CommUnitCmdSend(GateWay, CUHeader->DevMac, COMM_UNIT_CMD_TIME_SYNC, (uint8_t *)&ctime, 4, Response);
MAIN_DBG_LOG("Issue a time synchronization command.\r\n");
}
WritePara((uint8_t *)&GateWay->ConfigPara, sizeof(GWConfigPara_t));
break;}
case COMM_UNIT_CMD_CONT_LASER:{
if(PayLoad[0] == 0) {
//应答服务器
MegData = rt_malloc(10);
MegData[0] = 7;
MegData[1] = 0;
MegData[2] = NET_COMM_CMD_CONT_LASER;
MegData[3] = CUHeader->DevMac[0];
MegData[4] = CUHeader->DevMac[1];
MegData[5] = CUHeader->DevMac[2];
MegData[6] = CUHeader->DevMac[3];
MegData[7] = CUHeader->DevMac[4];
MegData[8] = CUHeader->DevMac[5];
MegData[9] = PayLoad[0];
CatOneEthSendQueue(MegData, 10);
rt_free(MegData);
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ContLaser = false;
MAIN_DBG_LOG("CommUnit The laser has been turned off! Mac:%02X-%02X-%02X-%02X-%02X-%02X\r\n",
CUHeader->DevMac[0], CUHeader->DevMac[1], CUHeader->DevMac[2], CUHeader->DevMac[3], CUHeader->DevMac[4], CUHeader->DevMac[5]);
}
else if(PayLoad[0] == 1){
//应答服务器
MegData = rt_malloc(10);
MegData[0] = 7;
MegData[1] = 0;
MegData[2] = NET_COMM_CMD_CONT_LASER;
MegData[3] = CUHeader->DevMac[0];
MegData[4] = CUHeader->DevMac[1];
MegData[5] = CUHeader->DevMac[2];
MegData[6] = CUHeader->DevMac[3];
MegData[7] = CUHeader->DevMac[4];
MegData[8] = CUHeader->DevMac[5];
MegData[9] = PayLoad[0];
CatOneEthSendQueue(MegData, 10);
rt_free(MegData);
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ContLaser = false;
MAIN_DBG_LOG("CommUnit The laser has been activated! Mac:%02X-%02X-%02X-%02X-%02X-%02X\r\n",
CUHeader->DevMac[0], CUHeader->DevMac[1], CUHeader->DevMac[2], CUHeader->DevMac[3], CUHeader->DevMac[4], CUHeader->DevMac[5]);
}
uint32_t ctime = TimeTs();
if(GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ConfigFlag == true) {
GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ConfigFlag = false;
LPDevConfigPara_t Config;
Config.CollectInterval = GateWay->ConfigPara.CommUnitArray[CommUnitIdx].CollectInterval;
Config.ReportInterval = GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ReportInterval;
Config.ERInterval = GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ERInterval;
Config.ERTime = GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ERTime;
Config.TimeStamp = ctime;
MAIN_DBG_LOG("CI:%d, RI:%d, EI:%d, ET:%d\r\n", Config.CollectInterval, Config.ReportInterval, Config.ERInterval, Config.ERTime);
CommUnitCmdSend(GateWay, CUHeader->DevMac, COMM_UNIT_CMD_READ, (uint8_t *)&Config, sizeof(LPDevConfigPara_t), Response);
}
else if(GateWay->ConfigPara.CommUnitArray[CommUnitIdx].ContLaser == true)
{
if(GateWay->ConfigPara.CommUnitArray[CommUnitIdx].LaserOnOff == true)
{//打开激光
CommUnitCmdSend(GateWay, CUHeader->DevMac, COMM_UNIT_CMD_CONT_LASER, (uint8_t *)&GateWay->ConfigPara.CommUnitArray[CommUnitIdx].LaserOnOff, 1, Response);
}
MAIN_DBG_LOG("Issue laser control commands.\r\n");
}
else if(GateWay->ConfigPara.CommUnitArray[CommUnitIdx].CailFlag == true)
{
CommUnitCmdSend(GateWay, CUHeader->DevMac, COMM_UNIT_CMD_CAIL, 0, 0, Response);
MAIN_DBG_LOG("Issue calibration instructions.\r\n");
}
else if(GateWay->ConfigPara.CommUnitArray[CommUnitIdx].TimeSyncFlag == true)
{
CommUnitCmdSend(GateWay, CUHeader->DevMac, COMM_UNIT_CMD_TIME_SYNC, (uint8_t *)&ctime, 4, Response);
MAIN_DBG_LOG("Issue a time synchronization command.\r\n");
}
WritePara((uint8_t *)&GateWay->ConfigPara, sizeof(GWConfigPara_t));
break;}
default:
break;
}
return CommUnitIdx;
}
/*****************************************************************************************
* 函数名称: Cat1RevCallBack
* 功能描述: 4G接收回调函数
* 参 数: rData，数据输入接口
rLen, 数据长度输入接口
* 返 回 值: 无
*****************************************************************************************/
int Cat1EthRevCallBack(GateWayPara GateWay, uint8_t *rData, uint16_t rLen)
{
uint16_t check,crc16;
uint8_t *Data;
uint8_t *MegData;
uint8_t sLen;
uint8_t CommUintMac[6] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
NetCommFrameHeader NCHeader = (NetCommFrameHeader)rData;
uint16_t FrameLen = sizeof(NetCommFrameHeader_t) + NCHeader->PayloadLen;
if(FrameLen > CAT_ONE_REV_LEN_MAX)
return -1;
if(NCHeader->Header != 0x7A)
return -1;
if(memcmp(NCHeader->GWMac, GateWay->ConfigPara.GwMac, 6) != 0x00)
return -1;
check = CRC_Modbus(0xA001, rData, FrameLen);
crc16 = rData[FrameLen] | (rData[FrameLen + 1] << 8);
Data = &rData[sizeof(NetCommFrameHeader_t)];
if(check != crc16)
return -1;
uint32_t cTime = TimeTs();
if(abs((int)(NCHeader->Timestamp - cTime)) > 2) {
TimeSync(NCHeader->Timestamp);
GateWay->TimeSyncFlag = true;
SensorCommPara_t SCPara;
SCPara.Cmd = RS485_SENSOR_CMD_TIME_SYNC;
SCPara.SensorAddr = 0x00;
SCPara.SensorType = 0x00;
SCPara.CmdParaLen = 4;
SCPara.CmdPara = (uint8_t *)&NCHeader->Timestamp;
memcpy(&CommUintMac[0], Data, 6);
if(GateWay->ConfigPara.Rs485Ch1.Enable == true) { //内部通讯单元处理
if(GateWay->ConfigPara.Rs485Ch1.CommUnitEnable == true)
CommUnitCmdSend(GateWay, CommUintMac, COMM_UNIT_CMD_TIME_SYNC, &rData[14], 4, GateWay->ConfigPara.Rs485Ch1.RS485Send);
else
RS485CmdSend(GateWay, 1, &SCPara);
}
if(GateWay->ConfigPara.Rs485Ch2.Enable == true) {
if(GateWay->ConfigPara.Rs485Ch2.CommUnitEnable == true)
CommUnitCmdSend(GateWay, CommUintMac, COMM_UNIT_CMD_TIME_SYNC, &rData[14], 4, GateWay->ConfigPara.Rs485Ch2.RS485Send);
else
RS485CmdSend(GateWay, 2, &SCPara);
}
for(int i = 0; i < COMMUNIT_NUM_MAX; i++)//参数遍历
{
if(GateWay->ConfigPara.CommUnitArray[i].RegFlag == true)
GateWay->ConfigPara.CommUnitArray[i].TimeSyncFlag = true;//校时置位，等待下次此MAC主设备上传数据时下发校准指令（低功耗）
}
//校准其他通讯网关
//CommUnitCmdSend(GateWay, CommUintMac, COMM_UNIT_CMD_TIME_SYNC, &rData[14], 4, Sx1276LoRaSendBuffer);
}
switch(NCHeader->Cmd) {
case NET_COMM_CMD_REG:{
if(*Data == 1) { //注册成功
GateWay->SvrRegFlag = true;
//memcpy(GateWay->SvrMac, NCHeader->SvrMac, 6);
memset(GateWay->SvrMac, 0x00, 6);
WritePara((uint8_t *)&GateWay->ConfigPara, sizeof(GWConfigPara_t));
MAIN_DBG_LOG("Gateway Registered...\r\n");
}
else {
GateWay->SvrRegFlag = false;
memset(GateWay->SvrMac, 0x00, 6);
MAIN_DBG_LOG("Gateway Register Failed....\r\n");
}
break;}
case NET_COMM_CMD_CAIL:{
//应答服务器
MegData = rt_malloc(4);
MegData[0] = 1;
MegData[1] = 0;
MegData[2] = NET_COMM_CMD_CAIL;
MegData[3] = 1;
sLen = 4;
CatOneEthSendQueue(MegData, sLen);
rt_free(MegData);
//开始校准
memcpy(&CommUintMac[0], Data, 6);
if(memcmp(CommUintMac, Data, 6) == 0) { //校准所有传感器
SensorCommPara_t SCPara;
SCPara.Cmd = RS485_SENSOR_CMD_CAIL;
SCPara.SensorAddr = 0x00;
//SCPara.SensorType = 0x00;
SCPara.CmdParaLen = 0;
SCPara.CmdPara = NULL;
if(GateWay->ConfigPara.Rs485Ch1.Enable == true) { //内部通讯单元处理
if(GateWay->ConfigPara.Rs485Ch1.CommUnitEnable == true)
RS485CmdSend(GateWay, 1, &SCPara);
else
CommUnitCmdSend(GateWay, CommUintMac, COMM_UNIT_CMD_CAIL, NULL, 0, GateWay->ConfigPara.Rs485Ch1.RS485Send);
}
if(GateWay->ConfigPara.Rs485Ch2.Enable == true) {
if(GateWay->ConfigPara.Rs485Ch1.CommUnitEnable == true)
RS485CmdSend(GateWay, 2, &SCPara);
else
CommUnitCmdSend(GateWay, CommUintMac, COMM_UNIT_CMD_CAIL, NULL, 0, GateWay->ConfigPara.Rs485Ch2.RS485Send);
}
for(int i = 0; i < COMMUNIT_NUM_MAX; i++)//参数遍历
{
if(GateWay->ConfigPara.CommUnitArray[i].RegFlag == true)
GateWay->ConfigPara.CommUnitArray[i].CailFlag = true;//校准置位，等待下次此MAC主设备上传数据时下发校准指令（低功耗）
}
//校准其他通讯网关
//CommUnitCmdSend(GateWay, CommUintMac, COMM_UNIT_CMD_CAIL, NULL, 0, Sx1276LoRaSendBuffer);
MAIN_DBG_LOG("Calibrate all device.\r\n");
}
else {
int ret = CheckCommUnitReg(GateWay, CommUintMac);
if(ret < 0)
return -1;
if(GateWay->ConfigPara.CommUnitArray[ret].CUType != DEV_TYPE_EXT_COMMUNIT)
return -1;
if((GateWay->ConfigPara.CommUnitArray[ret].Mac[0][3] / 0x80) != 1) {//判断是否为通讯单元（主设备）
if(GateWay->ConfigPara.CommUnitArray[ret].Mac[0][2] == 1)//判断通讯类型
{
GateWay->ConfigPara.CommUnitArray[ret].CailFlag = true;//校准置位，等待下次此MAC主设备上传数据时下发校准指令（低功耗）
//CommUnitCmdSend(GateWay, CommUintMac, COMM_UNIT_CMD_CAIL, NULL, 0, Sx1276LoRaSendBuffer);//查询模式
MAIN_DBG_LOG("Calibrate Mac:%02X-%02X-%02X-%02X-%02X-%02X\r\n",
CommUintMac[0], CommUintMac[1], CommUintMac[2], CommUintMac[3], CommUintMac[4], CommUintMac[5]);
}
else if(GateWay->ConfigPara.CommUnitArray[ret].Mac[0][2] == 2)//判断通讯类型
{
if(GateWay->ConfigPara.Rs485Ch1.Enable == true && !GateWay->ConfigPara.Rs485Ch1.CommUnitEnable)
{
CommUnitCmdSend(GateWay, CommUintMac, COMM_UNIT_CMD_CAIL, NULL, 0, GateWay->ConfigPara.Rs485Ch1.RS485Send);
}
else if(GateWay->ConfigPara.Rs485Ch2.Enable == true && !GateWay->ConfigPara.Rs485Ch2.CommUnitEnable)
{
CommUnitCmdSend(GateWay, CommUintMac, COMM_UNIT_CMD_CAIL, NULL, 0, GateWay->ConfigPara.Rs485Ch2.RS485Send);
}
}
}
}
break;}
case NET_COMM_CMD_UPDATE:{
MAIN_DBG_LOG("Received server response.....\r\n");
break;}
case NET_COMM_CMD_READ_GW_INFO: {
MegData = rt_malloc(512);
uint16_t SensorCnt = 0;
sLen = 5;
if(GateWay->ConfigPara.Rs485Ch1.Enable == true) { //内部通讯单元处理
if(GateWay->ConfigPara.Rs485Ch1.CommUnitEnable == true) {
SensorCnt++;
memcpy(&MegData[sLen], GateWay->ConfigPara.Rs485Ch1.CUData.Para.Mac[0], 6);
sLen += 6;
}
}
if(GateWay->ConfigPara.Rs485Ch2.Enable == true) {
if(GateWay->ConfigPara.Rs485Ch2.CommUnitEnable == true) {
SensorCnt++;
memcpy(&MegData[sLen], GateWay->ConfigPara.Rs485Ch2.CUData.Para.Mac[0], 6);
sLen += 6;
}
}
for(int i = 0; i < COMMUNIT_NUM_MAX; i++) {
if(GateWay->ConfigPara.CommUnitArray[i].RegFlag) {
for(int j = 0; j < GateWay->ConfigPara.CommUnitArray[i].SensorN; j++)
{
SensorCnt++;
memcpy(&MegData[sLen], GateWay->ConfigPara.CommUnitArray[i].Mac[j], 6);
sLen += 6;
}
}
}
MegData[sLen++] = GateWay->Battery;
MegData[sLen++] = GateWay->UploadInterval & 0x00ff;
MegData[sLen++] = (GateWay->UploadInterval >> 8) & 0x00ff;
MegData[sLen++] = GateWay->HistoryNum & 0x00ff;
MegData[sLen++] = (GateWay->HistoryNum >> 8) & 0x00ff;
MegData[sLen++] = (GateWay->HistoryNum >> 16) & 0x00ff;
MegData[sLen++] = (GateWay->HistoryNum >> 24) & 0x00ff;
MegData[0] = (sLen - 3) & 0x00ff;//数据体长度
MegData[1] = ((sLen - 3) >> 8) & 0x00ff;//数据体长度
MegData[2] = NET_COMM_CMD_READ_GW_INFO;//指令
MegData[3] = SensorCnt&0xFF;
MegData[4] = (SensorCnt >> 8)&0xFF;
CatOneEthSendQueue(MegData, sLen);
rt_free(MegData);
break;
}
case NET_COMM_CMD_GW_PARA_CONFIG:{
//应答服务器
MegData = rt_malloc(4);
MegData[0] = 1;
MegData[1] = 0;
MegData[2] = NET_COMM_CMD_GW_PARA_CONFIG;
MegData[3] = 1;
sLen = 4;
CatOneEthSendQueue(MegData, sLen);
rt_free(MegData);
MAIN_DBG_LOG("AThe server sends down the gateway parameter configuration...\r\n");
break;}
case NET_COMM_CMD_HIS_DATA: {
uint32_t *StartIdx, *EndIdx;
StartIdx = (uint32_t *)Data;
EndIdx = (uint32_t *)&Data[4];
if(*StartIdx > GateWay->HistoryNum)
return -1;
if(*EndIdx == 0) {
*EndIdx = GateWay->HistoryNum;
}
LogHeader_t LogH;
LogH.LogEndAddr = 0;
for(int i = *StartIdx; i < *EndIdx; i++) {
uint8_t *HisData;
int ret = ReadHistoryData(&LogH, &HisData, i);
if(HisData != NULL) {
MegData = rt_malloc(ret + 15);
MegData[0] = ret - 1 + 4;
MegData[1] = NET_COMM_CMD_HIS_DATA;
memcpy(&MegData[2], (uint8_t *)&LogH.LogIdx, 4);
sLen = 6;
memcpy(&MegData[sLen], HisData, 6);
sLen += 6;
memcpy(&MegData[sLen], &HisData[7], ret - 7);
sLen += ret - 7;
CatOneEthSendQueue(MegData, sLen);
rt_free(MegData);
rt_free(HisData);
rt_thread_delay(10);
}
else {
continue;
}
}
}
case NET_COMM_CMD_ADD_UNIT:{
if(*Data == 1) { //录入成功
MAIN_DBG_LOG("Adding CommUnit succeeded...\r\n");
}
else {
MAIN_DBG_LOG("Adding CommUnit Failed...\r\n");
}
break;}
case NET_COMM_CMD_LP_DEV_CONFIG: {
//开始配置
SvrDownLPDevConfigPara_t *LPDevConfig;
LPDevConfig = (SvrDownLPDevConfigPara_t *)Data;
int ret = memcmp(CommUintMac, LPDevConfig->CommDevAddr, 6);
if(ret == 0) {
for(int i = 0; i < COMMUNIT_NUM_MAX; i++) {
if(GateWay->ConfigPara.CommUnitArray[i].RegFlag) {
GateWay->ConfigPara.CommUnitArray[i].CollectInterval = LPDevConfig->CollectInterval;
GateWay->ConfigPara.CommUnitArray[i].ReportInterval = LPDevConfig->ReportInterval;
GateWay->ConfigPara.CommUnitArray[i].ERInterval = LPDevConfig->ERInterval;
GateWay->ConfigPara.CommUnitArray[i].ERTime = LPDevConfig->ERTime;
GateWay->ConfigPara.CommUnitArray[i].ConfigFlag = true;
}
}
MAIN_DBG_LOG("Configure all the parameters of the main devices.\r\n");
WritePara((uint8_t *)&GateWay->ConfigPara, sizeof(GWConfigPara_t));
}
else {
memcpy(&CommUintMac[0], Data, 6);
int ret = CheckCommUnitReg(GateWay, CommUintMac);
if(ret < 0)
return -1;
GateWay->ConfigPara.CommUnitArray[ret].CollectInterval = LPDevConfig->CollectInterval;
GateWay->ConfigPara.CommUnitArray[ret].ReportInterval = LPDevConfig->ReportInterval;
GateWay->ConfigPara.CommUnitArray[ret].ERInterval = LPDevConfig->ERInterval;
GateWay->ConfigPara.CommUnitArray[ret].ERTime = LPDevConfig->ERTime;
GateWay->ConfigPara.CommUnitArray[ret].ConfigFlag = true;
WritePara((uint8_t *)&GateWay->ConfigPara, sizeof(GWConfigPara_t));
MAIN_DBG_LOG("Main equipment parameter configuration. Mac:%02X-%02X-%02X-%02X-%02X-%02X\r\n",
CommUintMac[0], CommUintMac[1], CommUintMac[2], CommUintMac[3], CommUintMac[4], CommUintMac[5]);
}
//应答服务器
MegData = rt_malloc(4);
MegData[0] = 1;
MegData[1] = 0;
MegData[2] = NET_COMM_CMD_LP_DEV_CONFIG;
MegData[3] = 1;
sLen = 4;
CatOneEthSendQueue(MegData, sLen);
rt_free(MegData);
break;}
case NET_COMM_CMD_CONT_LASER:{
memcpy(&CommUintMac[0], Data, 6);
int ret = CheckCommUnitReg(GateWay, CommUintMac);
if(ret < 0)
return -1;
if(GateWay->ConfigPara.CommUnitArray[ret].CUType != DEV_TYPE_EXT_COMMUNIT)
return -1;
if((GateWay->ConfigPara.CommUnitArray[ret].Mac[0][3] / 0x80) != 1) {//判断是否为通讯单元（主设备）
if(GateWay->ConfigPara.CommUnitArray[ret].Mac[0][2] == 1)//判断通讯类型
{
GateWay->ConfigPara.CommUnitArray[ret].LaserOnOff = Data[6];//服务器下发打开或者关闭激光
if(GateWay->ConfigPara.CommUnitArray[ret].LaserOnOff == true)
{
GateWay->ConfigPara.CommUnitArray[ret].ContLaser = true;//控制激光，等待下次此MAC主设备上传数据时下发打开激光指令（低功耗）
MAIN_DBG_LOG("Waiting for the laser response. Mac:%02X-%02X-%02X-%02X-%02X-%02X\r\n",
CommUintMac[0], CommUintMac[1], CommUintMac[2], CommUintMac[3], CommUintMac[4], CommUintMac[5]);
}
else if(GateWay->ConfigPara.CommUnitArray[ret].LaserOnOff == false)
{//直接发送
MAIN_DBG_LOG("Waiting for the laser response. Mac:%02X-%02X-%02X-%02X-%02X-%02X\r\n",
CommUintMac[0], CommUintMac[1], CommUintMac[2], CommUintMac[3], CommUintMac[4], CommUintMac[5]);
GateWay->ConfigPara.CommUnitArray[ret].ContLaser = false;
CommUnitCmdSend(GateWay, CommUintMac, COMM_UNIT_CMD_CONT_LASER, (uint8_t *)&GateWay->ConfigPara.CommUnitArray[ret].LaserOnOff, 1, Sx1276LoRaSendBuffer);//查询模式
}
}
else if(GateWay->ConfigPara.CommUnitArray[ret].Mac[0][2] == 2)//判断通讯类型
{
if(GateWay->ConfigPara.Rs485Ch1.Enable == true && !GateWay->ConfigPara.Rs485Ch1.CommUnitEnable)
{
GateWay->ConfigPara.CommUnitArray[ret].LaserOnOff = Data[6];//服务器下发打开或者关闭激光
if(GateWay->ConfigPara.CommUnitArray[ret].LaserOnOff == true)
{
GateWay->ConfigPara.CommUnitArray[ret].ContLaser = true;//控制激光，等待下次此MAC主设备上传数据时下发打开激光指令（低功耗）
}
else if(GateWay->ConfigPara.CommUnitArray[ret].LaserOnOff == false)
{
CommUnitCmdSend(GateWay, CommUintMac, COMM_UNIT_CMD_CONT_LASER, &Data[6], 1, GateWay->ConfigPara.Rs485Ch1.RS485Send);
}
}
else if(GateWay->ConfigPara.Rs485Ch2.Enable == true && !GateWay->ConfigPara.Rs485Ch2.CommUnitEnable)
{
GateWay->ConfigPara.CommUnitArray[ret].LaserOnOff = Data[6];//服务器下发打开或者关闭激光
if(GateWay->ConfigPara.CommUnitArray[ret].LaserOnOff == true)
{
GateWay->ConfigPara.CommUnitArray[ret].ContLaser = true;//控制激光，等待下次此MAC主设备上传数据时下发打开激光指令（低功耗）
}
else if(GateWay->ConfigPara.CommUnitArray[ret].LaserOnOff == false)
{
CommUnitCmdSend(GateWay, CommUintMac, COMM_UNIT_CMD_CONT_LASER, &Data[6], 1, GateWay->ConfigPara.Rs485Ch2.RS485Send);
}
}
}
}
break;}
default:
break;
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink