/// <summary>
///
/// </summary>
/// <param name="device"></param>
protected override void OnDelete(IDevice device)
{
int id = GuidHelper.ConvertToInt32(device.Guid);
string s = string.Format("delete from tblDevice where deviceid = {0}", id);
_dbi.ExecuteScalar(s);
}
public override void OnProcess(ITask task, IParseResult pr)
{
if (pr.IsSuccess)
{
if (StringHelper.Equal(task.Opera.Name, "ReadReal"))
{
Xd202Data data = new Xd202Data();
data.BeforeWL = Convert.ToDouble(task.LastParseResult.Results["BeforeWL"]);
data.BehindWL = Convert.ToDouble(task.LastParseResult.Results["BehindWL"]);
data.Height = Convert.ToDouble(task.LastParseResult.Results["Height"]);
data.InstantFlux = Convert.ToDouble(task.LastParseResult.Results["IF"]);
data.RemainedAmount = Convert.ToDouble(task.LastParseResult.Results["RemainedAmount"]);
data.UsedAmount = 0 - data.RemainedAmount;
data.BeforeWL = CM2M(data.BeforeWL);
data.BehindWL = CM2M(data.BehindWL);
data.Height = CM2M(data.Height);
task.Device.DeviceDataManager.Last = data;
int id = GuidHelper.ConvertToInt32(task.Device.Guid);
DBI.Instance.InsertXd202Data(id, data);
}
}
}
protected override void OnDelete(IDevice device)
{
string s = string.Format(
"delete from tblDevice where DeviceID = {0}",
GuidHelper.ConvertToInt32(device.Guid));
DBI.Instance.ExecuteScalar(s);
}
public override void OnDelete(IStation station)
{
Station st = (Station)station;
int id = GuidHelper.ConvertToInt32(st.Guid);
Debug.Assert(id != 0);
DBI.Instance.DeleteStation(id);
}
protected override void OnUpdate(IDevice device)
{
string s = string.Format(
"update tblDevice set DeviceAddress = {0}, DeviceName = '{1}' where DeviceID = {2}",
device.Address,
device.Name,
GuidHelper.ConvertToInt32(device.Guid));
DBI.Instance.ExecuteScalar(s);
}
/// <summary>
///
/// </summary>
/// <param name="xgData"></param>
public void InsertXGData(XGDevice xgdevice, XGData xgData)
{
int tmCardID = GetTMCardID(xgData.CardSN);
int deviceID = GuidHelper.ConvertToInt32(xgdevice.Guid);
string s = string.Format(
"insert into tblTMData( DeviceID, TMID, TMDataDT) values ({0}, {1}, '{2}')",
deviceID, tmCardID, xgData.DT);
ExecuteScalar(s);
}
private void ProcessDataCache(LYR001Device d, LYR001DataCache dataCache)
{
if (dataCache.IsComplete())
{
GRData grdata = dataCache.ToGRData();
d.DeviceDataManager.Last = grdata;
// save
//
int id = GuidHelper.ConvertToInt32(d.Guid);
DBI.Instance.InsertGRData(id, grdata);
}
}
protected override void OnUpdate(IDevice device)
{
string s = @"update tblDevice set DeviceAddress = @DeviceAddress, DeviceName = @DeviceName
where DeviceID = @DeviceID";
ListDictionary list = new ListDictionary();
list.Add("DeviceAddress", device.Address);
list.Add("DeviceName", device.Name);
list.Add("DeviceID", GuidHelper.ConvertToInt32(device.Guid));
DBI.Instance.ExecuteScalar(s, list);
}
/// <summary>
///
/// </summary>
/// <param name="device"></param>
protected override void OnUpdate(IDevice device)
{
// TODO:
//
string s = string.Format(
"update tblDevice set DeviceAddress = {0}, DeviceName = '{1}', DeviceExtend = '{2}' where DeviceID = {3}",
device.Address,
device.Name,
GetExtend((XD1100Device)device),
GuidHelper.ConvertToInt32(device.Guid)
);
DBI.Instance.ExecuteScalar(s);
}
/// <summary>
///
/// </summary>
/// <param name="task"></param>
/// <param name="parseResult"></param>
public override void OnProcess(ITask task, IParseResult pr)
{
if (pr.IsSuccess)
{
string opera = task.Opera.Name;
if (StringHelper.Equal(opera, "read"))
{
if (StringHelper.Equal(pr.Name, string.Empty))
{
string stationName = Convert.ToString(pr.Results["name"]);
if (StringHelper.Equal(task.Device.Station.Name, stationName))
{
byte status = Convert.ToByte(pr.Results["status"]);
byte recordCount = Convert.ToByte(pr.Results["count"]);
byte[] recordsBytes = (byte[])pr.Results["datas"];
Debug.Assert(recordCount <= 5);
if (status == 0)
{
VGate100Data[] datas = ProcessRecord(recordsBytes, recordCount);
foreach (VGate100Data d in datas)
{
task.Device.DeviceDataManager.Last = d;
int id = GuidHelper.ConvertToInt32(task.Device.Guid);
DBI.Instance.InsertVGate100Data(id, d);
}
}
else
{
}
}
else
{
pr.Tag = string.Format("名称不匹配, 期望'{0}', 实际'{1}'",
task.Device.Station.Name, stationName);
}
}
else if (StringHelper.Equal(pr.Name, "noNameOrDatas"))
{
byte status = Convert.ToByte(pr.Results["status"]);
ResponseStatusEnum repStatus = (ResponseStatusEnum)status;
string text = EnumTextAttributeHelper.GetEnumTextAttributeValue(repStatus);
pr.Tag = text;
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="deviceID"></param>
/// <returns></returns>
internal IDevice Find(int deviceID)
{
IDevice r = null;
foreach (IDevice d in this)
{
int id = GuidHelper.ConvertToInt32(d.Guid);
if (id == deviceID)
{
r = d;
break;
}
}
return(r);
}
protected override void OnAdd(IDevice device)
{
Xd202 d = (Xd202)device;
string s = string.Format(
"insert into tblDevice(DeviceAddress, deviceType, stationID, DeviceName) values({0}, '{1}', {2}, '{3}')",
d.Address,
d.DeviceType.Type.Name,
GuidHelper.ConvertToInt32(d.Station.Guid),
d.Name
);
DBI.Instance.ExecuteScalar(s);
d.Guid = GuidHelper.Create(GetMaxDeviceID(DBI.Instance));
}
/// <summary>
///
/// </summary>
/// <param name="device"></param>
protected override void OnUpdate(IDevice device)
{
string s = @"update tblDevice
set DeviceAddress = @DeviceAddress, DeviceName = @DeviceName, DeviceExtend=@DeviceExtend, DeviceRemark = @deviceRemark
where DeviceID = @DeviceID";
ListDictionary list = new ListDictionary();
list.Add("DeviceAddress", device.Address);
list.Add("DeviceName", device.Name);
list.Add("DeviceExtend", device.GetStringParameters());
list.Add("DeviceRemark", device.Remark);
list.Add("DeviceID", GuidHelper.ConvertToInt32(device.Guid));
_dbi.ExecuteScalar(s, list);
}
protected override void OnAdd(IDevice device)
{
HDDevice d = (HDDevice)device;
string s = @"insert into tblDevice(DeviceAddress, deviceType, stationID, DeviceName)
values(@DeviceAddress, @DeviceType, @StationID, @DeviceName)";
ListDictionary list = new ListDictionary();
list.Add("DeviceAddress", d.Address);
list.Add("DeviceType", d.DeviceType.Type.Name);
list.Add("StationID", GuidHelper.ConvertToInt32(d.Station.Guid));
list.Add("DeviceName", d.Name);
DBI.Instance.ExecuteScalar(s, list);
d.Guid = GuidHelper.Create(GetMaxDeviceID(DBI.Instance));
}
public override void OnProcess(ITask task, IParseResult pr)
{
if (pr.IsSuccess)
{
if (StringHelper.Equal(task.Opera.Name, "Read"))
{
byte byteValue = (byte)task.LastParseResult.Results["value"];
bool value = byteValue != 0;
HDDeviceData data = new HDDeviceData();
data.Value = value;
task.Device.DeviceDataManager.Last = data;
int id = GuidHelper.ConvertToInt32(task.Device.Guid);
DBI.Instance.InsertHDData(id, data);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="task"></param>
/// <param name="parseResult"></param>
public override void OnProcess(ITask task, IParseResult pr)
{
if (pr.IsSuccess)
{
string opera = task.Opera.Name;
if (StringHelper.Equal(opera, "read"))
{
Scl6Data data = new Scl6Data();
data.InstantFlux = Convert.ToDouble(pr.Results["if"]);
data.Sum = Convert.ToDouble(pr.Results["sum"]);
task.Device.DeviceDataManager.Last = data;
int id = GuidHelper.ConvertToInt32(task.Device.Guid);
DBI.Instance.InsertScl6Data(id, data);
}
}
}
public override object GetLazyDataFieldValue(string name)
{
if (StringHelper.Equal(name, "name"))
{
return(this.Station.Name);
}
else if (StringHelper.Equal(name, "dt"))
{
//return DateTime.Now;
int deviceID = GuidHelper.ConvertToInt32(this.Guid);
return(DBI.Instance.GetVGateLastDateTime(deviceID));
}
else
{
string msg = "not find lazy name: " + name;
throw new InvalidOperationException(msg);
}
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void _mnuTemperatureLine_Click(object sender, EventArgs e)
{
XD1100Device selectedXd1100 = SoftManager.GetSoft().SelectedHardwareItem as XD1100Device;
if (selectedXd1100 != null)
{
string stationName = selectedXd1100.Station.Name;
int deviceID = GuidHelper.ConvertToInt32(selectedXd1100.Guid);
LocalController c = new LocalController();
frmXD100ModbusTemperatureControl f =
new frmXD100ModbusTemperatureControl(stationName, deviceID, c);
f.ShowDialog();
}
else
{
NUnit.UiKit.UserMessage.Display("selecte xd1100 device first");
}
}
/// <summary>
///
/// </summary>
/// <param name="device"></param>
protected override void OnAdd(IDevice device)
{
string s = @"insert into tblDevice(DeviceAddress, DeviceName, deviceType, deviceExtend, DeviceRemark, stationID)
values(@DeviceAddress, @DeviceName, @DeviceType, @DeviceExtend, @DeviceRemark, @StationID)";
ListDictionary list = new ListDictionary();
list.Add("DeviceAddress", device.Address);
list.Add("DeviceName", device.Name);
list.Add("DeviceType", device.DeviceType.Type.Name);
list.Add("DeviceExtend", device.GetStringParameters());
list.Add("DeviceRemark", device.Remark);
list.Add("StationID", GuidHelper.ConvertToInt32(device.Station.Guid));
_dbi.ExecuteScalar(s, list);
object obj = GetMaxDeviceID(_dbi);
device.Guid = GuidHelper.Create(Convert.ToInt32(obj));
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void _otProviderSetting_Click(object sender, EventArgs e)
{
frmOutsideStandard f = new frmOutsideStandard();
if (f.ShowDialog() == DialogResult.OK)
{
IOutside outSide = f.SelectedOutSide;
if (outSide != null)
{
OutsideTemperatureProviderManager.Provider = new DeviceOTProvider(outSide);
int deviceID = GuidHelper.ConvertToInt32(((IDevice)outSide).Guid);
DBI.Instance.SetOutsideTemperatureProviderDevice(deviceID);
}
else
{
OutsideTemperatureProviderManager.Provider = null;
DBI.Instance.ClearOutsideTemperatureProviderDevice();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void okButton_Click(object sender, EventArgs e)
{
object sel = this.cmbStandard.SelectedValue;
if (sel != null)
{
IOutside otDevice = (IOutside)sel;
OutsideTemperatureProviderManager.Provider = new DeviceOTProvider(otDevice);
int deviceid = GuidHelper.ConvertToInt32(((IDevice)otDevice).Guid);
DBI.Instance.SetOutsideTemperatureProviderDevice(deviceid);
}
else
{
DBI.Instance.ClearOutsideTemperatureProviderDevice();
OutsideTemperatureProviderManager.Provider = null;
}
this.DialogResult = DialogResult.OK;
this.Close();
}
/// <summary>
///
/// </summary>
/// <param name="d"></param>
/// <param name="parseResult"></param>
private void ProcessReadReal(ITask task, IParseResult pr)
{
GRData data = new GRData();
data.DT = DateTime.Now;
data.GT1 = Convert.ToSingle(pr.Results["GT1"]);
data.BT1 = Convert.ToSingle(pr.Results["BT1"]);
data.GT2 = Convert.ToSingle(pr.Results["GT2"]);
data.BT2 = Convert.ToSingle(pr.Results["BT2"]);
data.OT = Convert.ToSingle(pr.Results["OT"]);
data.GTBase2 = Convert.ToSingle(pr.Results["GTBase2"]);
data.GP1 = Convert.ToSingle(pr.Results["GP1"]);
data.BP1 = Convert.ToSingle(pr.Results["BP1"]);
data.WL = Convert.ToSingle(pr.Results["WL"]);
data.GP2 = Convert.ToSingle(pr.Results["GP2"]);
data.BP2 = Convert.ToSingle(pr.Results["BP2"]);
data.I1 = Convert.ToSingle(pr.Results["I1"]);
data.IR = Convert.ToSingle(pr.Results["IR"]);
data.I2 = Convert.ToSingle(pr.Results["I2"]);
data.S2 = Convert.ToInt32(pr.Results["S2"]);
data.S1 = Convert.ToInt32(pr.Results["S1"]);
data.SR = Convert.ToInt32(pr.Results["SR"]);
data.OD = Convert.ToInt32(pr.Results["OD"]);
//data.IH1 = Convert.ToDouble (parseResult.Results ["IH1"]);
//data.SH1 = Convert.ToDouble (parseResult.Results ["SH1"]);
data.IH1 = 0d;
data.SH1 = 0d;
// 2012-10-09 xd1100 pump status
//
bool[] pumpStatusArray = (bool[])pr.Results["pumpstate"];
data.CM1 = IsPumpRun(pumpStatusArray[0]);
data.CM2 = IsPumpRun(pumpStatusArray[1]);
data.CM3 = IsPumpRun(pumpStatusArray[2]);
data.RM1 = IsPumpRun(pumpStatusArray[3]);
data.RM2 = IsPumpRun(pumpStatusArray[4]);
object objWarn = pr.Results["Warn"];
IList listWarn = (IList)objWarn;
bool isContainsPowerAlaram = listWarn.Contains(POWER_ALARM);
if (!isContainsPowerAlaram)
{
if (HasPowerAlaramInStatus(task.Device as XD1100Device))
{
listWarn.Add(POWER_ALARM);
}
}
WarnWrapper ww = new WarnWrapper(listWarn);
data.Warn = ww;
XD1100Device d = (XD1100Device)task.Device;
//List<IFluxProvider> fluxProviderList = GetFluxProviderList(d);
DeviceCollection fluxDevices = d.Station.Devices.GetDevices(this.KIND_FLUX);
fluxDevices = RemoveUnkonwnPlaceDevice(fluxDevices);
bool hasFluxDevices = fluxDevices.Count > 0;
bool hasFluxData = fluxDevices.HasData(HasDataOption.All);
bool success = true;
if (hasFluxDevices)
{
if (hasFluxData)
{
Hashtable fluxResultHashTable = GetFluxDatas(fluxDevices);
foreach (object obj in fluxResultHashTable.Keys)
{
FluxPlace place = (FluxPlace)obj;
List <double> list = (List <double>)fluxResultHashTable[obj];
switch (place)
{
case FluxPlace.FirstSide:
data.I1 = Convert.ToSingle(list[0]);
data.S1 = Convert.ToInt32(list[1]);
break;
case FluxPlace.SecondSide:
data.I2 = Convert.ToSingle(list[0]);
data.S2 = Convert.ToInt32(list[1]);
break;
case FluxPlace.RecruitSide:
data.IR = Convert.ToSingle(list[0]);
data.SR = Convert.ToInt32(list[1]);
break;
default:
break;
}
}
}
else
{
success = false;
}
}
if (!success)
{
return;
}
DeviceCollection heatDevices = d.Station.Devices.GetDevices(KIND_HEAT);
//heatDevices = RemoveUnkonwnPlaceDevice(heatDevices);
heatDevices = this.Filter(heatDevices, FluxPlace.FirstSide);
bool hasHeatDevices = heatDevices.Count > 0;
bool hasHeatData = heatDevices.HasData(HasDataOption.All);
if (hasHeatDevices)
{
if (hasHeatData)
{
double instantFlux = 0d;
double sumFlux = 0d;
double ih = 0d;
double sh = 0d;
foreach (IDevice hd in heatDevices)
{
IData last = hd.DeviceDataManager.Last;
ih += Convert.ToDouble(last.GetValue("InstantHeat"));
sh += Convert.ToDouble(last.GetValue("SumHeat"));
instantFlux += Convert.ToDouble(last.GetValue("InstantFlux"));
sumFlux += Convert.ToDouble(last.GetValue("Sum"));
}
data.I1 = Convert.ToSingle(instantFlux);
data.S1 = Convert.ToInt32(sumFlux);
data.IH1 = ih;
data.SH1 = sh;
}
else
{
success = false;
}
}
if (!success)
{
return;
}
switch (d.HtmMode.ModeValue)
{
case ModeValue.Indirect:
data.CyclePumpDatas.Add(new PumpData("1#", Convert.ToInt32(pr.Results["cyclefrequency"])));
data.RecruitPumpDatas.Add(new PumpData("1#", Convert.ToInt32(pr.Results["recruitfrequency"])));
break;
case ModeValue.Direct:
data.GT1 = data.GT2;
data.BT1 = data.BT2;
break;
case ModeValue.Mixed:
data.BT1 = data.BT2;
data.CyclePumpDatas.AddRange(
new PumpData("1#", Convert.ToInt32(pr.Results["cyclefrequency"])),
new PumpData("2#", Convert.ToInt32(pr.Results["recruitfrequency"])),
new PumpData("3#", Convert.ToInt32(pr.Results["I2"])));
break;
}
d.DeviceDataManager.Last = data;
// save
//
int id = GuidHelper.ConvertToInt32(d.Guid);
DBI.Instance.InsertXD1100Data(id, data);
}
/// <summary>
///
/// </summary>
/// <param name="task"></param>
/// <param name="parseResult"></param>
public override void OnProcess(ITask task, IParseResult pr)
{
if (pr.IsSuccess)
{
//Xd100eData data = Xd100eData.GetCachedData();
Xd100e xd100eDevice = (Xd100e)task.Device;
Xd100eData data = xd100eDevice.GetCachedData();
Console.WriteLine("ori xd100e id: " + GuidHelper.ConvertToInt32(xd100eDevice.Guid));
string opera = task.Opera.Name;
if (StringHelper.Equal(opera, READ_REAL))
{
for (int i = Xd100eData.BeginChannelNO; i <= Xd100eData.EndChannelNO; i++)
{
int no = i;
string channelName = GetChannelName(no);
float val = Convert.ToSingle(pr.Results[channelName]);
val /= 100f;
data.SetChannelDataAI(no, val);
data.IsSetAI = true;
}
}
else if (StringHelper.Equal(opera, READ_REAL_DI))
{
//XD100EData data = xd100eDevice.XD100EData;
for (int i = Xd100eData.BeginChannelNO; i <= Xd100eData.EndChannelNO; i++)
{
int no = i;
string channelName = GetChannelName(no);
byte value = Convert.ToByte(pr.Results[channelName]);
data.SetChannelDataDI(no, value > 0);
data.IsSetDI = true;
}
}
//
//
if (data.IsComplete())
{
double ir = 0d, sr = 0d;
//bool hasRecuritFluxDevice;
string recuritEx = string.Empty;
//bool success = GetFluxValues(xd100eDevice, FluxPlace.RecruitSide, out hasRecuritFluxDevice,
// out ir, out sr, out recuritEx);
// get kind == fluxdevice device collection
//
DeviceCollection rDevices = xd100eDevice.Station.Devices.GetDevices(KIND_FLUX_DEVICE);
rDevices = Filter(rDevices, FluxPlace.RecruitSide);
bool hasRecuritFluxDevice = rDevices.Count > 0;
bool hasRecuritFluxData = rDevices.HasData(HasDataOption.All);
if (hasRecuritFluxData)
{
ir = Calc(rDevices, "InstantFlux", CalcType.Sum);
sr = Calc(rDevices, "Sum", CalcType.Sum);
recuritEx = GetRecuritEx(rDevices);
}
// get recruite device collection
// get recruite data
//
// get kind == heatdevcie device collection
// check has data
// [x] get place == first ?
// get device gt bt
double if1 = 0d, sf1 = 0d, gt1 = 0d, bt1 = 0d, ih1 = 0d, sh1 = 0d;
//bool hasFirstFluxDevice;
//string firstEx;
//bool success2 = GetFluxValues(xd100eDevice, FluxPlace.FirstSide, out hasFirstFluxDevice,
// out if1, out sf1, out firstEx);
DeviceCollection hs = xd100eDevice.Station.Devices.GetDevices(KIND);
hs = Filter(hs, FluxPlace.FirstSide);
bool hasFirstFluxDevice = hs.Count > 0;
bool hasFirstFluxData = hs.HasData(HasDataOption.All);
if (hasFirstFluxData)
{
if1 = Calc(hs, "InstantFlux", CalcType.Sum);
sf1 = Calc(hs, "Sum", CalcType.Sum);
gt1 = Calc(hs, "GT", CalcType.Avg);
bt1 = Calc(hs, "BT", CalcType.Avg);
ih1 = Calc(hs, "InstantHeat", CalcType.Sum);
sh1 = Calc(hs, "SumHeat", CalcType.Sum);
}
bool success = true;
if (hasRecuritFluxDevice)
{
if (hasRecuritFluxData)
{
data.IR = ir;
data.SR = sr;
data.REx = recuritEx;
}
else
{
success = false;
}
}
//
//
if (success)
{
if (hasFirstFluxDevice)
{
if (hasFirstFluxData)
{
// xd100e ai5 == if1
//
// ai1 - gt1, ai2 - bt1
//
data.IF1 = if1;
data.SF1 = sf1;
data.AI5 = Convert.ToSingle(if1);
data.AI1 = Convert.ToSingle(gt1);
data.AI2 = Convert.ToSingle(bt1);
data.IH1 = ih1;
data.SH1 = sh1;
}
else
{
success = false;
}
}
}
if (success)
{
data.DT = DateTime.Now;
xd100eDevice.DeviceDataManager.Last = data;
int deviceID = GuidHelper.ConvertToInt32(xd100eDevice.Guid);
Console.WriteLine("write xd100e id: " + deviceID);
DBI.Instance.InsertXd100eData(deviceID, data);
}
//if (success && success2)
//{
// data.IR = ir;
// data.SR = sr;
// data.REx = recuritEx;
// data.IF1 = if1;
// data.SF1 = sf1;
// if (hasFirstFluxDevice)
// {
// // xd100e ai5 == if1
// //
// // ai1 - gt1, ai2 - bt1
// //
// data.AI5 = Convert.ToSingle(if1);
// data.AI1 = Convert.ToSingle(GetGT1FromCRL_G(xd100eDevice));
// data.AI2 = Convert.ToSingle(GetBT1FromCRL_G(xd100eDevice));
// }
// data.DT = DateTime.Now;
// xd100eDevice.DeviceDataManager.Last = data;
// int deviceID = GuidHelper.ConvertToInt32(xd100eDevice.Guid);
// Console.WriteLine("write xd100e id: " + deviceID);
// DBI.Instance.InsertXd100eData(deviceID, data);
//}
}
}
}