using System;
|
using System.Collections.Generic;
|
using System.Text;
|
using Newtonsoft.Json.Linq;
|
|
namespace ZigBee.Device
|
{
|
[System.Serializable]
|
public class Logic
|
{
|
/// <summary>
|
/// 当前主网关ID
|
/// </summary>
|
public string GateWayId;
|
|
/// <summary>
|
/// 入网设备信息
|
/// </summary>
|
public int DataID;
|
|
/// <summary>
|
/// 网关反馈的时间戳
|
/// </summary>
|
public int Time;
|
|
[System.Serializable]
|
public class LogicBase
|
{
|
/// <summary>
|
/// 逻辑id，逻辑的唯一标识。如果该逻辑已经存在，则将原来逻辑覆盖。
|
///<para>若忽略该字段或该字段为0：网关自动为该逻辑分配一个未被使用的id。</para>
|
/// </summary>
|
public int LogicId;
|
}
|
|
/// <summary>
|
/// 网关信息错误反馈
|
/// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
|
/// </summary>
|
ErrorResponData errResponData;
|
/// <summary>
|
/// 网关信息错误反馈
|
/// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
|
/// </summary>
|
[System.Serializable]
|
public class ErrorResponData
|
{
|
/// <summary>
|
/// Error参数含义
|
///<para>1：网关无法解析命令数据。</para>
|
///<para>2：协调器正在升级或备份/恢复数据
|
///<para>3：操作设备/组/场景不存在</para>
|
///<para>4：其他错误</para>
|
///<para>5：数据传输错误（在某次客户端向网关发送数据的过程中，网关在合理时间范围内接收客户端数据不完整导致该错误发生。如客户端向网关一次发送100个字节的数据，但网关等待接收了一秒只接收了80个字节。发生该错误，网关将主动关闭客户端连接）</para>
|
/// </summary>
|
public int Error;
|
}
|
|
/// <summary>
|
/// 网关信息错误反馈的内容
|
/// </summary>
|
static string ErrorMess(int err)
|
{
|
string message = "";
|
switch (err)
|
{
|
case 1:
|
message = " 网关无法解析命令数据。";
|
break;
|
case 2:
|
message = " 协调器正在升级或备份 / 恢复数据。";
|
break;
|
case 3:
|
message = "操作设备 / 组 / 场景不存在";
|
break;
|
case 4:
|
message = " 其他错误";
|
break;
|
case 5:
|
message = " 数据传输错误（在某次客户端向网关发送数据的过程中，网关在合理时间范围内接收客户端数据不完整导致该错误发生。如客户端向网关一次发送100个字节的数据，但网关等待接收了一秒只接收了80个字节。发生该错误，网关将主动关闭客户端连接）";
|
break;
|
default:
|
break;
|
}
|
return message;
|
}
|
|
#region 当前没有主网关，无法进行逻辑操作
|
/// <summary>
|
///当前没有主网关，无法进行逻辑操作
|
/// </summary>
|
public GetLogicErrorData getLogicError;
|
/// <summary>
|
///当前没有主网关，无法进行逻辑操作
|
/// </summary>
|
[System.Serializable]
|
public class GetLogicErrorData
|
{
|
/// <summary>
|
/// 1：网关不是主网关，无法进行该操作。
|
/// </summary>
|
public int Error;
|
}
|
#endregion
|
|
#region 在从网关中发场景的命令的反馈
|
/// <summary>
|
///在从网关中发场景的命令的反馈
|
/// </summary>
|
public SceneErrorRespon sceneErrorRespon;
|
/// <summary>
|
///在从网关中发场景的命令的反馈
|
/// </summary>
|
[System.Serializable]
|
public class SceneErrorRespon
|
{
|
/// <summary>
|
/// 非主网关不能使用场景指令。
|
/// </summary>
|
public int Data_ID;
|
|
}
|
#endregion
|
|
#region 添加或修改逻辑.
|
/// <summary>
|
/// 添加或修改逻辑
|
/// </summary>
|
public static async System.Threading.Tasks.Task<AddLogicResponseAllData> AddLogicAsync(AddLogicData addLogicData)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
AddLogicResponseAllData allData =null;
|
if (ZbGateway.MainGateWay == null)
|
{
|
allData = new AddLogicResponseAllData { errorMessageBase = "当前没有主网关" };
|
return allData;
|
}
|
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var gatewayTemp = new ZbGateway() { Time = jobject.Value<int>("Time"), DataID = jobject.Value<int>("Data_ID"), CurrentGateWayId = ZbGateway.MainGateWay.getGatewayBaseInfo.gwID };
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
allData = new AddLogicResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
allData = new AddLogicResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Logic/AddLogic_Respon")
|
{
|
try
|
{
|
var logic = new Logic() { DataID = jobject.Value<int>("Data_ID"), GateWayId = ZbGateway.MainGateWay.CurrentGateWayId };
|
var tempTimeAttribute = Newtonsoft.Json.JsonConvert.DeserializeObject<TimeAttributeObj>(jobject["Data"]["TimeAttribute"].ToString());
|
var tempData = Newtonsoft.Json.JsonConvert.DeserializeObject<GetLogicInfoResponseBaseData>(jobject["Data"].ToString());
|
if (tempData != null)
|
{
|
var conditions = Newtonsoft.Json.Linq.JArray.Parse(jobject["Data"]["Conditions"].ToString());
|
allData = new AddLogicResponseAllData { };
|
var tempD = new GetLogicInfoResponseData { };
|
for (int m = 0; conditions != null && m < conditions.Count; m++)
|
{
|
var condition = conditions[m];
|
switch (condition["Type"].ToString())
|
{
|
case "0":
|
tempD.Conditions.Add(Newtonsoft.Json.JsonConvert.DeserializeObject<Logic.TimeConditionsInfo>(condition.ToString()));
|
break;
|
case "1":
|
tempD.Conditions.Add(Newtonsoft.Json.JsonConvert.DeserializeObject<Logic.DeviceConditionsInfo>(condition.ToString()));
|
break;
|
case "2":
|
tempD.Conditions.Add(Newtonsoft.Json.JsonConvert.DeserializeObject<Logic.LogicConditionsInfo>(condition.ToString()));
|
break;
|
case "3":
|
tempD.Conditions.Add(Newtonsoft.Json.JsonConvert.DeserializeObject<Logic.CounterConditionsInfo>(condition.ToString()));
|
break;
|
case "4":
|
tempD.Conditions.Add(Newtonsoft.Json.JsonConvert.DeserializeObject<Logic.CountdownConditionsInfo>(condition.ToString()));
|
break;
|
case "5":
|
tempD.Conditions.Add(Newtonsoft.Json.JsonConvert.DeserializeObject<Logic.TimeBucketConditionsInfo>(condition.ToString()));
|
break;
|
}
|
}
|
if (tempTimeAttribute != null) { tempD.TimeAttribute = tempTimeAttribute; }
|
if (tempData.LogicName != null) { tempD.LogicName = tempData.LogicName; }
|
if (tempData.Actions != null) { tempD.Actions = tempData.Actions; }
|
tempD.LogicId = tempData.LogicId;
|
tempD.IsEnable = tempData.IsEnable;
|
tempD.Relationship = tempData.Relationship;
|
tempD.Result = tempData.Result;
|
allData.getLogicInfoResponseData = tempD;
|
|
var info = ZbGateway.LogicList.Find((Logic.GetLogicInfoResponseData obj) => obj.LogicId == tempData.LogicId);
|
if (info == null)
|
{
|
ZbGateway.LogicList.Add(allData.getLogicInfoResponseData);
|
}
|
else
|
{
|
info.LogicName = tempD.LogicName;
|
info.Result = tempD.Result;
|
info.Relationship = tempD.Relationship;
|
info.IsEnable = tempD.IsEnable;
|
info.Conditions = tempD.Conditions;
|
info.Actions = tempD.Actions;
|
info.TimeAttribute = tempD.TimeAttribute;
|
}
|
System.Console.WriteLine($"收到通知后的主题_{ topic}");
|
}
|
}
|
catch(Exception ex){
|
var mess = ex.Message;
|
}
|
}
|
};
|
ZbGateway.MainGateWay.Actions += action;
|
System.Console.WriteLine("Logic/AddLogic_Actions 启动" + System.DateTime.Now.ToString());
|
|
try
|
{
|
if (addLogicData != null)
|
{
|
var bytes = new byte[32];
|
var reamarkGwBytes = System.Text.Encoding.UTF8.GetBytes(addLogicData.LogicName);
|
System.Array.Copy(reamarkGwBytes, 0, bytes, 0, 32 < reamarkGwBytes.Length ? 32 : reamarkGwBytes.Length);
|
addLogicData.LogicName = System.Text.Encoding.UTF8.GetString(bytes);
|
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 2000 } };
|
var data = new JObject { };
|
|
var conditionsList = new JArray { };
|
foreach (var conInfo in addLogicData.Conditions)
|
{
|
switch (conInfo.Type)
|
{
|
case 0:
|
var timeConditionsObj = conInfo as TimeConditionsInfo;
|
var tInfo = new JObject
|
{
|
["Type"] = timeConditionsObj.Type,
|
["IsValid"] = timeConditionsObj.IsValid,
|
["DateType"] = timeConditionsObj.DateType,
|
["StartHour"] = timeConditionsObj.StartHour,
|
["StartMin"] = timeConditionsObj.StartMin,
|
["AdjustTime"] = timeConditionsObj.AdjustTime,
|
["RemindTime"] = timeConditionsObj.RemindTime,
|
["EnDelay"] = timeConditionsObj.EnDelay,
|
["DelayTime"] = timeConditionsObj.DelayTime
|
};
|
conditionsList.Add(tInfo);
|
break;
|
case 1:
|
var deviceConditionsObj = conInfo as DeviceConditionsInfo;
|
var dInfo = new JObject
|
{
|
["Type"] = deviceConditionsObj.Type,
|
["IsValid"] = deviceConditionsObj.IsValid,
|
["MacAddr"] = deviceConditionsObj.MacAddr,
|
["Epoint"] = deviceConditionsObj.Epoint,
|
["Cluster_ID"] = deviceConditionsObj.Cluster_ID,
|
["AttriButeId"] = deviceConditionsObj.AttriButeId,
|
["AttriButeData1"] = deviceConditionsObj.AttriButeData1,
|
["AttriButeData2"] = deviceConditionsObj.AttriButeData2,
|
["Range"] = deviceConditionsObj.Range,
|
};
|
conditionsList.Add(dInfo);
|
break;
|
case 2:
|
var logicConditionsObj = conInfo as LogicConditionsInfo;
|
var lInfo = new JObject
|
{
|
["Type"] = logicConditionsObj.Type,
|
["IsValid"] = logicConditionsObj.IsValid,
|
["Condition_LogicId"] = logicConditionsObj.Condition_LogicId,
|
};
|
conditionsList.Add(lInfo);
|
break;
|
case 3:
|
var cConditionsObj = conInfo as CounterConditionsInfo;
|
var cInfo = new JObject
|
{
|
["Type"] = cConditionsObj.Type,
|
["IsValid"] = cConditionsObj.IsValid,
|
["MacAddr"] = cConditionsObj.MacAddr,
|
["Epoint"] = cConditionsObj.Epoint,
|
["Cluster_ID"] = cConditionsObj.Cluster_ID,
|
["AttriButeId"] = cConditionsObj.AttriButeId,
|
["AttriButeData1"] = cConditionsObj.AttriButeData1,
|
["AttriButeData2"] = cConditionsObj.AttriButeData2,
|
["Range"] = cConditionsObj.Range,
|
["Number"] = cConditionsObj.Number,
|
["Time"] = cConditionsObj.Time,
|
["Cycle"] = cConditionsObj.Cycle,
|
};
|
conditionsList.Add(cInfo);
|
break;
|
case 4:
|
var cdConditionsObj = conInfo as CountdownConditionsInfo;
|
var cdInfo = new JObject
|
{
|
["Type"] = cdConditionsObj.Type,
|
["IsValid"] = cdConditionsObj.IsValid,
|
["Time"] = cdConditionsObj.Time,
|
};
|
conditionsList.Add(cdInfo);
|
break;
|
case 5:
|
var tbConditionsObj = conInfo as TimeBucketConditionsInfo;
|
var tbInfo = new JObject
|
{
|
["Type"] = tbConditionsObj.Type,
|
["IsValid"] = tbConditionsObj.IsValid,
|
["StartHour"] = tbConditionsObj.StartHour,
|
["StartMin"] = tbConditionsObj.StartMin,
|
["StopHour"] = tbConditionsObj.StopHour,
|
["StopMin"] = tbConditionsObj.StopMin,
|
};
|
conditionsList.Add(tbInfo);
|
break;
|
case 6:
|
var sConditionsObj = conInfo as SecurityConditionsInfo;
|
var sInfo = new JObject
|
{
|
["Type"] = sConditionsObj.Type,
|
["IsValid"] = sConditionsObj.IsValid,
|
["EnOrWithdrawMode"] = sConditionsObj.EnOrWithdrawMode,
|
["ModeId"] = sConditionsObj.ModeId,
|
};
|
conditionsList.Add(sInfo);
|
break;
|
}
|
}
|
|
var actionsList = new JArray { };
|
foreach (var actInfo in addLogicData.Actions)
|
{
|
switch (actInfo.LinkType)
|
{
|
case 0:
|
var taskList = new JArray { };
|
foreach (var taskInfo in actInfo.TaskList)
|
{
|
var info = new JObject{
|
{ "TaskType", taskInfo.TaskType},
|
{ "Data1", taskInfo.Data1},
|
{ "Data2",taskInfo.Data2}
|
};
|
taskList.Add(info);
|
}
|
var tInfo = new JObject
|
{
|
["LinkType"] = actInfo.LinkType,
|
["DeviceAddr"] = actInfo.DeviceAddr,
|
["Epoint"] = actInfo.Epoint,
|
["Time"] = actInfo.Time,
|
["taskList"] = taskList,
|
|
};
|
actionsList.Add(tInfo);
|
break;
|
case 2:
|
var dInfo = new JObject
|
{
|
["LinkType"] = actInfo.LinkType,
|
["DeviceAddr"] = int.Parse(actInfo.DeviceAddr),
|
["ConditionId"] = actInfo.ConditionId,
|
["EnableCondition"] = actInfo.EnableCondition,
|
};
|
actionsList.Add(dInfo);
|
break;
|
case 4:
|
var lInfo = new JObject
|
{
|
["LinkType"] = actInfo.LinkType,
|
["EnableLogic"] = actInfo.EnableLogic,
|
};
|
actionsList.Add(lInfo);
|
break;
|
case 5:
|
var cInfo = new JObject
|
{
|
["LinkType"] = actInfo.LinkType,
|
["DeviceAddr"] = int.Parse(actInfo.DeviceAddr),
|
["ConditionId"] = actInfo.ConditionId,
|
["EnableCondition"] = actInfo.EnableCondition,
|
};
|
actionsList.Add(cInfo);
|
break;
|
case 6:
|
var cdInfo = new JObject
|
{
|
["LinkType"] = actInfo.LinkType,
|
["SecuritySetting"] = actInfo.SecuritySetting,
|
["SecurityModeId"] = actInfo.SecurityModeId,
|
["CheckIASStatus"] = actInfo.CheckIASStatus,
|
["IsDelayStart"] = actInfo.IsDelayStart,
|
["Password"] = actInfo.Password,
|
};
|
actionsList.Add(cdInfo);
|
break;
|
}
|
}
|
|
var selectMonthList = new JArray { };
|
foreach (var sm in addLogicData.TimeAttribute.SelectMonDate)
|
{
|
var aad = sm;
|
selectMonthList.Add(sm);
|
}
|
var dataAttribute = new JObject
|
{
|
{ "Calendar",addLogicData.TimeAttribute.Calendar},
|
{ "Repeat", addLogicData.TimeAttribute.Repeat} ,
|
{ "WeekDay", addLogicData.TimeAttribute.WeekDay} ,
|
{ "SetYear",addLogicData.TimeAttribute.SetYear} ,
|
{ "MonthDate", addLogicData.TimeAttribute.MonthDate} ,
|
{ "SelectMonDate", selectMonthList }
|
};
|
data = new JObject {
|
{ "LogicId",addLogicData.LogicId},
|
{ "IsEnable", addLogicData.IsEnable} ,
|
{ "LogicName", addLogicData.LogicName} ,
|
{ "Relationship",addLogicData.Relationship} ,
|
{ "TimeAttribute", dataAttribute} ,
|
{ "Conditions", conditionsList },
|
{ "Actions", actionsList }
|
};
|
jObject.Add("Data", data);
|
ZbGateway.MainGateWay?.Send("Logic/AddLogic", jObject.ToString());
|
}
|
}
|
catch { }
|
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < 2000)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (allData != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > 2000)
|
{
|
allData = new AddLogicResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
|
}
|
ZbGateway.MainGateWay.Actions -= action;
|
System.Console.WriteLine("Logic/AddLogic_Actions 退出" + System.DateTime.Now.ToString());
|
|
return allData;
|
});
|
}
|
|
/// <summary>
|
/// 添加或修改逻辑的数据,网关反馈信息
|
/// </summary>
|
public AddLogicResponseAllData addLogicResponseAllData;
|
/// <summary>
|
/// 添加或修改逻辑的数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class AddLogicResponseAllData
|
{
|
/// <summary>
|
/// 错误信息
|
/// </summary>
|
public string errorMessageBase;
|
/// <summary>
|
/// 网关信息错误反馈
|
/// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
|
/// </summary>
|
public ErrorResponData errorResponData;
|
/// <summary>
|
/// 添加或修改逻辑的数据
|
/// </summary>
|
public GetLogicInfoResponseData getLogicInfoResponseData;
|
}
|
|
/// <summary>
|
/// 添加或修改逻辑返回的数据
|
/// </summary>
|
//public AddLogicResposeData addLogicResposeData;
|
///// <summary>
|
///// 添加或修改逻辑返回的数据
|
///// </summary>
|
//[System.Serializable]
|
//public class AddLogicResposeData : LogicBase
|
//{
|
// /// <summary>
|
// /// 该逻辑是否被使能。
|
// ///<para>0：禁用该逻辑</para>
|
// ///<para>1：使能该逻辑</para>
|
// ///<para>2: 只触发一次。触发后该字段将自动置为0，即禁用状态</para>
|
// ///<para>3：只失能一次。触发后，不执行逻辑动作，该字段自动置为1，等待下次触发。</para>
|
// /// </summary>
|
// public int IsEnable;
|
|
// /// <summary>
|
// /// 逻辑名称
|
// /// </summary>
|
// public string LogicName;
|
|
// /// <summary>
|
// ///逻辑关系。
|
// ///<para>0：满足所有条件触发动作</para>
|
// ///<para>1：满足其中一个条件触发动作</para>
|
// /// </summary>
|
// public int Relationship;
|
|
// /// <summary>
|
// /// 逻辑条件列表
|
// /// </summary>
|
// public List<ConditionBase> Conditions = new List<ConditionBase>();
|
|
// /// <summary>
|
// /// 条件满足后执行的动作列表
|
// /// </summary>
|
// public List<ActionsInfo> Actions = new List<ActionsInfo>();
|
//}
|
|
/// <summary>
|
/// 添加或修改逻辑的数据
|
/// </summary>
|
public AddLogicData addLogicData;
|
/// <summary>
|
/// 添加或修改逻辑的数据
|
/// </summary>
|
[System.Serializable]
|
public class AddLogicData : LogicBase
|
{
|
/// <summary>
|
/// 逻辑名称
|
/// </summary>
|
public string LogicName = "";
|
|
/// <summary>
|
/// 该逻辑是否被使能。
|
///<para>0：禁用该逻辑</para>
|
///<para>1：使能该逻辑</para>
|
///<para>2: 只触发一次。触发后该字段将自动置为0，即禁用状态</para>
|
///<para>3：只失能一次。触发后，不执行逻辑动作，该字段自动置为1，等待下次触发。</para>
|
/// </summary>
|
public int IsEnable = 1;
|
|
/// <summary>
|
///逻辑关系。
|
///<para>0：满足所有条件触发动作</para>
|
///<para>1：满足其中一个条件触发动作</para>
|
/// </summary>
|
public int Relationship;
|
|
/// <summary>
|
///逻辑关系。
|
///<para>0：满足所有条件触发动作</para>
|
///<para>1：满足其中一个条件触发动作</para>
|
/// </summary>
|
public TimeAttributeObj TimeAttribute=new TimeAttributeObj();
|
|
/// <summary>
|
/// 逻辑条件列表
|
/// </summary>
|
public List<ConditionBase> Conditions = new List<ConditionBase>();
|
|
/// <summary>
|
/// 条件满足后执行的动作列表
|
/// </summary>
|
public List<ActionsInfo> Actions = new List<ActionsInfo>();
|
}
|
|
/// <summary>
|
/// 描述逻辑时间属性
|
/// </summary>
|
[System.Serializable]
|
public class TimeAttributeObj
|
{
|
/// <summary>
|
///条件类型
|
///0：阳历 1：农历
|
/// </summary>
|
public int Calendar;
|
|
/// <summary>
|
/// 时间重复性：用于限制逻辑的执行时间
|
///<para>0：一次性，只执行一次，执行后IsEnable值置0</para>
|
///<para>1：今年内执行</para>
|
///<para>2：每天执行</para>
|
///<para>3：每月执行</para>
|
///<para>4：每年执行</para>
|
///<para>5：周重复。</para>
|
/// </summary>
|
public int Repeat;
|
|
/// <summary>
|
/// 周工作模式（可或运算），当Repeat=5时有效，Repeat为其他值时可忽略该字段。
|
///<para>0x01 周一执行</para>
|
///<para>0x02 周二执行</para>
|
///<para>0x04 周三执行</para>
|
///<para>0x08 周四执行</para>
|
///<para>0x10 周五执行</para>
|
///<para>0x20 周六执行</para>
|
///<para>0x40 周日执行</para>
|
///<para>0x7F 每天执行</para>
|
///<para>数值可进行或运算，如周一、周三、周五执行，则为WeekDay=（0x01 || 0x04 || 0x10）= 0x15 即十进制 21。</para>
|
/// </summary>
|
/// <value>The week day.</value>
|
public int WeekDay;
|
|
/// <summary>
|
///当Repeat = 1时，该参数才有效。表示某个年份内才执行。如SetYear = 2020，则表示该条件2020内才会被执行。如果该字段被忽略或设定为 0 ，网关将自动填入今年的年份作为执行年份。
|
///可忽略，默认为设定条件时的年份。
|
/// </summary>
|
public int SetYear;
|
|
/// <summary>
|
///条件类型
|
///重复类型为每月执行时选择的日期。32位整型，bit值第0位到第30位分别代表每月的1号到31号，位值为1则表示该日期可执行逻辑，位值为0则该日期不可执行逻辑。如，MonthDate=91，则二进制值为：1011011 ，可知bit0=1，所以1号可执行。Bit1=1，所以2号可执行。Bit2=0，3号不可执行。Bit3和bit4为1所以4、5号可执行。Bit5为0，6号不可执行。Bit6为1，7号可执行。如果选择某段日期执行，可将这段日期号数对应的bit值全置1。如果3号到7号执行，则为二进制1111100，即MonthDate = 124。当Repeat =3时有效。Repeat不为3时，可忽略该参数。
|
/// </summary>
|
public int MonthDate;
|
|
/// <summary>
|
///重复类型为今年内执行或每年执行时选择执行的月份。
|
/// 选择执行的月份
|
///<para>0x01：1月执行；0x02：2月执行；</para>
|
///<para>0x04：3月执行；0x08：4月执行</para>
|
///<para>0x10：5月执行；0x20：6月执行</para>
|
///<para>0x40：7月执行；0x80：9月执行</para>
|
///<para>0x100: 10月执行；0x200: 11月执行</para>
|
///<para>0x400: 12月执行；</para>
|
///<para>数值可进行或运算，如一月、三月、五月执行，则为SelectMonth =（0x01 | 0x04 | 0x10）= 0x15 即十进制 21。</para>
|
///<para>当Repeat = 1或4时有效。Repeat为其他值时可忽略该字段。</para>
|
/// </summary>
|
public int SelectMonth;
|
|
/// <summary>
|
///重复类型为今年内执行或每年执行时选择执行的日期。
|
///SelectMonDate[0] 到SelectMonDate[11]分别表示1月份到12月份选择的号数，类型为32位整数，数值的含义和MonthDate相同。
|
///<para>当Repeat = 1或4时有效。Repeat为其他值时可忽略该字段。</para>
|
///</summary>
|
/// <summary>
|
/// 逻辑条件列表
|
/// </summary>
|
public List<int> SelectMonDate = new List<int>();
|
}
|
|
[System.Serializable]
|
public class ConditionBase
|
{
|
/// <summary>
|
///条件类型
|
///<para>0：时间点条件，在某个时间发生</para>
|
///<para>1：设备状态变化条件</para>
|
///<para>2：其他逻辑条件</para>
|
///<para>3：计数器条件</para>
|
///<para>4：倒计时</para>
|
///<para>5：时间段条件</para>
|
///<para>6：安防条件</para>
|
/// </summary>
|
public int Type;
|
|
/// <summary>
|
/// 该条件是否作为判断逻辑依据。当条件无效时，则忽略该条件。一个逻辑应该至少有一个有效条件用于判断逻辑是否成立，当一个逻辑所有条件无效时，该逻辑将永远不会生效。
|
///<para>0：无效（忽略条件）。</para>
|
///<para>1：有效（启用条件）。</para>
|
///<para>2：使能一次（条件成立一次后将被禁用，IsValid自动置为0）。</para>
|
///<para>3：失能一次（条件第一次成立会被忽略，触发不了逻辑，然后IsValid自动置1。以后条件再成立将不会被忽略）</para>
|
/// </summary>
|
public int IsValid = 1;
|
/// <summary>
|
/// 条件ID（(当新增或修改逻辑条件时，该字段无效））
|
/// </summary>
|
public int ConditionId ;
|
|
}
|
#endregion
|
|
#region 修改逻辑信息.
|
///<summary >
|
/// 修改逻辑信息
|
/// </summary>
|
public static async System.Threading.Tasks.Task<ReviseAttributeResponseAllData> ReviseAttributeAsync(ReviseAttributeData reviseAttributeData)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
ReviseAttributeResponseAllData allData =null;
|
if (ZbGateway.MainGateWay == null)
|
{
|
allData = new ReviseAttributeResponseAllData{ errorMessageBase = "当前没有主网关" };
|
return allData;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var gatewayTemp = new ZbGateway() { Time = jobject.Value<int>("Time"), DataID = jobject.Value<int>("Data_ID"), CurrentGateWayId = ZbGateway.MainGateWay.getGatewayBaseInfo.gwID };
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
allData = new ReviseAttributeResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
allData = new ReviseAttributeResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
|
if (topic == gatewayID + "/" + "Logic/ReviseAttribute_Respon")
|
{
|
try
|
{
|
var logic = new Logic() { DataID = jobject.Value<int>("Data_ID"), GateWayId = ZbGateway.MainGateWay.CurrentGateWayId };
|
var tempTimeAttribute = Newtonsoft.Json.JsonConvert.DeserializeObject<TimeAttributeObj>(jobject["Data"]["TimeAttribute"].ToString());
|
var tempData = Newtonsoft.Json.JsonConvert.DeserializeObject<ReviseAttributeResponseBaseData>(jobject["Data"].ToString());
|
|
if (tempData != null)
|
{
|
allData = new ReviseAttributeResponseAllData { };
|
var tempD = new ReviseAttributeResponseData { };
|
|
if (tempTimeAttribute != null) { tempD.TimeAttribute = tempTimeAttribute; }
|
if (tempData.LogicName != null) { tempD.LogicName = tempData.LogicName; }
|
tempD.LogicId = tempData.LogicId;
|
tempD.IsEnable = tempData.IsEnable;
|
tempD.Relationship = tempData.Relationship;
|
tempD.Result = tempData.Result;
|
allData.reviseAttributeResponseData = tempD;
|
|
var info = ZbGateway.LogicList.Find((Logic.GetLogicInfoResponseData obj) => obj.LogicId == tempData.LogicId);
|
if (info != null)
|
{
|
info.LogicName = tempD.LogicName;
|
info.Result = tempD.Result;
|
info.Relationship = tempD.Relationship;
|
info.IsEnable = tempD.IsEnable;
|
info.TimeAttribute = tempD.TimeAttribute;
|
}
|
System.Console.WriteLine($"收到通知后的主题_{ topic}");
|
}else{
|
allData = new ReviseAttributeResponseAllData { errorMessageBase = "网关返回的数据为空" };
|
}
|
}
|
catch (Exception ex)
|
{
|
var mess = ex.Message;
|
}
|
}
|
};
|
ZbGateway.MainGateWay.Actions += action;
|
System.Console.WriteLine("Logic/ReviseAttribute_Actions 启动" + "_" + ZbGateway.MainGateWay.getGatewayBaseInfo.gwID + System.DateTime.Now.ToString());
|
|
try
|
{
|
if (reviseAttributeData != null)
|
{
|
if(reviseAttributeData.LogicName!=null){
|
var bytes = new byte[32];
|
var reamarkGwBytes = System.Text.Encoding.UTF8.GetBytes(reviseAttributeData.LogicName);
|
System.Array.Copy(reamarkGwBytes, 0, bytes, 0, 32 < reamarkGwBytes.Length ? 32 : reamarkGwBytes.Length);
|
reviseAttributeData.LogicName = System.Text.Encoding.UTF8.GetString(bytes);
|
}
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 2001 } };
|
var data = new JObject { };
|
|
var selectMonthList = new JArray { };
|
if(reviseAttributeData.TimeAttribute!=null&& reviseAttributeData.TimeAttribute.SelectMonDate != null)
|
{
|
foreach (var sm in reviseAttributeData.TimeAttribute.SelectMonDate)
|
{
|
var aad = sm;
|
selectMonthList.Add(sm);
|
}
|
}
|
|
var dataAttribute = new JObject
|
{
|
{ "Calendar",reviseAttributeData.TimeAttribute.Calendar},
|
{ "Repeat", reviseAttributeData.TimeAttribute.Repeat} ,
|
{ "WeekDay", reviseAttributeData.TimeAttribute.WeekDay} ,
|
{ "SetYear",reviseAttributeData.TimeAttribute.SetYear} ,
|
{ "MonthDate", reviseAttributeData.TimeAttribute.MonthDate} ,
|
{ "SelectMonDate", selectMonthList }
|
};
|
|
data = new JObject {
|
{ "LogicId",reviseAttributeData.LogicId},
|
{ "IsEnable", reviseAttributeData.IsEnable} ,
|
{ "LogicName", reviseAttributeData.LogicName} ,
|
{ "Relationship",reviseAttributeData.Relationship},
|
{ "TimeAttribute", dataAttribute}
|
};
|
jObject.Add("Data", data);
|
ZbGateway.MainGateWay?.Send(("Logic/ReviseAttribute"), jObject.ToString());
|
}
|
} catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < 2000)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (allData != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > 2000)
|
{
|
allData = new ReviseAttributeResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
|
}
|
ZbGateway.MainGateWay.Actions -= action;
|
System.Console.WriteLine("Logic/ReviseAttribute_Actions 退出" + "_" + ZbGateway.MainGateWay.getGatewayBaseInfo.gwID + System.DateTime.Now.ToString());
|
|
return allData;
|
});
|
}
|
|
/// <summary>
|
///修改逻辑属性回复的所有数据,网关反馈信息
|
/// </summary>
|
public ReviseAttributeResponseAllData reviseAttributeResponseAllData;
|
///<summary >
|
/// 修改逻辑属性回复的所有数据
|
/// </summary>
|
[System.Serializable]
|
public class ReviseAttributeResponseAllData
|
{
|
/// <summary>
|
/// 错误信息
|
/// </summary>
|
public string errorMessageBase;
|
/// <summary>
|
/// 网关信息错误反馈
|
/// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
|
/// </summary>
|
public ErrorResponData errorResponData;
|
/// <summary>
|
/// 修改逻辑属性
|
/// </summary>
|
public ReviseAttributeResponseData reviseAttributeResponseData;
|
}
|
|
///<summary >
|
/// 修改逻辑属性回复的数据
|
/// </summary>
|
public ReviseAttributeResponseData reviseAttributeResponseData;
|
///<summary >
|
/// 修改逻辑属性回复的数据
|
/// </summary>
|
[System.Serializable]
|
public class ReviseAttributeResponseData : LogicBase
|
{
|
/// <summary>
|
/// 修改结果：
|
///<para>0：成功</para>
|
///<para>1：失败，逻辑不存在</para>
|
/// </summary>
|
public int Result;
|
|
/// <summary>
|
/// 该逻辑是否被使能。
|
///<para>0：禁用该逻辑</para>
|
///<para>1：使能该逻辑</para>
|
///<para>2: 只触发一次。触发后该字段将自动置为0，即禁用状态</para>
|
/// </summary>
|
public int IsEnable;
|
/// <summary>
|
/// 逻辑名称
|
/// </summary>
|
public string LogicName;
|
/// <summary>
|
/// 逻辑关系。
|
///<para>0：满足所有条件触发动作</para>
|
///<para>1：满足其中一个条件触发动作</para>
|
/// </summary>
|
public int Relationship;
|
|
/// <summary>
|
/// 逻辑名称
|
/// </summary>
|
public TimeAttributeObj TimeAttribute=new TimeAttributeObj();
|
}
|
|
[System.Serializable]
|
public class ReviseAttributeResponseBaseData : LogicBase
|
{
|
/// <summary>
|
/// 修改结果：
|
///<para>0：成功</para>
|
///<para>1：失败，逻辑不存在</para>
|
/// </summary>
|
public int Result;
|
|
/// <summary>
|
/// 该逻辑是否被使能。
|
///<para>0：禁用该逻辑</para>
|
///<para>1：使能该逻辑</para>
|
///<para>2: 只触发一次。触发后该字段将自动置为0，即禁用状态</para>
|
/// </summary>
|
public int IsEnable;
|
/// <summary>
|
/// 逻辑名称
|
/// </summary>
|
public string LogicName;
|
/// <summary>
|
/// 逻辑关系。
|
///<para>0：满足所有条件触发动作</para>
|
///<para>1：满足其中一个条件触发动作</para>
|
/// </summary>
|
public int Relationship;
|
}
|
|
///<summary >
|
/// 修改逻辑属性的数据
|
/// </summary>
|
public ReviseAttributeData reviseAttributeData;
|
///<summary >
|
/// 修改逻辑属性回复的数据
|
/// </summary>
|
[System.Serializable]
|
public class ReviseAttributeData : LogicBase
|
{
|
/// <summary>
|
/// 该逻辑是否被使能。
|
///<para>0：禁用该逻辑</para>
|
///<para>1：使能该逻辑</para>
|
///<para>2: 只触发一次。触发后该字段将自动置为0，即禁用状态</para>
|
///<para>3：只失能一次。触发后，不执行逻辑动作，该字段自动置为1，等待下次触发。</para>
|
///<para>不修改该属性时， 可忽略该字段</para>
|
/// </summary>
|
public int IsEnable;
|
/// <summary>
|
/// 逻辑名称
|
/// </summary>
|
public string LogicName;
|
/// <summary>
|
/// 逻辑关系。
|
///<para>0：满足所有条件触发动作</para>
|
///<para>1：满足其中一个条件触发动作</para>
|
///<para>不修改该属性时，可忽略该字段</para>
|
/// </summary>
|
public int Relationship;
|
|
/// <summary>
|
/// 描述逻辑时间属性
|
///和“1、添加或修改逻辑”的TimeAttribute字段格式相同。
|
///<para>不修改该属性时，可忽略该字段</para>
|
/// </summary>
|
public TimeAttributeObj TimeAttribute=new TimeAttributeObj();
|
}
|
#endregion
|
|
#region 通过逻辑id获取逻辑信息.
|
///<summary >
|
/// 通过逻辑id获取逻辑信息
|
/// </summary>
|
public static async System.Threading.Tasks.Task<GetLogicInfoResponseAllData> GetLogicInfoAsync(int logicId)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
GetLogicInfoResponseAllData allData = null;
|
if (ZbGateway.MainGateWay == null)
|
{
|
allData = new GetLogicInfoResponseAllData { errorMessageBase = "当前没有主网关" };
|
return allData;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var gatewayTemp = new ZbGateway() { Time = jobject.Value<int>("Time"), DataID = jobject.Value<int>("Data_ID"), CurrentGateWayId = ZbGateway.MainGateWay.getGatewayBaseInfo.gwID };
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
allData = new GetLogicInfoResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
allData = new GetLogicInfoResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Logic/GetLogicInfo_Respon")
|
{
|
try
|
{
|
var logic = new Logic() { DataID = jobject.Value<int>("Data_ID"), GateWayId = ZbGateway.MainGateWay.CurrentGateWayId };
|
var tempTimeAttribute = Newtonsoft.Json.JsonConvert.DeserializeObject<TimeAttributeObj>(jobject["Data"]["TimeAttribute"].ToString());
|
var tempData = Newtonsoft.Json.JsonConvert.DeserializeObject<GetLogicInfoResponseBaseData>(jobject["Data"].ToString());
|
if (tempData != null)
|
{
|
var conditions = Newtonsoft.Json.Linq.JArray.Parse(jobject["Data"]["Conditions"].ToString());
|
allData = new GetLogicInfoResponseAllData { };
|
var tempD = new GetLogicInfoResponseData { };
|
for (int m = 0; conditions != null && m < conditions.Count; m++)
|
{
|
var condition = conditions[m];
|
var ads = condition["Type"].ToString();
|
switch (condition["Type"].ToString())
|
{
|
case "0":
|
tempD.Conditions.Add(Newtonsoft.Json.JsonConvert.DeserializeObject<Logic.TimeConditionsInfo>(condition.ToString()));
|
break;
|
case "1":
|
tempD.Conditions.Add(Newtonsoft.Json.JsonConvert.DeserializeObject<Logic.DeviceConditionsInfo>(condition.ToString()));
|
break;
|
case "2":
|
tempD.Conditions.Add(Newtonsoft.Json.JsonConvert.DeserializeObject<Logic.LogicConditionsInfo>(condition.ToString()));
|
break;
|
case "3":
|
tempD.Conditions.Add(Newtonsoft.Json.JsonConvert.DeserializeObject<Logic.CounterConditionsInfo>(condition.ToString()));
|
break;
|
case "4":
|
tempD.Conditions.Add(Newtonsoft.Json.JsonConvert.DeserializeObject<Logic.CountdownConditionsInfo>(condition.ToString()));
|
break;
|
case "5":
|
tempD.Conditions.Add(Newtonsoft.Json.JsonConvert.DeserializeObject<Logic.TimeBucketConditionsInfo>(condition.ToString()));
|
break;
|
}
|
}
|
if (tempTimeAttribute != null) { tempD.TimeAttribute = tempTimeAttribute; }
|
if (tempData.LogicName != null) { tempD.LogicName = tempData.LogicName; }
|
if (tempData.Actions != null) { tempD.Actions = tempData.Actions; }
|
tempD.LogicId = tempData.LogicId;
|
tempD.IsEnable = tempData.IsEnable;
|
tempD.Relationship = tempData.Relationship;
|
tempD.Result = tempData.Result;
|
allData.getLogicInfoResponseData = tempD;
|
var info = ZbGateway.LogicList.Find((Logic.GetLogicInfoResponseData obj) => obj.LogicId == tempData.LogicId);
|
if (info == null)
|
{
|
ZbGateway.LogicList.Add(allData.getLogicInfoResponseData);
|
}
|
else
|
{
|
info.LogicName = tempD.LogicName;
|
info.Result = tempD.Result;
|
info.Relationship = tempD.Relationship;
|
info.IsEnable = tempD.IsEnable;
|
info.Conditions = tempD.Conditions;
|
info.Actions = tempD.Actions;
|
info.TimeAttribute = tempD.TimeAttribute;
|
}
|
System.Console.WriteLine($"收到通知后的主题_{ topic}");
|
}
|
}
|
catch (Exception ex)
|
{
|
var mess = ex.Message;
|
}
|
}
|
};
|
ZbGateway.MainGateWay.Actions += action;
|
System.Console.WriteLine("Logic/GetLogicInfo_Actions 启动" + "_" + ZbGateway.MainGateWay.getGatewayBaseInfo.gwID + System.DateTime.Now.ToString());
|
|
try
|
{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 2002 } };
|
var data = new JObject {
|
{ "LogicId",logicId}
|
};
|
jObject.Add("Data", data);
|
ZbGateway.MainGateWay?.Send(("Logic/GetLogicInfo"), jObject.ToString());
|
}
|
catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < 4000)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (allData != null&& allData?.getLogicInfoResponseData!=null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > 4000)
|
{
|
allData = new GetLogicInfoResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
|
}
|
ZbGateway.MainGateWay.Actions -= action;
|
System.Console.WriteLine("Logic/GetLogicInfo_Actions 退出" + "_" + ZbGateway.MainGateWay.getGatewayBaseInfo.gwID + System.DateTime.Now.ToString());
|
|
return allData;
|
});
|
}
|
|
/// <summary>
|
///通过逻辑id获取逻辑信息的所有数据,网关反馈信息
|
/// </summary>
|
public GetLogicInfoResponseAllData getLogicInfoResponseAllData;
|
///<summary >
|
/// 通过逻辑id获取逻辑信息回复的所有数据
|
/// </summary>
|
[System.Serializable]
|
public class GetLogicInfoResponseAllData
|
{
|
/// <summary>
|
/// 错误信息
|
/// </summary>
|
public string errorMessageBase;
|
/// <summary>
|
/// 网关信息错误反馈
|
/// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
|
/// </summary>
|
public ErrorResponData errorResponData;
|
/// <summary>
|
/// 通过逻辑id获取逻辑信息回复的数据
|
/// </summary>
|
public GetLogicInfoResponseData getLogicInfoResponseData;
|
}
|
|
///<summary >
|
///通过逻辑id获取逻辑信息回复的数据
|
/// </summary>
|
public GetLogicInfoResponseData getLogicInfoResponseData;
|
///<summary >
|
/// 通过逻辑id获取逻辑信息回复的数据
|
/// </summary>
|
[System.Serializable]
|
public class GetLogicInfoResponseData : LogicBase
|
{
|
/// <summary>
|
///0：获取成功
|
///<para>1：该逻辑不存在。</para>
|
///<para>以下所有字段只有在Result 为1时存在</para>
|
/// </summary>
|
public int Result;
|
|
/// <summary>
|
///该逻辑是否被使能。
|
///<para>0：禁用该逻辑</para>
|
///<para>1：使能该逻辑</para>
|
///<para>2: 只触发一次。触发后该字段将自动置为0，即禁用状态。</para>
|
/// </summary>
|
public int IsEnable;
|
|
/// <summary>
|
///逻辑名称
|
/// </summary>
|
public string LogicName;
|
|
/// <summary>
|
///逻辑关系。
|
///<para>0：满足所有条件触发动作</para>
|
///<para>1：满足其中一个条件触发动作</para>
|
/// </summary>
|
public int Relationship;
|
|
/// <summary>
|
///逻辑关系。
|
///<para>0：满足所有条件触发动作</para>
|
///<para>1：满足其中一个条件触发动作</para>
|
/// </summary>
|
public TimeAttributeObj TimeAttribute = new TimeAttributeObj();
|
|
/// <summary>
|
/// 逻辑条件列表
|
/// </summary>
|
public List<ConditionBase> Conditions = new List<ConditionBase>();
|
|
/// <summary>
|
/// 条件满足后执行的动作列表
|
/// </summary>
|
public List<ActionsInfo> Actions = new List<ActionsInfo>();
|
}
|
|
[System.Serializable]
|
public class GetLogicInfoResponseBaseData : LogicBase
|
{
|
/// <summary>
|
///0：获取成功
|
///<para>1：该逻辑不存在。</para>
|
///<para>以下所有字段只有在Result 为1时存在</para>
|
/// </summary>
|
public int Result;
|
|
/// <summary>
|
///该逻辑是否被使能。
|
///<para>0：禁用该逻辑</para>
|
///<para>1：使能该逻辑</para>
|
///<para>2: 只触发一次。触发后该字段将自动置为0，即禁用状态。</para>
|
/// </summary>
|
public int IsEnable;
|
|
/// <summary>
|
///逻辑名称
|
/// </summary>
|
public string LogicName;
|
|
/// <summary>
|
///逻辑关系。
|
///<para>0：满足所有条件触发动作</para>
|
///<para>1：满足其中一个条件触发动作</para>
|
/// </summary>
|
public int Relationship;
|
|
/// <summary>
|
/// 逻辑条件列表
|
/// </summary>
|
public List<ConditionBase> Conditions = new List<ConditionBase>();
|
|
/// <summary>
|
/// 条件满足后执行的动作列表
|
/// </summary>
|
public List<ActionsInfo> Actions = new List<ActionsInfo>();
|
}
|
#endregion
|
|
#region 获取逻辑列表.
|
///<summary >
|
/// 获取逻辑列表
|
/// （当数量很多时，可能第一次获取失败，要到重新获取）
|
/// </summary>
|
public static async System.Threading.Tasks.Task<GetLogicListResponseAllData> GetLogicListAsync()
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
GetLogicListResponseAllData allData = null;
|
if (ZbGateway.MainGateWay == null)
|
{
|
allData = new GetLogicListResponseAllData { errorMessageBase = "当前没有主网关" };
|
return allData;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var gatewayTemp = new ZbGateway() { Time = jobject.Value<int>("Time"), DataID = jobject.Value<int>("Data_ID"), CurrentGateWayId = ZbGateway.MainGateWay.getGatewayBaseInfo.gwID };
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
allData = new GetLogicListResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
allData = new GetLogicListResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Logic/GetLogicList_Respon")
|
{
|
var logic = new Logic() { DataID = jobject.Value<int>("DataID"), GateWayId = ZbGateway.MainGateWay.CurrentGateWayId };
|
var tempBindList = Newtonsoft.Json.Linq.JArray.Parse(jobject["Data"]["LogicList"].ToString());
|
|
var tempData = Newtonsoft.Json.JsonConvert.DeserializeObject<GetLogicListResponseData>(jobject["Data"].ToString());
|
if (tempData == null)
|
{
|
allData = new GetLogicListResponseAllData { errorMessageBase = "网关返回的数据为空" };
|
}
|
else
|
{
|
allData = new GetLogicListResponseAllData { getLogicListResponseData = tempData };
|
System.Console.WriteLine($"收到通知后的主题_{ topic}");
|
}
|
}
|
};
|
ZbGateway.MainGateWay.Actions += action;
|
System.Console.WriteLine("Logic/GetLogicList_Actions 启动" + "_" + ZbGateway.MainGateWay.getGatewayBaseInfo.gwID + System.DateTime.Now.ToString());
|
|
try
|
{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 2004 } };
|
ZbGateway.MainGateWay?.Send(("Logic/GetLogicList"), jObject.ToString());
|
}
|
catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < 4000)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (allData != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > 4000)
|
{
|
allData = new GetLogicListResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
|
}
|
ZbGateway.MainGateWay.Actions -= action;
|
System.Console.WriteLine("Logic/GetLogicList_Actions 退出" + "_" + ZbGateway.MainGateWay.getGatewayBaseInfo.gwID + System.DateTime.Now.ToString());
|
|
return allData;
|
});
|
}
|
|
/// <summary>
|
///通过逻辑id获取逻辑信息的所有数据,网关反馈信息
|
/// </summary>
|
public GetLogicListResponseAllData getLogicListResponseAllData;
|
///<summary >
|
/// 通过逻辑id获取逻辑信息回复的所有数据
|
/// </summary>
|
[System.Serializable]
|
public class GetLogicListResponseAllData
|
{
|
/// <summary>
|
/// 错误信息
|
/// </summary>
|
public string errorMessageBase;
|
/// <summary>
|
/// 网关信息错误反馈
|
/// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
|
/// </summary>
|
public ErrorResponData errorResponData;
|
/// <summary>
|
/// 通过逻辑id获取逻辑信息回复的数据
|
/// </summary>
|
public GetLogicListResponseData getLogicListResponseData;
|
}
|
|
///<summary >
|
///通过逻辑id获取逻辑信息回复的数据
|
/// </summary>
|
public GetLogicListResponseData getLogicListResponseData;
|
///<summary >
|
/// 通过逻辑id获取逻辑信息回复的数据
|
/// </summary>
|
[System.Serializable]
|
public class GetLogicListResponseData : LogicBase
|
{
|
/// <summary>
|
/// 逻辑条件列表
|
/// </summary>
|
public List<LogicListData> LogicList = new List<LogicListData>();
|
|
}
|
|
/// <summary>
|
/// 逻辑列表具体数据
|
/// </summary>
|
[System.Serializable]
|
public class LogicListData : LogicBase
|
{
|
|
/// <summary>
|
/// 逻辑名称
|
/// </summary>
|
public string LogicName;
|
|
/// <summary>
|
/// 该逻辑是否被使能。
|
///<para>0：禁用该逻辑</para>
|
///<para>1：使能该逻辑</para>
|
///<para>2: 只触发一次。触发后该字段将自动置为0，即禁用状态</para>
|
/// </summary>
|
public int IsEnable;
|
|
/// <summary>
|
///逻辑关系。
|
///<para>0：满足所有条件触发动作</para>
|
///<para>1：满足其中一个条件触发动作</para>
|
/// </summary>
|
public int Relationship;
|
|
}
|
#endregion
|
|
#region 新增或修改逻辑条件.
|
///<summary >
|
/// 新增或修改逻辑条件
|
/// <para>ChangeConditionData中type有效，此时ConditionObj中的type无效</para>
|
/// </summary>
|
public static async System.Threading.Tasks.Task<ChangeConditionResponseAllData> ChangeConditionAsync(ChangeConditionData changeConditionData)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
ChangeConditionResponseAllData allData = null;
|
if (ZbGateway.MainGateWay == null)
|
{
|
allData = new ChangeConditionResponseAllData { errorMessageBase = "当前没有主网关" };
|
return allData;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var gatewayTemp = new ZbGateway() { Time = jobject.Value<int>("Time"), DataID = jobject.Value<int>("Data_ID"), CurrentGateWayId = ZbGateway.MainGateWay.getGatewayBaseInfo.gwID };
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
allData = new ChangeConditionResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
allData = new ChangeConditionResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Logic/ChangeCondition_Respon")
|
{
|
var logic = new Logic() { DataID = jobject.Value<int>("DataID"), GateWayId = ZbGateway.MainGateWay.CurrentGateWayId };
|
var tempData = Newtonsoft.Json.JsonConvert.DeserializeObject<ChangeConditionResponseData>(jobject["Data"].ToString());
|
if (tempData == null)
|
{
|
allData = new ChangeConditionResponseAllData { errorMessageBase = "网关返回的数据为空" };
|
}
|
else
|
{
|
switch (tempData.Type)
|
{
|
case 0:
|
var timeObj = new ZigBee.Device.Logic.TimeConditionsInfo();
|
timeObj.IsValid = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["IsValid"].ToString());
|
timeObj.DateType = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["DateType"].ToString());
|
timeObj.StartHour = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["StartHour"].ToString());
|
timeObj.StartMin = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["StartMin"].ToString());
|
timeObj.AdjustTime = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["AdjustTime"].ToString());
|
timeObj.RemindTime = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["RemindTime"].ToString());
|
timeObj.EnDelay = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["EnDelay"].ToString());
|
timeObj.DelayTime = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["DelayTime"].ToString());
|
tempData.conditionObj = timeObj;
|
break;
|
case 1:
|
var devObj = new ZigBee.Device.Logic.DeviceConditionsInfo();
|
devObj.IsValid = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["IsValid"].ToString());
|
devObj.Epoint = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["Epoint"].ToString());
|
devObj.Cluster_ID = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["Cluster_ID"].ToString());
|
devObj.AttriButeId = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["AttriButeId"].ToString());
|
devObj.AttriButeData1 = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["AttriButeData1"].ToString());
|
devObj.AttriButeData2 = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["AttriButeData2"].ToString());
|
devObj.Range = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["Range"].ToString());
|
var tempAddrObj =Newtonsoft.Json.JsonConvert.DeserializeObject<MacAddrData>(jobject["Data"].ToString());
|
if(tempAddrObj.MacAddr != null)
|
{
|
devObj.MacAddr = tempAddrObj.MacAddr;
|
}
|
tempData.conditionObj = devObj;
|
break;
|
case 2:
|
var logicObj = new ZigBee.Device.Logic.LogicConditionsInfo ();
|
logicObj.IsValid = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["IsValid"].ToString());
|
logicObj.Condition_LogicId = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["Condition_LogicId"].ToString());
|
tempData.conditionObj = logicObj;
|
break;
|
case 3:
|
var countObj = new ZigBee.Device.Logic.CounterConditionsInfo();
|
countObj.IsValid = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["IsValid"].ToString());
|
countObj.Epoint = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["Epoint"].ToString());
|
countObj.Cluster_ID = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["Cluster_ID"].ToString());
|
countObj.AttriButeId = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["AttriButeId"].ToString());
|
countObj.AttriButeData1 = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["AttriButeData1"].ToString());
|
countObj.AttriButeData2 = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["AttriButeData2"].ToString());
|
countObj.Range = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["Range"].ToString());
|
countObj.Number = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["Number"].ToString());
|
countObj.Time = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["Time"].ToString());
|
countObj.Cycle = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["Cycle"].ToString());
|
var tempAddrObj2 = Newtonsoft.Json.JsonConvert.DeserializeObject<MacAddrData>(jobject["Data"].ToString());
|
if (tempAddrObj2.MacAddr != null)
|
{
|
countObj.MacAddr = tempAddrObj2.MacAddr;
|
}
|
tempData.conditionObj = countObj;
|
break;
|
case 4:
|
var cdObj = new ZigBee.Device.Logic.CountdownConditionsInfo();
|
cdObj.IsValid = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["IsValid"].ToString());
|
cdObj.Time = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["Time"].ToString());
|
tempData.conditionObj = cdObj;
|
break;
|
case 5:
|
var tbObj = new ZigBee.Device.Logic.TimeBucketConditionsInfo();
|
tbObj.IsValid = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["IsValid"].ToString());
|
tbObj.StartHour = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["StartHour"].ToString());
|
tbObj.StartMin = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["StartMin"].ToString());
|
tbObj.StopHour = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["StopHour"].ToString());
|
tbObj.StopMin = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["StopMin"].ToString());
|
tempData.conditionObj = tbObj;
|
break;
|
case 6:
|
var securitybObj = new ZigBee.Device.Logic.SecurityConditionsInfo();
|
securitybObj.IsValid = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["IsValid"].ToString());
|
securitybObj.EnOrWithdrawMode = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["EnOrWithdrawMode"].ToString());
|
securitybObj.ModeId = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["ModeId"].ToString());
|
tempData.conditionObj = securitybObj;
|
break;
|
}
|
allData = new ChangeConditionResponseAllData { changeConditionResponseData = tempData };
|
System.Console.WriteLine($"收到通知后的主题_{ topic}");
|
}
|
}
|
};
|
ZbGateway.MainGateWay.Actions += action;
|
System.Console.WriteLine("Logic/GetLogicList_Actions 启动" + "_" + ZbGateway.MainGateWay.getGatewayBaseInfo.gwID + System.DateTime.Now.ToString());
|
|
try
|
{
|
if(changeConditionData!=null){
|
var dataPublish = new Dictionary<string, object> { };
|
switch (changeConditionData.Type)
|
{
|
case 0:
|
var timeConditionsObj = changeConditionData.conditionObj as TimeConditionsInfo;
|
var dataPublish1 = new Dictionary<string, object>
|
{
|
["LogicId"] = changeConditionData.LogicId,
|
["ConditionId"] = changeConditionData.ConditionId,
|
["Type"] = changeConditionData.Type,
|
["IsValid"] = timeConditionsObj.IsValid,
|
["DateType"] = timeConditionsObj.DateType,
|
["StartHour"] = timeConditionsObj.StartHour,
|
["StartMin"] = timeConditionsObj.StartMin,
|
["AdjustTime"] = timeConditionsObj.AdjustTime,
|
["RemindTime"] = timeConditionsObj.RemindTime,
|
["EnDelay"] = timeConditionsObj.EnDelay,
|
["DelayTime"] = timeConditionsObj.DelayTime
|
};
|
dataPublish = dataPublish1;
|
break;
|
case 1:
|
var deviceConditionsObj = changeConditionData.conditionObj as DeviceConditionsInfo;
|
var dataPublish2 = new Dictionary<string, object>
|
{
|
["LogicId"] = changeConditionData.LogicId,
|
["ConditionId"] = changeConditionData.ConditionId,
|
["Type"] = changeConditionData.Type,
|
["IsValid"] = deviceConditionsObj.IsValid,
|
["MacAddr"] = deviceConditionsObj.MacAddr,
|
["Epoint"] = deviceConditionsObj.Epoint,
|
["Cluster_ID"] = deviceConditionsObj.Cluster_ID,
|
["AttriButeId"] = deviceConditionsObj.AttriButeId,
|
["AttriButeData1"] = deviceConditionsObj.AttriButeData1,
|
["AttriButeData2"] = deviceConditionsObj.AttriButeData2,
|
["Range"] = deviceConditionsObj.Range,
|
};
|
dataPublish = dataPublish2;
|
break;
|
case 2:
|
var logicConditionsObj = changeConditionData.conditionObj as LogicConditionsInfo;
|
var dataPublish3 = new Dictionary<string, object>
|
{
|
["LogicId"] = changeConditionData.LogicId,
|
["ConditionId"] = changeConditionData.ConditionId,
|
["Type"] = changeConditionData.Type,
|
["IsValid"] = logicConditionsObj.IsValid,
|
["Condition_LogicId"] = logicConditionsObj.Condition_LogicId,
|
};
|
dataPublish = dataPublish3;
|
break;
|
case 3:
|
var cConditionsObj = changeConditionData.conditionObj as CounterConditionsInfo;
|
var dataPublish4 = new Dictionary<string, object>
|
{
|
["LogicId"] = changeConditionData.LogicId,
|
["ConditionId"] = changeConditionData.ConditionId,
|
["Type"] = changeConditionData.Type,
|
["IsValid"] = cConditionsObj.IsValid,
|
["MacAddr"] = cConditionsObj.MacAddr,
|
["Epoint"] = cConditionsObj.Epoint,
|
["Cluster_ID"] = cConditionsObj.Cluster_ID,
|
["AttriButeId"] = cConditionsObj.AttriButeId,
|
["AttriButeData1"] = cConditionsObj.AttriButeData1,
|
["AttriButeData2"] = cConditionsObj.AttriButeData2,
|
["Range"] = cConditionsObj.Range,
|
["Number"] = cConditionsObj.Number,
|
["Time"] = cConditionsObj.Time,
|
["Cycle"] = cConditionsObj.Cycle,
|
};
|
dataPublish = dataPublish4;
|
break;
|
case 4:
|
var cdConditionsObj = changeConditionData.conditionObj as CountdownConditionsInfo;
|
var dataPublish5 = new Dictionary<string, object>
|
{
|
["LogicId"] = changeConditionData.LogicId,
|
["ConditionId"] = changeConditionData.ConditionId,
|
["Type"] = changeConditionData.Type,
|
["IsValid"] = cdConditionsObj.IsValid,
|
["Time"] = cdConditionsObj.Time,
|
};
|
dataPublish = dataPublish5;
|
break;
|
case 5:
|
var tbConditionsObj = changeConditionData.conditionObj as TimeBucketConditionsInfo;
|
var dataPublish6 = new Dictionary<string, object>
|
{
|
["LogicId"] = changeConditionData.LogicId,
|
["ConditionId"] = changeConditionData.ConditionId,
|
["Type"] = changeConditionData.Type,
|
["IsValid"] = tbConditionsObj.IsValid,
|
["StartHour"] = tbConditionsObj.StartHour,
|
["StartMin"] = tbConditionsObj.StartMin,
|
["StopHour"] = tbConditionsObj.StopHour,
|
["StopMin"] = tbConditionsObj.StopMin,
|
};
|
dataPublish = dataPublish6;
|
break;
|
case 6:
|
var sConditionsObj = changeConditionData.conditionObj as SecurityConditionsInfo;
|
var dataPublish7 = new Dictionary<string, object>
|
{
|
["LogicId"] = changeConditionData.LogicId,
|
["ConditionId"] = changeConditionData.ConditionId,
|
["Type"] = changeConditionData.Type,
|
["IsValid"] = sConditionsObj.IsValid,
|
["EnOrWithdrawMode"] = sConditionsObj.EnOrWithdrawMode,
|
["ModeId"] = sConditionsObj.ModeId,
|
};
|
dataPublish = dataPublish7;
|
break;
|
}
|
ZbGateway.MainGateWay?.Send("Logic/ChangeCondition", Device.Cluster_ID.Gateway, Command.LogicChangeCondition, Newtonsoft.Json.Linq.JObject.Parse(Newtonsoft.Json.JsonConvert.SerializeObject(dataPublish)));
|
}
|
}catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < 2000)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (allData != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > 2000)
|
{
|
allData = new ChangeConditionResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
|
}
|
ZbGateway.MainGateWay.Actions -= action;
|
System.Console.WriteLine("Logic/GetLogicList_Actions 退出" + "_" + ZbGateway.MainGateWay.getGatewayBaseInfo.gwID + System.DateTime.Now.ToString());
|
|
return allData;
|
});
|
}
|
|
/// <summary>
|
///新增或修改逻辑条件所有数据,网关反馈信息
|
/// </summary>
|
public ChangeConditionResponseAllData changeConditionResponseAllData;
|
///<summary >
|
/// 新增或修改逻辑条件回复的所有数据
|
/// </summary>
|
[System.Serializable]
|
public class ChangeConditionResponseAllData
|
{
|
/// <summary>
|
/// 错误信息
|
/// </summary>
|
public string errorMessageBase;
|
/// <summary>
|
/// 网关信息错误反馈
|
/// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
|
/// </summary>
|
public ErrorResponData errorResponData;
|
/// <summary>
|
/// 新增或修改逻辑条件回复的数据
|
/// </summary>
|
public ChangeConditionResponseData changeConditionResponseData;
|
}
|
|
[System.Serializable]
|
public class MacAddrData
|
{
|
/// <summary>
|
/// 物理地址
|
/// </summary>
|
public string MacAddr;
|
|
}
|
|
///<summary >
|
///新增或修改逻辑条件回复的数据
|
/// </summary>
|
public ChangeConditionResponseData changeConditionResponseData;
|
///<summary >
|
/// 通新增或修改逻辑条件回复的数据
|
/// </summary>
|
[System.Serializable]
|
public class ChangeConditionResponseData : LogicBase
|
{
|
/// <summary>
|
/// 条件id(当新增或修改逻辑条件时，该字段有效）
|
/// </summary>
|
public int ConditionId;
|
/// <summary>
|
/// 该条件是否作为判断逻辑依据。当条件无效时，则忽略该条件。一个逻辑应该至少有一个有效条件用于判断逻辑是否成立，当一个逻辑所有条件无效时，该逻辑将永远不会生效。
|
///<para>0：无效（忽略条件）。</para>
|
///<para>1：有效（启用条件）。</para>
|
///<para>2：使能一次（条件成立一次后将被禁用，IsValid自动置为0）。</para>
|
///<para>3：失能一次（条件第一次成立会被忽略，触发不了逻辑，然后IsValid自动置1。以后条件再成立将不会被忽略）</para>
|
/// </summary>
|
public int IsValid;
|
/// <summary>
|
///条件类型
|
///<para>0：时间点条件，在某个时间发生</para>
|
///<para>1：设备状态变化条件</para>
|
///<para>2：其他逻辑条件</para>
|
///<para>3：计数器条件</para>
|
///<para>4：倒计时</para>
|
///<para>5：时间段条件</para>
|
/// </summary>
|
public int Type;
|
|
/// <summary>
|
/// conditionObj:条件对象
|
/// </summary>
|
public ConditionBase conditionObj;
|
}
|
|
/// <summary>
|
/// 新增或修改逻辑条件的数据
|
/// </summary>
|
public ChangeConditionData changeConditionData;
|
/// <summary>
|
/// 新增或修改逻辑条件的数据
|
/// </summary>
|
[System.Serializable]
|
public class ChangeConditionData : LogicBase
|
{
|
/// <summary>
|
///(注意必需填写）条件类型;(没填写数据可能不回复）
|
///<para>0：时间点条件，在某个时间发生</para>
|
///<para>1：设备状态变化条件</para>
|
///<para>2：其他逻辑条件</para>
|
///<para>3：计数器条件</para>
|
///<para>4：倒计时</para>
|
///<para>5：时间段条件</para>
|
///<para>6：安防条件</para>
|
/// </summary>
|
public int Type;
|
/// <summary>
|
/// 条件id
|
/// 新增时ConditionId=0，修改时传入对应的ConditionId
|
/// </summary>
|
public int ConditionId;
|
/// <summary>
|
/// conditionObj:条件对象
|
/// </summary>
|
public ConditionBase conditionObj;
|
}
|
#endregion
|
|
#region 删除/启用/禁用逻辑条件.
|
///<summary >
|
/// 删除/启用/禁用逻辑条件
|
/// </summary>
|
public static async System.Threading.Tasks.Task<SetConditionResponseAllData> SetConditionAsync(SetConditionData setConditionData)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
SetConditionResponseAllData allData = null;
|
if (ZbGateway.MainGateWay == null)
|
{
|
allData = new SetConditionResponseAllData { errorMessageBase = "当前没有主网关" };
|
return allData;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var gatewayTemp = new ZbGateway() { Time = jobject.Value<int>("Time"), DataID = jobject.Value<int>("Data_ID"), CurrentGateWayId = ZbGateway.MainGateWay.getGatewayBaseInfo.gwID };
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
allData = new SetConditionResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
allData = new SetConditionResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Logic/SetCondition_Respon")
|
{
|
var logic = new Logic() { DataID = jobject.Value<int>("DataID"), GateWayId = ZbGateway.MainGateWay.CurrentGateWayId };
|
var tempData = Newtonsoft.Json.JsonConvert.DeserializeObject<SetConditionResponseData>(jobject["Data"].ToString());
|
if (tempData == null)
|
{
|
allData = new SetConditionResponseAllData { errorMessageBase = "网关返回的数据为空" };
|
}
|
else
|
{
|
allData = new SetConditionResponseAllData { setConditionResponseData = tempData };
|
System.Console.WriteLine($"收到通知后的主题_{ topic}");
|
}
|
}
|
};
|
ZbGateway.MainGateWay.Actions += action;
|
System.Console.WriteLine("Logic/SetCondition_Actions 启动" + "_" + ZbGateway.MainGateWay.getGatewayBaseInfo.gwID + System.DateTime.Now.ToString());
|
|
try
|
{
|
if(setConditionData !=null){
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 2006 } };
|
|
var data = new JObject {
|
{ "LogicId",setConditionData.LogicId},
|
{ "ConditionId", setConditionData.ConditionId} ,
|
{ "Operation", setConditionData.Operation }
|
};
|
jObject.Add("Data", data);
|
ZbGateway.MainGateWay?.Send(("Logic/SetCondition"), jObject.ToString());
|
}
|
}
|
catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < 2000)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (allData != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > 2000)
|
{
|
allData = new SetConditionResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
|
}
|
ZbGateway.MainGateWay.Actions -= action;
|
System.Console.WriteLine("Logic/SetCondition_Actions 退出" + "_" + ZbGateway.MainGateWay.getGatewayBaseInfo.gwID + System.DateTime.Now.ToString());
|
|
return allData;
|
});
|
}
|
|
/// <summary>
|
///删除/启用/禁用逻辑条件的所有数据,网关反馈信息
|
/// </summary>
|
public SetConditionResponseAllData setConditionResponseAllData;
|
///<summary >
|
/// 删除/启用/禁用逻辑条件回复的所有数据
|
/// </summary>
|
[System.Serializable]
|
public class SetConditionResponseAllData
|
{
|
/// <summary>
|
/// 错误信息
|
/// </summary>
|
public string errorMessageBase;
|
/// <summary>
|
/// 网关信息错误反馈
|
/// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
|
/// </summary>
|
public ErrorResponData errorResponData;
|
/// <summary>
|
/// 删除/启用/禁用逻辑条件回复的数据
|
/// </summary>
|
public SetConditionResponseData setConditionResponseData;
|
}
|
|
/// <summary>
|
///获取删除/启用/禁用逻辑条件的数据
|
/// </summary>
|
public SetConditionResponseData setConditionResponseData;
|
/// <summary>
|
///获取删除/启用/禁用逻辑条件的数据
|
/// </summary>
|
[System.Serializable]
|
public class SetConditionResponseData : LogicBase
|
{
|
/// <summary>
|
/// 0：成功
|
///<para>1：失败，逻辑或条件不存在</para>
|
/// </summary>
|
public int Result;
|
|
/// <summary>
|
/// 条件id
|
/// </summary>
|
public int ConditionId;
|
/// <summary>
|
/// 0：忽略条件，将条件IsVaild置0。
|
///<para>1：启用条件，将条件IsVaild置1。</para>
|
///<para>2：使能一次，将条件IsVaild置2（条件成立一次后将被禁用，IsValid自动置为0）。</para>
|
///<para>3：失能一次，将条件IsVaild置3（条件第一次成立会被忽略，触发不了逻辑，然后IsValid自动置1。以后条件再成立将不会被忽略）</para>
|
///<para>4：删除条件。</para>
|
/// </summary>
|
public int Operation;
|
}
|
|
/// <summary>
|
///设置删除/启用/禁用逻辑条件的数据
|
/// </summary>
|
public SetConditionData setConditionData;
|
/// <summary>
|
///设置删除/启用/禁用逻辑条件的数据
|
/// </summary>
|
[System.Serializable]
|
public class SetConditionData : LogicBase
|
{
|
/// <summary>
|
/// 条件id
|
/// </summary>
|
public int ConditionId;
|
/// <summary>
|
/// 0：忽略条件，将条件IsVaild置0。
|
///<para>1：启用条件，将条件IsVaild置1。</para>
|
///<para>2：使能一次，将条件IsVaild置2（条件成立一次后将被禁用，IsValid自动置为0）。</para>
|
///<para>3：失能一次，将条件IsVaild置3（条件第一次成立会被忽略，触发不了逻辑，然后IsValid自动置1。以后条件再成立将不会被忽略）</para>
|
///<para>4：删除条件。</para>
|
/// </summary>
|
public int Operation = 1;
|
}
|
#endregion
|
|
#region 修改或新增动作任务.
|
///<summary >
|
/// 修改或新增动作任务
|
/// </summary>
|
public static async System.Threading.Tasks.Task<ChangeActionResponseAllData> ChangeActionAsync(ChangeActionData actionData)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
ChangeActionResponseAllData allData = null;
|
if (ZbGateway.MainGateWay == null)
|
{
|
allData = new ChangeActionResponseAllData { errorMessageBase = "当前没有主网关" };
|
return allData;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var gatewayTemp = new ZbGateway() { Time = jobject.Value<int>("Time"), DataID = jobject.Value<int>("Data_ID"), CurrentGateWayId = ZbGateway.MainGateWay.getGatewayBaseInfo.gwID };
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
allData = new ChangeActionResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
allData = new ChangeActionResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Logic/ChangeAction_Respon")
|
{
|
var logic = new Logic() { DataID = jobject.Value<int>("DataID"), GateWayId = ZbGateway.MainGateWay.CurrentGateWayId };
|
var tempData = Newtonsoft.Json.JsonConvert.DeserializeObject<ChangeActionResponseData>(jobject["Data"].ToString());
|
if (tempData == null)
|
{
|
allData = new ChangeActionResponseAllData { errorMessageBase = "网关返回的数据为空" };
|
}
|
else
|
{
|
allData = new ChangeActionResponseAllData { changeActionResponseData = tempData };
|
System.Console.WriteLine($"收到通知后的主题_{ topic}");
|
}
|
}
|
};
|
ZbGateway.MainGateWay.Actions += action;
|
System.Console.WriteLine("Logic/ChangeAction_Actions 启动" + "_" + ZbGateway.MainGateWay.getGatewayBaseInfo.gwID + System.DateTime.Now.ToString());
|
|
try
|
{
|
if (actionData != null)
|
{
|
var dataPublish = new Dictionary<string, object> { };
|
switch (actionData.LinkType)
|
{
|
case 0:
|
var dataPublish0 = new Dictionary<string, object>
|
{
|
["LogicId"] = actionData.LogicId,
|
["LinkType"] = actionData.LinkType,
|
["DeviceAddr"] = actionData.DeviceAddr,
|
["Epoint"] = actionData.Epoint,
|
["TaskList"] = actionData.TaskList,
|
["Time"] = actionData.Time,
|
};
|
dataPublish = dataPublish0;
|
break;
|
case 2:
|
int sceneID = int.Parse(actionData.DeviceAddr);
|
var dataPublish2 = new Dictionary<string, object>
|
{
|
["LogicId"] = actionData.LogicId,
|
["LinkType"] = actionData.LinkType,
|
["DeviceAddr"] = sceneID,
|
["Epoint"] = actionData.Epoint,
|
};
|
dataPublish = dataPublish2;
|
break;
|
case 4:
|
int conID = int.Parse(actionData.DeviceAddr);
|
var dataPublish4 = new Dictionary<string, object> //{ };
|
{
|
["LogicId"] = actionData.LogicId,
|
["LinkType"] = actionData.LinkType,
|
["DeviceAddr"] = conID,
|
["EnableLogic"] = actionData.EnableLogic,
|
};
|
dataPublish = dataPublish4;
|
break;
|
case 5:
|
int logID = int.Parse(actionData.DeviceAddr);
|
var dataPublish5 = new Dictionary<string, object>
|
{
|
["LogicId"] = actionData.LogicId,
|
["LinkType"] = actionData.LinkType,
|
["DeviceAddr"] = logID,
|
["ConditionId"] = actionData.ConditionId,
|
["EnableCondition"] = actionData.EnableCondition,
|
};
|
dataPublish = dataPublish5;
|
break;
|
case 6:
|
int sID = int.Parse(actionData.DeviceAddr);
|
var dataPublish6 = new Dictionary<string, object>
|
{
|
["LogicId"] = actionData.LogicId,
|
["LinkType"] = actionData.LinkType,
|
["SecuritySetting"] = actionData.SecuritySetting,
|
["SecurityModeId"] = actionData.SecurityModeId,
|
["CheckIASStatus"] = actionData.CheckIASStatus,
|
["IsDelayStart"] = actionData.IsDelayStart,
|
["Password"] = actionData.Password
|
};
|
dataPublish = dataPublish6;
|
break;
|
}
|
ZbGateway.MainGateWay?.Send("Logic/ChangeAction", Device.Cluster_ID.Gateway, Command.LogicChangeAction, Newtonsoft.Json.Linq.JObject.Parse(Newtonsoft.Json.JsonConvert.SerializeObject(dataPublish)));
|
|
}
|
}
|
catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < 2000)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (allData != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > 2000)
|
{
|
allData = new ChangeActionResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
|
}
|
ZbGateway.MainGateWay.Actions -= action;
|
System.Console.WriteLine("Logic/ChangeAction_Actions 退出" + "_" + ZbGateway.MainGateWay.getGatewayBaseInfo.gwID + System.DateTime.Now.ToString());
|
|
return allData;
|
});
|
}
|
|
/// <summary>
|
///修改或新增动作任务的所有数据,网关反馈信息
|
/// </summary>
|
public ChangeActionResponseAllData changeActionResponseAllData;
|
///<summary >
|
/// 修改或新增动作任务回复的所有数据
|
/// </summary>
|
[System.Serializable]
|
public class ChangeActionResponseAllData
|
{
|
/// <summary>
|
/// 错误信息
|
/// </summary>
|
public string errorMessageBase;
|
/// <summary>
|
/// 网关信息错误反馈
|
/// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
|
/// </summary>
|
public ErrorResponData errorResponData;
|
/// <summary>
|
/// 修改或新增动作任务回复的数据
|
/// </summary>
|
public ChangeActionResponseData changeActionResponseData;
|
}
|
|
/// <summary>
|
///修改或新增动作任务回复的数据
|
/// </summary>
|
public ChangeActionResponseData changeActionResponseData;
|
/// <summary>
|
///获取修改或新增动作任务的数据
|
/// </summary>
|
[System.Serializable]
|
public class ChangeActionResponseData : LogicBase
|
{
|
/// <summary>
|
/// 0：成功
|
///<para>1：失败，逻辑不存在</para>
|
///<para>2：失败，联动设备不存在</para>
|
///<para>3：失败，联动的其他逻辑不存在。</para>
|
///<para>5：操作的逻辑的条件不存在</para>
|
///<para>6：布防撤防用户密码错误</para>
|
///<para>7：安防模式不存在</para>
|
/// </summary>
|
public int Result;
|
/// <summary>
|
/// 添加的联动设备类型
|
///<para>0：联动设备为zigbee节点设备</para>
|
///<para>2：联动设备为场景（恢复场景）</para>
|
///<para>4：使能失能其他逻辑</para>
|
///<para>5：禁用或启用逻辑条件</para>
|
///<para>6：安防模式操作</para>
|
/// </summary>
|
public int LinkType;
|
/// <summary>
|
/// 联动设备的地址：
|
///<para>设备mac地址（字符），LinkType=0。</para>
|
///<para>对场景操作，即恢复场景 为场景id（数值），LinkType为2。</para>
|
///<para>对其他逻辑操作 为逻辑id（数值），LinkType=4 、LinkType= 5。</para>
|
/// </summary>
|
public string DeviceAddr;
|
/// <summary>
|
///联动设备的端口号：
|
///<para>和mac地址共同标识唯一的zigbee设备 数值范围0-255</para>
|
///<para>场景和组设为null，或忽略该字段</para>
|
/// </summary>
|
public int Epoint;
|
/// <summary>
|
///逻辑使能、失能。
|
///<para>当LinkType = 4时存在</para>
|
///<para>0：失能逻辑。</para>
|
///<para>1：使能逻辑。</para>
|
///<para>2：只使能一次</para>
|
///<para>3：只失能一次</para>
|
/// </summary>
|
public int EnableLogic;
|
/// <summary>
|
/// 操作的逻辑条件id
|
/// </summary>
|
public int ConditionId;
|
/// <summary>
|
/// 是否禁用逻辑条件
|
///<para>当LinkType=5时存在</para>
|
///<para>0 禁用条件（将逻辑条件的IsValid字段置0）</para>
|
///<para>1 启用条件（将逻辑条件的IsValid字段置1）</para>
|
///<para>2：使能一次（条件成立一次后将被禁用，IsValid自动置为0）。</para>
|
///<para>3：失能一次（条件第一次成立会被忽略，触发不了逻辑，然后IsValid自动置1。以后条件再成立将不会被忽略）</para>
|
/// </summary>
|
public int EnableCondition;
|
/// <summary>
|
///延时执行时间。单位（秒）范围：0-65535。
|
///<para>逻辑成立后，延迟多久执行设备动作指令。</para>
|
///<para>当LinkType=0时存在。该字段可忽略，默认为0，即逻辑成立后立即执行设备动作。</para>
|
/// </summary>
|
public int Time;
|
/// <summary>
|
/// 联动任务列表，联动的节点设备执行的动作指令。
|
///<para>当LinkType=0时存在。</para>
|
///<para>和本章第1小节的添加或修改逻辑命令的TaskList数组格式相同</para>
|
/// </summary>
|
public List<TaskListInfo> TaskList = new List<TaskListInfo> { };
|
|
///<summary>
|
///对安防模式操作
|
///<para>当LinkType = 6时存在</para>
|
///<para>0：撤防</para>
|
///<para>1：永久布防，直到撤防</para>
|
///<para>2：布防，但使能一次，触发一次后将撤防。</para>
|
///<para>3：布防，但失能一次，第一次被激活不警告不触发动作。</para>
|
///<para>触发动作时，如果系统当前没有布防，则撤防失败。已经存在布防模式，将布防失败（需先对当前布防模式进行撤防）</para>
|
/// </summary>
|
/// <value>The epoint.</value>
|
public int SecuritySetting;
|
|
///<summary>
|
///安防模式id。为0时，则对当前在布防的安防模式进行操作。
|
/// </summary>
|
/// <value>The epoint.</value>
|
public int SecurityModeId;
|
|
///<summary>
|
///检查防区设备最近上报的安防信息状态进行布防
|
///<para>当LinkType = 6时存在</para>
|
///<para>0：不检查</para>
|
///<para>1：检查</para>
|
///<para>可缺省，默认为0</para>
|
/// </summary>
|
/// <value>The epoint.</value>
|
public int CheckIASStatus;
|
|
///<summary>
|
///是否延时启动。布防后延时一段时间正式启动防区，这段时间可以让人员撤离防区区域。
|
///<para>当LinkType = 6时存在</para>
|
///<para>0：不延时</para>
|
///<para>1：延时启动</para>
|
///<para>可缺省，默认为0</para>
|
/// </summary>
|
/// <value>The epoint.</value>
|
public int IsDelayStart;
|
}
|
/// <summary>
|
///设置需要修改或新增动作任务的数据
|
/// </summary>
|
public ChangeActionData changeActionData;
|
/// <summary>
|
///设置需要修改或新增动作任务的数据
|
/// LogicId，
|
/// </summary>
|
[System.Serializable]
|
public class ChangeActionData : LogicBase
|
{
|
/// <summary>
|
/// 添加的联动设备类型
|
///<para>0：联动设备为zigbee节点设备</para>
|
///<para>2：联动设备为场景（恢复场景）</para>
|
///<para>4：使能失能其他逻辑</para>
|
///<para>5：禁用或启用逻辑条件</para>
|
///<para> 6：安防模式操作</para>
|
/// </summary>
|
public int LinkType;
|
/// <summary>
|
/// 联动设备的地址：
|
/// <para>设备mac地址（字符），LinkType=0。</para>
|
///<para>对场景操作，即恢复场景 为场景id（数值），LinkType为2。</para>
|
///<para>对其他逻辑操作 为逻辑id（数值），LinkType=4 、LinkType= 5。</para>
|
/// </summary>
|
public string DeviceAddr;
|
/// <summary>
|
/// 联动设备的端口号：LinkType=0时存在
|
///<para>和mac地址共同标识唯一的zigbee设备 数值范围0-255</para>
|
///<para>场景和组设为null，或忽略该字段</para>
|
/// </summary>
|
public int Epoint;
|
/// <summary>
|
/// 逻辑使能、失能。LinkType=4时存在
|
///<para>0：失能逻辑。</para>
|
///<para>1：使能逻辑。</para>
|
///<para>2：只使能一次</para>
|
///<para>3：只失能一次</para>
|
/// </summary>
|
public int EnableLogic;
|
/// <summary>
|
/// 操作的逻辑条件id，LinkType=5时存在
|
/// </summary>
|
public int ConditionId;
|
/// <summary>
|
/// 是否禁用逻辑条件，LinkType=5时存在
|
///<para>0 禁用条件（将逻辑条件的IsValid字段置0）</para>
|
///<para>1 启用条件（将逻辑条件的IsValid字段置1）</para>
|
///<para>2：使能一次（条件成立一次后将被禁用，IsValid自动置为0）。</para>
|
///<para>3：失能一次（条件第一次成立会被忽略，触发不了逻辑，然后IsValid自动置1。以后条件再成立将不会被忽略）</para>
|
/// </summary>
|
public int EnableCondition;
|
/// <summary>
|
///延时执行时间。LinkType=0时存在
|
///<para>当LinkType=0时，该字段也可忽略，默认为0，即逻辑成立后立即执行设备动作。</para>
|
///<para>单位（秒）范围：0-65535。</para>
|
///<para>逻辑成立后，延迟多久执行设备动作指令。</para>
|
/// </summary>
|
public int Time;
|
/// <summary>
|
///联动任务列表，LinkType=0时存在
|
///<para>联动的节点设备执行的动作指令。</para>
|
///<para>和本章第1小节的添加或修改逻辑命令的TaskList数组格式相同</para>
|
/// </summary>
|
public List<TaskListInfo> TaskList = new List<TaskListInfo> { };
|
///<summary>
|
///对安防模式操作
|
///<para>当LinkType = 6时存在</para>
|
///<para>0：撤防</para>
|
///<para>1：永久布防，直到撤防</para>
|
///<para>2：布防，但使能一次，触发一次后将撤防。</para>
|
///<para>3：布防，但失能一次，第一次被激活不警告不触发动作。</para>
|
///<para>触发动作时，如果系统当前没有布防，则撤防失败。已经存在布防模式，将布防失败（需先对当前布防模式进行撤防）</para>
|
/// </summary>
|
/// <value>The epoint.</value>
|
public int SecuritySetting;
|
|
///<summary>
|
///安防模式id。为0时，则对当前在布防的安防模式进行操作。
|
/// </summary>
|
/// <value>The epoint.</value>
|
public int SecurityModeId;
|
|
///<summary>
|
///检查防区设备最近上报的安防信息状态进行布防
|
///<para>当LinkType = 6时存在</para>
|
///<para>0：不检查</para>
|
///<para>1：检查</para>
|
///<para>可缺省，默认为0</para>
|
/// </summary>
|
/// <value>The epoint.</value>
|
public int CheckIASStatus;
|
|
///<summary>
|
///是否延时启动。布防后延时一段时间正式启动防区，这段时间可以让人员撤离防区区域。
|
///<para>当LinkType = 6时存在</para>
|
///<para>0：不延时</para>
|
///<para>1：延时启动</para>
|
///<para>可缺省，默认为0</para>
|
/// </summary>
|
/// <value>The epoint.</value>
|
public int IsDelayStart;
|
|
///<summary>
|
///布防撤防用户密码，如果密码错误将加入失败
|
///<para>当LinkType = 6时存在</para>
|
///<para>数据回复时，该字段不存在</para>
|
/// </summary>
|
/// <value>The epoint.</value>
|
public int Password;
|
}
|
#endregion
|
|
#region 删除动作.
|
///<summary >
|
/// 删除动作
|
/// </summary>
|
public static async System.Threading.Tasks.Task<DelActionResponseAllData> DelActionAsync(DelActionData actionData)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
DelActionResponseAllData allData = null;
|
if (ZbGateway.MainGateWay == null)
|
{
|
allData = new DelActionResponseAllData { errorMessageBase = "当前没有主网关" };
|
return allData;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var gatewayTemp = new ZbGateway() { Time = jobject.Value<int>("Time"), DataID = jobject.Value<int>("Data_ID"), CurrentGateWayId = ZbGateway.MainGateWay.getGatewayBaseInfo.gwID };
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
allData = new DelActionResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
allData = new DelActionResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Logic/DelAction_Respon")
|
{
|
var logic = new Logic() { DataID = jobject.Value<int>("DataID"), GateWayId = ZbGateway.MainGateWay.CurrentGateWayId };
|
var tempData = Newtonsoft.Json.JsonConvert.DeserializeObject<DelActionResponseData>(jobject["Data"].ToString());
|
if (tempData == null)
|
{
|
allData = new DelActionResponseAllData { errorMessageBase = "网关返回的数据为空" };
|
}
|
else
|
{
|
allData = new DelActionResponseAllData { delActionResponseData = tempData };
|
System.Console.WriteLine($"收到通知后的主题_{ topic}");
|
}
|
}
|
};
|
ZbGateway.MainGateWay.Actions += action;
|
System.Console.WriteLine("Logic/DelAction_Actions 启动" + "_" + ZbGateway.MainGateWay.getGatewayBaseInfo.gwID + System.DateTime.Now.ToString());
|
|
try
|
{
|
if (actionData != null)
|
{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 2008 } };
|
|
var dataPublish = new Dictionary<string, object> { };
|
switch (actionData.Type)
|
{
|
case 0:
|
var dataPublish0 = new Dictionary<string, object>
|
{
|
["LogicId"] = actionData.LogicId,
|
["Type"] = actionData.Type,
|
["DeviceAddr"] = actionData.DeviceAddr,
|
["Epoint"] = actionData.Epoint,
|
};
|
dataPublish = dataPublish0;
|
break;
|
case 2:
|
int sceneID = int.Parse(actionData.DeviceAddr);
|
var dataPublish2 = new Dictionary<string, object>
|
{
|
["LogicId"] = actionData.LogicId,
|
["Type"] = actionData.Type,
|
["DeviceAddr"] = sceneID,
|
["Epoint"] = actionData.Epoint,
|
};
|
dataPublish = dataPublish2;
|
break;
|
case 4:
|
int conID = int.Parse(actionData.DeviceAddr);
|
var dataPublish4 = new Dictionary<string, object> //{ };
|
{
|
["LogicId"] = actionData.LogicId,
|
["Type"] = actionData.Type,
|
["DeviceAddr"] = conID,
|
};
|
dataPublish = dataPublish4;
|
break;
|
case 5:
|
int logID = int.Parse(actionData.DeviceAddr);
|
var dataPublish5 = new Dictionary<string, object>
|
{
|
["LogicId"] = actionData.LogicId,
|
["Type"] = actionData.Type,
|
["DeviceAddr"] = logID,
|
["ConditionId"] = actionData.ConditionId,
|
};
|
dataPublish = dataPublish5;
|
break;
|
case 6:
|
int sID = int.Parse(actionData.DeviceAddr);
|
var dataPublish6 = new Dictionary<string, object>
|
{
|
["LogicId"] = actionData.LogicId,
|
["Type"] = actionData.Type,
|
["SecurityModeId"] = actionData.SecurityModeId,
|
};
|
dataPublish = dataPublish6;
|
break;
|
}
|
ZbGateway.MainGateWay?.Send("Logic/ChangeAction", Device.Cluster_ID.Gateway, Command.LogicDelAction, Newtonsoft.Json.Linq.JObject.Parse(Newtonsoft.Json.JsonConvert.SerializeObject(dataPublish)));
|
}
|
}
|
catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < 2000)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (allData != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > 2000)
|
{
|
allData = new DelActionResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
|
}
|
ZbGateway.MainGateWay.Actions -= action;
|
System.Console.WriteLine("Logic/DelAction_Actions 退出" + "_" + ZbGateway.MainGateWay.getGatewayBaseInfo.gwID + System.DateTime.Now.ToString());
|
|
return allData;
|
});
|
}
|
|
/// <summary>
|
///删除动作的所有数据,网关反馈信息
|
/// </summary>
|
public DelActionResponseAllData delActionResponseAllData;
|
///<summary >
|
/// 删除动作回复的所有数据
|
/// </summary>
|
[System.Serializable]
|
public class DelActionResponseAllData
|
{
|
/// <summary>
|
/// 错误信息
|
/// </summary>
|
public string errorMessageBase;
|
/// <summary>
|
/// 网关信息错误反馈
|
/// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
|
/// </summary>
|
public ErrorResponData errorResponData;
|
/// <summary>
|
/// 删除动作回复的数据
|
/// </summary>
|
public DelActionResponseData delActionResponseData;
|
}
|
|
/// <summary>
|
///删除动作的数据
|
/// </summary>
|
public DelActionResponseData delActionResponseData;
|
/// <summary>
|
///删除动作的数据
|
/// </summary>
|
[System.Serializable]
|
public class DelActionResponseData : LogicBase
|
{
|
/// <summary>
|
/// 0：成功
|
///<para>1：失败，逻辑或动作设备不存在</para>
|
/// </summary>
|
public int Result;
|
/// <summary>
|
/// 删除的联动设备的类型：
|
///<para>0：联动设备为zigbee节点设备</para>
|
///<para>2：联动设备为场景（恢复场景）</para>
|
///<para>4：使能失能其他逻辑</para>
|
///<para>5：禁用或启用逻辑条件</para>
|
///<para>6：安防模式操作</para>
|
/// </summary>
|
public int Type;
|
/// <summary>
|
/// 联动设备的地址：
|
///<para>对设备操作 为设备mac地址（字符），Type为0</para>
|
///<para>对组操作 为组id（数值），Type为2</para>
|
///<para>对场景操作 为场景id（数值），Type为2</para>
|
///<para>对逻辑操作 为逻辑id（数值），Type为4或5</para>
|
/// </summary>
|
public string DeviceAddr;
|
///<summary>
|
///联动设备的端口号：
|
///<para>和mac地址共同标识唯一的zigbee设备 数值范围0-255</para>
|
///<para>场景和组、逻辑忽略该字段</para>
|
/// </summary>
|
public int Epoint;
|
/// <summary>
|
///其他逻辑的条件id，当Type为5时存在
|
/// </summary>
|
public int ConditionId;
|
/// <summary>
|
///安防模式id。为0时，则对当前在布防的安防模式进行操作。（当Type = 6时存在）
|
/// </summary>
|
public int SecurityModeId;
|
}
|
|
/// <summary>
|
///删除动作的数据
|
/// </summary>
|
public DelActionData delActionData;
|
/// <summary>
|
///删除动作的数据
|
/// </summary>
|
[System.Serializable]
|
public class DelActionData : LogicBase
|
{
|
/// <summary>
|
/// 删除的联动设备的类型：
|
///<para>0：联动设备为zigbee节点设备</para>
|
///<para>2：联动设备为场景（恢复场景）</para>
|
///<para>4：使能失能其他逻辑</para>
|
///<para>5：禁用或启用逻辑条件</para>
|
///<para>6：安防模式操作</para>
|
/// </summary>
|
public int Type;
|
/// <summary>
|
/// 联动设备的地址：
|
///<para>对设备操作 为设备mac地址（字符），Type为0</para>
|
///<para>对组操作 为组id（数值），Type为1</para>
|
///<para>对场景操作 为场景id（数值），Type为2</para>
|
///<para>对逻辑操作 为逻辑id（数值），Type为3</para>
|
/// </summary>
|
public string DeviceAddr;
|
/// <summary>
|
/// <para>Type为0时才存在，此时必需填写参数</para>
|
/// <para>联动设备的端口号</para>
|
///<para>和mac地址共同标识唯一的zigbee设备 数值范围0-255</para>
|
///<para>场景和组、逻辑忽略该字段</para>
|
/// </summary>
|
public int Epoint;
|
/// <summary>
|
/// <para>Type为5时才存在，此时必需填写参数</para>
|
/// 操作的逻辑条件id，Type为5时存在
|
/// </summary>
|
public int ConditionId;
|
/// <summary>
|
/// <para>Type为6时才存在，此时必需填写参数</para>
|
/// 安防模式id。为0时，则对当前在布防的安防模式进行操作。
|
/// </summary>
|
public int SecurityModeId;
|
}
|
#endregion
|
|
#region 删除逻辑.
|
///<summary >
|
/// 删除逻辑
|
/// </summary>
|
public static async System.Threading.Tasks.Task<DelLogicResponseAllData> DelLogicAsync(int logicId)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
DelLogicResponseAllData allData = null;
|
if (ZbGateway.MainGateWay == null)
|
{
|
allData = new DelLogicResponseAllData { errorMessageBase = "当前没有主网关" };
|
return allData;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var gatewayTemp = new ZbGateway() { Time = jobject.Value<int>("Time"), DataID = jobject.Value<int>("Data_ID"), CurrentGateWayId = ZbGateway.MainGateWay.getGatewayBaseInfo.gwID };
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
allData = new DelLogicResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
allData = new DelLogicResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Logic/DelLogic_Respon")
|
{
|
var logic = new Logic() { DataID = jobject.Value<int>("DataID"), GateWayId = ZbGateway.MainGateWay.CurrentGateWayId };
|
var tempData = Newtonsoft.Json.JsonConvert.DeserializeObject<DelLogicResponseData>(jobject["Data"].ToString());
|
if (tempData == null)
|
{
|
allData = new DelLogicResponseAllData { errorMessageBase = "网关返回的数据为空" };
|
}
|
else
|
{
|
allData = new DelLogicResponseAllData { delLogicResponseData = tempData };
|
System.Console.WriteLine($"收到通知后的主题_{ topic}");
|
}
|
}
|
};
|
ZbGateway.MainGateWay.Actions += action;
|
System.Console.WriteLine("Logic/DelLogic_Actions 启动" + "_" + ZbGateway.MainGateWay.getGatewayBaseInfo.gwID + System.DateTime.Now.ToString());
|
|
try
|
{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 2009 } };
|
var data = new JObject {
|
{ "LogicId",logicId}
|
};
|
jObject.Add("Data", data);
|
ZbGateway.MainGateWay?.Send(("Logic/DelLogic"), jObject.ToString());
|
}
|
catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < 2000)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (allData != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > 2000)
|
{
|
allData = new DelLogicResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
|
}
|
ZbGateway.MainGateWay.Actions -= action;
|
System.Console.WriteLine("Logic/DelLogic_Actions 退出" + "_" + ZbGateway.MainGateWay.getGatewayBaseInfo.gwID + System.DateTime.Now.ToString());
|
|
return allData;
|
});
|
}
|
|
/// <summary>
|
///删除逻辑的所有数据,网关反馈信息
|
/// </summary>
|
public DelLogicResponseAllData delLogicResponseAllData;
|
///<summary >
|
/// 删除逻辑的所有数据
|
/// </summary>
|
[System.Serializable]
|
public class DelLogicResponseAllData
|
{
|
/// <summary>
|
/// 错误信息
|
/// </summary>
|
public string errorMessageBase;
|
/// <summary>
|
/// 网关信息错误反馈
|
/// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
|
/// </summary>
|
public ErrorResponData errorResponData;
|
/// <summary>
|
/// 删除逻辑回复的数据
|
/// </summary>
|
public DelLogicResponseData delLogicResponseData;
|
}
|
|
/// <summary>
|
///删除逻辑的数据
|
/// </summary>
|
public DelLogicResponseData delLogicResponseData;
|
/// <summary>
|
///删除逻辑的数据
|
/// </summary>
|
[System.Serializable]
|
public class DelLogicResponseData : LogicBase
|
{
|
/// <summary>
|
///0：成功
|
///<para>1：失败，逻辑不存在</para>
|
/// </summary>
|
public int Result;
|
}
|
|
#endregion
|
|
#region 时间点条件推迟执行
|
/// <summary>
|
///获取时间点条件推迟执行的数据
|
/// </summary>
|
public TimingWillArriveData timingWillArriveData;
|
/// <summary>
|
///获取时间点条件推迟执行的数据
|
/// </summary>
|
[System.Serializable]
|
public class TimingWillArriveData : LogicBase
|
{
|
/// <summary>
|
/// 条件id
|
/// </summary>
|
public int ConditionId;
|
|
/// <summary>
|
///条件类型
|
///0：阳历 1：农历
|
/// </summary>
|
public int Calendar;
|
/// <summary>
|
///时间点类型：
|
///<para>0：正常时间点（从Datetime这个时间点开始执行）</para>
|
///<para>1：日出时间（从DateTime之后第一次日出时间开始执行）</para>
|
///<para>2：日落时间（从DateTime之后第一次日落时间开始执行）</para>
|
///<para>3：正午时间（从DateTime之后第一次中午时间开始执行）</para>
|
/// </summary>
|
public int DateType;
|
|
/// <summary>
|
///表示触发动作的开始时间 格式为由utc时间转换成的Unix时间戳。如北京时间2018年7月9日 17:50:00，则转换时间戳后为1531129800。该时间点也是每月每年重复的判断依据。
|
/// </summary>
|
public int Datetime;
|
/// <summary>
|
/// 当Type为0时，该字段才存在
|
///<para>重复类型</para>
|
///<para>1：每小时执行（按上面例子，从北京时间2018/7/9 17:50:00开始每小时执行一次）</para>
|
///<para>2：每天执行（按上面例子，从北京时间2018/7/9 17:50:00开始每天17:50:00执行一次）</para>
|
///<para>3：每月执行（按上面例子，从北京时间2018/7/9 17:50:00开始每月9日17:50:00执行一次。如果为农历则是每月农历二十六执行）</para>
|
///<para>4：每年执行（按上面例子，从北京时间2018/7/9 17:50:00开始每年7月9日17:50:00执行一次。如果为农历，则是每年农历五月二十六17:50:00执行）</para>
|
///<para>5：周重复。（周一到周七可选执行） </para>
|
/// </summary>
|
public int Repeat;
|
/// <summary>
|
/// 周工作模式（可或运算）
|
///<para>0x01 周一执行</para>
|
///<para>0x02 周二执行</para>
|
///<para>0x04 周三执行</para>
|
///<para>0x08 周四执行</para>
|
///<para>0x10 周五执行</para>
|
///<para>0x20 周六执行</para>
|
///<para>0x40 周日执行</para>
|
///<para>0x7F 每天执行</para>
|
///<para>数值可进行或运算，如周一、周三、周五执行，则为WeekDay=（0x01 || 0x04 || 0x10）= 0x15 即十进制 21。</para>
|
/// </summary>
|
/// <value>The week day.</value>
|
public int WeekDay;
|
/// <summary>
|
///提前提醒时间。（单位秒）范围：0-65535
|
///<para>定时条件将要触发的前RemindTime秒，网关将通知客户端定时时间将至，可能会执行逻辑动作（如果该逻辑还需要满足其他条件，则到达定时时间时，其他条件没有满足将不会执行逻辑动作）。在这段时间内，客户端可发送指令让定时推迟执行。最终的定时时间将是原来定时时间+推迟的时间。</para>
|
///<para>如果为0，则不提醒。到达提前提醒时，将发送第11小节的提醒通知。</para>
|
/// </summary>
|
public int RemindTime;
|
/// <summary>
|
///是否允许推迟
|
///<para>0：不允许</para>
|
///<para>1：允许</para>
|
///</summary>
|
public int EnDelay;
|
/// <summary>
|
///推迟时间（单位：秒）范围：0-65535
|
///<para>推迟时间如果小于提前提醒时间，则在推迟前的定时时间到达时提醒。</para>
|
///</summary>
|
public int DelayTime;
|
/// <summary>
|
///本次定时条件触发的utc时间
|
///</summary>
|
public int TriggerTime;
|
}
|
|
#endregion
|
|
//#region 推迟定时条件
|
///// <summary>
|
///// 设置推迟定时条件成立的数据
|
/////<para>如果要推迟定时条件成立，可在提醒后到达触发的时间点前发送以下推迟指令。如果推迟成功，时间条件将在原该触发的时间点上推迟DelayTime触发条件。</para>
|
///// </summary>
|
//public GetLogicTimeDelayTriggerData getLogicTimeDelayTrigger;
|
///// <summary>
|
///// 设置推迟定时条件成立的数据
|
/////<para>如果要推迟定时条件成立，可在提醒后到达触发的时间点前发送以下推迟指令。如果推迟成功，时间条件将在原该触发的时间点上推迟DelayTime触发条件。</para>
|
///// </summary>
|
//[System.Serializable]
|
//public class GetLogicTimeDelayTriggerData : LogicBase
|
//{
|
// /// <summary>
|
// /// 0：成功
|
// ///<para>1：失败，逻辑或条件不存在</para>
|
// ///<para>2：失败，条件不是定时条件。</para>
|
// ///<para>3：失败，条件不允许推迟</para>
|
// ///<para>4：失败，没有在提醒后到达触发的时间点前发送。</para>
|
// /// </summary>
|
// public int Result;
|
|
// /// <summary>
|
// ///条件id
|
// /// </summary>
|
// public int ConditionId;
|
// /// <summary>
|
// ///推迟后定时条件触发的utc时间
|
// /// </summary>
|
// public int TriggerTime;
|
|
//}
|
|
///// <summary>
|
///// 推迟定时条件成立，发布到网关
|
///// <para>如果要推迟定时条件成立，可在提醒后到达触发的时间点前发送以下推迟指令。如果推迟成功，时间条件将在原该触发的时间点上推迟DelayTime触发条件。</para>
|
///// <para>logicId 逻辑id，逻辑的唯一标识</para>
|
///// <para>conditionId 条件id</para>
|
///// </summary>
|
//public void LogicTimeDelayTriggerPublish(int logicId, int conditionId)
|
//{
|
// var dataPublish = new Dictionary<string, object> { ["LogicId"] = logicId, ["ConditionId"] = conditionId };
|
// ZbGateway.MainGateWay?.Send("Logic/TimingWillArrive", Device.Cluster_ID.Gateway, Command.LogicTimeDelayTrigger, Newtonsoft.Json.Linq.JObject.Parse(Newtonsoft.Json.JsonConvert.SerializeObject(dataPublish)));
|
//}
|
//#endregion
|
|
#region 逻辑被调用反馈.
|
///<summary >
|
///逻辑控制
|
/// </summary>
|
public static async System.Threading.Tasks.Task<ExecuteRespoAllData> ControlLogicAsync(int logicId)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
ExecuteRespoAllData allData = null;
|
if (ZbGateway.MainGateWay == null)
|
{
|
allData = new ExecuteRespoAllData { errorMessageBase = "当前没有主网关" };
|
return allData;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var gatewayTemp = new ZbGateway() { Time = jobject.Value<int>("Time"), DataID = jobject.Value<int>("Data_ID"), CurrentGateWayId = ZbGateway.MainGateWay.getGatewayBaseInfo.gwID };
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
allData = new ExecuteRespoAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
allData = new ExecuteRespoAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Logic/TestActions_Respon")
|
{
|
var logic = new Logic() { DataID = jobject.Value<int>("DataID"), GateWayId = ZbGateway.MainGateWay.CurrentGateWayId };
|
var tempData = Newtonsoft.Json.JsonConvert.DeserializeObject<ExecuteResponse>(jobject["Data"].ToString());
|
if (tempData == null)
|
{
|
allData = new ExecuteRespoAllData { errorMessageBase = "网关返回的数据为空" };
|
}
|
else
|
{
|
allData = new ExecuteRespoAllData { logicExecuteRespo = tempData };
|
System.Console.WriteLine($"收到通知后的主题_{ topic}");
|
}
|
}
|
};
|
ZbGateway.MainGateWay.Actions += action;
|
System.Console.WriteLine("Logic/TestActions_Actions 启动" + "_" + ZbGateway.MainGateWay.getGatewayBaseInfo.gwID + System.DateTime.Now.ToString());
|
|
try
|
{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 2012 } };
|
var data = new JObject {
|
{ "LogicId",logicId}
|
};
|
jObject.Add("Data", data);
|
ZbGateway.MainGateWay?.Send(("Logic/TestActions"), jObject.ToString());
|
}
|
catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < 2000)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (allData != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > 2000)
|
{
|
allData = new ExecuteRespoAllData { errorMessageBase = " 回复超时，请重新操作" };
|
|
}
|
ZbGateway.MainGateWay.Actions -= action;
|
System.Console.WriteLine("Logic/TestActions_Actions 退出" + "_" + ZbGateway.MainGateWay.getGatewayBaseInfo.gwID + System.DateTime.Now.ToString());
|
|
return allData;
|
});
|
}
|
|
/// <summary>
|
/// 调用场景,网关反馈信息
|
/// <para>返回Result 0：调用失败</para>
|
///<para>Result 1：调用成功<para>
|
/// </summary>
|
public ExecuteRespoAllData executeRespoAllData;
|
/// <summary>
|
/// 调用逻辑,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class ExecuteRespoAllData
|
{
|
/// <summary>
|
/// 错误信息
|
/// </summary>
|
public string errorMessageBase;
|
/// <summary>
|
/// 网关信息错误反馈
|
/// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
|
/// </summary>
|
public ErrorResponData errorResponData;
|
/// <summary>
|
/// 调用逻辑
|
/// </summary>
|
public ExecuteResponse logicExecuteRespo;
|
}
|
|
/// <summary>
|
///调用逻辑
|
/// </summary>
|
public ExecuteResponse logicExecuteRespo;
|
/// <summary>
|
///调用逻辑
|
/// </summary>
|
[System.Serializable]
|
public class ExecuteResponse : LogicBase
|
{
|
/// <summary>
|
/// 0：成功
|
///<para>1：失败，逻辑不存在</para>
|
/// </summary>
|
public int Result;
|
}
|
|
#endregion
|
|
#region 设定网关所在地经纬度.
|
/// <summary>
|
/// 设定网关所在地经纬度
|
/// <param name="longitude">Longitude:经度。单位：0.01°。 东经为正数，西经为负数。如：西经172.53°W，应填入-17253</param>
|
/// <param name="latitude">Latitude:维度。单位：0.01°。北纬度为正数，南纬度为负数。如：南纬度，如南纬90.25°S ，应该填入-9025。</param>
|
/// </summary>
|
public static async System.Threading.Tasks.Task<SetSiteResponseAllData> SetSiteAsync(int longitude,int latitude)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
SetSiteResponseAllData allData = null;
|
if (ZbGateway.MainGateWay == null)
|
{
|
allData = new SetSiteResponseAllData { errorMessageBase = "当前没有主网关" };
|
return allData;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var gatewayTemp = new ZbGateway() { Time = jobject.Value<int>("Time"), DataID = jobject.Value<int>("Data_ID"), CurrentGateWayId = ZbGateway.MainGateWay.getGatewayBaseInfo.gwID };
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
allData = new SetSiteResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
allData = new SetSiteResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Logic/SetSite_Respon")
|
{
|
var logic = new Logic() { DataID = jobject.Value<int>("DataID"), GateWayId = ZbGateway.MainGateWay.CurrentGateWayId };
|
var tempData = Newtonsoft.Json.JsonConvert.DeserializeObject<SetSiteResponseData>(jobject["Data"].ToString());
|
if (tempData == null)
|
{
|
allData = new SetSiteResponseAllData { errorMessageBase = "网关返回的数据为空" };
|
}
|
else
|
{
|
allData = new SetSiteResponseAllData { setSiteResponseData = tempData };
|
System.Console.WriteLine($"收到通知后的主题_{ topic}");
|
}
|
}
|
};
|
ZbGateway.MainGateWay.Actions += action;
|
System.Console.WriteLine("Logic/SetSite_Actions 启动" + "_" + ZbGateway.MainGateWay.getGatewayBaseInfo.gwID + System.DateTime.Now.ToString());
|
|
try
|
{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 2013 } };
|
var data = new JObject {
|
{ "Longitude",longitude},
|
{ "Latitude",latitude}
|
};
|
jObject.Add("Data", data);
|
ZbGateway.MainGateWay?.Send(("Logic/SetSite"), jObject.ToString());
|
}
|
catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < 2000)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (allData != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > 2000)
|
{
|
allData = new SetSiteResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
|
}
|
ZbGateway.MainGateWay.Actions -= action;
|
System.Console.WriteLine("Logic/SetSite_Actions 退出" + "_" + ZbGateway.MainGateWay.getGatewayBaseInfo.gwID + System.DateTime.Now.ToString());
|
|
return allData;
|
});
|
}
|
|
/// <summary>
|
/// 设定网关所在地经纬度,网关反馈信息
|
/// <para>返回Result 0：调用失败</para>
|
///<para>Result 1：调用成功<para>
|
/// </summary>
|
public SetSiteResponseAllData setSiteResponseAllData;
|
/// <summary>
|
/// 设定网关所在地经纬度,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class SetSiteResponseAllData
|
{
|
/// <summary>
|
/// 错误信息
|
/// </summary>
|
public string errorMessageBase;
|
/// <summary>
|
/// 网关信息错误反馈
|
/// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
|
/// </summary>
|
public ErrorResponData errorResponData;
|
/// <summary>
|
/// 设定网关所在地经纬度
|
/// </summary>
|
public SetSiteResponseData setSiteResponseData;
|
}
|
|
/// <summary>
|
///设定网关所在地经纬度
|
/// </summary>
|
public SetSiteResponseData setSiteResponseData;
|
/// <summary>
|
///设定网关所在地经纬度
|
/// </summary>
|
[System.Serializable]
|
public class SetSiteResponseData
|
{
|
/// <summary>
|
///0：成功
|
/// </summary>
|
public int Result;
|
/// <summary>
|
///经度。单位：0.01°。 东经为正数，西经为负数。如：西经172.53°W，应填入-17253
|
/// </summary>
|
public int Longitude;
|
/// <summary>
|
///维度。单位：0.01°。北纬度为正数，南纬度为负数。如：南纬度，如南纬90.25°S ，应该填入-9025。
|
/// </summary>
|
public int Latitude;
|
}
|
#endregion
|
|
#region 读取网关当前设定的经纬度信息.
|
///<summary >
|
///读取网关当前设定的经纬度信息
|
/// <para></para>
|
/// </summary>
|
public static async System.Threading.Tasks.Task<ReadSiteResponseAllData> ReadSiteAsync()
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
ReadSiteResponseAllData allData = null;
|
if (ZbGateway.MainGateWay == null)
|
{
|
allData = new ReadSiteResponseAllData { errorMessageBase = "当前没有主网关" };
|
return allData;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var gatewayTemp = new ZbGateway() { Time = jobject.Value<int>("Time"), DataID = jobject.Value<int>("Data_ID"), CurrentGateWayId = ZbGateway.MainGateWay.getGatewayBaseInfo.gwID };
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
allData = new ReadSiteResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
allData = new ReadSiteResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Logic/ReadSite_Respon")
|
{
|
var logic = new Logic() { DataID = jobject.Value<int>("DataID"), GateWayId = ZbGateway.MainGateWay.CurrentGateWayId };
|
var tempData = Newtonsoft.Json.JsonConvert.DeserializeObject<ReadSiteResponseData>(jobject["Data"].ToString());
|
if (tempData == null)
|
{
|
allData = new ReadSiteResponseAllData { errorMessageBase = "网关返回的数据为空" };
|
}
|
else
|
{
|
allData = new ReadSiteResponseAllData { readSiteResponseData = tempData };
|
System.Console.WriteLine($"收到通知后的主题_{ topic}");
|
}
|
}
|
};
|
ZbGateway.MainGateWay.Actions += action;
|
System.Console.WriteLine("Logic/ReadSite_Actions 启动" + "_" + ZbGateway.MainGateWay.getGatewayBaseInfo.gwID + System.DateTime.Now.ToString());
|
|
try
|
{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 2014 } };
|
ZbGateway.MainGateWay?.Send(("Logic/ReadSite"), jObject.ToString());
|
}
|
catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < 2000)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (allData != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > 2000)
|
{
|
allData = new ReadSiteResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
|
}
|
ZbGateway.MainGateWay.Actions -= action;
|
System.Console.WriteLine("Logic/ReadSite_Actions 退出" + "_" + ZbGateway.MainGateWay.getGatewayBaseInfo.gwID + System.DateTime.Now.ToString());
|
|
return allData;
|
});
|
}
|
|
/// <summary>
|
/// 读取网关当前设定的经纬度信息,网关反馈信息
|
/// <para>返回Result 0：调用失败</para>
|
///<para>Result 1：调用成功<para>
|
/// </summary>
|
public ReadSiteResponseAllData readSiteResponseAllData;
|
/// <summary>
|
/// 读取网关当前设定的经纬度信息,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class ReadSiteResponseAllData
|
{
|
/// <summary>
|
/// 错误信息
|
/// </summary>
|
public string errorMessageBase;
|
/// <summary>
|
/// 网关信息错误反馈
|
/// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
|
/// </summary>
|
public ErrorResponData errorResponData;
|
/// <summary>
|
/// 读取网关当前设定的经纬度信息
|
/// </summary>
|
public ReadSiteResponseData readSiteResponseData;
|
}
|
|
/// <summary>
|
///读取网关当前设定的经纬度信息
|
/// </summary>
|
public ReadSiteResponseData readSiteResponseData;
|
/// <summary>
|
///读取网关当前设定的经纬度信息
|
/// </summary>
|
[System.Serializable]
|
public class ReadSiteResponseData
|
{
|
/// <summary>
|
///经度。单位：0.01°。 东经为正数，西经为负数。如：西经172.53°W，应填入-17253
|
/// </summary>
|
public int Longitude;
|
/// <summary>
|
///维度。单位：0.01°。北纬度为正数，南纬度为负数。如：南纬度，如南纬90.25°S ，应该填入-9025。
|
/// </summary>
|
public int Latitude;
|
}
|
#endregion
|
|
#region 条件数据对象
|
/// <summary>
|
/// 其他逻辑条件数据
|
/// </summary>
|
[System.Serializable]
|
public class LogicConditionsInfo : ConditionBase
|
{
|
/// <summary>
|
///作条件的其他逻辑id。
|
/// </summary>
|
public int Condition_LogicId;
|
}
|
|
/// <summary>
|
/// 计数器条件数据
|
/// </summary>
|
[System.Serializable]
|
public class CounterConditionsInfo : ConditionBase
|
{
|
/// <summary>
|
/// 设备mac地址
|
/// </summary>
|
public string MacAddr;
|
|
/// <summary>
|
/// 当Type为1时，该字段才存在
|
///<para>设备端口号，该端口填入的是用于上报Cluster_ID和AttriButeId属性值的端口号。</para>
|
///<para>特殊设备：
|
///如果为hdl功能按键则填入按键号（按键对应的端口号）</para>
|
/// </summary>
|
public int Epoint;
|
|
/// <summary>
|
///当Type为1 时，该字段才存在
|
///<para>触发联动的属性状态所在Cluster 如开关Cluster 6 </para>
|
///<para>特殊设备：</para>
|
///<para>1、如果为hdl功能按键则填64528。</para>
|
///<para>2、如果为IAS安防设备则填入1280。</para>
|
///<para>3、如果为门锁操作事件，则填入64529。</para>
|
/// </summary>
|
public int Cluster_ID;
|
|
/// <summary>
|
///当Type为1 时，该字段才存在
|
/// <para>触发联动的属性 如Cluster = 6时 AttriButeId = 0为开关属性</para>
|
///<para>特殊设备：</para>
|
///<para>如果为hdl功能按键则为按键触发时上报触发信息的按键号类型。</para>
|
///<para>如果为IAS安防设备则填入1281。</para>
|
///<para>如果为门锁操作事件则填入门锁操作事件的OperationEventSoure列表值</para>
|
/// </summary>
|
public int AttriButeId;
|
|
|
/// <summary>
|
/// 属性状态临界值1
|
///<para>特殊设备：</para>
|
///<para>如果为hdl功能按键，则为下列按键模式：1：点击 2：前点击 4：后单击 8：仅双击 16：前双击 32：后双击 64：仅长按 128：前长按 256：后长按 512：长按释放。</para>
|
///<para>如果为IAS安防设备则为IAS安防设备信息上报数据中的ZoneStatus。</para>
|
///<para>如果为门锁操作事件则填入门锁操作事件的Operation Event Code值</para>
|
/// </summary>
|
public int AttriButeData1;
|
|
/// <summary>
|
/// 属性状态临界值2 （参考AttriButeData1说明）
|
/// </summary>
|
public int AttriButeData2;
|
|
/// <summary>
|
/// 0 : 大于AttriButeData1时计数一次
|
///<para>1 ：等于AttriButeData1时计数一次</para>
|
///<para>2：小于AttriButeData1时计数一次</para>
|
///<para>3：大于AttriButeData1且小于AttriButeData2计数一次</para>
|
///<para>4：小于AttriButeData1或大于AttriButeData2计数一次</para>
|
///<para>5：与AttriButeData1进行与运算结果不为0时计数一次。</para>
|
///<para>6：和上一次上报的AttriButeData值不同时计数一次 </para>
|
/// </summary>
|
public int Range;
|
|
/// <summary>
|
///到达多少次触发逻辑
|
/// </summary>
|
public int Number;
|
|
/// <summary>
|
///时间范围。单位：秒
|
///<para>多少秒内到达多少次触发。</para>
|
///<para>如果时间到达后，还不达到次数则将次数清零。重新开始倒计时及计数。</para>
|
/// </summary>
|
public int Time;
|
|
/// <summary>
|
///可缺省，默认为 0。
|
///<para>是否循环执行。对一次规定时间内是否达到触发次数的结果处理。</para>
|
///<para>0：循环执行。当超时或规定时间内达到次数后，清零次数，重新计时，继续下一次计数。</para>
|
///<para>1：某次超时退出。如果达到次数则清零计数重新计时，继续下一次计数。如果超时则退出计数。并将IsVail设置为0。</para>
|
///<para>2：计数一次退出。到达规定时间后，无论是否达到次数，都将退出。并将IsVail置0。</para>
|
///</summary>
|
public int Cycle;
|
}
|
|
/// <summary>
|
/// 倒计时条件数据
|
/// </summary>
|
[System.Serializable]
|
public class CountdownConditionsInfo : ConditionBase
|
{
|
/// <summary>
|
///倒计时多少秒触发。单位 秒。
|
///<para>倒计时只生效一次，每次倒计时完成后自动将IsValid置0。客户端可通过第6小节命令使能该倒计时条件，将IsValid置1，即可再次使用该倒计时。</para>
|
/// </summary>
|
public int Time;
|
}
|
|
/// <summary>
|
/// 时间段条件条件数据
|
/// </summary>
|
[System.Serializable]
|
public class TimeBucketConditionsInfo : ConditionBase
|
{
|
/// <summary>
|
///触发动作开始时间，小时。
|
/// </summary>
|
public int StartHour;
|
|
/// <summary>
|
///触发动作开始时间，分钟
|
/// </summary>
|
public int StartMin;
|
|
/// <summary>
|
///触发动作结束时间，小时
|
/// </summary>
|
public int StopHour;
|
|
/// <summary>
|
///触发时间结束时间，分钟
|
/// </summary>
|
public int StopMin;
|
|
}
|
|
/// <summary>
|
/// 安防条件数据
|
/// </summary>
|
[System.Serializable]
|
public class SecurityConditionsInfo : ConditionBase
|
{
|
/// <summary>
|
///0：布防成功瞬间触发条件成立。
|
///<para>1：撤防成功瞬间触发条件成立。</para>
|
/// </summary>
|
public int EnOrWithdrawMode;
|
|
/// <summary>
|
///安防模式id。如果为0，则为任意安防模式布防或撤防成功后触发条件
|
/// </summary>
|
public int ModeId;
|
|
}
|
|
/// <summary>
|
/// 执行动作数据
|
/// </summary>
|
[System.Serializable]
|
public class ActionsInfo
|
{
|
/// <summary>
|
/// 添加的联动设备类型
|
///<para>0：联动设备为zigbee节点设备</para>
|
///<para>2：联动设备为场景（恢复场景）</para>
|
///<para>4：使能失能其他逻辑</para>
|
///<para>5：禁用或启用逻辑条件</para>
|
///<para>6：对安防模式进行布撤防</para>
|
/// </summary>
|
/// <value>The type of the link.</value>
|
public int LinkType;
|
|
/// <summary>
|
/// 联动设备的地址：
|
///<para>设备mac地址（字符），LinkType=0。</para>
|
///<para>对场景操作，即恢复场景 为场景id（数值），LinkType为2。</para>
|
///<para>对其他逻辑操作 为逻辑id（数值），LinkType为4 、LinkType为 5。</para>
|
/// </summary>
|
/// <value>The device address.</value>
|
public string DeviceAddr;
|
/// <summary>
|
/// 联动设备的端口号：
|
///<para>和mac地址共同标识唯一的zigbee设备 数值范围0-255</para>
|
///<para>当LinkType=0时存在</para>
|
/// </summary>
|
/// <value>The epoint.</value>
|
public int Epoint;
|
|
/// <summary>
|
/// 逻辑使能、失能。
|
///<para>当LinkType = 4时存在</para>
|
///<para>0：失能逻辑。</para>
|
///<para>1：使能逻辑。</para>
|
///<para>2：只使能一次</para>
|
///<para>3：只失能一次</para>
|
/// </summary>
|
/// <value>The epoint.</value>
|
public int EnableLogic;
|
|
/// <summary>
|
/// 操作的逻辑条件id。
|
///<para>当LinkType=5时存在</para>
|
/// </summary>
|
/// <value>The epoint.</value>
|
public int ConditionId;
|
|
/// <summary>
|
/// 是否禁用逻辑条件
|
///<para>当LinkType=5时存在</para>
|
///<para>0 禁用条件（将逻辑条件的IsValid字段置0）</para>
|
///<para>1 启用条件（将逻辑条件的IsValid字段置1）</para>
|
///<para>2：使能一次（条件成立一次后将被禁用，IsValid自动置为0）。</para>
|
///<para>3：失能一次（条件第一次成立会被忽略，触发不了逻辑，然后IsValid自动置1。以后条件再成立将不会被忽略）</para>
|
/// </summary>
|
/// <value>The epoint.</value>
|
public int EnableCondition;
|
|
/// <summary>
|
/// 延时执行时间。单位（秒）范围：0-65535。
|
///<para>逻辑成立后，延迟多久执行设备动作指令。</para>
|
///<para>当LinkType=0时存在。该字段可忽略，默认为0，即逻辑成立后立即执行设备动作。</para>
|
/// </summary>
|
/// <value>The epoint.</value>
|
public int Time;
|
|
/// <summary>
|
/// 设备列表
|
/// <para>当LinkType=0时存在</para>
|
/// </summary>
|
public List<TaskListInfo> TaskList = new List<TaskListInfo>();
|
|
///<summary>
|
///对安防模式操作
|
///<para>当LinkType = 6时存在</para>
|
///<para>0：撤防</para>
|
///<para>1：永久布防，直到撤防</para>
|
///<para>2：布防，但使能一次，触发一次后将撤防。</para>
|
///<para>3：布防，但失能一次，第一次被激活不警告不触发动作。</para>
|
///<para>触发动作时，如果系统当前没有布防，则撤防失败。已经存在布防模式，将布防失败（需先对当前布防模式进行撤防）</para>
|
/// </summary>
|
/// <value>The epoint.</value>
|
public int SecuritySetting;
|
|
///<summary>
|
///安防模式id。为0时，则对当前在布防的安防模式进行操作。
|
/// </summary>
|
/// <value>The epoint.</value>
|
public int SecurityModeId;
|
|
///<summary>
|
///检查防区设备最近上报的安防信息状态进行布防
|
///<para>当LinkType = 6时存在</para>
|
///<para>0：不检查</para>
|
///<para>1：检查</para>
|
///<para>可缺省，默认为0</para>
|
/// </summary>
|
/// <value>The epoint.</value>
|
public int CheckIASStatus;
|
|
///<summary>
|
///是否延时启动。布防后延时一段时间正式启动防区，这段时间可以让人员撤离防区区域。
|
///<para>当LinkType = 6时存在</para>
|
///<para>0：不延时</para>
|
///<para>1：延时启动</para>
|
///<para>可缺省，默认为0</para>
|
/// </summary>
|
/// <value>The epoint.</value>
|
public int IsDelayStart;
|
|
///<summary>
|
///布防撤防用户密码，如果密码错误将加入失败
|
///<para>当LinkType = 6时存在</para>
|
///<para>数据回复时，该字段不存在</para>
|
/// </summary>
|
/// <value>The epoint.</value>
|
public int Password;
|
|
}
|
|
/// <summary>
|
/// 时间条件数据
|
/// </summary>
|
[System.Serializable]
|
public class TimeConditionsInfo : ConditionBase
|
{
|
/// <summary>
|
///时间点类型：
|
///<para>0：正常时间点（由StartHour和StartMin设定）</para>
|
///<para>1：日出时间 </para>
|
///<para>2：日落时间 </para>
|
///<para>3：正午时间 </para>
|
/// </summary>
|
public int DateType;
|
|
/// <summary>
|
///触发动作时间，（0-23）小时。
|
///<para>当DateType = 0时，该参数才有效。</para>
|
/// </summary>
|
public int StartHour;
|
|
/// <summary>
|
///触发动作时间，（0-59）分钟。
|
///<para>当DateType = 0 时，该参数才有效。</para>
|
/// </summary>
|
public int StartMin;
|
|
/// <summary>
|
///提前或推后多少分钟执行。（单位：分钟）
|
///<para>范围：-127到127。正数为推后，负值为提前。</para>
|
///<para>如日落前30分钟执行，则将该值设定为-30。</para>
|
///<para>当DateType不为0时，该参数才有效。</para>
|
/// </summary>
|
public int AdjustTime;
|
|
/// <summary>
|
///提前提醒时间。（单位秒）范围：0-65535
|
///<para>定时条件将要触发的前RemindTime秒，网关将通知客户端定时时间将至，可能会执行逻辑动作（如果该逻辑还需要满足其他条件，则到达定时时间时，其他条件没有满足将不会执行逻辑动作）。在这段时间内，客户端可发送指令让定时推迟执行。最终的定时时间将是原来定时时间+推迟的时间。</para>
|
///<para>如果为0，则不提醒。到达提前提醒时，将发送第11小节的提醒通知。</para>
|
/// </summary>
|
public int RemindTime;
|
|
/// <summary>
|
///是否允许推迟
|
///<para>0：不允许</para>
|
///<para>1：允许</para>
|
///</summary>
|
public int EnDelay;
|
|
/// <summary>
|
///推迟时间（单位：秒）范围：0-65535
|
///<para>推迟时间如果小于提前提醒时间，则在推迟前的定时时间到达时提醒。可缺省 ，默认为0。</para>
|
///</summary>
|
public int DelayTime;
|
}
|
|
/// <summary>
|
/// 设备条件数据
|
/// </summary>
|
[System.Serializable]
|
public class DeviceConditionsInfo : ConditionBase
|
{
|
/// <summary>
|
///设备mac地址(当Type为1时，该字段才存在)
|
/// </summary>
|
public string MacAddr;
|
/// <summary>
|
/// 设备端口号，(当Type为1时，该字段才存在)
|
/// <para>该端口填入的是用于上报Cluster_ID和AttriButeId属性值的端口号。）</para>
|
/// <para>特殊设备：
|
/// 如果为hdl功能按键则填入按键号（按键对应的端口号）</para>
|
/// </summary>
|
public int Epoint;
|
/// <summary>
|
/// 触发联动的属性状态所在Cluster 如开关Cluster 6.(当Type为1时，该字段才存在)
|
///<para>特殊设备：</para>
|
///<para>1、如果为hdl功能按键则填64528。</para>
|
///<para>2、如果为IAS安防设备则填入1280。</para>
|
///<para>3、如果为门锁操作事件，则填入64529.</para>
|
/// <para>4、如果为随心贴按键On/Off命令反馈，则填入1282</para>
|
/// </summary>
|
public int Cluster_ID;
|
/// <summary>
|
///触发联动的属性 如Cluster=6时 AttriButeId=0为开关属性.(当Type为1时，该字段才存在)
|
///<para>特殊设备：</para>
|
///<para>1.如果为hdl功能按键则为按键触发时上报触发信息的按键号类型。</para>
|
///<para>2.如果为IAS安防设备则填入1281。</para>
|
///<para>3.如果为门锁操作事件则填入门锁操作事件的OperationEventSoure列表值，参考第八章节3门锁操作事件通知</para>
|
///<para>4.如果为随心贴On/Off命令反馈，则填入1283。</para>
|
/// </summary>
|
public int AttriButeId;
|
/// <summary>
|
///属性状态临界值1 (当Type为1 时，该字段才存在)
|
/// <para>特殊设备：</para>
|
///<para>如果为hdl功能按键，则为下列按键模式：</para>
|
///<para>1：点击 2：前点击 4：后单击 8：仅双击</para>
|
///<para>16：前双击 32：后双击 64：仅长按 </para>
|
///<para>128：前长按 256：后长按 512：长按释放。</para>
|
///<para>2.如果为IAS安防设备则为IAS安防设备信息上报数据中的ZoneStatus。</para>
|
///<para>3.如果为门锁操作事件则填入门锁操作事件的Operation Event Code值，参考第八章节3门锁操作事件通知</para>
|
///<para>4、如果为随心贴On/Off则填入 0。当接收到随心贴设备On/Off命令反馈将触发逻辑</para>
|
/// </summary>
|
public int AttriButeData1;
|
/// <summary>
|
///属性状态临界值2 。(当Type为1 时，该字段才存在)
|
///<para>特殊设备：（见AttriButeData1说明）</para>
|
/// </summary>
|
public int AttriButeData2;
|
/// <summary>
|
///当Type为1 时，该字段才存在
|
///<para>上报的设备属性状态值AttriButeData（参考设备状态查询章节）与设定的临界值比较。</para>
|
///<para>0 : 上报的设备属性状态值大于AttriButeData1时触发动作</para>
|
///<para>1：上报的设备属性状态值等于AttriButeData1时触发动作</para>
|
///<para>2：上报的设备属性状态值小于AttriButeData1时触发动作</para>
|
///<para>3：上报的设备属性状态值大于AttriButeData1且小于AttriButeData2时触发动作</para>
|
///<para>4：上报的设备属性状态值小于AttriButeData1或大于AttriButeData2时触发动作</para>
|
///<para>5：上报的设备属性状态值和AttriButeData1进行与运算结果不为0时触发动作。（方便用于安防设备信息上报）</para>
|
///<para>特殊设备：如果为随心贴On/Off则填入 0。当接收到随心贴设备On/Off命令反馈将触发逻辑。</para>
|
/// </summary>
|
public int Range;
|
}
|
|
/// <summary>
|
/// 任务数据
|
/// </summary>
|
[System.Serializable]
|
public class TaskListInfo
|
{
|
/// <summary>
|
/// 任务类型。
|
///<para>1：开关 （设备具有开关功能时可用）</para>
|
///<para>3：亮度调整（设备具有亮度调节功能时可用）</para>
|
///<para>4：颜色调整 （设备具有颜色调节功能时可用）</para>
|
///<para>5：恒温器（设备具有恒温器功能时可用）</para>
|
///<para>6: 窗帘设备（设备具有窗帘功能时可用）</para>
|
///<para>7：设备identify识别。</para>
|
///<para>8：开关报警模式 </para>
|
///<para>9：squawk command</para>
|
///</summary>
|
public int TaskType;
|
/// <summary>
|
/// Data1取值
|
/// <para>开关 :Data1（数值）: 0关/1开</para>
|
///<para>亮度调整 Data1（数值）：亮度值</para>
|
///<para>颜色调整 Data1（数值）:色调</para>
|
/// <para>恒温器 Data1（数值）: 0加热/1制冷/2自动调节/3 设置工作模式/4 设置加热度数 5/设置制冷度数 6/设置风扇模式</para>
|
/// <para>窗帘设备 Data1（数值）: 0 打开/ 1关闭/ 2 停止转动/ 4 调整到指定高度/ 5 调整到指定的百分比处位置 / 7 调整到指定倾斜角/ 8 调整到指定的百分比倾斜度</para>
|
/// <para>设备identify识别。Data1为identify闪烁闪烁时间（0-65535秒）。</para>
|
/// <para>开关报警模式 Data1（数值，4字节整型）第1字节（bit0-bit7）表示报警模式，字节值0：停止蜂鸣器1：盗窃报警 2：火灾报警 3：紧急情况报警 4：警车发出的报警 5：消防车发出的报警 6：备用的报警。第2字节（bit8-bit15）表示是否启用报警灯，字节值 0：不启用 1：启用。第3字节（bit16-bit23）表示报警音量，字节值0：Low，1：Medium，2：high，3：very high。</para>
|
/// <para>squawk command Data1（数值，4字节整型）第1字节（bit0-bit7）表示报警模式，字节值0：安防系统“布防”音效” ，1：安防系统“撤防”音效。第2字节（bit8-bit15）表示是否启动报警灯，字节值0：不启动，1：启动。第3字节（bit16-bit23）表示报警音量，字节值0：Low ，1：Medium ，2：high ，3: very high。</para>
|
/// </summary>
|
public int Data1;
|
/// <summary>
|
/// Data2取值
|
/// <para>开关 Data2（数值）: 0</para>
|
/// <para>亮度调整 Data2（数值）: 0</para>
|
/// <para>颜色调整 Data2（数值）：饱和度 </para>
|
///<para> 恒温器Data2数值如下：
|
/// 【当Data1=0|1|2时，Data2为要变化的度数，单位：0.1℃ 。】
|
///【若Data1=3，Data2为要设定的空调模式（0-9），0：off，1：auto，3：cool， 4：heat ，5：emergency heating, 6：precooling，7：fan only ，8：dry，9：sleep。】
|
///【若Data1=4|5，Data2为加热或制冷度数，单位0.01摄氏度。】
|
///【若Data1=6，Data2为要设定的风扇模式（0-6），0：off，1：low，2：medium，3：high，4：on，5：auto，6：smart】 </para>
|
///<para>窗帘设备，Data2数值如下
|
///【当Data1=4或7，Data2为调整的高度或倾斜角度 倾斜角度单位为0.1°】。
|
///【当Data1=5 或 8，Data2为百分比，0-100表示0%-100%】</para>
|
///<para>设备identify识别。Data2（数值）: 0 </para>
|
///<para>开关报警模式 Data2（数值，4字节整型）第1、2字节（bit0-bit15）表示报警时长，字节值 0-65535，单位：秒。第3字节（bit16-bit23）表示闪烁占空比，字节值0-100。第4字节（bit16-bit23）表示报警灯亮度，字节值0：Low ，1：Medium ，2：high ，3: very high。</para>
|
///<para>squawk command：Data2（数值）: 0 </para>
|
/// </summary>
|
/// <value>The type of the task.</value>
|
public int Data2;
|
}
|
|
/// <summary>
|
///条件类型
|
///<para>0：时间点条件，在某个时间发生</para>
|
///<para>1：设备状态变化条件</para>
|
///<para>2：其他逻辑条件</para>
|
///<para>3：计数器条件</para>
|
///<para>4：倒计时</para>
|
///<para>5：时间段条件</para>
|
/// </summary>
|
public enum ConditionType
|
{
|
/// <summary>
|
///时间点条件，在某个时间发生
|
/// </summary>
|
Time = 0,
|
/// <summary>
|
///设备状态变化条件
|
/// </summary>
|
Device = 1,
|
/// <summary>
|
///其他逻辑条件
|
/// </summary>
|
Logic = 2,
|
/// <summary>
|
///计数器条件
|
/// </summary>
|
Counter = 3,
|
/// <summary>
|
///倒计时
|
/// </summary>
|
CountDown = 4,
|
/// <summary>
|
///条件类型
|
///时间段条件
|
/// </summary>
|
TimeBucket = 5,
|
}
|
#endregion
|
|
//public static string LogistFile = "LogistFile";
|
|
//public void SaveLogicObj(string logicFilePath)
|
//{
|
// Shared.IO.FileUtils.WriteFileByBytes(logicFilePath, Encoding.UTF8.GetBytes(Newtonsoft.Json.JsonConvert.SerializeObject(this)));
|
//}
|
|
///// <summary>
|
///// 根据逻辑路径恢复逻辑对象
|
///// logicFilePath命名："Logic" + LogicId;
|
///// </summary>
|
//public static Logic GetLogicByFilePath(string logicFilePath)
|
//{
|
// try
|
// {
|
// return Newtonsoft.Json.JsonConvert.DeserializeObject<Logic>(System.Text.Encoding.UTF8.GetString(Shared.IO.FileUtils.ReadFile(logicFilePath)));
|
// }
|
// catch
|
// {
|
// return new Logic();
|
// }
|
//}
|
}
|
}
|
