Robotic Paramount MyT Polar Alignment Update

This is an all-in-one combined post about the Robotic Polar Alignment project I initially published on June 6, 2022.   All the pieces are working perfectly, and excellent PA is achieved in just a few steps.

Disclaimer: This is a DIY project that carries no guarantees of any kind, and is published as a personal article.  Anyone working with electricity, heat, hand and power tools, must exercise proper precautions and safety measures.  The author is not responsible for any damages or injuries.  Use common sense, and do not undertake actions, for which you do not have proper skills, or are not sure how to perform - seek help, practice and learn first.  Do not alter anything you cannot afford to lose.

Sources of Parts and Tools: Author gets no compensation from any online store, outlet, vendor or merchant, all product references are purely informational. Do your homework, check reviews, and please share if you find something better, cheaper, higher quality.  I provide links to sources wherever possible, but things get out of stock often, so it may be necessary to source them elsewhere.  The good news is most of the parts are widely available, and are interchangeable with minimal modifications.

Now to the actual project:

Project Description

The Paramount MyT from Software Bisque is an excellent mount, with which I enjoy astroimaging deep space objects.  However, its polar alignment routine involves manually adjusting several hard to reach knobs, while observing the result of these adjustments on a laptop screen - hardly a fun task in the field. With encouragement from friends and family, I have undertaken a project to make this process remotely controlled and automated.  Having considered a few options, I have come up with the initial set of criteria for this design:

• No modifications to the Paramount MyT itself
• Use standard, easily available components and tools at reasonable cost
• Open source software with standard settings and options
• Portability/Mobility for fast set up and dismantle while traveling to dark sites (around here anything without four street lights above your head qualifies as a dark site)
• Sturdy design that survives humidity, cold, transportation vibrations
• 12V power, USB connection, and easily available drivers for all popular OSs (I use Windows)

New Worm Gear Azimuth Drive

This is the latest azimuth robotic polar alignment drive that I have redesigned, this approach should work on a fairly wide variety of systems.  Since I use the Paramount MyT, I added the capability to rotate the entire mount about the pier, as follows:

• Added a PTFE (Teflon) washer cut with scissors out of a 1 millimeter thick PTFE Sheet I bought here - this makes the pier plate rotate fairly freely, while maintaining sufficient stability.  I tried a thrust bearing before that, and it was too thick, and would probably not work without modifying the plate, which I did not want to do.
• Designed the worm model in Fusion 360, illustrated below, and modeled the motion of the gears.  I used this technique to create the worm gear for this inexpensive worm.  I have since bought a McMaster-Carr worm that was listed in Fusion 360, but this one is working really well already.  
• 3D printed worm gear and brackets, all files are on Thingiverse.
• Drilled the 5mm hole through the worm, and installed onto a 5mm x 200mm steel rod.  
• Inserted the rod on one side into a 5mm x 16mm x 5mm bearing then into this pillow block.  The pillow block is attached to the "bearing bracket" 3d print, which goes on top of the existing hole and uses the existing MyT bolt.
• The other end of the rod is inserted into a 5mm to 8mm coupling, and then coupled to the stepper motor.  I wound up using a 14:1 geared stepper from Newegg, as it takes quite a bit of torque to turn my fully loaded imaging train setup.
• Note on the motor bracket: while the 3D printed version worked, it flexed quite a bit, so I wound up machining it by hand from a piece of 6061 aluminum cut from this angle.  This bracket takes most of the force that moves the mount, so it has to be sturdy and rigid.  The bearing bracket is fine 3D printed, although I wound up printing it in PA-CF just in case.

Video of the Az drive animation in Fusion 360:

Altitude Drive with Universal Joint

• Universal joint 8 mm to 8 mm
• Two clothesline hooks, I got mine at Lowe's
• Four wing nuts to fit on the hooks
• Small steel plate to mount the hooks and motor bracket
• 3/16" screwdriver bit to drive the MyT Altitude screw

I added a steel geared motor bracket, to help rest the motor on the MyT, and attached the small steel plate to the bracket, in order to attach the hooks.

Mounting on the MyT 

Mounting the Alt drive: 

Undo the lower wing nuts and hook onto the pin on each end.  Insert the 3/16" bit into the Alt adjustment handle, it will slip in with maybe just a slight turn of the handle to align.  Then tighten both wing nuts - you want the motor to be clear of the red MyT body.

Mounting the Az drive: 

The first part is to attach the worm gear.  It has six countersunk holes to align with the 8-24 screws in the MyT tripod pier, but I needed to get longer screws (1 1/4" were fine).  The gear just slips over the tripod pier's circumference.

I used a PTFE (Teflon washer, described above) to reduce friction between pier plate and pier.  The worm itself holds position nicely during imaging.

Once the worm wheel and pier plate are attached, slip the Az drive brackets over the rear holes in the MyT, and secure with the regular MyT winged bolts.  It is important to ensure that the worm gear meshes fully into the worm wheel before everything is tightened, this is accomplished by a slight rotation of the whole assembly about the pier.

When tightening, it is OK to put a little tension on the worm rod to ensure it stays in place during operation.

Control Electronics - Arduino Shield with GRBL

The cheap Clone CNC V4 shield I got with Arduino Nano has a few issues, which are fairly easily overcome.  These fixes are described here and here.  There is no need for microstepping jumpers, so just remove them.

Install Arduino IDE, download GRBL (help on GRBL installation and use Google for more), but make sure to modify cpu_map.h for the clone board's pins.

Solder your 12V connector to the Mot GND (-) and Mot VCC(+) connectors on the board.  Make sure you get polarity right.  I measured with a meter for the barrel jacks connected to my power supply to be sure.  Be safe, use alligator clamps etc., protect yourself from touching any live wires.

I recommend tuning the A4988 reference voltage to the motor you will be using.  The link btw, is from the Ardufocus project, which may lead you down the path of designing your own open source precision focuser and other explorations.  Here, we are just concerned with setting up the optimal stepper motor drive current.

The X motor cable is connected to the Az motor, and the Z to the Alt motor.  There is no need for the Y cable in this design.

Software

I wrote two Python programs to work with this PA system - one for manual control and one for fully automated centering of the APA star, following a TPoint run.  These are available at https://github.com/storcium/polarbot

You will also need Ken Sturrock's library for interacting with Paramount SkyX available at https://github.com/kenneth-sturrock/PySkyX_ks

Celestron Heavy Duty Tripod Wheels

Three PVC pipe caps from hardware store, each with three tapped holes for thumb screws. 

 Single hole at the bottom of each cap to attach to a three wheel furniture moving tri-dolly. 

I sandwiched a cheap sorbothane ring between each dolly and its cap.

 

Robotic Paramount MyT Polar Alignment Part 2 - Software Automation

This post is obsolete, please go here for the updated version

Having built the motor controls, I wanted to see if there is a way to automate analysis of a star in the Accurate Polar Alignment process, and even move it into the center of the image using polar axes' motion.  After some programming work, the process is working well, and appears to be quite reliable.  Here are the parts:

1. Image acquisition - using Ken Sturrock's PySkyX_ks library one can easily obtain an image from camera using their preferred filter

2. Import image data using astropy.io fits.getdata() function 

3. Process the image with Gaussian Blur to remove hot pixels , then the alignment star is the brightest spot, done as as 2 lines of code with OpenCV, and you get the coordinates

4. Center of the image is just image size divided by 2 in both directions

5. Move the motors in one axis to obtain 2 points on that axis.  This is done by injecting G Code into a cheap GRBL controller to the motors, described in my previous post

6. The hard part was calculating where to go now, but thanks to this math solution by Paul Bourke it's an easy calculation to find the point closest to the image center and go there with your motors.

7. Repeat for the other axis, and repeat the process until you are close enough. 

I was able to reliably get within 60 pixels of the center in just 8 iterations.

Here is the current code:

#!/usr/bin/env python3

####################

# Import Libraries #

####################

from library.PySkyX_ks import *

import time

import os

import numpy as np

import math

import cv2

from astropy.io import fits

import serial.tools.list_ports

import serial

# Exposure

exposure = 2

# Gaussian blur radius

radius = 33

# Acceptable distance to origin to end run

ok_dist_to_origin = 100

# Acceptable distance to tangent point to move to next axis

ok_dist_to_tangent = 100

# Number of iterations to end the program

max_iterations = 90

# max motor move units

max_move = 30

# Backlash detection, if moved less than this number of pixels

backlash_pix_move = 30

# Motion initial moves and hints

travel = {}

expected_resolution = {}

travel["vertical"] = 8

travel["horizontal"] = 30

# These are system specific, and need to be measured

expected_resolution["vertical"] = 51

expected_resolution["horizontal"] = 22

def command(ser, command):

  command += "\r\n"

  #print ("Injecting " + command)

  ser.write(str.encode(command))

  time.sleep(2)

  while True:

    line = ser.readline()

    #print(line)

    if line == b'ok\r\n':

      time.sleep(5)

      return

def move_motors(port,direction, dist):

    #start_gcode = "G1G21G91"

    if dist > max_move:

        print ("Reducing distance to max units: " + max_move)

        dist = max_move

    start_gcode = "G21G91"

    feed_rate = 1

    if direction == "left":

        cstr = f"{start_gcode}X{dist}Y-{dist}F{feed_rate}"

    elif direction == "right":

        cstr = f"{start_gcode}X-{dist}Y{dist}F{feed_rate}"

    elif direction == "up":

        cstr = f"{start_gcode}Z{dist}F{feed_rate}"

    elif direction == "down":

        cstr = f"{start_gcode}Z-{dist}F{feed_rate}"

    print("Moving " +  direction + " " + str(dist) + " units")

    command(port,cstr)

def swap_direction(axis):

    if axis == "vertical":

        direction[axis] = "up" if (direction[axis] == "down") else "down"

    else:

        direction[axis] = "left" if (direction[axis] == "right") else "right"

    print ("Reversing direction to: " + direction[axis])

def take_image():

    TSXSend("ccdsoftCamera.filterWheelConnect()")  

    TSXSend("ccdsoftCamera.FilterIndexZeroBased = 0") # Luminance    

    timeStamp("Taking image: " + str(exposure) + "s")

    TSXSend("ccdsoftCamera.Asynchronous = false")

    TSXSend("ccdsoftCamera.AutoSaveOn = true")

    TSXSend("ccdsoftCamera.Frame = 1")

    TSXSend("ccdsoftCamera.Subframe = false")

    TSXSend("ccdsoftCamera.ExposureTime = " + str(exposure))

    TSXSend("ccdsoftCamera.Delay = 1")

    TSXSend("ccdsoftCamera.TakeImage()")

    TSXSend("ccdsoftCameraImage.AttachToActiveImager()")

    cameraImagePath =  TSXSend("ccdsoftCameraImage.Path").split("/")[-1]

    return cameraImagePath

# Find the motor controller

ports = serial.tools.list_ports.comports(include_links=False)

for port in ports :

    # These are specific to my Arduino, can be found with dumping serial port data

    if port.vid == 6790 and port.pid == 29987:

        GDEV = port.device

# GDEV = "COM7" # override if needed

ser = serial.Serial(GDEV, 115200)

time.sleep(2)

command(ser,"G1 G54 G17 G21 G90 G94 M5 M9 T0 F0 S0")

time.sleep(2)

# Set the desired autosave directory

ASPath = "C:/Users/Alex/Pictures/cal/apa"

# Make this dir or ignore if it already exists

os.makedirs(ASPath, exist_ok=True)

# Set the autopath root, TSX will append a date folder to it

TSXSend("ccdsoftCamera.AutoSavePath = '" + ASPath + "'")

starcoords = []

ctrdists = []

resolution = {}

direction = {}

backlash = {}

while True:

    for axis in ("vertical","horizontal"):

        axis_runs = 0

        while True:

            imgfile = take_image()

            imgData = fits.getdata(imgfile, ext=0)

            os.remove(imgfile) # clean up

            (imgY,imgX) = (imgData.shape) # size of image in pixels

           

            # find the (x, y) coordinates of the area of the image with the largest intensity value

            imgData = cv2.GaussianBlur(imgData,(radius,radius), 0)

            (minVal, maxVal, minLoc, maxLoc) = cv2.minMaxLoc(imgData)

            #print ("min " + str(minVal) + " max " + str(maxVal) + " minloc " + str(minLoc) + " maxloc " + str(maxLoc))

            # Coordinates of the star

            (starX, starY) = maxLoc

            starcoords.append(maxLoc)

            iteration = len(starcoords)

            iter_index = iteration - 1

            print("\r\nIteration: " + str(iteration))

            # Coordinates of center (crosshairs) of image

            midX = int(imgX/2)

            midY = int(imgY/2)

            print (f"Star at {starX},{starY} - Center at {midX},{midY}")

            # Calculate the Euclidean distance to origin

            DistToOrig = int(math.dist([starX, starY], [midX, midY]))

            ctrdists.append(DistToOrig)

            print("Distance to center: " + str(DistToOrig))

            # Are we close enough to finish up?

            if DistToOrig <= ok_dist_to_origin:

                print("We are close enough, exiting.")

                ser.close()

                exit()

                # Have we reach maximum iterations

            if iteration > max_iterations:

                print("Reached maximum moves, exiting.")

                ser.close()

                exit()

            # Ask if we want to proceed or exit

            #abortYN = input("Abort further tries? (YN): ").upper()

            #if abortYN == "Y":

            #    ser.close()

            #    exit()

            # take a guess as to direction

            if axis_runs == 0 and iteration == 1:

                direction["horizontal"] = "left" if starX < midX else "right"

                direction["vertical"] = "down" if starY < midY else "up"

            # Run analysis when we have at least 2 points of the line

            if axis_runs > 1:

                pix_traveled = int(math.dist(starcoords[iter_index], starcoords[iter_index - 1]))

                resolution[axis] = pix_traveled/travel[axis]

                # Sanity check for after backlash travel

                if resolution[axis] < (expected_resolution[axis] / 2):

                    resolution[axis] = expected_resolution[axis]

                # We traveled too little, ignore for small moves

                if pix_traveled < backlash_pix_move and travel[axis] > 7:

                    backlash_travel = int(travel[axis] - pix_traveled / resolution[axis])

                    print (f"Moved only {pix_traveled} pixels, possible backlash,compensating {backlash_travel} units")

                    move_motors(ser,direction[axis],backlash_travel)

                    continue

                print (f"Traveled {direction[axis]} for {pix_traveled} pixels at {resolution[axis]} pixels/unit")

                # Where is the tangent point with the middle?

                (X1, Y1) = starcoords[iter_index]

                (X2, Y2) = starcoords[iter_index - 1]

                X3 = midX

                Y3 = midY

                # Coordinates of the tangent intersect point

                if axis_runs == 2 or travel[axis] > 5:

                    # per http://paulbourke.net/geometry/pointlineplane/

                    p2p1 = math.dist([X1, Y1], [X2, Y2])

                    u = ((X3-X1)*(X2-X1) + (Y3-Y1)*(Y2-Y1)) / (p2p1 * p2p1)

                    X = int(X1 + u*(X2-X1))

                    Y = int(Y1 + u*(Y2-Y1))

                pixels_to_tangent = int(math.dist([X1, Y1], [X, Y]))

                print (f"Tangent point X={X} Y={Y} distance from current position: {pixels_to_tangent}")

               

                # Set new distance to travel so we reach the tangent point

                # Undershoot a little, because reversing reduces precision

                travel[axis] = int(pixels_to_tangent * 0.95 / resolution[axis])

                if travel[axis] == 0:

                    print ("Increasing distance from 0 to 3")

                    travel[axis] = 3

                elif travel[axis] > max_move:

                    print (f"Reducing distance from {travel[axis]} to max {max_move} units")

                    travel[axis] = max_move

                if pixels_to_tangent <= ok_dist_to_tangent:

                    print(f"Close enough to tangent, ending this {axis} axis run")

                    break

               

                # Have we overshot the tangent?

                (XP, YP) = starcoords[iter_index -1]

                prev_pix_to_tangent = int(math.dist([XP, YP], [X, Y]))

                # Reverse either if we overshot tangent, or getting away from center

                if (pix_traveled > prev_pix_to_tangent) or (ctrdists[iter_index] > ctrdists[iter_index-1]):

                    swap_direction(axis)

                                       

            # Move

            move_motors(ser,direction[axis],travel[axis])

            # Increment per axis counter

            axis_runs += 1

Robotic Paramount MyT Polar Alignment

This is an obsolete post, the new version is here

Disclaimer: This is a DIY project that carries no guarantees of any kind, and is published as a personal article.  Anyone working with electricity, heat, hand and power tools, must exercise proper precautions and safety measures.  The author is not responsible for any damages.  Use common sense, and do not undertake actions, for which you do not have proper skills, or are not sure how to perform - seek help, practice and learn first.  Do not alter anything you cannot afford to lose.

Sources of Parts and Tools: Author gets nothing from any online stores, outlets, vendors or merchants, product references are purely informational. Do your homework, check reviews, and please share if you find something better, cheaper, higher quality.  Rather than provide links, I often include descriptions, so you can search for your preferred sources for these parts.

Now to the actual project:

The main idea is to control the polar axis motion using common components and software used in CNC machines or 3D printers.  This can be adapted to use on almost any mount.

The Paramount MyT from Software Bisque is an excellent mount, with which I enjoy learning precision astrophotography, but that enjoyment does not go as far as contortion gymnastics involved in reaching MyT's polar alignment knobs while taking pictures of APA star, or adjusting the Polemaster Polaris position.  With encouragement from friends and family, I have undertaken a project to make this process remotely controlled.  Having considered a few designs, I have come up with the initial set of criteria for this design:

• No modifications to the Paramount itself, outside of normal Software Bisque options
• Use standard, easily available, components and tools at reasonable cost
• Open source software with standard settings and options
• Portability/Mobility for fast set up and dismantle while traveling to dark sites (around here anything without four street lights above your head qualifies as a dark site)
• Sturdy design that survives humidity, cold, transportation vibrations
• 12V power, USB connection, and easily available drivers for Windows (but possible to use on Linux and other platforms)

Under my imaging train load (one standard Bisque counterweight to balance a Versa plate with scope, focuser, camera, guider), the standard NEMA 17 stepper motors used in CNC and 3D printers, are too weak.  I did not want to use NEMA 23 motors, so wound up ordering three 14:1 geared stepper motor sets from Newegg.  This worked very well for my loads (up to 1.5 Newton-meter), but higher ratios may be required for heavier gear.

The MyT has two screws for azimuth adjustment, which must be turned together to move the mount, one screw goes clockwise and the other counterclockwise.  For example, to move the mount to the left, you must turn the right screw counterclockwise, and the left screw clockwise.  Refer to the mount's user guide for details.  Each screw has a socket, reachable by a "deep" screwdriver bit.  I wound up just cutting an IKEA disposable hex wrench into two 2-inch straight pieces, which work perfectly fine in a 5mm coupling hole (more on couplings below).

Altitude adjustment is done by one screw, which has a 3/16" hex socket, easily reachable by a standard screwdriver bit.  To navigate around the mount's relief, I used a flexible drill socket extension.  Interestingly, the cheapest extension performed the best, probably due to its flexibility.  

Parts List:

• Three 14:1 geared stepper motor sets from Newegg
• CNC Shield V4+ with Nano 3.0 A4988 Stepper Motor Driver Board for Arduino.  The one I got is no longer listed as available, but search for a similar one, or use any CNC/3D printing solution that can drive stepper motors.  See below for important information about the cloned Arduino CNC shields and program options.
• Three A4988 driver boards, if not included with the shield above.  Make sure to use the heatsinks.
• Arduino Nano, or a clone, note that it must be Atmega 328 compatible (so the Nano Every will not work), in order to be compatible with GRBL
• Cables to connect the motors to the Arduino shield.  I had some laying around 5 pin (motor side) to 4 pin (PCB side), standard 4 pin to 5 pin ones used in 3D printers.
• Project box to house the shield, I used this one: LeMotech ABS Plastic Junction Box Dustproof Waterproof IP65 Electrical Enclosure Box Universal Project Enclosure Grey with PC Transparent Clear Cover 3.3 x 3.2 x 2.2 inch (83 x 81 x 56 mm)
• Brackets for the stepper motor.  Note that these are the geared motors, where the mounting holes are closer to the center than the non-geared ones.  I could not find the brackets with the geared holes for fast enough delivery, so I got three Alloy Steel 42mm Stepper Motor Mounting Bracket Fixed Base Fixing Seat for Nema 17 and drilled holes in them to fit the gearbox screw holes.
• 2PCS Linear Rails 400mm Linear Guide Rails with 4PCS SBR12UU Slide Blocks, CNC Rail Kit, Linear Rails and Bearings Kit for Automated Machines and Equipment.  These are used in DIY CNC and 3D printers, and are easily found online, they look like this:

• Couplers for stepper motors to connect to the hex bits.  Use the ones appropriate for your bits.  The stepper gearboxes are 8mm, also use 8mm for1/4" hex bits (I used the 1/4" drive 3/16" bit for the altitude axis), and the bits I cut form the IKEA wrench for the azimuth screws fit into 5mm holes.  So I used (one) 8mm to 8mm Bore Rigid Coupling Set Screw L25XD14 Aluminum Alloy,Shaft Coupler and (two) 8mm to 5mm Bore Rigid Coupling Set Screw L25XD14 Aluminum Alloy,Shaft Couplers.  There is a whole lot of choices of these on Amazon and eBay, and other sites.  I started with flexible couplers, but ended up using rigid ones for more precise movement.
• A spring to pull together the slide blocks on the linear rail.  I went to Lowe's and just got the one that looked right, for less than $1.  The goal is to keep the slide blocks engaged in the hex sockets of the two azimuth screws, like so:

• Brackets to mount the linear rail to MyT.  I got two black steel brackets at Lowe's and drilled holes in them to match the holes on MyT, and I'll be making new ones from a piece of aluminum for looks and sturdiness.  The Lowes' brackets work fine for now.  It is important to assemble motors on sliding blocks, and fit to the MyT screws to make sure they line up, then mark and drill the holes.  
• 5mm screws to mount the motor brackets to sliding blocks.  I had to slightly enlarge the holes on my brackets with a drill, for the screws through them.
• A box of screws and washers is very helpful.  I got some M3, M4, M5 metric screws and nuts, and some fractional ones as well.  These are available in hardware stores, Amazon etc.
• 12V feed for the Arduino shield to feed motors.  I soldered a 2.1mm barrel jack to the connectors on the shield, as shown below, but any 12V source will work, make sure that it can supply enough power to drive the motors you are using
• USB for PC or your hub for Arduino to computer connection

Altitude Adjustment Assembly

I have redone the Altitude assembly to be much simpler and sturdier:

• Universal joint 8 mm to 8 mm, easily found on Amazon, etc.
• Two clothesline hooks, I got mine at Lowe's
• Four wing nuts
• Small steel plate to mount the hooks and motor bracket
• 3/16" screwdriver bit to drive the MyT Altitude screw

Motor Assemblies

For the RA axis motors, I first marked and drilled the holes for the motor gearbox mounting screws in the motor steel brackets.  Next, I enlarged the holes on the other side of the bracket to be able to attach them to slide blocks.  

First, attach to slide block, then attach the motor (otherwise you won't be able to reach the slide block screws easily).

Attach the motor side of shaft coupling with two included hex set screws.  Make sure there is enough space on the other end of the coupling to insert and secure the hex bit, which will drive the MyT polar alignment screws.  I first inserted both, then tightened set screws.

The 8mm to 8mm coupling is connected to both the motor shaft and the flexible drill bit extension.

Mounting the Slide Rail

The slide rail needs to be mounted to two of the four screws, which attach the MyT to its pier plate or base (rear of the mount).  For the first iteration of this project, I bought some right angle steel brackets from Lowes and drilled a few holes in them to properly position them.  Your main goal is to make sure the hex bits connected to motors align perfectly with the holes in Az axis screws.  I had to measure and drill a few times to obtain a perfect fit.  You will want to smooth edges of the holes with a larger bit, or a countersink bit, to avoid scratches on the MyT parts.

Mount the slide rail to the MyT and test the motors on slide blocks to fit the hex bits into MyT's screws.  Adjust as needed.  Once the perfect fit is attained, secure the brackets, and engage the motors' hex bits fully.  It may be necessary to rotate MyT's knobs in and out for the hex bits to seat themselves.  Once seated, tighten the knobs with reasonable force to the axis lever (like you would when you are done with polar alignment).  

Arduino Shield

The cheap Keys Studio clone CNC V4 shield I got with Arduino Nano has a few issues, which are fairly easily overcome.  These fixes are described here and here.  There is no need for microstepping jumpers (the full step is running at 14:1 ratio by the gearbox), so just remove them.

Install Arduino IDE, download GRBL (help on GRBL installation and use Google for more), but make sure to modify cpu_map.h for the clone board's pins.

Solder your preferred 12V connector to the Mot GND (-) and Mot VCC(+) connectors on the board.  Make sure you get polarity right.  I measured with a meter for the barrel jacks connected to my power supply to be sure.  Be safe, use alligator clamps etc., protect yourself from touching any live wires.

I recommend tuning the A4988 reference voltage to the motor you will be using.  The link btw, is from the Ardufocus project, which may lead you down the path of designing your own open source precision focuser and other explorations.  Here, we are just concerned with setting up the optimal stepper motor drive current.

Download and install a Gcode program, such as UGS.  

Connect the Nano USB cable to the computer and note its serial port via e.g. Device Manager on Windows.  Connect to this port via UGS:

Try to initiate motor motion on each of your 3 motors by sending some steps via X, Y, and Z axes.  For this test, do not have the motors engaged in MyT knobs yet - we are just making sure they can turn in each direction.

Once you are happy with the motor controls, disconnect the Arduino, turn off the power to the motors, and engage the motors' hex bits into the MyT knobs.  Reconnect all cables and UGS.

For my setup, I connected the X motor to the left Az side, Y motor to the right Az side, and the Z motor to the Alt knob screw.  With such setup, Altitude is controlled via the Z axis, and Az is controlled either by the bottom right diagonal arrow (X+ and Y-) or the top left diagonal arrow (Y+ and X-).  This will maintain tightness of the screws against the adjustment lever.  Do not use the other diagonal arrows.  You can experiment with other types of movement (X only or Y only), but I found the two diagonals to be the easiest option.

Calibration

You can calibrate UGS to treat MyT's "ticks" as mm for scale, this is accomplished in UGS setup wizard, or firmware settings (in the Machine menu).  This makes it easier to follow the SkyX polar alignment recommendations, which are given in ticks.

Testing

The first full test should be inside, with the mount's payload exactly as you will have it in the field, all equipment and counterweights attached.  Try moving the axes in each direction, and observe the motion.

After this is completed, I recommend packaging your controller shield and connectors into a project box, such the one I listed, or any other sturdy enclosure.  Find a way to attach this enclosure to the mount.  I am currently using stick-on magnets, you may want tot try this or Velcro, glue, nuts and bolts etc.  Do not let your controller dangle on wires in the field, that is not fun.  Test in driveway, back yard, other safe and well lit area to make sure all comes together and works well.

Dark Site Use

Once the MyT base is assembled (pier/tripod, plate, mount, equipment etc.), attached the motors as before, and connect to computer.  Run all your usual setup, which for me is a rough polar alignment, focus, filter, exposure, and a TPoint model.  I do use a Polemaster with these motors initially, which is unnecessary, but it makes APA a rather small adjustment later on.

Finally, operate your motors to achieve the precise polar alignment.  You can always turn the knobs by hand, even with the motors attached.  The motors may remain engaged after alignment is completed, or you can disengage them and remove, or just disconnect power, or keep everything connected - whatever suits your needs best.

Assembled Components