Merged in develop (pull request #6)

Release 0.5.0.0

* Removed unwanted files

* Adding git ignore file

* Started working on getting the basic communications with the scope working.
    Working on routines to get and set the date and time in the handbox.

* Switched the serial port over to using the .net frameworks serial port.
    Extracted the serial port into it's own class and created a simpler command processing mechanism.

* Implemented AbortSlew and did some code tidy up.

* Forced all code to 64-bit only, will make this 32/64 bit before release.
    Fixed issue in the SerialProcessor when setting the time, makes sure that there's no chance of thread stealing when pulling out the junk messages
    Added ConformanceResult.txt to show the progress of the driver development

* Added code for the site latitude
    and started work on the longitude.

* Added unit tests for reading and writing the utcDate.
    Fixed a couple of defects in the code that was setting the utcDate.

* Corrected Longitude value range

* Added support for UTC offset.

* Pulse guiding support added

* Added SiteLatitude unit tests

* Added unit tests for SiteLongitude

* Added unit tests for the new Pulse guide implementation.

* Added support for AlignmentMode

* Added support for AtPark and Park

* Added support for parking the scope
    Added support for reading the scope Azimuth

* Added support for reading Declination

* Added 5 second timeout for the serial port.
    Fixed problem with the GW command not working on the Autostar 497.

* Fixed broken unit test

* Added support for altitude

* Tidying up resharper warinings

* Implemented RightAscension
    TargetRightAscension
    TargetDec
    SlewToCoord
    and SlewToCoordAsync

* Sorted out the target RA and Dec exceptions to be compliant with ascom.

* Implemented SlewToAltAz and SlewToAltAzAsync

* Implemented SyncToTarget functionality

* Implemented slew to target

* Added support for MoveAxis

* Added support for tracking rate

* Added IFocuserV3 to the driver and made sure that it's registered for ASCOM as a focuser as well.

* Fixed issue with Target RA and Dec loosing precision

* Telescope driver now passes the Ascom conformance.

* Upgraded driver version to 0.1

* Added explicit locks around all sequences of commands.

* Basic implementation of the IFocusserV3

* Focuser passes validation, this makes the code V0.2

* Added support for CommandBlind and CommandString
    Modified the tracking rates to be setable.  However, the get is now simulated.

* 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

* Added comments for all meade commands.
    Fixed the Site Lat and Long setters

* Re instated the Altitude value and ran conformance for both the telescope and focuser.

* Redesigned the Altitude and Azimuth readings to use the Right Ascension and Declination co-ordinates and perform the transformation using the date and site details from the scope.   This will correct the problem of the Altitude reading from the handset being incorrect.

* Added code to make sure that the scope returns values in high precision mode.

* Fixed problem where SlewToAltAz didn't work correctly.  Now uses the RA/Dec slew for everything, and converts the values as needed.

* Upgraded the error handling to ensure that all serial commands are executed after checking that there is a connection open.

* Added some code to the focuser connect to make it consistent with the telescope connect in that it will now test that the connection is to an Autostar.

    Upgraded the move code to make it less unreliable.

* Added localisation support

* First draft of the installer

* Sorted out the registry settings needed to get the driver working properly on install.

* Modified the solution to be able to create as 32-bit install that works on 64bit windows 10.

* Added a call to activate when the setup dialog is shown.

Meade.net.focuser/Focuser.cs

@@ -0,0 +1,638 @@
+//tabs=4
+// --------------------------------------------------------------------------------
+// TODO fill in this information for your driver, then remove this line!
+//
+// ASCOM Focuser driver for Meade.net
+//
+// Description:	Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam 
+//				nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam 
+//				erat, sed diam voluptua. At vero eos et accusam et justo duo 
+//				dolores et ea rebum. Stet clita kasd gubergren, no sea takimata 
+//				sanctus est Lorem ipsum dolor sit amet.
+//
+// Implements:	ASCOM Focuser interface version: <To be completed by driver developer>
+// Author:		(XXX) Your N. Here <your@email.here>
+//
+// Edit Log:
+//
+// Date			Who	Vers	Description
+// -----------	---	-----	-------------------------------------------------------
+// dd-mmm-yyyy	XXX	6.0.0	Initial edit, created from ASCOM driver template
+// --------------------------------------------------------------------------------
+//
+
+
+// This is used to define code in the template that is specific to one class implementation
+// unused code canbe deleted and this definition removed.
+#define Focuser
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Text;
+using System.Runtime.InteropServices;
+
+using ASCOM;
+using ASCOM.Astrometry;
+using ASCOM.Astrometry.AstroUtils;
+using ASCOM.Utilities;
+using ASCOM.DeviceInterface;
+using System.Globalization;
+using System.Collections;
+using System.Reflection;
+using ASCOM.Utilities.Interfaces;
+
+namespace ASCOM.Meade.net
+{
+    //
+    // Your driver's DeviceID is ASCOM.Meade.net.Focuser
+    //
+    // The Guid attribute sets the CLSID for ASCOM.Meade.net.Focuser
+    // The ClassInterface/None addribute prevents an empty interface called
+    // _Meade.net from being created and used as the [default] interface
+    //
+    // TODO Replace the not implemented exceptions with code to implement the function or
+    // throw the appropriate ASCOM exception.
+    //
+
+    /// <summary>
+    /// ASCOM Focuser Driver for Meade.net.
+    /// </summary>
+    [Guid("a32ac647-bf0f-42f9-8ab0-d166fa5884ad")]
+    [ProgId("ASCOM.MeadeGeneric.focuser")]
+    [ServedClassName("Meade.net Focuser")]
+    [ClassInterface(ClassInterfaceType.None)]
+    public class Focuser : ReferenceCountedObjectBase, IFocuserV3
+    {
+        /// <summary>
+        /// ASCOM DeviceID (COM ProgID) for this driver.
+        /// The DeviceID is used by ASCOM applications to load the driver at runtime.
+        /// </summary>
+        //internal static string driverID = "ASCOM.Meade.net.Focuser";
+        internal static string driverID = Marshal.GenerateProgIdForType(MethodBase.GetCurrentMethod().DeclaringType);
+        // TODO Change the descriptive string for your driver then remove this line
+        /// <summary>
+        /// Driver description that displays in the ASCOM Chooser.
+        /// </summary>
+        private static string driverDescription = "Meade Generic";
+
+        internal static string comPortProfileName = "COM Port"; // Constants used for Profile persistence
+        internal static string comPortDefault = "COM1";
+        internal static string traceStateProfileName = "Trace Level";
+        internal static string traceStateDefault = "false";
+
+        internal static string comPort; // Variables to hold the currrent device configuration
+
+        /// <summary>
+        /// Private variable to hold the connected state
+        /// </summary>
+        private bool connectedState;
+
+        /// <summary>
+        /// Private variable to hold an ASCOM Utilities object
+        /// </summary>
+        private Util utilities;
+
+        /// <summary>
+        /// Private variable to hold an ASCOM AstroUtilities object to provide the Range method
+        /// </summary>
+        private AstroUtils astroUtilities;
+
+        /// <summary>
+        /// Variable to hold the trace logger object (creates a diagnostic log file with information that you specify)
+        /// </summary>
+        internal static TraceLogger tl;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Meade.net"/> class.
+        /// Must be public for COM registration.
+        /// </summary>
+        public Focuser()
+        {
+            tl = new TraceLogger("", "Meade.net.focusser");
+            ReadProfile(); // Read device configuration from the ASCOM Profile store
+
+            tl.LogMessage("Focuser", "Starting initialisation");
+
+            connectedState = false; // Initialise connected to false
+            utilities = new Util(); //Initialise util object
+            astroUtilities = new AstroUtils(); // Initialise astro utilities object
+
+            tl.LogMessage("Focuser", "Completed initialisation");
+        }
+
+
+        //
+        // PUBLIC COM INTERFACE IFocuserV3 IMPLEMENTATION
+        //
+
+        #region Common properties and methods.
+
+        /// <summary>
+        /// Displays the Setup Dialog form.
+        /// If the user clicks the OK button to dismiss the form, then
+        /// the new settings are saved, otherwise the old values are reloaded.
+        /// THIS IS THE ONLY PLACE WHERE SHOWING USER INTERFACE IS ALLOWED!
+        /// </summary>
+        public void SetupDialog()
+        {
+            tl.LogMessage("SetupDialog", "Opening setup dialog");
+            SharedResources.SetupDialog();
+            ReadProfile();
+            tl.LogMessage("SetupDialog", "complete");
+        }
+
+        public ArrayList SupportedActions
+        {
+            get
+            {
+                tl.LogMessage("SupportedActions Get", "Returning empty arraylist");
+                return new ArrayList();
+            }
+        }
+
+        public string Action(string actionName, string actionParameters)
+        {
+            LogMessage("", "Action {0}, parameters {1} not implemented", actionName, actionParameters);
+            throw new ASCOM.ActionNotImplementedException("Action " + actionName + " is not implemented by this driver");
+        }
+
+        public void CommandBlind(string command, bool raw)
+        {
+            CheckConnected("CommandBlind");
+            // Call CommandString and return as soon as it finishes
+            //this.CommandString(command, raw);
+            SharedResources.SendBlind(command);
+            // or
+            //throw new ASCOM.MethodNotImplementedException("CommandBlind");
+            // DO NOT have both these sections!  One or the other
+        }
+
+        public bool CommandBool(string command, bool raw)
+        {
+            CheckConnected("CommandBool");
+            //string ret = CommandString(command, raw);
+            // TODO decode the return string and return true or false
+            // or
+            throw new ASCOM.MethodNotImplementedException("CommandBool");
+            // DO NOT have both these sections!  One or the other
+        }
+
+        public string CommandString(string command, bool raw)
+        {
+            CheckConnected("CommandString");
+            // it's a good idea to put all the low level communication with the device here,
+            // then all communication calls this function
+            // you need something to ensure that only one command is in progress at a time
+            return SharedResources.SendString(command);
+
+            throw new ASCOM.MethodNotImplementedException("CommandString");
+        }
+
+        public void Dispose()
+        {
+            // Clean up the tracelogger and util objects
+            tl.Enabled = false;
+            tl.Dispose();
+            tl = null;
+            utilities.Dispose();
+            utilities = null;
+            astroUtilities.Dispose();
+            astroUtilities = null;
+        }
+
+        public bool Connected
+        {
+            get
+            {
+                LogMessage("Connected", "Get {0}", IsConnected);
+                return IsConnected;
+            }
+            set
+            {
+                tl.LogMessage("Connected", "Set {0}", value);
+                if (value == IsConnected)
+                    return;
+
+                if (value)
+                {
+                    try
+                    {
+                        SharedResources.Connect("Serial");
+                        try
+                        {
+                            SelectSite(1);
+                            SetLongFormat(true);
+
+                            connectedState = true;
+                        }
+                        catch (Exception)
+                        {
+                            SharedResources.Disconnect("Serial");
+                            throw;
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        LogMessage("Connected Set", "Error connecting to port {0} - {1}", comPort, ex.Message);
+                    }
+                }
+                else
+                {
+                    LogMessage("Connected Set", "Disconnecting from port {0}", comPort);
+                    SharedResources.Disconnect("Serial");
+                    connectedState = false;
+                }
+            }
+        }
+
+        private void SetLongFormat(bool setLongFormat)
+        {
+            SharedResources.Lock(() =>
+            {
+                var result = SharedResources.SendString(":GZ#");
+                //:GZ# Get telescope azimuth
+                //Returns: DDD*MM#T or DDD*MM’SS#
+                //The current telescope Azimuth depending on the selected precision.
+
+                bool isLongFormat = result.Length > 6;
+
+                if (isLongFormat != setLongFormat)
+                {
+                    utilities.WaitForMilliseconds(500);
+                    SharedResources.SendBlind(":U#");
+                    //:U# Toggle between low/hi precision positions
+                    //Low - RA displays and messages HH:MM.T sDD*MM
+                    //High - Dec / Az / El displays and messages HH:MM: SS sDD*MM:SS
+                    //    Returns Nothing
+                }
+            });
+        }
+
+        private void SelectSite(int site)
+        {
+            SharedResources.SendBlind($":W{site}#");
+            //:W<n>#
+            //Set current site to<n>, an ASCII digit in the range 1..4
+            //Returns: Nothing
+        }
+
+        public string Description
+        {
+            // TODO customise this device description
+            get
+            {
+                tl.LogMessage("Description Get", driverDescription);
+                return driverDescription;
+            }
+        }
+
+        public string DriverInfo
+        {
+            get
+            {
+                Version version = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
+                // TODO customise this driver description
+                string driverInfo = "Information about the driver itself. Version: " + String.Format(CultureInfo.InvariantCulture, "{0}.{1}", version.Major, version.Minor);
+                tl.LogMessage("DriverInfo Get", driverInfo);
+                return driverInfo;
+            }
+        }
+
+        public string DriverVersion
+        {
+            get
+            {
+                Version version = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
+                string driverVersion = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", version.Major, version.Minor);
+                tl.LogMessage("DriverVersion Get", driverVersion);
+                return driverVersion;
+            }
+        }
+
+        public short InterfaceVersion
+        {
+            // set by the driver wizard
+            get
+            {
+                LogMessage("InterfaceVersion Get", "3");
+                return Convert.ToInt16("3");
+            }
+        }
+
+        public string Name
+        {
+            get
+            {
+                //string name = "Short driver name - please customise";
+                string name = driverDescription;
+                tl.LogMessage("Name Get", name);
+                return name;
+            }
+        }
+
+        #endregion
+
+        #region IFocuser Implementation
+
+        public bool Absolute
+        {
+            get
+            {
+                tl.LogMessage("Absolute Get", false.ToString());
+                return false; // This is a relative focuser
+            }
+        }
+
+        public void Halt()
+        {
+            tl.LogMessage("Halt", "Halting");
+
+            CheckConnected("Halt");
+
+            SharedResources.SendBlind(":FQ#");
+            //:FQ# Halt Focuser Motion
+            //Returns: Nothing
+        }
+
+        public bool IsMoving
+        {
+            get
+            {
+                tl.LogMessage("IsMoving Get", false.ToString());
+                return false; // This focuser always moves instantaneously so no need for IsMoving ever to be True
+            }
+        }
+
+        public bool Link
+        {
+            get
+            {
+                tl.LogMessage("Link Get", this.Connected.ToString());
+                return this.Connected; // Direct function to the connected method, the Link method is just here for backwards compatibility
+            }
+            set
+            {
+                tl.LogMessage("Link Set", value.ToString());
+                this.Connected = value; // Direct function to the connected method, the Link method is just here for backwards compatibility
+            }
+        }
+
+        private readonly int _maxIncrement = 7000;
+        public int MaxIncrement
+        {
+            get
+            {
+                tl.LogMessage("MaxIncrement Get", _maxIncrement.ToString());
+                return _maxIncrement; // Maximum change in one move
+            }
+        }
+
+        private readonly int _maxStep = 7000;
+        public int MaxStep
+        {
+            get
+            {
+                tl.LogMessage("MaxStep Get", _maxStep.ToString());
+                return _maxStep;
+            }
+        }
+
+        public void Move(int Position)
+        {
+            tl.LogMessage("Move", Position.ToString());
+            CheckConnected("Move");
+
+            //todo implement backlash compensation
+            //todo implement direction reverse
+            //todo implement dynamic braking
+
+            if (Position < -MaxIncrement || Position > MaxIncrement)
+            {
+                throw new ASCOM.InvalidValueException($"position out of range {-MaxIncrement} < {Position} < {MaxIncrement}");
+            }
+
+            if (Position == 0)
+                return;
+
+            if (Position > 0)
+            {
+                //desired move direction is out
+                MoveFocuser(true, Math.Abs(Position));
+            }
+            else
+            {
+                //desired move direction is in
+                MoveFocuser(false, Math.Abs(Position));
+            }
+        }
+
+        private void MoveFocuser(bool directionOut, int steps)
+        {
+            SharedResources.Lock(() =>
+            {
+                SharedResources.SendBlind(":FF#");
+                //:FF# Set Focus speed to fastest setting
+                //Returns: Nothing
+
+                //:FS# Set Focus speed to slowest setting
+                //Returns: Nothing
+
+                //:F<n># Autostar, Autostar II – set focuser speed to <n> where <n> is an ASCII digit 1..4
+                //Returns: Nothing
+                //All others – Not Supported
+                utilities.WaitForMilliseconds(100);
+
+                SharedResources.SendBlind(directionOut ? ":F+#" : ":F-#");
+                //:F+# Start Focuser moving inward (toward objective)
+                //Returns: None
+
+                //:F-# Start Focuser moving outward (away from objective)
+                //Returns: None
+
+                utilities.WaitForMilliseconds(steps);
+
+                Halt();
+
+                utilities.WaitForMilliseconds(1000);
+            });
+        }
+
+        public int Position
+        {
+            get
+            {
+                throw new ASCOM.PropertyNotImplementedException("Position", false);
+                //return focuserPosition; // Return the focuser position
+            }
+        }
+
+        public double StepSize
+        {
+            get
+            {
+                tl.LogMessage("StepSize Get", "Not implemented");
+                throw new ASCOM.PropertyNotImplementedException("StepSize", false);
+            }
+        }
+
+        public bool TempComp
+        {
+            get
+            {
+                tl.LogMessage("TempComp Get", false.ToString());
+                return false;
+            }
+            set
+            {
+                tl.LogMessage("TempComp Set", "Not implemented");
+                throw new ASCOM.PropertyNotImplementedException("TempComp", false);
+            }
+        }
+
+        public bool TempCompAvailable
+        {
+            get
+            {
+                tl.LogMessage("TempCompAvailable Get", false.ToString());
+                return false; // Temperature compensation is not available in this driver
+            }
+        }
+
+        public double Temperature
+        {
+            get
+            {
+                tl.LogMessage("Temperature Get", "Not implemented");
+                throw new ASCOM.PropertyNotImplementedException("Temperature", false);
+            }
+        }
+
+        #endregion
+
+        #region Private properties and methods
+        // here are some useful properties and methods that can be used as required
+        // to help with driver development
+
+        #region ASCOM Registration
+
+        // Register or unregister driver for ASCOM. This is harmless if already
+        // registered or unregistered. 
+        //
+        /// <summary>
+        /// Register or unregister the driver with the ASCOM Platform.
+        /// This is harmless if the driver is already registered/unregistered.
+        /// </summary>
+        /// <param name="bRegister">If <c>true</c>, registers the driver, otherwise unregisters it.</param>
+        private static void RegUnregASCOM(bool bRegister)
+        {
+            using (var P = new ASCOM.Utilities.Profile())
+            {
+                P.DeviceType = "Focuser";
+                if (bRegister)
+                {
+                    P.Register(driverID, driverDescription);
+                }
+                else
+                {
+                    P.Unregister(driverID);
+                }
+            }
+        }
+
+        /// <summary>
+        /// This function registers the driver with the ASCOM Chooser and
+        /// is called automatically whenever this class is registered for COM Interop.
+        /// </summary>
+        /// <param name="t">Type of the class being registered, not used.</param>
+        /// <remarks>
+        /// This method typically runs in two distinct situations:
+        /// <list type="numbered">
+        /// <item>
+        /// In Visual Studio, when the project is successfully built.
+        /// For this to work correctly, the option <c>Register for COM Interop</c>
+        /// must be enabled in the project settings.
+        /// </item>
+        /// <item>During setup, when the installer registers the assembly for COM Interop.</item>
+        /// </list>
+        /// This technique should mean that it is never necessary to manually register a driver with ASCOM.
+        /// </remarks>
+        [ComRegisterFunction]
+        public static void RegisterASCOM(Type t)
+        {
+            RegUnregASCOM(true);
+        }
+
+        /// <summary>
+        /// This function unregisters the driver from the ASCOM Chooser and
+        /// is called automatically whenever this class is unregistered from COM Interop.
+        /// </summary>
+        /// <param name="t">Type of the class being registered, not used.</param>
+        /// <remarks>
+        /// This method typically runs in two distinct situations:
+        /// <list type="numbered">
+        /// <item>
+        /// In Visual Studio, when the project is cleaned or prior to rebuilding.
+        /// For this to work correctly, the option <c>Register for COM Interop</c>
+        /// must be enabled in the project settings.
+        /// </item>
+        /// <item>During uninstall, when the installer unregisters the assembly from COM Interop.</item>
+        /// </list>
+        /// This technique should mean that it is never necessary to manually unregister a driver from ASCOM.
+        /// </remarks>
+        [ComUnregisterFunction]
+        public static void UnregisterASCOM(Type t)
+        {
+            RegUnregASCOM(false);
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Returns true if there is a valid connection to the driver hardware
+        /// </summary>
+        private bool IsConnected
+        {
+            get
+            {
+                // TODO check that the driver hardware connection exists and is connected to the hardware
+                return connectedState;
+            }
+        }
+
+        /// <summary>
+        /// Use this function to throw an exception if we aren't connected to the hardware
+        /// </summary>
+        /// <param name="message"></param>
+        private void CheckConnected(string message)
+        {
+            if (!IsConnected)
+            {
+                throw new ASCOM.NotConnectedException(message);
+            }
+        }
+
+        /// <summary>
+        /// Read the device configuration from the ASCOM Profile store
+        /// </summary>
+        internal void ReadProfile()
+        {
+            var profileProperties = SharedResources.ReadProfile();
+            tl.Enabled = profileProperties.TraceLogger;
+            comPort = profileProperties.ComPort;
+        }
+
+        /// <summary>
+        /// Log helper function that takes formatted strings and arguments
+        /// </summary>
+        /// <param name="identifier"></param>
+        /// <param name="message"></param>
+        /// <param name="args"></param>
+        internal static void LogMessage(string identifier, string message, params object[] args)
+        {
+            var msg = string.Format(message, args);
+            tl.LogMessage(identifier, msg);
+        }
+        #endregion
+    }
+}

Meade.net.focuser/Meade.net.focuser.csproj

@@ -0,0 +1,170 @@
+<?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>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{A97E3AEC-F11D-49DA-B259-DE99DA813A86}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>ASCOM.Meade.net</RootNamespace>
+    <AssemblyName>ASCOM.Meade.net.Focuser</AssemblyName>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <UpgradeBackupLocation>
+    </UpgradeBackupLocation>
+    <OldToolsVersion>3.5</OldToolsVersion>
+    <TargetFrameworkVersion>v4.7.1</TargetFrameworkVersion>
+    <ApplicationIcon>ASCOM.ico</ApplicationIcon>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>ASCOMDriverTemplate.snk</AssemblyOriginatorKeyFile>
+    <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>
+    <IsWebBootstrapper>false</IsWebBootstrapper>
+    <UseApplicationTrust>false</UseApplicationTrust>
+    <BootstrapperEnabled>true</BootstrapperEnabled>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
+  </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>
+    <RegisterForComInterop>true</RegisterForComInterop>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <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>AnyCPU</PlatformTarget>
+    <RegisterForComInterop>false</RegisterForComInterop>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x86\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <RegisterForComInterop>true</RegisterForComInterop>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
+    <OutputPath>..\bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="ASCOM.Astrometry, Version=6.0.0.0, Culture=neutral, PublicKeyToken=565de7938946fba7, processorArchitecture=MSIL" />
+    <Reference Include="ASCOM.Attributes, Version=6.0.0.0, Culture=neutral, PublicKeyToken=565de7938946fba7, processorArchitecture=MSIL" />
+    <Reference Include="ASCOM.Controls, 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.SettingsProvider, 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="ASCOM.Utilities.Video, Version=6.1.0.0, Culture=neutral, PublicKeyToken=565de7938946fba7, processorArchitecture=MSIL" />
+    <Reference Include="System" />
+    <Reference Include="System.configuration" />
+    <Reference Include="System.Configuration.Install" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Focuser.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Properties\Resources.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>Resources.resx</DependentUpon>
+    </Compile>
+    <Compile Include="Properties\Settings.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTimeSharedInput>True</DesignTimeSharedInput>
+      <DependentUpon>Settings.settings</DependentUpon>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="Properties\Resources.resx">
+      <SubType>Designer</SubType>
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="app.config" />
+    <None Include="ASCOM.png" />
+    <None Include="ASCOMDriverTemplate.snk" />
+    <None Include="Properties\Settings.settings">
+      <Generator>SettingsSingleFileGenerator</Generator>
+      <LastGenOutput>Settings.Designer.cs</LastGenOutput>
+    </None>
+    <Content Include="ASCOM.ico" />
+    <Content Include="ReadMe.htm" />
+    <None Include="Resources\ASCOM.bmp" />
+  </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>
+  <ItemGroup>
+    <ProjectReference Include="..\Meade.net\Meade.net.csproj">
+      <Project>{3689a2cb-94c5-4012-a5cf-7e7d1dd27143}</Project>
+      <Name>Meade.net</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PreBuildEvent>
+    </PreBuildEvent>
+  </PropertyGroup>
+  <!-- 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>
+  -->
+</Project>

Meade.net.focuser/Properties/AssemblyInfo.cs

@@ -0,0 +1,39 @@
+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.
+//
+// TODO - Add your authorship information here
+[assembly: AssemblyTitle("ASCOM.Meade.net.Focuser")]
+[assembly: AssemblyDescription("ASCOM Focuser driver for Meade.net")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("cjdawson.com")]
+[assembly: AssemblyProduct("ASCOM Focuser driver for Meade.net")]
+[assembly: AssemblyCopyright("Copyright © 2019 cjdawson.com")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(true)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("4ad7a6d4-6d54-4a9a-bbf3-895353e318f8")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers 
+// by using the '*' as shown below:
+//
+// TODO - Set your driver's version here
+[assembly: AssemblyVersion("0.5.0.0")]
+[assembly: AssemblyFileVersion("0.5.0.0")]

Meade.net.focuser/Properties/Resources.Designer.cs

@@ -0,0 +1,83 @@
+//------------------------------------------------------------------------------
+// <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));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Icon similar to (Icon).
+        /// </summary>
+        internal static System.Drawing.Icon DefaultIcon {
+            get {
+                object obj = ResourceManager.GetObject("DefaultIcon", resourceCulture);
+                return ((System.Drawing.Icon)(obj));
+            }
+        }
+    }
+}

Meade.net.focuser/Properties/Resources.resx

@@ -0,0 +1,127 @@
+<?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>
+  <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=2.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=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="DefaultIcon" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\ASCOM.ico;System.Drawing.Icon, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+</root>

Meade.net.focuser/Properties/Settings.Designer.cs

@@ -0,0 +1,26 @@
+//------------------------------------------------------------------------------
+// <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 {
+    
+    
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "15.9.0.0")]
+    internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase {
+        
+        private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
+        
+        public static Settings Default {
+            get {
+                return defaultInstance;
+            }
+        }
+    }
+}

Meade.net.focuser/Properties/Settings.settings

@@ -0,0 +1,5 @@
+<?xml version='1.0' encoding='utf-8'?>
+<SettingsFile xmlns="http://schemas.microsoft.com/VisualStudio/2004/01/settings" CurrentProfile="(Default)">
+  <Profiles />
+  <Settings />
+</SettingsFile>

Meade.net.focuser/ReadMe.htm

@@ -0,0 +1,147 @@
+<!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="20110918;14150500">
+	<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 }
+		TD P.note { background: #33ffff; font-family: "Verdana", "Arial", "Helvetica", sans-serif; font-weight: normal }
+		TD P.underline { font-family: "Verdana", "Arial", "Helvetica", sans-serif; font-weight: normal; text-decoration: underline }
+	-->
+	</STYLE>
+</HEAD>
+<BODY LANG="en-GB" DIR="LTR">
+<TABLE WIDTH=100% BORDER=0 CELLPADDING=4 CELLSPACING=0>
+	<TR>
+		<TD>
+			<H2>ASCOM Focuser Driver (C#)</H2>
+		</TD>
+	</TR>
+</TABLE>
+<P><BR><BR>
+</P>
+<H4>You have just created the skeleton of an ASCOM
+Focuser driver in C#. It produces an in-process
+(assembly) based driver.</H4>
+<HR>
+<P CLASS="note">Prior to developing your first driver, please
+familiarize yourself with the <A HREF="http://ascom-standards.org/developer.html">developer
+information we've provided</A> at the ASCOM Initiative web site
+(internet required). 
+</P>
+<P CLASS="underline">You must do the following in order to complete
+your implementation:</P>
+<OL>
+	<LI><P STYLE="margin-bottom: 0cm">Switch to the Debug configuration
+	and build the template now. It should build without errors. 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm">Add a test project to the
+	solution. There are templates that can be used to add either a
+	console or a Windows Forms application:</P>
+</OL>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm">Select the <FONT FACE="Consolas, monospace">ASCOM
+	Test Forms App (CS)</FONT> or <FONT FACE="Consolas, monospace">ASCOM
+	Test Console App (CS)</FONT> template.</P>
+	<LI><P STYLE="margin-bottom: 0cm">Set a name for the test
+	application and click on OK.</P>
+	<LI><P STYLE="margin-bottom: 0cm">In the Wizard: set the same device
+	type and model name as for the driver and select Create to build the
+	test project.</P>
+	<LI><P STYLE="margin-bottom: 0cm">Set the Test Application to Run at
+	Startup.</P>
+	<LI><P STYLE="margin-bottom: 0cm">Click on Debug and the test
+	application should run.  You should be able to select your
+	application in the chooser. Selecting Properties should show the
+	default setup dialog for your driver.</P>
+	<LI><P STYLE="margin-bottom: 0cm">Trying to continue will generate
+	errors because the additional properties have not been implemented.</P>
+</UL>
+<OL START=4>
+	<LI><P STYLE="margin-bottom: 0cm">Go through the Driver.cs file and
+	replace the System.NotImplemented exceptions with code to implement
+	your driver's functionality. See the ASCOM IFocuserV3
+	spec.  If a property or method is not implemented in your driver the
+	System.NotImplemented exception must be replaced by an
+	ASCOM.PropertyNotImplemented or ASCOM.MethodNotImplemented
+	exception.</P>
+	<LI><P>Customize the Setup Dialog (SetupDialogForm) to provide the
+	settings and other controls for your driver. You can bind settings
+	directly to controls on your dialog form, there's no need to manage
+	settings manually. A custom Settings class takes care of managing
+	your settings behind the scenes. 
+	</P>
+</OL>
+<H3>Notes:</H3>
+<UL>
+	<LI><P STYLE="margin-bottom: 0cm">Successfully building the driver,
+	as well as using <FONT FACE="Lucida Console, Courier New, Courier, monospace">regasm</FONT>
+	on the assembly, registers it for both COM and ASCOM (the Chooser).
+	See the code in the ASCOM Registration region of Driver.vb. 
+	</P>
+	<LI><P STYLE="margin-bottom: 0cm">Doing a Clean for the project, as
+	well doing a <FONT FACE="Lucida Console, Courier New, Courier, monospace">regasm
+	-u</FONT> on the assembly, unregisters it for both COM and ASCOM
+	(the Chooser). 
+	</P>
+	<LI><P>Place a breakpoint in your driver class constructor, then
+	start debugging (go, F5). Your breakpoint will be hit when the test
+	application creates an instance of your driver (after selecting it
+	in the Chooser). You can now single step, examine variables, etc.
+	Please review the test application and make changes and additions to
+	activate various parts of your driver during debugging.</P>
+	<LI><P>The project's Debug configuration is already configured (The
+	test application creates an instance of your driver (after selecting
+	it in the Chooser). You can now single step, examine variables, etc.
+	Please review the test application and feel free to make changes and
+	additions to activate various parts of your driver during debugging.
+		</P>
+</UL>
+<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.focuser/app.config

@@ -0,0 +1,8 @@
+<?xml version="1.0"?>
+<configuration>
+    <configSections>
+        <sectionGroup name="applicationSettings" type="System.Configuration.ApplicationSettingsGroup, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
+            <section name="ASCOM.DeviceName.Properties.Settings" type="System.Configuration.ClientSettingsSection, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" requirePermission="false"/>
+        </sectionGroup>
+    </configSections>
+<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.1"/></startup></configuration>