baogq
/
ECommService
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
ECommService/CommService/TCPServer.cs

2894 lines
106 KiB
C#
Raw Permalink Normal View History Unescape Escape

添加项目文件。
1 month ago
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
using System.Threading;
using System.Net;
using System.Net.Sockets;
using System.Data.SqlClient;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Tcp;
using System.Globalization;
using UPPLibs;
using RemoteObjects;
using System.Diagnostics;
using System.ServiceProcess;
namespace CommService
{
/*
*类名称：TCPServer
*创建人：韩荣伟
*创建时间：2010-10-30
*功能描述：集中器通信上层管理类
*/
class TCPServer
{
private int srvport;
private bool listenloop;
private Thread tListenner;
private IPAddress ipadd;
private static List<TCPHandler> TCPHandlerList = new List<TCPHandler>();
//private static Hashtable TCPHandlerTable = new Hashtable();
private static Mutex mut = new Mutex();
//private struRequestInQueue sCurrentReq;
private uint unTimeingCount = 0;
private string connectString = Common.configReader.sConnectString;
private DateTime dtPoint;
private DateTime dtPointBegin;
private DateTime dtPointEnd;
public bool bPointCollect = false;
private Mutex mutForHistoryData = new Mutex();
private Hashtable htRecordForHistoryData = new Hashtable();
private int nDaysofHistoryData = 7;
private Hashtable htOnline = new Hashtable();
private Mutex mutForOnline = new Mutex();
private int nOffLineHours;
/*
*方法名称：RefreshHeartBeat
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：string sTID 集中器ID
*返回描述：void
*功能描述：为离线告警刷新心跳值
*/
public void RefreshHeartBeat(string sTID)
{
mutForOnline.WaitOne();
if (htOnline.ContainsKey(sTID) == false)
{
htOnline.Add(sTID, DateTime.Now);
}
else
{
htOnline[sTID] = DateTime.Now;
}
mutForOnline.ReleaseMutex();
}
/*
*方法名称：CheckOnline
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：void
*返回描述：void
*功能描述：检查离线告警，存库
*/
private void CheckOnline()
{
string sTID = "";
DateTime dtNow = DateTime.Now;
TimeSpan ts = new TimeSpan();
bool res = false;
mutForOnline.WaitOne();
foreach (DictionaryEntry de in htOnline)
{
ts = dtNow - (DateTime)de.Value;
//达到告警时限
if (ts.Hours >= nOffLineHours)
{
sTID = (string)de.Key;
htOnline.Remove(de.Key);
res = true;
break;
}
}
mutForOnline.ReleaseMutex();
//存库
if (res == true)
{
MessageHandler messageHandler = new MessageHandler(null);
messageHandler.SaveOffLineWarning(sTID, ts.Hours);
}
}
/*
*方法名称：ReplaceSameClient
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：string clientName 集中器ID
*返回描述：void
*功能描述：如果有同名的处理实例，取代处理
*/
public void ReplaceSameClient(string clientName)
{
//lock
mut.WaitOne();
if (TCPHandlerList.Count > 0)
{
TCPHandlerList.ForEach(delegate(TCPHandler tcpHandler)
{
if (tcpHandler.tName == clientName)
{
tcpHandler.SetReplaceFlag(true);
tcpHandler.Close();
Common.logFile.write("[" + clientName + "] " + "连接被一个同名的终端取代", LogFile.LOGLVL_NORMAL);
return;
}
});
}
//unlock
mut.ReleaseMutex();
}
/*
*方法名称：AddTCPHandler
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：TCPHandler tcpHandler 集中器通信处理类实例
*返回描述：void
*功能描述：向列表中加入集中器通信处理类实例
*/
public void AddTCPHandler(TCPHandler tcpHandler)
{
//lock
mut.WaitOne();
//add
TCPHandlerList.Add(tcpHandler);
//unlock
mut.ReleaseMutex();
}
/*
*方法名称：RemoveTCPHandler
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：TCPHandler tcpHandler 集中器通信处理类实例
*返回描述：void
*功能描述：从列表中删除集中器通信处理类实例
*/
public void RemoveTCPHandler(TCPHandler tcpHandler)
{
//lock
mut.WaitOne();
//remove
TCPHandlerList.Remove(tcpHandler);
//unlock
mut.ReleaseMutex();
}
//
/*
*方法名称：TCPServer
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：string ip 监听IP, int port 监听端口
*返回描述：void
*功能描述：TCPServer 构造函数，初始化处理
*/
public TCPServer(string ip, int port)
{
srvport = port;
listenloop = true;
ipadd = IPAddress.Parse(ip);
Common.logFile.write("TCPServer 初始化，" + ip + " " + port, LogFile.LOGLVL_NORMAL);
nOffLineHours = Common.configReader.nOffLineHours;
if (nOffLineHours < 1)
{
nOffLineHours = 1;
}
else if (nOffLineHours > 24)
{
nOffLineHours = 24;
}
UpdateNewTimePoint();
}
/*
*方法名称：UpdateNewTimePoint
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：void
*返回描述：void
*功能描述：更新整点时间段，正负55秒
*/
private void UpdateNewTimePoint()
{
DateTime dtNow = DateTime.Now;
dtPoint = new DateTime(dtNow.Year, dtNow.Month, dtNow.Day, dtNow.Hour, 0, 0);
dtPoint = dtPoint.AddHours(1);
dtPointBegin = dtPoint.AddSeconds(-55);
dtPointEnd = dtPoint.AddSeconds(55);
UpdateNewTimePointForHistoryData();
}
/*
*方法名称：UpdateNewTimePointForHistoryData
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：void
*返回描述：void
*功能描述：更新历史整点时间点，添加最新的，删除最久的
*/
private void UpdateNewTimePointForHistoryData()
{
try
{
DateTime dtNow = DateTime.Now;
DateTime dtPoint = new DateTime(dtNow.Year, dtNow.Month, dtNow.Day, dtNow.Hour, 0, 0);
dtPoint = dtPoint.AddHours(1);
mutForHistoryData.WaitOne();
if (htRecordForHistoryData.Count >= nDaysofHistoryData * 24)
{
//加入最新时间点
htRecordForHistoryData.Add(dtPoint, new Hashtable());
Common.logFile.write("维护历史数据整点列表，添加:" + dtPoint, LogFile.LOGLVL_DEBUG);
//去掉时间点最早的一个
dtPoint = dtPoint.AddHours(-nDaysofHistoryData * 24);
htRecordForHistoryData.Remove(dtPoint);
Common.logFile.write("维护历史数据整点列表，移除:" + dtPoint, LogFile.LOGLVL_DEBUG);
}
else if (htRecordForHistoryData.Count == 0)
{
htRecordForHistoryData.Add(dtPoint, new Hashtable());
for (int i = 0; i < (nDaysofHistoryData * 24 - 1); i++)
{
dtPoint = dtPoint.AddHours(-1);
htRecordForHistoryData.Add(dtPoint, new Hashtable());
}
Common.logFile.write("初始化历史数据整点列表，整点数量:" + htRecordForHistoryData.Count, LogFile.LOGLVL_DEBUG);
}
//nDaysofHistoryData
mutForHistoryData.ReleaseMutex();
}
catch (Exception e1)
{
Common.logFile.write("UpdateNewTimePointForHistoryData出现例外，Exception:" + e1, LogFile.LOGLVL_ERROR);
}
}
/*
*方法名称：QueryTimePointForHistoryData
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：string sHistoryData 采集时间, string sMeterID 仪表编号
*返回描述：bool true 是，false 否
*功能描述：查询历史数据是否是整点数据
*/
public bool QueryTimePointForHistoryData(string sHistoryData, string sMeterID)
{
bool res = false;
try
{
IFormatProvider culture = new CultureInfo("zh-CN", true);
if (sHistoryData.Length == 21)
{
sHistoryData = sHistoryData.Substring(1, 19);
}
DateTime dtHistoryData = DateTime.Parse(sHistoryData, culture);
mutForHistoryData.WaitOne();
//htRecordForHistoryData
foreach (DictionaryEntry de in htRecordForHistoryData)
{
DateTime dtKey = (DateTime)de.Key;
if (dtHistoryData >= dtKey.AddSeconds(-55) && dtHistoryData <= dtKey.AddSeconds(55))
{
Hashtable ht = (Hashtable)de.Value;
if (ht.ContainsKey(sMeterID) == false)
{
res = true;
ht.Add(sMeterID, null);
}
break;
}
}
mutForHistoryData.ReleaseMutex();
}
catch (Exception e1)
{
Common.logFile.write("QueryTimePointForHistoryData产生例外，Exception：" + e1.ToString(), LogFile.LOGLVL_ERROR);
}
return res;
}
/*
*方法名称：ListenThreadProc
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：void
*返回描述：void
*功能描述：通信监听线程函数
*/
public void ListenThreadProc()
{
Common.logDebugFile.write("=====ListenThreadProc 启动...", LogFile.LOGLVL_NORMAL);
listenloop = true;
Hashtable props = new Hashtable();
props.Add("useIpAddress", true);
props.Add("bindTo", Common.configReader.sRemotingIP);
props.Add("port", Common.configReader.nRemotingPort.ToString());
MessageHandler m = new MessageHandler();
MessageHandler.htEParams=new Hashtable();
//暂时不进行初始化
//while (MessageHandler.htEParams.Count == 0)
//{
// Thread.Sleep(30000);
// m.Init();
//}
Common.logDebugFile.write("进入监听循环...", LogFile.LOGLVL_NORMAL);
while (listenloop)
{
TcpListener tcpListener = null;
try
{
Common.logDebugFile.write("初始化TcpListener...", LogFile.LOGLVL_NORMAL);
tcpListener = new TcpListener(ipadd, srvport);
// Start listening for client requests
Common.logDebugFile.write("启动TcpListener...", LogFile.LOGLVL_NORMAL);
tcpListener.Start();
//props.Add( "exclusiveAddressUse", "false" );
TcpServerChannel channel = new TcpServerChannel(props, null);
//TcpServerChannel channel = new TcpServerChannel(Common.configReader.nRemotingPort);
ChannelServices.RegisterChannel(channel, false);
RemotingConfiguration.RegisterWellKnownServiceType(typeof(RemoteObjects.ReqHandler),
"RemoteObject", WellKnownObjectMode.SingleCall);
//Enter the listening loop
Common.logDebugFile.write("进入连接循环...", LogFile.LOGLVL_NORMAL);
while (listenloop)
{
// Perform a blocking call to accept requests.
// You could also user server.AcceptSocket() here.
TcpClient client = null;
try
{
if (tcpListener.Pending() == false)
{
Thread.Sleep(500);
continue;
}
//Common.logDebugFile.write("1-等待连接请求...（1-2-3）", LogFile.LOGLVL_NORMAL);
client = tcpListener.AcceptTcpClient();
//Common.logDebugFile.write("2-建立新连接...", LogFile.LOGLVL_NORMAL);
TCPHandler tcpHandler = new TCPHandler(client);
tcpHandler.SetTimeOut(Common.configReader.nTerminalTimeOut);
tcpHandler.Start();
AddTCPHandler(tcpHandler);
//Common.logDebugFile.write("3-建立新连接完成。\r\n\r\n", LogFile.LOGLVL_NORMAL);
//if (count >= 5)
//{
// tcpListener.Stop();
// break;
//}
//count++;
}
catch (Exception e2)
{
Common.logErrFile.write("监听程序 e2---SocketException: " + e2.ToString(), LogFile.LOGLVL_ERROR);
if (listenloop == false)
{
break;
}
Thread.Sleep(1000);
}
}
//if (tcpListener != null)
//{
// tcpListener.Stop();
//}
}
catch (Exception e1)
{
Common.logErrFile.write("监听程序 e1---Exception: " + e1.ToString(), LogFile.LOGLVL_ERROR);
if (listenloop == true)
{
Thread.Sleep(5000);
}
}
}
Common.logDebugFile.write("<<<<<<监听程序 退出>>>>>>>>", LogFile.LOGLVL_NORMAL);
}
/*
*方法名称：Start
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：void
*返回描述：void
*功能描述：启动通信监听线程
*/
public void Start()
{
//start listening thread
//Thread.Sleep(60000);
tListenner = new Thread(new ThreadStart(ListenThreadProc));
tListenner.IsBackground = true;
tListenner.Start();
Common.logSystemFile.write("启动侦听 成功", LogFile.LOGLVL_NORMAL);
}
/*
*方法名称：Stop
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：void
*返回描述：void
*功能描述：停止通信监听线程，资源释放
*/
public void Stop()
{
Common.logFile.write("停止侦听，处理中...", LogFile.LOGLVL_NORMAL);
listenloop = false;
//tcpListener.Stop();
TCPHandler tw = null;
bool loop = true;
while (loop)
{
loop = false;
tw = null;
//lock
mut.WaitOne();
if (TCPHandlerList.Count > 0)
{
tw = TCPHandlerList.ElementAt(0);
loop = true;
tw.stoped = true;
}
//unlock
mut.ReleaseMutex();
if (tw != null)
{
tw.Close();
tw.tWorker.Join();
}
}
TCPHandlerList.Clear();
//tListenner.Join();
Common.logFile.write("停止侦听 成功", LogFile.LOGLVL_NORMAL);
}
/*
*方法名称：GetTCPHandler
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：int hashCode 通信处理实例的哈希编码
*返回描述：TCPHandler 通信处理实例
*功能描述：从列表中查询通信处理实例
*/
public TCPHandler GetTCPHandler(int hashCode)
{
TCPHandler tcpHandler = null;
//lock
mut.WaitOne();
TCPHandlerList.ForEach(delegate(TCPHandler name)
{
if (name.tName.GetHashCode() == hashCode)
{
tcpHandler = name;
return;
}
});
//unlock
mut.ReleaseMutex();
return tcpHandler;
}
/*
*方法名称：handleRSCommand
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：ref TCPHandler tw 通信处理实例,
*byte flagCtrlF 功能码,
*object param 对象参数,
*ref struFrame resp 应答消息帧结构
*返回描述：bool true，处理成功，false 失败
*功能描述：remoting命令处理函数
*/
private bool handleRSCommand(ref TCPHandler tw, byte flagCtrlF, object param, ref struFrame resp)
{
bool res = false;
struFrame sFrame = new struFrame();
if (UPPHandler.PreframePacking(flagCtrlF, param, ref sFrame) == true)
{
byte[] frame = null;
if (UPPHandler.framePacking(ref sFrame, ref frame) == true)
{
struRequestInQueue sReqInQ = new struRequestInQueue();
sReqInQ.frameInfo = sFrame;
sReqInQ.bMatchOK = false;
sReqInQ.frameBytes = frame;
sReqInQ.frameResp = new struFrame();
sReqInQ.handleReqEvent = new AutoResetEvent(false);
sReqInQ.handleReqEvent.Reset();
tw.PutNewReq(ref sReqInQ);
if (sReqInQ.handleReqEvent.WaitOne(16000, false) == true)
{
Common.logFile.write("消息匹配 OK", LogFile.LOGLVL_DEBUG);
res = true;
//Common.logFile.write("sReqInQ.frameResp：" + sReqInQ.frameResp.GetHashCode().ToString(), LogFile.LOGLVL_DEBUG);
UPPHandler.frameCopy(ref sReqInQ.frameResp, ref resp);
//Common.logFile.write("读时间 成功！！！");
}
sReqInQ.handleReqEvent.Close();
}
}
return res;
}
/*
*方法名称：TimeOut
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：void
*返回描述：void
*功能描述：定时处理函数
*/
public void TimeOut()
{
CheckOnline();
CheckPointTime();
CheckHeartBeatTimeout();
}
/*
*方法名称：CheckHeartBeatTimeout
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：void
*返回描述：void
*功能描述：检查集中器心跳超时，是则踢出
*/
private void CheckHeartBeatTimeout()
{
try
{
TCPHandler tw = null;
bool loop = true;
unTimeingCount++;
bool bTiming = false;
//0 不校时
if (Common.configReader.nIntervalHoursForTiming > 0
&& unTimeingCount >= 3600 * Common.configReader.nIntervalHoursForTiming)
{
bTiming = true;
unTimeingCount = 0;
}
while (loop)
{
loop = false;
tw = null;
//lock
mut.WaitOne();
for (int i = 0; i < TCPHandlerList.Count; i++)
{
tw = TCPHandlerList.ElementAt(i);
if (tw == null)
{
loop = true;
TCPHandlerList.RemoveAt(i);
break;
}
if (tw.CheckTimeOut() == false)
{
//TCPWorkerList.Remove(tw);
TCPHandlerList.RemoveAt(i);
loop = true;
break;
}
if (bTiming == true)
{
//ReqHandler reqHandler = new ReqHandler();
//reqHandler.SetTime(tw.tName);
tw.ExecuteTiming();
}
}
//unlock
mut.ReleaseMutex();
if (tw != null && loop == true)
{
Common.logFile.write("[" + tw.tName + "]" + " 无心跳等待超时，链接被踢出 Kickoff", LogFile.LOGLVL_NORMAL);
if (tw.tName.CompareTo("未知终端") != 0)
{
//tw.SaveKickoffInfo(DateTime.Now);
tw.bKickOff = true;
}
tw.Close();
if (tw.tWorker.IsAlive)
{
if (tw.tWorker.Join(5000) == false)
tw.tWorker.Abort();
}
tw = null;
}
}
}
catch
{
}
}
/*
*方法名称：CheckPointTime
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：void
*返回描述：void
*功能描述：检查整点采集时间段，更新采集时间段
*/
private void CheckPointTime()
{
DateTime dtNow = DateTime.Now;
if ((dtNow >= dtPointBegin) && (dtNow <= dtPointEnd))
{
if (this.bPointCollect == false)
{
bPointCollect = true;
Common.logFile.write("Collect time now ON>>>>>>>>>>>>>>>>>>>>>>>>>>>>" + dtPoint + "|" + dtPointBegin + "-" + dtPointEnd, LogFile.LOGLVL_DEBUG);
}
}
else
{
if (this.bPointCollect == true)
{
bPointCollect = false;
UpdateNewTimePoint();
Common.logFile.write("Collect time now Off<<<<<<<<<<<<<<<<<<<<<<<<<<<<" + dtPoint + "|" + dtPointBegin + "-" + dtPointEnd, LogFile.LOGLVL_DEBUG);
}
}
}
/*
*方法名称：RS_AdjustTime
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：int nHashCode 通信处理实例的哈希编码
*返回描述：bool true 校时成功，false 失败
*功能描述：对集中器校时，生成校时消息帧，判断应答是否成功
*/
private bool RS_AdjustTime(int nHashCode)
{
//查找链接信息（终端编号，帧序号）
TCPHandler tw = null;
bool res = false;
if (nHashCode != 0)
{
tw = (TCPHandler)Common.platForm.tcpServer.GetTCPHandler(nHashCode);
}
if (tw != null)
{
if (tw.tName.Length == 5)
{
struWriteData wrData = new struWriteData();
wrData.addrDNL = new byte[2];
////终端类型
wrData.flagDTN = (byte)tw.tName[0];
//if (wrData.flagDTN != 'E')
//{
// MessageBox.Show("终端类型错误，非电力终端！");
// return;
//}
//逻辑编号
int n = Convert.ToInt32(tw.tName.Substring(1, 4), 16);
wrData.addrDNL[0] = (byte)(n / 256);
wrData.addrDNL[1] = (byte)(n % 256);
////主站地址
//public byte flagMSTA;
wrData.flagMSTA = 0x0;//???????????????????????????????????
//功能标志（写对象）
wrData.flagCtrlF = 0x08;
//测量点标志 (终端)
wrData.flagPoint = 0x00;
//帧序号
wrData.flagFSEQ = tw.GetSeqFrame();
//低级权限
wrData.flagAUT = 0x00;
//口令
wrData.passwd = new byte[3];
wrData.passwd[0] = 0x31;
wrData.passwd[1] = 0x32;
wrData.passwd[2] = 0x33;
//数据编号与数据
wrData.numPairs = new byte[8];
wrData.numPairs[0] = 0x80;
wrData.numPairs[1] = 0x30;
wrData.numPairs[2] = (byte)0; //秒
wrData.numPairs[3] = (byte)0; //分
wrData.numPairs[4] = (byte)0; //时
wrData.numPairs[5] = (byte)0; //日
wrData.numPairs[6] = (byte)0; //月
wrData.numPairs[7] = (byte)0; //年
wrData.isTimeCorrecting = true;
struFrame sFrame = new struFrame();
//放入链接队列
res = handleRSCommand(ref tw, wrData.flagCtrlF, wrData, ref sFrame);
//Common.logFile.write("handleRSCommand ====================");
}
else
{
//未认证的链接
//MessageBox.Show("未知终端，无权接收请求！");
}
}
return res;
}
/*
*方法名称：RS_GetData
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：int nHashCode 通信处理实例的哈希编码,
*object oParam 招唤设置参数,
*ref object oResp 招唤返回数据
*返回描述：bool true 成功，false 失败
*功能描述：对集中器进行数据招唤，生成招唤消息帧，判断应答是否成功
*/
private bool RS_GetData(int nHashCode, object oParam, ref object oResp)
{
//查找链接信息（终端编号，帧序号）
TCPHandler tw = null;
bool res = false;
if (nHashCode != 0)
{
tw = (TCPHandler)Common.platForm.tcpServer.GetTCPHandler(nHashCode);
}
if (tw != null)
{
struParam param = (struParam)oParam;
if (tw.tName.Length == 5)
{
struReadData rdData = new struReadData();
rdData.addrDNL = new byte[2];
////终端类型
rdData.flagDTN = (byte)tw.tName[0];
//if (rdData.flagDTN != 'E')
//{
// //MessageBox.Show("终端类型错误，非电力终端！");
// return false;
//}
////逻辑编号
int n = Convert.ToInt32(tw.tName.Substring(1, 4), 16);
rdData.addrDNL[0] = (byte)(n / 256);
rdData.addrDNL[1] = (byte)(n % 256);
////主站地址
//public byte flagMSTA;
rdData.flagMSTA = 0x0;//???????????????????????????????????
//功能标志
rdData.flagCtrlF = 0x01;
//测量点标志
rdData.flagPoint = Convert.ToByte(param.sMID, 16);
//帧序号
rdData.flagFSEQ = tw.GetSeqFrame();
//数据项编号
int size = 2 * param.lstParams.Count;
rdData.numPairs = new byte[size];
int i = 0;
foreach (int id in param.lstParams)
{
rdData.numPairs[i] = (byte)(id / 0x100);//终端时间
rdData.numPairs[i + 1] = (byte)(id % 0x100);//
i += 2;
}
struFrame sRespFrame = new struFrame();
//放入链接队列
res = handleRSCommand(ref tw, rdData.flagCtrlF, rdData, ref sRespFrame);
if (res == true)
{
struFrame sFrame = (struFrame)sRespFrame;
Hashtable htData = new Hashtable();
MessageHandler mh = new MessageHandler(null);//????????????????????????
sFrame.tName = tw.tName;
res = mh.DataParsing(ref sFrame, ref htData);
oResp = htData;
}
}
else
{
//未认证的链接
//MessageBox.Show("未知终端，无权接收请求！");
}
}
return res;
}
/*
*方法名称：RS_GetHeartBeatInterval
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：int nHashCode 通信处理实例的哈希编码,
*ref object oResp 读对象返回数据
*返回描述：bool true 成功，false 失败
*功能描述：对集中器进行读心跳间隔，生成读消息帧，判断应答是否成功
*/
private bool RS_GetHeartBeatInterval(int nHashCode, ref object oResp)
{
//查找链接信息（终端编号，帧序号）
TCPHandler tw = null;
bool res = false;
if (nHashCode != 0)
{
tw = (TCPHandler)Common.platForm.tcpServer.GetTCPHandler(nHashCode);
}
if (tw != null)
{
if (tw.tName.Length == 5)
{
struReadData rdData = new struReadData();
rdData.addrDNL = new byte[2];
////终端类型
rdData.flagDTN = (byte)tw.tName[0];
//if (rdData.flagDTN != 'E')
//{
// //MessageBox.Show("终端类型错误，非电力终端！");
// return false;
//}
////逻辑编号
int n = Convert.ToInt32(tw.tName.Substring(1, 4), 16);
rdData.addrDNL[0] = (byte)(n / 256);
rdData.addrDNL[1] = (byte)(n % 256);
////主站地址
//public byte flagMSTA;
rdData.flagMSTA = 0x0;//???????????????????????????????????
//功能标志
rdData.flagCtrlF = 0x01;
//测量点标志
rdData.flagPoint = 0x00;
//帧序号
rdData.flagFSEQ = tw.GetSeqFrame();
//数据项编号
rdData.numPairs = new byte[2];
rdData.numPairs[0] = 0xDB;//
rdData.numPairs[1] = 0x41;//
struFrame sRespFrame = new struFrame();
//放入链接队列
res = handleRSCommand(ref tw, rdData.flagCtrlF, rdData, ref sRespFrame);
if (res == true)
{
struFrame sFrame = (struFrame)sRespFrame;
int pointer = 1;
uint ID = (uint)(sFrame.strData[pointer] * 0x100 + sFrame.strData[pointer + 1]);
if (ID == 0xDB41)
{
string sInterval = sFrame.strData[pointer + 2].ToString("D2");
oResp = (object)sInterval;
Common.logFile.write("获取终端[" + tw.tName + "]心跳间隔：" + sInterval, LogFile.LOGLVL_NORMAL);
}
}
}
else
{
//未认证的链接
//MessageBox.Show("未知终端，无权接收请求！");
}
}
return res;
}
/*
*方法名称：RS_GetAutoSendInterval
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：int nHashCode 通信处理实例的哈希编码,
*ref object oResp 读对象返回数据
*返回描述：bool true 成功，false 失败
*功能描述：对集中器进行读主动上传间隔，生成读消息帧，判断应答是否成功
*/
private bool RS_GetAutoSendInterval(int nHashCode, ref object oResp)
{
//查找链接信息（终端编号，帧序号）
TCPHandler tw = null;
bool res = false;
if (nHashCode != 0)
{
tw = (TCPHandler)Common.platForm.tcpServer.GetTCPHandler(nHashCode);
}
if (tw != null)
{
if (tw.tName.Length == 5)
{
struReadData rdData = new struReadData();
rdData.addrDNL = new byte[2];
////终端类型
rdData.flagDTN = (byte)tw.tName[0];
//if (rdData.flagDTN != 'E')
//{
// //MessageBox.Show("终端类型错误，非电力终端！");
// return false;
//}
////逻辑编号
int n = Convert.ToInt32(tw.tName.Substring(1, 4), 16);
rdData.addrDNL[0] = (byte)(n / 256);
rdData.addrDNL[1] = (byte)(n % 256);
////主站地址
//public byte flagMSTA;
rdData.flagMSTA = 0x0;//???????????????????????????????????
//功能标志
rdData.flagCtrlF = 0x01;
//测量点标志
rdData.flagPoint = 0x00;
//帧序号
rdData.flagFSEQ = tw.GetSeqFrame();
//数据项编号
rdData.numPairs = new byte[2];
rdData.numPairs[0] = 0xDB;//
rdData.numPairs[1] = 0x42;//
struFrame sRespFrame = new struFrame();
//放入链接队列
res = handleRSCommand(ref tw, rdData.flagCtrlF, rdData, ref sRespFrame);
if (res == true)
{
struFrame sFrame = (struFrame)sRespFrame;
int pointer = 1;
uint ID = (uint)(sFrame.strData[pointer] * 0x100 + sFrame.strData[pointer + 1]);
if (ID == 0xDB42)
{
string sInterval = sFrame.strData[pointer + 2].ToString("D2");
oResp = (object)sInterval;
Common.logFile.write("获取终端[" + tw.tName + "]主动上传间隔：" + sInterval, LogFile.LOGLVL_NORMAL);
}
}
}
else
{
//未认证的链接
//MessageBox.Show("未知终端，无权接收请求！");
}
}
return res;
}
/*
*方法名称：RS_GetTime
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：int nHashCode 通信处理实例的哈希编码,
*ref object oResp 读对象返回数据
*返回描述：bool true 成功，false 失败
*功能描述：对集中器进行读当前时间，生成读消息帧，判断应答是否成功
*/
private bool RS_GetTime(int nHashCode, ref object oResp)
{
//查找链接信息（终端编号，帧序号）
TCPHandler tw = null;
bool res = false;
if (nHashCode != 0)
{
tw = (TCPHandler)Common.platForm.tcpServer.GetTCPHandler(nHashCode);
}
if (tw != null)
{
if (tw.tName.Length == 5)
{
struReadData rdData = new struReadData();
rdData.addrDNL = new byte[2];
////终端类型
rdData.flagDTN = (byte)tw.tName[0];
//if (rdData.flagDTN != 'E')
//{
// //MessageBox.Show("终端类型错误，非电力终端！");
// return false;
//}
////逻辑编号
int n = Convert.ToInt32(tw.tName.Substring(1, 4), 16);
rdData.addrDNL[0] = (byte)(n / 256);
rdData.addrDNL[1] = (byte)(n % 256);
////主站地址
//public byte flagMSTA;
rdData.flagMSTA = 0x0;//???????????????????????????????????
//功能标志
rdData.flagCtrlF = 0x01;
//测量点标志
rdData.flagPoint = 0x00;
//帧序号
rdData.flagFSEQ = tw.GetSeqFrame();
//数据项编号
rdData.numPairs = new byte[2];
rdData.numPairs[0] = 0x80;//终端时间
rdData.numPairs[1] = 0x30;//
struFrame sRespFrame = new struFrame();
//放入链接队列
res = handleRSCommand(ref tw, rdData.flagCtrlF, rdData, ref sRespFrame);
if (res == true)
{
struFrame sFrame = (struFrame)sRespFrame;
int pointer = 1;
uint ID = (uint)(sFrame.strData[pointer] * 0x100 + sFrame.strData[pointer + 1]);
if (ID == 0x8030)
{
string strDateTime = "20" + sFrame.strData[pointer + 7].ToString("x2")
+ "-" + sFrame.strData[pointer + 6].ToString("x2")
+ "-" + sFrame.strData[pointer + 5].ToString("x2")
+ " " + sFrame.strData[pointer + 4].ToString("x2")
+ ":" + sFrame.strData[pointer + 3].ToString("x2")
+ ":" + sFrame.strData[pointer + 2].ToString("x2");
oResp = (object)strDateTime;
Common.logFile.write("获取终端[" + tw.tName + "]时间：" + strDateTime, LogFile.LOGLVL_NORMAL);
}
}
}
else
{
//未认证的链接
//MessageBox.Show("未知终端，无权接收请求！");
}
}
return res;
}
/*
*方法名称：HandleRemoteService
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：int nFID remoting处理内部编码,
*string sTName 集中器ID,
*object oParam 参数对象,
*ref object oResp 应答对象
*返回描述：bool true 成功，false 失败
*功能描述：remoting 处理接口函数
*/
public bool HandleRemoteService(int nFID, string sTName, object oParam, ref object oResp)
{
bool res = false;
int nHashCode = sTName.GetHashCode();
switch (nFID)
{
//对时
case 0:
res = RS_AdjustTime(nHashCode);
break;
//读时间
case 1:
res = RS_GetTime(nHashCode, ref oResp);
break;
//写IP和端口
case 2:
res = RS_SetIPPort(nHashCode, oParam);
break;
//招唤数据
case 3:
res = RS_GetData(nHashCode, oParam, ref oResp);
break;
//写主动上传间隔
case 4:
res = RS_SetAutoSendInterval(nHashCode, oParam);
break;
//写心跳间隔
case 5:
res = RS_SetHeartBeatInterval(nHashCode, oParam);
break;
//读主动上传间隔
case 6:
res = RS_GetAutoSendInterval(nHashCode, ref oResp);
break;
//读心跳间隔
case 7:
res = RS_GetHeartBeatInterval(nHashCode, ref oResp);
break;
//写集中器ID
case 8:
res = RS_SetTerminalName(nHashCode, oParam);
break;
//写集中器仪表地址
case 9:
res = RS_SetMeterAddr(nHashCode, oParam);
break;
//读集中器仪表地址
case 10:
res = RS_GetMeterAddr(nHashCode, ref oResp);
break;
//写集中器仪表置位
case 11:
res = RS_SetMeterAble(nHashCode, oParam);
break;
//读集中器仪表置位
case 12:
res = RS_GetMeterAble(nHashCode, ref oResp);
break;
//写蒸汽告警参数
case 13:
res = RS_SetStreamThreshold(nHashCode, oParam);
break;
//读蒸汽告警参数
case 14:
res = RS_GetStreamThreshold(nHashCode, oParam, ref oResp);
break;
//写电力告警参数
case 15:
res = RS_SetElectricThreshold(nHashCode, oParam);
break;
//读电力告警参数
case 16:
res = RS_GetElectricThreshold(nHashCode, oParam, ref oResp);
break;
//读集中器信息
case 17:
res = RS_GetInfo(nHashCode, oParam, ref oResp);
break;
//写集中器目标IP和Port
case 18:
res = RS_SetServerIPPort(nHashCode, oParam);
break;
//写电力PT CT
case 19:
res = RS_SetElecPTCT(nHashCode, oParam);
break;
//读电力PT CT
case 20:
res = RS_GetElecPTCT(nHashCode, oParam, ref oResp);
break;
case 21:
res = RS_SetSteamFailInterval(nHashCode, oParam);
break;
default:
break;
}
return res;
}
/// <summary>
/// 设置蒸汽集中器采集数据失败时间间隔
/// </summary>
/// <param name="nHashCode">通信处理实例哈希编码</param>
/// <param name="oParam">参数对象</param>
/// <returns>bools设置成功 true</returns>
private bool RS_SetSteamFailInterval(int nHashCode, object oParam)
{
//查找链接信息（终端编号，帧序号）
TCPHandler tw = null;
bool res = false;
if (nHashCode != 0)
{
tw = (TCPHandler)Common.platForm.tcpServer.GetTCPHandler(nHashCode);
}
if (tw != null)
{
if (tw.tName.Length == 5)
{
struWriteData wrData = new struWriteData();
wrData.addrDNL = new byte[2];
////终端类型
wrData.flagDTN = (byte)tw.tName[0];
//if (wrData.flagDTN != 'E')
//{
// MessageBox.Show("终端类型错误，非电力终端！");
// return;
//}
//逻辑编号
int n = Convert.ToInt32(tw.tName.Substring(1, 4), 16);
wrData.addrDNL[0] = (byte)(n / 256);
wrData.addrDNL[1] = (byte)(n % 256);
////主站地址
//public byte flagMSTA;
wrData.flagMSTA = 0x0;//???????????????????????????????????
//功能标志（写对象）
wrData.flagCtrlF = 0x08;
//测量点标志 (终端)
wrData.flagPoint = 0x00;
//帧序号
wrData.flagFSEQ = tw.GetSeqFrame();
//低级权限
wrData.flagAUT = 0x00;
//口令
wrData.passwd = new byte[3];
wrData.passwd[0] = 0x31;
wrData.passwd[1] = 0x32;
wrData.passwd[2] = 0x33;
Hashtable ht = (Hashtable)oParam;
byte byParams = (byte)ht["DB44"];
//数据编号与数据
wrData.numPairs = new byte[3];
wrData.numPairs[0] = 0xDB;
wrData.numPairs[1] = 0x44;
wrData.numPairs[2] = byParams; //分钟
struFrame sFrame = new struFrame();
//放入链接队列
res = handleRSCommand(ref tw, wrData.flagCtrlF, wrData, ref sFrame);
//Common.logFile.write("handleRSCommand ====================");
}
else
{
//未认证的链接
//MessageBox.Show("未知终端，无权接收请求！");
}
}
return res;
}
/*
*方法名称：RS_SetHeartBeatInterval
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：int nHashCode 通信处理实例哈希编码,
*object oParam 参数对象
*返回描述：bool true 成功，false 失败
*功能描述：设置心跳超时间隔
*/
public bool RS_SetHeartBeatInterval(int nHashCode, object oParam)
{
//查找链接信息（终端编号，帧序号）
TCPHandler tw = null;
bool res = false;
if (nHashCode != 0)
{
tw = (TCPHandler)Common.platForm.tcpServer.GetTCPHandler(nHashCode);
}
if (tw != null)
{
if (tw.tName.Length == 5)
{
struWriteData wrData = new struWriteData();
wrData.addrDNL = new byte[2];
////终端类型
wrData.flagDTN = (byte)tw.tName[0];
//if (wrData.flagDTN != 'E')
//{
// MessageBox.Show("终端类型错误，非电力终端！");
// return;
//}
//逻辑编号
int n = Convert.ToInt32(tw.tName.Substring(1, 4), 16);
wrData.addrDNL[0] = (byte)(n / 256);
wrData.addrDNL[1] = (byte)(n % 256);
////主站地址
//public byte flagMSTA;
wrData.flagMSTA = 0x0;//???????????????????????????????????
//功能标志（写对象）
wrData.flagCtrlF = 0x08;
//测量点标志 (终端)
wrData.flagPoint = 0x00;
//帧序号
wrData.flagFSEQ = tw.GetSeqFrame();
//低级权限
wrData.flagAUT = 0x00;
//口令
wrData.passwd = new byte[3];
wrData.passwd[0] = 0x31;
wrData.passwd[1] = 0x32;
wrData.passwd[2] = 0x33;
Hashtable ht = (Hashtable)oParam;
byte byParams = (byte)ht["DB41"];
//数据编号与数据
wrData.numPairs = new byte[3];
wrData.numPairs[0] = 0xDB;
wrData.numPairs[1] = 0x41;
wrData.numPairs[2] = byParams; //分钟
struFrame sFrame = new struFrame();
//放入链接队列
res = handleRSCommand(ref tw, wrData.flagCtrlF, wrData, ref sFrame);
//Common.logFile.write("handleRSCommand ====================");
}
else
{
//未认证的链接
//MessageBox.Show("未知终端，无权接收请求！");
}
}
return res;
}
/*
*方法名称：RS_SetAutoSendInterval
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：int nHashCode 通信处理实例哈希编码,
*object oParam 参数对象
*返回描述：bool true 成功，false 失败
*功能描述：设置自动上传间隔时间
*/
public bool RS_SetAutoSendInterval(int nHashCode, object oParam)
{
//查找链接信息（终端编号，帧序号）
TCPHandler tw = null;
bool res = false;
if (nHashCode != 0)
{
tw = (TCPHandler)Common.platForm.tcpServer.GetTCPHandler(nHashCode);
}
if (tw != null)
{
if (tw.tName.Length == 5)
{
struWriteData wrData = new struWriteData();
wrData.addrDNL = new byte[2];
////终端类型
wrData.flagDTN = (byte)tw.tName[0];
//if (wrData.flagDTN != 'E')
//{
// MessageBox.Show("终端类型错误，非电力终端！");
// return;
//}
//逻辑编号
int n = Convert.ToInt32(tw.tName.Substring(1, 4), 16);
wrData.addrDNL[0] = (byte)(n / 256);
wrData.addrDNL[1] = (byte)(n % 256);
////主站地址
//public byte flagMSTA;
wrData.flagMSTA = 0x0;//???????????????????????????????????
//功能标志（写对象）
wrData.flagCtrlF = 0x08;
//测量点标志 (终端)
wrData.flagPoint = 0x00;
//帧序号
wrData.flagFSEQ = tw.GetSeqFrame();
//低级权限
wrData.flagAUT = 0x00;
//口令
wrData.passwd = new byte[3];
wrData.passwd[0] = 0x31;
wrData.passwd[1] = 0x32;
wrData.passwd[2] = 0x33;
Hashtable ht = (Hashtable)oParam;
byte byParams = (byte)ht["DB42"];
//数据编号与数据
wrData.numPairs = new byte[3];
wrData.numPairs[0] = 0xDB;
wrData.numPairs[1] = 0x42;
wrData.numPairs[2] = byParams; //分钟
struFrame sFrame = new struFrame();
//放入链接队列
res = handleRSCommand(ref tw, wrData.flagCtrlF, wrData, ref sFrame);
//Common.logFile.write("handleRSCommand ====================");
}
else
{
//未认证的链接
//MessageBox.Show("未知终端，无权接收请求！");
}
}
return res;
}
/*
*方法名称：RS_SetTerminalName
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：int nHashCode 通信处理实例哈希编码,
*object oParam 参数对象
*返回描述：bool true 成功，false 失败
*功能描述：设置集中器ID
*/
public bool RS_SetTerminalName(int nHashCode, object oParam)
{
string sNewName = (string)oParam;
if (sNewName.Length != 5)
{
return false;
}
//查找链接信息（终端编号，帧序号）
TCPHandler tw = null;
bool res = false;
if (nHashCode != 0)
{
tw = (TCPHandler)Common.platForm.tcpServer.GetTCPHandler(nHashCode);
}
if (tw != null)
{
if (tw.tName.Length == 5)
{
struWriteData wrData = new struWriteData();
wrData.addrDNL = new byte[2];
////终端类型
wrData.flagDTN = (byte)tw.tName[0];
//if (wrData.flagDTN != 'E')
//{
// MessageBox.Show("终端类型错误，非电力终端！");
// return;
//}
//逻辑编号
int n = Convert.ToInt32(tw.tName.Substring(1, 4), 16);
wrData.addrDNL[0] = (byte)(n / 256);
wrData.addrDNL[1] = (byte)(n % 256);
////主站地址
//public byte flagMSTA;
wrData.flagMSTA = 0x0;//???????????????????????????????????
//功能标志（写对象）
wrData.flagCtrlF = 0x08;
//测量点标志 (终端)
wrData.flagPoint = 0x00;
//帧序号
wrData.flagFSEQ = tw.GetSeqFrame();
//低级权限
wrData.flagAUT = 0x00;
//口令
wrData.passwd = new byte[3];
wrData.passwd[0] = 0x31;
wrData.passwd[1] = 0x32;
wrData.passwd[2] = 0x33;
//数据编号与数据
wrData.numPairs = new byte[5];
wrData.numPairs[0] = 0x80;
wrData.numPairs[1] = 0x17;
wrData.numPairs[2] = (byte)sNewName[0];
wrData.numPairs[3] = Convert.ToByte(sNewName.Substring(1, 2), 16);
wrData.numPairs[4] = Convert.ToByte(sNewName.Substring(3, 2), 16);
struFrame sFrame = new struFrame();
//放入链接队列
res = handleRSCommand(ref tw, wrData.flagCtrlF, wrData, ref sFrame);
//Common.logFile.write("handleRSCommand ====================");
}
else
{
//未认证的链接
//MessageBox.Show("未知终端，无权接收请求！");
}
}
return res;
}
/*
*方法名称：RS_SetIPPort
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：int nHashCode 通信处理实例哈希编码,
*object oParam 参数对象
*返回描述：bool true 成功，false 失败
*功能描述：设置集中器本地ip和端口
*/
public bool RS_SetIPPort(int nHashCode, object oParam)
{
//查找链接信息（终端编号，帧序号）
TCPHandler tw = null;
bool res = false;
if (nHashCode != 0)
{
tw = (TCPHandler)Common.platForm.tcpServer.GetTCPHandler(nHashCode);
}
if (tw != null)
{
if (tw.tName.Length == 5)
{
struWriteData wrData = new struWriteData();
wrData.addrDNL = new byte[2];
////终端类型
wrData.flagDTN = (byte)tw.tName[0];
//if (wrData.flagDTN != 'E')
//{
// MessageBox.Show("终端类型错误，非电力终端！");
// return;
//}
//逻辑编号
int n = Convert.ToInt32(tw.tName.Substring(1, 4), 16);
wrData.addrDNL[0] = (byte)(n / 256);
wrData.addrDNL[1] = (byte)(n % 256);
////主站地址
//public byte flagMSTA;
wrData.flagMSTA = 0x0;//???????????????????????????????????
//功能标志（写对象）
wrData.flagCtrlF = 0x08;
//测量点标志 (终端)
wrData.flagPoint = 0x00;
//帧序号
wrData.flagFSEQ = tw.GetSeqFrame();
//低级权限
wrData.flagAUT = 0x00;
//口令
wrData.passwd = new byte[3];
wrData.passwd[0] = 0x31;
wrData.passwd[1] = 0x32;
wrData.passwd[2] = 0x33;
//数据编号与数据
wrData.numPairs = new byte[11];//DPT计算电压时用//DCT计算电流时用//DPQ计算功率时用
wrData.numPairs[0] = 0x80;
wrData.numPairs[1] = 0x10;
Hashtable ht = (Hashtable)oParam;
byte[] byParams = (byte[])ht["8010"];
wrData.numPairs[2] = 0x04;
wrData.numPairs[3] = 0xAA;
wrData.numPairs[4] = 0xAA;
wrData.numPairs[5] = byParams[0];//192
wrData.numPairs[6] = byParams[1];//168
wrData.numPairs[7] = byParams[2]; //0
wrData.numPairs[8] = byParams[3];//58
wrData.numPairs[9] = byParams[4]; //40
wrData.numPairs[10] = byParams[5]; //01
struFrame sFrame = new struFrame();
//放入链接队列
res = handleRSCommand(ref tw, wrData.flagCtrlF, wrData, ref sFrame);
}
else
{
//未认证的链接
//MessageBox.Show("未知终端，无权接收请求！");
}
}
return res;
}
/*
*方法名称：RS_SetServerIPPort
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：int nHashCode 通信处理实例哈希编码,
*object oParam 参数对象
*返回描述：bool true 成功，false 失败
*功能描述：设置集中器目标ip和端口
*/
public bool RS_SetServerIPPort(int nHashCode, object oParam)
{
//查找链接信息（终端编号，帧序号）
TCPHandler tw = null;
bool res = false;
if (nHashCode != 0)
{
tw = (TCPHandler)Common.platForm.tcpServer.GetTCPHandler(nHashCode);
}
if (tw != null)
{
if (tw.tName.Length == 5)
{
struWriteData wrData = new struWriteData();
wrData.addrDNL = new byte[2];
////终端类型
wrData.flagDTN = (byte)tw.tName[0];
//if (wrData.flagDTN != 'E')
//{
// MessageBox.Show("终端类型错误，非电力终端！");
// return;
//}
//逻辑编号
int n = Convert.ToInt32(tw.tName.Substring(1, 4), 16);
wrData.addrDNL[0] = (byte)(n / 256);
wrData.addrDNL[1] = (byte)(n % 256);
////主站地址
//public byte flagMSTA;
wrData.flagMSTA = 0x0;//???????????????????????????????????
//功能标志（写对象）
wrData.flagCtrlF = 0x08;
//测量点标志 (终端)
wrData.flagPoint = 0x00;
//帧序号
wrData.flagFSEQ = tw.GetSeqFrame();
//低级权限
wrData.flagAUT = 0x00;
//口令
wrData.passwd = new byte[3];
wrData.passwd[0] = 0x31;
wrData.passwd[1] = 0x32;
wrData.passwd[2] = 0x33;
//数据编号与数据
wrData.numPairs = new byte[8];
wrData.numPairs[0] = 0x80;
wrData.numPairs[1] = 0x1A;
Hashtable ht = (Hashtable)oParam;
byte[] byParams = (byte[])ht["801A"];
wrData.numPairs[2] = byParams[0];//192
wrData.numPairs[3] = byParams[1];//168
wrData.numPairs[4] = byParams[2]; //0
wrData.numPairs[5] = byParams[3];//58
wrData.numPairs[6] = byParams[4]; //40
wrData.numPairs[7] = byParams[5]; //01
struFrame sFrame = new struFrame();
//放入链接队列
res = handleRSCommand(ref tw, wrData.flagCtrlF, wrData, ref sFrame);
//Common.logFile.write("handleRSCommand ====================");
}
else
{
//未认证的链接
//MessageBox.Show("未知终端，无权接收请求！");
}
}
return res;
}
/*
*方法名称：GetTerminalList
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：Hashtable htTerminal 集中器哈希表,
*返回描述：bool true 成功，false 失败
*功能描述：获得集中器列表
*/
public bool GetTerminalList(Hashtable htTerminal)
{
htTerminal.Clear();
List<string> lstTerminal = new List<string>();
Hashtable htTerminalForTest = new Hashtable();
Hashtable htTerminalAll = new Hashtable();
//lstTerminal.Clear();
bool res = true;
//lock
mut.WaitOne();
if (TCPHandlerList.Count > 0)
{
foreach (TCPHandler tcpHandler in TCPHandlerList)
{
if (tcpHandler.tName.CompareTo("未知终端") != 0)
{
lstTerminal.Add(tcpHandler.tName);
htTerminalForTest.Add(tcpHandler.tName, false);
htTerminalAll.Add(tcpHandler.tName, false);
}
}
}
else
{
//res = false;
lstTerminal.Add("null");
}
//unlock
mut.ReleaseMutex();
//Common.logFile.write("2.进入数据库查询", LogFile.LOGLVL_NORMAL);
if (res == true)
{
//string sTIDS = "('"+lstTerminal[0]+"'";
//for (int i = 1; i < lstTerminal.Count; i++)
//{
// sTIDS += ",'"+lstTerminal[i]+"'";
//}
//sTIDS += ")";
string queryString = string.Format("SELECT t2.[SettingAddress],t2.[collectdeviceid],[MonitorName] "
+ ",[MeterCommunicationID] "
+ "FROM [dbo].[T_Monitor] as t1 "
+ "Inner Join [dbo].[T_CollectDeviceInfo] as t2 "
+ "on t1.[collectdeviceid] = t2.[collectdeviceid] where t1.[MonitorType]={0} or t1.[MonitorType]={1} order by collectdeviceid", 2,3);//('E0001', 'S0001')
//Common.logFile.write("2.1进入数据库查询,queryString:" + queryString, LogFile.LOGLVL_NORMAL);
using (SqlConnection connection = new SqlConnection(connectString))
{
SqlCommand command = new SqlCommand(queryString, connection);
try
{
connection.Open();
try
{
SqlDataReader reader = command.ExecuteReader();
while (reader.Read())
{
if (!reader[1].ToString().ToUpper().StartsWith("XN"))//过滤 XN 虚拟节点
{
if (htTerminalAll.ContainsKey(reader[1].ToString()))
{
//online
htTerminal.Add(reader[3].ToString() + "\n" + reader[2].ToString(), reader[1].ToString() + "\n" + reader[0].ToString() + "\n" + "1");
}
else
{
//offline
htTerminal.Add(reader[3].ToString() + "\n" + reader[2].ToString(), reader[1].ToString() + "\n" + reader[0].ToString() + "\n" + "0");
}
htTerminalForTest.Remove(reader[1].ToString());
}
}
// Call Close when done reading.
reader.Close();
}
catch (SqlException e)
{
//info2Display += "\r\n蒸汽数据采集 SqlException：" + e.ToString() + "\r\n 原SQL语句:" + insertSQLString;
Common.logFile.write("原SQL语句:" + queryString + ",SQL语句错误：" + e.ToString(), LogFile.LOGLVL_ERROR);
res = false;
}
}
catch (Exception e)
{
Common.logFile.write("数据库打开错误：" + e.ToString(), LogFile.LOGLVL_ERROR);
Common.logFile.write("数据库打开错误：详见err.txt", LogFile.LOGLVL_NORMAL);
res = false;
}
}
//Common.logFile.write("2.2添加集中器测试", LogFile.LOGLVL_NORMAL);
//集中器测试
//
try
{
if (htTerminalForTest.Count > 0)
{
foreach (DictionaryEntry de in htTerminalForTest)
{
for (int i = 1; i <= 4; i++)
{
htTerminal.Add(i.ToString() + "\n" + de.Key.ToString(), de.Key.ToString() + "\n" + "测试" + "\n" + "1");
}
}
}
}
catch (Exception e1)
{
Common.logFile.write("添加集中器测试,Exception:" + e1.ToString(), LogFile.LOGLVL_ERROR);
res = false;
}
}
//Common.logFile.write("3.GetTerminalList结束："+res.ToString(), LogFile.LOGLVL_NORMAL);
return res;
}
/*
*方法名称：RS_GetMeterAble
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：Hashtable htTerminal 集中器哈希表,
*ref object oResp 应答数据对象
*返回描述：bool true 成功，false 失败
*功能描述：获得集中器仪表置位
*/
private bool RS_GetMeterAble(int nHashCode, ref object oResp)
{
//查找链接信息（终端编号，帧序号）
TCPHandler tw = null;
bool res = false;
if (nHashCode != 0)
{
tw = (TCPHandler)Common.platForm.tcpServer.GetTCPHandler(nHashCode);
}
if (tw != null)
{
if (tw.tName.Length == 5)
{
struReadData rdData = new struReadData();
rdData.addrDNL = new byte[2];
////终端类型
rdData.flagDTN = (byte)tw.tName[0];
//if (rdData.flagDTN != 'E')
//{
// //MessageBox.Show("终端类型错误，非电力终端！");
// return false;
//}
////逻辑编号
int n = Convert.ToInt32(tw.tName.Substring(1, 4), 16);
rdData.addrDNL[0] = (byte)(n / 256);
rdData.addrDNL[1] = (byte)(n % 256);
////主站地址
//public byte flagMSTA;
rdData.flagMSTA = 0x0;//???????????????????????????????????
//功能标志
rdData.flagCtrlF = 0x01;
//测量点标志
rdData.flagPoint = 0x00;
//帧序号
rdData.flagFSEQ = tw.GetSeqFrame();
//数据项编号
rdData.numPairs = new byte[2];
rdData.numPairs[0] = 0x89;//
rdData.numPairs[1] = 0x00;//
struFrame sRespFrame = new struFrame();
//放入链接队列
res = handleRSCommand(ref tw, rdData.flagCtrlF, rdData, ref sRespFrame);
if (res == true)
{
struFrame sFrame = (struFrame)sRespFrame;
int pointer = 1;
uint ID = (uint)(sFrame.strData[pointer] * 0x100 + sFrame.strData[pointer + 1]);
if (ID == 0x8900)
{
byte[] arrParam = new byte[16];
//string sInterval = sFrame.strData[pointer + 2].ToString("D2");
for (int i = 0; i < 16; i++)
{
arrParam[i] = sFrame.strData[pointer + 2 + i];
}
oResp = (object)arrParam;
Common.logFile.writeHexString("获取终端[" + tw.tName + "]仪表使能：", arrParam, LogFile.LOGLVL_NORMAL);// write("获取终端[" + tw.tName + "]主动上传间隔（分钟）：" + sInterval, LogFile.LOGLVL_NORMAL);
}
}
}
else
{
//未认证的链接
//MessageBox.Show("未知终端，无权接收请求！");
}
}
return res;
}
/*
*方法名称：RS_GetStreamThreshold
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：int nHashCode 集中器哈希编码,
*object oParam 参数对象,
*ref object oResp 应答数据对象
*返回描述：bool true 成功，false 失败
*功能描述：获得蒸汽告警参数
*/
private bool RS_GetStreamThreshold(int nHashCode, object oParam, ref object oResp)
{
//查找链接信息（终端编号，帧序号）
TCPHandler tw = null;
bool res = false;
string sMID = (string)oParam;
if (nHashCode != 0)
{
tw = (TCPHandler)Common.platForm.tcpServer.GetTCPHandler(nHashCode);
}
if (tw != null)
{
if (tw.tName.Length == 5)
{
struReadData rdData = new struReadData();
rdData.addrDNL = new byte[2];
////终端类型
rdData.flagDTN = (byte)tw.tName[0];
//if (rdData.flagDTN != 'E')
//{
// //MessageBox.Show("终端类型错误，非电力终端！");
// return false;
//}
////逻辑编号
int n = Convert.ToInt32(tw.tName.Substring(1, 4), 16);
rdData.addrDNL[0] = (byte)(n / 256);
rdData.addrDNL[1] = (byte)(n % 256);
////主站地址
//public byte flagMSTA;
rdData.flagMSTA = 0x0;//???????????????????????????????????
//功能标志
rdData.flagCtrlF = 0x01;
//测量点标志
rdData.flagPoint = Convert.ToByte(sMID, 16);//?????????????????????????
//帧序号
rdData.flagFSEQ = tw.GetSeqFrame();
//数据项编号
rdData.numPairs = new byte[32];
rdData.numPairs[0] = 0x8C;//
rdData.numPairs[1] = 0x00;//
rdData.numPairs[2] = 0x8C;//
rdData.numPairs[3] = 0x01;//
rdData.numPairs[4] = 0x8C;//
rdData.numPairs[5] = 0x02;//
rdData.numPairs[6] = 0x8C;//
rdData.numPairs[7] = 0x03;//
rdData.numPairs[8] = 0x8D;//
rdData.numPairs[9] = 0x00;//
rdData.numPairs[10] = 0x8D;//
rdData.numPairs[11] = 0x01;//
rdData.numPairs[12] = 0x8D;//
rdData.numPairs[13] = 0x02;//
rdData.numPairs[14] = 0x8D;//
rdData.numPairs[15] = 0x03;//
rdData.numPairs[16] = 0x8E;//
rdData.numPairs[17] = 0x00;//
rdData.numPairs[18] = 0x8E;//
rdData.numPairs[19] = 0x01;//
rdData.numPairs[20] = 0x8E;//
rdData.numPairs[21] = 0x02;//
rdData.numPairs[22] = 0x8E;//
rdData.numPairs[23] = 0x03;//
rdData.numPairs[24] = 0x8F;//
rdData.numPairs[25] = 0x00;//
rdData.numPairs[26] = 0x8F;//
rdData.numPairs[27] = 0x01;//
rdData.numPairs[28] = 0x8F;//
rdData.numPairs[29] = 0x02;//
rdData.numPairs[30] = 0x8F;//
rdData.numPairs[31] = 0x03;//
struFrame sRespFrame = new struFrame();
//放入链接队列
res = handleRSCommand(ref tw, rdData.flagCtrlF, rdData, ref sRespFrame);
if (res == true)
{
struFrame sFrame = (struFrame)sRespFrame;
string[] arrParam = new string[16];
MessageHandler mh = new MessageHandler(null);
res = mh.S_ThresholdParamParsing(ref sFrame, ref arrParam);
oResp = arrParam;
}
}
else
{
//未认证的链接
//MessageBox.Show("未知终端，无权接收请求！");
}
}
return res;
}
/*
*方法名称：RS_GetMeterAddr
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：int nHashCode 集中器哈希编码,
*ref object oResp 应答数据对象
*返回描述：bool true 成功，false 失败
*功能描述：获得仪表地址
*/
private bool RS_GetMeterAddr(int nHashCode, ref object oResp)
{
//查找链接信息（终端编号，帧序号）
TCPHandler tw = null;
bool res = false;
if (nHashCode != 0)
{
tw = (TCPHandler)Common.platForm.tcpServer.GetTCPHandler(nHashCode);
}
if (tw != null)
{
if (tw.tName.Length == 5)
{
struReadData rdData = new struReadData();
rdData.addrDNL = new byte[2];
////终端类型
rdData.flagDTN = (byte)tw.tName[0];
//if (rdData.flagDTN != 'E')
//{
// //MessageBox.Show("终端类型错误，非电力终端！");
// return false;
//}
////逻辑编号
int n = Convert.ToInt32(tw.tName.Substring(1, 4), 16);
rdData.addrDNL[0] = (byte)(n / 256);
rdData.addrDNL[1] = (byte)(n % 256);
////主站地址
//public byte flagMSTA;
rdData.flagMSTA = 0x0;//???????????????????????????????????
//功能标志
rdData.flagCtrlF = 0x01;
//测量点标志
rdData.flagPoint = 0x00;
//帧序号
rdData.flagFSEQ = tw.GetSeqFrame();
//数据项编号
rdData.numPairs = new byte[2];
rdData.numPairs[0] = 0x89;//
rdData.numPairs[1] = 0x01;//
struFrame sRespFrame = new struFrame();
//放入链接队列
res = handleRSCommand(ref tw, rdData.flagCtrlF, rdData, ref sRespFrame);
if (res == true)
{
struFrame sFrame = (struFrame)sRespFrame;
int pointer = 1;
uint ID = (uint)(sFrame.strData[pointer] * 0x100 + sFrame.strData[pointer + 1]);
if (ID == 0x8901)
{
byte[] arrAddr = new byte[16];
//string sInterval = sFrame.strData[pointer + 2].ToString("D2");
for (int i = 0; i < 16; i++)
{
arrAddr[i] = sFrame.strData[pointer + 2 + i];
}
oResp = (object)arrAddr;
Common.logFile.writeHexString("获取终端[" + tw.tName + "]仪表地址：", arrAddr, LogFile.LOGLVL_NORMAL);// write("获取终端[" + tw.tName + "]主动上传间隔（分钟）：" + sInterval, LogFile.LOGLVL_NORMAL);
}
}
}
else
{
//未认证的链接
//MessageBox.Show("未知终端，无权接收请求！");
}
}
return res;
}
/*
*方法名称：RS_SetMeterAble
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：int nHashCode 集中器哈希编码,
*object oParam 参数对象
*返回描述：bool true 成功，false 失败
*功能描述：设置仪表置位
*/
public bool RS_SetMeterAble(int nHashCode, object oParam)
{
byte[] arrParams = (byte[])oParam;
if (arrParams.Length != 16)
{
return false;
}
//查找链接信息（终端编号，帧序号）
TCPHandler tw = null;
bool res = false;
if (nHashCode != 0)
{
tw = (TCPHandler)Common.platForm.tcpServer.GetTCPHandler(nHashCode);
}
if (tw != null)
{
if (tw.tName.Length == 5)
{
struWriteData wrData = new struWriteData();
wrData.addrDNL = new byte[2];
////终端类型
wrData.flagDTN = (byte)tw.tName[0];
//if (wrData.flagDTN != 'E')
//{
// MessageBox.Show("终端类型错误，非电力终端！");
// return;
//}
//逻辑编号
int n = Convert.ToInt32(tw.tName.Substring(1, 4), 16);
wrData.addrDNL[0] = (byte)(n / 256);
wrData.addrDNL[1] = (byte)(n % 256);
////主站地址
//public byte flagMSTA;
wrData.flagMSTA = 0x0;//???????????????????????????????????
//功能标志（写对象）
wrData.flagCtrlF = 0x08;
//测量点标志 (终端)
wrData.flagPoint = 0x00;
//帧序号
wrData.flagFSEQ = tw.GetSeqFrame();
//低级权限
wrData.flagAUT = 0x00;
//口令
wrData.passwd = new byte[3];
wrData.passwd[0] = 0x31;
wrData.passwd[1] = 0x32;
wrData.passwd[2] = 0x33;
//数据编号与数据
wrData.numPairs = new byte[18];
wrData.numPairs[0] = 0x89;
wrData.numPairs[1] = 0x00;
arrParams.CopyTo(wrData.numPairs, 2);
struFrame sFrame = new struFrame();
//放入链接队列
res = handleRSCommand(ref tw, wrData.flagCtrlF, wrData, ref sFrame);
//Common.logFile.write("handleRSCommand ====================");
}
else
{
//未认证的链接
//MessageBox.Show("未知终端，无权接收请求！");
}
}
return res;
}
/*
*方法名称：RS_SetMeterAddr
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：int nHashCode 集中器哈希编码,
*object oParam 参数对象
*返回描述：bool true 成功，false 失败
*功能描述：设置仪表地址
*/
public bool RS_SetMeterAddr(int nHashCode, object oParam)
{
byte[] arrParams = (byte[])oParam;
if (arrParams.Length != 16)
{
return false;
}
//查找链接信息（终端编号，帧序号）
TCPHandler tw = null;
bool res = false;
if (nHashCode != 0)
{
tw = (TCPHandler)Common.platForm.tcpServer.GetTCPHandler(nHashCode);
}
if (tw != null)
{
if (tw.tName.Length == 5)
{
struWriteData wrData = new struWriteData();
wrData.addrDNL = new byte[2];
////终端类型
wrData.flagDTN = (byte)tw.tName[0];
//if (wrData.flagDTN != 'E')
//{
// MessageBox.Show("终端类型错误，非电力终端！");
// return;
//}
//逻辑编号
int n = Convert.ToInt32(tw.tName.Substring(1, 4), 16);
wrData.addrDNL[0] = (byte)(n / 256);
wrData.addrDNL[1] = (byte)(n % 256);
////主站地址
//public byte flagMSTA;
wrData.flagMSTA = 0x0;//???????????????????????????????????
//功能标志（写对象）
wrData.flagCtrlF = 0x08;
//测量点标志 (终端)
wrData.flagPoint = 0x00;
//帧序号
wrData.flagFSEQ = tw.GetSeqFrame();
//低级权限
wrData.flagAUT = 0x00;
//口令
wrData.passwd = new byte[3];
wrData.passwd[0] = 0x31;
wrData.passwd[1] = 0x32;
wrData.passwd[2] = 0x33;
//数据编号与数据
wrData.numPairs = new byte[18];
wrData.numPairs[0] = 0x89;
wrData.numPairs[1] = 0x01;
arrParams.CopyTo(wrData.numPairs, 2);
struFrame sFrame = new struFrame();
//放入链接队列
res = handleRSCommand(ref tw, wrData.flagCtrlF, wrData, ref sFrame);
//Common.logFile.write("handleRSCommand ====================");
}
else
{
//未认证的链接
//MessageBox.Show("未知终端，无权接收请求！");
}
}
return res;
}
/*
*方法名称：RS_SetStreamThreshold
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：int nHashCode 集中器哈希编码,
*object oParam 参数对象
*返回描述：bool true 成功，false 失败
*功能描述：设置蒸汽告警参数
*/
public bool RS_SetStreamThreshold(int nHashCode, object oParam)
{
struParam struP = (struParam)oParam;
string[] arrParams = (string[])struP.oParam;
if (arrParams.Length != 16)
{
return false;
}
//查找链接信息（终端编号，帧序号）
TCPHandler tw = null;
bool res = false;
if (nHashCode != 0)
{
tw = (TCPHandler)Common.platForm.tcpServer.GetTCPHandler(nHashCode);
}
if (tw != null)
{
if (tw.tName.Length == 5)
{
struWriteData wrData = new struWriteData();
wrData.addrDNL = new byte[2];
////终端类型
wrData.flagDTN = (byte)tw.tName[0];
//if (wrData.flagDTN != 'E')
//{
// MessageBox.Show("终端类型错误，非电力终端！");
// return;
//}
//逻辑编号
int n = Convert.ToInt32(tw.tName.Substring(1, 4), 16);
wrData.addrDNL[0] = (byte)(n / 256);
wrData.addrDNL[1] = (byte)(n % 256);
////主站地址
//public byte flagMSTA;
wrData.flagMSTA = 0x0;//???????????????????????????????????
//功能标志（写对象）
wrData.flagCtrlF = 0x08;
//测量点标志 (终端)
wrData.flagPoint = Convert.ToByte(struP.sMID, 16);
//帧序号
wrData.flagFSEQ = tw.GetSeqFrame();
//低级权限
wrData.flagAUT = 0x00;
//口令
wrData.passwd = new byte[3];
wrData.passwd[0] = 0x31;
wrData.passwd[1] = 0x32;
wrData.passwd[2] = 0x33;
//Hashtable ht = (Hashtable)oParam;
//数据编号与数据
//wrData.numPairs = new byte[18];
//wrData.numPairs[0] = 0x89;
//wrData.numPairs[1] = 0x01;
//arrParams.CopyTo(wrData.numPairs, 2);
MessageHandler mh = new MessageHandler(null);
Hashtable htThreshold = new Hashtable();
res = mh.S_ThresholdParamTrans(ref arrParams, ref wrData.numPairs, htThreshold);
if (res == true)
{
struFrame sFrame = new struFrame();
//放入链接队列
res = handleRSCommand(ref tw, wrData.flagCtrlF, wrData, ref sFrame);
//存库
if (res == true)
{
res = mh.saveAlarmThreshold(tw.tName, struP.sMID, htThreshold);
}
}
//Common.logFile.write("handleRSCommand ====================");
}
else
{
//未认证的链接
//MessageBox.Show("未知终端，无权接收请求！");
}
}
return res;
}
/*
*方法名称：RS_SetElectricThreshold
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：int nHashCode 集中器哈希编码,
*object oParam 参数对象
*返回描述：bool true 成功，false 失败
*功能描述：设置电力告警参数
*/
public bool RS_SetElectricThreshold(int nHashCode, object oParam)
{
struParam struP = (struParam)oParam;
string[] arrParams = (string[])struP.oParam;
if (arrParams.Length != 24)
{
return false;
}
//查找链接信息（终端编号，帧序号）
TCPHandler tw = null;
bool res = false;
if (nHashCode != 0)
{
tw = (TCPHandler)Common.platForm.tcpServer.GetTCPHandler(nHashCode);
}
if (tw != null)
{
if (tw.tName.Length == 5)
{
struWriteData wrData = new struWriteData();
wrData.addrDNL = new byte[2];
////终端类型
wrData.flagDTN = (byte)tw.tName[0];
//if (wrData.flagDTN != 'E')
//{
// MessageBox.Show("终端类型错误，非电力终端！");
// return;
//}
//逻辑编号
int n = Convert.ToInt32(tw.tName.Substring(1, 4), 16);
wrData.addrDNL[0] = (byte)(n / 256);
wrData.addrDNL[1] = (byte)(n % 256);
////主站地址
//public byte flagMSTA;
wrData.flagMSTA = 0x0;//???????????????????????????????????
//功能标志（写对象）
wrData.flagCtrlF = 0x08;
//测量点标志 (终端)
wrData.flagPoint = Convert.ToByte(struP.sMID, 16);
//帧序号
wrData.flagFSEQ = tw.GetSeqFrame();
//低级权限
wrData.flagAUT = 0x00;
//口令
wrData.passwd = new byte[3];
wrData.passwd[0] = 0x31;
wrData.passwd[1] = 0x32;
wrData.passwd[2] = 0x33;
//Hashtable ht = (Hashtable)oParam;
//数据编号与数据
//wrData.numPairs = new byte[18];
//wrData.numPairs[0] = 0x89;
//wrData.numPairs[1] = 0x01;
//arrParams.CopyTo(wrData.numPairs, 2);
MessageHandler mh = new MessageHandler(null);
Hashtable htThreshold = new Hashtable();
res = mh.E_ThresholdParamTrans(ref arrParams, ref wrData.numPairs, htThreshold);
if (res == true)
{
struFrame sFrame = new struFrame();
//放入链接队列
res = handleRSCommand(ref tw, wrData.flagCtrlF, wrData, ref sFrame);
//存库
if (res == true)
{
res = mh.E_saveAlarmThreshold(tw.tName, struP.sMID, htThreshold);
}
}
//Common.logFile.write("handleRSCommand ====================");
}
else
{
//未认证的链接
//MessageBox.Show("未知终端，无权接收请求！");
}
}
return res;
}
/*
*方法名称：RS_GetElectricThreshold
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：int nHashCode 集中器哈希编码,
*object oParam 参数对象
*ref object oResp 应答数据对象
*返回描述：bool true 成功，false 失败
*功能描述：读取电力告警参数
*/
private bool RS_GetElectricThreshold(int nHashCode, object oParam, ref object oResp)
{
//查找链接信息（终端编号，帧序号）
TCPHandler tw = null;
bool res = false;
string sMID = (string)oParam;
if (nHashCode != 0)
{
tw = (TCPHandler)Common.platForm.tcpServer.GetTCPHandler(nHashCode);
}
if (tw != null)
{
if (tw.tName.Length == 5)
{
struReadData rdData = new struReadData();
rdData.addrDNL = new byte[2];
////终端类型
rdData.flagDTN = (byte)tw.tName[0];
//if (rdData.flagDTN != 'E')
//{
// //MessageBox.Show("终端类型错误，非电力终端！");
// return false;
//}
////逻辑编号
int n = Convert.ToInt32(tw.tName.Substring(1, 4), 16);
rdData.addrDNL[0] = (byte)(n / 256);
rdData.addrDNL[1] = (byte)(n % 256);
////主站地址
//public byte flagMSTA;
rdData.flagMSTA = 0x0;//???????????????????????????????????
//功能标志
rdData.flagCtrlF = 0x01;
//测量点标志
rdData.flagPoint = Convert.ToByte(sMID, 16);//?????????????????????????
//帧序号
rdData.flagFSEQ = tw.GetSeqFrame();
//数据项编号
rdData.numPairs = new byte[16];
rdData.numPairs[0] = 0xda;
rdData.numPairs[1] = 0x80;
rdData.numPairs[2] = 0xda;
rdData.numPairs[3] = 0x81;
rdData.numPairs[4] = 0xda;
rdData.numPairs[5] = 0x82;
rdData.numPairs[6] = 0xda;
rdData.numPairs[7] = 0x83;
rdData.numPairs[8] = 0xda;
rdData.numPairs[9] = 0x85;
rdData.numPairs[10] = 0xda;
rdData.numPairs[11] = 0x86;
rdData.numPairs[12] = 0xda;
rdData.numPairs[13] = 0x87;
rdData.numPairs[14] = 0xda;
rdData.numPairs[15] = 0x88;
struFrame sRespFrame = new struFrame();
//放入链接队列
res = handleRSCommand(ref tw, rdData.flagCtrlF, rdData, ref sRespFrame);
if (res == true)
{
struFrame sFrame = (struFrame)sRespFrame;
string[] arrParam = new string[8];
MessageHandler mh = new MessageHandler(null);
res = mh.E_ThresholdParamParsing(ref sFrame, ref arrParam);
oResp = arrParam;
}
}
else
{
//未认证的链接
//MessageBox.Show("未知终端，无权接收请求！");
}
}
return res;
}
/*
*方法名称：RS_GetInfo
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：int nHashCode 集中器哈希编码,
*object oParam 参数对象
*ref object oResp 信息数据对象
*返回描述：bool true 成功，false 失败
*功能描述：读取集中器信息
*/
private bool RS_GetInfo(int nHashCode, object oParam, ref object oResp)
{
//查找链接信息（终端编号，帧序号）
TCPHandler tw = null;
bool res = false;
string sMID = (string)oParam;
if (nHashCode != 0)
{
tw = (TCPHandler)Common.platForm.tcpServer.GetTCPHandler(nHashCode);
}
if (tw != null)
{
if (tw.tName.Length == 5)
{
TimeSpan ts = DateTime.Now - tw.dtLogin;
oResp = "\r\n\t\t\t\tIP和端口：" + tw.strIPPort
+ "\r\n\t\t\t\t登录时间：" + tw.sLoginTime
+ "\r\n\t\t\t\t在线时间：" + ts.Days + " 天, " + ts.Hours + " 小时, " + ts.Minutes + " 分, " + ts.Seconds + " 秒";
res = true;
}
else
{
//未认证的链接
//MessageBox.Show("未知终端，无权接收请求！");
}
}
return res;
}
/*
*方法名称：RS_SetElecPTCT
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：int nHashCode 集中器哈希编码,
*object oParam 参数对象
*返回描述：bool true 成功，false 失败
*功能描述：设置电力PT CT
*/
public bool RS_SetElecPTCT(int nHashCode, object oParam)
{
struParam struP = (struParam)oParam;
string[] arrParams = (string[])struP.oParam;
if (arrParams.Length != 2)
{
return false;
}
//查找链接信息（终端编号，帧序号）
TCPHandler tw = null;
bool res = false;
if (nHashCode != 0)
{
tw = (TCPHandler)Common.platForm.tcpServer.GetTCPHandler(nHashCode);
}
if (tw != null)
{
if (tw.tName.Length == 5)
{
struWriteData wrData = new struWriteData();
wrData.addrDNL = new byte[2];
////终端类型
wrData.flagDTN = (byte)tw.tName[0];
//if (wrData.flagDTN != 'E')
//{
// MessageBox.Show("终端类型错误，非电力终端！");
// return;
//}
//逻辑编号
int n = Convert.ToInt32(tw.tName.Substring(1, 4), 16);
wrData.addrDNL[0] = (byte)(n / 256);
wrData.addrDNL[1] = (byte)(n % 256);
////主站地址
//public byte flagMSTA;
wrData.flagMSTA = 0x0;//???????????????????????????????????
//功能标志（写对象）
wrData.flagCtrlF = 0x08;
//测量点标志 (终端)
wrData.flagPoint = Convert.ToByte(struP.sMID, 16);
//帧序号
wrData.flagFSEQ = tw.GetSeqFrame();
//低级权限
wrData.flagAUT = 0x00;
//口令
wrData.passwd = new byte[3];
wrData.passwd[0] = 0x31;
wrData.passwd[1] = 0x32;
wrData.passwd[2] = 0x33;
//Hashtable ht = (Hashtable)oParam;
//数据编号与数据
//wrData.numPairs = new byte[18];
//wrData.numPairs[0] = 0x89;
//wrData.numPairs[1] = 0x01;
//arrParams.CopyTo(wrData.numPairs, 2);
MessageHandler mh = new MessageHandler(null);
Hashtable htPTCT = new Hashtable();
res = mh.E_PTCTParamTrans(ref arrParams, ref wrData.numPairs, htPTCT);//？？？？？？？？？？？？？
if (res == true)
{
struFrame sFrame = new struFrame();
//放入链接队列
res = handleRSCommand(ref tw, wrData.flagCtrlF, wrData, ref sFrame);
////存库
//if (res == true)
//{
// res = mh.E_saveAlarmThreshold(tw.tName, struP.sMID, htThreshold);
//}
}
//Common.logFile.write("handleRSCommand ====================");
}
else
{
//未认证的链接
//MessageBox.Show("未知终端，无权接收请求！");
}
}
return res;
}
/*
*方法名称：RS_GetElecPTCT
*创建人：韩荣伟
*创建时间：2010-10-30
*参数描述：int nHashCode 集中器哈希编码,
*object oParam 参数对象
*ref object oResp 应答数据对象
*返回描述：bool true 成功，false 失败
*功能描述：读取电力PT CT
*/
private bool RS_GetElecPTCT(int nHashCode, object oParam, ref object oResp)
{
//查找链接信息（终端编号，帧序号）
TCPHandler tw = null;
bool res = false;
string sMID = (string)oParam;
if (nHashCode != 0)
{
tw = (TCPHandler)Common.platForm.tcpServer.GetTCPHandler(nHashCode);
}
if (tw != null)
{
if (tw.tName.Length == 5)
{
struReadData rdData = new struReadData();
rdData.addrDNL = new byte[2];
////终端类型
rdData.flagDTN = (byte)tw.tName[0];
//if (rdData.flagDTN != 'E')
//{
// //MessageBox.Show("终端类型错误，非电力终端！");
// return false;
//}
////逻辑编号
int n = Convert.ToInt32(tw.tName.Substring(1, 4), 16);
rdData.addrDNL[0] = (byte)(n / 256);
rdData.addrDNL[1] = (byte)(n % 256);
////主站地址
//public byte flagMSTA;
rdData.flagMSTA = 0x0;//???????????????????????????????????
//功能标志
rdData.flagCtrlF = 0x01;
//测量点标志
rdData.flagPoint = Convert.ToByte(sMID, 16);//?????????????????????????
//帧序号
rdData.flagFSEQ = tw.GetSeqFrame();
//数据项编号
rdData.numPairs = new byte[4];
rdData.numPairs[0] = 0x89;//PT
rdData.numPairs[1] = 0x11;
rdData.numPairs[2] = 0x89;//CT
rdData.numPairs[3] = 0x12;
struFrame sRespFrame = new struFrame();
//放入链接队列
res = handleRSCommand(ref tw, rdData.flagCtrlF, rdData, ref sRespFrame);
if (res == true)
{
struFrame sFrame = (struFrame)sRespFrame;
string[] arrParam = new string[2];
MessageHandler mh = new MessageHandler(null);
res = mh.E_PTCTParamParsing(ref sFrame, ref arrParam);
oResp = arrParam;
}
}
else
{
//未认证的链接
//MessageBox.Show("未知终端，无权接收请求！");
}
}
return res;
}
}
}