Ejemplo n.º 1
0
        bool SetTextForGui(ErrorDefine eDefine, string msgName)
        {
            if (eDefine != C_NO_ERROR)
            {
                // TODO - write log4net here
                _log.Error(msgName + " : " + errObject.GetNotification(errDefine));

                GenerateDBC.SetTextInfo("Info:" + msgName + " : " + errObject.GetNotification(errDefine));
                return(false);
            }
            return(true);
        }
Ejemplo n.º 2
0
        internal bool ValidateData()
        {
            //Log4net
            _log.Info("Validating data...");

            if (!isLoadingDataBefore)
            {
                MessageBox.Show("Please load data before", "Warning", MessageBoxButtons.OK);
                return(false);
            }
            // Clear text append before checking
            GenerateDBC.ClearTextInfo();

            bool flagError = true;

            foreach (Messages msg in canMatrix)
            {
                //check frame info
                errDefine  = CheckMessageInfo(msg);
                flagError &= SetTextForGui(errDefine, msg.MessageName);

                //check node of frame
                errDefine  = CheckListNodeInfo(msg.ListNode);
                flagError &= SetTextForGui(errDefine, msg.MessageName);

                if (flagError)
                {
                    //log4net
                    _log.Info(msg.MessageName + " is OK");
                }

                //Check signal
                foreach (Signal signal in msg.ListSignal)
                {
                    // signal info
                    errDefine  = CheckSignalInfo(signal);
                    flagError &= SetTextForGUI(errDefine, msg.MessageName, signal.SignalName);

                    //check node of signal
                    errDefine  = CheckListNodeInfo(signal.ListNode);
                    flagError &= SetTextForGUI(errDefine, msg.MessageName, signal.SignalName);

                    if (flagError)
                    {
                        //log4net
                        _log.Info("\t" + signal.SignalName + " is OK");
                    }
                }
            }

            return(flagError);
        }
Ejemplo n.º 3
0
 public string GetNotification(ErrorDefine errorType)
 {
     return(ErrorNotification.NotificationString(errorType));
 }
Ejemplo n.º 4
0
 public ErrorObject(ErrorDefine errorType)
 {
     this.errorType          = errorType;
     this.errorMessageOutput = ErrorNotification.NotificationString(errorType);
 }
Ejemplo n.º 5
0
 public void ResetVariable()
 {
     errDefine = C_NO_ERROR;
     canMatrix.Clear();
     isLoadingDataBefore = false;
 }
Ejemplo n.º 6
0
        public static string NotificationString(ErrorDefine errDefine)
        {
            string strOutput;

            switch (errDefine)
            {
                #region Check frame

            case C_ERROR_MSG_NAME_NULL:
                strOutput = " Frame name is missing";
                break;

            case C_ERROR_MSG_ID_NULL:
                strOutput = " Frame ID is missing";
                break;

            case C_ERROR_MSG_SENDTYPE_NULL:
                strOutput = " Frame send type is missing";
                break;

            case C_ERROR_MSG_SENDTYPE_INVALID:
                strOutput = " Frame send type is either Cycle or Event";
                break;

            case C_ERROR_MSG_CYCLETIME_NULL:
                strOutput = " Frame cycle time is missing";
                break;

            case C_ERROR_MSG_CYCLETIME_L_THAN0:
                strOutput = " Frame cycle time must greater than 0";
                break;

            case C_ERROR_MSG_DLC_NULL:
                strOutput = " Frame DLC is missing";
                break;

            case C_ERROR_MSG_DLC_L_THAN0:
                strOutput = " Frame DLC must greater than 0";
                break;

            case C_ERROR_MSG_DLC_G_THAN8:
                strOutput = " Frame DLC must less than 0";
                break;

            case C_ERROR_MSG_NOTSEND_RECEIVE:
                strOutput = " At least Frame must be sent or received by one node!";
                break;

                #endregion !Check frame

                #region Check signal

            case C_ERROR_SGN_NAME_NULL:
                strOutput = " Signal name must be not null";
                break;

            case C_ERROR_SGN_NAME_LENGTH_G_THAN32:
                strOutput = " Signal name length must be less than 32";
                break;

            case C_ERROR_SGN_BYTEORDER_ONLY_LSB_MSB:
                strOutput = " Signal only support for Motorola_LSB and Motorola_MSB";
                break;

            case C_ERROR_SGN_STARTBIT_NULL:
                strOutput = " Signal start bit is missing";
                break;

            case C_ERROR_SGN_STARTBIT_G_THAN63:
                strOutput = " Signal start bit must be less than 63 (start bit <= 63)";
                break;

            case C_ERROR_SGN_BITLENGTH_NULL:
                strOutput = " Signal bit length is missing";
                break;

            case C_ERROR_SGN_BITLENGTH_G_THAN64:
                strOutput = " Signal bit length must be less than 64 (bit length <= 64)";
                break;

            case C_ERROR_SGN_DATATYPE_ONLY_UNSIGNED_SIGNED:
                strOutput = " Signal data type should be UNSIGNED or SIGNED";
                break;

            case C_ERROR_SGN_RESOLUTION_INVALID:
                strOutput = " Signal RESOLUTION is invalid";
                break;

            case C_ERROR_SGN_OFFSET_INVALID:
                strOutput = " Signal OFFSET is invalid";
                break;

            case C_ERROR_SGN_PHYMIN_INVALID:
                strOutput = " Signal physical min is invalid";
                break;

            case C_ERROR_SGN_PHYMAX_INVALID:
                strOutput = " Signal physical max is invalid";
                break;

            case C_ERROR_SGN_HEXMIN_INVALID:
                strOutput = " Signal hexa min is invalid";
                break;

            case C_ERROR_SGN_HEXMAX_INVALID:
                strOutput = " Signal hexa max is invalid";
                break;

            case C_ERROR_SGN_INITVALUE_NULL:
                strOutput = " Signal INITVALUE must be not null";
                break;

            case C_ERROR_SGN_INITVALUE_INVALID:
                strOutput = " Signal INITVALUE is invalid";
                break;

            case C_ERROR_SGN_NOTSEND_RECEIVE:
                strOutput = "  At least signal must be sent or received by one node!";
                break;

                #endregion ! Check signal

            default:
                strOutput = "";
                break;
            }
            return(strOutput);
        }
Ejemplo n.º 7
0
        static void PerformMeasurement(Int32 in_com)
        {
            ColorManagementMISDK sdk = ColorManagementMISDK.GetInstance();
            ReturnMessage        ret = new ReturnMessage();

            // Connect
            ret = sdk.Connect(in_com);
            if (!ErrorDefine.IsNormalCode(ret.errorCode))
            {
                Console.WriteLine("Error:{0:d} Connect", ret.errorCode);
                return;
            }

            // Get instrumentInfo
            InstrumentInfoEx instInfoEx;

            ret = sdk.GetInstrumentInfo(out instInfoEx, in_com);
            if (!ErrorDefine.IsNormalCode(ret.errorCode))
            {
                Console.WriteLine("Error:{0:d} GetInstrumentInfo Ex", ret.errorCode);
                sdk.DisConnect(in_com);
                return;
            }

            if (instInfoEx.Name != "CM-25cG")
            {
                Console.WriteLine("Unsppoted instrument");
                sdk.DisConnect(in_com);
                return;
            }

            // Set measurement mode (color & gloss)
            MeasCondMode mode = MeasCondMode.MeasModeColorAndGloss;

            ret = sdk.SetMeasurementMode(mode, in_com);
            if (!ErrorDefine.IsNormalCode(ret.errorCode))
            {
                Console.WriteLine("Error:{0:d} SetMeasurementMode", ret.errorCode);
                sdk.DisConnect(in_com);
                return;
            }

            // Calibration check
            bool calComplete = false;

            do
            {
                CalStatus calStatus;
                ret = sdk.GetCalibrationStatus(out calStatus, in_com);
                if (!ErrorDefine.IsNormalCode(ret.errorCode))
                {
                    Console.WriteLine("Error:{0:d} GetCalibrationStatus", ret.errorCode);
                    sdk.DisConnect(in_com);
                    return;
                }

                switch (calStatus)
                {
                case CalStatus.StatusZero:
                    // Zero calibration
                    Console.WriteLine("Please set the zero calibration box.");
                    Console.ReadKey();
                    ret = sdk.PerformZeroCalibration(in_com);
                    if (!ErrorDefine.IsNormalCode(ret.errorCode))
                    {
                        Console.WriteLine("Error:{0:d} PerformZeroCalibration", ret.errorCode);
                        sdk.DisConnect(in_com);
                        return;
                    }
                    break;

                case CalStatus.StatusWhite:
                    // White calibration
                    Console.WriteLine("Please set the white calibration box.");
                    Console.ReadKey();
                    ret = sdk.PerformWhiteCalibration(in_com);
                    if (!ErrorDefine.IsNormalCode(ret.errorCode))
                    {
                        Console.WriteLine("Error:{0:d} PerformWhiteCalibration", ret.errorCode);
                        sdk.DisConnect(in_com);
                        return;
                    }
                    break;

                case CalStatus.StatusGloss:
                    // Gloss calibration
                    Console.WriteLine("Please set the gloss calibration box.");
                    Console.ReadKey();
                    ret = sdk.PerformGlossCalibration(in_com);
                    if (!ErrorDefine.IsNormalCode(ret.errorCode))
                    {
                        Console.WriteLine("Error:{0:d} PerformGlossCalibration", ret.errorCode);
                        sdk.DisConnect(in_com);
                        return;
                    }
                    break;

                case CalStatus.StatusUser:
                    // User calibration
                    Console.WriteLine("Please set the User calibration box.");
                    Console.ReadKey();
                    ret = sdk.PerformUserCalibration(in_com);
                    if (!ErrorDefine.IsNormalCode(ret.errorCode))
                    {
                        Console.WriteLine("Error:{0:d} PerformUserCalibration", ret.errorCode);
                        sdk.DisConnect(in_com);
                        return;
                    }
                    break;

                default:
                    calComplete = true;
                    break;
                }
            }while (!calComplete);

            // Perform measurement
            Console.WriteLine("Please set the sample plate.");
            Console.ReadKey();
            ret = sdk.PerformMeasurement(in_com);
            if (!ErrorDefine.IsNormalCode(ret.errorCode))
            {
                Console.WriteLine("Error:{0:d} PerformMeasurement", ret.errorCode);
                sdk.DisConnect(in_com);
                return;
            }

            // Polling measurement
            MeasStatus measStatus;

            do
            {
                ret = sdk.PollingMeasurement(out measStatus, in_com);
                if (!ErrorDefine.IsNormalCode(ret.errorCode))
                {
                    Console.WriteLine("Error:{0:d} PollingMeasurement", ret.errorCode);
                    sdk.DisConnect(in_com);
                    return;
                }
            }while (measStatus != MeasStatus.Idling);

            // Set MeasDataType to display on the screen
            Dictionary <MeasDataType, string> convertMeasColorDataTypeTable = new Dictionary <MeasDataType, string>()
            {
                { MeasDataType.DTYPE_SPEC, "SPEC" },
            };
            Dictionary <MeasDataType, string> convertMeasSpecDataTypeTable = new Dictionary <MeasDataType, string>()
            {
                { MeasDataType.DTYPE_GLOSS, "GLOSS" }, { MeasDataType.DTYPE_SPEC, "SPEC" },
            };

            // Get sample color data
            MeasDataColor measurementColorData = new MeasDataColor();

            measurementColorData.color = ColorSpace.COLOR_LAB;
            ret = sdk.ReadAllLatestData(measurementColorData, in_com);
            if (!ErrorDefine.IsNormalCode(ret.errorCode))
            {
                Console.WriteLine("Error:{0:d} ReadAllLatestData Color", ret.errorCode);
                sdk.DisConnect(in_com);
                return;
            }
            // Colorimetric data display
            foreach (KeyValuePair <MeasDataType, List <double> > data in measurementColorData.data)
            {
                if (convertMeasColorDataTypeTable.ContainsKey(data.Key))
                {
                    Console.WriteLine("{3} L*:{0,6:f2} a*:{1,6:f2} b*:{2,6:f2}", data.Value[0], data.Value[1], data.Value[2], convertMeasColorDataTypeTable[data.Key]);
                }
            }

            // Get sample spec data
            Dictionary <MeasDataType, List <double> > measurementSpecData = new Dictionary <MeasDataType, List <double> >();

            ret = sdk.ReadAllLatestData(out measurementSpecData, in_com);
            if (!ErrorDefine.IsNormalCode(ret.errorCode))
            {
                Console.WriteLine("Error:{0:d} ReadAllLatestData Spec", ret.errorCode);
                sdk.DisConnect(in_com);
                return;
            }
            // Spectral data display
            if (measurementSpecData.Count != 0)
            {
                Console.Write("      ");
                foreach (MeasDataType key in measurementSpecData.Keys)
                {
                    if (convertMeasSpecDataTypeTable.ContainsKey(key))
                    {
                        Console.Write("{0:s},   ", convertMeasSpecDataTypeTable[key]);
                    }
                }
                Console.Write('\n');

                int waveLength   = instInfoEx.WaveLengthStart;
                int maxWaveCount = ((instInfoEx.WaveLengthEnd - instInfoEx.WaveLengthStart) / instInfoEx.WaveLengthPitch) + 1;
                for (Int32 count = 0; count < maxWaveCount; count++)
                {
                    Console.Write("{0:d3}: ", waveLength);
                    foreach (MeasDataType key in measurementSpecData.Keys)
                    {
                        if (convertMeasSpecDataTypeTable.ContainsKey(key))
                        {
                            Console.Write("{0,6:f2}, ", measurementSpecData[key][count]);
                        }
                    }
                    Console.Write('\n');
                    waveLength += instInfoEx.WaveLengthPitch;
                }
            }

            // Disconnect
            sdk.DisConnect(in_com);

            return;
        }
Ejemplo n.º 8
0
        static void WriteTargetData(Int32 in_com)
        {
            ColorManagementMISDK sdk = ColorManagementMISDK.GetInstance();

            // Connect
            ReturnMessage ret = sdk.Connect(in_com);

            if (!ErrorDefine.IsNormalCode(ret.errorCode))
            {
                Console.WriteLine("Error:{0:d} Connect", ret.errorCode);
                return;
            }

            // Get instrumentInfo
            InstrumentInfoEx instInfoEx;

            ret = sdk.GetInstrumentInfo(out instInfoEx, in_com);
            if (!ErrorDefine.IsNormalCode(ret.errorCode))
            {
                Console.WriteLine("Error:{0:d} GetInstrumentInfo Ex", ret.errorCode);
                sdk.DisConnect(in_com);
                return;
            }

            if (instInfoEx.Name != "CM-25cG")
            {
                Console.WriteLine("Unsppoted instrument");
                sdk.DisConnect(in_com);
                return;
            }

            Console.WriteLine("Please input the target number to be written. 1-2500");
            int targetNum = Convert.ToInt32(Console.ReadLine());

            // Set target data
            TargetDataPack targetDataPack = new TargetDataPack();

            // Set time
            targetDataPack.date = DateTime.Now;
            // Set group list
            targetDataPack.group_list = new List <int> {
                0, 0, 0, 0, 0
            };
            // Set name (MAX 30 characters)
            string name = "target:" + targetNum.ToString();

            if (name.Length > 30)
            {
                name.Remove(30);
            }
            targetDataPack.name = name;
            // Set meas mode
            targetDataPack.meas_mode = MeasCondMode.MeasModeColorAndGloss;
            // Set meas area
            targetDataPack.meas_area = MeasArea.AREA_MAV;
            // Set meas type
            targetDataPack.meas_type = MeasType.MEASTYPE_NONE;
            // Set meas angel
            targetDataPack.meas_angle = MeasAngle.MEAS_ANGLE_NONE;
            // Set light direction
            targetDataPack.l_direction = LightDirection.LDIRECTION_NONE;
            // Set meas specular component
            targetDataPack.meas_scie = MeasCondScie.SC_NONE;
            // Set meas UV
            targetDataPack.meas_uv = MeasCondUv.UV_NONE;
            // Set warning level
            targetDataPack.warning_level = 80;
            // Set warning
            targetDataPack.warning = 0;
            // Set diagnosis
            targetDataPack.diagnosis = 0;
            // Set data attribute
            int specOrColor = 0;

            Console.WriteLine("Please set 1 for spectral and 2 for colorimetric.");
            specOrColor = Convert.ToInt32(Console.ReadLine());
            if (specOrColor == 1)
            {
                // spectral data
                targetDataPack.data_attr = DataAttr.DATAATTR_SPEC;
            }
            else
            {
                // colorimetric data
                targetDataPack.data_attr = DataAttr.DATAATTR_LAB;
            }

            // Set target data
            if (specOrColor == 1)
            {
                // spectral data
                List <double> gloss = new List <double>();
                gloss.Add(10.00);
                List <double> data = new List <double>();
                for (Int32 i = instInfoEx.WaveLengthStart; i <= instInfoEx.WaveLengthEnd; i += instInfoEx.WaveLengthPitch)
                {
                    data.Add(100.00);
                }
                targetDataPack.data = new Dictionary <DataId, List <double> >();
                targetDataPack.data.Add(DataId.DATAID_GLOSS, gloss);
                targetDataPack.data.Add(DataId.DATAID_SPEC, data);

                // Set target
                ret = sdk.SetTargetData(targetNum, targetDataPack, in_com);
                if (!ErrorDefine.IsNormalCode(ret.errorCode))
                {
                    Console.WriteLine("Error:{0:d} SetTargetData", ret.errorCode);
                    sdk.DisConnect(in_com);
                    return;
                }
            }
            else if (specOrColor == 2)
            {
                targetDataPack.data_color      = new ColorData();
                targetDataPack.data_color.obs1 = Observer.Deg10;
                targetDataPack.data_color.ill1 = Illuminant.ILL_D65;
                targetDataPack.data_color.obs2 = Observer.Deg10;
                targetDataPack.data_color.ill2 = Illuminant.ILL_C;

                targetDataPack.data_color.data1 = new Dictionary <DataId, List <double> >();
                List <double> data1 = new List <double>()
                {
                    100.00, 100.00, 100.00
                };
                targetDataPack.data_color.data1.Add(DataId.DATAID_SPEC, data1);

                targetDataPack.data_color.data2 = new Dictionary <DataId, List <double> >();
                List <double> data2 = new List <double>()
                {
                    99.00, 1.10, 1.20
                };
                targetDataPack.data_color.data2.Add(DataId.DATAID_SPEC, data2);

                List <double> gloss = new List <double>()
                {
                    10.00
                };
                targetDataPack.data_color.data1.Add(DataId.DATAID_GLOSS, gloss);
                targetDataPack.data_color.data2.Add(DataId.DATAID_GLOSS, gloss);

                // Set target
                ret = sdk.SetTargetData(targetNum, targetDataPack, in_com);
                if (!ErrorDefine.IsNormalCode(ret.errorCode))
                {
                    Console.WriteLine("Error:{0:d} SetTargetData", ret.errorCode);
                    sdk.DisConnect(in_com);
                    return;
                }
            }
            else
            {
                // specOrColor
                Console.WriteLine("Unsupported");
                sdk.DisConnect(in_com);
                return;
            }

            // Set tolerance for light source primary
            DataForm dataForm = new DataForm();

            dataForm.IrradiationDirection = IrradiationDirection.NO_PARAM;
            dataForm.DataType             = DataType.NO_PARAM;
            ToleranceData  tolerancePrimaryData  = new ToleranceData();
            ToleranceParam tolerancePrimaryParam = new ToleranceParam();

            tolerancePrimaryParam.Upper_enable = 1;
            tolerancePrimaryParam.Upper_value  = 1.1;
            tolerancePrimaryParam.Lower_enable = 1;
            tolerancePrimaryParam.Lower_value  = -1.2;
            tolerancePrimaryData.Tolerance     = new Dictionary <int, ToleranceParam>();
            tolerancePrimaryData.Tolerance.Add((int)ToleranceId.TOLERANCE_ID_L, tolerancePrimaryParam); //L*
            tolerancePrimaryData.Tolerance.Add((int)ToleranceId.TOLERANCE_ID_A, tolerancePrimaryParam); //a*
            tolerancePrimaryData.Tolerance.Add((int)ToleranceId.TOLERANCE_ID_B, tolerancePrimaryParam); //b*
            ret = sdk.SetToleranceForTarget(targetNum, 0, dataForm, tolerancePrimaryData, in_com);
            if (!ErrorDefine.IsNormalCode(ret.errorCode))
            {
                Console.WriteLine("Error:{0:d} SetToleranceForTarget primary", ret.errorCode);
                sdk.DisConnect(in_com);
                return;
            }

            // Set tolerance for light source secondary
            ToleranceData  toleranceSecondaryData  = new ToleranceData();
            ToleranceParam toleranceSecondaryParam = new ToleranceParam();

            toleranceSecondaryParam.Upper_enable = 0;
            toleranceSecondaryParam.Upper_value  = 2.1;
            toleranceSecondaryParam.Lower_enable = 0;
            toleranceSecondaryParam.Lower_value  = -2.2;
            toleranceSecondaryData.Tolerance     = new Dictionary <int, ToleranceParam>();
            toleranceSecondaryData.Tolerance.Add((int)ToleranceId.TOLERANCE_ID_L, toleranceSecondaryParam); //L*
            toleranceSecondaryData.Tolerance.Add((int)ToleranceId.TOLERANCE_ID_A, toleranceSecondaryParam); //a*
            toleranceSecondaryData.Tolerance.Add((int)ToleranceId.TOLERANCE_ID_B, toleranceSecondaryParam); //b*
            ret = sdk.SetToleranceForTarget(targetNum, 1, dataForm, toleranceSecondaryData, in_com);
            if (!ErrorDefine.IsNormalCode(ret.errorCode))
            {
                Console.WriteLine("Error:{0:d} SetToleranceForTarget secondary", ret.errorCode);
                sdk.DisConnect(in_com);
                return;
            }

            // Set parametric for tolerance
            ParametricCoef parametricData = new ParametricCoef();

            parametricData.CMC = new List <double>();
            parametricData.CMC.Add(1.1);
            parametricData.CMC.Add(1.2);
            parametricData.DeltaE94 = new List <double>();
            parametricData.DeltaE94.Add(2.1);
            parametricData.DeltaE94.Add(2.2);
            parametricData.DeltaE94.Add(2.3);
            parametricData.DeltaE00 = new List <double>();
            parametricData.DeltaE00.Add(3.1);
            parametricData.DeltaE00.Add(3.2);
            parametricData.DeltaE00.Add(3.3);
            ret = sdk.SetParametricForTarget(targetNum, dataForm, parametricData, in_com);
            if (!ErrorDefine.IsNormalCode(ret.errorCode))
            {
                Console.WriteLine("Error:{0:d} SetParametricForTarget", ret.errorCode);
                sdk.DisConnect(in_com);
                return;
            }

            // Disconnect
            sdk.DisConnect(in_com);

            return;
        }
Ejemplo n.º 9
0
        static void ReadSampleData(Int32 in_com)
        {
            ColorManagementMISDK sdk = ColorManagementMISDK.GetInstance();

            // Connect
            ReturnMessage ret = sdk.Connect(in_com);

            if (!ErrorDefine.IsNormalCode(ret.errorCode))
            {
                Console.WriteLine("Error:{0:d} Connect", ret.errorCode);
                return;
            }

            // Get instrumentInfo
            InstrumentInfoEx instInfoEx;

            ret = sdk.GetInstrumentInfo(out instInfoEx, in_com);
            if (!ErrorDefine.IsNormalCode(ret.errorCode))
            {
                Console.WriteLine("Error:{0:d} GetInstrumentInfo Ex", ret.errorCode);
                sdk.DisConnect(in_com);
                return;
            }

            if (instInfoEx.Name != "CM-25cG")
            {
                Console.WriteLine("Unsppoted instrument");
                sdk.DisConnect(in_com);
                return;
            }

            // Get sample count
            Int32 sampleCount = 0;

            ret = sdk.GetSampleCount(out sampleCount, in_com);
            if (!ErrorDefine.IsNormalCode(ret.errorCode))
            {
                Console.WriteLine("Error:{0:d} GetSampleCount", ret.errorCode);
                sdk.DisConnect(in_com);
                return;
            }

            Dictionary <DataId, string> convertDataIDTable1 = new Dictionary <DataId, string>()
            {
                { DataId.DATAID_GLOSS, " GLOSS" }, { DataId.DATAID_SPEC, " SPEC " }
            };

            for (Int32 i = 1; i <= sampleCount; i++)
            {
                SampleData sampleData = new SampleData();
                sampleData.ColorData = new ColorValue();
                SampleDataPack sampleDataPacket = new SampleDataPack();

                // Get sample data
                ret = sdk.GetSampleData(i, sampleDataPacket, in_com);
                if (!ErrorDefine.IsNormalCode(ret.errorCode))
                {
                    Console.WriteLine("Error:{0:d} GetSampleData", ret.errorCode);
                    sdk.DisConnect(in_com);
                    return;
                }
                Console.WriteLine("No.{0:d4} Name:{1} Date:{2}", i, sampleDataPacket.name, sampleDataPacket.date);
                Console.WriteLine("{0} {1}", sampleDataPacket.meas_mode.ToString(), sampleDataPacket.meas_area.ToString());

                // Display data
                if (sampleDataPacket.data != null && sampleDataPacket.data.Count != 0)
                {
                    Console.Write("   , ");
                    foreach (DataId key in sampleDataPacket.data.Keys)
                    {
                        Console.Write("{0:s}, ", convertDataIDTable1[key]);
                    }
                    Console.Write('\n');

                    int maxCount   = sampleDataPacket.data.Values.FirstOrDefault().Count;
                    int WaveLength = instInfoEx.WaveLengthStart;

                    // Spectral & Gloss data display
                    for (Int32 count = 0; count < maxCount; count++)
                    {
                        Console.Write("{0:d3}, ", WaveLength);
                        foreach (DataId key in sampleDataPacket.data.Keys)
                        {
                            Console.Write("{0,6:00.00}, ", sampleDataPacket.data[key][count]);
                        }
                        Console.Write('\n');
                        WaveLength += instInfoEx.WaveLengthPitch;
                    }
                }
            }

            // Disconnect
            sdk.DisConnect(in_com);

            return;
        }