public void RequestPlcDataToDB(string strJsonText)
{
try
{
if (!string.IsNullOrEmpty(strJsonText))
{
int receiveNumber = strJsonText.Length;
DataLogHelper logHelper = new DataLogHelper();
logHelper.SocketLog(strJsonText, receiveNumber);
#region 对接收到的传感器日志数据进行转换操作
try
{
HNFactoryAutoSystem.Business.DeviceBusiness deviceBusiness = new HNFactoryAutoSystem.Business.DeviceBusiness();
SensorDataCollection datas = JsonConvert.DeserializeObject <SensorDataCollection>(strJsonText);
//将传感器读取的数据写入生产日志表
foreach (SensorData data in datas)
{
//判断值类型来提取传感器的状态信息
string strDeviceStatus = "P";
string strSensorId = data.SensorId;
string strSensorValueType = data.ValueType;
decimal deParValue = data.SensorValue;
deviceBusiness.AddDeviceProduceLog(strDeviceStatus, strSensorId, strSensorValueType, deParValue);
}
}
catch { }
#endregion
}
}
catch { }
}
private void button2_Click(object sender, EventArgs e)
{
if (!string.IsNullOrEmpty(textBox1.Text))
{
DataLogHelper logHelper = new DataLogHelper();
Business.DeviceBusiness deviceBusiness = new Business.DeviceBusiness();
string strText = textBox1.Text;
int receiveNumber = strText.Length;
if (!string.IsNullOrEmpty(strText))
{
logHelper.SocketLog(strText, receiveNumber);
#region 对接收到的传感器日志数据进行转换操作
try
{
SensorDataCollection datas = JsonConvert.DeserializeObject <SensorDataCollection>(strText);
//将传感器读取的数据写入生产日志表
foreach (SensorData data in datas)
{
//判断值类型来提取传感器的状态信息
string strDeviceStatus = "P";
string strSensorId = data.SensorId;
string strSensorValueType = data.ValueType;
decimal deParValue = data.SensorValue;
deviceBusiness.AddDeviceProduceLog(strDeviceStatus, strSensorId, strSensorValueType, deParValue);
}
}
catch { }
#endregion
}
}
}
/// <summary>
/// Create data in bulk, overwriting data that was already there, if any
/// </summary>
/// <param name="sensor"></param>
/// <param name="data_to_save"></param>
public void CreateData(ISensor sensor, SensorDataCollection data_to_save)
{
// Find the sensor file
string fn = GetFilename(sensor);
if (File.Exists(fn))
{
File.Delete(fn);
}
// Convert to an array to avoid list conflicts
var array = data_to_save.Data.ToArray();
array.WriteToStream(fn, true);
}
/// <summary>
/// 将数据保存起来并发送给后台服务
/// </summary>
/// <param name="data"></param>
private void RequestToDB(byte[] data)
{
//地址起点
#region 对寄存器数据进行按需提取
int iIndex = 0;
SensorDataCollection sensorDatas = new SensorDataCollection();
foreach (PLCAddressSet addressSet in AddressSets)
{
byte[] btInfo = new byte[addressSet.ValueLength];
if (data.Length > iIndex)
{
try
{
//按指定的寄存器地址来提取数据
Array.Copy(data, iIndex, btInfo, 0, addressSet.ValueLength);
//针对提取出来的数据，进行解码操作
string strBxString = ConvertTools.BytesToHexString(btInfo);
decimal deValue = decimal.Zero;
deValue = Convert.ToInt32(strBxString, 16);
//如果是过程值数据需要对参数进行缩放
if (addressSet.ValueType == "NumberValue")
{
deValue *= addressSet.Scale;
}
SensorData sensorData = new SensorData()
{
FactoryId = addressSet.FactoryId,
PLCId = addressSet.PLC_Id,
PLCAddress = addressSet.PLC_Address,
SensorId = addressSet.SensorId,
ValueType = addressSet.ValueType,
SensorValue = Convert.ToDecimal(strBxString),
ReceiveTime = DateTime.Now
};
sensorDatas.Add(sensorData);
}
catch { }
//更新下一个寄存器起点
iIndex += addressSet.ValueLength;
}
}
#endregion
#region 读取总记录写入数据库
//string strMessage = Encoding.ASCII.GetString(data);
string strMessage = string.Format("[{0}]读取设备数据完成", _typeStr);
ModbusMessageLog logitem = new ModbusMessageLog()
{
LogTime = DateTime.Now,
LogMessage = strMessage,
FunctionCode = FunctionCode.Read.ToString(),
MessageFrame = data,
ProtocolDataUnit = data,
SlaveAddress = _startaddress.ToString(),
TransactionId = Wrapper.CurrentDataIndex.ToString()
};
DataLogHelper.AddModbusMessageLog(logitem);
#endregion
//将数据传入后台处理
string strToText = sensorDatas.ToJsonString();
SendToSocketServer(strToText);
}
private void DrawToImage()
{
// Kick out if we just don't have anything worthwhile
if (_width <= 0 || _height <= 0 || _sensor == null || _datastore == null)
{
return;
}
var start = DateTime.UtcNow;
// Figure out window
_max_date = DateTime.UtcNow;
_min_date = _max_date;
_chart_rect = new Rectangle()
{
X = 5, Y = 5, Width = _width - 10, Height = _height - 10
};
_min_value = decimal.MaxValue;
_max_value = decimal.MinValue;
_range_in_value = 100.0;
// If there's an artificial limitation on the time window, use that instead
if (_chartTimeframe == ViewTimeframe.AllTime)
{
if (_raw_data != null && _raw_data.Data.Count > 0)
{
_min_date = (from r in _raw_data.Data select r.Time).Min();
}
else
{
_min_date = _max_date.AddHours(-1);
}
}
else
{
_min_date = _max_date.AddMinutes(-(int)_chartTimeframe);
}
_range_in_seconds = (double)(_max_date - _min_date).TotalSeconds;
// Filter data by time
if (_raw_data == null)
{
_raw_data = _datastore.RetrieveData(_sensor, _min_date, _max_date, true);
}
_filtered = (from r in _raw_data.Data where r.Time > _min_date && r.Time < _max_date orderby r.Time ascending select r).ToList();
if (_filtered.Any())
{
// Range checks and clamping
_min_value = (from r in _filtered select r.Value).Min();
_max_value = (from r in _filtered select r.Value).Max();
if (_min_value > 0)
{
_min_value = 0;
}
if (_max_value < 0)
{
_max_value = 0;
}
// Increase the maximum slightly so we can see the peak
if (_max_value > 0m)
{
_max_value = _max_value * 1.03m;
}
_range_in_value = (double)(_max_value - _min_value);
}
// New version of drawing code does it all ourselves
Bitmap bmp = new Bitmap(_width, _height);
Graphics g = Graphics.FromImage(bmp);
g.FillRectangle(Brushes.White, new Rectangle(new Point(0, 0), new Size(_width, _height)));
g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
//System.Diagnostics.Debug.WriteLine("Startup chart in " + (DateTime.UtcNow - start).ToString());
// We have a 5px border around each edge, and remember the positions
Pen black = new Pen(Color.Black);
g.DrawRectangle(black, _chart_rect);
//System.Diagnostics.Debug.WriteLine("Rectangle in " + (DateTime.UtcNow - start).ToString());
// Only draw something if values make sense
if (_range_in_value > 0 && _range_in_seconds > 0)
{
DrawGraphLines(g);
//System.Diagnostics.Debug.WriteLine("GraphLines in " + (DateTime.UtcNow - start).ToString());
DrawSensorData(g);
//System.Diagnostics.Debug.WriteLine("SensorData in " + (DateTime.UtcNow - start).ToString());
}
// Save this to a temporary filename
g.Dispose();
_chart_image = bmp;
//System.Diagnostics.Debug.WriteLine("Updated chart in " + (DateTime.UtcNow - start).ToString());
Notify("ChartImage");
}
public SensorDataCollection RetrieveData(ISensor sensor, DateTime?start_date = null, DateTime?end_date = null, bool fetch_exceptions = false)
{
var data = new SensorDataCollection();
data.StartDate = start_date ?? DateTime.MinValue;
data.EndDate = end_date ?? DateTime.MaxValue;
data.Data = new List <SensorData>();
data.Exceptions = new List <SensorException>();
// Check to see if this sensor filename exists
string fn = GetFilename(sensor);
if (File.Exists(fn))
{
// Construct a new CSVReader and be careful about this
using (var csv = new CSVReader(fn, ',', '\"', false)) {
foreach (string[] line in csv)
{
if (line != null && line.Length >= 2)
{
DateTime t = DateTime.MinValue;
Decimal val;
// Load the measurement time if present
int ms = 0;
if (line.Length >= 3)
{
int.TryParse(line[2], out ms);
}
// Save values
if (DateTime.TryParse(line[0], out t) && Decimal.TryParse(line[1], out val))
{
// Only load the specific timeframe
if (t < data.StartDate || t > data.EndDate)
{
continue;
}
// Load the exception if asked
if (fetch_exceptions)
{
if (line.Length >= 3)
{
SensorException e = new SensorException()
{
Description = line[2],
ExceptionTime = t
};
data.Exceptions.Add(e);
}
}
// Load the sensor data
SensorData sd = new SensorData()
{
Time = t,
Value = val,
CollectionTimeMs = ms
};
data.Data.Add(sd);
}
}
}
}
}
// Mark for lazy loading
return(data);
}
/// <summary>
/// Fetch some data for this sensor
/// </summary>
/// <param name="sensor"></param>
/// <param name="start_date"></param>
/// <param name="end_date"></param>
/// <param name="fetch_exceptions"></param>
/// <returns></returns>
public SensorDataCollection RetrieveData(ISensor sensor, DateTime?start_date = null, DateTime?end_date = null, bool fetch_exceptions = false)
{
// Create a new sensor data collection object
SensorDataCollection result = new SensorDataCollection();
result.StartDate = DateTime.MinValue;
result.EndDate = DateTime.MaxValue;
// Start the query process
using (var conn = new SQLiteConnection(_connstring)) {
conn.Open();
// Insert using raw compiled code
using (var cmd = conn.CreateCommand()) {
// Set up parameters
string[] parameter_names = new[] { "@sensor_id", "@start_date", "@end_date" };
DbParameter[] parameters = parameter_names.Select(pn =>
{
DbParameter parameter = cmd.CreateParameter();
parameter.ParameterName = pn;
cmd.Parameters.Add(parameter);
return(parameter);
}).ToArray();
// Next set up the actual query text
string measurement_query = @"SELECT measurement_time, value, collection_time_ms FROM measurements WHERE sensor_id = @sensor_id";
string exception_query = @"SELECT exception_time, exception_text, stacktrace, cleared FROM exceptions WHERE sensor_id = @sensor_id";
parameters[0].Value = sensor.Identity;
if (start_date != null && start_date.HasValue)
{
measurement_query += " AND measurement_time >= @start_date";
exception_query += " AND exception_time >= @start_date";
parameters[1].Value = start_date.Value.Ticks;
result.StartDate = start_date.Value;
}
if (end_date != null && end_date.HasValue)
{
measurement_query += " AND measurement_time <= @end_date";
exception_query += " AND exception_time <= @end_date";
parameters[2].Value = end_date.Value.Ticks;
result.EndDate = end_date.Value;
}
// Now query for measurements
cmd.CommandText = measurement_query;
using (var dr = cmd.ExecuteReader()) {
while (dr.Read())
{
SensorData sd = new SensorData();
sd.Time = new DateTime(dr.GetInt64(0));
sd.Value = dr.GetDecimal(1);
sd.CollectionTimeMs = dr.GetInt32(2);
result.Data.Add(sd);
}
}
// Now reset the query for the exceptions table
cmd.CommandText = exception_query;
using (var dr = cmd.ExecuteReader()) {
while (dr.Read())
{
SensorException se = new SensorException();
se.ExceptionTime = new DateTime(dr.GetInt64(0));
se.Description = dr.GetString(1);
se.StackTrace = dr.GetString(2);
se.Cleared = (dr.GetInt32(3) == 1);
result.Exceptions.Add(se);
}
}
}
}
return(result);
}
/// <summary>
/// Create data in bulk, overwriting any previous data if any existed
/// </summary>
/// <param name="sensor"></param>
/// <param name="data_to_save"></param>
public void CreateData(ISensor sensor, SensorDataCollection data_to_save)
{
// Now insert using SQLite/Dapper
InsertItems(sensor.Identity, data_to_save.Data);
}
/// <summary>
/// 接收消息
/// </summary>
/// <param name="clientSocket"></param>
private void ReceiveMessage(object clientSocket)
{
Socket myClientSocket = (Socket)clientSocket;
while (true)
{
try
{
byte[] buffer = new byte[1024 * 1024 * 2];
//实际接受到的有效字节数
int receiveNumber = myClientSocket.Receive(buffer);
if (receiveNumber == 0)
{
break;
}
//string strInfo = string.Format("接收客户端{0}消息{1}", myClientSocket.RemoteEndPoint.ToString(), Encoding.ASCII.GetString(result, 0, receiveNumber));
string strInfo = Encoding.UTF8.GetString(buffer, 0, receiveNumber);
string[] strTexts = strInfo.Split('|');
////通过clientSocket接收数据
//int receiveNumber = myClientSocket.Receive(result);
//string strInfo = string.Format("接收客户端{0}消息{1}", myClientSocket.RemoteEndPoint.ToString(), Encoding.ASCII.GetString(result, 0, receiveNumber));
////MessageBox.Show(strInfo);
DataLogHelper logHelper = new DataLogHelper();
Business.DeviceBusiness deviceBusiness = new Business.DeviceBusiness();
foreach (string strText in strTexts)
{
if (!string.IsNullOrEmpty(strText))
{
logHelper.SocketLog(strText, receiveNumber);
#region 对接收到的传感器日志数据进行转换操作
try
{
SensorDataCollection datas = JsonConvert.DeserializeObject <SensorDataCollection>(strText);
//将传感器读取的数据写入生产日志表
foreach (SensorData data in datas)
{
//判断值类型来提取传感器的状态信息
string strDeviceStatus = "P";
string strSensorId = data.SensorId;
string strSensorValueType = data.ValueType;
decimal deParValue = data.SensorValue;
deviceBusiness.AddDeviceProduceLog(strDeviceStatus, strSensorId, strSensorValueType, deParValue);
}
}
catch { }
#endregion
}
}
}
catch (Exception ex)
{
//Console.WriteLine(ex.Message);
//ServerMainFormtxt_Log.AppendText(ex.Message + "\r \n");
myClientSocket.Shutdown(SocketShutdown.Both);
myClientSocket.Close();
break;
}
}
}
