/// <summary>
/// 获取交换机的基础信息
/// </summary>
/// <param name="masProtocol"></param>
/// <param name="deviceControl"></param>
/// <param name="deviceCode"></param>
/// <param name="commPort"></param>
/// <returns></returns>
public byte[] HandGetSwitchInfo(MasProtocol masProtocol, GetSwitchboardParamCommRequest getswicthInfo, ref string deviceCode)
{
NetworkDeviceInfo netmacobject = null;
GetSwitchboardParamCommRequestCommand commandobject = new GetSwitchboardParamCommRequestCommand();
byte[] sendbuff = null;
if (getswicthInfo == null)
{
return(sendbuff);
}
netmacobject = Cache.CacheManager.GetItemByKey <NetworkDeviceInfo>(getswicthInfo.DeviceCode, true);//按照IP搜索对象
if (netmacobject == null)
{
LogHelper.Error("获取交换机的基础信息，未找到对应的IP地址【" + getswicthInfo.DeviceCode + "】");
return(sendbuff);
}
lock (Cache.LockWorkNet)//用缓存的连接号和接收时间进行更新
{
CacheNetWork curnet = Cache.LstWorkNet.Find(delegate(CacheNetWork p) { return(p.IP == netmacobject.IP); });
if (curnet != null)
{
netmacobject.NetID = curnet.NetID;
}
}
if (netmacobject.NetID > 0)
{
deviceCode = netmacobject.IP;
commandobject = Basic.Framework.Common.ObjectConverter.Copy <GetSwitchboardParamCommRequest, GetSwitchboardParamCommRequestCommand>(getswicthInfo); //得到基础数据
sendbuff = commandobject.ToBytes(); //得到通讯命令的返回Buffer数组
}
return(sendbuff);
}
/// <summary>
/// 获取网络模块参数
/// </summary>
/// <param name="networkModuleCacheRequest"></param>
/// <returns></returns>
public BasicResponse <NetDeviceSettingInfo> GetNetworkModuletParameters(NetworkModuletParametersGetRequest networkModuleCacheRequest)
{
BasicResponse <NetDeviceSettingInfo> Result = new BasicResponse <NetDeviceSettingInfo>();
QuerytNetworkDeviceParamRequest searchAssignNetDeviceRequest = new QuerytNetworkDeviceParamRequest();
searchAssignNetDeviceRequest.Mac = networkModuleCacheRequest.Mac;
//searchAssignNetDeviceRequest.WaitTime = networkModuleCacheRequest.WaitTime;
//todo 调用RPC组件获取数据
MasProtocol masProtocol = new MasProtocol(SystemType.Security, DirectionType.Down, ProtocolType.QuerytNetworkDeviceParamRequest);
masProtocol.Protocol = searchAssignNetDeviceRequest;
//调用RPC发送搜索网络模块命令，并接收回传的参数
var result = RpcService.Send <QuerytNetworkDeviceParamResponse>(masProtocol, RequestType.DeviceUdpRequest);
if (result == null)
{
Result.Code = 1;
Result.Message = "获取网络模块参数失败！";
return(Result);
}
Result.Data = result.NetworkDeviceParam;
return(Result);
}
/// <summary>
/// 核心服务层同步缓存到网关的处理
/// </summary>
/// <param name="masProtocol"></param>
public void HandleUpdateCacheDataRequest(MasProtocol masProtocol)
{
UpdateCacheDataRequest request = masProtocol.Deserialize <UpdateCacheDataRequest>();
if (request == null)
{
return;
}
if (request.DeviceList != null)
{
HandleDeviceCache(request.DeviceList);//测点同步
}
if (request.DeviceTypeList != null)
{
HandleDeviceTypeCache(request.DeviceTypeList);//设备类型同步
}
if (request.NetworkDeviceList != null)
{
HandleNetworkDeviceCache(request.NetworkDeviceList);//网络模块同步
}
if (request.DeviceAcrossControlList != null)
{
HandleDeviceAcrossControlCache(request.DeviceAcrossControlList);//交叉控制同步
}
}
public byte[] HandUpdateCancle(MasProtocol masProtocol, UpdateCancleRequest updateCancleRequest, ref string deviceCode)
{
DeviceInfo deviceinfoobject = null;
DeviceTypeInfo devicetypeobject = null;
NetworkDeviceInfo netmacobject = null;
UpdateCancleRequestCommand commandobject = new UpdateCancleRequestCommand();
byte[] sendbuff = null;
if (masProtocol == null || updateCancleRequest == null)
{
return(sendbuff);
}
if (!GetDeviceObject(ref deviceinfoobject, ref devicetypeobject, ref netmacobject, ProtocolType.DeviceControlRequest, updateCancleRequest.DeviceCode))
{
return(sendbuff);
}
if (netmacobject.NetID > 0)
{
deviceCode = netmacobject.MAC; //向下的发送的MAC地址
commandobject = Basic.Framework.Common.ObjectConverter.Copy <UpdateCancleRequest, UpdateCancleRequestCommand>(updateCancleRequest); //得到基础数据
commandobject.DeviceId = updateCancleRequest.DeviceId;
commandobject.HardVersion = updateCancleRequest.HardVersion;
commandobject.FileVersion = updateCancleRequest.FileVersion;
commandobject.def = deviceinfoobject; // Framework.Common.ObjectConverter.DeepCopy<DeviceInfo>(deviceinfoobject);//得到分站的对象必须是深度拷贝;
sendbuff = commandobject.ToBytes(); //得到通讯命令的返回Buffer数组
//if (sendbuff != null)
//{
// sendbuff = Cache.GetPackages(sendbuff, netmacobject, deviceinfoobject, 2, CommandCodes.ExtendCommand, (byte)devicetypeobject.LC2);//通过当前网络模块进行打包
//}
}
return(sendbuff);
}
public byte[] HandQueryHistoryRealData(MasProtocol masProtocol, QueryHistoryRealDataRequest queryHistoryRealData, ref string deviceCode, ref int commPort)
{
DeviceInfo deviceinfoobject = null;
DeviceTypeInfo devicetypeobject = null;
NetworkDeviceInfo netmacobject = null;
QueryHistoryRealDataRequestCommand commandobject = new QueryHistoryRealDataRequestCommand();
byte[] sendbuff = null;
if (queryHistoryRealData == null)
{
return(sendbuff);
}
if (!GetDeviceObject(ref deviceinfoobject, ref devicetypeobject, ref netmacobject, ProtocolType.QueryHistoryRealDataRequest, queryHistoryRealData.DeviceCode))
{
return(sendbuff);
}
if (netmacobject.NetID > 0)
{
commPort = deviceinfoobject.K3;
deviceCode = netmacobject.IP; //向下的发送的MAC地址
commandobject = Basic.Framework.Common.ObjectConverter.Copy <QueryHistoryRealDataRequest, QueryHistoryRealDataRequestCommand>(queryHistoryRealData); //得到基础数据
commandobject.def = deviceinfoobject; //得到分站的对象必须是深度拷贝
commandobject.SerialNumber = queryHistoryRealData.SerialNumber;
sendbuff = commandobject.ToBytes(); //得到通讯命令的返回Buffer数组
//if (sendbuff != null)
//{
// sendbuff = Cache.GetPackages(sendbuff, netmacobject, deviceinfoobject, 2, CommandCodes.ExtendCommand, (byte)devicetypeobject.LC2);//通过当前网络模块进行打包
//}
}
return(sendbuff);
}
public byte[] HandSensorGradingAlarm(MasProtocol masProtocol, SetSensorGradingAlarmRequest sensorGradingAlarm, ref string deviceCode, ref int commPort)
{
DeviceInfo deviceinfoobject = null;
DeviceTypeInfo devicetypeobject = null;
NetworkDeviceInfo netmacobject = null;
SetSensorGradingAlarmRequestCommand commandobject = new SetSensorGradingAlarmRequestCommand();
byte[] sendbuff = null;
if (sensorGradingAlarm == null)
{
return(sendbuff);
}
if (!GetDeviceObject(ref deviceinfoobject, ref devicetypeobject, ref netmacobject, ProtocolType.SetSensorGradingAlarmRequest, sensorGradingAlarm.DeviceCode))
{
return(sendbuff);
}
if (netmacobject.NetID > 0)
{
commPort = deviceinfoobject.K3;
deviceCode = netmacobject.IP; //向下的发送的MAC地址
commandobject = Basic.Framework.Common.ObjectConverter.Copy <SetSensorGradingAlarmRequest, SetSensorGradingAlarmRequestCommand>(sensorGradingAlarm); //得到基础数据
commandobject.def = deviceinfoobject; //得到分站的对象必须是深度拷贝
sendbuff = commandobject.ToBytes(); //得到通讯命令的返回Buffer数组
//if (sendbuff != null)
//{
// sendbuff = Cache.GetPackages(sendbuff, netmacobject, deviceinfoobject, 2, CommandCodes.ExtendCommand, (byte)devicetypeobject.LC2);//通过当前网络模块进行打包
//}
}
return(sendbuff);
}
public byte[] HandModificationDeviceAdress(MasProtocol masProtocol, ModificationDeviceAdressRequest modificationDeviceAdress, ref string deviceCode, ref int commPort)
{
DeviceInfo deviceinfoobject = null;
DeviceTypeInfo devicetypeobject = null;
NetworkDeviceInfo netmacobject = null;
ModificationDeviceAdressRequestCommand commandobject = new ModificationDeviceAdressRequestCommand();
byte[] sendbuff = null;
if (masProtocol == null || modificationDeviceAdress == null)
{
return(sendbuff);
}
if (!GetDeviceObject(ref deviceinfoobject, ref devicetypeobject, ref netmacobject, ProtocolType.ModificationDeviceAdressRequest, modificationDeviceAdress.DeviceCode))
{
return(sendbuff);
}
if (netmacobject.NetID > 0)
{
commPort = deviceinfoobject.K3;
deviceCode = netmacobject.IP; //向下的发送的MAC地址
commandobject = Basic.Framework.Common.ObjectConverter.Copy <ModificationDeviceAdressRequest, ModificationDeviceAdressRequestCommand>(modificationDeviceAdress); //得到基础数据
commandobject.def = deviceinfoobject; //得到分站的对象必须是深度拷贝
sendbuff = commandobject.ToBytes(); //得到通讯命令的返回Buffer数组
}
return(sendbuff);
}
public byte[] HandResetDeviceCommand(MasProtocol masProtocol, ResetDeviceCommandRequest resetDevice, ref string deviceCode, ref int commPort)
{
DeviceInfo deviceinfoobject = null;
DeviceTypeInfo devicetypeobject = null;
NetworkDeviceInfo netmacobject = null;
ResetDeviceRequestCommand commandobject = new ResetDeviceRequestCommand();
byte[] sendbuff = null;
if (resetDevice == null)
{
return(sendbuff);
}
if (!GetDeviceObject(ref deviceinfoobject, ref devicetypeobject, ref netmacobject, ProtocolType.ResetDeviceCommandRequest, resetDevice.DeviceCode))
{
return(sendbuff);
}
if (netmacobject.NetID > 0)
{
commPort = deviceinfoobject.K3;
deviceCode = netmacobject.IP; //向下的发送的MAC地址
commandobject = Basic.Framework.Common.ObjectConverter.Copy <ResetDeviceCommandRequest, ResetDeviceRequestCommand>(resetDevice); //得到基础数据
commandobject.def = deviceinfoobject; //得到分站的对象必须是深度拷贝
sendbuff = commandobject.ToBytes(); //得到通讯命令的返回Buffer数组
}
return(sendbuff);
}
public byte[] HandDeviceControl(MasProtocol masProtocol, DeviceControlRequest deviceControl, ref string deviceCode, ref int commPort)
{
DeviceInfo deviceinfoobject = null;
DeviceTypeInfo devicetypeobject = null;
NetworkDeviceInfo netmacobject = null;
DeviceControlRequestCommand commandobject = new DeviceControlRequestCommand();
byte[] sendbuff = null;
if (masProtocol == null || deviceControl == null)
{
return(sendbuff);
}
if (!GetDeviceObject(ref deviceinfoobject, ref devicetypeobject, ref netmacobject, ProtocolType.DeviceControlRequest, deviceControl.DeviceCode))
{
return(sendbuff);
}
if (netmacobject.NetID > 0)
{
commPort = deviceinfoobject.K3;
deviceCode = netmacobject.IP;
commandobject = Basic.Framework.Common.ObjectConverter.Copy <DeviceControlRequest, DeviceControlRequestCommand>(deviceControl); //得到基础数据
commandobject.OrderVersion = (byte)devicetypeobject.LC2; //设备设备类型
commandobject.def = deviceinfoobject;
sendbuff = commandobject.ToBytes(); //得到通讯命令的返回Buffer数组
}
return(sendbuff);
}
private void UpdateStationDataProc(int exFlag, byte[] data, MasProtocol protocol, ushort startIndex, string point)
{
switch (exFlag)
{
case 1: //中心站请求远程升级
StationUpdateResponseCommand stationUpdate = new StationUpdateResponseCommand();
stationUpdate.Handle(data, protocol, startIndex, point);
break;
case 4: //中心站巡检分站的文件接收情况
InspectionResponseCommand inspection = new InspectionResponseCommand();
inspection.Handle(data, protocol, startIndex, point);
break;
case 5: //中心站告知分站重启并升级
RestartResponseCommand restart = new RestartResponseCommand();
restart.Handle(data, protocol, startIndex, point);
break;
case 6: //中心站告知分站该次升级过程中止
UpdateCancleResponseCommand updateCancle = new UpdateCancleResponseCommand();
updateCancle.Handle(data, protocol, startIndex, point);
break;
case 7: //中心站告知分站恢复最近一次备份
ReductionResponseCommand reduction = new ReductionResponseCommand();
reduction.Handle(data, protocol, startIndex, point);
break;
case 8: //中心站查询分站信息
GetStationUpdateStateResponseCommand getStationUpdateState = new GetStationUpdateStateResponseCommand();
getStationUpdateState.Handle(data, protocol, startIndex, point);
break;
}
}
public void SendInitializeRequestToCenter(MasProtocol Protocol, string point)
{
DeviceInitializeRequest ResponseObject = new DeviceInitializeRequest();
Protocol.ProtocolType = ProtocolType.DeviceInitializeRequest;
ResponseObject.DeviceCode = point;
Protocol.Protocol = ResponseObject;
}
public void SendInitializeAffirmToCenter(MasProtocol Protocol, string point, ushort crc)
{
InitializeResponse ResponseObject = new InitializeResponse();
Protocol.ProtocolType = ProtocolType.InitializeResponse;
ResponseObject.StationCrc = crc;
ResponseObject.DeviceCode = point;
Protocol.Protocol = ResponseObject;
}
/// <summary>
/// 启动初始化缓存
/// </summary>
public void Start()
{
MasProtocol masProtocol = new MasProtocol(SystemType.Security, DirectionType.Up, ProtocolType.QueryCacheDataRequest);
masProtocol.Protocol = new QueryCacheDataRequest();
var result = GatewayManager.RpcManager.Send <QueryCacheDataResponse>(masProtocol, RequestType.BusinessRequest);
if (result == null)
{
return;
}
if (result.DeviceList != null && result.DeviceList.Count > 0)
{
GatewayManager.CacheManager.AddItems <DeviceInfo>(result.DeviceList);
LogHelper.Debug("获取测点缓存成功，数量：" + result.DeviceList.Count);
}
else
{
LogHelper.Debug("获取测点缓存成功，数量：0");
}
if (result.DeviceTypeList != null && result.DeviceTypeList.Count > 0)
{
GatewayManager.CacheManager.AddItems <DeviceTypeInfo>(result.DeviceTypeList);
LogHelper.Debug("获取测点类型缓存成功，数量：" + result.DeviceTypeList.Count);
}
else
{
LogHelper.Debug("获取测点类型缓存成功，数量：0");
}
if (result.NetworkDeviceList != null && result.NetworkDeviceList.Count > 0)
{
GatewayManager.CacheManager.AddItems <NetworkDeviceInfo>(result.NetworkDeviceList);
LogHelper.Debug("获取网络模块缓存成功，数量：" + result.NetworkDeviceList.Count);
}
else
{
LogHelper.Debug("获取网络模块缓存成功，数量：0");
}
if (result.DeviceAcrossControlList != null && result.DeviceAcrossControlList.Count > 0)
{
GatewayManager.CacheManager.AddItems <DeviceAcrossControlInfo>(result.DeviceAcrossControlList);
LogHelper.Debug("获取交叉控制缓存成功，数量：" + result.DeviceAcrossControlList.Count);
}
else
{
LogHelper.Debug("获取交叉控制缓存成功，数量：0");
}
}
public void HandleSetSensorGradingAlarm(byte[] data, MasProtocol protocol, ushort startIndex, byte deviceCommunicationType, string point)
{
SetSensorGradingAlarmResponse ResponseObject = new SetSensorGradingAlarmResponse();
protocol.ProtocolType = ProtocolType.SetSensorGradingAlarmResponse;
ResponseObject.DeviceCode = point;
ResponseObject.RandomCode = 0;
protocol.Protocol = ResponseObject;
}
/// <summary>
/// 处理回发的数据体，以分站为对象
/// </summary>
/// <param name="data"></param>
/// <param name="protocolData"></param>
public void HandleDeviceData(byte[] data, MasProtocol protocolData)
{
DeviceTypeInfo dev = null;
dev = Cache.CacheManager.QueryFrist <DeviceTypeInfo>(p => p.Devid == def.Devid, true);
if (dev != null)
{
DataControlByMonitor(data, protocolData, (byte)dev.LC2);
}
}
/// <summary>
/// 调用驱动处理 核心服务层到驱动的命令
/// </summary>
/// <param name="driverCode"></param>
/// <param name="masProtocol"></param>
public void HandleProtocolData(string driverCode, MasProtocol masProtocol)
{
if (!_driverCache.ContainsKey(driverCode))
{
LogHelper.Error("DriverManager.HandleProtocolData() 错误，driverCode：" + driverCode + " 驱动编号不存在");
return;
}
_driverCache[driverCode].HandleProtocolData(masProtocol);
}
/// <summary>
/// 结束广播任务
/// </summary>
/// <param name="masProtocol"></param>
/// <returns></returns>
public static RpcResponse endPaTask(MasProtocol masProtocol)
{
EndPaTaskRequest request = masProtocol.Deserialize <EndPaTaskRequest>();
if (request == null)
{
return(null);
}
EndPaTaskResponse response = BroadCastControllerProxy.broadCastControllerProxy.endPaTask(request);
return(RpcResponse.Response <EndPaTaskResponse>(response));
}
/// <summary>
/// 启动音乐广播任务
/// </summary>
/// <param name="masProtocol"></param>
/// <returns></returns>
public static RpcResponse startPaMusicTask(MasProtocol masProtocol)
{
StartPaMusicTaskRequest request = masProtocol.Deserialize <StartPaMusicTaskRequest>();
if (request == null)
{
return(null);
}
StartPaMusicTaskResponse response = BroadCastControllerProxy.broadCastControllerProxy.startPaMusicTask(request);
return(RpcResponse.Response <StartPaMusicTaskResponse>(response));
}
/// <summary>
/// 删除播放列表音乐
/// </summary>
/// <param name="masProtocol"></param>
/// <returns></returns>
public static RpcResponse delPlayListMusic(MasProtocol masProtocol)
{
PlayListMusicControlRequest request = masProtocol.Deserialize <PlayListMusicControlRequest>();
if (request == null)
{
return(null);
}
PlayListMusicControlResponse response = BroadCastControllerProxy.broadCastControllerProxy.delPlayListMusic(request);
return(RpcResponse.Response <PlayListMusicControlResponse>(response));
}
/// <summary>
/// 查询终端
/// </summary>
/// <param name="masProtocol"></param>
/// <returns></returns>
public static RpcResponse queryTerm(MasProtocol masProtocol)
{
TerminalQueryRequest request = masProtocol.Deserialize <TerminalQueryRequest>();
if (request == null)
{
return(null);
}
TerminalQueryResponse response = BroadCastControllerProxy.broadCastControllerProxy.queryTerm(request);
return(RpcResponse.Response <TerminalQueryResponse>(response));
}
/// <summary>
/// 监听呼叫
/// </summary>
/// <param name="masProtocol"></param>
/// <returns></returns>
public static RpcResponse monitorCall(MasProtocol masProtocol)
{
MonitorCallRequest request = masProtocol.Deserialize <MonitorCallRequest>();
if (request == null)
{
return(null);
}
MonitorCallResponse response = BroadCastControllerProxy.broadCastControllerProxy.monitorCall(request);
return(RpcResponse.Response <MonitorCallResponse>(response));
}
/// <summary>
/// 挂断呼叫
/// </summary>
/// <param name="masProtocol"></param>
/// <returns></returns>
public static RpcResponse hangupCall(MasProtocol masProtocol)
{
HangupCallRequest request = masProtocol.Deserialize <HangupCallRequest>();
if (request == null)
{
return(null);
}
HangupCallResponse response = BroadCastControllerProxy.broadCastControllerProxy.hangupCall(request);
return(RpcResponse.Response <HangupCallResponse>(response));
}
/// <summary>
/// 发送数据到远程服务器
/// </summary>
/// <typeparam name="TResult">返回的结果类型</typeparam>
/// <param name="masProtocol">待发送的协议</param>
/// <param name="requestType">请求的类型</param>
/// <returns>调用结果</returns>
public TResult Send <TResult>(MasProtocol masProtocol, RequestType requestType)
{
GatewayRpcRequest request = new GatewayRpcRequest(requestType);
request.MasProtocol = masProtocol;
var response = _client.Send <GatewayRpcRequest, TResult>(request);
if (response.IsSuccess)
{
//todo
}
return(response.Data);
}
private void RealDataCreateByState(MasProtocol protocol, ItemState state)
{
QueryRealDataResponse realData = new QueryRealDataResponse();
realData.RealDataItems = new List <RealDataItem>();
protocol.ProtocolType = ProtocolType.QueryRealDataResponse;
RealDataItem item = new RealDataItem();
item = new RealDataItem();
item.Channel = "0";
item.Address = "0";
item.State = state;
realData.RealDataItems.Add(item);
realData.DeviceCode = def.Point;
protocol.Protocol = realData;
}
public void HandleModificationDeviceAdressData(byte[] data, MasProtocol protocol, ushort startIndex, byte deviceCommunicationType, string point)
{
ModificationDeviceAdressResponse ResponseObject = new ModificationDeviceAdressResponse();
protocol.ProtocolType = ProtocolType.ModificationDeviceAdressResponse;
ResponseObject.DeviceCode = point;
if (startIndex + 6 < data.Length)
{
ResponseObject.RandomCode = data[startIndex + 6];
}
else
{
ResponseObject.RandomCode = 0;
}
protocol.Protocol = ResponseObject;
}
/// <summary>
/// 向网关同步数据
/// </summary>
/// <param name="SendItemList"></param>
/// <returns></returns>
private bool SynchronousDataToGateway(List <AreaInfo> SendItemList)
{
foreach (AreaInfo areaInfo in SendItemList)
{
PartitionControlRequest partitionControlRequest = new PartitionControlRequest();
if (string.IsNullOrEmpty(areaInfo.Areadescribe))
{
partitionControlRequest.zoneId = "";//分区标识
}
else
{
partitionControlRequest.zoneId = areaInfo.Areadescribe; //分区标识
}
partitionControlRequest.paTaskDN = ""; //分区广播接入号码[暂未使用]
partitionControlRequest.zoneName = areaInfo.Areaname; //分区名称
partitionControlRequest.almLinkUdn1 = ""; //分区报警联动用户号码列表[暂未使用]
partitionControlRequest.almLinkUdn2 = ""; //分区报警联动用户号码列表[暂未使用]
partitionControlRequest.almLinkUdn3 = ""; //分区报警联动用户号码列表[暂未使用]
partitionControlRequest.InfoState = areaInfo.InfoState;
//调用RPC发送
MasProtocol masProtocol = new MasProtocol(SystemType.Broadcast, DirectionType.Down, ProtocolType.PartitionControlRequest);
masProtocol.Protocol = partitionControlRequest;
PartitionControlResponse result = RpcService.Send <PartitionControlResponse>(masProtocol, RequestType.BusinessRequest);
if (result == null && result.retCode != "0")
{
Basic.Framework.Logging.LogHelper.Error("向网关同步广播分区信息失败！,分区名称：" + areaInfo.Areaname);
return(false);
}
else
{
//将返回的分区标识更新到缓存及数据库 20180103
areaInfo.Areadescribe = result.zoneId;
//更新数据库
var _area = ObjectConverter.Copy <AreaInfo, AreaModel>(areaInfo);
_Repository.UpdateArea(_area);
//更新区域缓存 20171128
AreaCacheUpdateRequest AreaCacheUpdateRequest = new AreaCacheUpdateRequest();
AreaCacheUpdateRequest.AreaInfo = areaInfo;
_AreaCacheService.UpdateAreaCache(AreaCacheUpdateRequest);
}
}
return(true);
}
/// <summary>
/// 仅适用于分站的电源箱解码
/// <param name="data">传入回发的Buffer</param>
/// <param name="protocol">回发的对象</param>
/// <param name="startIndex">分站号的索引位置</param>
/// <param name="deviceCommunicationType">分站的类型</param>
/// <param name="point">分站的测点号</param>
/// </summary>
public void HandleBatteryRealData(byte[] data, MasProtocol protocol, ushort startIndex, byte deviceCommunicationType, string point)
{
QueryBatteryRealDataResponse realData = new QueryBatteryRealDataResponse();
BatteryRealDataItem BatteryItem = new BatteryRealDataItem();
protocol.ProtocolType = ProtocolType.QueryBatteryRealDataResponse;
realData.BatteryDateTime = DateTime.Now;
realData.DeviceCode = point;
realData.BatteryRealDataItems = new List <BatteryRealDataItem>();
BatteryItem.DeviceProperty = ItemDevProperty.Substation;
Cache.HandleDeviceBattery(data, (byte)(startIndex + 5), BatteryItem);//解析电源箱的数据 111
realData.BatteryRealDataItems.Add(BatteryItem);
protocol.Protocol = realData;
}
/// <summary>
/// 音乐管理
/// </summary>
/// <param name="masProtocol"></param>
/// <returns></returns>
public static RpcResponse musicManage(MasProtocol masProtocol)
{
MusicControlRequest request = masProtocol.Deserialize <MusicControlRequest>();
if (request == null)
{
return(null);
}
if (request.InfoState == InfoState.AddNew)
{
addMusic(request);
}
if (request.InfoState == InfoState.Delete)
{
delMusic(request);
}
return(null);
}
/// <summary>
/// 发送心跳请求
/// </summary>
/// <returns></returns>
private bool SendHeartbeatRequest()
{
HeartbeatRequest request = new HeartbeatRequest()
{
RequestTime = DateTime.Now,
Status = 1
};
MasProtocol masProtocol = new MasProtocol(SystemType.Security, DirectionType.Up, ProtocolType.HeartbeatRequest);
masProtocol.Protocol = request;
var response = GatewayManager.RpcManager.Send <GatewayRpcResponse>(masProtocol, RequestType.DeviceRequest);
if (response != null && response.IsSuccess)
{
return(true);
}
return(false);
}
/// <summary>
/// 向网关同步数据
/// </summary>
/// <param name="SendItemList"></param>
/// <returns></returns>
private bool SynchronousDataToGateway(List <Jc_DefInfo> SendItemList)
{
foreach (Jc_DefInfo deviceInfo in SendItemList)
{
TerminalControlRequest terminalControlRequest = new TerminalControlRequest();
//查找分区标识
AreaCacheGetByKeyRequest AreaCacheRequest = new AreaCacheGetByKeyRequest();
AreaCacheRequest.Areaid = deviceInfo.Areaid;
AreaInfo areaInfo = _areaCacheService.GetByKeyAreaCache(AreaCacheRequest).Data;
if (areaInfo != null)
{
terminalControlRequest.zoneId = areaInfo.Areadescribe;//分区标识
}
else
{
Basic.Framework.Logging.LogHelper.Error("未找到广播设备对应的分区信息，设备标识：" + deviceInfo.Point);
return(false);
}
terminalControlRequest.termDN = deviceInfo.Point; //终端号码
terminalControlRequest.type = deviceInfo.Bz6; //终端类型
terminalControlRequest.name = deviceInfo.Wz; //终端名称
terminalControlRequest.record = deviceInfo.Bz7; //录音使能是否启用
terminalControlRequest.auth = deviceInfo.Bz8; //注册鉴权是否启用
terminalControlRequest.password = deviceInfo.Bz9; //注册鉴权密码
terminalControlRequest.pa = deviceInfo.Bz11; //广播使能是否启用
terminalControlRequest.cfuDN = deviceInfo.Bz12; //始终呼叫转移号码
terminalControlRequest.cfxDN = deviceInfo.Bz13; //条件呼叫转移号码
terminalControlRequest.InfoState = deviceInfo.InfoState;
//调用RPC发送
MasProtocol masProtocol = new MasProtocol(SystemType.Broadcast, DirectionType.Down, ProtocolType.TerminalControlRequest);
masProtocol.Protocol = terminalControlRequest;
TerminalControlResponse result = RpcService.Send <TerminalControlResponse>(masProtocol, RequestType.BusinessRequest);
if (result == null && result.retCode != "0")
{
Basic.Framework.Logging.LogHelper.Error("向网关同步广播设备信息失败！,设备标识：" + deviceInfo.Point);
return(false);
}
}
return(true);
}
