722 lines
40 KiB
C#
722 lines
40 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using DTS.Common.Classes.Sensors;
|
|
using DTS.Common.DAS.Concepts;
|
|
using DTS.Common.Enums;
|
|
using DTS.Common.Enums.Sensors;
|
|
|
|
namespace DTS.SensorDB.TDM
|
|
{
|
|
/// <summary>
|
|
/// this class handles logic of TDM CSV export it is partially built from
|
|
/// http://fogbugz/fogbugz/default.asp?5286#31544
|
|
/// and http://build:8080/svn/Software/Code/TDASManager/trunk/source/sensor.c
|
|
/// </summary>
|
|
public class TDMCSVImport
|
|
{
|
|
/// <summary>
|
|
/// most of these will get mapped to full bridge, a couple to half bridge
|
|
/// the existing TDM code doesn't appear to consider 1/4 bridge
|
|
/// </summary>
|
|
private enum MeasurementTypes
|
|
{
|
|
MEASTYPE_FULLBRIDGE,
|
|
MEASTYPE_HALFBRIDGE,
|
|
MEASTYPE_VOLTAGE,
|
|
MEASTYPE_IRTRACC,
|
|
MEASTYPE_VOLTAGE_FB,
|
|
MEASTYPE_POTENTIOMETER_FB,
|
|
MEASTYPE_POTENTIOMETER_HB,
|
|
MEASTYPE_ARS_ANGLE
|
|
}
|
|
|
|
/// <summary>
|
|
/// Available filter types in the file
|
|
/// note FIR100 not supported by SLICE code currently?
|
|
/// </summary>
|
|
private enum FilterTypes
|
|
{
|
|
FILTERTYPE_USEFREQ = 0,
|
|
FILTERTYPE_CFC60,
|
|
FILTERTYPE_CFC180,
|
|
FILTERTYPE_CFC600,
|
|
FILTERTYPE_CFC1000,
|
|
FILTERTYPE_FIR100,
|
|
FILTERTYPE_NONE,
|
|
FILTERTYPE_UNFILTERED
|
|
}
|
|
/// <summary>
|
|
/// possible zero methods for sensors
|
|
/// </summary>
|
|
private enum ZeroMethods
|
|
{
|
|
ZMETHOD_PREZERO = 1,
|
|
ZMETHOD_AVGTIME,
|
|
ZMETHOD_EQUALS0MV
|
|
}
|
|
/// <summary>
|
|
/// goes from a label/string in CSV to an enum (measurement type)
|
|
/// </summary>
|
|
/// <param name="label"></param>
|
|
/// <returns></returns>
|
|
private static MeasurementTypes LabelToMeasurementType(string label)
|
|
{
|
|
switch (label)
|
|
{
|
|
case "Full Bridge": return MeasurementTypes.MEASTYPE_FULLBRIDGE;
|
|
case "Half Bridge": return MeasurementTypes.MEASTYPE_HALFBRIDGE;
|
|
case "Voltage Mode": return MeasurementTypes.MEASTYPE_VOLTAGE;
|
|
case "IRTRACC": return MeasurementTypes.MEASTYPE_IRTRACC;
|
|
case "Voltage Mode FB": return MeasurementTypes.MEASTYPE_VOLTAGE_FB;
|
|
case "Potentiometer FB": return MeasurementTypes.MEASTYPE_POTENTIOMETER_FB;
|
|
case "Potentiometer HB": return MeasurementTypes.MEASTYPE_POTENTIOMETER_HB;
|
|
case "Angular Rate Sensor - Angle": return MeasurementTypes.MEASTYPE_ARS_ANGLE;
|
|
default:
|
|
throw new NotSupportedException("unknown measurement type: " + label);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// goes from an enum to a label/string (measurement type)
|
|
/// </summary>
|
|
/// <param name="mt"></param>
|
|
/// <returns></returns>
|
|
private static string MeasurementTypeToLabel(MeasurementTypes mt)
|
|
{
|
|
switch (mt)
|
|
{
|
|
case MeasurementTypes.MEASTYPE_FULLBRIDGE: return "Full Bridge";
|
|
case MeasurementTypes.MEASTYPE_HALFBRIDGE: return "Half Bridge";
|
|
case MeasurementTypes.MEASTYPE_VOLTAGE: return "Voltage Mode";
|
|
case MeasurementTypes.MEASTYPE_IRTRACC: return "IRTRACC";
|
|
case MeasurementTypes.MEASTYPE_VOLTAGE_FB: return "Voltage Mode FB";
|
|
case MeasurementTypes.MEASTYPE_POTENTIOMETER_FB: return "Potentiometer FB";
|
|
case MeasurementTypes.MEASTYPE_POTENTIOMETER_HB: return "Potentiometer HB";
|
|
case MeasurementTypes.MEASTYPE_ARS_ANGLE: return "Angular Rate Sensor - Angle";
|
|
default:
|
|
throw new NotSupportedException("unknown measurement type: " + mt.ToString());
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// all possible tags/columns in CSV
|
|
/// </summary>
|
|
public enum TAGS
|
|
{
|
|
SENSOR_CSV_LABEL_SERIAL_NO,
|
|
SENSOR_CSV_LABEL_COMMENT,
|
|
SENSOR_CSV_LABEL_EID,
|
|
SENSOR_CSV_LABEL_CALDATE,
|
|
SENSOR_CSV_LABEL_MANUFACTURER,
|
|
SENSOR_CSV_LABEL_SENSOR_TYPE,
|
|
SENSOR_CSV_LABEL_UNITS,
|
|
SENSOR_CSV_LABEL_CAPACITY_EU,
|
|
SENSOR_CSV_LABEL_MEASUREMENT_TYPE,
|
|
SENSOR_CSV_LABEL_EXCITATION_VOLTS,
|
|
SENSOR_CSV_LABEL_SENSITIVITY,
|
|
SENSOR_CSV_LABEL_SENSITIVITY_UNITS,
|
|
SENSOR_CSV_LABEL_INVERT,
|
|
SENSOR_CSV_LABEL_USE_SHUNT_CAL,
|
|
SENSOR_CSV_LABEL_BRIDGE_RESISTANCE_OHMS,
|
|
SENSOR_CSV_LABEL_ZMO_MV,
|
|
SENSOR_CSV_LABEL_ZMO_UPDATE_MV,
|
|
SENSOR_CSV_LABEL_ZMO_TOLERANCE_MV,
|
|
SENSOR_CSV_LABEL_REMOVE_ZMO_OFFSET,
|
|
SENSOR_CSV_LABEL_TEST_DEVICE,
|
|
SENSOR_CSV_LABEL_TEST_DEVICE_TYPE,
|
|
SENSOR_CSV_LABEL_CODE,
|
|
SENSOR_CSV_LABEL_JCODE,
|
|
SENSOR_CSV_LABEL_FILTER_TYPE,
|
|
SENSOR_CSV_LABEL_FILTER_FREQUENCY,
|
|
SENSOR_CSV_LABEL_RANGE_0,
|
|
SENSOR_CSV_LABEL_RANGE_1,
|
|
SENSOR_CSV_LABEL_RANGE_2,
|
|
SENSOR_CSV_LABEL_RANGE_3,
|
|
SENSOR_CSV_LABEL_TOYOTA_CALC_1,
|
|
SENSOR_CSV_LABEL_TOYOTA_CALC_2,
|
|
SENSOR_CSV_LABEL_TOYOTA_CALC_3,
|
|
SENSOR_CSV_LABEL_ZERO_METHOD,
|
|
SENSOR_CSV_LABEL_ZERO_INITIAL_EU,
|
|
SENSOR_CSV_LABEL_ZERO_TIME_START_MSEC,
|
|
SENSOR_CSV_LABEL_ZERO_TIME_END_MSEC,
|
|
SENSOR_CSV_LABEL_FLAGS,
|
|
UNKNOWN //any flag we don't know gets stuffed into unkown
|
|
}
|
|
/// <summary>
|
|
/// goes from a tag to a string/label (columns/fields)
|
|
/// </summary>
|
|
/// <param name="tag"></param>
|
|
/// <returns></returns>
|
|
private static string TagToLabel(TAGS tag)
|
|
{
|
|
switch (tag)
|
|
{
|
|
case TAGS.SENSOR_CSV_LABEL_SERIAL_NO: return "Serial No";
|
|
case TAGS.SENSOR_CSV_LABEL_COMMENT: return "Comment";
|
|
case TAGS.SENSOR_CSV_LABEL_EID: return "EID";
|
|
case TAGS.SENSOR_CSV_LABEL_CALDATE: return "Calibration Date";
|
|
case TAGS.SENSOR_CSV_LABEL_MANUFACTURER: return "Manufacturer";
|
|
case TAGS.SENSOR_CSV_LABEL_SENSOR_TYPE: return "Sensor Type";
|
|
case TAGS.SENSOR_CSV_LABEL_UNITS: return "Units";
|
|
case TAGS.SENSOR_CSV_LABEL_CAPACITY_EU: return "Capacity (EU)";
|
|
case TAGS.SENSOR_CSV_LABEL_MEASUREMENT_TYPE: return "Measurement Type";
|
|
case TAGS.SENSOR_CSV_LABEL_EXCITATION_VOLTS: return "Excitation Volts";
|
|
case TAGS.SENSOR_CSV_LABEL_SENSITIVITY: return "Sensitivity";
|
|
case TAGS.SENSOR_CSV_LABEL_SENSITIVITY_UNITS: return "Sensitivity Units";
|
|
case TAGS.SENSOR_CSV_LABEL_INVERT: return "Invert (1 = Yes, 0 = No)";
|
|
case TAGS.SENSOR_CSV_LABEL_USE_SHUNT_CAL: return "Use Shunt Cal (1 = Yes, 0 = No)";
|
|
case TAGS.SENSOR_CSV_LABEL_BRIDGE_RESISTANCE_OHMS: return "Bridge Resistance Ohms";
|
|
case TAGS.SENSOR_CSV_LABEL_ZMO_MV: return "ZMO mV";
|
|
case TAGS.SENSOR_CSV_LABEL_ZMO_UPDATE_MV: return "ZMO Updated mV";
|
|
case TAGS.SENSOR_CSV_LABEL_ZMO_TOLERANCE_MV: return "ZMO Tolerance mV";
|
|
case TAGS.SENSOR_CSV_LABEL_REMOVE_ZMO_OFFSET: return "Remove ZMO Offset";
|
|
case TAGS.SENSOR_CSV_LABEL_TEST_DEVICE: return "Test Device (DO NOT CHANGE)";
|
|
case TAGS.SENSOR_CSV_LABEL_TEST_DEVICE_TYPE: return "Test Device Type (DO NOT CHANGE)";
|
|
case TAGS.SENSOR_CSV_LABEL_CODE: return "Ch. Code (DO NOT CHANGE)";
|
|
case TAGS.SENSOR_CSV_LABEL_JCODE: return "J Code (DO NOT CHANGE)";
|
|
case TAGS.SENSOR_CSV_LABEL_FILTER_TYPE: return "Filter Type";
|
|
case TAGS.SENSOR_CSV_LABEL_FILTER_FREQUENCY: return "Filter Frequency";
|
|
case TAGS.SENSOR_CSV_LABEL_RANGE_0: return "Low Range";
|
|
case TAGS.SENSOR_CSV_LABEL_RANGE_1: return "Medium Range";
|
|
case TAGS.SENSOR_CSV_LABEL_RANGE_2: return "High Range";
|
|
case TAGS.SENSOR_CSV_LABEL_RANGE_3: return "Arbitrary Range";
|
|
case TAGS.SENSOR_CSV_LABEL_TOYOTA_CALC_1: return "Toyota Calc 1";
|
|
case TAGS.SENSOR_CSV_LABEL_TOYOTA_CALC_2: return "Toyota Calc 2";
|
|
case TAGS.SENSOR_CSV_LABEL_TOYOTA_CALC_3: return "Toyota Calc 3";
|
|
case TAGS.SENSOR_CSV_LABEL_ZERO_METHOD: return "Zero Method";
|
|
case TAGS.SENSOR_CSV_LABEL_ZERO_INITIAL_EU: return "Zero Initial EU";
|
|
case TAGS.SENSOR_CSV_LABEL_ZERO_TIME_START_MSEC: return "Zero Start Time ms";
|
|
case TAGS.SENSOR_CSV_LABEL_ZERO_TIME_END_MSEC: return "Zero End Time ms";
|
|
case TAGS.SENSOR_CSV_LABEL_FLAGS: return "Flags";
|
|
}
|
|
throw new NotSupportedException("Unknown tag: " + tag.ToString());
|
|
}
|
|
/// <summary>
|
|
/// goes from a label to a tag/string (columns/fields)
|
|
/// </summary>
|
|
/// <param name="label"></param>
|
|
/// <returns></returns>
|
|
public static TAGS LabelToTag(string label)
|
|
{
|
|
switch (label)
|
|
{
|
|
case "Serial No": return TAGS.SENSOR_CSV_LABEL_SERIAL_NO;
|
|
case "Comment": return TAGS.SENSOR_CSV_LABEL_COMMENT;
|
|
case "EID": return TAGS.SENSOR_CSV_LABEL_EID;
|
|
case "Calibration Date": return TAGS.SENSOR_CSV_LABEL_CALDATE;
|
|
case "Manufacturer": return TAGS.SENSOR_CSV_LABEL_MANUFACTURER;
|
|
case "Sensor Type": return TAGS.SENSOR_CSV_LABEL_SENSOR_TYPE;
|
|
case "Units": return TAGS.SENSOR_CSV_LABEL_UNITS;
|
|
case "Capacity (EU)": return TAGS.SENSOR_CSV_LABEL_CAPACITY_EU;
|
|
case "Measurement Type": return TAGS.SENSOR_CSV_LABEL_MEASUREMENT_TYPE;
|
|
case "Excitation Volts": return TAGS.SENSOR_CSV_LABEL_EXCITATION_VOLTS;
|
|
case "Sensitivity": return TAGS.SENSOR_CSV_LABEL_SENSITIVITY;
|
|
case "Sensitivity Units": return TAGS.SENSOR_CSV_LABEL_SENSITIVITY_UNITS;
|
|
case "Invert (1 = Yes, 0 = No)": return TAGS.SENSOR_CSV_LABEL_INVERT;
|
|
case "Use Shunt Cal (1 = Yes, 0 = No)": return TAGS.SENSOR_CSV_LABEL_USE_SHUNT_CAL;
|
|
case "Bridge Resistance Ohms": return TAGS.SENSOR_CSV_LABEL_BRIDGE_RESISTANCE_OHMS;
|
|
case "ZMO mV": return TAGS.SENSOR_CSV_LABEL_ZMO_MV;
|
|
case "ZMO Updated mV": return TAGS.SENSOR_CSV_LABEL_ZMO_UPDATE_MV;
|
|
case "ZMO Tolerance mV": return TAGS.SENSOR_CSV_LABEL_ZMO_TOLERANCE_MV;
|
|
case "Remove ZMO Offset": return TAGS.SENSOR_CSV_LABEL_REMOVE_ZMO_OFFSET;
|
|
case "Test Device (DO NOT CHANGE)": return TAGS.SENSOR_CSV_LABEL_TEST_DEVICE;
|
|
case "Test Device Type (DO NOT CHANGE)": return TAGS.SENSOR_CSV_LABEL_TEST_DEVICE_TYPE;
|
|
case "Ch. Code (DO NOT CHANGE)": return TAGS.SENSOR_CSV_LABEL_CODE;
|
|
case "J Code (DO NOT CHANGE)": return TAGS.SENSOR_CSV_LABEL_JCODE;
|
|
case "Filter Type": return TAGS.SENSOR_CSV_LABEL_FILTER_TYPE;
|
|
case "Filter Frequency": return TAGS.SENSOR_CSV_LABEL_FILTER_FREQUENCY;
|
|
case "Low Range": return TAGS.SENSOR_CSV_LABEL_RANGE_0;
|
|
case "Medium Range": return TAGS.SENSOR_CSV_LABEL_RANGE_1;
|
|
case "High Range": return TAGS.SENSOR_CSV_LABEL_RANGE_2;
|
|
case "Arbitrary Range": return TAGS.SENSOR_CSV_LABEL_RANGE_3;
|
|
case "Toyota Calc 1": return TAGS.SENSOR_CSV_LABEL_TOYOTA_CALC_1;
|
|
case "Toyota Calc 2": return TAGS.SENSOR_CSV_LABEL_TOYOTA_CALC_2;
|
|
case "Toyota Calc 3": return TAGS.SENSOR_CSV_LABEL_TOYOTA_CALC_3;
|
|
case "Zero Method": return TAGS.SENSOR_CSV_LABEL_ZERO_METHOD;
|
|
case "Zero Initial EU": return TAGS.SENSOR_CSV_LABEL_ZERO_INITIAL_EU;
|
|
case "Zero Start Time ms": return TAGS.SENSOR_CSV_LABEL_ZERO_TIME_START_MSEC;
|
|
case "Zero End Time ms": return TAGS.SENSOR_CSV_LABEL_ZERO_TIME_END_MSEC;
|
|
case "Flags": return TAGS.SENSOR_CSV_LABEL_FLAGS;
|
|
}
|
|
throw new NotSupportedException("unknown tag: " + label);
|
|
}
|
|
|
|
public static DTS.SensorDB.SensorData GetSensor(string[] tokens, TAGS[] tagOrder, ref List<string> errors, Dictionary<string, string> sensorTypeToDimension)
|
|
{
|
|
DTS.SensorDB.SensorData sd = new SensorData();
|
|
sd.Calibration = new SensorCalibration();
|
|
|
|
|
|
double filterFrequency = 0D;
|
|
FilterTypes filterType = FilterTypes.FILTERTYPE_NONE;
|
|
string calc1 = "";
|
|
string calc2 = "";
|
|
string calc3 = "";
|
|
double dSensitivity = 0D;
|
|
for (int i = 0; i < tokens.Length && i < tagOrder.Length; i++)
|
|
{
|
|
var tag = tagOrder[i];
|
|
string sItem = tokens[i].Trim();
|
|
//remove starting =" if found
|
|
if (sItem.StartsWith("=")) { sItem = sItem.Substring(1); }
|
|
//remove starting and trailing "
|
|
if (sItem.StartsWith("\"") && sItem.EndsWith("\""))
|
|
{
|
|
sItem = sItem.Substring(1, sItem.Length - 2);
|
|
}
|
|
try
|
|
{
|
|
switch (tag)
|
|
{
|
|
case TAGS.SENSOR_CSV_LABEL_FLAGS:
|
|
//indicates marked for deletion ...
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_BRIDGE_RESISTANCE_OHMS:
|
|
{
|
|
sItem = sItem.Trim();
|
|
double d;
|
|
if (double.TryParse(sItem, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out d))
|
|
{
|
|
sd.BridgeResistance = d;
|
|
}
|
|
else { errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); }
|
|
}
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_CALDATE:
|
|
{
|
|
sItem = sItem.Trim();
|
|
if (string.IsNullOrWhiteSpace(sItem))
|
|
{
|
|
sd.Calibration.CalibrationDate = (DateTime)System.Data.SqlTypes.SqlDateTime.MinValue;
|
|
}
|
|
else
|
|
{
|
|
string[] subtokens = new string[0];
|
|
|
|
string sDay = "";
|
|
string sMonth = "";
|
|
string sYear = "";
|
|
|
|
if (sItem.Contains("/"))
|
|
{
|
|
sItem = sItem.Replace("//", "/");
|
|
subtokens = sItem.Split('/');
|
|
if (3 == subtokens.Length) { sYear = subtokens[2]; sMonth = subtokens[0]; sDay = subtokens[1]; }
|
|
}
|
|
else if (sItem.Contains("-"))
|
|
{
|
|
subtokens = sItem.Split('-');
|
|
if (3 == subtokens.Length) { sYear = subtokens[0]; sMonth = subtokens[1]; sDay = subtokens[2]; }
|
|
}
|
|
|
|
|
|
if (3 != subtokens.Length)
|
|
{
|
|
errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem));
|
|
sd.Calibration.CalibrationDate = (DateTime)System.Data.SqlTypes.SqlDateTime.MinValue;
|
|
}
|
|
else
|
|
{
|
|
int d;
|
|
int m;
|
|
int y;
|
|
if (int.TryParse(sMonth, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out m)
|
|
&& int.TryParse(sDay, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out d)
|
|
&& int.TryParse(sYear, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out y))
|
|
{
|
|
try
|
|
{
|
|
sd.Calibration.CalibrationDate = new DateTime(y, m, d);
|
|
}
|
|
catch (System.Exception)
|
|
{
|
|
errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem));
|
|
sd.Calibration.CalibrationDate = (DateTime)System.Data.SqlTypes.SqlDateTime.MinValue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem));
|
|
sd.Calibration.CalibrationDate = (DateTime)System.Data.SqlTypes.SqlDateTime.MinValue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_CAPACITY_EU:
|
|
{
|
|
sItem = sItem.Trim();
|
|
double d;
|
|
if (double.TryParse(sItem, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out d))
|
|
{
|
|
sd.Capacity = d;
|
|
}
|
|
else { errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); }
|
|
}
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_CODE:
|
|
sd.UserValue2 = sItem;
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_COMMENT:
|
|
sd.Comment = sItem;
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_EID:
|
|
if (!string.IsNullOrWhiteSpace(sItem))
|
|
{
|
|
sd.EID = sItem;
|
|
}
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_EXCITATION_VOLTS:
|
|
{
|
|
double d;
|
|
if (!double.TryParse(sItem.Trim(), System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out d))
|
|
{
|
|
errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem));
|
|
}
|
|
else
|
|
{
|
|
if (0 == d) { d = 5D; }//handle the "Voltage Insertion" mode, which is a 0 in the CSV for excitation
|
|
var exc = DTS.Common.DAS.Concepts.Test.Module.Channel.Sensor.GetExcitationVoltageEnumFromMagnitude(d);
|
|
sd.SupportedExcitation = new ExcitationVoltageOptions.ExcitationVoltageOption[] { exc };
|
|
sd.Calibration.Records.Records[0].Excitation = exc;
|
|
}
|
|
}
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_FILTER_FREQUENCY:
|
|
{
|
|
double d;
|
|
if (double.TryParse(sItem.Trim(), System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out d))
|
|
{
|
|
filterFrequency = d;
|
|
}
|
|
else { errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); }
|
|
}
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_FILTER_TYPE:
|
|
{
|
|
int iType;
|
|
if (int.TryParse(sItem.Trim(), System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out iType))
|
|
{
|
|
filterType = (FilterTypes)iType;
|
|
}
|
|
else { errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); }
|
|
}
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_INVERT:
|
|
{
|
|
sItem = sItem.Trim();
|
|
switch (sItem.ToUpper())
|
|
{
|
|
case "0":
|
|
case "F":
|
|
case "N": sd.Invert = false; break;
|
|
case "1":
|
|
case "Y":
|
|
case "T": sd.Invert = true; break;
|
|
default:
|
|
errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem));
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_JCODE:
|
|
{
|
|
sd.UserValue1 = sItem;
|
|
}
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_MANUFACTURER:
|
|
{
|
|
sd.Manufacturer = sItem;
|
|
}
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_MEASUREMENT_TYPE:
|
|
{
|
|
var type = LabelToMeasurementType(sItem.Trim());
|
|
switch (type)
|
|
{
|
|
case MeasurementTypes.MEASTYPE_ARS_ANGLE:
|
|
sd.Bridge = SensorConstants.BridgeType.FullBridge;
|
|
break;
|
|
case MeasurementTypes.MEASTYPE_FULLBRIDGE:
|
|
sd.Bridge = SensorConstants.BridgeType.FullBridge;
|
|
break;
|
|
case MeasurementTypes.MEASTYPE_HALFBRIDGE:
|
|
sd.Bridge = SensorConstants.BridgeType.HalfBridge_SigPlus;
|
|
break;
|
|
case MeasurementTypes.MEASTYPE_IRTRACC:
|
|
sd.Bridge = SensorConstants.BridgeType.FullBridge;
|
|
sd.Calibration.NonLinear = true;
|
|
sd.Calibration.Records.Records[0].Poly.NonLinearStyle = NonLinearStyles.IRTraccDiagnosticsZero;
|
|
sd.Calibration.Records.Records[0].Poly.MarkValid(true);
|
|
break;
|
|
case MeasurementTypes.MEASTYPE_POTENTIOMETER_FB:
|
|
sd.Bridge = SensorConstants.BridgeType.FullBridge;
|
|
break;
|
|
case MeasurementTypes.MEASTYPE_POTENTIOMETER_HB:
|
|
sd.Bridge = SensorConstants.BridgeType.HalfBridge_SigPlus;
|
|
break;
|
|
case MeasurementTypes.MEASTYPE_VOLTAGE:
|
|
sd.Bridge = SensorConstants.BridgeType.HalfBridge_SigPlus;
|
|
break;
|
|
case MeasurementTypes.MEASTYPE_VOLTAGE_FB:
|
|
sd.Bridge = SensorConstants.BridgeType.FullBridge;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_RANGE_0:
|
|
{
|
|
double d;
|
|
if (double.TryParse(sItem.Trim(), System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out d))
|
|
{
|
|
sd.RangeLow = d;
|
|
}
|
|
else { errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); }
|
|
}
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_RANGE_1:
|
|
{
|
|
double d;
|
|
if (double.TryParse(sItem.Trim(), System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out d))
|
|
{
|
|
sd.RangeMedium = d;
|
|
}
|
|
else { errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); }
|
|
}
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_RANGE_2:
|
|
{
|
|
double d;
|
|
if (double.TryParse(sItem.Trim(), System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out d))
|
|
{
|
|
sd.RangeHigh = d;
|
|
}
|
|
else { errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); }
|
|
}
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_RANGE_3:
|
|
{
|
|
/*double d;
|
|
if (double.TryParse(sItem.Trim(), System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out d))
|
|
{
|
|
sd.Capacity = d;
|
|
}
|
|
else { errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); }*/
|
|
}
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_REMOVE_ZMO_OFFSET:
|
|
{
|
|
switch (sItem.Trim().ToUpper())
|
|
{
|
|
case "1":
|
|
case "T":
|
|
case "Y":
|
|
sd.Calibration.RemoveOffset = true;
|
|
break;
|
|
case "0":
|
|
case "F":
|
|
case "N":
|
|
sd.Calibration.RemoveOffset = false;
|
|
break;
|
|
default:
|
|
errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem));
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_SENSITIVITY:
|
|
{
|
|
double d;
|
|
if (double.TryParse(sItem.Trim(), out d))
|
|
{
|
|
sd.Calibration.Records.Records[0].Sensitivity = d;
|
|
dSensitivity = d;
|
|
}
|
|
else { errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); }
|
|
}
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_SENSITIVITY_UNITS:
|
|
{
|
|
switch (sItem.Trim().ToLower())
|
|
{
|
|
case "mv/v/eu": sd.Calibration.IsProportional = true; sd.Calibration.Records.Records[0].SensitivityUnits = SensorConstants.SensUnits.mVperVperEU; break;
|
|
case "mv/eu": sd.Calibration.IsProportional = false; sd.Calibration.Records.Records[0].SensitivityUnits = SensorConstants.SensUnits.mVperEU; break;
|
|
default: errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); break;
|
|
}
|
|
}
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_SENSOR_TYPE:
|
|
{
|
|
if (!sensorTypeToDimension.ContainsKey(sItem.Trim()))
|
|
{
|
|
errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem));
|
|
}
|
|
else
|
|
{
|
|
sd.PhysicalDimension = sensorTypeToDimension[sItem.Trim()];
|
|
}
|
|
}
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_SERIAL_NO:
|
|
sd.SerialNumber = sItem.Trim();
|
|
sd.Calibration.SerialNumber = sd.SerialNumber;
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_TEST_DEVICE:
|
|
//not currently used
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_TEST_DEVICE_TYPE:
|
|
//not currently used
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_TOYOTA_CALC_1:
|
|
calc1 = sItem.Trim();
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_TOYOTA_CALC_2:
|
|
calc2 = sItem.Trim();
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_TOYOTA_CALC_3:
|
|
calc3 = sItem.Trim();
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_UNITS:
|
|
sItem = sItem.Trim();
|
|
sd.DisplayUnit = sItem.Trim();
|
|
Array.ForEach(sd.Calibration.Records.Records, record => record.EngineeringUnits = sItem.Trim()); //FB16398: set units on all records, not just first
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_USE_SHUNT_CAL:
|
|
{
|
|
switch (sItem.Trim().ToUpper())
|
|
{
|
|
case "0":
|
|
case "F":
|
|
case "N":
|
|
sd.Shunt = ShuntMode.None;
|
|
break;
|
|
case "1":
|
|
case "T":
|
|
case "Y":
|
|
sd.Shunt = ShuntMode.Emulation;
|
|
break;
|
|
default:
|
|
errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem));
|
|
break;
|
|
|
|
}
|
|
}
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_ZERO_INITIAL_EU:
|
|
{
|
|
double d;
|
|
if (double.TryParse(sItem.Trim(), System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out d))
|
|
{//TODO: linear/nonlinear
|
|
sd.Calibration.InitialOffsets = new InitialOffsets(new InitialOffset(d));
|
|
}
|
|
}
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_ZERO_METHOD:
|
|
{
|
|
int iTemp;
|
|
if (int.TryParse(sItem.Trim(), System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out iTemp))
|
|
{
|
|
ZeroMethods zm = (ZeroMethods)iTemp;
|
|
switch (zm)
|
|
{
|
|
case ZeroMethods.ZMETHOD_AVGTIME: sd.Calibration.ZeroMethods.Methods[0].Method = ZeroMethodType.AverageOverTime; break;
|
|
case ZeroMethods.ZMETHOD_EQUALS0MV: sd.Calibration.ZeroMethods.Methods[0].Method = ZeroMethodType.None; break;
|
|
case ZeroMethods.ZMETHOD_PREZERO: sd.Calibration.ZeroMethods.Methods[0].Method = ZeroMethodType.UsePreEventDiagnosticsZero; break;
|
|
default: errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); break;
|
|
}
|
|
}
|
|
else { errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); }
|
|
}
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_ZERO_TIME_END_MSEC:
|
|
{
|
|
double d;
|
|
if (double.TryParse(sItem.Trim(), System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out d))
|
|
{//TODO: linear/nonlinear
|
|
sd.Calibration.ZeroMethods.Methods[0].End = d;
|
|
}
|
|
else { errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); }
|
|
}
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_ZERO_TIME_START_MSEC:
|
|
{
|
|
double d;
|
|
if (double.TryParse(sItem.Trim(), System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out d))
|
|
{//TODO: linear/nonlinear
|
|
sd.Calibration.ZeroMethods.Methods[0].Start = d;
|
|
}
|
|
else { errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); }
|
|
}
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_ZMO_MV:
|
|
{
|
|
//we don't do anything with this currently
|
|
}
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_ZMO_TOLERANCE_MV:
|
|
{
|
|
double d;
|
|
if (double.TryParse(sItem.Trim(), System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out d))
|
|
{
|
|
sd.OffsetToleranceHigh = d;
|
|
sd.OffsetToleranceLow = -1D * d;
|
|
}
|
|
else { errors.Add(string.Format("{0} Invalid: {1}", tag.ToString(), sItem)); }
|
|
}
|
|
break;
|
|
case TAGS.SENSOR_CSV_LABEL_ZMO_UPDATE_MV:
|
|
{
|
|
//we don't do anything with this currently
|
|
}
|
|
break;
|
|
case TAGS.UNKNOWN:
|
|
break;
|
|
}
|
|
}
|
|
catch (System.Exception ex)
|
|
{
|
|
errors.Add("problem handing " + tag.ToString() + ": " + ex.Message);
|
|
}
|
|
}
|
|
sd.UserValue3 = string.Format("{0}{1}{2}{1}{3}", calc1, System.Globalization.CultureInfo.InvariantCulture.TextInfo.ListSeparator, calc2, calc3);
|
|
if (sd.Calibration.NonLinear)
|
|
{
|
|
sd.Calibration.Records.Records[0].Sensitivity = 0;
|
|
sd.Calibration.Records.Records[0].Poly.LinearizationExponent = -75D / 175D;
|
|
sd.Calibration.Records.Records[0].Poly.MMPerV = 1000D / dSensitivity;
|
|
}
|
|
switch (filterType)
|
|
{
|
|
case FilterTypes.FILTERTYPE_CFC1000: sd.Filter = new FilterClass(FilterClassType.CFC1000); break;
|
|
case FilterTypes.FILTERTYPE_CFC180: sd.Filter = new FilterClass(FilterClassType.CFC180); break;
|
|
case FilterTypes.FILTERTYPE_CFC60: sd.Filter = new FilterClass(FilterClassType.CFC60); break;
|
|
case FilterTypes.FILTERTYPE_CFC600: sd.Filter = new FilterClass(FilterClassType.CFC600); break;
|
|
case FilterTypes.FILTERTYPE_FIR100:
|
|
sd.Filter = new FilterClass(FilterClassType.CFC180);
|
|
errors.Add("FIR100 not supported - converting to CFC180");
|
|
break;
|
|
case FilterTypes.FILTERTYPE_NONE: sd.Filter = new FilterClass(FilterClassType.None); break;
|
|
case FilterTypes.FILTERTYPE_UNFILTERED: sd.Filter = new FilterClass(FilterClassType.Unfiltered); break;
|
|
case FilterTypes.FILTERTYPE_USEFREQ: sd.Filter = new FilterClass(filterFrequency); break;
|
|
default:
|
|
errors.Add("unknown filtertype: " + filterType.ToString());
|
|
break;
|
|
}
|
|
sd.UUID = sd.SerialNumber;
|
|
if (sd.Capacity < 1)
|
|
{
|
|
sd.Capacity = 1;
|
|
errors.Add(string.Format("{0} does not have a valid capacity. A capacity of 1 will be used", sd.SerialNumber));
|
|
}
|
|
if (string.IsNullOrWhiteSpace(sd.DisplayUnit))
|
|
{
|
|
sd.DisplayUnit = "g";
|
|
Array.ForEach(sd.Calibration.Records.Records, record => record.EngineeringUnits = "g"); //FB16398: set units on all records, not just first
|
|
errors.Add(string.Format("{0} does not have engineering units specified. A value of 'g' will be used", sd.SerialNumber));
|
|
}
|
|
return sd;
|
|
}
|
|
}
|
|
}
|