コード例 #1
0
        public InspectionStatistics GetInspectionStatistics(out VBAIDateTime VBAIDateTime)
        {
            InspectionStatistics statistics;

            Error err = vbaiGetInspectionStatistics(_session.nativeSession, out statistics, out VBAIDateTime);

            ExceptionBuilder.CheckErrorAndThrow(err);
            return(statistics);
        }
コード例 #2
0
        public StepResult[] GetInspectionResults(out VBAIDateTime VBAIDateTime, out bool inspectionStatus)
        {
            int size;

            StepResult[] stepResultArray;
            Error        err = vbaiGetInspectionResults(_session.nativeSession, null, out size, out VBAIDateTime, out inspectionStatus);

            if (err != Error.Success)
            {
                stepResultArray = null;
                ExceptionBuilder.CheckErrorAndThrow(err);
                return(stepResultArray);
            }
            stepResultArray = new StepResult[size];
            err             = vbaiGetInspectionResults(_session.nativeSession, stepResultArray, out size, out VBAIDateTime, out inspectionStatus);
            ExceptionBuilder.CheckErrorAndThrow(err);
            return(stepResultArray);
        }
コード例 #3
0
 private static extern Error vbaiSetTargetDateTime(NativeSession session, VBAIDateTime VBAIDateTime, VBAITimeZone VBAITimeZone);
コード例 #4
0
        public void SetTargetDateTime(VBAIDateTime VBAIDateTime, VBAITimeZone VBAITimeZone)
        {
            Error err = vbaiSetTargetDateTime(_session.nativeSession, VBAIDateTime, VBAITimeZone);

            ExceptionBuilder.CheckErrorAndThrow(err);
        }
コード例 #5
0
        public InspectionMeasurements[] GetInspectionMeasurements(string[] stepGUIDs, out VBAIDateTime timeStamp)
        {
            IntPtr measurementsPtr = IntPtr.Zero;
            int    i, j, offset1 = 0, offset2 = 0, index;

            InspectionMeasurements[] measurementsArray;

            MeasurementsPriv     measuresPriv     = new MeasurementsPriv();
            StepMeasurementsPriv stepMeasuresPriv = new StepMeasurementsPriv();
            StepMeasurementPriv  stepMeasurePriv  = new StepMeasurementPriv();
            int size = 0;

            byte[,] guids = null;
            if (stepGUIDs != null)
            {
                if (stepGUIDs.Length != 0)
                {
                    size  = stepGUIDs.Length;
                    guids = new byte[stepGUIDs.Length, 256];

                    for (i = 0; i < stepGUIDs.Length; i++)
                    {
                        byte[] temp = System.Text.Encoding.ASCII.GetBytes(stepGUIDs[i]);
                        for (j = 0; j < temp.Length; j++)
                        {
                            guids[i, j] = temp[j];
                        }
                    }
                }
            }

            Error err = vbaiGetInspectionMeasurements(_session.nativeSession, guids, size, ref measurementsPtr, out timeStamp);

            if (err != Error.Success)
            {
                ExceptionBuilder.CheckErrorAndThrow(err);
                measurementsArray = null;
                return(measurementsArray);
            }
            measuresPriv      = (MeasurementsPriv)Marshal.PtrToStructure(measurementsPtr, typeof(MeasurementsPriv));
            measurementsArray = new InspectionMeasurements[measuresPriv.numSteps];
            for (i = 0; i < measuresPriv.numSteps; i++)
            {
                stepMeasuresPriv = (StepMeasurementsPriv)Marshal.PtrToStructure((IntPtr)((int)measuresPriv.StepMeasurementsIntPtr + offset1), typeof(StepMeasurementsPriv));
                offset1         += Marshal.SizeOf(typeof(StepMeasurementsPriv));
                measurementsArray[i].stepGUID     = String.Copy(stepMeasuresPriv.stepGUID);
                measurementsArray[i].measurements = new StepMeasurements[stepMeasuresPriv.numMeasurements];
                offset2 = 0;
                for (j = 0; j < stepMeasuresPriv.numMeasurements; j++)
                {
                    stepMeasurePriv = (StepMeasurementPriv)Marshal.PtrToStructure((IntPtr)((int)stepMeasuresPriv.MeasurementsIntPtr + offset2), typeof(StepMeasurementPriv));
                    offset2        += Marshal.SizeOf(typeof(StepMeasurementPriv));
                    if (stepMeasurePriv.displayName != null)
                    {
                        measurementsArray[i].measurements[j].displayName = String.Copy(stepMeasurePriv.displayName);
                    }
                    if (stepMeasurePriv.resultGUID != null)
                    {
                        measurementsArray[i].measurements[j].resultGUID = String.Copy(stepMeasurePriv.resultGUID);
                    }
                    if (stepMeasurePriv.unit != null)
                    {
                        measurementsArray[i].measurements[j].unit = String.Copy(stepMeasurePriv.unit);
                    }
                    measurementsArray[i].measurements[j].measurementType  = stepMeasurePriv.measurementType;
                    measurementsArray[i].measurements[j].measurement.type = stepMeasurePriv.measurement.type;
                    switch (measurementsArray[i].measurements[j].measurement.type)
                    {
                    case MeasurementDataType.NumericType:
                        measurementsArray[i].measurements[j].measurement.numData = stepMeasurePriv.measurement.measurement.numeric;
                        break;

                    case MeasurementDataType.BooleanType:
                        measurementsArray[i].measurements[j].measurement.boolData = stepMeasurePriv.measurement.measurement.boolean == 1;
                        break;

                    case MeasurementDataType.StringType:
                        measurementsArray[i].measurements[j].measurement.strData = Marshal.PtrToStringAnsi(stepMeasurePriv.measurement.measurement.strIntPtr);
                        break;

                    case MeasurementDataType.PassFailType:
                        measurementsArray[i].measurements[j].measurement.passData.numericResult = stepMeasurePriv.measurement.measurement.passFail.numericResult;
                        measurementsArray[i].measurements[j].measurement.passData.pass          = stepMeasurePriv.measurement.measurement.passFail.pass == 1;
                        if (stepMeasurePriv.measurement.measurement.passFail.reportTextIntPtr != null)
                        {
                            measurementsArray[i].measurements[j].measurement.passData.reportText = Marshal.PtrToStringAnsi(stepMeasurePriv.measurement.measurement.passFail.reportTextIntPtr);
                        }
                        if (stepMeasurePriv.measurement.measurement.passFail.stringResultIntPtr != null)
                        {
                            measurementsArray[i].measurements[j].measurement.passData.stringResult = Marshal.PtrToStringAnsi(stepMeasurePriv.measurement.measurement.passFail.stringResultIntPtr);
                        }
                        break;

                    case MeasurementDataType.ArrayType:
                        ArrayMeasurementPriv arrayData = stepMeasurePriv.measurement.measurement.arrayData;
                        measurementsArray[i].measurements[j].measurement.arrayData.type = arrayData.type;
                        if (arrayData.size != 0)
                        {
                            if (arrayData.type == ArrayDataType.Numeric1DType)
                            {
                                measurementsArray[i].measurements[j].measurement.arrayData.numArrayData = new double[arrayData.size];
                                Marshal.Copy(arrayData.arrayDataIntPtr, measurementsArray[i].measurements[j].measurement.arrayData.numArrayData, 0, (int)arrayData.size);
                            }
                            else if (arrayData.type == ArrayDataType.Boolean1DType)
                            {
                                measurementsArray[i].measurements[j].measurement.arrayData.boolArrayData = new bool[arrayData.size];
                                int[] tempBoolArray = new int[arrayData.size];
                                Marshal.Copy(arrayData.arrayDataIntPtr, tempBoolArray, 0, (int)arrayData.size);
                                for (index = 0; index < arrayData.size; index++)
                                {
                                    measurementsArray[i].measurements[j].measurement.arrayData.boolArrayData[index] = tempBoolArray[index] == 1;
                                }
                            }
                            else
                            {
                                measurementsArray[i].measurements[j].measurement.arrayData.strArrayData = new string[arrayData.size];
                                for (index = 0; index < arrayData.size; index++)
                                {
                                    // We have a char**, so dereference once to get char*
                                    IntPtr deref = (IntPtr)Marshal.PtrToStructure((IntPtr)((int)arrayData.arrayDataIntPtr + 4 * index), typeof(IntPtr));
                                    measurementsArray[i].measurements[j].measurement.arrayData.strArrayData[index] = Marshal.PtrToStringAnsi(deref);
                                }
                            }
                        }
                        break;

                    default:
                        break;
                    }
                }
            }

            return(measurementsArray);
        }
コード例 #6
0
 private static extern Error vbaiGetInspectionStatistics(NativeSession session, out InspectionStatistics stats, out VBAIDateTime VBAIDateTime);
コード例 #7
0
 private static extern Error vbaiGetInspectionMeasurements(NativeSession session, byte[,] stepGUIDs, int numGUIDs, ref IntPtr measurements, out VBAIDateTime VBAIDateTime);
コード例 #8
0
 private static extern Error vbaiGetInspectionResults(NativeSession session, [In, Out] StepResult[] stepResultArray, out int size, out VBAIDateTime VBAIDateTime, out bool inspectionStatus);