public static void CDMA_UNKNOWN(IOData Data)
{
Logger.WriteStub("Stubbed.");
Data.Read32 = 0x00;
}
private void SaveMacDataValue()
{
IOData d = mac.IoData;
switch (showMode)
{
case 0:
{
for (int i = 0; i < 32; i++)
{
d.DiList[i] = IDs[i].Int;
if (SGs[i].Value == 1)
{
d.DiMask = d.DiMask.Bit(i, true);
d.DiUsed = d.DiUsed.Bit(i, true);
}
else if (SGs[i].Value == 0)
{
d.DiMask = d.DiMask.Bit(i, false);
d.DiUsed = d.DiUsed.Bit(i, true);
}
else
{
d.DiUsed = d.DiUsed.Bit(i, false);
}
}
}
break;
case 1:
{
for (int i = 0; i < 32; i++)
{
d.DoList[i] = IDs[i].Int;
if (SGs[i].Value == 1)
{
d.DoMask = d.DoMask.Bit(i, true);
d.DoUsed = d.DoUsed.Bit(i, true);
}
else if (SGs[i].Value == 0)
{
d.DoMask = d.DoMask.Bit(i, false);
d.DoUsed = d.DoUsed.Bit(i, true);
}
else
{
d.DoUsed = d.DoUsed.Bit(i, false);
}
}
}
break;
case 2: //输入16 输出16
{
for (int i = 0; i < 32; i++)
{
if (i < 16)
{
d.DiList[i] = IDs[i].Int;
if (SGs[i].Value == 1)
{
d.DiMask = d.DiMask.Bit(i, true);
d.DiUsed = d.DiUsed.Bit(i, true);
}
else if (SGs[i].Value == 0)
{
d.DiMask = d.DiMask.Bit(i, false);
d.DiUsed = d.DiUsed.Bit(i, true);
}
else
{
d.DiUsed = d.DiUsed.Bit(i, false);
}
}
else
{
int m = i - 16;
d.DoList[m] = IDs[i].Int;
if (SGs[i].Value == 1)
{
d.DoMask = d.DoMask.Bit(m, true);
d.DoUsed = d.DoUsed.Bit(m, true);
}
else if (SGs[i].Value == 0)
{
d.DoMask = d.DoMask.Bit(m, false);
d.DoUsed = d.DoUsed.Bit(m, true);
}
else
{
d.DoUsed = d.DoUsed.Bit(m, false);
}
}
}
}
break;
default:
break;
}
SystemDataManager.saved = true;
}
/// <summary>
/// 返回服务器端接收的数据,此处主要将一个设备下的所有IO表数据统一获取后在一次性上传,
/// </summary>
/// <param name="server"></param>
/// <param name="comm"></param>
/// <param name="device"></param>
/// <param name="para">为null,此参数不传递,根据用户驱动需要</param>
/// <param name="receivedatas">接收的全部数据，要求在驱动中进行一次读取后返回</param>
public static void CDriverDll_OnDataReceived(IO_SERVER server, IO_COMMUNICATION comm, IO_DEVICE device, byte[] receivedatas, string date, object sender)
{
//解析数据
var analysisTask = Task.Run(() =>
{
try
{
if (device != null && device.DeviceDrive != null)
{
//清理已经接收完成的数据
for (int i = 0; i < device.IOParas.Count; i++)
{
device.IOParas[i].IORealData = null;
}
device.GetedValueDate = DateTime.Now;
device.ReceiveBytes = receivedatas;
#region 循环解析实时数据接收的每个参数
ScadaDeviceKernel Driver = (ScadaDeviceKernel)device.DeviceDrive;
for (int i = 0; i < device.IOParas.Count; i++)
{
#region 解析开关量 模拟量 字符常量 数据
try
{
if (device.IOParas[i].IO_POINTTYPE == "模拟量" || device.IOParas[i].IO_POINTTYPE == "开关量" || device.IOParas[i].IO_POINTTYPE == "字符串量")
{
try
{
Driver.InitKernel(server, comm, device, device.IOParas[i], device.DriverInfo);
IOData recdata = Driver.AnalysisData(server, comm, device, device.IOParas[i], receivedatas, Convert.ToDateTime(date), sender);
if (recdata != null)
{
device.IOParas[i].IORealData = recdata;
}
}
catch
{
device.IOParas[i].IORealData = null;
}
}
}
catch
{
}
#endregion
#region 解析关系数据库值
try
{
if (device.IOParas[i].IO_POINTTYPE == "关系数据库值" && device.IOParas[i].IO_DATASOURCE.Trim() != "")
{
RelationalDatabase rlation = new RelationalDatabase(device.IOParas[i].IO_DATASOURCE);
string sql = rlation.GetSql();
string conn = rlation.ConnectString;
switch (rlation.Database_Type)
{
case "SQL Server":
{
try
{
if (conn != "" && sql != "")
{
DbHelperSQL sqlHealp = new DbHelperSQL();
sqlHealp.connectionString = conn;
DataSet ds = sqlHealp.Query(sql);
if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
{
device.IOParas[i].IORealData = new IOData();
device.IOParas[i].IORealData.CommunicationID = device.IO_COMM_ID;
device.IOParas[i].IORealData.ServerID = device.IO_SERVER_ID;
device.IOParas[i].IORealData.ID = device.IO_DEVICE_ID;
device.IOParas[i].IORealData.ParaName = device.IOParas[i].IO_NAME;
device.IOParas[i].IORealData.ParaString = device.IOParas[i].IO_PARASTRING;
device.IOParas[i].IORealData.ParaValue = ds.Tables[0].Rows[0]["value"].ToString();
device.IOParas[i].IORealData.QualityStamp = QualityStamp.GOOD;
device.IOParas[i].IORealData.Date = Convert.ToDateTime(ds.Tables[0].Rows[0]["datetime"].ToString());
}
}
}
catch
{
device.IOParas[i].IORealData = null;
}
}
break;
case "ORACLE":
{
try
{
if (conn != "" && sql != "")
{
DbHelperOra oracleHealp = new DbHelperOra();
oracleHealp.connectionString = conn;
DataSet ds = oracleHealp.Query(sql);
if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
{
device.IOParas[i].IORealData = new IOData();
device.IOParas[i].IORealData.CommunicationID = device.IO_COMM_ID;
device.IOParas[i].IORealData.ServerID = device.IO_SERVER_ID;
device.IOParas[i].IORealData.ID = device.IO_DEVICE_ID;
device.IOParas[i].IORealData.ParaName = device.IOParas[i].IO_NAME;
device.IOParas[i].IORealData.ParaString = device.IOParas[i].IO_PARASTRING;
device.IOParas[i].IORealData.ParaValue = ds.Tables[0].Rows[0]["value"].ToString();
device.IOParas[i].IORealData.QualityStamp = QualityStamp.GOOD;
device.IOParas[i].IORealData.Date = Convert.ToDateTime(ds.Tables[0].Rows[0]["datetime"].ToString());
}
}
}
catch
{
device.IOParas[i].IORealData = null;
}
}
break;
case "MySql":
{
try
{
if (conn != "" && sql != "")
{
DbHelperMySQL mysqlHealp = new DbHelperMySQL();
mysqlHealp.connectionString = conn;
DataSet ds = mysqlHealp.Query(sql);
if (ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
{
device.IOParas[i].IORealData = new IOData();
device.IOParas[i].IORealData.CommunicationID = device.IO_COMM_ID;
device.IOParas[i].IORealData.ServerID = device.IO_SERVER_ID;
device.IOParas[i].IORealData.ID = device.IO_DEVICE_ID;
device.IOParas[i].IORealData.ParaName = device.IOParas[i].IO_NAME;
device.IOParas[i].IORealData.ParaString = device.IOParas[i].IO_PARASTRING;
device.IOParas[i].IORealData.ParaValue = ds.Tables[0].Rows[0]["value"].ToString();
device.IOParas[i].IORealData.QualityStamp = QualityStamp.GOOD;
device.IOParas[i].IORealData.Date = Convert.ToDateTime(ds.Tables[0].Rows[0]["datetime"].ToString());
double d = 0;
if (double.TryParse(device.IOParas[i].IORealData.ParaValue, out d))
{
device.IOParas[i].IORealData.DataType = typeof(double);
}
else
{
device.IOParas[i].IORealData.DataType = typeof(string);
}
}
}
}
catch
{
device.IOParas[i].IORealData = null;
}
}
break;
}
}
}
catch
{
}
#endregion
#region 解析计算值包含公式计算的
//
try
{
if (device.IOParas[i].IO_POINTTYPE == "计算值")
{
if (device.IOParas[i].IO_FORMULA.Trim() != "")
{
device.IOParas[i].IORealData = new IOData();
try
{
device.IOParas[i].IORealData.QualityStamp = QualityStamp.GOOD;
device.IOParas[i].IORealData.Date = DateTime.Now;
device.IOParas[i].IORealData.ParaName = device.IOParas[i].IO_NAME;
device.IOParas[i].IORealData.DataType = typeof(double);
//替换关键字为数值
string formula = device.IOParas[i].IO_FORMULA;
foreach (IO_PARA para in device.IOParas)
{
if (device.IOParas[i].IO_POINTTYPE != "字符串量" && device.IOParas[i].IO_POINTTYPE != "计算值" && device.IOParas[i].IORealData != null)
{
if (device.IOParas[i].IORealData.QualityStamp == QualityStamp.GOOD && device.IOParas[i].IORealData.ParaValue != "-9999" && device.IOParas[i].IORealData.ParaValue != "")
{
formula = formula.Replace(device.IOParas[i].IO_NAME, device.IOParas[i].IORealData.ParaValue);
}
}
}
if (formula != "")
{
//解析数学公式
device.IOParas[i].IORealData.ParaValue = AnalyzeCalculate.Calculate(device.IOParas[i].IO_FORMULA);
double d = 0;
if (double.TryParse(device.IOParas[i].IORealData.ParaValue, out d))
{
device.IOParas[i].IORealData.DataType = typeof(double);
}
else
{
device.IOParas[i].IORealData.DataType = typeof(string);
}
}
else
{
device.IOParas[i].IORealData.ParaValue = "-9999";
device.IOParas[i].IORealData.QualityStamp = QualityStamp.BAD;
}
}
catch
{
device.IOParas[i].IORealData.QualityStamp = QualityStamp.BAD;
device.IOParas[i].IORealData.Date = DateTime.Now;
device.IOParas[i].IORealData.ParaName = device.IOParas[i].IO_NAME;
}
}
else
{
device.IOParas[i].IORealData = null;
}
}
}
catch
{
}
#endregion
#region 进行量程转换
try
{
if (device.IOParas[i].IO_POINTTYPE == "模拟量")
{
if (device.IOParas[i].IORealData != null && device.IOParas[i].IO_ENABLERANGECONVERSION == 1 && device.IOParas[i].IORealData.QualityStamp == QualityStamp.GOOD)
{
if (device.IOParas[i].IORealData.ParaValue != "" && device.IOParas[i].IORealData.ParaValue != "-9999")
{
string value = ConvertParaTypeValue(device.IOParas[i].GetParaValueType(), device.IOParas[i].IORealData.ParaValue, double.Parse(device.IOParas[i].IO_RANGEMAX), double.Parse(device.IOParas[i].IO_RANGEMIN), double.Parse(device.IOParas[i].IO_MAXVALUE), double.Parse(device.IOParas[i].IO_MINVALUE));
device.IOParas[i].IORealData.ParaValue = value;
}
}
}
}
catch
{
}
#endregion
#region 常量值
try
{
if (device.IOParas[i].IO_POINTTYPE == "常量值")
{
device.IOParas[i].IORealData = new IOData()
{
CommunicationID = device.IOParas[i].IO_COMM_ID,
DataType = typeof(string),
Date = device.GetedValueDate,
ParaName = device.IOParas[i].IO_NAME,
ParaString = device.IOParas[i].IO_PARASTRING,
ParaValue = device.IOParas[i].IO_INITALVALUE,
QualityStamp = QualityStamp.GOOD,
ServerID = device.IOParas[i].IO_SERVER_ID
};
}
}
catch
{
}
#endregion
}
#endregion
#region 将解析后的数据上传到数据中心服务器上
IO_DEVICE newDevice = device.Copy();
try
{
//将接收到的数据保存到实时缓存,主要用于批量上传,提高传输效率
receiveRealCache.Push(new ReceiveCacheObject()
{
DataString = RealDataDBUtility.GetRealDataCacheString(device)
});
MonitorFormManager.ShowMonitorUploadListView(server, comm, device, "上传成功");
}
catch (Exception emx)
{
ThrowExceptionToMain(emx);
}
//在事件接收窗体中显示接收的采集数据
if (OnMonitorReceive != null)
{
OnMonitorReceive(server, comm, newDevice, receivedatas);
}
#endregion
#region 计算报警并上传
try
{
Task.Run(() =>
{
List <IO_PARAALARM> res = new List <IO_PARAALARM>();
//将接收到的数据保存到实时缓存,主要用于批量上传,提高传输效率
receiveRealCache.Push(new AlarmCacheObject()
{
DataString = RealDataDBUtility.GetAlarmCacheString(device, out res)
});
for (int i = 0; i < res.Count; i++)
{
MonitorFormManager.MonitorIODataAlarmShowView(server, comm, device, res[i], "上传成功");
}
res.Clear();
res = null;
});
}
catch (Exception emx)
{
ThrowExceptionToMain(emx);
}
#endregion
}
}
catch (Exception emx)
{
ThrowExceptionToMain(emx);
}
if (receivedatas != null && receivedatas.Length > 0)
{
AddLogToMainLog(device.IO_DEVICE_NAME + "接收到数据 DATA=" + CVT.ByteToHexStr(receivedatas));
}
});
}
/// <summary>
/// 解析数据
/// </summary>
/// <param name="server"></param>
/// <param name="Communication"></param>
/// <param name="device"></param>
/// <param name="para"></param>
/// <param name="datas"></param>
/// <param name="datatime"></param>
/// <param name="sender"></param>
/// <returns></returns>
protected override IOData Analysis(IO_SERVER server, IO_COMMUNICATION Communication, IO_DEVICE device, IO_PARA para, byte[] datas, DateTime datatime, object sender)
{
if (datas.Length > 0 && sender != null && para != null)
{
ParaPack paraPack = new ParaPack(para.IO_PARASTRING);
ModbusFragmentStore modbusStore = (ModbusFragmentStore)sender;
IOData data = new IOData();
data.CommunicationID = Communication.IO_COMM_ID;
data.ID = device.IO_DEVICE_ADDRESS;
data.ParaName = para.IO_NAME;
data.ServerID = server.SERVER_ID;
data.Date = DateTime.Now;
Modbus_Type dataType = (Modbus_Type)Enum.Parse(typeof(Modbus_Type), paraPack.GetValue("数据类型"));
switch (dataType)
{
case Modbus_Type.单精度浮点数32位:
data.DataType = typeof(float);
break;
case Modbus_Type.双精度浮点数64位:
data.DataType = typeof(double);
break;
case Modbus_Type.字符型:
data.DataType = typeof(string);
break;
case Modbus_Type.无符号整数16位:
data.DataType = typeof(UInt16);
break;
case Modbus_Type.无符号整数32位:
data.DataType = typeof(UInt32);
break;
case Modbus_Type.无符号整数8位:
data.DataType = typeof(byte);
break;
case Modbus_Type.符号整数16位:
data.DataType = typeof(Int16);
break;
case Modbus_Type.符号整数8位:
data.DataType = typeof(sbyte);
break;
case Modbus_Type.符号整数32位:
data.DataType = typeof(int);
break;
}
data.datas = datas;
data.ParaString = para.IO_PARASTRING;
//获取数据值高八位,低八位
int startaddr = int.Parse(paraPack.GetValue("偏置"));
int charsize = int.Parse(paraPack.GetValue("字节长度"));
string code = paraPack.GetValue("内存区");
bool bitSave = paraPack.GetValue("按位存取") == "1" ? true : false;
bool ishigh = paraPack.GetValue("存储位置") == "高八位" ? true : false;
ModbusFragment fragment = modbusStore.Fragments.Find(x => x.Code == code && startaddr >= x.StartRegister && startaddr <= x.StartRegister + x.RegisterNum);
if (fragment != null)
{
switch (code)
{
case "01": //线圈
{
byte[] vdatas = new byte[fragment.Length];
Array.Copy(datas, fragment.StartIndex, vdatas, 0, fragment.Length);
data.ParaValue = vdatas[startaddr].ToString();
}
break;
case "02": //线圈只读
{
byte[] vdatas = new byte[fragment.Length];
Array.Copy(datas, fragment.StartIndex, vdatas, 0, fragment.Length);
data.ParaValue = vdatas[startaddr].ToString();
}
break;
case "03": //寄存器可读可写
{
//注意是否按位读取，
byte[] vdatas = new byte[fragment.Length];
Array.Copy(datas, fragment.StartIndex, vdatas, 0, fragment.Length);
ushort[] vals = ModbusConvert.Bytes2Ushorts(vdatas); //将字节数组转为ushort
switch (dataType)
{
case Modbus_Type.单精度浮点数32位:
{
data.ParaValue = ModbusConvert.GetReal(vals, startaddr).ToString();
}
break;
case Modbus_Type.双精度浮点数64位:
{
data.ParaValue = ModbusConvert.GetDouble(vals, startaddr).ToString();
}
break;
case Modbus_Type.字符型:
{
data.ParaValue = ModbusConvert.GetString(vals, startaddr, charsize).ToString();
}
break;
case Modbus_Type.无符号整数16位:
{
data.ParaValue = ModbusConvert.GetUShort(vals, startaddr).ToString();
}
break;
case Modbus_Type.无符号整数32位:
{
data.ParaValue = ModbusConvert.GetUInt(vals, startaddr).ToString();
}
break;
case Modbus_Type.无符号整数8位:
{
data.ParaValue = ModbusConvert.GetSByte(vals, startaddr, ishigh).ToString();
}
break;
case Modbus_Type.符号整数16位:
{
data.ParaValue = ModbusConvert.GetShort(vals, startaddr).ToString();
}
break;
case Modbus_Type.符号整数8位:
{
data.ParaValue = ModbusConvert.GetByte(vals, startaddr, ishigh).ToString();
}
break;
case Modbus_Type.符号整数32位:
{
data.ParaValue = ModbusConvert.GetInt(vals, startaddr).ToString();
}
break;
}
}
break;
case "04": //寄存器只读
{
//注意是否按位读取，
byte[] vdatas = new byte[fragment.Length];
Array.Copy(datas, fragment.StartIndex, vdatas, 0, fragment.Length);
ushort[] vals = ModbusConvert.Bytes2Ushorts(vdatas); //将字节数组转为ushort
switch (dataType)
{
case Modbus_Type.单精度浮点数32位:
{
data.ParaValue = ModbusConvert.GetReal(vals, 0).ToString();
}
break;
case Modbus_Type.双精度浮点数64位:
{
data.ParaValue = ModbusConvert.GetDouble(vals, 0).ToString();
}
break;
case Modbus_Type.字符型:
{
data.ParaValue = ModbusConvert.GetString(vals, 0, charsize).ToString();
}
break;
case Modbus_Type.无符号整数16位:
{
data.ParaValue = ModbusConvert.GetUShort(vals, 0).ToString();
}
break;
case Modbus_Type.无符号整数32位:
{
data.ParaValue = ModbusConvert.GetUInt(vals, 0).ToString();
}
break;
case Modbus_Type.无符号整数8位:
{
data.ParaValue = ModbusConvert.GetSByte(vals, 0, ishigh).ToString();
}
break;
case Modbus_Type.符号整数16位:
{
data.ParaValue = ModbusConvert.GetShort(vals, 0).ToString();
}
break;
case Modbus_Type.符号整数8位:
{
data.ParaValue = ModbusConvert.GetByte(vals, 0, ishigh).ToString();
}
break;
case Modbus_Type.符号整数32位:
{
data.ParaValue = ModbusConvert.GetInt(vals, 0).ToString();
}
break;
}
}
break;
}
data.QualityStamp = QualityStamp.GOOD;
}
return(data);
}
return(null);
}
public static void HID_PAD(IOData Data)
{
Logger.WriteStub("Stubbed.");
Data.Read16 = 0xFFF;
}
/// <summary>
/// 获取某个参数的解析数据,如果该参数还没有接收到数返回为null
/// </summary>
/// <param name="server"></param>
/// <param name="device"></param>
/// <param name="para"></param>
/// <param name="datas"></param>
/// <param name="datatime"></param>
/// <returns></returns>
protected override IOData Analysis(IO_SERVER server, IO_COMMUNICATION communication, IO_DEVICE device, IO_PARA para, byte[] datas, DateTime datatime)
{
try
{
//02号功能码 (DI离散输入量)
//01号和05号功能码 (DI离散输入量)
//03号功能码 (HR保持寄存器)
//04号功能码 (AR保持寄存器)
//08号功能码 (诊断)
//15号功能码 (强制多个寄存器)
//07号功能码 (读不正常状态)
//构造字符串
// 线圈状态 = 1,
//读输入状态 = 2,
//读保持型寄存器 = 3,
//读输入型寄存器 = 4,
//强制单个线圈 = 5,
//写单个寄存器 = 6,
//强制多个线圈 = 15,
//写多个寄存器 = 16,
//读变量 = 20,
//写变量 = 21,
//错误信息 = 80,
//NONE
string parastring = para.IO_PARASTRING;
ModbusData analysisData = ModbusAnalysis.ReceiveAnalysis(datas);
IOData data = new IOData();
data.QualityStamp = QualityStamp.BAD;
data.ParaValue = "-9999";
data.Date = DateTime.Now;
data.ID = para.IO_ID;
data.CommunicationID = communication.IO_COMM_ID;
data.ParaName = para.IO_NAME;
data.ServerID = server.SERVER_ID;
string[] paras = parastring.Split(',');//读取参数设置的所有参数格式
if (paras.Length < 8)
{
return(data);
}
int function = int.Parse(paras[0].Split(':')[1].Trim()); //功能码
int deviation = int.Parse(paras[1].Split(':')[1].Trim()); //偏置量
if (Convert.ToInt32(analysisData.FunctionCode) > 30) //大于80标识返回的是错误信息
{
base.DeviceException(analysisData.FunctionCode.ToString());
}
if (Convert.ToInt32(analysisData.FunctionCode) != function)//如果接收的数据功能码和参数功能码不一致，则放弃该数据，否则继续下步解析
{
return(data);
}
//判断寄存器存储的数据类型，不同的类型占用数据字节不一样
Type datatype = typeof(short);
int numunit = 1;//判读当前占用的字节
switch (paras[2].Split(':')[1].Trim())
{
case "8位有符号":
datatype = typeof(sbyte);
numunit = 2;
break;
case "8位无符号":
datatype = typeof(byte);
numunit = 2;
break;
case "16位有符号":
datatype = typeof(Int16);
numunit = 2;
break;
case "16位无符号":
datatype = typeof(UInt16);
numunit = 2;
break;
case "32位有符号":
datatype = typeof(Int32);
numunit = 4;
break;
case "32位无符号":
datatype = typeof(UInt32);
numunit = 4;
break;
case "字符型":
datatype = typeof(String);
break;
case "32位浮点型":
datatype = typeof(float);
numunit = 4;
break;
case "64位双精度浮点型":
datatype = typeof(double);
numunit = 8;
break;
default:
datatype = typeof(byte);
numunit = 2;
break;
}
bool isbanary = false;//是否按位读写
int banarynumber = int.Parse(paras[6].Split(':')[1].Trim());
if (paras[5].Split(':')[1].Trim() == "1")
{
isbanary = true;
}
else
{
isbanary = false;
}
if (paras.Length == 8)
{
if (paras[7].Split('|')[1].Trim() == BitStoreMode.低位字节在前.ToString())
{
data.BitStoreMode = BitStoreMode.低位字节在前;
}
else
{
data.BitStoreMode = BitStoreMode.高位字节在前;
}
}
//判断当前返回寄存器的个数
if (deviation < analysisData.StartAddress || numunit > analysisData.MCount)
{
//返回空值表示当前寄存器
return(null);
}
if (isbanary == false)
{
try
{
byte[] valuebyte = new byte[numunit];
int index = (deviation - 1) * 2 + 3;
if (index <= 0 || index >= analysisData.Data.Length)
{
base.DeviceException("error=10114 模拟量数据解析错误 数据点配置超过返回的数据点长度");
}
if (analysisData.Data.Length > numunit + index)
{
Array.Copy(analysisData.Data, index, valuebyte, 0, valuebyte.Length);//拷贝数据
data.datas = valuebyte;
data.DataType = datatype;
data.Date = DateTime.Now;
data.ID = analysisData.SlaveID.ToString();
data.ParaName = para.IO_NAME;
data.ParaValue = ConvertType.BytesToBit(valuebyte, datatype, data.BitStoreMode).ToString();
if (data.ParaValue == null)
{
data.ParaValue = "-9999";
}
data.ParaString = parastring;
if (data.ParaValue != "-9999")
{
data.QualityStamp = QualityStamp.GOOD;
}
else
{
data.QualityStamp = QualityStamp.BAD;
}
}
}
catch (Exception emx)
{
base.DeviceException("error HA111" + emx.Message);
}
}
else //如果按照位读取
{
int index = (deviation - 1) * 2 + 3;
if (index <= 0 || index >= analysisData.Data.Length)
{
this.DeviceException("error= HA11115开关量数据解析错误 数据点配置超过返回的数据点长度");
}
if (analysisData.Data.Length > 2 + index)
{
try
{
byte[] valuebyte = new byte[2]; //按位读取的话，首先读取一个寄存器地址，并将该地址
Array.Copy(analysisData.Data, index, valuebyte, 0, valuebyte.Length); //拷贝数据
object num = ConvertType.BytesToBit(valuebyte, datatype, data.BitStoreMode).ToString();
if (datatype == typeof(UInt16))
{
data.ParaValue = string.Format("{0}", Convert.ToUInt16(num) >> banarynumber & 1);
data.QualityStamp = QualityStamp.GOOD;
}
else if (datatype == typeof(Int16))
{
data.ParaValue = string.Format("{0}", Convert.ToInt16(num) >> banarynumber & 1);
data.QualityStamp = QualityStamp.GOOD;
}
else if (datatype == typeof(sbyte))
{
data.ParaValue = string.Format("{0}", Convert.ToSByte(num) >> banarynumber & 1);
data.QualityStamp = QualityStamp.GOOD;
}
else if (datatype == typeof(byte))
{
data.ParaValue = string.Format("{0}", Convert.ToByte(num) >> banarynumber & 1);
data.QualityStamp = QualityStamp.GOOD;
}
else if (datatype == typeof(Int32))
{
data.ParaValue = string.Format("{0}", Convert.ToInt32(num) >> banarynumber & 1);
data.QualityStamp = QualityStamp.GOOD;
}
else if (datatype == typeof(UInt32))
{
data.ParaValue = string.Format("{0}", Convert.ToUInt32(num) >> banarynumber & 1);
data.QualityStamp = QualityStamp.GOOD;
}
if (banarynumber < 0 && banarynumber >= 16)
{
this.DeviceException("error=D10001 数据位数应该在0-15的范围内");
data.QualityStamp = QualityStamp.BAD;
data.ParaValue = "-9999";
}
data.datas = valuebyte;
data.DataType = datatype;
data.Date = DateTime.Now;
data.ID = analysisData.SlaveID.ToString();
data.ParaName = para.IO_NAME;
data.ParaString = parastring;
}
catch (Exception emx)
{
this.DeviceException(emx.Message);
}
}
}
return(data);
}
catch (Exception emx)
{
this.DeviceException(emx.Message);
}
return(null);
}
public byte ReadUInt8(uint Address)
{
if (Type == CPUType.ARM9)
{
if (Address < 0x08000000)
{
return(InstructionTCM[Address]);
}
}
else
{
if (Address < 0x00010000)
{
return(BootROM11.BootROM[Address]);
}
else if (Address >= 0x00010000 && Address < 0x00010000 + 0x00010000)
{
return(BootROM11.BootROM[Address - 0x00010000]);
}
}
if (Address >= 0x10000000 && Address < 0x10000000 + 0x08000000)
{
if (Type == CPUType.ARM11)
{
if (Address >= 0x17E00000 && Address < 0x17E00000 + 0x00002000)
{
return(0);
}
}
IOData IOInfo = new IOData(CPU, Address, IOType.Read, 1);
IO.Call(IOInfo);
return(IOInfo.Read8);
}
else if (Address >= 0x1FF80000 && Address < 0x1FF80000 + 0x00080000)
{
return(AXIWRAM[Address - 0x1FF80000]);
}
else if (Address >= 0x20000000 && Address < 0x20000000 + 0x08000000)
{
return(FCRAM[Address - 0x20000000]);
}
if (Type == CPUType.ARM9)
{
if (Address >= 0xFFF00000 && Address < 0xFFF00000 + 0x00004000)
{
return(DataTCM[Address - 0xFFF00000]);
}
}
if (Type == CPUType.ARM9)
{
if (Address >= 0xFFFF0000)
{
return(BootROM9.BootROM[Address - 0xFFFF0000]);
}
}
else
{
if (Address >= 0xFFFF0000)
{
return(BootROM11.BootROM[Address - 0xFFFF0000]);
}
}
Logger.WriteInfo($"Read [{Type}] @ 0x{Address.ToString("X")}");
return(0);
}
protected override IOData Analysis(IO_SERVER server, IO_COMMUNICATION Communication, IO_DEVICE device, IO_PARA para, byte[] datas, DateTime datatime, object sender)
{
ParaPack commPack = new ParaPack(Communication.IO_COMM_PARASTRING);
ParaPack devicePack = new ParaPack(device.IO_DEVICE_PARASTRING);
IOData data = new IOData();
data.QualityStamp = QualityStamp.BAD;
if (device == null)
{
return(data);
}
if (para == null)
{
return(data);
}
if (sender == null)
{
return(data);
}
if (datas.Length <= 0)
{
return(data);
}
if (commPack.GetValue("数据格式") == "江苏协昌环保股份有限公司")
{
#region 江苏协昌环保股份有限公司
try
{
ParaPack paraPack = new ParaPack(para.IO_PARASTRING);
string deviceUid = devicePack.GetValue("设备识别号").Trim();
data.CommunicationID = Communication.IO_COMM_ID;
data.ID = device.IO_DEVICE_ADDRESS;
data.ParaName = para.IO_NAME;
data.ServerID = server.SERVER_ID;
data.Date = DateTime.Now;
string str = ScadaHexByteOperator.UTF8ByteToString(datas);
MqttJsonObject mqttJsonObject = (MqttJsonObject)sender;
if (mqttJsonObject != null && !string.IsNullOrEmpty(deviceUid) && mqttJsonObject.device.uid.Trim() == deviceUid.Trim())
{
//由于一次性获取的是所有数据,所以需要解析所有数据
data.QualityStamp = QualityStamp.GOOD;
string jsonname = paraPack.GetValue("JSON名称").Trim();
string boardAddress = paraPack.GetValue("版子地址");
string boardIndex = paraPack.GetValue("版子索引号");
string port = paraPack.GetValue("端口号");
string portIndex = paraPack.GetValue("端口索引号");
string DataType = paraPack.GetValue("数据类型");
string valueIndex = paraPack.GetValue("采集值索引号");
if (mqttJsonObject.paras != null)
{
MqttJsonPara selectObj = mqttJsonObject.paras.Find(x => x.name.Trim() == jsonname.Trim());
if (selectObj != null)
{
if (selectObj.data != null && selectObj.data.Count > 0)
{
string date = selectObj.data[0].ToString();
try
{
///解析Json数据
DateTime?dateTime = GetDateTime(date);
if (dateTime != null)
{
string pboardAddress = selectObj.data[int.Parse(boardIndex)].ToString();
string pport = selectObj.data[int.Parse(portIndex)].ToString();
string value = selectObj.data[int.Parse(valueIndex)].ToString();
data.QualityStamp = QualityStamp.GOOD;
data.ParaValue = value;
data.Date = dateTime;
}
else
{
data.QualityStamp = QualityStamp.BAD;
data.ParaValue = data.QualityStampValue.ToString();
}
}
catch (Exception emx)
{
this.DeviceException(emx.Message);
data.QualityStamp = QualityStamp.BAD;
data.ParaValue = data.QualityStampValue.ToString();
}
}
}
else
{
data.QualityStamp = QualityStamp.BAD;
data.ParaValue = data.QualityStampValue.ToString();
}
}
}
else
{
data.QualityStamp = QualityStamp.BAD;
data.ParaValue = data.QualityStampValue.ToString();
}
}
catch (Exception emx)
{
data.QualityStamp = QualityStamp.BAD;
data.ParaValue = data.QualityStampValue.ToString();
this.DeviceException(emx.Message);
}
#endregion
}
else if (commPack.GetValue("数据格式") == "通用MQTT解析")
{
#region 通用MQTT解析
try
{
ParaPack paraPack = new ParaPack(para.IO_PARASTRING);
string deviceUid = devicePack.GetValue("设备ID编码").Trim();
data.CommunicationID = Communication.IO_COMM_ID;
data.ID = device.IO_DEVICE_ADDRESS;
data.ParaName = para.IO_NAME;
data.ServerID = server.SERVER_ID;
data.Date = DateTime.Now;
string str = ScadaHexByteOperator.UTF8ByteToString(datas);
CommonMqttJsonObject mqttJsonObject = (CommonMqttJsonObject)sender;
if (mqttJsonObject != null && !string.IsNullOrEmpty(deviceUid) && mqttJsonObject.device.uid.Trim() == deviceUid.Trim())
{
//由于一次性获取的是所有数据,所以需要解析所有数据
data.QualityStamp = QualityStamp.GOOD;
string jsonname = paraPack.GetValue("IO标识").Trim();
string timeIndex = paraPack.GetValue("时间值索引");
string DataType = paraPack.GetValue("数据类型");
string valueIndex = paraPack.GetValue("采集值索引");
if (DataType == "命令参数")
{
data.QualityStamp = QualityStamp.GOOD;
data.ParaValue = data.QualityStampValue.ToString();
return(data);
}
//采集参数
if (mqttJsonObject.paras != null)
{
CommonMqttJsonPara selectObj = mqttJsonObject.paras.Find(x => x.name.Trim() == jsonname.Trim());
if (selectObj != null)
{
if (selectObj.data != null && selectObj.data.Count > 0)
{
string date = selectObj.data.Count > (int.Parse(timeIndex) + 1)? selectObj.data[int.Parse(timeIndex)].ToString():DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss,f");
try
{
///解析Json数据
DateTime?dateTime = GetDateTime(date);
if (dateTime != null)
{
string value = selectObj.data.Count > (int.Parse(valueIndex) + 1) ? selectObj.data[int.Parse(valueIndex)].ToString():"-9999";
data.QualityStamp = value != "-9999"?QualityStamp.GOOD: QualityStamp.BAD;
data.ParaValue = value;
data.Date = dateTime;
}
else
{
data.QualityStamp = QualityStamp.BAD;
data.ParaValue = data.QualityStampValue.ToString();
}
}
catch (Exception emx)
{
this.DeviceException(emx.Message);
data.QualityStamp = QualityStamp.BAD;
data.ParaValue = data.QualityStampValue.ToString();
}
}
}
else
{
data.QualityStamp = QualityStamp.BAD;
data.ParaValue = data.QualityStampValue.ToString();
}
}
}
else
{
data.QualityStamp = QualityStamp.BAD;
data.ParaValue = data.QualityStampValue.ToString();
}
}
catch (Exception emx)
{
data.QualityStamp = QualityStamp.BAD;
data.ParaValue = data.QualityStampValue.ToString();
this.DeviceException(emx.Message);
}
#endregion
}
return(data);
}
public static string LoadBasicData(string id)
{
string message = "Sucussfully loaded data for ";
string _nseUrlIo = ConfigurationManager.AppSettings["NseUrlIO"].Replace("&", "&");
string _nseUrlBasic = ConfigurationManager.AppSettings["NseUrlBasic"].Replace("&", "&");
string _nifty50 = ConfigurationManager.AppSettings["nifty50"].Replace("&", "&");
string _allFO = ConfigurationManager.AppSettings["AllFO"].Replace("&", "&");
string _indexOnly = ConfigurationManager.AppSettings["IndexOnly"].Replace("&", "&");
string _banknifty = ConfigurationManager.AppSettings["Banknifty"].Replace("&", "&");
string _expiryDate = ConfigurationManager.AppSettings["ExpiryDate"];
string _masterDMAExcelSource = ConfigurationManager.AppSettings["MasterDMAExcelSource"];
string _TodayCSVFile = ConfigurationManager.AppSettings["TodayCSVFile"];
string _masterDatapathOI = ConfigurationManager.AppSettings["MasterDatapathOI"];
string _masterDatapathBasic = ConfigurationManager.AppSettings["MasterDatapathBasic"];
string _masterDatapathDMA = ConfigurationManager.AppSettings["MasterDatapathDMA"];
BulkEntity objData = new BulkEntity();
Dma objDma = new Dma();
OBJtoXML xmltoObj = new OBJtoXML();
try
{
string _list = "";
if (id.Contains("IndexOnly"))
{
_list = _indexOnly;
message = message + " IndexOnly,";
}
else if (id.Contains("Banknifty"))
{
_list = _banknifty;
message = message + " Banknifty,";
}
else if (id.Contains("nifty50"))
{
_list = _nifty50;
message = message + " nifty50,";
}
else
{
_list = _allFO;
message = message + " All listed items.,";
}
foreach (string item in id.Split(','))
{
if (item == "BasicData")
{
objData.BasicData = BasicData.ColletData(_nseUrlBasic, _list);
message = message + " BasicData,";
xmltoObj.CreateXML(objData.BasicData, _masterDatapathBasic, "basicdata", true);
//Need to implement this one when master data been ready
//List<KeyValue> objLtpPrices = GenerateLastPrices(objData.BasicData);
//objData.DMAData = objDma.GetDmaData(_masterDMAExcelSource, objLtpPrices, "");
//message = message + " DMA,";
//xmltoObj.CreateXML(objData.DMAData, _masterDatapathDMA, "dmadata", true);
}
if (item == "OI")
{
IOData objOI = new IOData();
objData.OIData = objOI.LoadOIData(_nseUrlIo, _expiryDate, _list);
message = message + " OI,";
xmltoObj.CreateXML(objData.OIData, _masterDatapathOI, "openinterest", true);
}
}
}
catch (Exception ex)
{
message = ex.Message;
}
return(message);
}
public string ProcessRequest(string id)
{
string message = "Sucussfully loaded data for ";
string _nseUrlIo = ConfigurationManager.AppSettings["NseUrlIO"].Replace("&", "&");
string _nseUrlBasic = ConfigurationManager.AppSettings["NseUrlBasic"].Replace("&", "&");
string _nifty50 = ConfigurationManager.AppSettings["nifty50"].Replace("&", "&");
string _allFO = ConfigurationManager.AppSettings["AllFO"].Replace("&", "&");
string _indexOnly = ConfigurationManager.AppSettings["IndexOnly"].Replace("&", "&");
string _banknifty = ConfigurationManager.AppSettings["Banknifty"].Replace("&", "&");
string _expiryDate = ConfigurationManager.AppSettings["ExpiryDate"];
string _masterDMAExcelSource = ConfigurationManager.AppSettings["MasterDMAExcelSource"];
string _TodayCSVFile = ConfigurationManager.AppSettings["TodayCSVFile"];
string _masterDatapathOI = ConfigurationManager.AppSettings["MasterDatapathOI"];
string _masterDatapathBasic = ConfigurationManager.AppSettings["MasterDatapathBasic"];
string _masterDatapathDMA = ConfigurationManager.AppSettings["MasterDatapathDMA"];
BulkEntity objData = new BulkEntity();
Dma objDma = new Dma();
OBJtoXML xmltoObj = new OBJtoXML();
try
{
string _list = "";
if (id.Contains("IndexOnly"))
{
_list = _indexOnly;
message = message + " IndexOnly,";
}
else if (id.Contains("Banknifty"))
{
_list = _banknifty;
message = message + " Banknifty,";
}
else if (id.Contains("nifty50"))
{
_list = _nifty50;
message = message + " nifty50,";
}
else
{
_list = _allFO;
message = message + " All listed items.,";
}
foreach (string item in id.Split(','))
{
if (item == "BasicData")
{
objData.BasicData = BasicData.ColletData(_nseUrlBasic, _list);
message = message + " BasicData,";
xmltoObj.CreateXML(objData.BasicData, _masterDatapathBasic, "BasicData", false);
List <KeyValue> objLtpPrices = GenerateLastPrices(objData.BasicData);
objData.DMAData = objDma.GetDmaData(_masterDMAExcelSource, objLtpPrices, "");
message = message + " DMA,";
xmltoObj.CreateXML(objData.DMAData, _masterDatapathDMA, "DMAData", false);
}
if (item == "DMA")
{
//DMA moved to Basic data refresh, when you click referesh request for the
//basic data then system refresh DMA data also
//So, no need to saparate request for the DMA.
//Presently signing off the DMA refresh option based on the data.csv file
objData.DMAData = objDma.GetDmaData(_masterDMAExcelSource, _TodayCSVFile, "");
message = message + " DMA,";
xmltoObj.CreateXML(objData.DMAData, _masterDatapathDMA, "DMAData", false);
}
if (item == "OI")
{
IOData objOI = new IOData();
objData.OIData = objOI.LoadOIData(_nseUrlIo, _expiryDate, _list);
message = message + " OI,";
xmltoObj.CreateXML(objData.OIData, _masterDatapathOI, "OIData", false);
}
}
}
catch (Exception ex)
{
message = ex.Message;
}
return(message);
}
public void ClearData()
{
data = new IOData();
data.isChanged = true;
this.AutoSave();
}
private IOSystem()
{
data = new IOData();
}
/// <summary>
/// Handle the input API call.
/// </summary>
/// <param name="request">The request object for the API call</param>
/// <returns>The input response</returns>
public APIResponse Handle(APIRequest request)
{
_log.Trace($"Handle input from client. Content-Type is '{request.Headers.ContentType}'");
var response = new APIResponse();
// Check the Content-Type
// If it is application/json
// TODO: if will be parsed into IOData that may contain multiple
// TODO: Define custom JSON? application/vnd.limitless.input+json?
// inputs.
if (request.Headers.ContentType == MimeType.Json)
{
_log.Debug("Received JSON, parse into usable type");
throw new NotImplementedException("JSON received. Needs to be parsed into usable type");
}
// Find out what Mime/Language input combinations are supported by the interaction engine
// This will determine what the input pipeline should attempt to produce
// TODO: Support multiple IO combinations for more advanced engines
SupportedIOCombination engineCombinations = _engine.GetSupportedIOCombinations().First();
// TODO: Resolve multi-request parallel - ie. speech recognition + voice recognition id
// Attempt to process input to reach the engineCombinations
var ioData = new IOData(new MimeLanguage(request.Headers.ContentType, request.Headers.RequestLanguage), request.Data);
ioData = Resolve(ioData, engineCombinations.SupportedInput, _inputProviders);
// Let the engine do its thing
ioData = _engine.ProcessInput(ioData);
// TODO Find solution to multiple accepted languages
// What is the client expecting in return
Tuple <string, decimal> preferredMime = request.Headers.Accept.OrderByDescending(x => x.Item2).First();
// Multiple languages could be present, this selects the language with the highest weighted value
// More on languages and weighted values: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Language
// The tuple contains <language,weight>
Tuple <string, decimal> preferredLanguage = request.Headers.AcceptLanguage.OrderByDescending(x => x.Item2).First();
ioData = Resolve(ioData, new MimeLanguage(preferredMime.Item1, preferredLanguage.Item1), _outputProviders);
// Set the headers for the data.
// TODO: In future this will be part of the response
// not just a list.
response.Data = ioData.Data;
var header = new
{
Header = "Content-Type",
Value = ioData.MimeLanguage.Mime
};
response.Headers.Add(header);
header = new
{
Header = "Language",
Value = ioData.MimeLanguage.Language
};
response.Headers.Add(header);
return(response);
}
/// <summary>
/// Recursively processes the input until a usable data type is extracted
/// or LimitlessSettings MaxResolveAttempts is reached
/// </summary>
/// <param name="input">The input data</param>
/// <param name="preferredOutput">The preferred output Mime and Language</param>
/// <param name="providers">The providers available to process input</param>
/// <param name="resolveAttempts">The maximum attempts to extract usable data from input</param>
/// <returns>The processed data from the pipeline</returns>
private IOData Resolve(IOData input, MimeLanguage preferredOutput, List <IIOProcessor> providers, int resolveAttempts = 0)
{
/* Resolving the input provider to use happens in the following order
* 1. Use the first provider that matches both input and preferredOutput
* 2. Use the first provider that matches input and preferredOutput.Language[0,2]
* 3. Use the first provider that matches input.Language[0,2] and preferredOutput.Language[0,2]
* 4. Use the first provider that matched input and output Mimes
* 5. Fail
*/
// TODO: Add support for wildcard mime and language */*
// Get a copy of the list so that we don't change the instance list
providers = new List <IIOProcessor>(providers);
if (resolveAttempts >= CoreContainer.Instance.Settings.Core.MaxResolveAttempts)
{
throw new NotSupportedException("Maximum attempts reached for providing data in the preferred format");
}
//Use the first provider that matches both input and preferredOutput
var availableProviders = providers.Where(
x => x.GetSupportedIOCombinations().Count
(
y => y.SupportedInput.Mime == input.MimeLanguage.Mime && y.SupportedInput.Language == input.MimeLanguage.Language &&
y.SupportedOutput.Mime == preferredOutput.Mime && y.SupportedOutput.Language == preferredOutput.Language
) > 0);
if (availableProviders.Count <IIOProcessor>() == 0)
{
availableProviders = providers.Where(
x => x.GetSupportedIOCombinations().Count
(
y => y.SupportedInput.Mime == input.MimeLanguage.Mime && y.SupportedInput.Language == input.MimeLanguage.Language &&
y.SupportedOutput.Mime == preferredOutput.Mime && y.SupportedOutput.Language == preferredOutput.Language.Substring(0, 2)
) > 0);
}
if (availableProviders.Count <IIOProcessor>() == 0)
{
availableProviders = providers.Where(
x => x.GetSupportedIOCombinations().Count
(
y => y.SupportedInput.Mime == input.MimeLanguage.Mime && y.SupportedInput.Language == input.MimeLanguage.Language.Substring(0, 2) &&
y.SupportedOutput.Mime == preferredOutput.Mime && y.SupportedOutput.Language == preferredOutput.Language.Substring(0, 2)
) > 0);
}
if (availableProviders.Count <IIOProcessor>() == 0)
{
availableProviders = providers.Where(
x => x.GetSupportedIOCombinations().Count
(
y => y.SupportedInput.Mime == input.MimeLanguage.Mime && y.SupportedOutput.Mime == preferredOutput.Mime
) > 0);
}
// Nothing matched
if (availableProviders.Count <IIOProcessor>() == 0)
{
_log.Trace($"No provider available for input types '{input.MimeLanguage}' providing output types '{preferredOutput}'. Returning current");
return(input);
}
_log.Trace($"Found {availableProviders.Count<IIOProcessor>()} provider(s) for input {input.MimeLanguage} and output {preferredOutput}");
var provider = availableProviders.First();
// After process is done the output becomes the
// input for the next provider
input = provider.Process(input, preferredOutput);
if (input == null)
{
throw new NullReferenceException($"Provider '{provider.GetType().Name}' returned a null result for input '{input.MimeLanguage}'");
}
resolveAttempts++;
if (providers.Remove(provider))
{
Resolve(input, preferredOutput, providers, resolveAttempts);
}
else
{
throw new InvalidOperationException($"The provider '{provider.GetType().Name}' could not be removed from the available list");
}
// In theory this will never be reached
// Why?
// If the mime type is not supported, we return
// If the output is null, we return
return(input);
}
public static void IRQ_IE(IOData Data)
{
Logger.WriteStub("Stubbed.");
Data.Read32 = 0xFF;
}
