HOZ/SmartSEMControl/SmartSEM.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;

using APILib;
using System.Threading;

namespace SmartSEMControl
{
    public class SmartSEM
    {
        #region 参数
        //放大缩小
        private String AP_MAG = "AP_MAG";
        //焦距
        private String AP_WD = "AP_WD";
        //亮度
        private String AP_BRIGHTNESS = "AP_BRIGHTNESS";
        //对比度
        private String AP_CONTRAST = "AP_CONTRAST";
        //消像散X轴
        private String AP_STIG_X = "AP_STIG_X";
        //消像散Y轴
        private String AP_STIG_Y = "AP_STIG_Y";
        //角度补偿
        private String AP_TILT_ANGLE = "AP_TILT_ANGLE";
        //X轴移动到
        private String AP_STAGE_GOTO_X = "AP_STAGE_GOTO_X";
        //Y轴移动到
        private String AP_STAGE_GOTO_Y = "AP_STAGE_GOTO_Y";
        //Z轴移动到
        private String AP_STAGE_GOTO_Z = "AP_STAGE_GOTO_Z";
        //T轴移动到
        private String AP_STAGE_GOTO_T = "AP_STAGE_GOTO_T";
        //R轴移动到
        private String AP_STAGE_GOTO_R = "AP_STAGE_GOTO_R";
        //M轴移动到
        private String AP_STAGE_GOTO_M = "AP_STAGE_GOTO_M";
        //Scan Rotate角度
        private String AP_SCANROTATION = "AP_SCANROTATION";
        //像素大小
        private String AP_PIXEL_SIZE = "AP_PIXEL_SIZE";
        //X轴坐标
        private String AP_STAGE_AT_X = "AP_STAGE_AT_X";
        //Y轴坐标
        private String AP_STAGE_AT_Y = "AP_STAGE_AT_Y";
        //Z轴坐标
        private String AP_STAGE_AT_Z = "AP_STAGE_AT_Z";
        //T轴坐标
        private String AP_STAGE_AT_T = "AP_STAGE_AT_T";
        //R轴坐标
        private String AP_STAGE_AT_R = "AP_STAGE_AT_R";
        //M轴坐标
        private String AP_STAGE_AT_M = "AP_STAGE_AT_M";
        #endregion

        #region 命令
        //开启电压
        private String CMD_BEAM_ON = "CMD_BEAM_ON";
        //关闭电压
        private String CMD_EHT_OFF = "CMD_EHT_OFF";
        #endregion

        #region APILib
        private Api CZEMApi = new Api();
        private Boolean m_bInitialised = false;
        private long lrt = 0;
        #endregion

        #region 设备初始化
        /// <summary>
        /// 设备初始化
        /// </summary>
        /// <returns>return:true or false</returns>
        public Boolean Init()
        {
<<<<<<< HEAD
            //lrt = CZEMApi.Initialise("");
            lrt = CZEMApi.InitialiseRemoting();
            if (lrt!=0)
=======
            lrt = CZEMApi.Initialise("");
            if (lrt != 0)
            {
                m_bInitialised = false;
                return false;
            }
            else
            {
                m_bInitialised = true;
                return true;
            }
        }
        #endregion

        #region 设备远程初始化
        /// <summary>
        /// 设备远程初始化
        /// </summary>
        /// <returns>return:true or false</returns>
        public Boolean InitRemoting()
        {
            lrt = CZEMApi.InitialiseRemoting();
            if (lrt != 0)
>>>>>>> d024f5d5b8a815002f9bb9d30c911d0849ddba85
            {
                m_bInitialised = false;
                return false;
            }
            else
            {
                m_bInitialised = true;
                return true;
            }
        }
        #endregion

        #region 关闭设备
        /// <summary>
        /// 关闭设备
        /// </summary>
        /// <returns>true or false</returns>
        public Boolean UnInit()
        {
            if (m_bInitialised)
            {
                lrt = CZEMApi.ClosingControl();
                if (lrt != 0)
                {
                    return false;
                }
                else
                {
                    m_bInitialised = false;
                    return true;
                }
            }
            else
            {
                return false;
            }
        }
        #endregion

        #region 读参数函数
        private Boolean ReadParams(String str_param, ref float value)
        {
            if (m_bInitialised)
            {
                object varfloat = new VariantWrapper((float)0.0f);
                lrt = CZEMApi.Get(str_param, ref varfloat);
                if (lrt != 0)
                {
                    return false;
                }
                else
                {
                    value = Convert.ToSingle(varfloat);
                    return true;
                }
            }
            else
            {
                return false;
            }
        }
        #endregion

        #region 写参数函数
        private Boolean WriteParams(String str_param, float value)
        {
            if (m_bInitialised)
            {
                //先取范围
                object varMin = new VariantWrapper((float)0.0f);
                object varMax = new VariantWrapper((float)0.0f);
                lrt = CZEMApi.GetLimits(str_param, ref varMin, ref varMax);
                if (lrt != 0)
                {
                    return false;
                }
                if (value <= Convert.ToSingle(varMax) && value >= Convert.ToSingle(varMin))
                {
                    object varFloat = new VariantWrapper(value);
                    lrt = CZEMApi.Set(str_param, ref varFloat);// set value
                    if (lrt != 0)
                    {
                        return false;
                    }
                    return true;
                    //这里是写入后读取判断值是否写入，也可以在事件1中捕获返回值
                    //object varfloat = new VariantWrapper((float)0.0f);
                    ////object varStr = new VariantWrapper("");
                    //lrt = CZEMApi.Get(strPara, ref varfloat);

                    //if (lrt != 0)
                    //{
                    //    ReportError(lrt, "Set Value", strPara);
                    //    return;
                    //}
                    //lblgetValue.Text = Convert.ToDecimal(varfloat).ToString();
                }
                else
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
        }
        #endregion

        #region 执行命令
        private Boolean ExecuteCmd(String cmd)
        {
            if (m_bInitialised)
            {
                lrt = CZEMApi.Execute(cmd);// execute command
                if (lrt != 0)
                {
                    return false;
                }
                else
                {
                    return true;
                }
            }
            else
            {
                return false;
            }
        }
        #endregion

        #region 放大缩小
        /// <summary>
        /// 读取缩放倍数
        /// </summary>
        /// <returns>true:float or false:NaN</returns>
        public float GetMagnification()
        {
            float ret = 0;
            if (ReadParams(AP_MAG, ref ret))
            {
                return ret;
            }
            else
            {
                return float.NaN;
            }
        }

        /// <summary>
        /// 设置缩放倍数
        /// </summary>
        /// <param name="set">倍数</param>
        /// <returns>true or false</returns>
        public Boolean SetMagnification(float set)
        {
            return WriteParams(AP_MAG, set);
        }
        #endregion

        #region 焦距
        /// <summary>
        /// 读取工作距离
        /// </summary>
        /// <returns>true:float or false:NaN</returns>
        public float GetWorkingDistance()
        {
            float ret = 0;
            if (ReadParams(AP_WD, ref ret))
            {
                return ret;
            }
            else
            {
                return float.NaN;
            }
        }

        /// <summary>
        /// 设置焦距
        /// </summary>
        /// <param name="set">焦距</param>
        /// <returns>true or false</returns>
        public Boolean SetWorkingDistance(float set)
        {
            return WriteParams(AP_WD, set);
        }
        #endregion

        #region 亮度
        /// <summary>
        /// 读取亮度
        /// </summary>
        /// <returns>true:float or false:NaN</returns>
        public float GetBrightness()
        {
            float ret = 0;
            if (ReadParams(AP_BRIGHTNESS, ref ret))
            {
                return ret;
            }
            else
            {
                return float.NaN;
            }
        }

        /// <summary>
        /// 设置亮度
        /// </summary>
        /// <param name="set">亮度</param>
        /// <returns>true or false</returns>
        public Boolean SetBrightness(float set)
        {
            return WriteParams(AP_BRIGHTNESS, set);
        }
        #endregion

        #region 对比度
        /// <summary>
        /// 读取对比度
        /// </summary>
        /// <returns>true:float or false:NaN</returns>
        public float GetContrast()
        {
            float ret = 0;
            if (ReadParams(AP_CONTRAST, ref ret))
            {
                return ret;
            }
            else
            {
                return float.NaN;
            }
        }

        /// <summary>
        /// 设置对比度
        /// </summary>
        /// <param name="set">对比度</param>
        /// <returns>true or false</returns>
        public Boolean SetContrast(float set)
        {
            return WriteParams(AP_CONTRAST, set);
        }
        #endregion

        #region 消像散
        /// <summary>
        /// 读取消像散X
        /// </summary>
        /// <returns>true:float or false:NaN</returns>
        public float GetAstigmatismX()
        {
            float ret = 0;
            if (ReadParams(AP_STIG_X, ref ret))
            {
                return ret;
            }
            else
            {
                return float.NaN;
            }
        }

        /// <summary>
        /// 读取消像散Y
        /// </summary>
        /// <returns>true:float or false:NaN</returns>
        public float GetAstigmatismY()
        {
            float ret = 0;
            if (ReadParams(AP_STIG_Y, ref ret))
            {
                return ret;
            }
            else
            {
                return float.NaN;
            }
        }

        /// <summary>
        /// 设置消像散X
        /// </summary>
        /// <param name="set">对比度</param>
        /// <returns>true or false</returns>
        public Boolean SetAstigmatismX(float set)
        {
            return WriteParams(AP_STIG_X, set);
        }

        /// <summary>
        /// 设置消像散Y
        /// </summary>
        /// <param name="set">对比度</param>
        /// <returns>true or false</returns>
        public Boolean SetAstigmatismY(float set)
        {
            return WriteParams(AP_STIG_Y, set);
        }
        #endregion

        #region 角度补偿
        /// <summary>
        /// 读取角度补偿
        /// </summary>
        /// <returns>true:float or false:NaN</returns>
        public float GetTiltAngle()
        {
            float ret = 0;
            if (ReadParams(AP_TILT_ANGLE, ref ret))
            {
                return ret;
            }
            else
            {
                return float.NaN;
            }
        }

        /// <summary>
        /// 设置角度补偿
        /// </summary>
        /// <param name="set">角度补偿</param>
        /// <returns>true or false</returns>
        public Boolean SetTiltAngle(float set)
        {
            return WriteParams(AP_TILT_ANGLE, set);
        }
        #endregion

        #region 抓取图像
        /// <summary>
        /// 抓取图像
        /// </summary>
        /// <returns>true:float or false:NaN</returns>
        public Boolean GrabImage(String filename, short type)
        {
            if (m_bInitialised)
            {
                lrt = CZEMApi.Grab(0, 0, 1024, 768, type, filename);
                if (lrt != 0)
                {
                    return false;
                }
                else
                {
                    return true;
                }
            }
            else
            {
                return false;
            }
        }
        #endregion

        #region SEM移动接口
        /// <summary>
        /// 返回样品台坐标数组
        /// </summary>
        /// <returns>Lenght=6</returns>
        public float[] GetStagePosition()
        {
            object retx = new VariantWrapper((float)0.0f);
            object rety = new VariantWrapper((float)0.0f);
            object retz = new VariantWrapper((float)0.0f);
            object rett = new VariantWrapper((float)0.0f);
            object retr = new VariantWrapper((float)0.0f);
            object retm = new VariantWrapper((float)0.0f);
            float[] ret = new float[6];
            if (m_bInitialised)
            {
                CZEMApi.GetStagePosition(ref retx, ref rety, ref retz, ref rett, ref retr, ref retm);
                ret[0] = Convert.ToSingle(retx);
                ret[1] = Convert.ToSingle(rety);
                ret[2] = Convert.ToSingle(retz);
                ret[3] = Convert.ToSingle(rett);
                ret[4] = Convert.ToSingle(retr);
                ret[5] = Convert.ToSingle(retm);
            }
            else
            {
                ret[0] = float.NaN;
                ret[1] = float.NaN;
                ret[2] = float.NaN;
                ret[3] = float.NaN;
                ret[4] = float.NaN;
                ret[5] = float.NaN;
            }
            return ret;
        }

        /// <summary>
        /// SEM位置 X轴
        /// </summary>
        /// <returns>true:float or false:NaN</returns>
        public float GetStageAtX()
        {
            float ret = 0;
            if (ReadParams(AP_STAGE_AT_X, ref ret))
            {
                return ret;
            }
            else
            {
                return float.NaN;
            }
        }

        /// <summary>
        /// SEM位置 Y轴
        /// </summary>
        /// <returns>true:float or false:NaN</returns>
        public float GetStageAtY()
        {
            float ret = 0;
            if (ReadParams(AP_STAGE_AT_Y, ref ret))
            {
                return ret;
            }
            else
            {
                return float.NaN;
            }
        }

        /// <summary>
        /// SEM位置 Z轴
        /// </summary>
        /// <returns>true:float or false:NaN</returns>
        public float GetStageAtZ()
        {
            float ret = 0;
            if (ReadParams(AP_STAGE_AT_Z, ref ret))
            {
                return ret;
            }
            else
            {
                return float.NaN;
            }
        }

        /// <summary>
        /// SEM位置 T轴
        /// </summary>
        /// <returns>true:float or false:NaN</returns>
        public float GetStageAtT()
        {
            float ret = 0;
            if (ReadParams(AP_STAGE_AT_T, ref ret))
            {
                return ret;
            }
            else
            {
                return float.NaN;
            }
        }

        /// <summary>
        /// SEM位置 R轴
        /// </summary>
        /// <returns>true:float or false:NaN</returns>
        public float GetStageAtR()
        {
            float ret = 0;
            if (ReadParams(AP_STAGE_AT_R, ref ret))
            {
                return ret;
            }
            else
            {
                return float.NaN;
            }
        }

        /// <summary>
        /// SEM位置 M轴
        /// </summary>
        /// <returns>true:float or false:NaN</returns>
        public float GetStageAtM()
        {
            float ret = 0;
            if (ReadParams(AP_STAGE_AT_M, ref ret))
            {
                return ret;
            }
            else
            {
                return float.NaN;
            }
        }

        /// <summary>
        /// SEM位置 X轴
        /// </summary>
        /// <param name="set">X轴移动坐标</param>
        /// <returns></returns>
        public Boolean SetStageGotoX(float set)
        {
            return WriteParams(AP_STAGE_GOTO_X, set);
        }

        /// <summary>
        /// SEM位置 Y轴
        /// </summary>
        /// <param name="set">Y轴移动坐标</param>
        /// <returns></returns>
        public Boolean SetStageGotoY(float set)
        {
            return WriteParams(AP_STAGE_GOTO_Y, set);
        }

        /// <summary>
        /// SEM位置 Z轴
        /// </summary>
        /// <param name="set">Y轴移动坐标</param>
        /// <returns></returns>
        public Boolean SetStageGotoZ(float set)
        {
            return WriteParams(AP_STAGE_GOTO_Z, set);
        }

        /// <summary>
        /// SEM位置 T轴
        /// </summary>
        /// <param name="set">Y轴移动坐标</param>
        /// <returns></returns>
        public Boolean SetStageGotoT(float set)
        {
            return WriteParams(AP_STAGE_GOTO_T, set);
        }

        /// <summary>
        /// SEM位置 R轴
        /// </summary>
        /// <param name="set">Y轴移动坐标</param>
        /// <returns></returns>
        public Boolean SetStageGotoR(float set)
        {
            return WriteParams(AP_STAGE_GOTO_R, set);
        }

        /// <summary>
        /// SEM位置 M轴
        /// </summary>
        /// <param name="set">M轴移动坐标</param>
        /// <returns></returns>
        public Boolean SetStageGotoM(float set)
        {
            return WriteParams(AP_STAGE_GOTO_M, set);
        }
        #endregion

        #region Scan Rotate角度接口
        /// <summary>
        /// 获取Scan Rotate角度接口
        /// </summary>
        /// <returns>true:float or false:NaN</returns>
        public float GetScanRotation()
        {
            float ret = 0;
            if (ReadParams(AP_SCANROTATION, ref ret))
            {
                return ret;
            }
            else
            {
                return float.NaN;
            }
        }

        /// <summary>
        /// 设置Scan Rotate角度接口
        /// </summary>
        /// <param name="set">角度补偿</param>
        /// <returns>true or false</returns>
        public Boolean SetScanRotation(float set)
        {
            return WriteParams(AP_SCANROTATION, set);
        }
        #endregion

        #region 像素读取PixelSize
        /// <summary>
        /// 获取Pixel Size 接口,只读
        /// </summary>
        /// <returns>true:float or false:NaN</returns>
        public float GetPixelSize()
        {
            float ret = 0;
            if (ReadParams(AP_PIXEL_SIZE, ref ret))
            {
                return ret;
            }
            else
            {
                return float.NaN;
            }
        }
        #endregion

        #region 开启电压
        public Boolean CmdOpenVoltage()
        {
            return ExecuteCmd(CMD_BEAM_ON);
        }
        #endregion

        #region 关闭电压
        public Boolean CmdCloseVoltage()
        {
            return ExecuteCmd(CMD_EHT_OFF);
        }
        #endregion
    }
}