Merged in feature/LocalServer (pull request #5)

Feature/LocalServer

* Major refactor.  Switching over to a local server hub style driver allowing multiple programs to control the telescope at one time without the need for the POTH Hub

* Unified the setup dialog

* Implemented shared serial port, Both Telescope and Driver can connect at the same time.

* Ported the focuser implementation from the non server based version.

* Ported the telescope driver code.

* Fixed problem with # not being stripped from the returned string ends. Fixed issue with RA being returned as degress rather than hours.

* Telescope passes validation

* Added a lock around the focuser move.

* Reimplemented CommandBlind and CommandString

* Corrected version information

* Removed the Altitude support as there's a bug in the Autostar and Audiostar firmware

Meade.net/ClassFactory.cs

@@ -0,0 +1,244 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Collections;
+
+namespace ASCOM.Meade.net
+{
+
+    #region C# Definition of IClassFactory
+    //
+    // Provide a definition of theCOM IClassFactory interface.
+    //
+    [
+      ComImport,                                                // This interface originated from COM.
+      ComVisible(false),                                        // Must not be exposed to COM!!!
+      InterfaceType(ComInterfaceType.InterfaceIsIUnknown),      // Indicate that this interface is not IDispatch-based.
+      Guid("00000001-0000-0000-C000-000000000046")              // This GUID is the actual GUID of IClassFactory.
+    ]
+    public interface IClassFactory
+    {
+        void CreateInstance(IntPtr pUnkOuter, ref Guid riid, out IntPtr ppvObject);
+        void LockServer(bool fLock);
+    }
+    #endregion
+
+    //
+    // Universal ClassFactory. Given a type as a parameter of the 
+    // constructor, it implements IClassFactory for any interface
+    // that the class implements. Magic!!!
+    //
+    public class ClassFactory : IClassFactory
+    {
+
+        #region Access to ole32.dll functions for class factories
+
+        // Define two common GUID objects for public usage.
+        public static Guid IID_IUnknown = new Guid("{00000000-0000-0000-C000-000000000046}");
+        public static Guid IID_IDispatch = new Guid("{00020400-0000-0000-C000-000000000046}");
+
+        [Flags]
+        enum CLSCTX : uint
+        {
+            CLSCTX_INPROC_SERVER = 0x1,
+            CLSCTX_INPROC_HANDLER = 0x2,
+            CLSCTX_LOCAL_SERVER = 0x4,
+            CLSCTX_INPROC_SERVER16 = 0x8,
+            CLSCTX_REMOTE_SERVER = 0x10,
+            CLSCTX_INPROC_HANDLER16 = 0x20,
+            CLSCTX_RESERVED1 = 0x40,
+            CLSCTX_RESERVED2 = 0x80,
+            CLSCTX_RESERVED3 = 0x100,
+            CLSCTX_RESERVED4 = 0x200,
+            CLSCTX_NO_CODE_DOWNLOAD = 0x400,
+            CLSCTX_RESERVED5 = 0x800,
+            CLSCTX_NO_CUSTOM_MARSHAL = 0x1000,
+            CLSCTX_ENABLE_CODE_DOWNLOAD = 0x2000,
+            CLSCTX_NO_FAILURE_LOG = 0x4000,
+            CLSCTX_DISABLE_AAA = 0x8000,
+            CLSCTX_ENABLE_AAA = 0x10000,
+            CLSCTX_FROM_DEFAULT_CONTEXT = 0x20000,
+            CLSCTX_INPROC = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER,
+            CLSCTX_SERVER = CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER,
+            CLSCTX_ALL = CLSCTX_SERVER | CLSCTX_INPROC_HANDLER
+        }
+
+        [Flags]
+        enum REGCLS : uint
+        {
+            REGCLS_SINGLEUSE = 0,
+            REGCLS_MULTIPLEUSE = 1,
+            REGCLS_MULTI_SEPARATE = 2,
+            REGCLS_SUSPENDED = 4,
+            REGCLS_SURROGATE = 8
+        }
+        //
+        // CoRegisterClassObject() is used to register a Class Factory
+        // into COM's internal table of Class Factories.
+        //
+        [DllImport("ole32.dll")]
+        static extern int CoRegisterClassObject(
+            [In] ref Guid rclsid,
+            [MarshalAs(UnmanagedType.IUnknown)] object pUnk,
+            uint dwClsContext,
+            uint flags,
+            out uint lpdwRegister);
+        //
+        // Called by a COM EXE Server that can register multiple class objects 
+        // to inform COM about all registered classes, and permits activation 
+        // requests for those class objects. 
+        // This function causes OLE to inform the SCM about all the registered 
+        // classes, and begins letting activation requests into the server process.
+        //
+        [DllImport("ole32.dll")]
+        static extern int CoResumeClassObjects();
+        //
+        // Prevents any new activation requests from the SCM on all class objects
+        // registered within the process. Even though a process may call this API, 
+        // the process still must call CoRevokeClassObject for each CLSID it has 
+        // registered, in the apartment it registered in.
+        //
+        [DllImport("ole32.dll")]
+        static extern int CoSuspendClassObjects();
+        //
+        // CoRevokeClassObject() is used to unregister a Class Factory
+        // from COM's internal table of Class Factories.
+        //
+        [DllImport("ole32.dll")]
+        static extern int CoRevokeClassObject(uint dwRegister);
+        #endregion
+
+        #region Constructor and Private ClassFactory Data
+
+        protected Type m_ClassType;
+        protected Guid m_ClassId;
+        protected ArrayList m_InterfaceTypes;
+        protected uint m_ClassContext;
+        protected uint m_Flags;
+        protected UInt32 m_locked = 0;
+        protected uint m_Cookie;
+        protected string m_progid;
+
+        public ClassFactory(Type type)
+        {
+            if (type == null)
+                throw new ArgumentNullException("type");
+            m_ClassType = type;
+
+            //PWGS Get the ProgID from the MetaData
+            m_progid = Marshal.GenerateProgIdForType(type);
+            m_ClassId = Marshal.GenerateGuidForType(type);		// Should be nailed down by [Guid(...)]
+            m_ClassContext = (uint)CLSCTX.CLSCTX_LOCAL_SERVER;	// Default
+            m_Flags = (uint)REGCLS.REGCLS_MULTIPLEUSE |			// Default
+                        (uint)REGCLS.REGCLS_SUSPENDED;
+            m_InterfaceTypes = new ArrayList();
+            foreach (Type T in type.GetInterfaces())            // Save all of the implemented interfaces
+                m_InterfaceTypes.Add(T);
+        }
+
+        #endregion
+
+        #region Common ClassFactory Methods
+        public uint ClassContext
+        {
+            get { return m_ClassContext; }
+            set { m_ClassContext = value; }
+        }
+
+        public Guid ClassId
+        {
+            get { return m_ClassId; }
+            set { m_ClassId = value; }
+        }
+
+        public uint Flags
+        {
+            get { return m_Flags; }
+            set { m_Flags = value; }
+        }
+
+        public bool RegisterClassObject()
+        {
+            // Register the class factory
+            int i = CoRegisterClassObject
+                (
+                ref m_ClassId,
+                this,
+                m_ClassContext,
+                m_Flags,
+                out m_Cookie
+                );
+            return (i == 0);
+        }
+
+        public bool RevokeClassObject()
+        {
+            int i = CoRevokeClassObject(m_Cookie);
+            return (i == 0);
+        }
+
+        public static bool ResumeClassObjects()
+        {
+            int i = CoResumeClassObjects();
+            return (i == 0);
+        }
+
+        public static bool SuspendClassObjects()
+        {
+            int i = CoSuspendClassObjects();
+            return (i == 0);
+        }
+        #endregion
+
+        #region IClassFactory Implementations
+        //
+        // Implement creation of the type and interface.
+        //
+        void IClassFactory.CreateInstance(IntPtr pUnkOuter, ref Guid riid, out IntPtr ppvObject)
+        {
+            IntPtr nullPtr = new IntPtr(0);
+            ppvObject = nullPtr;
+
+            //
+            // Handle specific requests for implemented interfaces
+            //
+            foreach (Type iType in m_InterfaceTypes)
+            {
+                if (riid == Marshal.GenerateGuidForType(iType))
+                {
+                    ppvObject = Marshal.GetComInterfaceForObject(Activator.CreateInstance(m_ClassType), iType);
+                    return;
+                }
+            }
+            //
+            // Handle requests for IDispatch or IUnknown on the class
+            //
+            if (riid == IID_IDispatch)
+            {
+                ppvObject = Marshal.GetIDispatchForObject(Activator.CreateInstance(m_ClassType));
+                return;
+            }
+            else if (riid == IID_IUnknown)
+            {
+                ppvObject = Marshal.GetIUnknownForObject(Activator.CreateInstance(m_ClassType));
+            }
+            else
+            {
+                //
+                // Oops, some interface that the class doesn't implement
+                //
+                throw new COMException("No interface", unchecked((int)0x80004002));
+            }
+        }
+
+        void IClassFactory.LockServer(bool bLock)
+        {
+            if (bLock)
+                Server.CountLock();
+            else
+                Server.UncountLock();
+            // Always attempt to see if we need to shutdown this server application.
+            Server.ExitIf();
+        }
+        #endregion
+    }
+}

Meade.net/GarbageCollection.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Threading;
+
+namespace ASCOM.Meade.net
+{
+    /// <summary>
+    /// Summary description for GarbageCollection.
+    /// </summary>
+    class GarbageCollection
+    {
+        protected bool m_bContinueThread;
+        protected bool m_GCWatchStopped;
+        protected int m_iInterval;
+        protected ManualResetEvent m_EventThreadEnded;
+
+        public GarbageCollection(int iInterval)
+        {
+            m_bContinueThread = true;
+            m_GCWatchStopped = false;
+            m_iInterval = iInterval;
+            m_EventThreadEnded = new ManualResetEvent(false);
+        }
+
+        public void GCWatch()
+        {
+            // Pause for a moment to provide a delay to make threads more apparent.
+            while (ContinueThread())
+            {
+                GC.Collect();
+                Thread.Sleep(m_iInterval);
+            }
+            m_EventThreadEnded.Set();
+        }
+
+        protected bool ContinueThread()
+        {
+            lock (this)
+            {
+                return m_bContinueThread;
+            }
+        }
+
+        public void StopThread()
+        {
+            lock (this)
+            {
+                m_bContinueThread = false;
+            }
+        }
+
+        public void WaitForThreadToStop()
+        {
+            m_EventThreadEnded.WaitOne();
+            m_EventThreadEnded.Reset();
+        }
+    }
+}

Meade.net/LocalServer.cs

@@ -0,0 +1,642 @@
+//
+// ASCOM.Meade.net Local COM Server
+//
+// This is the core of a managed COM Local Server, capable of serving
+// multiple instances of multiple interfaces, within a single
+// executable. This implementes the equivalent functionality of VB6
+// which has been extensively used in ASCOM for drivers that provide
+// multiple interfaces to multiple clients (e.g. Meade Telescope
+// and Focuser) as well as hubs (e.g., POTH).
+//
+// Written by: Robert B. Denny (Version 1.0.1, 29-May-2007)
+// Modified by Chris Rowland and Peter Simpson to allow use with multiple devices of the same type March 2011
+//
+//
+using System;
+using System.IO;
+using System.Windows.Forms;
+using System.Drawing;
+using System.Collections;
+using System.Runtime.InteropServices;
+using System.Reflection;
+using ASCOM.Utilities;
+using Microsoft.Win32;
+using System.Text;
+using System.Threading;
+using System.Security.Principal;
+using System.Diagnostics;
+using ASCOM;
+
+namespace ASCOM.Meade.net
+{
+    public static class Server
+    {
+
+        #region Access to kernel32.dll, user32.dll, and ole32.dll functions
+        [Flags]
+        enum CLSCTX : uint
+        {
+            CLSCTX_INPROC_SERVER = 0x1,
+            CLSCTX_INPROC_HANDLER = 0x2,
+            CLSCTX_LOCAL_SERVER = 0x4,
+            CLSCTX_INPROC_SERVER16 = 0x8,
+            CLSCTX_REMOTE_SERVER = 0x10,
+            CLSCTX_INPROC_HANDLER16 = 0x20,
+            CLSCTX_RESERVED1 = 0x40,
+            CLSCTX_RESERVED2 = 0x80,
+            CLSCTX_RESERVED3 = 0x100,
+            CLSCTX_RESERVED4 = 0x200,
+            CLSCTX_NO_CODE_DOWNLOAD = 0x400,
+            CLSCTX_RESERVED5 = 0x800,
+            CLSCTX_NO_CUSTOM_MARSHAL = 0x1000,
+            CLSCTX_ENABLE_CODE_DOWNLOAD = 0x2000,
+            CLSCTX_NO_FAILURE_LOG = 0x4000,
+            CLSCTX_DISABLE_AAA = 0x8000,
+            CLSCTX_ENABLE_AAA = 0x10000,
+            CLSCTX_FROM_DEFAULT_CONTEXT = 0x20000,
+            CLSCTX_INPROC = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER,
+            CLSCTX_SERVER = CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER,
+            CLSCTX_ALL = CLSCTX_SERVER | CLSCTX_INPROC_HANDLER
+        }
+
+        [Flags]
+        enum COINIT : uint
+        {
+            /// Initializes the thread for multi-threaded object concurrency.
+            COINIT_MULTITHREADED = 0x0,
+            /// Initializes the thread for apartment-threaded object concurrency. 
+            COINIT_APARTMENTTHREADED = 0x2,
+            /// Disables DDE for Ole1 support.
+            COINIT_DISABLE_OLE1DDE = 0x4,
+            /// Trades memory for speed.
+            COINIT_SPEED_OVER_MEMORY = 0x8
+        }
+
+        [Flags]
+        enum REGCLS : uint
+        {
+            REGCLS_SINGLEUSE = 0,
+            REGCLS_MULTIPLEUSE = 1,
+            REGCLS_MULTI_SEPARATE = 2,
+            REGCLS_SUSPENDED = 4,
+            REGCLS_SURROGATE = 8
+        }
+
+
+        // CoInitializeEx() can be used to set the apartment model
+        // of individual threads.
+        [DllImport("ole32.dll")]
+        static extern int CoInitializeEx(IntPtr pvReserved, uint dwCoInit);
+
+        // CoUninitialize() is used to uninitialize a COM thread.
+        [DllImport("ole32.dll")]
+        static extern void CoUninitialize();
+
+        // PostThreadMessage() allows us to post a Windows Message to
+        // a specific thread (identified by its thread id).
+        // We will need this API to post a WM_QUIT message to the main 
+        // thread in order to terminate this application.
+        [DllImport("user32.dll")]
+        static extern bool PostThreadMessage(uint idThread, uint Msg, UIntPtr wParam,
+            IntPtr lParam);
+
+        // GetCurrentThreadId() allows us to obtain the thread id of the
+        // calling thread. This allows us to post the WM_QUIT message to
+        // the main thread.
+        [DllImport("kernel32.dll")]
+        static extern uint GetCurrentThreadId();
+        #endregion
+
+        #region Private Data
+        private static int objsInUse;                       // Keeps a count on the total number of objects alive.
+        private static int serverLocks;                     // Keeps a lock count on this application.
+        private static frmMain s_MainForm = null;               // Reference to our main form
+        private static ArrayList s_ComObjectAssys;              // Dynamically loaded assemblies containing served COM objects
+        private static ArrayList s_ComObjectTypes;              // Served COM object types
+        private static ArrayList s_ClassFactories;              // Served COM object class factories
+        private static string s_appId = "{4e68ec46-5ffc-49e7-b298-38a548df0bfd}";	// Our AppId
+        private static readonly Object lockObject = new object();
+        #endregion
+
+        // This property returns the main thread's id.
+        public static uint MainThreadId { get; private set; }   // Stores the main thread's thread id.
+
+        // Used to tell if started by COM or manually
+        public static bool StartedByCOM { get; private set; }   // True if server started by COM (-embedding)
+
+
+        #region Server Lock, Object Counting, and AutoQuit on COM startup
+        // Returns the total number of objects alive currently.
+        public static int ObjectsCount
+        {
+            get
+            {
+                lock (lockObject)
+                {
+                    return objsInUse;
+                }
+            }
+        }
+
+        // This method performs a thread-safe incrementation of the objects count.
+        public static int CountObject()
+        {
+            // Increment the global count of objects.
+            return Interlocked.Increment(ref objsInUse);
+        }
+
+        // This method performs a thread-safe decrementation the objects count.
+        public static int UncountObject()
+        {
+            // Decrement the global count of objects.
+            return Interlocked.Decrement(ref objsInUse);
+        }
+
+        // Returns the current server lock count.
+        public static int ServerLockCount
+        {
+            get
+            {
+                lock (lockObject)
+                {
+                    return serverLocks;
+                }
+            }
+        }
+
+        // This method performs a thread-safe incrementation the 
+        // server lock count.
+        public static int CountLock()
+        {
+            // Increment the global lock count of this server.
+            return Interlocked.Increment(ref serverLocks);
+        }
+
+        // This method performs a thread-safe decrementation the 
+        // server lock count.
+        public static int UncountLock()
+        {
+            // Decrement the global lock count of this server.
+            return Interlocked.Decrement(ref serverLocks);
+        }
+
+        // AttemptToTerminateServer() will check to see if the objects count and the server 
+        // lock count have both dropped to zero.
+        //
+        // If so, and if we were started by COM, we post a WM_QUIT message to the main thread's
+        // message loop. This will cause the message loop to exit and hence the termination 
+        // of this application. If hand-started, then just trace that it WOULD exit now.
+        //
+        public static void ExitIf()
+        {
+            lock (lockObject)
+            {
+                if ((ObjectsCount <= 0) && (ServerLockCount <= 0))
+                {
+                    if (StartedByCOM)
+                    {
+                        UIntPtr wParam = new UIntPtr(0);
+                        IntPtr lParam = new IntPtr(0);
+                        PostThreadMessage(MainThreadId, 0x0012, wParam, lParam);
+                    }
+                }
+            }
+        }
+        #endregion
+
+        // -----------------
+        // PRIVATE FUNCTIONS
+        // -----------------
+
+        #region Dynamic Driver Assembly Loader
+        //
+        // Load the assemblies that contain the classes that we will serve
+        // via COM. These will be located in the same folder as
+        // our executable.
+        //
+        private static bool LoadComObjectAssemblies()
+        {
+            s_ComObjectAssys = new ArrayList();
+            s_ComObjectTypes = new ArrayList();
+
+            // put everything into one folder, the same as the server.
+            string assyPath = Assembly.GetEntryAssembly().Location;
+            assyPath = Path.GetDirectoryName(assyPath);
+
+            DirectoryInfo d = new DirectoryInfo(assyPath);
+            foreach (FileInfo fi in d.GetFiles("*.dll"))
+            {
+                string aPath = fi.FullName;
+                //
+                // First try to load the assembly and get the types for
+                // the class and the class factory. If this doesn't work ????
+                //
+                try
+                {
+                    Assembly so = Assembly.LoadFrom(aPath);
+                    //PWGS Get the types in the assembly
+                    Type[] types = so.GetTypes();
+                    foreach (Type type in types)
+                    {
+                        // PWGS Now checks the type rather than the assembly
+                        // Check to see if the type has the ServedClassName attribute, only use it if it does.
+                        MemberInfo info = type;
+
+                        object[] attrbutes = info.GetCustomAttributes(typeof(ServedClassNameAttribute), false);
+                        if (attrbutes.Length > 0)
+                        {
+                            //MessageBox.Show("Adding Type: " + type.Name + " " + type.FullName);
+                            s_ComObjectTypes.Add(type); //PWGS - much simpler
+                            s_ComObjectAssys.Add(so);
+                        }
+                    }
+                }
+                catch (BadImageFormatException)
+                {
+                    // Probably an attempt to load a Win32 DLL (i.e. not a .net assembly)
+                    // Just swallow the exception and continue to the next item.
+                    continue;
+                }
+                catch (Exception e)
+                {
+                    MessageBox.Show("Failed to load served COM class assembly " + fi.Name + " - " + e.Message,
+                        "Meade.net", MessageBoxButtons.OK, MessageBoxIcon.Stop);
+                    return false;
+                }
+
+            }
+            return true;
+        }
+        #endregion
+
+        #region COM Registration and Unregistration
+        //
+        // Test if running elevated
+        //
+        private static bool IsAdministrator
+        {
+            get
+            {
+                WindowsIdentity i = WindowsIdentity.GetCurrent();
+                WindowsPrincipal p = new WindowsPrincipal(i);
+                return p.IsInRole(WindowsBuiltInRole.Administrator);
+            }
+        }
+
+        //
+        // Elevate by re-running ourselves with elevation dialog
+        //
+        private static void ElevateSelf(string arg)
+        {
+            ProcessStartInfo si = new ProcessStartInfo();
+            si.Arguments = arg;
+            si.WorkingDirectory = Environment.CurrentDirectory;
+            si.FileName = Application.ExecutablePath;
+            si.Verb = "runas";
+            try { Process.Start(si); }
+            catch (System.ComponentModel.Win32Exception)
+            {
+                MessageBox.Show("The Meade.net was not " + (arg == "/register" ? "registered" : "unregistered") +
+                    " because you did not allow it.", "Meade.net", MessageBoxButtons.OK, MessageBoxIcon.Warning);
+            }
+            catch (Exception ex)
+            {
+                MessageBox.Show(ex.ToString(), "Meade.net", MessageBoxButtons.OK, MessageBoxIcon.Stop);
+            }
+            return;
+        }
+
+        //
+        // Do everything to register this for COM. Never use REGASM on
+        // this exe assembly! It would create InProcServer32 entries 
+        // which would prevent proper activation!
+        //
+        // Using the list of COM object types generated during dynamic
+        // assembly loading, it registers each one for COM as served by our
+        // exe/local server, as well as registering it for ASCOM. It also
+        // adds DCOM info for the local server itself, so it can be activated
+        // via an outboiud connection from TheSky.
+        //
+        private static void RegisterObjects()
+        {
+            if (!IsAdministrator)
+            {
+                ElevateSelf("/register");
+                return;
+            }
+            //
+            // If reached here, we're running elevated
+            //
+
+            Assembly assy = Assembly.GetExecutingAssembly();
+            Attribute attr = Attribute.GetCustomAttribute(assy, typeof(AssemblyTitleAttribute));
+            string assyTitle = ((AssemblyTitleAttribute)attr).Title;
+            attr = Attribute.GetCustomAttribute(assy, typeof(AssemblyDescriptionAttribute));
+            string assyDescription = ((AssemblyDescriptionAttribute)attr).Description;
+
+            //
+            // Local server's DCOM/AppID information
+            //
+            try
+            {
+                //
+                // HKCR\APPID\appid
+                //
+                using (RegistryKey key = Registry.ClassesRoot.CreateSubKey("APPID\\" + s_appId))
+                {
+                    key.SetValue(null, assyDescription);
+                    key.SetValue("AppID", s_appId);
+                    key.SetValue("AuthenticationLevel", 1, RegistryValueKind.DWord);
+                }
+                //
+                // HKCR\APPID\exename.ext
+                //
+                using (RegistryKey key = Registry.ClassesRoot.CreateSubKey(string.Format("APPID\\{0}",
+                            Application.ExecutablePath.Substring(Application.ExecutablePath.LastIndexOf('\\') + 1))))
+                {
+                    key.SetValue("AppID", s_appId);
+                }
+            }
+            catch (Exception ex)
+            {
+                MessageBox.Show("Error while registering the server:\n" + ex.ToString(),
+                        "Meade.net", MessageBoxButtons.OK, MessageBoxIcon.Stop);
+                return;
+            }
+            finally
+            {
+            }
+
+            //
+            // For each of the driver assemblies
+            //
+            foreach (Type type in s_ComObjectTypes)
+            {
+                bool bFail = false;
+                try
+                {
+                    //
+                    // HKCR\CLSID\clsid
+                    //
+                    string clsid = Marshal.GenerateGuidForType(type).ToString("B");
+                    string progid = Marshal.GenerateProgIdForType(type);
+                    //PWGS Generate device type from the Class name
+                    string deviceType = type.Name;
+
+                    using (RegistryKey key = Registry.ClassesRoot.CreateSubKey(string.Format("CLSID\\{0}", clsid)))
+                    {
+                        key.SetValue(null, progid);						// Could be assyTitle/Desc??, but .NET components show ProgId here
+                        key.SetValue("AppId", s_appId);
+                        using (RegistryKey key2 = key.CreateSubKey("Implemented Categories"))
+                        {
+                            key2.CreateSubKey("{62C8FE65-4EBB-45e7-B440-6E39B2CDBF29}");
+                        }
+                        using (RegistryKey key2 = key.CreateSubKey("ProgId"))
+                        {
+                            key2.SetValue(null, progid);
+                        }
+                        key.CreateSubKey("Programmable");
+                        using (RegistryKey key2 = key.CreateSubKey("LocalServer32"))
+                        {
+                            key2.SetValue(null, Application.ExecutablePath);
+                        }
+                    }
+                    //
+                    // HKCR\CLSID\progid
+                    //
+                    using (RegistryKey key = Registry.ClassesRoot.CreateSubKey(progid))
+                    {
+                        key.SetValue(null, assyTitle);
+                        using (RegistryKey key2 = key.CreateSubKey("CLSID"))
+                        {
+                            key2.SetValue(null, clsid);
+                        }
+                    }
+                    //
+                    // ASCOM 
+                    //
+                    assy = type.Assembly;
+
+                    // Pull the display name from the ServedClassName attribute.
+                    attr = Attribute.GetCustomAttribute(type, typeof(ServedClassNameAttribute)); //PWGS Changed to search type for attribute rather than assembly
+                    string chooserName = ((ServedClassNameAttribute)attr).DisplayName ?? "MultiServer";
+                    using (var P = new ASCOM.Utilities.Profile())
+                    {
+                        P.DeviceType = deviceType;
+                        P.Register(progid, chooserName);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    MessageBox.Show("Error while registering the server:\n" + ex.ToString(),
+                            "Meade.net", MessageBoxButtons.OK, MessageBoxIcon.Stop);
+                    bFail = true;
+                }
+                finally
+                {
+                }
+                if (bFail) break;
+            }
+        }
+
+        //
+        // Remove all traces of this from the registry. 
+        //
+        // **TODO** If the above does AppID/DCOM stuff, this would have
+        // to remove that stuff too.
+        //
+        private static void UnregisterObjects()
+        {
+            if (!IsAdministrator)
+            {
+                ElevateSelf("/unregister");
+                return;
+            }
+
+            //
+            // Local server's DCOM/AppID information
+            //
+            Registry.ClassesRoot.DeleteSubKey(string.Format("APPID\\{0}", s_appId), false);
+            Registry.ClassesRoot.DeleteSubKey(string.Format("APPID\\{0}",
+                    Application.ExecutablePath.Substring(Application.ExecutablePath.LastIndexOf('\\') + 1)), false);
+
+            //
+            // For each of the driver assemblies
+            //
+            foreach (Type type in s_ComObjectTypes)
+            {
+                string clsid = Marshal.GenerateGuidForType(type).ToString("B");
+                string progid = Marshal.GenerateProgIdForType(type);
+                string deviceType = type.Name;
+                //
+                // Best efforts
+                //
+                //
+                // HKCR\progid
+                //
+                Registry.ClassesRoot.DeleteSubKey(String.Format("{0}\\CLSID", progid), false);
+                Registry.ClassesRoot.DeleteSubKey(progid, false);
+                //
+                // HKCR\CLSID\clsid
+                //
+                Registry.ClassesRoot.DeleteSubKey(String.Format("CLSID\\{0}\\Implemented Categories\\{{62C8FE65-4EBB-45e7-B440-6E39B2CDBF29}}", clsid), false);
+                Registry.ClassesRoot.DeleteSubKey(String.Format("CLSID\\{0}\\Implemented Categories", clsid), false);
+                Registry.ClassesRoot.DeleteSubKey(String.Format("CLSID\\{0}\\ProgId", clsid), false);
+                Registry.ClassesRoot.DeleteSubKey(String.Format("CLSID\\{0}\\LocalServer32", clsid), false);
+                Registry.ClassesRoot.DeleteSubKey(String.Format("CLSID\\{0}\\Programmable", clsid), false);
+                Registry.ClassesRoot.DeleteSubKey(String.Format("CLSID\\{0}", clsid), false);
+                try
+                {
+                    //
+                    // ASCOM
+                    //
+                    using (var P = new ASCOM.Utilities.Profile())
+                    {
+                        P.DeviceType = deviceType;
+                        P.Unregister(progid);
+                    }
+                }
+                catch (Exception) { }
+            }
+        }
+        #endregion
+
+        #region Class Factory Support
+        //
+        // On startup, we register the class factories of the COM objects
+        // that we serve. This requires the class facgtory name to be
+        // equal to the served class name + "ClassFactory".
+        //
+        private static bool RegisterClassFactories()
+        {
+            s_ClassFactories = new ArrayList();
+            foreach (Type type in s_ComObjectTypes)
+            {
+                ClassFactory factory = new ClassFactory(type);                  // Use default context & flags
+                s_ClassFactories.Add(factory);
+                if (!factory.RegisterClassObject())
+                {
+                    MessageBox.Show("Failed to register class factory for " + type.Name,
+                        "Meade.net", MessageBoxButtons.OK, MessageBoxIcon.Stop);
+                    return false;
+                }
+            }
+            ClassFactory.ResumeClassObjects();                                  // Served objects now go live
+            return true;
+        }
+
+        private static void RevokeClassFactories()
+        {
+            ClassFactory.SuspendClassObjects();                                 // Prevent race conditions
+            foreach (ClassFactory factory in s_ClassFactories)
+                factory.RevokeClassObject();
+        }
+        #endregion
+
+        #region Command Line Arguments
+        //
+        // ProcessArguments() will process the command-line arguments
+        // If the return value is true, we carry on and start this application.
+        // If the return value is false, we terminate this application immediately.
+        //
+        private static bool ProcessArguments(string[] args)
+        {
+            bool bRet = true;
+
+            //
+            //**TODO** -Embedding is "ActiveX start". Prohibit non_AX starting?
+            //
+            if (args.Length > 0)
+            {
+
+                switch (args[0].ToLower())
+                {
+                    case "-embedding":
+                        StartedByCOM = true;                                        // Indicate COM started us
+                        break;
+
+                    case "-register":
+                    case @"/register":
+                    case "-regserver":                                          // Emulate VB6
+                    case @"/regserver":
+                        RegisterObjects();                                      // Register each served object
+                        bRet = false;
+                        break;
+
+                    case "-unregister":
+                    case @"/unregister":
+                    case "-unregserver":                                        // Emulate VB6
+                    case @"/unregserver":
+                        UnregisterObjects();                                    //Unregister each served object
+                        bRet = false;
+                        break;
+
+                    default:
+                        MessageBox.Show("Unknown argument: " + args[0] + "\nValid are : -register, -unregister and -embedding",
+                            "Meade.net", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
+                        break;
+                }
+            }
+            else
+                StartedByCOM = false;
+
+            return bRet;
+        }
+        #endregion
+
+        #region SERVER ENTRY POINT (main)
+        //
+        // ==================
+        // SERVER ENTRY POINT
+        // ==================
+        //
+        [STAThread]
+        static void Main(string[] args)
+        {
+            if (!LoadComObjectAssemblies()) return;                     // Load served COM class assemblies, get types
+
+            if (!ProcessArguments(args)) return;                        // Register/Unregister
+
+            // Initialize critical member variables.
+            objsInUse = 0;
+            serverLocks = 0;
+            MainThreadId = GetCurrentThreadId();
+            Thread.CurrentThread.Name = "Main Thread";
+
+            Application.EnableVisualStyles();
+            Application.SetCompatibleTextRenderingDefault(false);
+            s_MainForm = new frmMain();
+            if (StartedByCOM) s_MainForm.WindowState = FormWindowState.Minimized;
+
+            // Register the class factories of the served objects
+            RegisterClassFactories();
+
+            // Start up the garbage collection thread.
+            GarbageCollection GarbageCollector = new GarbageCollection(1000);
+            Thread GCThread = new Thread(new ThreadStart(GarbageCollector.GCWatch));
+            GCThread.Name = "Garbage Collection Thread";
+            GCThread.Start();
+
+            //
+            // Start the message loop. This serializes incoming calls to our
+            // served COM objects, making this act like the VB6 equivalent!
+            //
+            try
+            {
+                Application.Run(s_MainForm);
+            }
+            finally
+            {
+                // Revoke the class factories immediately.
+                // Don't wait until the thread has stopped before
+                // we perform revocation!!!
+                RevokeClassFactories();
+
+                // Now stop the Garbage Collector thread.
+                GarbageCollector.StopThread();
+                GarbageCollector.WaitForThreadToStop();
+            }
+        }
+        #endregion
+    }
+}

Meade.net/Meade.net.csproj

@@ -0,0 +1,153 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="12.0">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>8.0.50727</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{3689A2CB-94C5-4012-A5CF-7E7D1DD27143}</ProjectGuid>
+    <OutputType>WinExe</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>ASCOM.Meade.net</RootNamespace>
+    <AssemblyName>ASCOM.Meade.net.Server</AssemblyName>
+    <TargetFrameworkVersion>v4.7.1</TargetFrameworkVersion>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <OldToolsVersion>2.0</OldToolsVersion>
+    <UpgradeBackupLocation />
+    <TargetFrameworkProfile />
+    <IsWebBootstrapper>false</IsWebBootstrapper>
+    <PublishUrl>publish\</PublishUrl>
+    <Install>true</Install>
+    <InstallFrom>Disk</InstallFrom>
+    <UpdateEnabled>false</UpdateEnabled>
+    <UpdateMode>Foreground</UpdateMode>
+    <UpdateInterval>7</UpdateInterval>
+    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
+    <UpdatePeriodically>false</UpdatePeriodically>
+    <UpdateRequired>false</UpdateRequired>
+    <MapFileExtensions>true</MapFileExtensions>
+    <ApplicationRevision>0</ApplicationRevision>
+    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
+    <UseApplicationTrust>false</UseApplicationTrust>
+    <BootstrapperEnabled>true</BootstrapperEnabled>
+  </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>
+    <PlatformTarget>x86</PlatformTarget>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>false</Prefer32Bit>
+  </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>
+    <PlatformTarget>x86</PlatformTarget>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>LocalServer.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <PropertyGroup>
+    <ApplicationIcon>ASCOM.ico</ApplicationIcon>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="ASCOM.Attributes, Version=6.0.0.0, Culture=neutral, PublicKeyToken=565de7938946fba7, processorArchitecture=MSIL" />
+    <Reference Include="ASCOM.DeviceInterfaces, Version=6.0.0.0, Culture=neutral, PublicKeyToken=565de7938946fba7, processorArchitecture=MSIL" />
+    <Reference Include="ASCOM.Exceptions, Version=6.0.0.0, Culture=neutral, PublicKeyToken=565de7938946fba7, processorArchitecture=MSIL" />
+    <Reference Include="ASCOM.Utilities, Version=6.0.0.0, Culture=neutral, PublicKeyToken=565de7938946fba7, processorArchitecture=MSIL" />
+    <Reference Include="System" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="ClassFactory.cs" />
+    <Compile Include="frmMain.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="frmMain.Designer.cs">
+      <DependentUpon>frmMain.cs</DependentUpon>
+    </Compile>
+    <Compile Include="GarbageCollection.cs" />
+    <Compile Include="LocalServer.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <EmbeddedResource Include="frmMain.resx">
+      <SubType>Designer</SubType>
+      <DependentUpon>frmMain.cs</DependentUpon>
+    </EmbeddedResource>
+    <Compile Include="Properties\Resources.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>Resources.resx</DependentUpon>
+    </Compile>
+    <Compile Include="ReferenceCountedObject.cs" />
+    <Compile Include="SetupDialogForm.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="SetupDialogForm.designer.cs">
+      <DependentUpon>SetupDialogForm.cs</DependentUpon>
+    </Compile>
+    <Compile Include="SharedResources.cs" />
+    <EmbeddedResource Include="Properties\Resources.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+    <EmbeddedResource Include="SetupDialogForm.resx">
+      <DependentUpon>SetupDialogForm.cs</DependentUpon>
+      <SubType>Designer</SubType>
+    </EmbeddedResource>
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="ASCOM.ico" />
+    <Content Include="ASCOM.png" />
+    <Content Include="ReadMe.htm" />
+    <None Include="Resources\ASCOM.bmp" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="app.config" />
+    <None Include="LocalServer.snk" />
+  </ItemGroup>
+  <ItemGroup>
+    <BootstrapperPackage Include="Microsoft.Net.Client.3.5">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName>
+      <Install>false</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Windows.Installer.3.1">
+      <Visible>False</Visible>
+      <ProductName>Windows Installer 3.1</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+  </ItemGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+  <PropertyGroup>
+    <PreBuildEvent>
+    </PreBuildEvent>
+    <PostBuildEvent>
+    </PostBuildEvent>
+  </PropertyGroup>
+</Project>

Meade.net/Properties/AssemblyInfo.cs

@@ -0,0 +1,27 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("ASCOM Meade.net server")]
+[assembly: AssemblyDescription("ASCOM multi-interface server for Meade.net")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("cjdawson.com")]
+[assembly: AssemblyProduct("")]
+[assembly: AssemblyCopyright("Copyright © 2019 cjdawson.com")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+[assembly: AssemblyVersion("0.4.0.0")]
+[assembly: AssemblyFileVersion("0.4.0.0")]
+
+[assembly: ComVisibleAttribute(false)]

Meade.net/Properties/Resources.Designer.cs

@@ -0,0 +1,73 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.42000
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace ASCOM.Meade.net.Properties {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "15.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class Resources {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal Resources() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("ASCOM.Meade.net.Properties.Resources", typeof(Resources).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap ASCOM {
+            get {
+                object obj = ResourceManager.GetObject("ASCOM", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+    }
+}

Meade.net/Properties/Resources.resx

@@ -0,0 +1,124 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
+  <data name="ASCOM" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\ASCOM.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+</root>

Meade.net/ReadMe.htm

@@ -0,0 +1,666 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+  <HEAD>
+    <META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=windows-1252"/>
+    <TITLE>Untitled Document</TITLE>
+    <META NAME="GENERATOR" CONTENT="OpenOffice.org 3.2  (Win32)"/>
+    <META NAME="CREATED" CONTENT="0;0"/>
+    <META NAME="CHANGEDBY" CONTENT="Chris Rowland"/>
+    <META NAME="CHANGED" CONTENT="20110422;10442800"/>
+    <META NAME="CHANGEDBY" CONTENT="Chris Rowland"/>
+    <STYLE TYPE="text/css">
+      <!--
+		@page { margin: 2cm }
+		P { font-family: "Verdana", "Arial", "Helvetica", sans-serif; font-weight: normal }
+		TD P { font-family: "Verdana", "Arial", "Helvetica", sans-serif; font-weight: normal }
+		H3 { font-family: "Arial", "Helvetica", sans-serif }
+		H2 { font-family: "Arial", "Helvetica", sans-serif }
+		H4 { font-family: "Arial", "Helvetica", sans-serif }
+		PRE { margin-left: 0.18cm; margin-right: 0.18cm; margin-top: 0.18cm; margin-bottom: 0.18cm; background: #ccffff }
+		PRE.western { font-weight: normal }
+		PRE.cjk { font-family: "NSimSun", monospace; font-weight: normal }
+		PRE.ctl { font-weight: normal }
+		EM.underline { text-decoration: underline }
+	-->
+    </STYLE>
+  </HEAD>
+  <BODY LANG="en-GB" DIR="LTR">
+    <TABLE WIDTH="100%" BORDER="0" CELLPADDING="4" CELLSPACING="0" STYLE="page-break-before: always">
+      <TR>
+        <TD>
+          <H2>
+            ASCOM LocalServer (singleton) Host
+          </H2>
+        </TD>
+      </TR>
+    </TABLE>
+    <P>
+      <BR/>
+      <BR/>
+
+    </P>
+    <H4>
+      You have just created a local server (singleton) host for one or
+      more ASCOM driver classes.
+    </H4>
+    <HR/>
+    <P>
+      This project implements an ASCOM host server for one or more
+      driver classes in a single-instance executable. It can be used to
+      serve multiple instances of a single driver class (hub), provide
+      driver services for multiple devices (e.g., Telescope and Focuser) to
+      multiple applications and allow multiple devices of the same type to
+      be connected. In the latter scenario, the multiple driver classes
+      will often share one or more resources such as the serial connection
+      and a microcontroller in the combined device. From the client's
+      perspective, using the drivers served by the local server is exactly
+      the same as if the drivers are loaded into the client's process space
+      (in-proc servers).
+    </P>
+    <P STYLE="margin-left: 0.42cm; margin-right: 0.42cm; border: 1px solid #000000; padding: 0.21cm">
+      <STRONG>
+        <SPAN STYLE="background: #ffee88">NOTE:</SPAN>
+      </STRONG>
+      <SPAN STYLE="background: #ffee88">
+        Unless you are prepared to handle all of the timing issues that arise
+        when multiple clients are accessing the properties and methods of
+        your driver(s), stop now. Just because the local server serializes
+        the calls to your driver(s)' properties and methods does not mean
+        that there will be no timing or concurrency issues.<BR/>
+        &nbsp;<BR/>For
+        example, suppose the hub serves instances of a Telescope driver. One
+        client sets the TargetRightAscension property, then another sets
+        TargetRightAscension to a different value, then the first client sets
+        TargetDeclination, then the first client calls SlewToTarget()
+        followed by the second client calling SlewToTarget(). Besides the
+        first client's slew command sending the scope to the wrong (and
+        possibly dangerous) coordinates, there is the problem of the second
+        client trying to slew a slewing scope. Local server drivers are
+        tricky to get right. There is no such thing as &quot;ignorance is
+        bliss&quot; here.
+
+      </SPAN>
+    </P>
+    <P STYLE="margin-left: 0.42cm; margin-right: 0.42cm; border: 1px solid #000000; padding: 0.21cm">
+      <SPAN STYLE="background: #ffee88">
+        This implementation has changed
+        from what was defined for Platform 5.5 as follows:
+      </SPAN>
+    </P>
+    <P STYLE="margin-left: 0.42cm; margin-right: 0.42cm; border: 1px solid #000000; padding: 0.21cm">
+      <SPAN STYLE="background: #ffee88">
+        The drivers are now installed in
+        the same folder as the local server executable. This makes deployment
+        cleaner because the whole driver can exist in a single folder
+        independently of other drivers.
+      </SPAN>
+    </P>
+    <P STYLE="margin-left: 0.42cm; margin-right: 0.42cm; border: 1px solid #000000; padding: 0.21cm">
+      <SPAN STYLE="background: #ffee88">
+        The ProgId and friendly name as
+        displayed by the Chooser are defined using attributes. This allows
+        driver dlls to be identified clearly and so avoids confusion with
+        other dlls that may be required such as interop dlls.
+      </SPAN>
+    </P>
+    <P STYLE="margin-left: 0.42cm; margin-right: 0.42cm; border: 1px solid #000000; padding: 0.21cm">
+      <SPAN STYLE="background: #ffee88">
+        Some changes have been made that
+        will facilitate generating multiple drivers of the same type.
+      </SPAN>
+    </P>
+    <P STYLE="margin-left: 0.42cm; margin-right: 0.42cm; border: 1px solid #000000; padding: 0.21cm">
+      <SPAN STYLE="background: #ffee88">
+        I've put some additional advice and
+        comments in the notes below <I>in italics.</I>
+      </SPAN>
+    </P>
+    <P>
+      You're probably anxious to get going, but you really should read
+      through the <A HREF="#theory">Theory of Operation</A> and <A HREF="#details">
+        Detailed
+        Use and Deployment
+      </A> below.
+    </P>
+    <P>You must do the following in order to complete your local server:</P>
+    <OL>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          In the local server's project
+          properties, Application tab, change BOTH the AssemblyName and the
+          default assembly name to ASCOM.xxx (e.g., ASCOM.SuperScope). <I>
+            This
+            may be done by default now.
+          </I>
+        </P>
+      </LI>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          Add one or more driver skeleton
+          projects using the in-proc templates. You may use either the C# or
+          VB templates. Project name is not important (not used in ProgID)
+          choose something like TelescopeDriver. You will be changing the
+          substituted project name in these projects below. If you ensure that
+          the LocalServer and all the driver projects have the same NameSpace
+          e.g. ASCOM.SuperScope the renaming in section 6a will not be
+          required.
+        </P>
+      </LI>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          Develop and debug these driver
+          projects as normal in-process assemblies. This will be much simpler
+          because the driver and test code can be debugged in the same
+          process.
+        </P>
+      </LI>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          Build the LocalServer.
+        </P>
+      </LI>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          Set a reference to the local
+          server <STRONG>project</STRONG> in each of the driver skeleton
+          projects.
+        </P>
+      </LI>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">In each skeleton driver project:</P>
+        <OL TYPE="a">
+          <LI>
+            <P STYLE="margin-bottom: 0cm">
+              Do a Find In Files for the
+              project name of the skeleton driver (e.g., TelescopeDriver) and
+              change it to match the project name of your local server (e.g.
+              SuperScope). You don't have to do this in the ReadMe.html file.
+              Everywhere else, however, is IMPORTANT. This sets the correct
+              namespace, progID, etc. If you're a bit more brave, you can use
+              Replace in Files. <I>
+                This may not be needed if the correct
+                namespace and naming conventions have been followed when the
+                drivers and local server were generated.
+              </I>
+            </P>
+          </LI>
+          <LI>
+            <P STYLE="margin-bottom: 0cm">
+              In project properties,
+              Application tab, change the assembly name to
+              ASCOM.<EM CLASS="underline">localserverprojectname</EM>.<EM>drivertype</EM>,
+              (e.g., ASCOM.SuperScope.Telescope).
+            </P>
+          </LI>
+          <LI>
+            <P STYLE="margin-bottom: 0cm">
+              In project properties,
+              Application tab, click Assembly Information...
+            </P>
+            <UL>
+              <LI>
+                <P STYLE="margin-bottom: 0cm">
+                  Assure that Make assembly COM
+                  visible is <STRONG>on</STRONG> (it should already be on).
+                </P>
+              </LI>
+              <LI>
+                <P STYLE="margin-bottom: 0cm">
+                  Edit the Product Name to be the
+                  &quot;friendly name&quot; of your driver as will be shown in the
+                  Chooser. <I>
+                    Not used now, use the ServedClassName attribute
+                    instead.
+                  </I>
+                </P>
+              </LI>
+            </UL>
+          </LI>
+          <LI>
+            <P STYLE="margin-bottom: 0cm">
+              In project properties, Build tab,
+              turn <STRONG>off</STRONG> Register for COM Interop.
+            </P>
+          </LI>
+          <LI>
+            <P>
+              Modify the driver class declaration to inherit from
+              ReferenceCountedObjectBase. Examples:<BR/>C#:
+            </P>
+            <PRE CLASS="western">
+              public class Telescope :
+              ReferenceCountedObjectBase,
+              ITelescope
+            </PRE>
+            <P>
+              VB:
+            </P>
+            <PRE CLASS="western">
+              Public Class Telescope
+              '==================================
+              Inherits ReferenceCountedObjectBase
+              Implements ITelescope
+              '==================================
+            </PRE>
+          </LI>
+          <LI>
+            <P STYLE="margin-bottom: 0cm">
+              In driver.cs/driver.vb, remove
+              the entire ASCOM Registration region
+            </P>
+          </LI>
+          <LI>
+            <P STYLE="margin-bottom: 0cm">
+              In driver.cs/driver.vb, remove
+              the private strings for driver ID and driver description. <I>
+                They
+                may be needed internally, and if so should be set from the
+                associated attributes, ServedClassName for the description and
+                ProgId for the driver Id.
+              </I>
+            </P>
+          </LI>
+          <LI>
+            <P STYLE="margin-bottom: 0cm">
+              Modify the class attributes by
+              adding the ServedClassName and ProgID attributes. The
+              ServedClassName attribute must be the friendly name shown as the
+              device name in the Chooser and the ProgId the progid of the driver
+              e.g. ASCOM.SuperScope.Telescope. The class header should look like
+              this:
+            </P>
+            <P STYLE="margin-bottom: 0cm">C#:</P>
+            <PRE CLASS="western" STYLE="margin-right: 0.16cm">
+              <FONT FACE="Consolas" SIZE="2" STYLE="font-size: 9pt">
+                [<FONT COLOR="#2b91af">Guid</FONT><FONT COLOR="#000000">(</FONT><FONT COLOR="#a31515">&quot;0AE8B38D-10A1-4A8D-A5B7-1B050F74B48B&quot;</FONT><FONT COLOR="#000000">)]  // set by the template</FONT>
+                <FONT COLOR="#000000">[</FONT><FONT COLOR="#2b91af">ProgId</FONT><FONT COLOR="#000000">(</FONT><FONT COLOR="#a31515">&quot;ASCOM.SuperScope.Telescope&quot;</FONT><FONT COLOR="#000000">)]</FONT>
+                <FONT COLOR="#000000">[</FONT><FONT COLOR="#2b91af">ServedClassName</FONT><FONT COLOR="#000000"> (</FONT><FONT COLOR="#a31515">&quot;Super Scope Telescope&quot;</FONT><FONT COLOR="#000000">)]</FONT>
+                <FONT COLOR="#000000">[</FONT><FONT COLOR="#2b91af">ClassInterface</FONT><FONT COLOR="#000000">(</FONT><FONT COLOR="#2b91af">ClassInterfaceType</FONT><FONT COLOR="#000000">.None)]</FONT>
+                <FONT COLOR="#0000ff">public </FONT><FONT COLOR="#0000ff">class </FONT><FONT COLOR="#2b91af">Telescope </FONT><FONT COLOR="#000000">: </FONT><FONT COLOR="#2b91af">ReferenceCountedObjectBase</FONT><FONT COLOR="#000000"> , </FONT><FONT COLOR="#2b91af">ITelescope</FONT>
+              </FONT>
+            </PRE>
+          </LI>
+        </OL>
+      </LI>
+    </OL>
+    <P STYLE="margin-bottom: 0cm">
+      <BR/>
+    </P>
+    <OL>
+      <OL TYPE="a">
+        <P>VB:</P>
+        <PRE CLASS="western">
+          <FONT FACE="Consolas" SIZE="2" STYLE="font-size: 9pt">
+            &lt;Guid(&ldquo;<FONT COLOR="#a31515">0AE8B38D-10A1-4A8D-A5B7-1B050F74B48B</FONT>&rdquo;)&gt;
+            &lt;ProgId(&ldquo;ASCOM.SuperScope.Telescope&rdquo;)&gt;
+            &lt;ServedClassName(&ldquo;Super Scope Telescope&rdquo;)&gt;
+            Public Class Telescope
+            '==================================
+            Inherits ReferenceCountedObjectBase
+            Implements ITelescope
+            '==================================
+          </FONT>
+        </PRE>
+      </OL>
+    </OL>
+    <P STYLE="margin-left: 2.5cm">
+      Add the following line to the driver
+      constructor, this sets the driver ID using the ProgId Attribute:
+    </P>
+    <OL>
+      <OL TYPE="a">
+        <P>C#</P>
+        <PRE CLASS="western">
+          <FONT FACE="Consolas" SIZE="2" STYLE="font-size: 9pt">
+            s_csDriverID = <FONT COLOR="#2b91af">Marshal</FONT><FONT COLOR="#000000">.GenerateProgIdForType(</FONT><FONT COLOR="#0000ff">this</FONT><FONT COLOR="#000000">.GetType());</FONT>
+          </FONT>
+        </PRE>
+        <P>VB:</P>
+        <PRE CLASS="western">
+          <FONT FACE="Consolas" SIZE="2" STYLE="font-size: 9pt">
+            s_csDriverID = <FONT COLOR="#2b91af">Marshal</FONT><FONT COLOR="#000000">.GenerateProgIdForType(</FONT><FONT COLOR="#0000ff">Me</FONT><FONT COLOR="#000000">.GetType())</FONT>
+          </FONT>
+        </PRE>
+      </OL>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          Unless you're writing a
+          single-driver hub, you will have two or more driver types (e.g.
+          Telescope and Focuser) and thus two or more driver assembly projects
+          added. Presumably, these drivers need to share some resources (e.g.
+          a single COM port via Helper.Serial). <U>
+            Put shared resources into
+            the SharedResources class provided
+          </U>. There are some examples that
+          should give a clue, modify and delete these as required.
+        </P>
+      </LI>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          A shared serial port is already
+          provided (see SharedResources.cs) as <FONT FACE="Lucida Console, Courier New, Courier, monospace">SharedResources.SharedSerial</FONT>
+          and it is an ASCOM Helper Serial object. You may wish to define
+          additional shared resources in static member variables with public
+          static accessor properties as is already done for SharedSerial.
+          Unfortunately, if you are a Visual Basic programmer, you will have
+          to make these additions in C#.
+        </P>
+      </LI>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          If you are writing a hub and don't
+          need the serial port, in SharedResources.cs you can remove the
+          public static SharedSerial property, the m_SharedSerial member in
+          the private data region, and the line in main that initializes it.
+          If you don't need any other shared resources for your hub, then you
+          can remove the SharedResources.cs file completely.
+        </P>
+      </LI>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          If you modified the LocalServer,
+          build it again now. This will refresh the stuff that's visible to
+          the drivers.
+        </P>
+      </LI>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          Build the driver skeletons to
+          verify that you got all of the namespace and other variable changes.
+        </P>
+      </LI>
+      <LI>
+        <P>
+          The local server dynamically loads the driver assemblies from
+          the same folder as the local server executable. <BR/>
+          <BR/>During
+          development, you'll need to add a post-build task to each of your
+          driver assembly projects which puts a copy of the driver assembly
+          into the local server executable folder. Here is an example:
+        </P>
+        <PRE CLASS="western">    copy &quot;$(TargetPath)&quot; &quot;$(SolutionDir)\SuperScope\$(OutDir)\$(TargetFileName)&quot;</PRE>
+        <P STYLE="margin-bottom: 0cm">
+          This assumes that the server project is called &ldquo;SuperScope&rdquo;,
+          and handles using the debug or release build.<BR/>
+          Note the quotes for
+          possible path elements with spaces in them. <I>
+            An alternative is to
+            set the build path to the required destination instead of the
+            default path.
+          </I>
+        </P>
+      </LI>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          <I>
+            Make sure the drivers are
+            registered through the local server by running it with the /register
+            parameter, see below for details.
+          </I>
+        </P>
+      </LI>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          <SPAN STYLE="background: #ffff00">IMPORTANT:</SPAN>
+          With a local server based driver (or hub) it is possible for
+          multiple clients to control the device(s). It is up to you to
+          safeguard against abuse. <I>
+            The sort of thing that's needed is to
+            have a counter of the number of connections to a device, the
+            connection is only fully broken when the number of connections is
+            zero. You may also need code to prevent several drivers from talking
+            to the hardware at the same time, the lock pattern is useful for
+            that.
+          </I>
+        </P>
+      </LI>
+      <LI>
+        <P>
+          You may want to add controls and/or status information to the
+          main form frmMain of the local server. Please resist the temptation
+          to turn the local server's main form into a graphical device control
+          panel. Instead, make a separate application that uses the served
+          driver(s). <U>A driver is not a program!</U>
+        </P>
+      </LI>
+    </OL>
+    <H3>Notes</H3>
+    <UL>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          The local server handles all of
+          the registration and unregistration for each of its served driver
+          classes, including the ASCOM Chooser info and the DCOM/AppID info
+          needed for activation from TheSky. By running the server from a
+          command line and giving /register or /unregister as the command line
+          option, it will register or unregister all served classes
+          (respectively). <SPAN STYLE="background: #ffff00">
+            Never use REGASM
+            on the local server executable!
+          </SPAN> <I>
+            This can be done in the
+            Visual Studio IDE by setting the server project to run as startup
+            and setting the command line argument to /register in Debug &ndash;
+            Start Options.
+          </I>
+        </P>
+      </LI>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          When you make the installer for
+          your local server based driver/hub, do not let it register the
+          executable for COM. Instead, have it activate the installed local
+          server with the /register option.
+        </P>
+      </LI>
+      <LI>
+        <P>
+          The ASCOM registration uses the ServedClassName attribute as
+          the friendly name that will show in the chooser and the ProgId
+          attribute as the driver Id.
+        </P>
+      </LI>
+      <LI>
+        <P>
+          The best deployment way is to install all the files in a
+          folder that's a sub folder of the main driver, so the SuperScope
+          driver files will be in the folder ...\ASCOM\Telescope\SuperScope.
+          This can be done in the Inno script by changing the DefaultDirName
+          like this:<BR/>
+            DefaultDirName=&quot;{cf}\ASCOM\Telescope\SuperScope&quot;<BR/>then
+	the files can all be installed with DestDir: {app}; 
+        </P>
+      </LI>
+    </UL>
+    <H3>
+      <A NAME="theory"></A>Theory of Operation
+    </H3>
+    <P>
+      The local server is an executable which can provide multiple
+      instances of multiple drivers to multiple clients. This capability is
+      needed for two applications:
+    </P>
+    <UL>
+      <LI>
+        <P STYLE="margin-bottom: 0cm">
+          A hub, which allows multiple
+          clients to share a single device
+        </P>
+      </LI>
+      <LI>
+        <P>
+          A device which provides multiple services, such as a
+          telescope which has a focuser built-in where both the telescope and
+          focuser are controlled by the same serial connection and different
+          client programs need to control to the focuser and telescope.
+        </P>
+      </LI>
+    </UL>
+    <P>
+      By simply dropping suitably developed driver assemblies into the
+      same folder as the local server executable, the local server will
+      find them and register them for COM and ASCOM and serve any number of
+      instances of the drivers' interfaces to any number of client
+      programs. It does this by locating and loading the driver assemblies,
+      analysing them to detect their classes and interfaces, and
+      implementing a class factory that can create instances of them for
+      clients.
+    </P>
+    <P>
+      A driver is an assembly which contains a class that <EM>implements</EM>
+      one of the ASCOM standard driver interfaces and <EM>inherits</EM> the
+      ReferenceCountedObjectBase class of the local server. Apart from
+      that, driver assemblies are identical to those that are used
+      in-process (DLL-type). The instructions above detail the steps needed
+      to convert an in-process driver into one that can be served by the
+      local server.
+    </P>
+    <P>
+      The name of the local server is important, so we provide it as a
+      <EM>template</EM> from which you can create a local server for your
+      produce. To make this clear, let's assume that your company AlphaTech
+      produces a telescope system which contains a microcontroller that is
+      able to control not only the telescope mount, but also a focuser and
+      a camera rotator. The mount, focuser, and rotator are all controlled
+      via commands sent through a common serial line connecting the
+      computer to the microcontroller, so you need a local server. In
+      ASCOM, then, you probably want your system to appear as
+      AlphaTech.Telescope, AlphaTech.Focuser, and AlphaTech.Rotator. Then
+      you would name the local server AlphaTech. Be sure to give this due
+      consideration before creating the template, the project name is the
+      name of your local server. <I>
+        Is this still correct? I get the
+        impression that ASCOM.AlphaTech.Server would be OK.
+      </I>
+    </P>
+    <P>
+      The fact that driver classes inherit from the local server's
+      ReferenceCountedObjectBase class allows the local server to maintain
+      a reference count on the driver class. If a client creates an
+      instance of a served driver, the local server automatically starts up
+      and provides an instance of the class to the client. Once started the
+      local server can provide additional instances of any of its served
+      driver classes. If the reference count of all served classes drops to
+      zero as a result of clients releasing their instances, the local
+      server will automatically exit.
+    </P>
+    <P>
+      Registration services provided include not only the basic COM
+      class registration, but also DCOM/AppID info needed to use the served
+      classes from outbound connections from Software Bisque's TheSky. It
+      also registers the served classes for the ASCOM Chooser. The
+      &quot;friendly&quot; name of each served driver that appears in the
+      chooser comes from the driver's ServedClassName attribute. This also
+      used to identify a driver so that non driver dlls, such as Interop
+      dlls can be ignored. The COM ProgID for each served driver is
+      specified in the ProgId attribute - ASCOM.<EM>localservername</EM>.<EM>drivertype</EM>,
+      for example, ASCOM.AlphaTech.Telescope, where AlphaTech is the local
+      server name and Telescope is the type of the driver. Unregistering
+      removes all of this information from the system. Specifying the
+      ProgId as an attribute allows multiple driver assemblies to be
+      generated using the same source and namespace. This is used to
+      provide multiple instances of the same driver, each with a different
+      ProgId and so able to be registered separately.
+    </P>
+    <P>
+      Driver DLLs are identified for registering/unregistering because
+      they contain a type with the ServedClassName attribute. Only these
+      will be registered for Com and ASCOM.  This has changed; in Platform
+      5 there was no attribute and the local server attempted to register
+      all dlls. The new behaviour allows support dlls such as interop dlls
+      to be included without them being registered incorrectly.  There was
+      also an interim version where the ServedClassName attribute was on
+      the assembly, not the class.  <I>
+        All these previous versions, and the
+        new drivers will operate together with Platform 6, the changes are
+        local to the individual drivers.
+      </I>
+    </P>
+    <H3>
+      <A NAME="details"></A>Detailed Use and Deployment
+    </H3>
+    <P>
+      Once you have built your local server and the served driver class
+      assemblies, here's how to use it. To register the served classes,
+      activate the local server from a shell command line with the option
+      /register (or /regserver, for VB6 compatibility):
+    </P>
+    <PRE CLASS="western">
+      C:\xxx&gt; <EM>localserver</EM>.exe /register
+    </PRE>
+    <P>
+      To unregister the local server and its drivers, activate the local
+      server from a shell command line with the option /unregister (or
+      /unregserver for VB6 compatibility):
+    </P>
+    <PRE CLASS="western">
+      C:\xxx&gt; <EM>localserver</EM>.exe /unregister
+    </PRE>
+    <P>
+      When the operating system starts the local server in response to a
+      client creating one of it's served driver classes, the command option
+      /embedding is included. The local server's code detects this and sets
+      a variable that you can use.
+    </P>
+    <P STYLE="margin-bottom: 0cm">
+      When deploying a hub or set of drivers
+      with the local server, you'll have to arrange for the local server
+      and the driver assemblies to be placed together in a folder in the
+      ASCOM driver folder. Any support files, such as Interop DLLs can be
+      put in the same fiolder. That's all you need to do, the local server
+      will find them in the same folder as it is located in.
+    </P>
+    <DIV ALIGN="RIGHT">
+      <TABLE WIDTH="100"% BORDER="0" CELLPADDING="4" CELLSPACING="0">
+        <TR>
+          <TD>
+            <TABLE WIDTH="100"% BORDER="0" CELLPADDING="4" CELLSPACING="0">
+              <TR>
+                <TD>
+                  <H3>ASCOM Initiative</H3>
+                </TD>
+                <TD>
+                  <IMG SRC="ASCOM.png" NAME="graphics1" ALIGN="RIGHT" WIDTH="48" HEIGHT="56" BORDER="0"/>
+                </TD>
+              </TR>
+            </TABLE>
+            <P>
+              <BR/>
+              <BR/>
+
+            </P>
+          </TD>
+        </TR>
+        <TR>
+          <TD>
+            <P>
+              The ASCOM Initiative consists of a group of astronomy software
+              developers and instrument vendors whose goals are to promote the
+              driver/client model and scripting automation.
+            </P>
+            <P>
+              See the <A HREF="http://ascom-standards.org/" TARGET="browser">
+                ASCOM
+                web site
+              </A> for more information. Please participate in the
+              <A HREF="http://tech.groups.yahoo.com/group/ASCOM-Talk" TARGET="browser">
+                ASCOM-Talk
+                Yahoo Group
+              </A>.
+            </P>
+          </TD>
+        </TR>
+      </TABLE>
+    </DIV>
+    <P>
+      <BR/>
+      <BR/>
+
+    </P>
+    <P>
+      <BR/>
+      <BR/>
+
+    </P>
+  </BODY>
+</HTML>

Meade.net/ReferenceCountedObject.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace ASCOM.Meade.net
+{
+    [ComVisible(false)]
+    public class ReferenceCountedObjectBase
+    {
+        public ReferenceCountedObjectBase()
+        {
+            // We increment the global count of objects.
+            Server.CountObject();
+        }
+
+        ~ReferenceCountedObjectBase()
+        {
+            // We decrement the global count of objects.
+            Server.UncountObject();
+            // We then immediately test to see if we the conditions
+            // are right to attempt to terminate this server application.
+            Server.ExitIf();
+        }
+    }
+}

Meade.net/SetupDialogForm.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Drawing;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Windows.Forms;
+using ASCOM.Utilities;
+using ASCOM.Meade.net;
+
+namespace ASCOM.Meade.net
+{
+    [ComVisible(false)]					// Form not registered for COM!
+    public partial class SetupDialogForm : Form
+    {
+        public SetupDialogForm()
+        {
+            InitializeComponent();
+        }
+
+        private void cmdCancel_Click(object sender, EventArgs e) // Cancel button event handler
+        {
+            Close();
+        }
+
+        private void BrowseToAscom(object sender, EventArgs e) // Click on ASCOM logo event handler
+        {
+            try
+            {
+                System.Diagnostics.Process.Start("http://ascom-standards.org/");
+            }
+            catch (System.ComponentModel.Win32Exception noBrowser)
+            {
+                if (noBrowser.ErrorCode == -2147467259)
+                    MessageBox.Show(noBrowser.Message);
+            }
+            catch (System.Exception other)
+            {
+                MessageBox.Show(other.Message);
+            }
+        }      
+
+        public void SetProfile(ProfileProperties profileProperties)
+        {
+            chkTrace.Checked = profileProperties.TraceLogger;
+            // set the list of com ports to those that are currently available
+            comboBoxComPort.Items.Clear();
+            comboBoxComPort.Items.AddRange(System.IO.Ports.SerialPort.GetPortNames());      // use System.IO because it's static
+            // select the current port if possible
+            if (comboBoxComPort.Items.Contains(profileProperties.ComPort))
+            {
+                comboBoxComPort.SelectedItem = profileProperties.ComPort;
+            }
+        }
+
+        public ProfileProperties GetProfile()
+        {
+            var profileProperties = new ProfileProperties
+            {
+                TraceLogger = chkTrace.Checked,
+                ComPort = comboBoxComPort.SelectedItem.ToString()
+            };
+
+            return profileProperties;
+        }
+    }
+}

Meade.net/SetupDialogForm.designer.cs

@@ -0,0 +1,148 @@
+namespace ASCOM.Meade.net
+{
+    partial class SetupDialogForm
+    {
+        /// <summary>
+        /// Required designer variable.
+        /// </summary>
+        private System.ComponentModel.IContainer components = null;
+
+        /// <summary>
+        /// Clean up any resources being used.
+        /// </summary>
+        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing && (components != null))
+            {
+                components.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        #region Windows Form Designer generated code
+
+        /// <summary>
+        /// Required method for Designer support - do not modify
+        /// the contents of this method with the code editor.
+        /// </summary>
+        private void InitializeComponent()
+        {
+            this.cmdOK = new System.Windows.Forms.Button();
+            this.cmdCancel = new System.Windows.Forms.Button();
+            this.label1 = new System.Windows.Forms.Label();
+            this.picASCOM = new System.Windows.Forms.PictureBox();
+            this.label2 = new System.Windows.Forms.Label();
+            this.chkTrace = new System.Windows.Forms.CheckBox();
+            this.comboBoxComPort = new System.Windows.Forms.ComboBox();
+            ((System.ComponentModel.ISupportInitialize)(this.picASCOM)).BeginInit();
+            this.SuspendLayout();
+            // 
+            // cmdOK
+            // 
+            this.cmdOK.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
+            this.cmdOK.DialogResult = System.Windows.Forms.DialogResult.OK;
+            this.cmdOK.Location = new System.Drawing.Point(281, 112);
+            this.cmdOK.Name = "cmdOK";
+            this.cmdOK.Size = new System.Drawing.Size(59, 24);
+            this.cmdOK.TabIndex = 0;
+            this.cmdOK.Text = "OK";
+            this.cmdOK.UseVisualStyleBackColor = true;
+            // 
+            // cmdCancel
+            // 
+            this.cmdCancel.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right)));
+            this.cmdCancel.DialogResult = System.Windows.Forms.DialogResult.Cancel;
+            this.cmdCancel.Location = new System.Drawing.Point(281, 142);
+            this.cmdCancel.Name = "cmdCancel";
+            this.cmdCancel.Size = new System.Drawing.Size(59, 25);
+            this.cmdCancel.TabIndex = 1;
+            this.cmdCancel.Text = "Cancel";
+            this.cmdCancel.UseVisualStyleBackColor = true;
+            this.cmdCancel.Click += new System.EventHandler(this.cmdCancel_Click);
+            // 
+            // label1
+            // 
+            this.label1.Location = new System.Drawing.Point(12, 9);
+            this.label1.Name = "label1";
+            this.label1.Size = new System.Drawing.Size(123, 31);
+            this.label1.TabIndex = 2;
+            this.label1.Text = "Construct your driver\'s setup dialog here.";
+            // 
+            // picASCOM
+            // 
+            this.picASCOM.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
+            this.picASCOM.Cursor = System.Windows.Forms.Cursors.Hand;
+            this.picASCOM.Image = global::ASCOM.Meade.net.Properties.Resources.ASCOM;
+            this.picASCOM.Location = new System.Drawing.Point(292, 9);
+            this.picASCOM.Name = "picASCOM";
+            this.picASCOM.Size = new System.Drawing.Size(48, 56);
+            this.picASCOM.SizeMode = System.Windows.Forms.PictureBoxSizeMode.AutoSize;
+            this.picASCOM.TabIndex = 3;
+            this.picASCOM.TabStop = false;
+            this.picASCOM.Click += new System.EventHandler(this.BrowseToAscom);
+            this.picASCOM.DoubleClick += new System.EventHandler(this.BrowseToAscom);
+            // 
+            // label2
+            // 
+            this.label2.AutoSize = true;
+            this.label2.Location = new System.Drawing.Point(13, 90);
+            this.label2.Name = "label2";
+            this.label2.Size = new System.Drawing.Size(58, 13);
+            this.label2.TabIndex = 5;
+            this.label2.Text = "Comm Port";
+            // 
+            // chkTrace
+            // 
+            this.chkTrace.AutoSize = true;
+            this.chkTrace.Location = new System.Drawing.Point(77, 118);
+            this.chkTrace.Name = "chkTrace";
+            this.chkTrace.Size = new System.Drawing.Size(69, 17);
+            this.chkTrace.TabIndex = 6;
+            this.chkTrace.Text = "Trace on";
+            this.chkTrace.UseVisualStyleBackColor = true;
+            // 
+            // comboBoxComPort
+            // 
+            this.comboBoxComPort.FormattingEnabled = true;
+            this.comboBoxComPort.Location = new System.Drawing.Point(77, 87);
+            this.comboBoxComPort.Name = "comboBoxComPort";
+            this.comboBoxComPort.Size = new System.Drawing.Size(90, 21);
+            this.comboBoxComPort.TabIndex = 7;
+            // 
+            // SetupDialogForm
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.ClientSize = new System.Drawing.Size(350, 175);
+            this.Controls.Add(this.comboBoxComPort);
+            this.Controls.Add(this.chkTrace);
+            this.Controls.Add(this.label2);
+            this.Controls.Add(this.picASCOM);
+            this.Controls.Add(this.label1);
+            this.Controls.Add(this.cmdCancel);
+            this.Controls.Add(this.cmdOK);
+            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog;
+            this.MaximizeBox = false;
+            this.MinimizeBox = false;
+            this.Name = "SetupDialogForm";
+            this.SizeGripStyle = System.Windows.Forms.SizeGripStyle.Hide;
+            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
+            this.Text = "Meade.net Setup";
+            ((System.ComponentModel.ISupportInitialize)(this.picASCOM)).EndInit();
+            this.ResumeLayout(false);
+            this.PerformLayout();
+
+        }
+
+        #endregion
+
+        private System.Windows.Forms.Button cmdOK;
+        private System.Windows.Forms.Button cmdCancel;
+        private System.Windows.Forms.Label label1;
+        private System.Windows.Forms.PictureBox picASCOM;
+        private System.Windows.Forms.Label label2;
+        private System.Windows.Forms.CheckBox chkTrace;
+        private System.Windows.Forms.ComboBox comboBoxComPort;
+    }
+}

Meade.net/SetupDialogForm.resx

@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>

Meade.net/SharedResources.cs

@@ -0,0 +1,382 @@
+//
+// ================
+// Shared Resources
+// ================
+//
+// This class is a container for all shared resources that may be needed
+// by the drivers served by the Local Server. 
+//
+// NOTES:
+//
+//	* ALL DECLARATIONS MUST BE STATIC HERE!! INSTANCES OF THIS CLASS MUST NEVER BE CREATED!
+//
+// Written by:	Bob Denny	29-May-2007
+// Modified by Chris Rowland and Peter Simpson to hamdle multiple hardware devices March 2011
+//
+using System;
+using System.Collections.Generic;
+using System.Text;
+using ASCOM;
+using ASCOM.Utilities;
+
+namespace ASCOM.Meade.net
+{
+    public class ProfileProperties
+    {
+        // properies that are part of the profile
+        public string ComPort { get; set; }
+        public bool TraceLogger { get; set; }
+    }
+
+    /// <summary>
+    /// The resources shared by all drivers and devices, in this example it's a serial port with a shared SendMessage method
+    /// an idea for locking the message and handling connecting is given.
+    /// In reality extensive changes will probably be needed.
+    /// Multiple drivers means that several applications connect to the same hardware device, aka a hub.
+    /// Multiple devices means that there are more than one instance of the hardware, such as two focusers.
+    /// In this case there needs to be multiple instances of the hardware connector, each with it's own connection count.
+    /// </summary>
+    public static class SharedResources
+    {
+        // object used for locking to prevent multiple drivers accessing common code at the same time
+        private static readonly object lockObject = new object();
+
+        // Shared serial port. This will allow multiple drivers to use one single serial port.
+        private static ASCOM.Utilities.Serial s_sharedSerial = new ASCOM.Utilities.Serial(); // Shared serial port
+        private static int s_z = 0; // counter for the number of connections to the serial port
+
+        //
+        // Public access to shared resources
+        //
+
+        #region single serial port connector
+
+        //
+        // this region shows a way that a single serial port could be connected to by multiple 
+        // drivers.
+        //
+        // Connected is used to handle the connections to the port.
+        //
+        // SendMessage is a way that messages could be sent to the hardware without
+        // conflicts between different drivers.
+        //
+        // All this is for a single connection, multiple connections would need multiple ports
+        // and a way to handle connecting and disconnection from them - see the
+        // multi driver handling section for ideas.
+        //
+
+        /// <summary>
+        /// Shared serial port
+        /// </summary>
+        public static ASCOM.Utilities.Serial SharedSerial
+        {
+            get { return s_sharedSerial; }
+        }
+
+        /// <summary>
+        /// number of connections to the shared serial port
+        /// </summary>
+        public static int connections
+        {
+            get { return s_z; }
+            set { s_z = value; }
+        }
+
+        public static void SendBlind(string message)
+        {
+            lock (lockObject)
+            {
+                SharedSerial.ClearBuffers();
+                SharedSerial.Transmit(message);
+            }
+        }
+
+        public static bool SendBool(string message)
+        {
+            SharedSerial.ClearBuffers();
+            return SendChar(message) == "1";
+        }
+
+        /// <summary>
+        /// Example of a shared SendMessage method, the lock
+        /// prevents different drivers tripping over one another.
+        /// It needs error handling and assumes that the message will be sent unchanged
+        /// and that the reply will always be terminated by a "#" character.
+        /// </summary>
+        /// <param name="message"></param>
+        /// <returns></returns>
+        public static string SendString(string message)
+        {
+            lock (lockObject)
+            {
+                SharedSerial.ClearBuffers();
+                SharedSerial.Transmit(message);
+                return SharedSerial.ReceiveTerminated("#").TrimEnd('#');
+            }
+        }
+
+        public static string SendChar(string message)
+        {
+            lock (lockObject)
+            {
+                SharedSerial.ClearBuffers();
+                SharedSerial.Transmit(message);
+                return SharedSerial.ReceiveCounted(1);
+            }
+        }
+
+        public static string ReadTerminated()
+        {
+            lock (lockObject)
+            {
+                return SharedSerial.ReceiveTerminated("#");
+            }
+        }
+
+        /// <summary>
+        /// Example of handling connecting to and disconnection from the
+        /// shared serial port.
+        /// Needs error handling
+        /// the port name etc. needs to be set up first, this could be done by the driver
+        /// checking Connected and if it's false setting up the port before setting connected to true.
+        /// It could also be put here.
+        /// </summary>
+        public static bool Connected
+        {
+            set
+            {
+                lock (lockObject)
+                {
+                    if (value)
+                    {
+                        if (s_z == 0)
+                            SharedSerial.Connected = true;
+                        s_z++;
+                    }
+                    else
+                    {
+                        s_z--;
+                        if (s_z <= 0)
+                        {
+                            SharedSerial.Connected = false;
+                        }
+                    }
+                }
+            }
+            get { return SharedSerial.Connected; }
+        }
+
+        #endregion
+
+        #region Profile
+
+        internal static string driverID = "ASCOM.MeadeGeneric.Telescope";
+
+        // Constants used for Profile persistence
+        internal static string comPortProfileName = "COM Port";
+        internal static string traceStateProfileName = "Trace Level";
+
+        public static void WriteProfile(ProfileProperties profileProperties)
+        {
+            using (Profile driverProfile = new Profile())
+            {
+                driverProfile.DeviceType = "Telescope";
+                driverProfile.WriteValue(driverID, traceStateProfileName, profileProperties.TraceLogger.ToString());
+                driverProfile.WriteValue(driverID, comPortProfileName, profileProperties.ComPort);
+            }
+        }
+
+        private static readonly string comPortDefault = "COM1";
+        internal static string traceStateDefault = "false";
+
+        public static ProfileProperties ReadProfile()
+        {
+            ProfileProperties profileProperties = new ProfileProperties();
+            using (Profile driverProfile = new Profile())
+            {
+                driverProfile.DeviceType = "Telescope";
+                profileProperties.ComPort =
+                    driverProfile.GetValue(driverID, comPortProfileName, string.Empty, comPortDefault);
+                profileProperties.TraceLogger = Convert.ToBoolean(driverProfile.GetValue(driverID,
+                    traceStateProfileName, string.Empty, traceStateDefault));
+            }
+
+            return profileProperties;
+        }
+
+        #endregion
+
+        #region SetupDialog
+
+        public static void SetupDialog()
+        {
+            // consider only showing the setup dialog if not connected
+            // or call a different dialog if connected
+            if (SharedSerial.Connected)
+            {
+                System.Windows.Forms.MessageBox.Show("Already connected, please disconnect before altering settings");
+                return;
+            }
+
+            var profileProperties = ReadProfile();
+
+            using (SetupDialogForm F = new SetupDialogForm())
+            {
+                F.SetProfile(profileProperties);
+
+                var result = F.ShowDialog();
+                if (result == System.Windows.Forms.DialogResult.OK)
+                {
+                    profileProperties = F.GetProfile();
+
+                    WriteProfile(profileProperties); // Persist device configuration values to the ASCOM Profile store
+                }
+            }
+        }
+
+        #endregion
+
+        #region Multi Driver handling
+
+        // this section illustrates how multiple drivers could be handled,
+        // it's for drivers where multiple connections to the hardware can be made and ensures that the
+        // hardware is only disconnected from when all the connected devices have disconnected.
+
+        // It is NOT a complete solution!  This is to give ideas of what can - or should be done.
+        //
+        // An alternative would be to move the hardware control here, handle connecting and disconnecting,
+        // and provide the device with a suitable connection to the hardware.
+        //
+        /// <summary>
+        /// dictionary carrying device connections.
+        /// The Key is the connection number that identifies the device, it could be the COM port name,
+        /// USB ID or IP Address, the Value is the DeviceHardware class
+        /// </summary>
+        private static Dictionary<string, DeviceHardware> connectedDevices = new Dictionary<string, DeviceHardware>();
+
+        /// <summary>
+        /// This is called in the driver Connect(true) property,
+        /// it add the device id to the list of devices if it's not there and increments the device count.
+        /// </summary>
+        /// <param name="deviceId"></param>
+        public static void Connect(string deviceId)
+        {
+            lock (lockObject)
+            {
+                if (!connectedDevices.ContainsKey(deviceId))
+                    connectedDevices.Add(deviceId, new DeviceHardware());
+                connectedDevices[deviceId].count++; // increment the value
+
+                if (deviceId == "Serial")
+                {
+                    if (connectedDevices[deviceId].count == 1)
+                    {
+                        var profileProperties = ReadProfile();
+                        SharedResources.SharedSerial.PortName = profileProperties.ComPort;
+                        SharedResources.SharedSerial.DTREnable = false;
+                        SharedResources.SharedSerial.RTSEnable = false;
+                        SharedResources.SharedSerial.DataBits = 8;
+                        SharedResources.SharedSerial.StopBits = SerialStopBits.One;
+                        SharedResources.SharedSerial.Parity = SerialParity.None;
+                        SharedResources.SharedSerial.Speed = SerialSpeed.ps9600;
+                        SharedResources.SharedSerial.Handshake = SerialHandshake.None;
+                        SharedResources.SharedSerial.Connected = true;
+
+                        string firmware = SendString(":GVN#");
+                    }
+                }
+            }
+        }
+
+        public static void Disconnect(string deviceId)
+        {
+            lock (lockObject)
+            {
+                if (connectedDevices.ContainsKey(deviceId))
+                {
+                    connectedDevices[deviceId].count--;
+                    if (connectedDevices[deviceId].count <= 0)
+                    {
+                        connectedDevices.Remove(deviceId);
+                        if (deviceId == "Serial")
+                        {
+                            SharedResources.SharedSerial.Connected = false;
+                        }
+                    }
+                }
+            }
+        }
+
+        public static bool IsConnected(string deviceId)
+        {
+            if (connectedDevices.ContainsKey(deviceId))
+                return (connectedDevices[deviceId].count > 0);
+            else
+                return false;
+        }
+
+        #endregion
+
+        public static void Lock(Action action)
+        {
+            lock (lockObject)
+            {
+                action();
+            }
+        }
+
+        public static T Lock<T>(Func<T> func)
+        {
+            lock (lockObject)
+            {
+                return func();
+            }
+        }
+
+        /// <summary>
+        /// Skeleton of a hardware class, all this does is hold a count of the connections,
+        /// in reality extra code will be needed to handle the hardware in some way
+        /// </summary>
+        public class DeviceHardware
+        {
+            private int _count;
+
+            internal int count
+            {
+                set => _count = value;
+                get => _count;
+            }
+
+            internal DeviceHardware()
+            {
+                count = 0;
+            }
+        }
+
+        //#region ServedClassName attribute
+        ///// <summary>
+        ///// This is only needed if the driver is targeted at  platform 5.5, it is included with Platform 6
+        ///// </summary>
+        //[global::System.AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
+        //public sealed class ServedClassNameAttribute : Attribute
+        //{
+        //    // See the attribute guidelines at 
+        //    //  http://go.microsoft.com/fwlink/?LinkId=85236
+
+        //    /// <summary>
+        //    /// Gets or sets the 'friendly name' of the served class, as registered with the ASCOM Chooser.
+        //    /// </summary>
+        //    /// <value>The 'friendly name' of the served class.</value>
+        //    public string DisplayName { get; private set; }
+        //    /// <summary>
+        //    /// Initializes a new instance of the <see cref="ServedClassNameAttribute"/> class.
+        //    /// </summary>
+        //    /// <param name="servedClassName">The 'friendly name' of the served class.</param>
+        //    public ServedClassNameAttribute(string servedClassName)
+        //    {
+        //        DisplayName = servedClassName;
+        //    }
+        //}
+        //#endregion
+    }
+}

Meade.net/app.config

@@ -0,0 +1,3 @@
+<?xml version="1.0"?>
+<configuration>
+<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.1"/></startup></configuration>

Meade.net/frmMain.Designer.cs

@@ -0,0 +1,63 @@
+using System;
+
+namespace ASCOM.Meade.net
+{
+    partial class frmMain
+    {
+        /// <summary>
+        /// Required designer variable.
+        /// </summary>
+        private System.ComponentModel.IContainer components = null;
+
+        /// <summary>
+        /// Clean up any resources being used.
+        /// </summary>
+        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing && (components != null))
+            {
+                components.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        #region Windows Form Designer generated code
+
+        /// <summary>
+        /// Required method for Designer support - do not modify
+        /// the contents of this method with the code editor.
+        /// </summary>
+        private void InitializeComponent()
+        {
+            this.label1 = new System.Windows.Forms.Label();
+            this.SuspendLayout();
+            // 
+            // label1
+            // 
+            this.label1.Location = new System.Drawing.Point(12, 10);
+            this.label1.Name = "label1";
+            this.label1.Size = new System.Drawing.Size(199, 33);
+            this.label1.TabIndex = 0;
+            this.label1.Text = "This is an ASCOM driver, not a program for you to use.";
+            // 
+            // frmMain
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+            this.ClientSize = new System.Drawing.Size(233, 52);
+            this.Controls.Add(this.label1);
+            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedToolWindow;
+            this.Name = "frmMain";
+            this.Text = "Meade.net Driver Server";
+            this.ResumeLayout(false);
+
+        }
+
+        #endregion
+
+        private System.Windows.Forms.Label label1;
+
+    }
+}
+

Meade.net/frmMain.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Drawing;
+using System.Text;
+using System.Windows.Forms;
+
+namespace ASCOM.Meade.net
+{
+    public partial class frmMain : Form
+    {
+        delegate void SetTextCallback(string text);
+
+        public frmMain()
+        {
+            InitializeComponent();
+        }
+
+    }
+}

Meade.net/frmMain.resx

@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>