Initial commit

.gitignore

+## ide
+# 忽略操作系统生成的文件
+DS_Store
+# 忽略日志文件
+*.log
+**/.vs
+**/.idea
+work.md
+__pycache__/
+*.py[cod]
+$__pycache__$
+/logs/
+/Resource/
+/dist/
+/build/
+/bin/
+/obj/
+/MTB/
+# 忽略环境变量文件
+env
+# 忽略依赖文件夹
+node_modules/
\ No newline at end of file

ZeissMicroscopeAPI.sln

+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.36602.28
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ZeissMicroscopeAPI", "ZeissMicroscopeAPI\ZeissMicroscopeAPI.csproj", "{A1F466A5-74F6-4942-861D-1C1ADD822D25}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{A1F466A5-74F6-4942-861D-1C1ADD822D25}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{A1F466A5-74F6-4942-861D-1C1ADD822D25}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{A1F466A5-74F6-4942-861D-1C1ADD822D25}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{A1F466A5-74F6-4942-861D-1C1ADD822D25}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {D7979928-52F4-482C-8DF4-8043656C7812}
+	EndGlobalSection
+EndGlobal

ZeissMicroscopeAPI/Class1.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ZeissMicroscopeAPI
+{
+    public class Class1
+    {
+    }
+}

ZeissMicroscopeAPI/Properties/AssemblyInfo.cs

+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// 有关程序集的一般信息由以下
+// 控制。更改这些特性值可修改
+// 与程序集关联的信息。
+[assembly: AssemblyTitle("ZeissMicroscopeAPI")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("ZeissMicroscopeAPI")]
+[assembly: AssemblyCopyright("Copyright ©  2026")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// 将 ComVisible 设置为 false 会使此程序集中的类型
+//对 COM 组件不可见。如果需要从 COM 访问此程序集中的类型
+//请将此类型的 ComVisible 特性设置为 true。
+[assembly: ComVisible(false)]
+
+// 如果此项目向 COM 公开，则下列 GUID 用于类型库的 ID
+[assembly: Guid("a1f466a5-74f6-4942-861d-1c1add822d25")]
+
+// 程序集的版本信息由下列四个值组成: 
+//
+//      主版本
+//      次版本
+//      生成号
+//      修订号
+//
+//可以指定所有这些值，也可以使用“生成号”和“修订号”的默认值
+//通过使用 "*"，如下所示:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

ZeissMicroscopeAPI/YQLControllers/ObjectiveController.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using ZEISS.MTB.Api;
+using YQLInterfaces;
+using YQLUtils;
+namespace ZeissMicroscopeAPI
+{
+    public class ObjectiveController
+    {
+        public static int  ObjectiveIsMonitoring          (IMicroscope Manager                                                                        ) {
+            var result = Settings.RECODE_FAILURE;
+            try
+            {
+                result = Manager.ObjectiveHandler.IsMonitoring ? Settings.RECODE_SUCCEED : Settings.RECODE_FAILURE;
+            }
+            catch (Exception E) { YQLUtil.Print_Exception(E); }
+            return result;
+        }
+        public static int ObjectiveIsLocked              (IMicroscope Manager                                                                        ) {
+            var result = Settings.RECODE_FAILURE;
+            try
+            {
+                result = Manager.ObjectiveHandler.IsLocked ? Settings.RECODE_SUCCEED : Settings.RECODE_FAILURE;
+            }
+            catch (Exception E) { YQLUtil.Print_Exception(E); }
+            return result;
+        }
+        public static int ObjectiveIsBusy                (IMicroscope Manager                                                                        ) {
+            var result = Settings.RECODE_FAILURE;
+            try
+            {
+                result = Manager.ObjectiveHandler.IsBusy ? Settings.RECODE_SUCCEED : Settings.RECODE_FAILURE;
+            }
+            catch (Exception E) { YQLUtil.Print_Exception(E); }
+            return result;
+        }
+        public static int ObjectiveHasMonitoring         (IMicroscope Manager                                                                        ) {
+            var result = Settings.RECODE_FAILURE;
+            try
+            {
+                result = Manager.ObjectiveHandler.HasMonitoring ? Settings.RECODE_SUCCEED : Settings.RECODE_FAILURE;
+            }
+            catch (Exception E) { YQLUtil.Print_Exception(E); }
+            return result;
+        }
+        public static int ObjectiveIsLockedForClient     (IMicroscope Manager                                                                        ) {
+            var result = Settings.RECODE_FAILURE;
+            try
+            {
+                result = Manager.ObjectiveHandler.IsLockedForClient(Manager.MicroscopeID) ? Settings.RECODE_SUCCEED : Settings.RECODE_FAILURE;
+            }
+            catch (Exception E) { YQLUtil.Print_Exception(E); }
+            return result;
+        }
+        public static int ObjectiveIsMonitoringForClient (IMicroscope Manager                                                                        ) {
+            var result = Settings.RECODE_FAILURE;
+            try
+            {
+                result = Manager.ObjectiveHandler.IsMonitoringForClient(Manager.MicroscopeID) ? Settings.RECODE_SUCCEED : Settings.RECODE_FAILURE;
+            }
+            catch (Exception E) { YQLUtil.Print_Exception(E); }
+            return result;
+        }
+        public static int ObjectiveLock                  (IMicroscope Manager                                                                        ) {
+            var result = Settings.RECODE_FAILURE;
+            try
+            {
+                result = Manager.ObjectiveHandler.Lock(Manager.MicroscopeID) ? Settings.RECODE_SUCCEED : Settings.RECODE_FAILURE;
+            }
+            catch (Exception E) { YQLUtil.Print_Exception(E); }
+            return result;
+        }
+        public static int ObjectiveStartMonitoring       (IMicroscope Manager                                                                        ) {
+            var result = Settings.RECODE_FAILURE;
+            try
+            {
+                result = Manager.ObjectiveHandler.StartMonitoring(Manager.MicroscopeID) ? Settings.RECODE_SUCCEED : Settings.RECODE_FAILURE;
+            }
+            catch (Exception E) { YQLUtil.Print_Exception(E); }
+            return result;
+        }
+        public static int ObjectiveStopMonitoring        (IMicroscope Manager                                                                        ) {
+            var result = Settings.RECODE_FAILURE;
+            try
+            {
+                result = Manager.ObjectiveHandler.StopMonitoring(Manager.MicroscopeID) ? Settings.RECODE_SUCCEED : Settings.RECODE_FAILURE;
+            }
+            catch (Exception E) { YQLUtil.Print_Exception(E); }
+            return result;
+        }
+        public static int ObjectiveUnlock                (IMicroscope Manager                                                                        ) {
+            var result = Settings.RECODE_FAILURE;
+            try
+            {
+                result = Manager.ObjectiveHandler.Unlock(Manager.MicroscopeID) ? Settings.RECODE_SUCCEED : Settings.RECODE_FAILURE;
+            }
+            catch (Exception E) { YQLUtil.Print_Exception(E); }
+            return result;
+        }
+        public static int ObjectiveWaitReady             (IMicroscope Manager, int timeout                                                           ) {
+            var result = Settings.RECODE_FAILURE;
+            try
+            {
+                result = Manager.ObjectiveHandler.WaitReady(timeout) ? Settings.RECODE_SUCCEED : Settings.RECODE_FAILURE;
+            }
+            catch (Exception E) { YQLUtil.Print_Exception(E); }
+            return result;
+        }
+        public static int             ObjectiveAbsPosition                    (IMicroscope Manager                                        ) {
+            var result = Settings.RECODE_FAILURE;
+            try
+            {
+                result = Convert.ToInt32(Manager.ObjectiveHandler.Position);
+            }
+            catch (Exception E) { YQLUtil.Print_Exception(E); }
+            return result;
+        }
+        public static int             ObjectiveMinPosition                    (IMicroscope Manager                                        ) {
+            var result = Settings.RECODE_FAILURE;
+            try
+            {
+                result = Convert.ToInt32(Manager.ObjectiveHandler.MinPosition);
+            }
+            catch (Exception E) { YQLUtil.Print_Exception(E); }
+            return result;
+        }
+        public static int             ObjectiveMaxPosition                    (IMicroscope Manager                                        ) {
+            var result = Settings.RECODE_FAILURE;
+            try
+            {
+                result = Convert.ToInt32(Manager.ObjectiveHandler.MaxPosition);
+            }
+            catch (Exception E) { YQLUtil.Print_Exception(E); }
+            return result;
+        }
+        public static int             ObjectiveSetPosition                    (IMicroscope Manager, int position, int mode, int timeout   ) {
+            var result = Settings.RECODE_FAILURE;
+            try
+            {
+                Manager.ObjectiveHandler.SetPosition(Convert.ToInt16(position), (MTBCmdSetModes)mode, timeout);
+                result = Settings.RECODE_SUCCEED;
+            }
+            catch (Exception E) { YQLUtil.Print_Exception(E); }
+            return result;
+        }
+        public static int             ObjectiveSetPosition                    (IMicroscope Manager, int position, int mode                )
+        {
+            var result = Settings.RECODE_FAILURE;
+            try
+            {
+                Manager.ObjectiveHandler.SetPosition(Convert.ToInt16(position), (MTBCmdSetModes)mode);
+                result = Settings.RECODE_SUCCEED;
+            }
+            catch (Exception E) { YQLUtil.Print_Exception(E); }
+            return result;
+        }
+    }
+}

ZeissMicroscopeAPI/YQLInterfaces/IMicroscope.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using ZEISS.MTB.Api;
+
+namespace ZeissMicroscopeAPI
+{
+    public interface IMicroscope: IDisposable
+    {
+        bool hasMicroscope          { get; }
+        bool hasMTBConnection       { get; }            // 连接接口
+        bool hasMTBID               { get; }            // 模块序号
+        bool hasManager             { get; }            // 控制模块
+        bool hasMTBModules          { get; }            // 全部模块
+        bool IsValid                { get; }
+        bool IsAvailable            { get; }
+        bool IsOpen                 { get; }
+        int  Accessibility          { get; }
+        bool IsLogin                { get; }
+        bool IsInit                 { get; }
+        string MicroscopeType       { get; }               // 蔡司显微镜型号
+        string MicroscopeVersion    { get; }               // 蔡司显微镜版本
+        string MicroscopeID         { get; }               // 蔡司显微镜序号
+        bool   IsSucceed            { get; }               // 当前加载状态
+        int    DeviceID             { get; set; }
+        string MTBAxisUnit          { get; set; }               // 显微镜轴移动单位
+        string MTBUnit              { get; set; }               // 显微镜默认单位
+        string MTBSpeedUnit         { get; set; }               // 显微镜速度单位
+        string MTBLightUnit         { get; set; }               // 显微镜光源单位
+        IMTBDevice ZeissMicroscope { get; }
+        int Open    ();
+        int Close   ();
+        int ReOpen  ();
+        int Init    ();
+        int Login   ();
+        int Logout  ();
+        void initManager    ();
+        void deleManager    ();
+        void initMTBModules ();
+        void deleMTBModules ();
+
+        string[]      ComponentIDs  (                   );
+        int           getDeviceCount(                   );
+        IMTBComponent           Handler        (string ComponentID );
+        IMTBFocus               FocusHandler        { get; }
+        IMTBAxis                AxisHandler         { get; }
+        IMTBMove                MoveHandler         { get; }
+        IMTBContinualSpeed      SpeedHandler        { get; }
+        IMTBChanger             RLTLHandler         { get; }
+        IMTBObjectiveChanger    ObjectiveHandler    { get; }
+        IMTBLamp                LampHandler         { get; }
+        IMTBServo               ApblHandler         { get; }
+        IMTBServo               LfblHandler         { get; }
+
+        IMTBContrastChangerProperties               MTBCondenserProperties                  { get; }
+        IMTBEyepiece                                MTBEyePiece                             { get; }
+        IMTBFocus                                   MTBFocus                                { get; }
+        IMTBMicroscopeManager                       MTBMicroscopeManager                    { get; }
+        IMTBObject                                  MTBObject                               { get; }
+        IMTBObjectiveChanger                        MTBObjectiveChanger                     { get; }
+        IMTBChanger                                 MTBRLTLSwitch                           { get; }
+        IMTBServo                                   MTBTLFieldStop                          { get; }
+        IMTBFilterChanger                           MTBTLFilterChanger1                     { get; }
+        IMTBFilterChanger                           MTBTLFilterChanger2                     { get; }
+        IMTBLamp                                    MTBTLHalogenLamp                        { get; }
+        IMTBFilterChanger                           MTBTLVirtualFilterChanger               { get; }
+    }
+}

ZeissMicroscopeAPI/YQLInterfaces/IYQLContext.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace YQLInterfaces
+{
+    public class IYQLContext : YQLInterface
+    {
+
+    }
+}

ZeissMicroscopeAPI/YQLInterfaces/YQLInterface.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Reflection;
+
+namespace YQLInterfaces
+{
+    public class YQLInterface
+    {
+        public string Information { get; set; }
+
+        public static bool has_Field(object src, string name, Type TYPE)
+        {
+            try
+            {
+                if (src == null) return false;
+                var propertyInfo = src.GetType().GetProperty(name);
+                if (propertyInfo != null && propertyInfo.GetValue(src, null) != null)
+                    return propertyInfo.GetValue(src, null).GetType() == TYPE;
+            }
+            catch (Exception) { }
+            return false;
+        }
+        public static T GetField<T>(object src, string name)
+        {
+            try
+            {
+                if (src == null) return default(T);
+                var propertyInfo = src.GetType().GetProperty(name);
+                return (T)propertyInfo.GetValue(src, null);
+            }
+            catch (Exception) { }
+            return default(T);
+        }
+        public static void SetField<T>(object src, string name, T value)
+        {
+            try
+            {
+                if (src == null) return;
+                var propertyInfo = src.GetType().GetProperty(name);
+                propertyInfo.SetValue(src, value, null);
+            }
+            catch (Exception) { }
+            return;
+        }
+        public virtual bool hasProperty(string name, Type TYPE)
+        {
+            try
+            {
+                var propertyInfo = GetType().GetProperty(name);
+                if (propertyInfo != null && propertyInfo.GetValue(this, null) != null)
+                    return propertyInfo.GetValue(this, null).GetType() == TYPE;
+            }
+            catch (Exception) { }
+            return false;
+        }
+        public virtual T getProperty<T>(string name)
+        {
+            try
+            {
+                var propertyInfo = GetType().GetProperty(name);
+                return (T)propertyInfo.GetValue(this, null);
+            }
+            catch (Exception) { }
+            return default(T);
+        }
+        public virtual void setProperty<T>(string name, T value)
+        {
+            try
+            {
+                var propertyInfo = GetType().GetProperty(name);
+                propertyInfo.SetValue(this, value, null);
+            }
+            catch (Exception) { }
+            return;
+        }
+
+        public virtual void initialization(string information)
+        {
+            Information = information;
+            initialize();
+        }
+        public virtual void initialize()
+        {
+            initData();
+            initValue();
+            initProperty();
+            initConnect();
+        }
+        public virtual void deinitialize()
+        {
+            deleConnect();
+            deleProperty();
+            deleValue();
+            deleData();
+        }
+        public virtual void initData() { }
+        public virtual void initValue() { }
+        public virtual void initProperty() { }
+        public virtual void initConnect() { }
+
+        public virtual void deleData() { }
+        public virtual void deleValue() { }
+        public virtual void deleProperty() { }
+        public virtual void deleConnect() { }
+
+        public void From(object source)
+        {
+            if (source == null)
+                return;
+            if (object.ReferenceEquals(this, source))
+                return;
+            Type type = source.GetType();
+            foreach (PropertyInfo property in type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
+            {
+                if (!property.CanWrite) continue;
+                if (!hasProperty(property.Name, property.PropertyType)) continue;
+                object value = property.GetValue(source);
+                if (value == null || property.PropertyType.IsValueType || property.PropertyType == typeof(string))
+                {
+                    property.SetValue(this, value);
+                }
+                else
+                {
+                    property.SetValue(this, DeepCopy(value));
+                }
+            }
+        }
+
+        public object Copy()
+        {
+            Type type = GetType();
+            object target = DeepCopy(this);
+            return target;
+        }
+
+        public static object DeepCopy(object source)
+        {
+            if (source == null) return null;
+            Type type = source.GetType();
+            object target = Activator.CreateInstance(type);
+
+            // 遍历所有属性
+            foreach (PropertyInfo property in type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
+            {
+                if (!property.CanWrite) continue;
+
+                object value = property.GetValue(source);
+                if (value == null || property.PropertyType.IsValueType || property.PropertyType == typeof(string))
+                {
+                    property.SetValue(target, value);
+                }
+                else
+                {
+                    property.SetValue(target, DeepCopy(value));
+                }
+            }
+
+            // 遍历所有字段
+            foreach (FieldInfo field in type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
+            {
+                object value = field.GetValue(source);
+                if (value == null || field.FieldType.IsValueType || field.FieldType == typeof(string))
+                {
+                    field.SetValue(target, value);
+                }
+                else
+                {
+                    field.SetValue(target, DeepCopy(value));
+                }
+            }
+
+            return target;
+        }
+
+    }
+}

ZeissMicroscopeAPI/YQLUtils/AppTimeLoop.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Threading;
+
+namespace YQLUtils
+{
+    public class AppTimeLoop
+    {
+        public static void ProcessEvents(int interVal)
+        {
+            int waittime       = 2;
+            DateTime startTime = DateTime.Now;
+            while(true)
+            {
+                DateTime endTime = DateTime.Now;
+                if ((int)(endTime - startTime).TotalMilliseconds >= interVal)
+                    break;
+                Thread.Sleep(waittime);
+            }
+        }
+        public static void delay(int interVal)
+        {
+            if (interVal == 0)
+                return;
+            Thread.Sleep(Math.Abs(interVal));
+        }
+        public static void msleep(int interVal)
+        {
+            if (interVal == 0)
+                return;
+            Thread.Sleep(Math.Abs(interVal));
+        }
+        public static void sleep(int interVal)
+        {
+            if (interVal == 0)
+                return;
+            Thread.Sleep(Math.Abs(interVal * 1000));
+        }
+    }
+}

ZeissMicroscopeAPI/YQLUtils/Settings.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+namespace YQLUtils
+{
+    public class Settings
+    {
+        public static int RECODE_FAILURE                      = 0   ;
+        public static int RECODE_SUCCEED                      = 1   ;
+        public static int RECODE_WARNING                      = 2   ;
+        public static int RECODE_CHANGED                      = 3   ;
+        public static int RECODE_JUMPING                      = 4   ;
+        public static int CODE_SUCCESS                        = 200 ;
+        public static int CODE_FAILURE                        = 500 ;
+        public static int CODE_WARNING                        = 201 ;
+        public static int AXIS_STATUS_REGISTER_0              = 0   ;
+        public static int AXIS_STATUS_REGISTER_1              = 1   ;
+        public static int AXIS_STATUS_REGISTER_2              = 2   ;
+        public static int AXIS_STATUS_REGISTER_3              = 3   ;
+        public static int AXIS_STATUS_REGISTER_4              = 4   ;
+        public static int READONLY_AXIS_STATUS_REGISTER_0     = 0   ;
+        public static int READONLY_AXIS_STATUS_REGISTER_1     = 1   ;
+        public static int READONLY_AXIS_STATUS_REGISTER_2     = 2   ;
+        public static int READONLY_AXIS_STATUS_REGISTER_3     = 3   ;
+        public static int READONLY_AXIS_STATUS_REGISTER_4     = 4   ;
+        public static int READONLY_AXIS_STATUS_REGISTER_5     = 5   ;
+        public static byte[] START_DECODE       = { 0x16, 0x54, 0x0D };
+        public static byte[] STOP_DECODE        = { 0x16, 0x55, 0x0D };
+        public static byte[] CONSOLE_MODE       = { 0x16, 0x4D, 0x0D, 0x30, 0x34, 0x30, 0x31, 0x44, 0x30, 0x35, 0x2E };
+        public static byte[] GET_VERSION        = { 0x16, 0x4D, 0x0D, 0x25, 0x25, 0x25, 0x56, 0x45, 0x52, 0x2E };
+        public static byte[] DECODE_TAIL        = { 0x0D, 0x0A};
+        public static byte[] DECODE_FRAME_TAIL  = { 0x06 };
+        public const byte       DEFAULT_BYTE                = default(byte      );
+        public const string     DEFAULT_STRING              = default(string    );
+        public const bool       DEFAULT_BOOL                = default(bool      );
+        public const short      DEFAULT_INT16               = default(short     );
+        public const ushort     DEFAULT_UINT16              = default(ushort    );
+        public const int        DEFAULT_INT32               = default(int       );
+        public const uint       DEFAULT_UINT32              = default(uint      );
+        public const long       DEFAULT_INT64               = default(long      );
+        public const ulong      DEFAULT_UINT64              = default(ulong     );
+        public const float      DEFAULT_FLOAT               = default(float     );
+        public const double     DEFAULT_DOUBLE              = default(double    );
+        public const byte       DEFAULT_BYTE_ARRAY          = default(byte      );
+        public const string[]   DEFAULT_STRING_ARRAY        = default(string  []);
+        public const bool  []   DEFAULT_BOOL_ARRAY          = default(bool    []);
+        public const short []   DEFAULT_INT16_ARRAY         = default(short   []);
+        public const ushort[]   DEFAULT_UINT16_ARRAY        = default(ushort  []);
+        public const int   []   DEFAULT_INT32_ARRAY         = default(int     []);
+        public const uint  []   DEFAULT_UINT32_ARRAY        = default(uint    []);
+        public const long  []   DEFAULT_INT64_ARRAY         = default(long    []);
+        public const ulong []   DEFAULT_UINT64_ARRAY        = default(ulong   []);
+        public const float []   DEFAULT_FLOAT_ARRAY         = default(float   []);
+        public const double[]   DEFAULT_DOUBLE_ARRAY        = default(double  []);
+        public const string MTBCondenserProperties          = "MTBCondenserProperties"     ;
+        public const string MTBEyePiece                     = "MTBEyePiece"                ;
+        public const string MTBFocus                        = "MTBFocus"                   ;
+        public const string MTBMicroscopeManager            = "MTBMicroscopeManager"       ;
+        public const string MTBObject                       = "MTBObject"                  ;
+        public const string MTBObjectiveChanger             = "MTBObjectiveChanger"        ;
+        public const string MTBRLTLSwitch                   = "MTBRLTLSwitch"              ;
+        public const string MTBTLFieldStop                  = "MTBTLFieldStop"             ;
+        public const string MTBTLFilterChanger1             = "MTBTLFilterChanger1"        ;
+        public const string MTBTLFilterChanger2             = "MTBTLFilterChanger2"        ;
+        public const string MTBTLHalogenLamp                = "MTBTLHalogenLamp"           ;
+        public const string MTBTLVirtualFilterChanger       = "MTBTLVirtualFilterChanger"  ;
+        public const string MTBMicroscopeLanguage           = "en";
+    }
+}
\ No newline at end of file

ZeissMicroscopeAPI/YQLUtils/YQLUtil.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Diagnostics;
+namespace YQLUtils
+{
+    public class YQLUtil
+    {
+        
+        public static string get_Exception(Exception E)
+        {
+            StringBuilder buffer = new StringBuilder();
+            UTF8Encoding utf8 = new UTF8Encoding();
+            if (E != null)
+            {
+                var stackTrace = new StackTrace(E, true);
+                foreach (var frame in stackTrace.GetFrames())
+                    buffer.Append($"FileName: {frame.GetFileName()} MethodName: {frame.GetMethod().Name} Line: {frame.GetFileLineNumber()} Message:{E.ToString()}\n\r");
+
+            }
+            if (buffer.Length <= 0)
+                buffer.Append("\n\r");
+            var data = utf8.GetBytes(buffer.ToString());
+            return utf8.GetString(data);
+        }
+        public static void Print_Exception(Exception E)
+        {
+            Console.Write($"{YQLUtil.get_Exception(E)}");
+        }
+    }
+}

ZeissMicroscopeAPI/ZeissMicroscopeAPI.csproj

+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{A1F466A5-74F6-4942-861D-1C1ADD822D25}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>ZeissMicroscopeAPI</RootNamespace>
+    <AssemblyName>ZeissMicroscopeAPI</AssemblyName>
+    <TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <Deterministic>true</Deterministic>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="MTBApi, Version=3.5.10.0, Culture=neutral, PublicKeyToken=39820acb30580488, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>.\MTBApi.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Class1.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="YQLControllers\ApblController.cs" />
+    <Compile Include="YQLControllers\AxisController.cs" />
+    <Compile Include="YQLControllers\LampController.cs" />
+    <Compile Include="YQLControllers\ObjectiveController.cs" />
+    <Compile Include="YQLManagers\MicManager.cs" />
+    <Compile Include="YQLInterfaces\IMicroscope.cs" />
+    <Compile Include="YQLInterfaces\IYQLContext.cs" />
+    <Compile Include="YQLInterfaces\IMicController.cs" />
+    <Compile Include="YQLInterfaces\YQLInterface.cs" />
+    <Compile Include="YQLManagers\ZeissMicReader.cs" />
+    <Compile Include="YQLUtils\AppTimeLoop.cs" />
+    <Compile Include="YQLUtils\Settings.cs" />
+    <Compile Include="YQLUtils\YQLUtil.cs" />
+  </ItemGroup>
+  <ItemGroup />
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+</Project>
\ No newline at end of file

ZeissMicroscopeAPI/obj/Debug/.NETFramework,Version=v4.8.AssemblyAttributes.cs

+// <autogenerated />
+using System;
+using System.Reflection;
+[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]

ZeissMicroscopeAPI/obj/Debug/ZeissMicroscopeAPI.csproj.CoreCompileInputs.cache

+b669d1d8837b3aaec29b50b354526f4633dc0145

ZeissMicroscopeAPI/obj/Debug/ZeissMicroscopeAPI.csproj.FileListAbsolute.txt

+D:\C_Shape\ZeissMicroscopeAPI\ZeissMicroscopeAPI\bin\Debug\ZeissMicroscopeAPI.dll
+D:\C_Shape\ZeissMicroscopeAPI\ZeissMicroscopeAPI\bin\Debug\ZeissMicroscopeAPI.pdb
+D:\C_Shape\ZeissMicroscopeAPI\ZeissMicroscopeAPI\bin\Debug\MTBApi.dll
+D:\C_Shape\ZeissMicroscopeAPI\ZeissMicroscopeAPI\obj\Debug\ZeissMicroscopeAPI.csproj.AssemblyReference.cache
+D:\C_Shape\ZeissMicroscopeAPI\ZeissMicroscopeAPI\obj\Debug\ZeissMicroscopeAPI.csproj.CoreCompileInputs.cache
+D:\C_Shape\ZeissMicroscopeAPI\ZeissMicroscopeAPI\obj\Debug\ZeissMicroscopeAPI.csproj.CopyComplete
+D:\C_Shape\ZeissMicroscopeAPI\ZeissMicroscopeAPI\obj\Debug\ZeissMicroscopeAPI.dll
+D:\C_Shape\ZeissMicroscopeAPI\ZeissMicroscopeAPI\obj\Debug\ZeissMicroscopeAPI.pdb

ZeissMicroscopeAPI/obj/Release/.NETFramework,Version=v4.8.AssemblyAttributes.cs

+// <autogenerated />
+using System;
+using System.Reflection;
+[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]

ZeissMicroscopeAPI/obj/Release/ZeissMicroscopeAPI.csproj.CoreCompileInputs.cache

+8653c002f7d4e6f4244d65272ab91545620a4f61

ZeissMicroscopeAPI/obj/Release/ZeissMicroscopeAPI.csproj.FileListAbsolute.txt

+D:\C_Shape\ZeissMicroscopeAPI\ZeissMicroscopeAPI\bin\Release\ZeissMicroscopeAPI.dll
+D:\C_Shape\ZeissMicroscopeAPI\ZeissMicroscopeAPI\bin\Release\ZeissMicroscopeAPI.pdb
+D:\C_Shape\ZeissMicroscopeAPI\ZeissMicroscopeAPI\bin\Release\MTBApi.dll
+D:\C_Shape\ZeissMicroscopeAPI\ZeissMicroscopeAPI\obj\Release\ZeissMicroscopeAPI.csproj.CoreCompileInputs.cache
+D:\C_Shape\ZeissMicroscopeAPI\ZeissMicroscopeAPI\obj\Release\ZeissMicroscopeAPI.csproj.CopyComplete
+D:\C_Shape\ZeissMicroscopeAPI\ZeissMicroscopeAPI\obj\Release\ZeissMicroscopeAPI.dll
+D:\C_Shape\ZeissMicroscopeAPI\ZeissMicroscopeAPI\obj\Release\ZeissMicroscopeAPI.pdb
+D:\C_Shape\ZeissMicroscopeAPI\ZeissMicroscopeAPI\obj\Release\ZeissMicroscopeAPI.csproj.AssemblyReference.cache