private void ConvertUnit(UnitConvert unit, float[] values)
{
for (int i = 0; i < values.Length; i++)
{
values[i] = (float)unit.Convert(values[i]);
}
}
public ValueRow(
int index, string name, float value, string format, UnitConvert unit,
bool save = false, bool chart = false, EUnitType yAxis = EUnitType.None)
{
Index = index;
Name = name;
Value = value;
Format = format;
Unit = unit;
State = EValueState.None;
YAxis = yAxis;
Chart = chart;
Save = save;
Storage = (Save == true) ? new ValueStorage(csLength) : null;
}
public void Open(Int64 recNo)
{
db.Lock();
try
{
this.recNo = recNo;
bufferedSeries.ClearPoints();
double totalTime = 0;
DataBookDataSet bookSet = db.DataBookSet;
DataRawUnitDataSet rawUnitSet = db.DataRawUnitSet;
DataRawDataSet rawSet = db.DataRawSet;
UnitConvert unit = new UnitConvert(EUnitType.None, 0, 0);
bookSet.Select(recNo);
if (bookSet.IsEmpty() == false)
{
bookSet.Fetch();
scanTime = bookSet.ScanTime;
bufferedSeries.BaseTime = scanTime * 1000;
if (string.IsNullOrWhiteSpace(bookSet.TestName) == true)
{
fName = $"None_Line{bookSet.TestLine + 1}";
}
else
{
fName = $"{bookSet.TestName}_Line{bookSet.TestLine + 1}";
}
rawUnitSet.Select(bookSet.RecNo);
try
{
for (int i = 0; i < rawUnitSet.GetRowCount(); i++)
{
rawUnitSet.Fetch(i);
unit.Type = (EUnitType)rawUnitSet.UnitType;
unit.From = rawUnitSet.UnitFrom;
unit.To = rawUnitSet.UnitTo;
SetMethodUnit((EUnitType)rawUnitSet.UnitType, rawUnitSet.UnitTo);
SetPlotSeriesUnit(i, (EUnitType)rawUnitSet.UnitType, rawUnitSet.UnitTo);
rawSet.Select(rawUnitSet.RecNo);
for (int j = 0; j < rawSet.GetRowCount(); j++)
{
rawSet.Fetch(j);
if (rawSet.DataRaw == null)
{
break;
}
if (i == 0)
{
totalTime += (rawSet.DataRaw.Length - 1) * bufferedSeries.BaseTime;
}
ConvertUnit(unit, rawSet.DataRaw);
bufferedSeries[i].Points.AddRange(rawSet.DataRaw);
}
Win32.SwitchToThread();
}
}
finally
{
foreach (TabPage page in graphTab.TabPages)
{
CtrlViewGraphPanel ctrl = page.Controls[0] as CtrlViewGraphPanel;
ctrl.Method = method;
ctrl.RefreshYAxesUnit();
ctrl.SetMaxRangeAxisX(totalTime);
}
InvalidateGraphSeries(graphTab.SelectedTab);
}
}
}
finally
{
db.Unlock();
}
}
private void Initialize()
{
// Load constant variables
int i = 1;
string key = $"CH{i}";
string param = Resource.Ini.GetString("Constant.Channel", key);
Const.Clear();
while (string.IsNullOrWhiteSpace(param) == false)
{
string[] @params = param.Split(new[] { ',' }, StringSplitOptions.None);
EUnitType type = (EUnitType)Enum.Parse(typeof(EUnitType), @params[1]);
int unitNo = GetUnitNo(type, @params[2]);
UnitConvert unit = new UnitConvert(type, unitNo, unitNo);
ValueRow row = new ValueRow(i - 1, @params[0], 0f, @params[3],
unit, bool.Parse(@params[4]), bool.Parse(@params[5]), type);
Const.Add(@params[0], row);
i++;
key = $"CH{i}";
param = Resource.Ini.GetString("Constant.Channel", key);
}
Const["Total.Rated.Capacity"].Unit.Enabled = false;
Const["Total.Rated.EER_COP"].Unit.Enabled = false;
// Load calculated variables
i = 1;
key = $"CH{i}";
param = Resource.Ini.GetString("Calculated.Channel", key);
Calcurated.Clear();
while (string.IsNullOrWhiteSpace(param) == false)
{
string[] @params = param.Split(new[] { ',' }, StringSplitOptions.None);
EUnitType type = (EUnitType)Enum.Parse(typeof(EUnitType), @params[1]);
int unitNo = GetUnitNo(type, @params[2]);
UnitConvert unit = new UnitConvert(type, unitNo, unitNo);
ValueRow row = new ValueRow(i - 1, @params[0], 0f, @params[3],
unit, bool.Parse(@params[4]), bool.Parse(@params[5]), type);
Calcurated.Add(@params[0], row);
i++;
key = $"CH{i}";
param = Resource.Ini.GetString("Calculated.Channel", key);
}
// Load measured variables
i = 1;
key = $"CH{i}";
param = Resource.Ini.GetString("Measured.Channel", key);
Measured.Clear();
while (string.IsNullOrWhiteSpace(param) == false)
{
string[] @params = param.Split(new[] { ',' }, StringSplitOptions.None);
EUnitType type = (EUnitType)Enum.Parse(typeof(EUnitType), @params[1]);
int unitNo = GetUnitNo(type, @params[2]);
UnitConvert unit = new UnitConvert(type, unitNo, unitNo);
ValueRow row = new ValueRow(i - 1, @params[0], 0f, @params[3],
unit, bool.Parse(@params[4]), bool.Parse(@params[5]), type);
Measured.Add(@params[0], row);
i++;
key = $"CH{i}";
param = Resource.Ini.GetString("Measured.Channel", key);
}
foreach (KeyValuePair <string, ValueRow> row in Calcurated)
{
if (row.Value.Chart == true)
{
Graph.Add(row.Key, row.Value);
}
}
foreach (KeyValuePair <string, ValueRow> row in Measured)
{
if (row.Value.Chart == true)
{
Graph.Add(row.Key, row.Value);
}
}
}
private void SetSheetValues(Dictionary <string, Cell> sheet, List <string> cellTags, int integCount,
int integTime, DataValueUnitDataSet valueUnitSet, DataValueDataSet valueSet, bool isThermo, bool isNozzle = false)
{
string tag, state = "";
float average = 0;
int valueCount = 0;
int valueUnitCount = valueUnitSet.GetRowCount();
UnitConvert unit = new UnitConvert(EUnitType.None, 0, 0);
for (int i = 0; i < valueUnitCount; i++)
{
valueUnitSet.Fetch(i);
unit.Type = (EUnitType)valueUnitSet.UnitType;
unit.From = valueUnitSet.UnitFrom;
unit.To = valueUnitSet.UnitTo;
if (isThermo == true)
{
tag = $"{{{cellTags[i]}-N}}";
sheet[tag].Value = valueUnitSet.ValueName;
}
tag = $"{{{cellTags[i]}}}";
if (cellTags[i] != "365")
{
if (valueUnitSet.UnitType == 0)
{
sheet[tag].Value = "";
}
else
{
sheet[tag].Value = unit.ToDescription;
}
}
average = 0;
valueSet.Select(valueUnitSet.RecNo);
valueCount = valueSet.GetRowCount();
for (int j = 0; j < valueCount; j++)
{
valueSet.Fetch(j);
tag = $"{{{cellTags[i]}-{valueSet.DataNo+1}}}";
if (valueUnitSet.UnitType == 0)
{
if ((cellTags[i] == "365") && (isNozzle == true))
{
state = GetNozzleState((byte)valueSet.DataValue);
sheet[tag].Value = state;
}
else
{
sheet[tag].Value = "";
average = float.NaN;
break;
}
}
else
{
if (float.IsNaN(valueSet.DataValue) == true)
{
sheet[tag].Value = "";
average = float.NaN;
break;
}
else
{
if (string.IsNullOrWhiteSpace(valueUnitSet.Format) == false)
{
sheet[tag].NumberFormat = valueUnitSet.Format;
}
sheet[tag].Value = unit.Convert(valueSet.DataValue);
average += valueSet.DataValue;
}
}
}
tag = $"{{{cellTags[i]}-0}}";
if (cellTags[i] == "365")
{
if (isNozzle == true)
{
sheet[tag].Value = state;
}
else
{
sheet[tag].Value = "";
}
}
else
{
if ((valueUnitSet.UnitType == 0) || (valueCount == 0))
{
sheet[tag].Value = "";
}
else
{
if (float.IsNaN(average) == true)
{
sheet[tag].Value = "";
}
else
{
average = average / valueCount;
sheet[tag].Value = unit.Convert(average);
}
}
}
}
sheet["{min-0}"].Value = "Average";
for (int i = 0; i < integCount; i++)
{
tag = $"{{min-{i+1}}}";
sheet[tag].Value = $"{(i+1)*integTime} min";
}
}
