public ModuleObject(string displayName, UserControl contentControl, IValueHelper<bool> canSaveHelper)
{
DisplayName = displayName;
ContentControl = contentControl;
IsAvailableHelper = new ValueHelper<bool>() { Value = true/*Starts available by default*/ };
CanSaveHelper = canSaveHelper;
}
private static void server_OnReceive(ValueHelper.ValueSocket.SocketEvents.ReceiveEventArgs e)
{
Console.WriteLine(Encoding.UTF8.GetString(e.Data));
Boolean result = server.Send(e.Socket, e.Data);
if (!result)
Console.WriteLine("失败");
}
public IISWebApplication()
{
PhysicalPathHelper = new ValueHelper<string>();
IISEnableDirBrowsing = true;
IISAccessRead = true;
IISAccessExecute = true;
IISAccessWrite = true;
IISAccessScript = true;
IISDefaultDoc = "index.aspx,index.html,index.htm,default.aspx";
InitializeComponent();
}
public ConnectionStringHelper(IValueHelper<string> valueHelper)
{
ValueHelper = valueHelper;
ServerHelper = new ValueHelper<string>();
DatabaseHelper = new ValueHelper<string>();
UserHelper = new ValueHelper<string>();
PasswordHelper = new ValueHelper<string>();
ValueHelper.ValueChanged += ParseConnectionString;
ParseConnectionString();
ServerHelper.ValueChanged += ()=> { SetValue( KeysServer, ServerHelper.Value ); };
DatabaseHelper.ValueChanged += ()=> { SetValue( KeysDatabase, DatabaseHelper.Value ); };
UserHelper.ValueChanged += ()=> { SetValue( KeysUser, UserHelper.Value ); };
PasswordHelper.ValueChanged += ()=> { SetValue( KeysPassword, PasswordHelper.Value ); };
}
protected override Range <IComparable> IRangeProviderGetRange(IRangeConsumer rangeConsumer)
{
if (rangeConsumer == ActualDependentAxis)
{
var dependentValuesByIndependentValue = IndependentValueDependentValues.Select(e => e.ToArray()).ToArray();
var mostNegative = dependentValuesByIndependentValue
.Select(g => g.Where(v => v < 0)
.Sum())
.Where(v => v < 0)
.ToArray();
var leastNegative = dependentValuesByIndependentValue
.Select(g => g.Where(v => v <= 0)
.DefaultIfEmpty(1.0)
.First())
.Where(v => v <= 0)
.ToArray();
var mostPositive = dependentValuesByIndependentValue
.Select(g => g.Where(v => 0 < v)
.Sum())
.Where(v => 0 < v)
.ToArray();
var leastPositive = dependentValuesByIndependentValue
.Select(g => g.Where(v => 0 <= v)
.DefaultIfEmpty(-1.0)
.First())
.Where(v => 0 <= v)
.ToArray();
// Compute minimum
double minimum = 0;
if (mostNegative.Any())
{
minimum = mostNegative.Min();
}
else if (leastPositive.Any())
{
minimum = leastPositive.Min();
}
// Compute maximum
double maximum = 0;
if (mostPositive.Any())
{
maximum = mostPositive.Max();
}
else if (leastNegative.Any())
{
maximum = leastNegative.Max();
}
if (IsStacked100)
{
minimum = Math.Min(minimum, 0);
maximum = Math.Max(maximum, 0);
}
return(new Range <IComparable>(minimum, maximum));
}
else if (rangeConsumer == ActualIndependentAxis)
{
// Using a non-ICategoryAxis for the independent axis
// Need to specifically adjust for slot size of bars/columns so they don't overlap
// Note: Calculation for slotSize is not perfect, but it's quick, close, and errs on the safe side
Range <IComparable> range = base.IRangeProviderGetRange(rangeConsumer);
int count = Math.Max(IndependentValueGroups.Count(), 1);
if (ActualIndependentAxis.CanPlot(0.0))
{
double minimum = ValueHelper.ToDouble(range.Minimum);
double maximum = ValueHelper.ToDouble(range.Maximum);
double slotSize = (maximum - minimum) / count;
return(new Range <IComparable>(minimum - slotSize, maximum + slotSize));
}
else
{
DateTime minimum = ValueHelper.ToDateTime(range.Minimum);
DateTime maximum = ValueHelper.ToDateTime(range.Maximum);
TimeSpan slotSize = TimeSpan.FromTicks((maximum - minimum).Ticks / count);
return(new Range <IComparable>(minimum - slotSize, maximum + slotSize));
}
}
else
{
return(base.IRangeProviderGetRange(rangeConsumer));
}
}
static void client_OnReceive(ValueHelper.ValueSocket.SocketEvents.ReceiveEventArgs e)
{
Console.WriteLine(Encoding.UTF8.GetString(e.Data)); ;
}
protected override void UpdateView(DataPoint dataPoint)
{
if (!this.IsDataPointViewVisible(dataPoint))
{
return;
}
DateTime now = DateTime.Now;
XYDataPoint xyDataPoint = dataPoint as XYDataPoint;
if (xyDataPoint != null && this.CanGraph(xyDataPoint))
{
DataPointView view = dataPoint.View;
if (view != null)
{
FrameworkElement mainView = view.MainView;
if (mainView != null)
{
bool flag = this.ChartArea.Orientation != Orientation.Horizontal;
RectOrientation rectOrientation = RectOrientation.BottomTop;
Point positionInAxisUnits = this.GetPositionInAxisUnits(xyDataPoint);
Point point1 = new Point(Math.Round(positionInAxisUnits.X), Math.Round(positionInAxisUnits.Y));
object crossingPosition = this.Series.YAxis.Scale.ActualCrossingPosition;
Point basePoint = new Point(positionInAxisUnits.X, this.Series.YAxis.AxisPresenter.ConvertDataToAxisUnits(crossingPosition) ?? 0.0);
Point point2 = new Point(Math.Round(basePoint.X), Math.Round(basePoint.Y));
double num1 = point1.X + Math.Round(this.PointClusterOffset);
double num2 = this.MinMaxScreenCoordinates(positionInAxisUnits.Y);
double num3 = Math.Round(this.PointWidth);
double height = this.MinMaxScreenCoordinates(basePoint.Y - positionInAxisUnits.Y);
if (ValueHelper.Compare(xyDataPoint.YValue as IComparable, crossingPosition as IComparable) != 0 && Math.Abs(height) < 2.0 && this.CanAdjustHeight())
{
height = basePoint.Y - positionInAxisUnits.Y >= 0.0 ? 2.0 : -2.0;
num2 = point2.Y - height;
}
if (height < 0.0)
{
rectOrientation = RectOrientation.TopBottom;
height = Math.Abs(height);
num2 -= height;
}
double num4 = this.MinMaxScreenCoordinates(this.GetYOffsetInAxisUnits(xyDataPoint, positionInAxisUnits, basePoint));
double num5 = Math.Round(num2 - num4);
double num6 = this.AdjustColumnHeight(height);
if (flag)
{
if (rectOrientation == RectOrientation.BottomTop)
{
rectOrientation = RectOrientation.RightLeft;
}
else if (rectOrientation == RectOrientation.TopBottom)
{
rectOrientation = RectOrientation.LeftRight;
}
Canvas.SetLeft((UIElement)mainView, num5);
Canvas.SetTop((UIElement)mainView, num1);
mainView.Width = num6;
mainView.Height = num3;
view.AnchorRect = new Rect(num5, num1, num6, num3);
view.AnchorPoint = rectOrientation != RectOrientation.RightLeft ? new Point(num5 + num6, num1 + this.PointWidth / 2.0) : new Point(num5, num1 + this.PointWidth / 2.0);
}
else
{
Canvas.SetLeft((UIElement)mainView, num1);
Canvas.SetTop((UIElement)mainView, num5);
mainView.Width = num3;
mainView.Height = num6;
view.AnchorRect = new Rect(num1, num5, num3, num6);
view.AnchorPoint = rectOrientation != RectOrientation.BottomTop ? new Point(num1 + this.PointWidth / 2.0, num5 + num6) : new Point(num1 + this.PointWidth / 2.0, num5);
}
BarControl barControl = mainView as BarControl;
if (barControl != null)
{
barControl.Orientation = rectOrientation;
}
view.AnchorRectOrientation = rectOrientation;
}
}
}
base.UpdateView(dataPoint);
if (this.ChartArea == null)
{
return;
}
this.ChartArea.UpdateSession.AddCounter("ColumnSeriesPresenter.UpdateView", DateTime.Now - now);
}
public void ParseResult(ref SensorAcqResult rawData)
{
byte[] data = rawData.Response;
rawData.ErrorCode = IsValid(data);
if ((int)Errors.SUCCESS != rawData.ErrorCode)
{
return;
}
var module = ValueHelper.GetShort_BE(data, IDX_DevId);
if (module != rawData.Sensor.ModuleNo)
{
rawData.ErrorCode = (int)Errors.ERR_INVALID_MODULE;
return;
}
if (data[IDX_CMD] == 0xC0)
{
rawData.ErrorCode = ModbusErrorCode.GetErrorCode(data[IDX_CMD + 1]);
return;
}
var channel = data[IDX_CMD + 1];
if (channel == 0)
{
channel = 1;
}
if (channel != rawData.Sensor.ChannelNo)
{
rawData.ErrorCode = (int)Errors.ERR_RECEIVED_CH;
return;
}
var freState = data[IDX_DataField + 2] & 0x000f;
var tempState = data[IDX_DataField + 2] & 0xfff0;
if (freState != 0 || tempState != 0)
{
if (freState != 0 && tempState != 0)
{
rawData.ErrorCode = (int)Errors.ERR_VIBRW_FREWIRE_TEMPWIRE;
return;
}
if (freState != 0)
{
rawData.ErrorCode = (int)Errors.ERR_VIBRW_FREWIRE;
return;
}
rawData.ErrorCode = (int)Errors.ERR_VIBRW_TEMPWIRE;
return;
}
try
{
// TODO 大字序 FLOAT
var frequency = ValueHelper.GetFloat_BE(data, IDX_DataField + 3);
var am = ValueHelper.GetFloat_BE(data, IDX_DataField + 7);
var temperature = ValueHelper.GetFloat_BE(data, IDX_DataField + 11);
double physicalQuantity = 0;
double colphy = 0;
double k = 0;
double f0 = 0;
double kt = 0;
double t0 = 0;
if (rawData.Sensor.Parameters.Count >= 4)
{
k = rawData.Sensor.Parameters[0].Value;
f0 = rawData.Sensor.Parameters[1].Value;
kt = rawData.Sensor.Parameters[2].Value;
t0 = rawData.Sensor.Parameters[3].Value;
}
switch (rawData.Sensor.FormulaID)
{
case 1:
colphy = physicalQuantity = (k * (Math.Pow(frequency, 2) - Math.Pow(f0, 2)) + kt * (temperature - t0));
break;
case 7:
double H = rawData.Sensor.Parameters[4].Value;
colphy = (k * (Math.Pow(f0, 2) - Math.Pow(frequency, 2)) + kt * (temperature - t0));
var h = colphy * 1000 / 9.8f;
physicalQuantity = (H + h);
break;
default:
physicalQuantity = (k * (Math.Pow(frequency, 2) - Math.Pow(f0, 2)) + kt * (temperature - t0));
colphy = physicalQuantity;
break;
}
var raws = new double[] { frequency, temperature };
var phys = new double[] { physicalQuantity };
var colphys = new double[] { colphy };
rawData.Data = new SensorData(raws, phys, colphys)
{
JsonResultData =
string.Format("{0}\"sensorId\":{1},\"data\":\"频率:{2} Hz,温度:{3} ℃\"{4}", '{', rawData.Sensor.SensorID,
frequency, temperature, '}')
};
}
catch (Exception ex)
{
rawData.ErrorCode = (int)Errors.ERR_DATA_PARSEFAILED;
_logger.ErrorFormat("ModBus VibratingWire sensor [id:{0},m:{1},ch:{4}] parsedfailed ,received bytes{3},ERROR : {2}", rawData.Sensor.SensorID, rawData.Sensor.ModuleNo, ex.Message, ValueHelper.BytesToHexStr(rawData.Response), rawData.Sensor.ChannelNo);
}
}
public void ParseResult(ref SensorAcqResult rawData)
{
byte[] data = rawData.Response;
rawData.ErrorCode = IsValid(data);
if ((int)Errors.SUCCESS != rawData.ErrorCode)
{
return;
}
int module = ValueHelper.GetShort_BE(data, IDX_SOURCE);
if (module != rawData.Sensor.ModuleNo)
{
rawData.ErrorCode = (int)Errors.ERR_INVALID_MODULE;
return;
}
int channel = Convert.ToInt16(data[IDX_CONTENT]);
if (channel != rawData.Sensor.ChannelNo)
{
rawData.ErrorCode = (int)Errors.ERR_RECEIVED_CH;
return;
}
try
{
float frequency = ValueHelper.GetFloat(data, IDX_FREDATA);
float temperature = ValueHelper.GetFloat(data, IDX_TEMPDATA);
double physicalQuantity = 0;
double colphy = 0;
double k = 0;
double f0 = 0;
double kt = 0;
double t0 = 0;
if (rawData.Sensor.Parameters.Count >= 4)
{
k = rawData.Sensor.Parameters[0].Value;
f0 = rawData.Sensor.Parameters[1].Value;
kt = rawData.Sensor.Parameters[2].Value;
t0 = rawData.Sensor.Parameters[3].Value;
}
switch (rawData.Sensor.FormulaID)
{
case 1:
physicalQuantity = (k * (Math.Pow(frequency, 2) - Math.Pow(f0, 2)) + kt * (temperature - t0));
colphy = physicalQuantity;
break;
case 7:
double H = rawData.Sensor.Parameters[4].Value;
var P = (k * (Math.Pow(f0, 2) - Math.Pow(frequency, 2)) + kt * (temperature - t0));
var h = P * 1000 / 9.8f;
physicalQuantity = (H + h);
colphy = P;
break;
case 17:
physicalQuantity = (k * (Math.Pow(f0, 2) - Math.Pow(frequency, 2)) + kt * (temperature - t0));
colphy = physicalQuantity;
break;
default:
physicalQuantity = (k * (Math.Pow(frequency, 2) - Math.Pow(f0, 2)) + kt * (temperature - t0));
colphy = physicalQuantity;
break;
}
var raws = new double[] { frequency, temperature };
var phys = new double[] { physicalQuantity };
var colphys = new double[] { colphy };
rawData.Data = new SensorData(raws, phys, colphys)
{
JsonResultData =
string.Format("{0}\"sensorId\":{1},\"data\":\"频率:{2} Hz,温度:{3} ℃\"{4}", '{', rawData.Sensor.SensorID,
frequency, temperature, '}')
};
}
catch (Exception ex)
{
rawData.ErrorCode = (int)Errors.ERR_DATA_PARSEFAILED;
_logger.ErrorFormat("VibratingWire sensor [id:{0},m:{1},ch:{4}] parsedfailed ,received bytes{3},ERROR : {2}", rawData.Sensor.SensorID, rawData.Sensor.ModuleNo, ex.Message, ValueHelper.BytesToHexStr(rawData.Response), rawData.Sensor.ChannelNo);
}
}
/// <summary>
/// Overrides the actual range to ensure that it is never set to an
/// empty range.
/// </summary>
/// <param name="range">The range to override.</param>
/// <returns>Returns the overridden range.</returns>
protected override Range <IComparable> OverrideDataRange(Range <IComparable> range)
{
range = base.OverrideDataRange(range);
if (!range.HasData)
{
return(new Range <IComparable>(0.0, 1.0));
}
else if (ValueHelper.Compare(range.Minimum, range.Maximum) == 0)
{
Range <IComparable> outputRange = new Range <IComparable>((ValueHelper.ToDouble(range.Minimum)) - 1, (ValueHelper.ToDouble(range.Maximum)) + 1);
return(outputRange);
}
// ActualLength of 1.0 or less maps all points to the same coordinate
if (range.HasData && this.ActualLength > 1.0)
{
bool isDataAnchoredToOrigin = false;
IList <ValueMarginCoordinateAndOverlap> valueMargins = new List <ValueMarginCoordinateAndOverlap>();
foreach (IValueMarginProvider valueMarginProvider in this.RegisteredListeners.OfType <IValueMarginProvider>())
{
foreach (ValueMargin valueMargin in valueMarginProvider.GetValueMargins(this))
{
IAnchoredToOrigin dataAnchoredToOrigin = valueMarginProvider as IAnchoredToOrigin;
isDataAnchoredToOrigin = (dataAnchoredToOrigin != null && dataAnchoredToOrigin.AnchoredAxis == this);
valueMargins.Add(
new ValueMarginCoordinateAndOverlap
{
ValueMargin = valueMargin,
});
}
}
if (valueMargins.Count > 0)
{
double maximumPixelMarginLength =
valueMargins
.Select(valueMargin => valueMargin.ValueMargin.LowMargin + valueMargin.ValueMargin.HighMargin)
.MaxOrNullable().Value;
// Requested margin is larger than the axis so give up
// trying to find a range that will fit it.
if (maximumPixelMarginLength > this.ActualLength)
{
return(range);
}
Range <double> originalRange = range.ToDoubleRange();
Range <double> currentRange = range.ToDoubleRange();
// Ensure range is not empty.
if (currentRange.Minimum == currentRange.Maximum)
{
currentRange = new Range <double>(currentRange.Maximum - 1, currentRange.Maximum + 1);
}
// priming the loop
double actualLength = this.ActualLength;
ValueMarginCoordinateAndOverlap maxLeftOverlapValueMargin;
ValueMarginCoordinateAndOverlap maxRightOverlapValueMargin;
UpdateValueMargins(valueMargins, currentRange.ToComparableRange());
GetMaxLeftAndRightOverlap(valueMargins, out maxLeftOverlapValueMargin, out maxRightOverlapValueMargin);
while (maxLeftOverlapValueMargin.LeftOverlap > 0 || maxRightOverlapValueMargin.RightOverlap > 0)
{
double unitOverPixels = currentRange.GetLength().Value / actualLength;
double newMinimum = currentRange.Minimum - ((maxLeftOverlapValueMargin.LeftOverlap + 0.5) * unitOverPixels);
double newMaximum = currentRange.Maximum + ((maxRightOverlapValueMargin.RightOverlap + 0.5) * unitOverPixels);
currentRange = new Range <double>(newMinimum, newMaximum);
UpdateValueMargins(valueMargins, currentRange.ToComparableRange());
GetMaxLeftAndRightOverlap(valueMargins, out maxLeftOverlapValueMargin, out maxRightOverlapValueMargin);
}
if (isDataAnchoredToOrigin)
{
if (originalRange.Minimum >= 0 && currentRange.Minimum < 0)
{
currentRange = new Range <double>(0, currentRange.Maximum);
}
else if (originalRange.Maximum <= 0 && currentRange.Maximum > 0)
{
currentRange = new Range <double>(currentRange.Minimum, 0);
}
}
return(currentRange.ToComparableRange());
}
}
return(range);
}
protected override string OnExecute()
{
//获取传入参数
HttpContext context = this.SpContext as HttpContext;
context.Response.ContentType = "text/html";
Dictionary <string, string> dic = new Dictionary <string, string>();
dic = RequestData.FromJson <Dictionary <string, string> >();
DataTable dtDetail = null;
SpRequestMsg pSpRequestMsg = new SpRequestMsg();
string pRequestguid = string.Empty;
string yhcid = string.Empty;
pRequestguid = dic["guid"] ?? ""; //
string pRequestxjnrjjl = dic["xjnrjjl"] ?? ""; //获取结论上报内容
string datesbsj = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"); //上报时间
string sqlSelectguid = "select max(cid) from p_gas_inspection_hidden"; //查询出隐患表的最大cid值
DataTable dtGetguid = new DataTable();
dtGetguid = ApplicationManager.DefaultConnection.QueryData(sqlSelectguid).Tables[0];
if (dtGetguid.Rows[0][0].ToString() == "")
{
yhcid = "1";
}
if (dtGetguid.Rows[0][0].ToString() != "")
{
int maxguid = Convert.ToInt32(dtGetguid.Rows[0][0]) + 1;
yhcid = Convert.ToString(maxguid);
}
if (string.IsNullOrEmpty(pRequestguid))
{
pSpRequestMsg.success = false;
pSpRequestMsg.message = "返回guid为空!";
pSpRequestMsg.data = "";
return(pSpRequestMsg.ToNormalJson());
}
SpPagingResponse pSpPagingResponse = new SpPagingResponse();
IUtilService service = SpServiceFactory.CreateUtilService();
try
{
SavePicAction savepic = new SavePicAction();
List <string> listImgeName = new List <string>();
listImgeName = savepic.SaveUploadFileList(context, "GasPhoto");
string NameImgs = "";
Log.Info("listImgeName:" + listImgeName.Count);
for (int i = 0; i < listImgeName.Count; i++)
{
if (listImgeName[i].ToString() == "")
{
}
else
{
NameImgs += listImgeName[i].ToString() + ";";
}
}
dtDetail = service.QueryInsertImageList(pRequestguid, NameImgs, pRequestxjnrjjl, datesbsj, yhcid);
pSpRequestMsg.success = true;
pSpRequestMsg.message = "上报信息成功";
pSpRequestMsg.data = dtDetail.ToJson();
pRequestguid = ValueHelper.DataTable2Json(dtDetail);
//Log.Info("结果:上报信息成功");
}
catch (Exception ex)
{
pSpRequestMsg.success = false;
pSpRequestMsg.message = "插入信息获取异常,详情" + ex.Message;
pSpRequestMsg.data = "";
Log.Error("插入信息详情获取异常:" + ex.Message.ToString());
return(pSpRequestMsg.ToNormalJson());
}
return(dtDetail.ToJsonStore(true, dtDetail.Rows.Count));
}
private const int IDX_FRAMETAIL_RESP = 27; // 帧尾=0xef
#region Implementation of ISensorAdapter
public void Request(ref SensorAcqResult sensorAcq)
{
try
{
if (sensorAcq.Sensor.ModuleNo > ushort.MaxValue || sensorAcq.Sensor.ModuleNo < ushort.MinValue)
{
sensorAcq.ErrorCode = (int)Errors.ERR_INVALID_MODULE;
sensorAcq.Request = null;
return;
}
var packet = new byte[19];
packet[IDX_FrameH] = 0xfe;
packet[IDX_FrameH + 1] = 0x46;
packet[IDX_FrameH + 2] = 0x41;
packet[IDX_FrameH + 3] = 0x53;
packet[IDX_FRAME_LEN] = 19;
ValueHelper.WriteUShort_BE(packet, IDX_DEST, (ushort)sensorAcq.Sensor.ModuleNo);
packet[IDX_CMD] = 0x01;
byte control = 0;
//int range = si.Parameters != null && si.ParamCount >= 3 ? (int) si.Parameters[3].Value : 1;
//Id Range
//1 0~5V
//2 -5~5V
//3 0~10V
//4 -10~10V
var range = (VoltageSensorRange)EnumHelper.GetItemFromDesc(typeof(VoltageSensorRange), sensorAcq.Sensor.ProductCode);
switch (range)
{
case VoltageSensorRange.FSLF10:
control = 0x40; // 0x47
break;
case VoltageSensorRange.FSLF25:
control = 0x41; // 0x4f
break;
case VoltageSensorRange.FSLF50:
control = 0x50; // 0x57
break;
case VoltageSensorRange.FSLF100:
control = 0x51; // 0x5f
break;
case VoltageSensorRange.FS_LFV_V0P5:
control = 0x40;
break;
case VoltageSensorRange.FS_LFV_V0P10:
control = 0x50;
break;
case VoltageSensorRange.FS_LFV_VM5P5:
control = 0x48;
break;
case VoltageSensorRange.FS_LFV_VM10P10:
control = 0x58;
break;
default:
control = 0x40;
break;
}
control = (byte)(control | (byte)(0x07 & (byte)(sensorAcq.Sensor.ChannelNo - 1)));
packet[IDX_CONTENT] = control;
packet[IDX_CONTENT + 1] = (byte)(sensorAcq.Sensor.ChannelNo);
packet[IDX_CHSUM_Req] = ValueHelper.CheckXor(packet, 0, IDX_CHSUM_Req);
packet[IDX_FRAMETAIL_REQ] = 0xef;
sensorAcq.ErrorCode = (int)Errors.SUCCESS;
sensorAcq.Request = packet;
}
catch
{
sensorAcq.Request = null;
sensorAcq.ErrorCode = (int)Errors.ERR_UNKNOW;
}
}
protected override void UpdateDataItemPlacement(IEnumerable <DefinitionSeries.DataItem> dataItems)
{
IAxis actualIndependentAxis = ActualIndependentAxis;
if ((null != ActualDependentAxis) && (null != actualIndependentAxis))
{
double plotAreaMaximumDependentCoordinate = ActualDependentAxis.GetPlotAreaCoordinate(ActualDependentRangeAxis.Range.Maximum).Value;
double zeroCoordinate = ActualDependentAxis.GetPlotAreaCoordinate(ActualDependentRangeAxis.Origin ?? 0.0).Value;
ICategoryAxis actualIndependentCategoryAxis = actualIndependentAxis as ICategoryAxis;
double nonCategoryAxisRangeMargin = (null != actualIndependentCategoryAxis) ? 0 : GetMarginForNonCategoryAxis(actualIndependentAxis);
foreach (IndependentValueGroup group in IndependentValueGroups)
{
Range <UnitValue> categoryRange = new Range <UnitValue>();
if (null != actualIndependentCategoryAxis)
{
categoryRange = actualIndependentCategoryAxis.GetPlotAreaCoordinateRange(group.IndependentValue);
}
else
{
UnitValue independentValueCoordinate = actualIndependentAxis.GetPlotAreaCoordinate(group.IndependentValue);
if (ValueHelper.CanGraph(independentValueCoordinate.Value))
{
categoryRange = new Range <UnitValue>(new UnitValue(independentValueCoordinate.Value - nonCategoryAxisRangeMargin, independentValueCoordinate.Unit), new UnitValue(independentValueCoordinate.Value + nonCategoryAxisRangeMargin, independentValueCoordinate.Unit));
}
}
if (categoryRange.HasData)
{
double categoryMinimumCoordinate = categoryRange.Minimum.Value;
double categoryMaximumCoordinate = categoryRange.Maximum.Value;
double padding = 0.1 * (categoryMaximumCoordinate - categoryMinimumCoordinate);
categoryMinimumCoordinate += padding;
categoryMaximumCoordinate -= padding;
double sum = IsStacked100 ?
group.DataItems.Sum(di => Math.Abs(ValueHelper.ToDouble(di.DataPoint.ActualDependentValue))) :
1;
if (0 == sum)
{
sum = 1;
}
double ceiling = 0;
double floor = 0;
foreach (DataItem dataItem in group.DataItems)
{
DataPoint dataPoint = dataItem.DataPoint;
double value = IsStacked100 ? (ValueHelper.ToDouble(dataPoint.ActualDependentValue) * (100 / sum)) : ValueHelper.ToDouble(dataPoint.ActualDependentValue);
if (ValueHelper.CanGraph(value))
{
double valueCoordinate = ActualDependentAxis.GetPlotAreaCoordinate(value).Value;
double fillerCoordinate = (0 <= value) ? ceiling : floor;
double topCoordinate = 0, leftCoordinate = 0, height = 0, width = 0, deltaCoordinate = 0;
if (AxisOrientation.Y == ActualDependentAxis.Orientation)
{
topCoordinate = plotAreaMaximumDependentCoordinate - Math.Max(valueCoordinate + fillerCoordinate, zeroCoordinate + fillerCoordinate);
double bottomCoordinate = plotAreaMaximumDependentCoordinate - Math.Min(valueCoordinate + fillerCoordinate, zeroCoordinate + fillerCoordinate);
deltaCoordinate = bottomCoordinate - topCoordinate;
height = (0 < deltaCoordinate) ? deltaCoordinate + 1 : 0;
leftCoordinate = categoryMinimumCoordinate;
width = categoryMaximumCoordinate - categoryMinimumCoordinate + 1;
}
else
{
leftCoordinate = Math.Min(valueCoordinate + fillerCoordinate, zeroCoordinate + fillerCoordinate);
double rightCoordinate = Math.Max(valueCoordinate + fillerCoordinate, zeroCoordinate + fillerCoordinate);
deltaCoordinate = rightCoordinate - leftCoordinate;
width = (0 < deltaCoordinate) ? deltaCoordinate + 1 : 0;
topCoordinate = categoryMinimumCoordinate;
height = categoryMaximumCoordinate - categoryMinimumCoordinate + 1;
}
double roundedTopCoordinate = Math.Round(topCoordinate);
Canvas.SetTop(dataItem.Container, roundedTopCoordinate);
dataPoint.Height = Math.Round(topCoordinate + height - roundedTopCoordinate);
double roundedLeftCoordinate = Math.Round(leftCoordinate);
Canvas.SetLeft(dataItem.Container, roundedLeftCoordinate);
dataPoint.Width = Math.Round(leftCoordinate + width - roundedLeftCoordinate);
dataPoint.Visibility = Visibility.Visible;
if (0 <= value)
{
ceiling += deltaCoordinate;
}
else
{
floor -= deltaCoordinate;
}
}
else
{
dataPoint.Visibility = Visibility.Collapsed;
}
}
}
else
{
foreach (DataPoint dataPoint in group.DataItems.Select(di => di.DataPoint))
{
dataPoint.Visibility = Visibility.Collapsed;
}
}
}
}
}
/// <summary>
/// 同步发送接收
/// </summary>
/// <param name="buffer">Can't be null! </param>
/// <param name="timeout"></param>
/// <returns></returns>
public DtuMsg Ssend(byte[] buffer, int timeout)
{
if (buffer == null || buffer.Length == 0)
{
_log.Error("Null send buffer required. ");
return(NewErrorMsg((int)Errors.ERR_NULL_SEND_DATA));
}
if (!IsOnline)
{
_log.Error("DtuConnection Not Ready");
return(NewErrorMsg((int)Errors.ERR_NOT_CONNECTED));
}
if (Status != WorkingStatus.IDLE)
{
_log.Error("I'm BUSY!");
return(NewErrorMsg((int)Errors.ERR_DTU_BUSY));
}
Status = WorkingStatus.WORKING_SYNC;
_log.DebugFormat("DTU {0} SSending message, size={1}, {2}, timeout={3} s", DtuID, buffer.Length, ValueHelper.BytesToHexStr(buffer), timeout);
IDtuDataHandler oldHandler = _handler;
var worker = new AsyncDtuMsgHandler(timeout);
_handler = worker;
_server.Send(DtuID, buffer);
var thread = new Thread(worker.DoWork);
thread.Start();
thread.Join(); // wait thread dead.
Status = WorkingStatus.IDLE;
_handler = oldHandler;
return(worker.Received());
}
public void ParseResult(ref SensorAcqResult rawData)
{
rawData.ErrorCode = IsValid(rawData.Response);
if (rawData.ErrorCode != (int)Errors.SUCCESS)
{
return;
}
byte[] data = rawData.Response;
var module = data[IDX_Adrress];
if (module != rawData.Sensor.ModuleNo)
{
rawData.ErrorCode = (int)Errors.ERR_INVALID_MODULE;
return;
}
try
{
var elongationIndicator = ValueHelper.GetShort_BE(data, IDX_Length + 1) / 10.0;
double changeElongation = 0;
if (rawData.Sensor.Parameters != null && rawData.Sensor.Parameters.Count > 0)
{
var displacement = elongationIndicator - rawData.Sensor.Parameters[0].Value;
changeElongation = displacement;
}
var raws = new double[] { elongationIndicator };
var phys = new double[] { changeElongation };
rawData.Data = new SensorData(raws, phys, raws)
{
JsonResultData =
string.Format("{0}\"sensorId\":{1},\"data\":\"偏移量:{2} mm\"{3}", '{', rawData.Sensor.SensorID,
elongationIndicator, '}')
};
//rawData.Data = new LVDTData(elongationIndicator, changeElongation)
//{
// JsonResultData =
// string.Format("{0}\"sensorId\":{1},\"data\":\"偏移量:{2} mm\"{3}", '{', rawData.Sensor.SensorID,
// elongationIndicator, '}')
//};
}
catch (Exception ex)
{
rawData.ErrorCode = (int)Errors.ERR_DATA_PARSEFAILED;
_logger.ErrorFormat("bl lvdt sensor [Id:{0} m: {1}] parsedfailed,received bytes{2}, ERROR: {3}",
rawData.Sensor.SensorID, rawData.Sensor.ModuleNo, ValueHelper.BytesToHexStr(rawData.Response),
ex.Message);
}
}
/// <inheritdoc/>
public override string ToString()
{
return($"{Field} eq {ValueHelper.ConvertToSearchSafeValue(Value)}");
}
private SensorAcqResult RequestGprsSensor(Sensor si, IDtuConnection conn, int timeout)
{
var r = new SensorAcqResult
{
DtuCode = conn.DtuID,
Sensor = si,
Request = null,
Response = null,
Data = null,
ErrorCode = (int)Errors.ERR_DEFAULT
};
SendSensorCollectMsg(CollectState.Request, r);
var senadapter = _adapterManager.GetAdapter(si.ProtocolType);
//var senadapter = _adapterManager.GetSensorAdapter(si.ProtocolType);
if (senadapter == null)
{
return(CreateAcqResult(conn.DtuID, si, (int)Errors.ERR_UNKNOW_PROTOCOL, "Sensor has no ProtocolCode"));
}
try
{
//senadapter.Request(ref r);
var mp = new object[] { r };
object[] cp = null;
CrossDomainCompiler.Call(senadapter.ScriptPath, typeof(ISensorAdapter), senadapter.ClassName, "Request", ref cp, ref mp);
r = mp[0] as SensorAcqResult;
}
catch (Exception ex)
{
log.ErrorFormat("dtu{0} sensor:{1} create cmd error {2}", conn.DtuID, si.SensorID, ex.Message);
return(CreateAcqResult(conn.DtuID, si, (int)Errors.ERR_COMPILED, "internal error: SensorAdapter ERROR"));
}
if (r == null)
{
return(CreateAcqResult(conn.DtuID, si, (int)Errors.ERR_CREATE_CMD, "create cmd error: SensorAdapter ERROR"));
}
r.RequestTime = DateTime.Now;
if (r.ErrorCode != (int)Errors.SUCCESS)
{
return(CreateAcqResult(conn.DtuID, si, r.ErrorCode, "Sensor has no SensorAdapter"));
}
// send
if (r.ErrorCode == (int)Errors.SUCCESS && r.Request != null)
{
DtuMsg msg = conn.Ssend(r.Request, timeout);
if (msg == null)
{
return(CreateAcqResult(conn.DtuID, si, (int)Errors.ERR_NULL_RECEIVED_DATA, "Receive buff is null !"));
}
r.ResponseTime = msg.Refreshtime; // 若结果错误， 该时间无意义。
// Parse
if (msg.IsOK())
{
try
{
r.Response = msg.Databuffer;
if (r.Response != null)
{
//senadapter.ParseResult(ref r);
var mp = new object[] { r };
object[] cp = null;
CrossDomainCompiler.Call(senadapter.ScriptPath, typeof(ISensorAdapter), senadapter.ClassName, "ParseResult", ref cp, ref mp);
r = mp[0] as SensorAcqResult;
}
else
{
log.ErrorFormat("sensor:{0}, error Received buff is null", r.Sensor.SensorID);
}
}
catch (Exception ex)
{
log.ErrorFormat("dtu:{0},s[sid:{2}-m:{3}-c:{4}] , ERR_COMPILED {1}", conn.DtuID, ex.Message, si.SensorID, si.ModuleNo, si.ChannelNo);
return(CreateAcqResult(conn.DtuID, si, (int)Errors.ERR_COMPILED, "internal error: COMPILED ERROR"));
}
if (r == null)
{
return(CreateAcqResult(conn.DtuID, si, (int)Errors.ERR_DATA_PARSEFAILED, "internal error: SensorAdapter ERROR"));
}
r.ErrorMsg = r.ErrorCode == (int)Errors.SUCCESS ? "OK!" : ValueHelper.CreateJsonResultStr(si.SensorID, EnumHelper.GetDescription((Errors)r.ErrorCode));
}
else
{
r.ErrorCode = msg.ErrorCode;
r.ErrorMsg = msg.ErrorMsg;
}
r.Elapsed = msg.Elapsed;
}
else
{
if (r.ErrorCode == (int)Errors.ERR_DEFAULT)
{
r.ErrorCode = (int)Errors.ERR_UNKNOW;
}
r.ErrorMsg = "create cmd error";
}
if (r.ErrorCode != (int)Errors.SUCCESS)
{
r.Data = new SensorErrorData(r.Sensor.SensorID, r.ErrorCode);
}
SendSensorCollectMsg(CollectState.Response, r);
return(r);
}
// Translates a single pseudoinstruction
public EncodeLine[] TranslatePseudoSingle(EncodingFormat encoding, string[] parts, int index, uint pc, bool skipLabelAssertion = false)
{
List <EncodeLine> result = new List <EncodeLine>();
int startParenIndex = 0;
int endParenIndex = 0;
string strImmed = "";
string[] newParts;
uint ivalue = 0;
//long lvalue = 0;
ushort ushortval = 0;
//short shortval = 0;
bool useNegativeOffset = false;
string regS = "";
int argIndex0 = 0;
int argIndex1 = 0;
bool doesBranchIfEqual = false;
bool isStore = false;
bool useAT = false;
// Find args
string strArgs = "";
string[] args = null;
if (!string.IsNullOrEmpty(parts[1]))
{
strArgs = ASMStringHelper.RemoveSpaces(parts[1]);
args = strArgs.Split(',');
}
switch (encoding.Command)
{
case "jalr":
if (args.Length == 1)
{
parts[1] = args[0] + ",ra";
}
result.Add(new EncodeLine(parts, index));
break;
case "mul":
case "div":
case "rem":
case "mod":
if ((encoding.Command == "div") && (args.Length < 3))
{
result.Add(new EncodeLine(parts, index));
break;
}
newParts = new string[2];
newParts[0] = (encoding.Command == "mul") ? "mult" : "div";
newParts[1] = args[1] + "," + args[2];
result.Add(new EncodeLine(newParts, index));
parts[0] = ((encoding.Command == "mul") || (encoding.Command == "div")) ? "mflo" : "mfhi";
parts[1] = args[0];
result.Add(new EncodeLine(parts, index));
break;
case "bgt":
case "blt":
case "bge":
case "ble":
argIndex0 = ((encoding.Command == "bgt") || (encoding.Command == "ble")) ? 1 : 0;
argIndex1 = (argIndex0 > 0) ? 0 : 1;
doesBranchIfEqual = ((encoding.Command == "bge") || (encoding.Command == "ble"));
newParts = new string[2];
newParts[0] = "slt";
newParts[1] = "at," + args[argIndex0] + "," + args[argIndex1];
result.Add(new EncodeLine(newParts, index));
parts[0] = doesBranchIfEqual ? "beq" : "bne";
parts[1] = "at,zero," + args[2];
result.Add(new EncodeLine(parts, index));
break;
case "lbu":
case "lb":
case "lhu":
case "lh":
case "lw":
case "sb":
case "sh":
case "sw":
bool isHiLo = ((args[1].ToLower().StartsWith("%hi")) || (args[1].ToLower().StartsWith("%lo")));
startParenIndex = args[1].IndexOf('(', (isHiLo ? 4 : 0)); // check -1
endParenIndex = args[1].IndexOf(')', (startParenIndex >= 0) ? startParenIndex : 0);
isStore = encoding.Command.ToLower().StartsWith("s");
useAT = ((startParenIndex >= 0) || (isStore));
if (startParenIndex >= 0)
{
regS = args[1].Substring(startParenIndex + 1, endParenIndex - startParenIndex - 1);
strImmed = args[1].Substring(0, startParenIndex);
}
else
{
strImmed = args[1];
}
ivalue = ValueHelper.GetAnyUnsignedValue(strImmed, skipLabelAssertion);
bool isLabel = !(
((strImmed.StartsWith("0x")) || (strImmed.StartsWith("-0x"))) ||
(ASMStringHelper.StringIsNumeric(strImmed)) ||
((strImmed.StartsWith("-")) && (strImmed.Length > 1)) ||
(isHiLo)
);
if (((ivalue > 0x7fff) && (strImmed[0] != '-') && (!isHiLo)) || isLabel)
{
ushortval = (ushort)(ivalue & 0xffff);
if (ushortval >= 0x8000)
{
useNegativeOffset = true;
ushortval = (ushort)(0x10000 - ushortval);
}
newParts = new string[2];
newParts[0] = "lui";
newParts[1] = (useAT ? "at" : args[0]) + "," + ((ivalue >> 16) + (useNegativeOffset ? 1 : 0));
result.Add(new EncodeLine(newParts, index));
if (startParenIndex >= 0)
{
newParts = new string[2];
newParts[0] = "addu";
newParts[1] = "at,at," + regS;
result.Add(new EncodeLine(newParts, index));
}
parts[1] = args[0] + "," + (useNegativeOffset ? "-" : "") + ushortval + "(" + (useAT ? "at" : args[0]) + ")";
result.Add(new EncodeLine(parts, index));
}
else
{
result.Add(new EncodeLine(parts, index));
}
break;
// "la" always translates to two instructions, while "li" can translate to one.
case "la":
case "li":
//ivalue = ValueHelper.GetAnyUnsignedValue(args[1]);
/*
* try
* {
* ivalue = ValueHelper.GetAnyUnsignedValue(args[1]);
* //ivalue = ValueHelper.FindUnsignedValue(args[1]);
* }
* catch
* {
* ivalue = 0;
* }
*/
ivalue = ValueHelper.GetAnyUnsignedValue(args[1], skipLabelAssertion);
bool isLA = encoding.Command.Equals("la");
if (ivalue >= 0xffff8000)
{
parts[0] = "addiu";
parts[1] = args[0] + ",zero," + ((ushort)(ivalue & 0xffff));
result.Add(new EncodeLine(parts, index));
}
else if ((ivalue > 0xffff) || isLA)
{
newParts = new string[2];
newParts[0] = "lui";
newParts[1] = args[0] + "," + (ivalue >> 16);
result.Add(new EncodeLine(newParts, index));
ushortval = (ushort)(ivalue & 0xffff);
if ((ushortval > 0) || (isLA))
{
parts[0] = "ori";
parts[1] = args[0] + "," + args[0] + "," + ushortval;
result.Add(new EncodeLine(parts, index));
}
}
else
{
if (!((args[1].StartsWith("0x") || ASMStringHelper.StringIsNumeric(args[1]))))
{
parts[1] = args[0] + "," + ValueHelper.LabelHelper.LabelToUnsigned(args[1], skipLabelAssertion);
}
result.Add(new EncodeLine(parts, index));
}
break;
default:
result.Add(new EncodeLine(parts, index));
break;
}
return(result.ToArray());
}
/// <summary>
/// Updates each point.
/// </summary>
/// <param name="dataPoint">The data point to update.</param>
protected override void UpdateDataPoint(DataPoint dataPoint)
{
if (SeriesHost == null || PlotArea == null)
{
return;
}
object category = dataPoint.ActualIndependentValue ?? (this.ActiveDataPoints.IndexOf(dataPoint) + 1);
Range <UnitValue> coordinateRange = GetCategoryRange(category);
if (!coordinateRange.HasData)
{
return;
}
else if (coordinateRange.Maximum.Unit != Unit.Pixels || coordinateRange.Minimum.Unit != Unit.Pixels)
{
throw new InvalidOperationException(Properties.Resources.DataPointSeriesWithAxes_ThisSeriesDoesNotSupportRadialAxes);
}
double minimum = (double)coordinateRange.Minimum.Value;
double maximum = (double)coordinateRange.Maximum.Value;
double plotAreaHeight = ActualDependentRangeAxis.GetPlotAreaCoordinate(ActualDependentRangeAxis.Range.Maximum).Value;
IEnumerable <ColumnSeries> columnSeries = SeriesHost.Series.OfType <ColumnSeries>().Where(series => series.ActualIndependentAxis == ActualIndependentAxis);
int numberOfSeries = columnSeries.Count();
double coordinateRangeWidth = (maximum - minimum);
double segmentWidth = coordinateRangeWidth * 0.8;
double columnWidth = segmentWidth / numberOfSeries;
int seriesIndex = columnSeries.IndexOf(this);
double dataPointY = ActualDependentRangeAxis.GetPlotAreaCoordinate(ValueHelper.ToDouble(dataPoint.ActualDependentValue)).Value;
double zeroPointY = ActualDependentRangeAxis.GetPlotAreaCoordinate(ActualDependentRangeAxis.Origin).Value;
double offset = seriesIndex * Math.Round(columnWidth) + coordinateRangeWidth * 0.1;
double dataPointX = minimum + offset;
if (GetIsDataPointGrouped(category))
{
// Multiple DataPoints share this category; offset and overlap them appropriately
IGrouping <object, DataPoint> categoryGrouping = GetDataPointGroup(category);
int index = categoryGrouping.IndexOf(dataPoint);
dataPointX += (index * (columnWidth * 0.2)) / (categoryGrouping.Count() - 1);
columnWidth *= 0.8;
Canvas.SetZIndex(dataPoint, -index);
}
if (ValueHelper.CanGraph(dataPointY) && ValueHelper.CanGraph(dataPointX) && ValueHelper.CanGraph(zeroPointY))
{
dataPoint.Visibility = Visibility.Visible;
double left = Math.Round(dataPointX);
double width = Math.Round(columnWidth);
double top = Math.Round(plotAreaHeight - Math.Max(dataPointY, zeroPointY) + 0.5);
double bottom = Math.Round(plotAreaHeight - Math.Min(dataPointY, zeroPointY) + 0.5);
double height = bottom - top + 1;
Canvas.SetLeft(dataPoint, left);
Canvas.SetTop(dataPoint, top);
dataPoint.Width = width;
dataPoint.Height = height;
}
else
{
dataPoint.Visibility = Visibility.Collapsed;
}
}
public override void Unmarshall(byte[] buff)
{
base.Unmarshall(buff);
this.DtuCode = Convert.ToInt32(ValueHelper.GetString(this.Data, 0, 8));
this.Received = ValueHelper.GetShort(this.Data, 8);
}
public void ParseResult(ref SensorAcqResult rawData)
{
byte[] data = rawData.Response;
rawData.ErrorCode = IsValid(data);
if ((int)Errors.SUCCESS != rawData.ErrorCode)
{
return;
}
Encoding enc = new ASCIIEncoding();
var recbytes = enc.GetString(data);
var module = recbytes.Substring(1, 2);
if (int.Parse(module) != rawData.Sensor.ModuleNo)
{
rawData.ErrorCode = (int)Errors.ERR_INVALID_MODULE;
return;
}
try
{
var pdata = recbytes.Substring(3, recbytes.Length - 6);
var pressure = Convert.ToSingle(pdata);
string jsonResultData = string.Format("{0}\"sensorId\":{1},\"data\":\"压强:{2} kPa\"{3}", '{',
rawData.Sensor.SensorID, pressure, '}');
double physicalQuantity = 0;
switch (rawData.Sensor.FormulaID)
{
case 8:
var pressCul = pressure - rawData.Sensor.Parameters[1].Value;
if (ValueHelper.IsEqualZero(rawData.Sensor.Parameters[0].Value))
{
rawData.Sensor.Parameters[0].Value = 1;
}
var settlement = 1000 * pressCul / (rawData.Sensor.Parameters[0].Value * 9.8f);
physicalQuantity = settlement;
break;
case 10:
jsonResultData = string.Format("{0}\"sensorId\":{1},\"data\":\"米水柱:{2} mH2O\"{3}", '{',
rawData.Sensor.SensorID, pressure, '}');
int type = (int)rawData.Sensor.Parameters[0].Value;
double waterLevel = pressure * 100;
double len = rawData.Sensor.Parameters[1].Value; // 底长
switch (type)
{
case 0: //三角堰
physicalQuantity =
(float)(Math.Pow(waterLevel, 2.5) * (0.0142 - ((int)(waterLevel / 5)) * 0.0001));
break;
case 1: //矩形堰
physicalQuantity = (float)(Math.Pow(waterLevel, 1.5) * len * 0.0186);
break;
case 2: // 梯形堰
physicalQuantity =
(float)(Math.Pow(waterLevel, 1.5) * (len - 0.2 * waterLevel) * 0.01838);
break;
}
break;
}
var raws = new double[] { pressure };
var phys = new double[] { physicalQuantity };
rawData.Data = new SensorData(raws, phys, raws)
{
JsonResultData = jsonResultData
};
//rawData.Data = new PressureData(pressure, physicalQuantity)
//{
// JsonResultData = jsonResultData
//};
}
catch (Exception ex)
{
rawData.ErrorCode = (int)Errors.ERR_DATA_PARSEFAILED;
_logger.ErrorFormat("mpm pressure [id:{0},m:{1}] parsedfailed ,received bytes{3},ERROR : {2}", rawData.Sensor.SensorID, rawData.Sensor.ModuleNo, ex.Message, ValueHelper.BytesToHexStr(rawData.Response));
}
}
private static Storyboard CreateStoryboard(this DependencyObject target, DependencyProperty animatingDependencyProperty, string propertyPath, string propertyKey, ref object toValue, TimeSpan durationTimeSpan, IEasingFunction easingFunction)
{
object obj = target.GetValue(animatingDependencyProperty);
Storyboard storyboard = new Storyboard();
Storyboard.SetTarget((DependencyObject)storyboard, target);
Storyboard.SetTargetProperty((DependencyObject)storyboard, new PropertyPath(propertyPath, new object[0]));
if (obj != null && toValue != null)
{
double doubleValue1;
double doubleValue2;
if (ValueHelper.TryConvert(obj, out doubleValue1) && ValueHelper.TryConvert(toValue, out doubleValue2))
{
DoubleAnimation doubleAnimation = new DoubleAnimation();
doubleAnimation.Duration = (Duration)durationTimeSpan;
doubleAnimation.To = new double?(ValueHelper.ToDouble(toValue));
toValue = (object)doubleAnimation.To;
storyboard.Children.Add((Timeline)doubleAnimation);
}
else
{
DateTime dateTimeValue1;
DateTime dateTimeValue2;
if (ValueHelper.TryConvert(obj, out dateTimeValue1) && ValueHelper.TryConvert(toValue, out dateTimeValue2))
{
ObjectAnimationUsingKeyFrames animationUsingKeyFrames = new ObjectAnimationUsingKeyFrames();
animationUsingKeyFrames.Duration = (Duration)durationTimeSpan;
long count = (long)(durationTimeSpan.TotalSeconds * 20.0);
if (count < 2L)
{
count = 2L;
}
IEnumerable <TimeSpan> intervalsInclusive = ValueHelper.GetTimeSpanIntervalsInclusive(durationTimeSpan, count);
foreach (DiscreteObjectKeyFrame discreteObjectKeyFrame in Enumerable.Zip <DateTime, TimeSpan, DiscreteObjectKeyFrame>(ValueHelper.GetDateTimesBetweenInclusive(dateTimeValue1, dateTimeValue2, count), intervalsInclusive, (Func <DateTime, TimeSpan, DiscreteObjectKeyFrame>)((dateTime, timeSpan) =>
{
return(new DiscreteObjectKeyFrame()
{
Value = (object)dateTime,
KeyTime = (KeyTime)timeSpan
});
})))
{
animationUsingKeyFrames.KeyFrames.Add((ObjectKeyFrame)discreteObjectKeyFrame);
toValue = discreteObjectKeyFrame.Value;
}
storyboard.Children.Add((Timeline)animationUsingKeyFrames);
}
}
}
if (storyboard.Children.Count == 0)
{
ObjectAnimationUsingKeyFrames animationUsingKeyFrames = new ObjectAnimationUsingKeyFrames();
DiscreteObjectKeyFrame discreteObjectKeyFrame1 = new DiscreteObjectKeyFrame();
discreteObjectKeyFrame1.Value = toValue;
discreteObjectKeyFrame1.KeyTime = (KeyTime) new TimeSpan(0, 0, 0);
DiscreteObjectKeyFrame discreteObjectKeyFrame2 = discreteObjectKeyFrame1;
animationUsingKeyFrames.KeyFrames.Add((ObjectKeyFrame)discreteObjectKeyFrame2);
storyboard.Children.Add((Timeline)animationUsingKeyFrames);
}
return(storyboard);
}
private bool IsStringEquals(string str1, string str2)
{
return ValueHelper.IsStringEquals(str1, str2);
}
public void MarshalResponse(SimpleS3Config config, ListObjectsResponse response, IDictionary <string, string> headers, Stream responseStream)
{
response.RequestCharged = headers.ContainsKey(AmzHeaders.XAmzRequestCharged);
using (XmlTextReader xmlReader = new XmlTextReader(responseStream))
{
xmlReader.ReadToDescendant("ListBucketResult");
foreach (string name in XmlHelper.ReadElements(xmlReader))
{
switch (name)
{
case "Name":
response.BucketName = xmlReader.ReadString();
break;
case "Prefix":
response.Prefix = xmlReader.ReadString();
break;
case "KeyCount":
response.KeyCount = ValueHelper.ParseInt(xmlReader.ReadString());
break;
case "MaxKeys":
response.MaxKeys = ValueHelper.ParseInt(xmlReader.ReadString());
break;
case "IsTruncated":
response.IsTruncated = ValueHelper.ParseBool(xmlReader.ReadString());
break;
case "EncodingType":
response.EncodingType = ValueHelper.ParseEnum <EncodingType>(xmlReader.ReadString());
break;
case "Delimiter":
response.Delimiter = xmlReader.ReadString();
break;
case "StartAfter":
response.StartAfter = xmlReader.ReadString();
break;
case "NextContinuationToken":
response.NextContinuationToken = xmlReader.ReadString();
break;
case "ContinuationToken":
response.ContinuationToken = xmlReader.ReadString();
break;
case "Contents":
ReadContents(response, xmlReader);
break;
case "CommonPrefixes":
ReadCommonPrefixes(response, xmlReader);
break;
}
}
}
if (config.AutoUrlDecodeResponses && response.EncodingType == EncodingType.Url)
{
response.Delimiter = WebUtility.UrlDecode(response.Delimiter);
response.Prefix = WebUtility.UrlDecode(response.Prefix);
response.StartAfter = WebUtility.UrlDecode(response.StartAfter);
foreach (S3Object obj in response.Objects)
{
obj.ObjectKey = WebUtility.UrlDecode(obj.ObjectKey);
}
}
}
/// <summary>
/// 使用提供的条件查询数据库（表由entityType指定），返回满足条件的记录（分页）
/// </summary>
/// <typeparam name="T">要查询的实体类型，标记了DbTable和DbField特性的类，并且具有空白构造函数</typeparam>
/// <param name="connector"></param>
/// <param name="criteria">查询条件字典，键是PropertyName，条件仅支持=比较，条件间仅支持AND运算</param>
/// <param name="pageIndex">从0开始的返回页索引</param>
/// <param name="pageSize">每页几行记录</param>
/// <param name="sortProperty">用于排序的PropertyName(如为空则使用关键字)</param>
/// <param name="descending">是否倒序排列</param>
/// <param name="total">符合条件的记录总数</param>
/// <returns></returns>
public static async Task <PagedQuery <T> > SearchEntities <T>(DbConnector connector, Dictionary <string, object> criteria,
int pageIndex, int pageSize, string sortProperty, bool descending) where T : new()
{
Type entityType = typeof(T);
if (!(DbTableAttribute.GetCustomAttribute(entityType, typeof(DbTableAttribute)) is DbTableAttribute tableAttr))
{
throw new Exception("类型" + entityType.FullName + "没有标记DbTableAttribute特性");
}
string selectClause = "SELECT * ";
string fromClause = "FROM " + tableAttr.TableName;
string orderBy;
#region 正确处理orderBy
DbFieldAttribute sortFieldAttr = null;
if (string.IsNullOrWhiteSpace(sortProperty))
{
//如果没有传递sortProperty参数, 则使用PrimaryKey
foreach (PropertyInfo property in entityType.GetProperties())
{
DbFieldAttribute fldAttr = DbFieldAttribute.GetCustomAttribute(property, typeof(DbFieldAttribute)) as DbFieldAttribute;
if (fldAttr != null && fldAttr.IsPrimaryKey)
{
sortFieldAttr = fldAttr;
break;
}
}
}
else
{
PropertyInfo property = entityType.GetProperty(sortProperty);
if (property == null)
{
throw new Exception(string.Format("类型{0}中没有找到{1}属性用于排序", entityType.FullName, sortProperty));
}
sortFieldAttr = DbFieldAttribute.GetCustomAttribute(property, typeof(DbFieldAttribute)) as DbFieldAttribute;
}
if (sortFieldAttr == null)
{
throw new Exception("类型" + entityType.FullName + "没有标记IsPrimaryKey=true的DbField特性");
}
if (descending)
{
orderBy = sortFieldAttr.FieldName + " DESC";
}
else
{
orderBy = sortFieldAttr.FieldName;
}
#endregion
StringBuilder whereBuilder = new StringBuilder();
List <SqlParameter> sqlParameters = new List <SqlParameter>();
if (criteria != null)
{
foreach (string conditionName in criteria.Keys)
{
if (criteria[conditionName] == null || criteria[conditionName].ToString().Length == 0)
{
continue;
}
PropertyInfo conditionProperty = entityType.GetProperty(conditionName);
if (conditionProperty == null)
{
throw new Exception(string.Format("类型{0}中没有找到{1}属性用于查询条件", entityType.FullName, conditionName));
}
DbFieldAttribute conditionAttr = DbFieldAttribute.GetCustomAttribute(conditionProperty, typeof(DbFieldAttribute)) as DbFieldAttribute;
if (conditionAttr == null)
{
throw new Exception(string.Format("类型{0}的{1}属性没有标记DbFieldAttribute特性, 无法用于数据库查询",
entityType.FullName, conditionName));
}
SqlParameter parameter = GenerateSqlParameter(conditionAttr, conditionProperty.PropertyType, criteria[conditionName]);
sqlParameters.Add(parameter);
whereBuilder.AppendFormat("[{0}]=@{0} ", conditionAttr.FieldName);
whereBuilder.Append("AND ");
}
}
if (whereBuilder.Length > 0)
{
whereBuilder.Remove(whereBuilder.Length - 4, 4);
}
string sql = BuildPagedSelectSql(selectClause, fromClause, whereBuilder.ToString(), orderBy, pageIndex, pageSize);
DataSet ds = await connector.ExecuteSqlQuerySet(sql, sqlParameters.ToArray());
PagedQuery <T> result = new PagedQuery <T>();
if (ds != null && ds.Tables.Count == 2)
{
result.Total = (int)ds.Tables[0].Rows[0][0];
ds.Tables[1].TableName = "result";
result.Records = await Task.Run(() => ValueHelper.WrapEntities <T>(ds.Tables[1]));
}
else
{
result.Total = 0;
result.Records = new T[0];
}
ds.Dispose();
return(result);
}
/// <summary>
/// Returns a value indicating whether a value can plot.
/// </summary>
/// <param name="value">The value to plot.</param>
/// <returns>A value indicating whether a value can plot.</returns>
public override bool CanPlot(object value)
{
DateTime val;
return(ValueHelper.TryConvert(value, out val));
}
public void MarshalResponse(SimpleS3Config config, ListObjectVersionsResponse response, IDictionary <string, string> headers, Stream responseStream)
{
using (XmlTextReader xmlReader = new XmlTextReader(responseStream))
{
//To support Google's lack of versions which is identical to S3 ListObjectVersions, but not quite
//xmlReader.ReadToDescendant("ListVersionsResult");
foreach (string name in XmlHelper.ReadElements(xmlReader))
{
switch (name)
{
case "IsTruncated":
response.IsTruncated = ValueHelper.ParseBool(xmlReader.ReadString());
break;
case "EncodingType":
response.EncodingType = ValueHelper.ParseEnum <EncodingType>(xmlReader.ReadString());
break;
case "KeyMarker":
response.KeyMarker = xmlReader.ReadString();
break;
case "VersionIdMarker":
response.VersionIdMarker = xmlReader.ReadString();
break;
case "NextKeyMarker":
response.NextKeyMarker = xmlReader.ReadString();
break;
case "NextVersionIdMarker":
response.NextVersionIdMarker = xmlReader.ReadString();
break;
case "Name":
response.BucketName = xmlReader.ReadString();
break;
case "Prefix":
response.Prefix = xmlReader.ReadString();
break;
case "Delimiter":
response.Delimiter = xmlReader.ReadString();
break;
case "MaxKeys":
response.MaxKeys = ValueHelper.ParseInt(xmlReader.ReadString());
break;
case "Version":
response.Versions.Add(ParseVersion(xmlReader));
break;
case "DeleteMarker":
response.DeleteMarkers.Add(ParseDeleteMarker(xmlReader));
break;
case "CommonPrefixes":
response.CommonPrefixes.Add(ParseCommonPrefixes(xmlReader));
break;
}
}
}
if (config.AutoUrlDecodeResponses && response.EncodingType == EncodingType.Url)
{
response.KeyMarker = WebUtility.UrlDecode(response.KeyMarker);
response.NextKeyMarker = WebUtility.UrlDecode(response.NextKeyMarker);
response.Prefix = WebUtility.UrlDecode(response.Prefix);
response.Delimiter = WebUtility.UrlDecode(response.Delimiter);
foreach (S3Version version in response.Versions)
{
version.ObjectKey = WebUtility.UrlDecode(version.ObjectKey);
}
foreach (S3DeleteMarker marker in response.DeleteMarkers)
{
marker.ObjectKey = WebUtility.UrlDecode(marker.ObjectKey);
}
}
}
internal void UpdateActualLabelContent()
{
if (this.LabelContent != null)
{
this.ActualLabelContent = this.LabelContent;
}
else if (this.ShowValueAsLabel)
{
StringFormatConverter stringFormatConverter = new StringFormatConverter();
string str = ValueHelper.PrepareFormatString(this.StringFormat);
bool flag = false;
double doubleValue;
if (this.Series != null && this.Series.LabelDisplayUnitSystem != null && ValueHelper.TryConvert(this.PrimaryValue, false, out doubleValue))
{
this.Series.LabelDisplayUnitSystem.CalculateActualDisplayUnit(doubleValue, str);
if (this.Series.LabelDisplayUnitSystem.ActualDisplayUnit != null)
{
flag = true;
this.ActualLabelContent = this.Series.LabelDisplayUnitSystem.FormatLabel(str, (object)doubleValue, new int?(2));
}
}
if (flag)
{
return;
}
this.ActualLabelContent = stringFormatConverter.Convert(this.PrimaryValue, (Type)null, (object)str, (CultureInfo)null);
}
else
{
this.ActualLabelContent = (object)null;
}
}
/// <summary>
/// 获取详情模板
/// </summary>
/// <returns></returns>
public virtual ActionResult DetailTemplate(string id = null)
{
var m = id == null ? new TDto() : Service.GetById <TDto>(ValueHelper.GetSafeValue <TKey>(id));
return(PartialView(m));
}
private void server_OnReceive(ValueHelper.ValueSocket.SocketEvents.ReceiveEventArgs e)
{
if (sessionManager.CheckSessionExist(e.Socket))
{
Message message = valueProtocol.Decode(e.Data);
if (message.header.Opcode == OperType.Close)
{
removeUser(e.Socket);
}
if (message.header.Opcode == OperType.Text)
{
String msg = message.Data.ToString();
execMsg(e.Socket, msg);
}
}
else
{
String request = Encoding.UTF8.GetString(e.Data);
Byte[] response = valueProtocol.GetResponse(request);
server.Send(e.Socket, response);
sessionManager.AddSession(e.Socket, request);
}
}
public void MarshalResponse(IConfig config, ListMultipartUploadsResponse response, IDictionary <string, string> headers, Stream responseStream)
{
XmlSerializer s = new XmlSerializer(typeof(ListMultipartUploadsResult));
using (XmlTextReader r = new XmlTextReader(responseStream))
{
r.Namespaces = false;
ListMultipartUploadsResult listResult = (ListMultipartUploadsResult)s.Deserialize(r);
if (listResult.EncodingType != null)
{
response.EncodingType = ValueHelper.ParseEnum <EncodingType>(listResult.EncodingType);
}
response.KeyMarker = config.AutoUrlDecodeResponses && response.EncodingType == EncodingType.Url ? WebUtility.UrlDecode(listResult.KeyMarker) : listResult.KeyMarker;
response.NextKeyMarker = config.AutoUrlDecodeResponses && response.EncodingType == EncodingType.Url ? WebUtility.UrlDecode(listResult.NextKeyMarker) : listResult.NextKeyMarker;
response.Prefix = config.AutoUrlDecodeResponses && response.EncodingType == EncodingType.Url ? WebUtility.UrlDecode(listResult.Prefix) : listResult.Prefix;
response.Delimiter = config.AutoUrlDecodeResponses && response.EncodingType == EncodingType.Url ? WebUtility.UrlDecode(listResult.Delimiter) : listResult.Delimiter;
response.Bucket = listResult.Bucket;
response.UploadIdMarker = listResult.UploadIdMarker;
response.NextUploadIdMarker = listResult.NextUploadIdMarker;
response.MaxUploads = listResult.MaxUploads;
response.IsTruncated = listResult.IsTruncated;
if (listResult.CommonPrefixes != null)
{
response.CommonPrefixes = new List <string>(listResult.CommonPrefixes.Count);
foreach (CommonPrefix prefix in listResult.CommonPrefixes)
{
response.CommonPrefixes.Add(prefix.Prefix);
}
}
else
{
response.CommonPrefixes = Array.Empty <string>();
}
if (listResult.Uploads != null)
{
response.Uploads = new List <S3Upload>(listResult.Uploads.Count);
foreach (Upload listUpload in listResult.Uploads)
{
S3Upload s3Upload = new S3Upload();
s3Upload.ObjectKey = config.AutoUrlDecodeResponses && response.EncodingType == EncodingType.Url ? WebUtility.UrlDecode(listUpload.Key) : listUpload.Key;
s3Upload.UploadId = listUpload.UploadId;
if (listUpload.StorageClass != null)
{
s3Upload.StorageClass = ValueHelper.ParseEnum <StorageClass>(listUpload.StorageClass);
}
s3Upload.Initiated = listUpload.Initiated;
if (listUpload.Owner != null)
{
s3Upload.Owner = new S3Identity();
s3Upload.Owner.Name = listUpload.Owner.DisplayName;
s3Upload.Owner.Id = listUpload.Owner.Id;
}
if (listUpload.Initiator != null)
{
s3Upload.Initiator = new S3Identity();
s3Upload.Initiator.Name = listUpload.Initiator.DisplayName;
s3Upload.Initiator.Id = listUpload.Initiator.Id;
}
response.Uploads.Add(s3Upload);
}
}
else
{
response.Uploads = Array.Empty <S3Upload>();
}
}
}
public static void OnMsg(byte[] buff, int len)
{
Console.WriteLine("< {0}", ValueHelper.BytesToHexStr(buff, 0, len));
Console.WriteLine("> {0}", AutoReply);
client.Send(AutoReply);
}
public void ParseResult(ref SensorAcqResult rawData)
{
var data = rawData.Response;
rawData.ErrorCode = IsValid(data);
if ((int)Errors.SUCCESS != rawData.ErrorCode)
{
return;
}
var module = ValueHelper.GetShort_BE(data, IDX_SOURCE);
if (module != rawData.Sensor.ModuleNo)
{
rawData.ErrorCode = (int)Errors.ERR_INVALID_MODULE;
return;
}
int channel = Convert.ToInt16(data[IDX_CONTENT]);
if (channel != rawData.Sensor.ChannelNo)
{
rawData.ErrorCode = (int)Errors.ERR_RECEIVED_CH;
return;
}
try
{
var temByte = new byte[4];
for (var j = 0; j < 2; j++)
{
temByte[1 - j] = data[12 + j];
}
uint voltageAd = this.bytesToInt(temByte); //原始电压AD值
var range =
(VoltageSensorRange)
EnumHelper.GetItemFromDesc(typeof(VoltageSensorRange), rawData.Sensor.ProductCode);
float voltage = Getvoltage(range, voltageAd);
double phyValue = 0;
if (rawData.Sensor.FormulaID == 5) // 电压公式 ε=k*vol-c
{
phyValue = (rawData.Sensor.Parameters[0].Value * voltage -
rawData.Sensor.Parameters[1].Value);
}
else if (rawData.Sensor.FormulaID == 16) // LVDT电压公式 L=k(V-V0)+C
{
phyValue = (rawData.Sensor.Parameters[0].Value *
(voltage - rawData.Sensor.Parameters[2].Value) +
rawData.Sensor.Parameters[1].Value);
}
var raws = new double[] { voltageAd, voltage };
var phys = new double[] { phyValue };
rawData.Data = new SensorData(raws, phys, raws)
{
JsonResultData =
string.Format("{0}\"sensorId\":{1},\"data\":\"电压:{2} V\"{3}", '{',
rawData.Sensor.SensorID, voltage, '}')
};
//rawData.Data = new VoltageData(voltage, phyValue)
//{
// JsonResultData =
// string.Format("{0}\"sensorId\":{1},\"data\":\"电压:{2} V\"{3}", '{',
// rawData.Sensor.SensorID, voltage, '}')
//};
}
catch (Exception ex)
{
rawData.ErrorCode = (int)Errors.ERR_DATA_PARSEFAILED;
_logger.ErrorFormat("voltage sensor [id:{0},m:{1},ch:{4}] parsedfailed ,received bytes{3},ERROR : {2}", rawData.Sensor.SensorID, rawData.Sensor.ModuleNo, ex.Message, ValueHelper.BytesToHexStr(rawData.Response), rawData.Sensor.ChannelNo);
}
}
static void server_OnAccept(ValueHelper.ValueSocket.SocketEvents.SocketEventArgs e)
{
//throw new NotImplementedException();
}
private int IsValid(byte[] data)
{
if (data.Length < 24 || data.Length > 26)
{
return((int)Errors.ERR_INVALID_DATA);
}
if (data[IDX_FrameH] != 0xfe || data[IDX_FrameH + 1] != 0x46 || data[IDX_FrameH + 2] != 0x41 || data[IDX_FrameH + 3] != 0x53 || data[data.Length - 1] != 0xef)
{
return((int)Errors.ERR_INVALID_DATA);
}
var xorValue = data[data.Length - 2];
var xorCalc = 0;
xorCalc = data.Length == 25 ? ValueHelper.CheckXor(data, 0, data.Length - 3) : ValueHelper.CheckXor(data, 0, data.Length - 2);
if (xorCalc == xorValue)
{
return((int)Errors.SUCCESS);
}
return((int)Errors.ERR_CRC);
}
public void Init(ActionsManager actionsManager, string creator, IValueHelper<string> connectionStringValueHelper)
{
System.Diagnostics.Debug.Assert( Creator == null, "Init() should be called only once!" );
Creator = creator;
ActionsManager = actionsManager;
IsConnectionOkHelper = new ValueHelper<bool>{ Value = false };
ConnectionString_ValueChangedActionDelayer = new ActionHelper();
bool hadInitialConnectionString;
if( string.IsNullOrEmpty(connectionStringValueHelper.Value) )
{
// Fill control with initial values
connectionStringValueHelper.Value = ConnectionStringHelper.SampleConnectionString;
hadInitialConnectionString = false;
}
else
{
hadInitialConnectionString = true;
}
ConnectionStringHelper = new Utils.Event.ConnectionStringHelper( connectionStringValueHelper );
// Link Show Password CheckBox
cbShowPassword.Checked += ES.Routed( cbShowPassword_Changed );
cbShowPassword.Unchecked += ES.Routed( cbShowPassword_Changed );
cbShowPassword_Changed();
// Link TextBoxes to ConnectionStringHelper
txtServer.Text = Server;
ConnectionStringHelper.ServerHelper.ValueChanged += ()=>{ txtServer.Text = Server; };
txtServer.TextChanged += ES.TextChanged( ()=>{ Server = txtServer.Text; } );
txtDatabase.Text = Database;
ConnectionStringHelper.DatabaseHelper.ValueChanged += ()=>{ txtDatabase.Text = Database; };
txtDatabase.TextChanged += ES.TextChanged( ()=>{ Database = txtDatabase.Text; } );
txtUser.Text = User;
ConnectionStringHelper.UserHelper.ValueChanged += ()=>{ txtUser.Text = User; };
txtUser.TextChanged += ES.TextChanged( ()=>{ User = txtUser.Text; } );
txtPasswordClear.Text =
txtPasswordHidden.Password =
txtPasswordConfirm.Password = Password;
ConnectionStringHelper.PasswordHelper.ValueChanged += ()=>
{
var password = Password;
txtPasswordClear.Text = password;
if( txtPasswordHidden.Password != password ) txtPasswordHidden.Password = password;
if( txtPasswordConfirm.Password != password ) txtPasswordConfirm.Password = password;
};
txtPasswordClear.TextChanged += (sender,e)=>{ Password = txtPasswordClear.Text; };
txtPasswordHidden.PasswordChanged += ES.Routed( txtPasswordHiddenConfirm_PasswordChanged );
txtPasswordConfirm.PasswordChanged += ES.Routed( txtPasswordHiddenConfirm_PasswordChanged );
// Monitor ConnectionString changes
txtConnectionString.Text = ConnectionStringHelper.GetConnectionStringWithoutPassword( PasswordHideString );
ConnectionString_ValueChangedActionDelayer.Action = ConnectionString_ValueChangedDelayed;
ConnectionStringHelper.ValueHelper.ValueChanged += ConnectionString_ValueChanged;
if( hadInitialConnectionString )
// Try connection right now if a ConnectionString is already available
ConnectionString_ValueChangedActionDelayer.Trigger();
// Set delay on the ConnectionString's ActionHelper
ConnectionString_ValueChangedActionDelayer.DelaySeconds = 1;
}
public void ParseResult(ref SensorAcqResult rawData)
{
rawData.ErrorCode = IsValid(rawData.Response);
if (rawData.ErrorCode != (int)Errors.SUCCESS)
{
return;
}
Encoding enc = new ASCIIEncoding();
var recstr = enc.GetString(rawData.Response);
int startIndex;
try
{
if (!IsModule(rawData, out startIndex))
{
rawData.ErrorCode = (int)Errors.ERR_INVALID_MODULE;
return;
}
var pdata = recstr.Substring(startIndex, 6);
var len = Convert.ToInt32(pdata) / 1000.0; //mm --> m
var changelen = (len - rawData.Sensor.Parameters[0].Value) * 1000; // m --> mm
if (rawData.Sensor.FormulaID == 22)
{
changelen *= -1;
}
double[] raws = { len };
double[] phys = { changelen };
rawData.Data = new SensorData(raws, phys, raws)
{
JsonResultData =
string.Format("{0}\"sensorId\":{1},\"data\":\"测量距离:{2} m\"{3}", '{', rawData.Sensor.SensorID,
len, '}')
};
//rawData.Data = new LaserData(len, changelen)
//{
// JsonResultData =
// string.Format("{0}\"sensorId\":{1},\"data\":\"测量距离:{2} m\"{3}", '{', rawData.Sensor.SensorID,
// len, '}')
//};
}
catch (Exception ex)
{
rawData.ErrorCode = (int)Errors.ERR_DATA_PARSEFAILED;
_logger.ErrorFormat("ftm laser sensor [Id:{0} m: {1}] pasefailed, received bytes{2}: {3}",
rawData.Sensor.SensorID, rawData.Sensor.ModuleNo, ValueHelper.BytesToHexStr(rawData.Response),
ex.Message);
}
}
