WT5L

NGC 6960 - Veil Nebula (Western Segment)

2011-11-30T16:12:00.001-05:00

In the constellation Cygnus (The Swan) an unknown supergiant star exploded some 15,000 years ago and briefly appeared as a spectacular Type II supernova. The remnant of that ancient blast is now visible as a very large circle of nebulosity known as the Cygnus Loop. More popularly known as the Veil Nebula (aka Filamentary Nebula, Bridal Veil Nebula, or Network Nebula), this circle of star material spans some 3 degrees or six full-Moon-diameters of the night sky. The segment on the western side of the loop is cataloged as NGC 6960 or Caldwell 33 and is the subject of my recent image shown below:

(Click image to view larger version)

This portion of the Veil Nebula is also known as "The Witches Broom" and is dominated by the bright, magnitude 4.2 foreground star known as 52 Cygni. NGC 6960 runs in a roughly north-south line slightly east of 52 Cygni. A cropped, full resolution image of this western segment of the Veil is shown below:

(Click image to view larger version)

Note 1: East is toward top and North is toward right side for all images. Complete image details are available by clicking here.

Note 2: [Source: O'Meara, Stephen James. "The Caldwell Objects". Cambridge: University of Cambridge and Sky Publishing, 2002. Print.]

Spectacular Pleiades

2011-11-26T18:36:00.000-05:00

On fall and winter evenings, the northern sky's most spectacular open cluster rides high in the constellation Taurus the Bull. The 70-million-year-old cluster contains some 100 stars in an area 14 light years in diameter with ten stars brighter than 6th magnitude. Photographs show the entire area surrounded by ice-blue nebulosity that reflects the light of the hot, young stars. Debate continues whether the nebulosity is associated with the stars or whether the cluster is just moving through an area of nebulosity. Either way, the cluster/nebulosity combination makes for a magnificent wide-field photograph. Here is a reduced version of the Pleiades:

(Click image to view larger version)

A map of the Pleiades rotated to match all images is shown below:

(Click image to view larger version)

The brightest area of nebulosity surrounds the star Merope (23 Taurii) and is known as the Merope Nebula (IC349). Just to the south of Merope (left) is another area of nebulosity cataloged as NGC 1435 and also known as Tempel's Nebula. A close-up image of the area around Merope is shown below:

(Click image to view larger version)

Another bright area of nebulosity surrounds the Maia (20 Taurii) and is known as the Maia Nebula (NGC 1432). A close-up image of the area around Maia is shown below:

(Click image to view larger version)

Note 1: East is toward top and North is toward right side for all images. Complete image details are available by clicking here.

Note 2: [Source: O'Meara, Stephen James. "The Messier Objects". Cambridge: University of Cambridge and Sky Publishing, 1998. Print.]

NGC 663 and Companions

2011-10-29T08:39:00.005-04:00

Among the many open cluster in the region where the Milky Way cuts through Cassiopeia is a tight grouping of three clusters dominated by NGC 663. With a diameter of 15 arc-minutes and a magnitude of 7.1, NGC 663 is also cataloged as Caldwell 10 and is often described as the 'The Horseshoe Cluster'. Here is a close-up image of NGC 663:

(Click image to view larger version)

About one-half degree to the southwest of NGC 663 is another fainter and smaller cluster cataloged as NGC 659. This cluster is about 6 arcmin in diameter and shines at magnitude 7.9. Here is a close-up image of NGC 659:

(Click image to view larger version)

Also in the same field of view, about 43 arc-minutes to the northwest of NGC 663 is still another small cluster designated as NGC 654. This cluster is also about 6 arc-minutes in diameter but slightly brighter than NGC 659 at magnitude 6.5. Here is a close-up image of NGC 654:

(Click image to view larger version)

The complete field-of-view containing the three clusters (labeled) is shown in the following image. Note: The bright blue-white star to the southwest (below and left) of NGC 659 is the multiple star 44 CAS. This 5.8 magnitude star has a magnitude 9.6 companion 66 arc-seconds away and a 9.2 magnitude companion 140 arc-seconds away.

(Click image to view larger, unlabeled version)

Note: East is toward top and North is toward right side for all images. Also, complete image details are available by clicking here.

Comet Garradd - Sept. 29, 2011

2011-10-06T10:35:00.003-04:00

Comet C/2009 P1 (Garradd) is a fairly bright and very well placed object for North American astronomers from now through Spring of 2012. As comets go it is a large object but never comes closer to the Sun than Mars' average distance. Thus it will be visible for an unusually long time but will never sport much of a tail. Below is an image of Garradd taken on the evening of September 29, 2011 from the Chiefland Astronomy Village in Chiefland, Florida. It is composed of multiple 2-minute exposures through LRGB filters.

(Click image to view larger version)

Here is also a very short video of the motion of Garradd over the 90-minute period that I spent imaging the object (10 frames, each frame approximately ten minutes apart).

Sending Text Messages with Python

2011-09-05T16:35:00.000-04:00

One of the neat things I like to do with my Astro-Imaging scripts is to have the ability to send periodic status messages to my cell phone. With this capability, if I am away from my imaging computer, I can always know how imaging is progressing. Also, I can have my script send any error messages that crop up so that I may immediately return to my imaging setup if needed.

The key to sending text messages is contained in this List of SMS Gateways that contains e-mail addresses for each of the major cell phone carriers. Basically, all you need to do is send an e-mail message to the domain that applies to your cell phone carrier with your phone's ten-digit number as the address. As the Wikipedia page explains, you can only send simple text messages to the SMS gateway. The following Python code listing shows how to send the e-mail message programmatically. Obviously, you will need to know the outgoing e-mail domain, your user name and password for accessing your personal e-mail service provider to make the code work.

The listing shown below is coded for my particular service carrier (AT&T Wireless). To personalize the code for your particular setup, just modify the five constants defined prior to the class declaration. The source file corresponding to this listing can be downloaded from cTexting.zip.

from smtplib import SMTP
import datetime
import socket
import traceback

SMTP_DOMAIN = r'<OUTGOING EMAIL DOMAIN>'
SMTP_USER   = r'<USER NAME>'
SMTP_PASS   = r'<PASSWORD>'
FROM_ADDR   = r'AstroPhoto Update <anyone@gmail.com>'
TO_ADDR     = r'<TEN-DIGIT CELL NUMBER>@txt.att.net'

socket.setdefaulttimeout(10)

##--------------------------------------------------------------------------------
## Class: cTextMsg
##------------------------------------------------------------------------------
class cTextMsg:
    __objectName = ''

    def __init__(self):
        pass
        
    def set_objectName(self, value):
        self.__objectName = value
        return
    
    def get_objectName(self):
        return self.__objectName

    def sendSMSMessage(self,message):
        smtp = SMTP()
        smtp.set_debuglevel(0)
        
        subject = self.get_objectName()
        date = datetime.datetime.now().strftime('%d/%m/%Y %H:%M')

        msg = 'From: %s\nTo: %s\nSubject: %s\nDate: %s\n\n%s' % \
                (FROM_ADDR,TO_ADDR,subject,date,message)
        
        try:
            smtp.connect(SMTP_DOMAIN,0)
            smtp.login(SMTP_USER,SMTP_PASS)
            smtp.sendmail(FROM_ADDR,TO_ADDR,msg)
            print "SMS Message Sent Successfully"
            smtp.quit()
        except socket.timeout:
            print "ERROR: Timeout sending SMS Message"
        except:
            print "ERROR: Unable to send SMS Message"
            print '!'*60
            print traceback.format_exc()
        
##
##    END OF 'cTextMsg' Class
##

if __name__ == '__main__':
    
    email_msg = cTextMsg()
    email_msg.set_objectName('M31')
    print 'Object Name: ' + email_msg.get_objectName()
    email_msg.sendSMSMessage('This is a sample message from an imaging session.')

Vertical Antenna Tilt Mount

2011-09-03T17:24:00.031-04:00

For the past 10+ years (which covers almost the entire span of my amateur radio career) my main antenna has been a GAP Titan DX 8-band vertical antenna. This versatile antenna weighs in at around 25 lbs. and has a height of about 25 feet. For most of this time the antenna has been mounted on one corner of a second floor wooden deck and was very difficult to raise and lower. In fact, the antenna was only lowered once, in September 2004, when our area was hit by two hurricanes in a three-week period. Consequently, I have not been able to easily check the condition of the antenna and perform some needed periodic maintenance.

Due to the obvious deterioration of the antenna from lack of maintenance and from this area's highly corrosive seaside location, I've decided to remove the antenna from its second floor mount and to re-mount it in a more convenient location in my back yard. A main requirement of the this new mount was to provide a means to easily raise and lower the antenna when needed for maintenance and when adverse weather conditions threaten. Below is a photo of the new tilt ground-mount base for the GAP antenna that I've come up with.

The base is made up of two 8-foot long treated 2"x4"s that are sunk 3 feet into the ground. A 42" deep by 18" diameter hole was dug out, filled with 6" of rock then poured with concrete around the 2"x4"s. Three sets of 6" long carriage bolts were installed between the 2"x4"s below ground level to give the concrete something to grab onto other than the treated wood.

Above the ground, the 2"x4" were joined with a 4-foot piece of treated 2"x6". A 6-foot piece of schedule-40 1" galvanized water pipe (1.32" OD) is mounted inside the channel formed by the 2"x4"s and 2"x6" (backside of photo on the left).

The pivot-point for the tilt mechanism is drilled through the galvanized pipe near the top end of the pipe. The pipe swings on a piece of 3/32" stainless steel threaded rod secured with two nuts of the outside of the 2"x4"s. Another set of nuts is installed on either side of the pipe to prevent the pipe from wobbling when it swings in and out of the channel between the 2"x4"s. Refer to the photo to the right.

In the normal, upright position, the galvanized pipe is secured to the base mount using 3 stainless steel 1/4" U-bolts pushed through holes in the 2"x6". Two of the three U-bolts are visible in the photo to the left.

For the antenna to be lowered, the three U-bolts are removed and the antenna will be either walked or winched down to a horizontal position. (I'm considering installation of a hand-winching mechanism.) The top of the 2"x6" will prevent the antenna from swinging lower than a nearly-horizontal position. Refer to the photo of the unloaded swing pipe in the photo to the right.

The antenna will be mounted onto the top portion of the 1" galvanized pipe using a stainless steel mounting plate and U-bolts provided with the GAP antenna. The 5'x5' wire hoop at the base of the antenna will be installed after the antenna is raised into its vertical position. Likewise, the hoop will have to be removed prior to lowering the antenna into its horizontal position. By elevating the base of the antenna about 6' off the ground, the hoop will be positioned approximately 8' off the the ground and well above the heads of anyone walking in the yard.

LoTW Application Complete!

2011-08-30T19:06:00.000-04:00

My latest Logbook of the World (LoTW) application was submitted on July 19, 2011 and completed on August 29, 2011. In this application, I applied for 93 LoTW QSO credits, 20 paper QSO credits, and one DXCC award (10M). The following table contains my current DXCC status. Complete details regarding all confirmed DXCC entities and additional information regarding the DXCC awards program can be found by clicking here.

Mixed	157 Confirmed	157 Awarded	0 Pending	(0 LotW, 0 Paper)
CW	127 Confirmed	127 Awarded	0 Pending	(0 LotW, 0 Paper)
Phone	131 Confirmed	131 Awarded	0 Pending	(0 LotW, 0 Paper)
Digital	78 Confirmed	78 Awarded	0 Pending	(0 LotW, 0 Paper)
80m	20 Confirmed	20 Awarded	0 Pending	(0 LotW, 0 Paper)
40m	92 Confirmed	92 Awarded	0 Pending	(0 LotW, 0 Paper)
30m	5 Confirmed	5 Awarded	0 Pending	(0 LotW, 0 Paper)
20m	117 Confirmed	117 Awarded	0 Pending	(0 LotW, 0 Paper)
17m	3 Confirmed	3 Awarded	0 Pending	(0 LotW, 0 Paper)
15m	129 Confirmed	129 Awarded	0 Pending	(0 LotW, 0 Paper)
12m	6 Confirmed	6 Awarded	0 Pending	(0 LotW, 0 Paper)
10m	104 Confirmed	104 Awarded	0 Pending	(0 LotW, 0 Paper)

Starts With A Bang! and Messier 29

2011-08-12T16:27:00.006-04:00

One of my favorite science blogs is Starts With A Bang! by Ethan Siegel. Ethan is a theoretical astrophysicist at the Lewis and Clark College in Portland, Oregon. I hadn't checked in on his blog in a few weeks so I spent some time today reading through recent postings and ran across a post from August 2nd entitled "If I had a Telescope this Summer...". Reading through the excellent post on summer objects to view, I was pleasantly surprised to see he used my photo from last fall of the open cluster Messier 29 in Cygnus (see below). Now it really is my favorite blog! (Click here for a larger version of the photo.)

Updated DXCC Status

2011-07-17T15:01:00.000-04:00

The following table contains my current DXCC status. Complete details regarding all confirmed DXCC entities and additional information regarding the DXCC awards program can be found by clicking here.

Mixed	157 Confirmed	135 Awarded	22 Pending	(18 LotW, 4 Card)
CW	127 Confirmed	100 Awarded	27 Pending	(24 LotW, 3 Card)
Phone	131 Confirmed	118 Awarded	13 Pending	(8 LotW, 5 Card)
RTTY	78 Confirmed	66 Awarded	12 Pending	(12 LotW, 0 Card)
80m	20 Confirmed	18 Awarded	2 Pending	(2 LotW, 0 Card)
40m	92 Confirmed	70 Awarded	22 Pending	(21 LotW, 1 Card)
20m	117 Confirmed	102 Awarded	15 Pending	(14 LotW, 1 Card)
15m	129 Confirmed	112 Awarded	17 Pending	(15 LotW, 2 Card)
10m	104 Confirmed	93 Awarded	11 Pending	(7 LotW, 4 Card)

Automated Astrophotography with Python - Part 7

2011-07-10T14:20:00.002-04:00

FOCUSING WITH FOCUSMAX
Achieving great focus is undoubtedly one of the most critical operations for any astronomical imaging application. Using the free application, FocusMax, this step can be reduced to a simple, repeatable, and highly effective operation. Fortunately, FocusMax provides all of the necessary interfaces to quickly automate this important step. The following listing shows a new class named 'cFocuser'. This class is responsible for controlling all aspects of the focus operation. The listing for the 'cFocuser' class is shown below:

import time
import pythoncom
import win32com.client

FOCUSMAXTIME = 150
LASTFOCHFD = -1

ERROR   = True
NOERROR = False

##------------------------------------------------------------------------------
## Class: cFocuser
##------------------------------------------------------------------------------
class cFocuser:
    def __init__(self,printlog):
        printlog.log(0,"Connecting to FocusMax...")
        self.__FM = win32com.client.Dispatch("FocusMax.FocusControl")

    def checkFocusStar(self,printlog):
        printlog.log(0,"Checking focus by measuring HFD...")
        HFD = []
        count = 0
        # take 7 HFD measurements, sort the list, report the median value
        while count < 7:
            busy = self.__FM.SingleExposeAsyncStatus        
            self.__FM.SingleExposeAsync()
            # wait for measurement to end
            startTime = time.time()
            busy = -1
            while busy == -1 and (time.time() - startTime) < FOCUSMAXTIME:
                time.sleep(1)
                busy = self.__FM.SingleExposeAsyncStatus
            if self.__FM.SingleExposeAsyncStatus != 1:
                printlog.log(0,"HFD Measurement failed or timed out")
                return -1        
            result = self.__FM.HalfFluxDiameter
            flux = self.__FM.TotalFlux
            time.sleep(0.5)
            printlog.log(1,"HFD Measurement: %0.2f  Total Flux: %d" %
                         (result,flux))
            if flux > 20000:
                HFD.append(result)
                count = count + 1
        HFD.sort()
        j = len(HFD)
        if not j%2:
            median = (HFD[(j/2)-1]+HFD[j/2])/2.0
        else:
            median = HFD[j/2]
        focuserPos = self.__FM.Position
        printlog.log(0,"Median HFD = %0.2f at Pos = %d" % (median,focuserPos))
        return median

    def focusStar(self,printlog):
        global LASTFOCHFD
        printlog.log(0,"Starting FocusMax Focus method...")
        try:
            busy = self.__FM.FocusAsyncStatus        
            start = self.__FM.FocusAsync()
        except pythoncom.com_error, (hr, msg, exc, arg):
            printlog.log(0,"ERROR: %s" % exc[2])
            return ERROR
        else:
            if start:
                # wait for focus method to end
                startTime = time.time()
                busy = -1
                while busy == -1 and (time.time() - startTime) < FOCUSMAXTIME:
                    time.sleep(1)
                    busy = self.__FM.FocusAsyncStatus
                if self.__FM.FocusAsyncStatus != 1:
                    printlog.log(0,"Focus method failed or timed out.")
                    return ERROR        
                printlog.log(0,"FocusMax Focus method complete...")
                tgtHFD = self.__FM.HalfFluxDiameter
                if tgtHFD > 0.5:
                    median = self.checkFocusStar(printlog)
                    if median == -1:
                        return ERROR
                    elif median < 0.5 or median > 4.0:
                        printlog.log(0,"ERROR: Focus results out of range.")
                        return ERROR
                    else:
                        LASTFOCHFD = median
                        return NOERROR
                else:
                    printlog.log(0,"ERROR: Focus method failed.")
                    return ERROR
            else:
                printlog.log(0,"ERROR: FocusMax Focus method failed to start.")
                return ERROR

##
## END OF 'cFocuser' Class
##

The constructor for 'cFocuser' is called whenever a new object of the class is instantiated and is used to create a new object (__FM) that is bound to the FocusMax object (FocusControl) required by this class. Following the constructor, the 'checkFocusStar()' method performs a check of focus quality by invoking the 'SingleExposeAsync()' method. This method is called multiple times to take a series of measurement of a suitable focus star that has previously been centered in the field of view. After waiting for the exposure to complete, the method checks the properties that holds the measurement's HFD and total flux (brightness). The measurements are written to the screen and to the log file and the HFD value is appended to a list data structure. After seven measurements are collected, the HFD list is sorted and the median value is extracted and returned to the method's calling routine.

The other method in this class is named 'focusStar()' and performs the actual focus operation (nearly equivalent to clicking on the 'Focus' button on FocusMax's front panel). This method invokes the FocusMax 'FocusAsync()' method to kick off the focus operation. The method then polls the 'FocusAsyncStatus' property to determine when the focus operation is complete. If the focus star's HFD is a reasonable value, the 'checkFocusStar()' method is called to determine the median of seven consecutive HFD measurements. The median value is then assigned to a global variable, 'LASTFOCHFD'.

UNIT TESTING
Unlike unit tests for modules presented up to this point, the unit test for this class can not be simulated. Therefore, actual stars must be available to adequately verify the operation of this module. Due to poor weather and equipment failures I have been unable to generate and verify a unit test for the 'cFocuser' class. As soon as I am able, I will update this post with a unit test.

WHAT'S NEXT?
In the next post, I will demonstrate the method that I use to automatically select focus stars. This method will work with previous modules and result in a means to select a suitable focus star near the object to image, slew to the star, focus and determine median HFD, then slew to the main object to begin imaging. This procedure, along with periodic slews back to the focus star to check and ,if necessary, re-focus, is the main sequence of events that I use for my astronomical imaging script.

M21 - Open Cluster

2011-06-28T08:30:00.024-04:00

(Click image to go to info page)

The open cluster M21 is a loose collection of about 50 stars located less than one degree northeast of the Trifid nebula (M20) in Sagittarius. The cluster lies approximately 4000 light years away and has a diameter of about 15 arc-minutes. Together, M20 and M21 make up an asterism known as "Webb's Cross" with M21 at the northern end and M20 at the southern end of the cross. M21 was first observed by Charles Messier in 1764. [Source: O'Meara, Stephen James. "The Messier Objects". Cambridge: University of Cambridge and Sky Publishing, 1998. Print.]

The data for this LRGB photo was captured between 3 June and 5 June 2011. All images were taken at the Chiefland Astronomy Village in Chiefland, Florida. Complete details regarding this image can be found by clicking on the image above or by clicking here.

M20 - Trifid Nebula

2011-06-27T08:05:00.005-04:00

(Click image to go to info page)

The Trifid Nebula is a large, bright nebula and open cluster located in the constellation Sagittarius. It consists of four bright lobes separated by dark lanes of obscuring matter. As seen in the photo above and in the full-frame photo found here, M20 is located in a densely populated region of the Milky Way. At a magnitude of 5.9 and a distance of approximately 5000 light-years, the Trifid was first observed by Charles Messier in 1764. [Source: O'Meara, Stephen James. "The Messier Objects". Cambridge: University of Cambridge and Sky Publishing, 1998. Print.]

The data for this LRGB photo was captured between 3 June and 5 June 2011. All images were taken at the Chiefland Astronomy Village in Chiefland, Florida. Complete details regarding this image can be found by clicking on the image above or by clicking here.

Automated Astrophotography with Python - Part 6

2011-06-26T15:15:00.003-04:00

PLATE SOLVING WITH CCDSOFT AND THE SKY6
One of the most important features of any automated imaging script includes the ability to determine exactly where the imaging system is pointing at any given time. This is accomplished by astrometric plate solves that correlates positions of stars in an image with predetermined, known star positions. The combination of CCDSoft and the Sky6 (or MaxIm DL Pro and Pinpoint) provide a software path to implement this feature. For my astro-imaging purposes, I've chosen a more convoluted path to achieving plate solves. Specifically, I acquire my plate solve images using MaxIm DL (which pulls approximate RA and Dec coordinates of the image's center from the Sky6 via an ASCOM driver), then load the image into CCDSoft to perform the actual plate solve operation.

In order to capture the initial image to be plate solved it is necessary to add some code to the 'cCamera' class. A new class constant that specifies the save directory of the plate solve images is added at the top of the module:

PLATESOLVE_PATH = r"c:\\imaging scripts\\plate_solve_images\\"

Also, two new methods are added to the 'cCamera' class. These new methods are shown below:

def exposePlateSolve(self,length,filterSlot,name,printlog):
    self.__CAMERA.Expose(length,1,filterSlot)
    while not self.__CAMERA.ImageReady:
        time.sleep(0.5)
    # save exposure into plate solve folder
    printlog.log(0,"Saving plate solve image...")
    self.__CAMERA.SaveImage(PLATESOLVE_PATH + name + "_platesolve.fit")

def setQuarterSubFrame(self):
    self.__CAMERA.StartX = self.CAMERA.CameraXSize / 4
    self.__CAMERA.StartY = self.CAMERA.CameraYSize / 4
    self.__CAMERA.NumX = self.CAMERA.CameraXSize / 2
    self.__CAMERA.NumY = self.CAMERA.CameraYSize / 2

The method 'exposePlateSolve()' is used to capture the image, generate a filename, and save the image to the directory specified by PLATESOLVE_PATH. (Typically, all my plate solve images are unbinned, 10-second exposures taken through the luminance filter.) Since plate solves using CCDSoft and the Sky6 do not execute reliably on large images, I always use sub-framing to reduce the image size to one-fourth the area of a full-size frame. The 'setQuarterSubFrame()' method is responsible for setting up the reduced sub-frame so that the center of the sub-frame and the center of the full-size frame coincide.

The next listing shows a new class named 'cPlateSolver'. This class is responsible for initiating the plate solve operation through CCDSoft. CCDSoft, in turn, calls on the Sky6 to assist with the matching of stars in the database with the stars in the plate solve image. The listing for 'cPlateSolver' is shown below:

import pythoncom
import win32com.client

IMAGESCALE = 1.808
PLATESOLVE_PATH = r"c:\\Imaging_Scripts\\plate_solve_images\\"

class cPlateSolver:
    def __init__(self,printlog):
        printlog.log(0,"Connecting to CCDSoft...")
        self.__IMAGE = win32com.client.Dispatch("CCDSoft.Image")

    def insertWCS(self,name,targetRA,targetDec,mount,printlog):
        plateSolveResults = []
        # open platesolve.fit in CCDSoft and perform plate solve
        self.__IMAGE.Path = PLATESOLVE_PATH + name + "_platesolve.fit"
        self.__IMAGE.Open()
        # set image scale in CCDSoft
        self.__IMAGE.ScaleInArcsecondsPerPixel = IMAGESCALE
        try:
            self.__IMAGE.InsertWCS()
        except pythoncom.com_error, (hr, msg, exc, arg):
            errorstr = exc[2]
            errorstr = errorstr.replace('\n',' ')
            printlog.log(0,"Plate Solve %s" % errorstr)
            self.__IMAGE.Close()
            plateSolveResults = [0.0,0.0,-1,-1]
        else:
            # if no errors, report results
            printlog.log(0,"Plate Solve Results:")
            printlog.log(1,"Image Scale: %0.3f asp" % IMAGESCALE)
            printlog.log(1,"North Angle: %0.2f deg" % self.__IMAGE.NorthAngle)
            # get 2000 Epoch RA and Dec of center of plate solved image
            RADec = self.__IMAGE.XYToRADec(self.__IMAGE.Width/2.0,
                                         self.__IMAGE.Height/2.0)
            plateSolveResults.append(RADec[0])
            plateSolveResults.append(RADec[1])
            J2000RA = mount.getAngleToDMS(RADec[0])
            printlog.log(1,"Solved RA (J2000) : %02dh %02dm %0.2fs" % \
                         (J2000RA[0],J2000RA[1],J2000RA[2]))
            J2000DEC = mount.getAngleToDMS(RADec[1])
            printlog.log(1,"Solved DEC (J2000): %02d deg %02d' %0.2f\"" % \
                         (J2000DEC[0],J2000DEC[1],J2000DEC[2]))
            # Compute angular separation and position angle from
            # plate solved location to target location
            angSeparation = mount.getAngularSeparation(targetRA,targetDec,
                                                       RADec[0],RADec[1])
            positionAngle = mount.getPositionAngle(targetRA,targetDec,
                                                   RADec[0],RADec[1])
            angSeparation = angSeparation * 3600
            plateSolveResults.append(angSeparation)
            plateSolveResults.append(positionAngle)
            printlog.log(1,"Pointing error = %0.2f arcsec at %0.2f deg" % \
                         (angSeparation,positionAngle))
            self.__IMAGE.Close()
        return plateSolveResults        

    def execPlateSolve(self,camera,mount,name,targetRA,targetDec,printlog,
                       mode="Image"):
        # set binning to unbinned
        printlog.log(0,"Setting imager bin mode to 1x1")
        camera.setBinning(1,printlog)
        # set up camera for quarter-size subframe in center
        camera.setQuarterSubFrame()
        # take 10 second exposure
        printlog.log(0,"Exposing 10 second image for Plate Solve...")
        if mode.upper() == "IMAGE":
            camera.exposePlateSolve(10.0,0,PLATESOLVE_PATH+name,printlog)
        else:
            camera.exposePlateSolve(10.0,0,PLATESOLVE_PATH+name+'_test',
                                    printlog)
        #insert WCS
        printlog.log(0,"Performing plate solve with CCDSoft and The Sky6...")
        return self.insertWCS(name,targetRA,targetDec,mount,printlog)
            
##
## END OF 'cPlateSolver' Class
##

Two constants are declared and initialized at the top of the listing. 'IMAGESCALE' contains the arc-seconds per pixel resolution of the image to be solved and 'PLATESOLVE_PATH' is the path to the directory where the image has been stored. The class constructor creates an instance of the 'Image' object of CCDSoft.

The plate solve operation is initiated by a call to the 'execPlateSolve()' method of 'cPlateSolver'. This method sets up the binning and sub-framing of the plate solve image then calls the 'exposePlateSolveImage()' method of the 'camera' instance of the 'cCamera' object. The image is then exposed and saved under a name that is generated using the 'name' argument of the method (the save filename is modified if the mode is determined to be something other than 'Image'). After the plate solve image is exposed and saved, the plate solve operation is performed by a call to the 'insertWCS()' method.

The 'insertWCS()' method is fairly simple. After opening the plate solve image in CCDSoft and setting the 'ScaleInArcsecondsPerPixel' attribute, the 'insertWCS()' method of CCDSoft's 'Image' object is called from inside a try...except...else construct. If the plate solve fails, an informative error message is printed to the screen and log file. Otherwise, the RA and Dec coordinates of the plate solve image's center is determined using the 'XYToRADec()' method of CCDSoft's 'Image' object. The RA and Declination are reformatted, written to screen and log file, and appended to the 'plateSolveResults' list data structure. Additionally, the separation (in arc-seconds) and position angle from the solved coordinates to the intended coordinates are found, written to screen and log file, and also appended to the 'plateSolveResults' list. This is is then returned to the calling routine ('execPlateSolve()') which, in turn, returns the list to its calling routine.

The unit test for this class demonstrates use of the methods in the 'cPlateSolver' class and is shown below:

if __name__ == '__main__':

    import cLogger_6
    import cCamera_6
    import cMount_6

    # set up path and name of the logfile
    cCameraLogFile = r"C:\Imaging_Scripts\logfiles\cplatesolver.log"

    # instantiate the class with the path and name
    printer = cLogger_6.cLogger(cCameraLogFile)
    printer.logHeader('Unit Test cPlateSolver Class')

    # Create an instance of the cCamera class
    testCamera = cCamera_6.cCamera(printer)

    # Create an instance of the cMount class
    testMount = cMount_6.cMount(printer)

    # Create an instance of the cPlateSolver class
    testPlateSolve = cPlateSolver(printer)

    objects = ['M92','M107']
    for obj in objects:
        printer.log(0,"")
        if not testMount.findObject(obj):
            printer.log(0,"%s located" % (obj,))
            coords = testMount.getCoordinates()
            targetRA = coords['RA J2000']
            targetDec = coords['DEC J2000']
            DMScoords = testMount.getAngleToDMS(targetRA)
            printer.log(0,"%s RA  (J2000) = %02.0fh %02.0fm %02.0fs" % \
                        (obj,DMScoords[0],DMScoords[1],DMScoords[2]))
            DMScoords = testMount.getAngleToDMS(targetDec)
            printer.log(0,"%s Dec (J2000) = %02.0fd %02.0f' %02.0f\"" % \
                        (obj,DMScoords[0],DMScoords[1],DMScoords[2]))
            psResults = testPlateSolve.execPlateSolve(testCamera,testMount,
                                                      obj,targetRA,targetDec,
                                                      printer,'test')
        else:
            printer.log(0,"%s could not be found." % obj)

    printer.logFooter()
    printer.blank()

In the unit test shown above, after importing the 'cLogger', 'cCamera', and 'cMount' modules, an instance of the class contained in each module is created. An instance of the 'cPlateSolver' class is then created and two object names are placed in a list. Next, a loop is entered that iterates through the object list. The first step of the loop is to find the object in the Sky6's database and, if found, extract the object's RA and Declination coordinates which are used as the target or intended coordinates. The 'execPlateSolve()' method of the 'cPlateSolver' object is then called with mode set to something other than 'Image'. This causes the plate solve image's name to be mangled by inserting '_test' in the middle of the file name. This is so as to not overwrite the actual plate solve image that is used to generate a successful plate solve after image acquisition. The process is then repeated for each object in the list.

TESTING THE CLASSES
Like in previous posts, before testing classes in this section, the Sky6 simulator must be manually connected to the telescope control system using the usual procedure. Also, the imaging and guide cameras in MaxIm DL should be first connected to the simulated cameras. The 'cPlateSolver' module can then be executed from the IDE in the normal manner. The source files described in this chapter can be downloaded from chapter_6.zip. Note: the .fit files included in the .zip must be placed in the same directory that the plate solve images are saved to.

As an additional exercise, edit the unit test for the 'cPlateSolver' module and completely remove the 'test' argument in the call to the 'execPlateSolve()' method then run the module. This will cause the plate solve image's name to NOT be mangled and will thus overwrite the real plate solve image included in the .zip file (so, you should make a copy of the actual .fit image prior to this test.). After the plate solve image is taken, the image generated from the simulator will be used for a plate solve. Obviously, this will fail but the manner of the failure is instructive. If the error message returned is 'Plate Solve Error: command failed. Error code = 206 (0xce).' this most likely means the RA and Declination coordinates of the center of the image were not placed into the FITS header of the plate solve image (look for keywords 'OBJCTRA' and 'OBJCTDEC'). Conversely, if the error message is 'Plate Solve Image link failed because there are not enough stars in the image. Try adjusting the image's background and range. Error code = 651 (0x28b).', this indicates that the image just can't be solved (and this is the expected behavior).

WHAT'S NEXT?
In the next post, I will present a new class that demonstrates the use of 'FocusMax' using MaxIm DL Pro. The module will include a unit test which can't be executed from in a simulator mode but must have real stars, real images, and a properly configured 'FocusMax' to execute successfully.

CLICK HERE FOR NEXT POST IN THIS SERIES

M5 - Globular Cluster Now In Color

2011-06-21T11:00:00.000-04:00

(Click image to go to info page)

As described in a previous post found here, the high-resolution (unbinned) luminance data for this showcase globular cluster was captured in early May 2011 from my favorite dark site at the Chiefland Astronomy Village. On my return trip to CAV in June 2011, I collected the low-resolution (binned 2x2) red, green, and blue data. Normally, I adjust the exposure times for each filter per results of manual G2V calibration that I performed when I first acquired the SBIG ST-8300M camera and then use 1/1/1 weighting when color combining. This time I used the same exposure (5-minutes) for each sub-frame for each filter then used the free application eXcalibrator to determine the RGB weighting for color combine. In short, it worked great! eXcalibrator found 13 G2V stars in the image field and from these determined a RGB weighting of 1.000/1.128/1.301 (very close to the results of my manual G2V calibration).

The color balance of the image above has not been manually adjusted from the initial color combine. Complete details regarding this image and more color images of M5 at various resolutions can be found by clicking on the image above or by clicking here.

Automated Astrophotography with Python - Part 5

2011-06-18T13:35:00.001-04:00

LOGGING TO A TEXT FILE
In previous posts all status messages have been sent only to the standard output (screen) and disappear when Python is closed. In this post I'll describe how to direct status messages to also appear in a permanent log file. In order to accomplish this, it is necessary to generate a new class named 'cLogger'. The listing for the 'cLogger' class is show below:

import time

##----------------------------------------------------------------------------
## Class: cLogger
##----------------------------------------------------------------------------
class cLogger:
    def __init__(self,filename):
        self.__filename = filename
        self.__level = 0
        self.__echo = True

    def log(self,level,value,echo=True):
        self.__level = level
        self.__echo = echo
        
        # echo to terminal with leading space if echo = True (default)
        if self.__echo:
            print " " + value
        # build the filename
        iDateTime = time.localtime()
        sDateStr = time.strftime('_%Y%m%d.log', iDateTime)
        # prepend spaces depending on log level (each additional level has two
        # spaces before text, for indenting)
        for i in range(level):
            value = "   " + value
        # build the full screen line including timestamp
        prefix = time.strftime("%H:%M:%S ", time.localtime(time.time()))
        if value.endswith("\n"):
            value = value[:-1]
        value = prefix + value
        # write all entries to detailed log file
        try:
            f = open (self.__filename[:-4] + sDateStr, "a")
            f.write(value)
            f.write("\n")
            f.close()
        except:
            print "Log: UNABLE TO WRITE TO LOG FILE:"
            print "Filename:", self.__filename[:-4] + sDateStr
            print "Log line:", value        

    def blank(self,echo=True):
        self.__echo = echo
        if self.__echo:
            print " "
        # build the filename
        iDateTime = time.localtime()
        sDateStr = time.strftime('_%Y%m%d.log', iDateTime)
        # write all entries to detailed log file
        try:
            f = open (self.__filename[:-4] + sDateStr, "a")
            f.write("\n")
            f.close()
        except:
            print "Log: UNABLE TO WRITE TO LOG FILE:"
            print "Filename:", self.__filename[:-4] + sDateStr

    def logHeader(self,strTitle):
        self.log(0,"")
        strVal = strTitle + " Log File"
        self.log(0,strVal,False)
        self.log(0,"",False)
        self.log(0,"*** START OF SCRIPT ***")

    def logFooter(self):
        self.log(0,"Script complete!")
        self.log(0,"*** END OF SCRIPT ***")
        self.log(0,"")

##
## END OF 'cLogger' Class
##

The constructor for 'cClass' is a short method that initializes class attributes. (Note: when an instance of the class is created, a complete path and filename must be provided to the class.) The 'log()' method is the routine that writes a status message to the logfile. The contents of the argument 'value' is the string text message that is logged. The 'level' argument determines the indentation level of the message and 'echo' determines whether the status message is also sent to the standard output (screen). The filename that is passed into the class is used as the base of the actual log filename. After the dot and three letter extension (ex. '.log') is removed, the remainder of the filename is appended with the year, month, day, and '.log' extension. Also, the text status message is prefixed with the local hour, minute, and second. The new filename is then opened in 'append' mode and the prefixed text message is written to the file with a carriage return character added to the end of the line. The file is then immediately closed to prevent inadvertent writes.

The 'blank()' method serves only to write a blank line (with no time-stamp on the line) to the log file. This method is used to separate logging of individual runs of a script. The final two methods, 'logHeader()' and 'logFooter()', write out pre-defined header and footer messages to the log file.

The unit test for this class demonstrates use of all methods in the 'cLogger' class and is shown below:

if __name__ == '__main__':

    # set up path and name of the logfile
    cLoggerLogFile = r"C:\Imaging_Scripts\logfiles\clogger.log"

    # instantiate the class with the path and name
    printer = cLogger(cLoggerLogFile)
    
    # print to logfile and to screen
    printer.logHeader('Unit Test for cLogger Class')
    printer.log(0,"Line 1 of status: no indentation")
    printer.log(1,"Line 2 of status: 2 spaces of indentation")
    printer.log(2,"Line 3 of status: 4 spaces of indentation")
    printer.log(3,"Line 4 of status: 6 spaces of indentation")
    # print to logfile only
    printer.log(2,"Line 5 of status: 4 spaces of indentation",False)
    # continue printing to logfile and to screen
    printer.log(1,"Line 6 of status: 2 spaces of indentation")
    printer.log(0,"Line 7 of status: no indentation")
    printer.logFooter()
    printer.blank()

LOGGING FROM WITHIN CLASSES
In order for status messages generated within classes to be logged, it is necessary to modify those classes to include calls to 'cLogger'. For example, shown below is the listing of affected methods in the 'cMount' class. The major change is that a 'cLogger' object is now passed as an argument into the methods that contain status message print statements. Then, in those arguments, the 'print' statement is changed to call the 'log()' method of the passed-in 'cLogger' object. Note that any messages that you wish to only show up on the screen should be left as normal Python 'print' statements. (Changes necessary to implement logging is shown in light cyan text.)

##------------------------------------------------------------------------------
## Class: cMount
##------------------------------------------------------------------------------
class cMount:
    def __init__(self,printlog):
        self.__info = {}
        self.__objectName = ''
        printlog.log(0,"Connecting to The Sky6...")
        self.__SKYCHART = win32com.client.Dispatch("TheSky6.StarChart")
        self.__SKYINFO = win32com.client.Dispatch("TheSky6.ObjectInformation")
        self.__UTIL = win32com.client.Dispatch("TheSky6.Utils")
        self.__MOUNT = win32com.client.Dispatch("TheSky6.RASCOMTele")

    def slewToObject(self,obj,printlog,delay=2.0):
        if not self.findObject(obj):
            coords = self.getCoordinates()
            printlog.log(0,"Slewing telescope to %s..." % obj)
            JnowRA = self.__UTIL.ConvertAngleToDMS(coords['RA Now'])
            printlog.log(0,"JNow RA : %02dh %02dm %0.2fs" % (JnowRA[0],
                                                             JnowRA[1],
                                                             JnowRA[2]))
            JnowDEC = self.__UTIL.ConvertAngleToDMS(coords['DEC Now'])
            printlog.log(0,"JNow DEC: %02d deg %02d' %0.2f\"" % (JnowDEC[0],
                                                                 JnowDEC[1],
                                                                 JnowDEC[2]))
            try:
                self.__MOUNT.SlewToRaDec(coords['RA Now'],coords['DEC Now'],obj)
            except:
                printlog.log(0,"ERROR: During slew to Object")
                return ERROR
            else:
                printlog.log(0,"Done slewing!")
                # delay (default = 2.0 seconds)
                time.sleep(delay)
                return NOERROR
        else:
            printlog.log(0,"%s could not be found." % obj)
            return ERROR

    def slewToAzAlt(self,azimuth,altitude,name,printlog,delay=2.0):
        printlog.log(0,"Slewing to Azimuth: %0.1f and Altitude: %0.1f..." % \
                     (azimuth,altitude))
        try:
            self.__MOUNT.SlewToAzAlt(azimuth,altitude,name)
        except:
            printlog.log(0,"ERROR: During slew to altitude/azimuth position")
            return ERROR
        else:
            printlog.log(0,"Done slewing!")
            # delay (default = 2.0 seconds)
            time.sleep(delay)
            return NOERROR

Additionally, the unit test for 'cMount' must be modified to implement the data logging feature. Here's the listing for the 'cMount' class unit test:

if __name__ == "__main__":
    
    import cLogger_5

    # set up path and name of the logfile
    cMountLogFile = r"C:\Imaging_Scripts\logfiles\cmount.log"

    # instantiate the class with the path and name
    printer = cLogger_5.cLogger(cMountLogFile)
    printer.logHeader('Unit Test for cMount Class')

    # create an instance of the cMount object
    testMount = cMount(printer)

    # prompt for name of object to locate
    print
    obj = raw_input(" Enter first object to slew to: ")
    # test slewToObject()
    testMount.slewToObject(obj,printer)

    # prompt for name of object to locate
    print
    obj = raw_input(" Enter second object to slew to: ")
    # test slewToObject()
    testMount.slewToObject(obj,printer)

    # prompt for name of object for sync
    print
    obj = raw_input(" Enter object to sync to: ")
    if not testMount.findObject(obj):
        coords = testMount.getCoordinates()
        # test syncToObject()
        printer.log(0,"Syncing control system to %s" % obj)
        testMount.syncToObject(coords['RA Now'],coords['DEC Now'],obj)
    else:
        printer.log(0,"%s could not be found." % obj)

    # prompt for azimuth and altitude for slew
    print
    azimuth = raw_input(" Enter azimuth for slew: ")
    azimuth = float(azimuth)
    altitude = raw_input(" Enter altitude for slew: ")
    altitude = float(altitude)

    # test slewToAzAlt()
    testMount.slewToAzAlt(azimuth,altitude,"park",printer)

    printer.logFooter()
    printer.blank()

In the unit test shown above, after importing the 'cLogger' module, an instance of the class named 'printer' is created. This object is then used in calls to methods of the 'cMount' class and to generate status messages for the unit test itself. The class listing and unit test for the 'cCamera' class has been similarly modified and included in the download files for this chapter.

TESTING THE CLASSES
Like in previous posts, before testing classes in this section, the Sky6 simulator must be manually connected to the telescope control system using the usual procedure. Also, the imaging and guide cameras in MaxIm DL should be first connected to the simulated cameras. The 'cLogger', 'cMount', and 'cCamera' classes can then be executed from the IDE in the normal manner. The source files described in this chapter can be downloaded from chapter_5.zip. Execute each unit test individually then inspect the generated log files to see that they are written as expected. Next, run each unit test again to verify that the log file is appended with new status messages for each run of the unit test.

WHAT'S NEXT?
In the next post, I will present a new class that implements plate solving using the Sky6 and CCDSoft. The class and unit test will also include a provision to perform a simulated test of the plate solve operation.

CLICK HERE FOR NEXT POST IN THIS SERIES

Automated Astrophotography with Python - Part 4

2011-06-15T12:20:00.009-04:00

USING AN INPUT TEXT FILE
In the previous post there was much user interaction required to choose all the possible options for setting up a simple imaging session. In this post, I'll show how I use an input text file that eliminates the need to make all the selections at run-time. Here is a sample of a typical input text file:

#
# Object Command Arguments: [0] = 'OBJECT'
#                           [1] = Object Name
Object m34
#
# Guidestar Command Arguments: [0] = 'GUIDESTAR'
#                              [1] = AUTO -or- MANUAL Guide Star Selection
#                              [2] = Exposure Length in sec. (Auto mode only)
Guidestar Auto 1.0
#
# Exposure Command Arguments: [0] = 'LIGHT'
#                             [1] = Filter (L,R,G,B,HA)
#                             [2] = Binning (Positive Integer)
#                             [3] = Exposure Length (Positive Float)
#                             [4] = No. of Images (Positive Integer)
#            
#
Light L 1 10.25 3
# Light B 2 584 1
# Light G 2 30 2
# Light R 2 357 1
# Other Parameters Command Arguments: [0] = 'OTHERS'
#                                     [1] = CCD Temperature (ex. '-20.0C' or 'Skip')
#                                     [2] = Warm CCD After Imaging? (Y/N)
#                                     [3] = Slew to Safe Position After 
#                                           Imaging? (Y/N)
Others -20C Y Y

A new class called 'cParser' has been created to parse the text file and strip out commands and the parameters associated with each command. The code listing of the 'cParser' class follows:

import sys
import string

INPUTPATH = "c:\\Imaging_Scripts\\input_files\\"
COMMANDS = ('OBJECT','LIGHT','OTHERS','GUIDESTAR')

ERROR = True
NOERROR = False

##------------------------------------------------------------------------------
## Class: cParser
##------------------------------------------------------------------------------
class cParser:
    def __init__(self):
        self.__cmdArgument = []

    def missing(self,filename):
        try:
            f = open(INPUTPATH + filename)
            f.close()
            return NOERROR
        except IOError:
            return ERROR

    def parseFile(self,filename):
        if not self.missing(filename):
            f = open(INPUTPATH + filename, "r")
            while True:
                setup = []
                text = f.readline()
                if text == "":
                    f.close()
                    break
                if text[0] == "#":
                    continue
                line = text.split(" ")
                if line[0].upper() not in COMMANDS:
                    print " ERROR: Invalid Command - %s" % line[0].upper()
                    f.close()
                    return None
                else:
                    for i in range(len(line)):
                        line[i] = line[i].replace('\n','')
                        setup.append(line[i].upper())
                self.__cmdArgument.append(setup)
            return self.__cmdArgument
        else:
            print " Error: Input file %s not found" % filename
            return None

##
## END OF 'cParser' Class
##

As shown in the listing, the expected path to the input text files is defined by the constant "INPUTPATH" and indicates I've chosen to create a sub-directory off of the main directory that holds all my Python classes and scripts. The next line defines a constant called 'COMMANDS' that is a tuple of all valid commands that the parser recognizes. The heart of the 'cParser' class is contained in the 'parseFile()' method. This method reads through the input file line-by-line while ignoring any lines that begins with a '#' character. The contents of a line containing a valid command is parsed using the 'split' string function where the splitting character is a space. The command and parameters associated with that command are built into a list which is then appended to the class attribute list '__cmdArgument'. This process repeats for each command that is found until a line is read containing an empty string. The empty string is considered an end-of-file character and terminates the parsing operation. At this point the contents of the class attribute '__cmdArgument' is passed back to the calling routine thus returning a list that contains lists of commands and parameters.

The following code is a listing of the unit test for this module. It simply prompts the user to enter a filename for the input file then parses the file and prints out lists of commands and parameters found in the file.

if __name__ == '__main__':

    # instantiate the class
    cmdFile = cParser()

    # prompt for the filename of the input command file
    print
    filename = raw_input("Enter input command filename: ")
    if not cmdFile.missing(filename):
        cmds = cmdFile.parseFile(filename)
    else:
        print "ERROR: Input command file not found"
        raise EnvironmentError, 'Halting program'
    print
    for cmdsAndParams in cmds:
        print cmdsAndParams
    print

The following is a listing of the script that demonstrates how to make use of the input text file.

import cMount_4
import cCamera_4
import cParser_4

filterDictionary = {'R':0,'G':1,'B':2,'L':3,'HA':4}

# create an instance of the mount and camera class
testMount = cMount_4.cMount()
testCamera = cCamera_4.cCamera()
cmdFile = cParser_4.cParser()

# get imaging location
print
print "The Sky6 location is %s" % testMount.getImagingLocation()

# prompt for the filename of the input command file
print
filename = raw_input("Enter input command filename: ")
if not cmdFile.missing(filename):
    cmds = cmdFile.parseFile(filename)
else:
    print "ERROR: Input command file not found"
    raise EnvironmentError, 'Halting program'

autoGuide = False
warmCCD = False
slewSafePosition = False
autoGuideStarSelect = False
print
if len(cmds) > 0:
    for stringcmd in cmds:
        if stringcmd[0] == 'OBJECT':
            obj = stringcmd[1]
            print "Object:     %s" % obj
        if stringcmd[0] == 'LIGHT':
            filterName = stringcmd[1]
            binning = stringcmd[2]
            exp = float(stringcmd[3])
            noImages = int(stringcmd[4])
            print "Filter:     %s" % filterName
            print "Binning:    %s" % binning
            print "Exposure:   %02.2f" % exp
            print "No. Images: %d" % noImages
        if stringcmd[0] == 'OTHERS':
            temp = stringcmd[1]
            print "CCD Temp:   %s" % temp
            if stringcmd[2] == 'Y':
                print "Warm CCD?:  Yes"
                warmCCD = True
            else:
                print "Warm CCD?:  No"
            if stringcmd[3] == 'Y':
                print "Slew to Safe Position?: Yes"
                slewSafePosition = True
            else:
                print "Slew to Safe Position?: No"
        if stringcmd[0] == 'GUIDESTAR':
            autoGuide = True
            if stringcmd[1] == 'AUTO':
                autoGuideStarSelect = True
                guideExp = float(stringcmd[2])

print
testCamera.setCCDTemp(temp)
testCamera.gotoCCDTemp()

print
if not testMount.findObject(obj):
    if testMount.checkObjectInWest():
        print "%s is west of the meridian" % obj
    else:
        print "%s is east of the meridian" % obj

    print
    times = testMount.getTimes()
    print "System Date = %s" % times['Date Now']
    print "System Time = %s" % times['Time Now']
    if times.has_key('Rise time'):
        hms = testMount.getAngleToDMS(times['Rise time'])
        print "%s rise time    = %02.0f:%02.0f:%02.0f" % (obj,hms[0],hms[1],
                                                          hms[2])
    if times.has_key('Transit time'):
        hms = testMount.getAngleToDMS(times['Transit time'])
        print "%s transit time = %02.0f:%02.0f:%02.0f" % (obj,hms[0],hms[1],
                                                          hms[2])
    if times.has_key('Set time'):
        hms = testMount.getAngleToDMS(times['Set time'])
        print "%s set time     = %02.0f:%02.0f:%02.0f" % (obj,hms[0],hms[1],
                                                          hms[2])
else:
    print "ERROR: Object not found"
    raise EnvironmentError, 'Halting program'

#begin test
print
if not testMount.slewToObject(obj):
    # Reset guide star positions for next test
    testCamera.resetGuideStar()
    print
    testCamera.setBinning(int(binning))
    testCamera.setFullFrame()
    fileName = "%s_%s_%sx%s" % (obj,filterName,binning,binning)
    if autoGuide:
        if autoGuideStarSelect:
            if testCamera.autoGuide(True,guideExp):
                testCamera.stopAutoGuide()
        else:
            if testCamera.autoGuide(False,0.0):
                testCamera.stopAutoGuide()
        # Make sure autoguider is running
        if testCamera.checkGuiderRunning():
            print
            for i in range(noImages):
                testCamera.exposeLight(exp,filterDictionary[filterName.upper()],
                                       fileName)
            # Stop autoguider after all images complete
            testCamera.stopAutoGuide()    
        else:
            print "ERROR - Autoguider not running as expected"
    else:
        print
        for i in range(noImages):
            testCamera.exposeLight(exp,filterDictionary[filterName.upper()],
                                   fileName)
else:
    print "ERROR: During slew to object"
    raise EnvironmentError, 'Halting program'

# warm the CCD to ambient
if warmCCD:
    print
    testCamera.warmCCD()

# slew to safe position
if slewSafePosition:
    print
    testMount.slewToAzAlt(90.0,75.0,"safe")

print
print "Script Complete!"

After importing the 'cCamera', 'cMount', and 'cParser' modules, each class is instantiated. The user is then prompted for the name of the input text file, its existence is verified by the 'missing()' method, and the file is parsed by the 'parseFile()' method. The next block of code strips out the parameters for each command and associates these parameters with local variables to be used throughout the remainder of the script. The next step is to set the CCD temperature and to wait for the CCD temperature to stabilize (unless 'skip' is specified). After finding the object to image in the Sky6 database, the scope is commanded to slew to the object. If the 'GUIDESTAR' command has been specified, autoguiding will then start with either automatic or manual guide star selection. Finally, after tracking errors have converged (if applicable), the images will be taken using the parameters found with the 'LIGHT' command. After all images are collected, the CCD temperature will be warmed back to ambient if the appropriate parameter is set in the 'OTHERS' command. Likewise, if the appropriate parameter is set, the scope will be commanded to slew to a hard-coded safe position (azimuth of 90 degrees, altitude of 75 degrees).

RUNNING THE SCRIPT
Like in the previous post, before executing this script the Sky6 simulator must be manually connected to the telescope control system using the usual procedure. Also, the imaging and guide cameras in MaxIm DL should be first connected to the simulated cameras. The python script can then be executed from the IDE in the normal manner. The source listing for files used by this script can be downloaded from chapter_4.zip. Experiment with the script by running it multiple times by editing and saving the input text file to select different commands and parameters. (Note: Leave off (or comment out using '#' character) the 'GUIDESTAR' command to perform imaging with no autoguiding.)

WHAT'S NEXT?
One deficiency with this script is all status messages only go to the screen. Ideally, it would be good to also echo status of the imaging session to a log file for later analysis. In the next post, I will present a new class that handles data logging with time-stamps on each message. Implementing this capability will also require some changes to the 'cCamera' and 'cMount' class modules.

CLICK HERE FOR NEXT POST IN THIS SERIES

Automated Astrophotography with Python - Part 3

2011-06-11T20:40:00.005-04:00

USING CLASSES
In this post, I'll demonstrate how to use the classes (cCamera and cMount) developed in previous posts to generate a practical script that slews to a given object then starts imaging with or without autoguiding. In order for the classes and scripts to work together correctly, there are a few initial steps to perform.

SETUP
The first step is to set up a local directory that will contain source code for classes and scripts. This directory can be set up anywhere on your hard drive but I prefer to locate this directory just off of the root directory of my C: drive. On my computer I have set up a directory named 'c:\imaging_scripts'. The classes and script that go with with this post (chapter_3.zip) should be copied to this directory. The second step is to set up Python so that it knows to look in this new directory. This is done my setting an environment variable called 'PYTHONPATH' with the path to the directory. These are the steps to set up 'PYTHONPATH' on a Windows 7 machine (setup on a Windows XP computer should be very similar):

Click 'Start' button
Right click on 'Computer' then click on 'Properties'
Click on 'Advanced system settings'
Click on the 'Environment Variables...' button
Under 'User variables for...' click the 'New...' button
In the 'Variable name:' field enter 'PYTHONPATH'
in the 'Variable value:' field enter 'C:\Python27;C:\imaging_scripts' or whatever name you used for your directory
Click the 'OK' button then reboot your computer
Test the path setup by loading the Python IDE. At the '>>>' prompt type 'import cMount_3'. If the IDE comes back with another '>>>' prompt without throwing an exception, the path is set up correctly.

A listing of the complete script that calls both the 'cMount' and 'cCamera' classes is given below:

import cMount_3
import cCamera_3

filterDictionary = {'R':0,'G':1,'B':2,'L':3,'HA':4}

# create an instance of the mount and camera class
testMount = cMount_3.cMount()
testCamera = cCamera_3.cCamera()

# get imaging location
print
print "The Sky6 location is %s" % testMount.getImagingLocation()


# prompt for CCD temperature (type 'skip' if no change to existing temp)
print
temp = raw_input("Enter CCD temperature (ex. '-20C','-5','skip'): ")
testCamera.setCCDTemp(temp)
testCamera.gotoCCDTemp()

# Test 1 - Slew and image with no autoguiding
# prompt for name of object to locate
print
obj = raw_input("Enter name of object to image: ")
if not testMount.findObject(obj):
    if testMount.checkObjectInWest():
        print "%s is west of the meridian" % obj
    else:
        print "%s is east of the meridian" % obj

    times = testMount.getTimes()
    print "System Date = %s" % times['Date Now']
    print "System Time = %s" % times['Time Now']
    if times.has_key('Rise time'):
        hms = testMount.getAngleToDMS(times['Rise time'])
        print "%s rise time    = %02.0f:%02.0f:%02.0f" % (obj,hms[0],hms[1],
                                                          hms[2])
    if times.has_key('Transit time'):
        hms = testMount.getAngleToDMS(times['Transit time'])
        print "%s transit time = %02.0f:%02.0f:%02.0f" % (obj,hms[0],hms[1],
                                                          hms[2])
    if times.has_key('Set time'):
        hms = testMount.getAngleToDMS(times['Set time'])
        print "%s set time     = %02.0f:%02.0f:%02.0f" % (obj,hms[0],hms[1],
                                                          hms[2])

# prompt for length of exposure
exp = raw_input("Enter length of exposure: ")
try:
    exp = float(exp)
except:
    print "ERROR: Invalid exposure length..."
    raise EnvironmentError, 'Halting program'

# prompt for binning of image
binning = raw_input("Enter binning for exposure (1/2/3): ")
if binning in ('1','2','3'):
    try:
        binmode = int(binning)
    except:
        print "ERROR: Invalid binning..."
        raise EnvironmentError, 'Halting program'

# prompt for number of exposures
noImages = raw_input("Enter the number of exposures: ")
try:
    noImages = int(noImages)
except:
    print "ERROR: Invalid number of images..."
    raise EnvironmentError, 'Halting program'

# prompt for filter
filterName = raw_input("Enter filter for exposures (L/R/G/B/Ha): ")
if not filterName.upper() in ('R','G','B','L','HA'):
    print "ERROR: Invalid filter designation..."
    raise EnvironmentError, 'Halting program'

# begin test
print
if not testMount.slewToObject(obj):
    testCamera.setBinning(binmode)
    testCamera.setFullFrame()
    fileName = "%s_%s_%sx%s" % (obj,filterName,binning,binning)
    for i in range(noImages):
        testCamera.exposeLight(exp,filterDictionary[filterName.upper()],
                               fileName)
else:
    print "ERROR: Object not found or error slewing to object"
    raise EnvironmentError, 'Halting program'


# Test 2 - Slew and image with autoguiding and auto guide star selection
# prompt for name of object to locate
print
obj = raw_input("Enter name of object to image: ")
if not testMount.findObject(obj):
    if testMount.checkObjectInWest():
        print "%s is west of the meridian" % obj
    else:
        print "%s is east of the meridian" % obj

    times = testMount.getTimes()
    print "System Date = %s" % times['Date Now']
    print "System Time = %s" % times['Time Now']
    if times.has_key('Rise time'):
        hms = testMount.getAngleToDMS(times['Rise time'])
        print "%s rise time    = %02.0f:%02.0f:%02.0f" % (obj,hms[0],hms[1],
                                                          hms[2])
    if times.has_key('Transit time'):
        hms = testMount.getAngleToDMS(times['Transit time'])
        print "%s transit time = %02.0f:%02.0f:%02.0f" % (obj,hms[0],hms[1],
                                                          hms[2])
    if times.has_key('Set time'):
        hms = testMount.getAngleToDMS(times['Set time'])
        print "%s set time     = %02.0f:%02.0f:%02.0f" % (obj,hms[0],hms[1],
                                                          hms[2])

# prompt for length of exposure
exp = raw_input("Enter length of exposure: ")
try:
    exp = float(exp)
except:
    print "ERROR: Invalid exposure length..."
    raise EnvironmentError, 'Halting program'

# prompt for binning of image
binning = raw_input("Enter binning for exposure (1/2/3): ")
if binning in ('1','2','3'):
    try:
        binmode = int(binning)
    except:
        print "ERROR: Invalid binning..."
        raise EnvironmentError, 'Halting program'

# prompt for number of exposures
noImages = raw_input("Enter the number of exposures: ")
try:
    noImages = int(noImages)
except:
    print "ERROR: Invalid number of images..."
    raise EnvironmentError, 'Halting program'

# prompt for filter
filterName = raw_input("Enter filter for exposures (L/R/G/B/Ha): ")
if not filterName.upper() in ('R','G','B','L','HA'):
    print "ERROR: Invalid filter designation..."
    raise EnvironmentError, 'Halting program'

#begin test
print
if not testMount.slewToObject(obj):
    # Start camera autoguiding with auto guide star select
    # Guide exposure = 2.0 second
    # Reset guide star positions for next test
    testCamera.resetGuideStar()
    if testCamera.autoGuide(True,2.0):
        testCamera.stopAutoGuide()
    # Make sure autoguider is running
    if testCamera.checkGuiderRunning():
        testCamera.setBinning(binmode)
        testCamera.setFullFrame()
        fileName = "%s_%s_%sx%s" % (obj,filterName,binning,binning)
        for i in range(noImages):
            testCamera.exposeLight(exp,filterDictionary[filterName.upper()],
                                   fileName)
        # Stop autoguider after all images complete
        testCamera.stopAutoGuide()    
    else:
        print "ERROR - Autoguider not running as expected"
else:
    print "ERROR: Object not found or error slewing to object"
    raise EnvironmentError, 'Halting program'

# Test 3 - Slew and image with autoguiding and manual guide star selection
# prompt for name of object to locate
print
obj = raw_input("Enter name of object to image: ")
if not testMount.findObject(obj):
    if testMount.checkObjectInWest():
        print "%s is west of the meridian" % obj
    else:
        print "%s is east of the meridian" % obj

    times = testMount.getTimes()
    print "System Date = %s" % times['Date Now']
    print "System Time = %s" % times['Time Now']
    if times.has_key('Rise time'):
        hms = testMount.getAngleToDMS(times['Rise time'])
        print "%s rise time    = %02.0f:%02.0f:%02.0f" % (obj,hms[0],hms[1],
                                                          hms[2])
    if times.has_key('Transit time'):
        hms = testMount.getAngleToDMS(times['Transit time'])
        print "%s transit time = %02.0f:%02.0f:%02.0f" % (obj,hms[0],hms[1],
                                                          hms[2])
    if times.has_key('Set time'):
        hms = testMount.getAngleToDMS(times['Set time'])
        print "%s set time     = %02.0f:%02.0f:%02.0f" % (obj,hms[0],hms[1],
                                                          hms[2])
        
# prompt for length of exposure
exp = raw_input("Enter length of exposure: ")
try:
    exp = float(exp)
except:
    print "ERROR: Invalid exposure length..."
    raise EnvironmentError, 'Halting program'

# prompt for binning of image
binning = raw_input("Enter binning for exposure (1/2/3): ")
if binning in ('1','2','3'):
    try:
        binmode = int(binning)
    except:
        print "ERROR: Invalid binning..."
        raise EnvironmentError, 'Halting program'

# prompt for number of exposures
noImages = raw_input("Enter the number of exposures: ")
try:
    noImages = int(noImages)
except:
    print "ERROR: Invalid number of images..."
    raise EnvironmentError, 'Halting program'

# prompt for filter
filterName = raw_input("Enter filter for exposures (L/R/G/B/Ha): ")
if not filterName.upper() in ('R','G','B','L','HA'):
    print "ERROR: Invalid filter designation..."
    raise EnvironmentError, 'Halting program'

# begin test
print
if not testMount.slewToObject(obj):
    # Start camera autoguiding with manual guide star select
    # Reset guide star positions for next test
    testCamera.resetGuideStar()
    if testCamera.autoGuide(False,0.0):
        testCamera.stopAutoGuide()
    # Make sure autoguider is running
    if testCamera.checkGuiderRunning():
        testCamera.setBinning(binmode)
        testCamera.setFullFrame()
        fileName = "%s_%s_%sx%s" % (obj,filterName,binning,binning)
        for i in range(noImages):
            testCamera.exposeLight(exp,filterDictionary[filterName.upper()],
                                   fileName)
        # Stop autoguider after all images complete
        testCamera.stopAutoGuide()    
    else:
        print "ERROR - Autoguider not running as expected"
else:
    print "ERROR: Object not found or error slewing to object"
    raise EnvironmentError, 'Halting program'

# warm the CCD to ambient
print
testCamera.warmCCD()

print
print "Script Complete!"

The first two lines of the script contain the import statements that reference the filenames (less the .py extension) containing the 'cMount' and 'cCamera' classes. At this point, instances of the two class are created and a dictionary is set up that indexes a letter or string representing the filter to the filter wheel slot number. Next, the current Sky6 location is printed then the user is prompted to enter a CCD temperature (enter 'skip' if no temperature change is desired). After setting the temperature and waiting for it to stabilize, the script begins the first of three tests.

The first test begins by prompting the user for the name of an object. If the object is located in the Sky6 database, the data related to the object (side of meridian, current date/time, rise/transit/set times) are printed to screen. The user is then prompted to enter the length of the exposure, the binning, the number of exposures, and the filter to be used. The testing then begins by commanding a slew to the object then the images are collected per user inputs with no autoguiding enabled. For the second test, the first test is repeated similarly but this time the images are collected with autoguiding and auto guide star selection (2.0 second guide exposures) enabled. The third test is identical to the first two tests except that autoguiding is enable with manual guide star selection.

RUNNING THE SCRIPT
Before executing this script, the Sky6 simulator must be manually connected to the telescope control system using the same procedure as described in the previous post. Also, the imaging and guide cameras in MaxIm DL should be first connected to the simulated cameras. The python script can then be executed from the IDE in the normal manner. The source listing for files used by this script can be downloaded from chapter_3.zip. Experiment with the script by running it multiple times and selecting different objects for The Sky6 to locate, slew to, and image.

WHAT'S NEXT?
One problem with this script is the repetitive and error-prone requirement to have the user manually enter object name, binning, exposure length, etc. for each test. In the next post, I will develop a new class that will allow this information to be read from an input text file. This will be a necessary feature to facilitate full automation of the imaging process.

CLICK HERE FOR NEXT POST IN THIS SERIES

Automated Astrophotography with Python - Part 2c

2011-06-09T19:49:00.003-04:00

TELESCOPE CONTROL
The last features to add to the 'cMount' class are the ability to control pointing of the telescope and to synchronize the control system to a particular point in the sky. All these functions are found in the RASCOMTele class of the Sky6. As in previous posts, instead of showing the complete 'cMount' class listing, here I show only the changes to the listing presented in the previous post. The first listing shows the one new line that must be added to the class constructor ('__init__' method) to create an instance of the Sky6 RASCOMTele class. Here is the listing for that change:

self.__MOUNT = win32com.client.Dispatch("TheSky6.RASCOMTele")

The next listing shows the three new methods added to 'cMount' that call methods from the Sky6 RASCOMTele class:

def slewToObject(self,obj,delay=2.0):
    if not self.findObject(obj):
        coords = self.getCoordinates()
        print "Slewing telescope to %s..." % obj
        JnowRA = self.__UTIL.ConvertAngleToDMS(coords['RA Now'])
        print "JNow RA : %02dh %02dm %0.2fs" % (JnowRA[0],JnowRA[1],
                                                JnowRA[2])
        JnowDEC = self.__UTIL.ConvertAngleToDMS(coords['DEC Now'])
        print "JNow DEC: %02d deg %02d' %0.2f\"" % (JnowDEC[0],JnowDEC[1],
                                                    JnowDEC[2])
        try:
            self.__MOUNT.SlewToRaDec(coords['RA Now'],coords['DEC Now'],obj)
        except:
            print "ERROR: During slew to Object"
            return ERROR
        else:
            print "Done slewing!"
            # delay (default = 2.0 seconds)
            time.sleep(delay)
            return NOERROR
    else:
        print "%s could not be found." % obj
        return ERROR
    

def slewToAzAlt(self,azimuth,altitude,name,delay=2.0):
    print "Slewing to Azimuth: %0.1f and Altitude: %0.1f..." % (azimuth,
                                                                altitude)
    try:
        self.__MOUNT.SlewToAzAlt(azimuth,altitude,name)
    except:
        print "ERROR: During slew to altitude/azimuth position"
        return ERROR
    else:
        print "Done slewing!"
        # delay (default = 2.0 seconds)
        time.sleep(delay)
        return NOERROR

def syncToObject(self,RA,Dec,Obj):
    self.__MOUNT.Sync(RA,Dec,Obj)

The first new method is 'slewToObject()'. This method attempts to locate the object in the Sky6's database. If successful, the current epoch equatorial coordinates are extracted and printed to screen. The method then calls the 'RASCOMTele' method 'SlewToRaDec()' in a try, except, else block to trap any exceptions. After the slew completes, a delay (default of 2 sec) is entered before the method returns to the calling routine. Similarly, the 'slewToAzAlt()' method calls the 'RASCOMTele' method 'SlewToAzAlt()' in a try, except, else block again to trap any exceptions. The final new method is 'syncToObject()' and calls the 'Sync()' method of 'RASCOMTele' to synchronize the control system to the specified coordinates.

cMOUNT UNIT TEST
The following listing shows the unit test code for this version of the 'cMount' class. After creating an instance of the class, the user is prompted to enter the name of an object. If a valid object name is entered, the simulator is commanded to slew to the object. This test is then repeated for a second object. Next, the user is prompted to enter the name of another object. This object is then located in the database and the telescope control system is synced to the location of that object. (The telescope pointing "bull's eye" jumps to the location of the object.) Finally, the user is prompted to enter azimuth and altitude values. Assuming valid values have been entered, the simulator will slew to the location specified by the entered azimuth and altitude.

if __name__ == "__main__":
    
    # create an instance of the cMount object
    testMount = cMount()

    # prompt for name of object to locate
    print
    obj = raw_input("Enter first object to slew to: ")
    # test slewToObject()
    testMount.slewToObject(obj)

    # prompt for name of object to locate
    print
    obj = raw_input("Enter second object to slew to: ")
    # test slewToObject()
    testMount.slewToObject(obj)

    # prompt for name of object for sync
    print
    obj = raw_input("Enter object to sync to: ")
    if not testMount.findObject(obj):
        coords = testMount.getCoordinates()
        # test syncToObject()
        print "Syncing control system to %s" % obj
        testMount.syncToObject(coords['RA Now'],coords['DEC Now'],obj)
    else:
        print "%s could not be found." % obj

    # prompt for azimuth and altitude for slew
    print
    azimuth = raw_input("Enter azimuth for slew: ")
    azimuth = float(azimuth)
    altitude = raw_input("Enter altitude for slew: ")
    altitude = float(altitude)

    # test slewToAzAlt()
    testMount.slewToAzAlt(azimuth,altitude,"park")

RUNNING THE SCRIPT
In order to test this version of the 'cMount' class you must first load the Sky6 and manually connect the telescope control system to the simulator. This is done by clicking on the 'Telescope' pull-down menu tab then selecting the 'Setup...' option. In the 'Telescope Setup' dialog box, select 'Simulator' in the selection box under 'Name:'. Click on the 'Close' button then re-click the 'Telescope' pull-down menu tab then select the 'Server Settings...' option. In the 'Server Settings' dialog box, make sure the 'Allow sync' and 'Allow goto' boxes are checked then click the 'OK' button. (Note: the changes to the 'Telescope Setup' and 'Server Settings' dialog boxes only need to be made the first time the simulator is used.) The connection to the simulator is then made by clicking on the 'Telescope' pull-down menu tab then hovering over the 'Link' option. Move the mouse pointer over to and click on 'Establish' to make the connection. (You can also just click on the green telescope icon on the menu bar.) After a moment, the white bull's eye will appear that indicates the current location of the scope control system. The python script can now be executed from the IDE in the normal manner. The source listing for 'cMount' can be downloaded from cMount_2c.zip. Experiment with the script by running it multiple times and selecting different objects for The Sky6 to locate, slew to, and sync to. (When testing is complete, click on the red telescope icon the menu bar to terminate the connection.)

WHAT'S NEXT?
This post completes discussion of the 'cMount' class (although additional methods may be added to the class in later posts). In the next post, I will create a script that creates an instance of the 'cMount' class and an instance of the 'cCamera' class to demonstrate how these classes can be used in combination to generate practical scripts for slewing and imaging of objects.

CLICK HERE FOR NEXT POST IN THIS SERIES

Automated Astrophotography with Python - Part 2b

2011-06-08T10:00:00.004-04:00

THE SKY6 UTILITIES
The next major functionality to add to the 'cMount' class is the ability to perform various calculations related to equatorial coordinates. All these functions are found in the UTILS class of the Sky6. As in previous posts, instead of showing the complete 'cMount' class listing, here I show only the changes to the listing presented in the previous post. The first listing shows the one new line that must be added to the class constructor ('__init__' method) to create an instance of the Sky6 UTILS class. Here is the listing for that change:

self.__UTIL = win32com.client.Dispatch("TheSky6.Utils")

The next listing shows the six new methods added to 'cMount' that call methods from the Sky6 UTILS class:

def getAngularSeparation(self,RA1,Dec1,RA2,Dec2):
    """Returns results of "ComputeAngularSeparation" method of UTILS"""
    return self.__UTIL.ComputeAngularSeparation(RA1,Dec1,RA2,Dec2)
    
def getPositionAngle(self,RA1,Dec1,RA2,Dec2):
    """Returns results of "ComputePositionAngle" method of UTILS"""
    return self.__UTIL.ComputePositionAngle(RA1,Dec1,RA2,Dec2)

def getAngleToDMS(self,angle):
    """Returns results of "ConvertAngleToDMS" method of UTILS"""
    return self.__UTIL.ConvertAngleToDMS(angle)

def get2000ToNow(self,RA,Dec):
    """Returns results of "Precess2000ToNow" method of UTILS"""
    return self.__UTIL.Precess2000ToNow(RA,Dec)

def getNowTo2000(self,RA,Dec):
    """Returns results of "PrecessNowTo2000" method of UTILS"""
    return self.__UTIL.PrecessNowTo2000(RA,Dec)

def getRADecToAzAlt(self,RA,Dec):
    """Returns results of "ConvertRADecToAzAlt" method of UTILS"""
    return self.__UTIL.ConvertRADecToAzAlt(RA,Dec)

The first two methods are used to compute the angular separation (in degrees) between two equatorial coordinates and to compute the position angle (measured counter-clockwise from true North) from one coordinate to the other. The method 'getAngleToDMS()' is used to compute the degrees, minutes, and seconds from an angle expressed as a float value. The next two methods are used to precess an equatorial coordinate between the current epoch and the year 2000 epoch or vice-versa. Finally, the 'getRADecToAzAlt()' method is used to generate altitude and azimuth for the Sky6's current time and location from an equatorial coordinate. Many more methods are available in the UTILS class and descriptions can be found in the Sky6's help section under 'Scripted Operation'.

cMOUNT UNIT TEST
The following listing shows the unit test code for this version of the 'cMount' class. After creating an instance of the class, the test attempts to locate 'Pollux' in the database. If successful, the equatorial coordinates for the star are found and the RA and Dec for both the current epoch and for the year 2000 epoch are printed out in Hours or Degrees, minutes, and seconds. This operation is repeated for 'Castor' then the separation and position angle between the two stars is found and printed to screen. Next, the object 'M95' is located and the the RA and DEC (epoch 2000) is found and printed to screen. The current epoch coordinates is then found and printed using the 'get2000ToNow()' method. The object's altitude and azimuth is then computed and printed out. As a final test the object 'M65' is located and the the RA and DEC (current epoch) is found and printed. The year 2000 epoch coordinates is then found and printed using the 'getNowTo2000()' method. The object's altitude and azimuth is then computed and printed out.

if __name__ == "__main__":
    
    # create an instance of the cMount object
    testMount = cMount()

    # test getAngleToDMS()
    obj1 = 'Pollux'
    if not testMount.findObject(obj1):
        coords1 = testMount.getCoordinates()
        print
        DMScoords = testMount.getAngleToDMS(coords1['RA Now'])
        print "%s RA  (current epoch) = %02.0fh %02.0fm %03.1fs" % (obj1,
                DMScoords[0],DMScoords[1],DMScoords[2])
        DMScoords = testMount.getAngleToDMS(coords1['DEC Now'])
        print "%s Dec (current epoch) = %02.0fd %02.0f' %03.1f\"" % (obj1,
                DMScoords[0],DMScoords[1],DMScoords[2])
        DMScoords = testMount.getAngleToDMS(coords1['RA J2000'])
        print "%s RA     (epoch 2000) = %02.0fh %02.0fm %03.1fs" % (obj1,
                DMScoords[0],DMScoords[1],DMScoords[2])
        DMScoords = testMount.getAngleToDMS(coords1['DEC J2000'])
        print "%s Dec    (epoch 2000) = %02.0fd %02.0f' %03.1f\"" % (obj1,
                DMScoords[0],DMScoords[1],DMScoords[2])
    else:
        print "%s could not be found." % obj1

    obj2 = 'Castor'
    if not testMount.findObject(obj2):
        coords2 = testMount.getCoordinates()
        print
        DMScoords = testMount.getAngleToDMS(coords2['RA Now'])
        print "%s RA  (current epoch) = %02.0fh %02.0fm %03.1fs" % (obj2,
                DMScoords[0],DMScoords[1],DMScoords[2])
        DMScoords = testMount.getAngleToDMS(coords2['DEC Now'])
        print "%s Dec (current epoch) = %02.0fd %02.0f' %03.1f\"" % (obj2,
                DMScoords[0],DMScoords[1],DMScoords[2])
        DMScoords = testMount.getAngleToDMS(coords2['RA J2000'])
        print "%s RA     (epoch 2000) = %02.0fh %02.0fm %03.1fs" % (obj2,
                DMScoords[0],DMScoords[1],DMScoords[2])
        DMScoords = testMount.getAngleToDMS(coords2['DEC J2000'])
        print "%s Dec    (epoch 2000) = %02.0fd %02.0f' %03.1f\"" % (obj2,
                DMScoords[0],DMScoords[1],DMScoords[2])
    else:
        print "%s could not be found." % obj2

    # test getAngularSeparation()
    separation = testMount.getAngularSeparation(coords1['RA Now'],
                    coords1['DEC Now'],coords2['RA Now'],coords2['DEC Now'])
    separation = testMount.getAngleToDMS(separation)
    print
    print "The separation between %s and %s is %02.0f deg %02.0f min" % \
          (obj1,obj2,separation[0],separation[1])

    # test getPositionAngle()
    angle = testMount.getPositionAngle(coords2['RA Now'],coords2['DEC Now'],
                                       coords1['RA Now'],coords1['DEC Now'])
    angle = testMount.getAngleToDMS(angle)
    print
    print "The postion angle from %s to %s is %02.0f deg %02.0f min" % \
          (obj1,obj2,angle[0],angle[1])

    obj1 = 'm95'
    if not testMount.findObject(obj1):
        # test get2000ToNow()
        coords1 = testMount.getCoordinates()
        print
        DMScoords = testMount.getAngleToDMS(coords1['RA J2000'])
        print "%s RA     (epoch 2000) = %02.0fh %02.0fm %02.0fs" % (obj1,
                DMScoords[0],DMScoords[1],DMScoords[2])
        DMScoords = testMount.getAngleToDMS(coords1['DEC J2000'])
        print "%s Dec    (epoch 2000) = %02.0fd %02.0f' %02.0f\"" % (obj1,
                DMScoords[0],DMScoords[1],DMScoords[2])


        coords2 = testMount.get2000ToNow(coords1['RA J2000'],coords1['DEC J2000'])
        DMScoords = testMount.getAngleToDMS(coords2[0])
        print "%s RA  (current epoch) = %02.0fh %02.0fm %02.0fs" % (obj1,
                DMScoords[0],DMScoords[1],DMScoords[2])
        DMScoords = testMount.getAngleToDMS(coords2[1])
        print "%s Dec (current epoch) = %02.0fd %02.0f' %02.0f\"" % (obj1,
                DMScoords[0],DMScoords[1],DMScoords[2])

        # test getRADecToAzAlt()
        print
        azAlt = testMount.getRADecToAzAlt(coords1['RA J2000'],
                                          coords1['DEC J2000'])
        azimuth = testMount.getAngleToDMS(azAlt[0])
        print "%s Azimuth  = %02.0fd %02.0fm %02.0fs" % (obj1,
                azimuth[0],azimuth[1],azimuth[2])
        altitude = testMount.getAngleToDMS(azAlt[1])
        print "%s Altitude = %02.0fd %02.0fm %02.0fs" % (obj1,
                altitude[0],altitude[1],altitude[2])
        print
    else:
        print "%s could not be found." % obj1

    obj2 = 'm65'
    if not testMount.findObject(obj2):
        # test getNowTo2000()
        coords1 = testMount.getCoordinates()
        print
        DMScoords = testMount.getAngleToDMS(coords1['RA Now'])
        print "%s RA  (current epoch) = %02.0fh %02.0fm %02.0fs" % (obj2,
                DMScoords[0],DMScoords[1],DMScoords[2])
        DMScoords = testMount.getAngleToDMS(coords1['DEC Now'])
        print "%s Dec (current epoch) = %02.0fd %02.0f' %02.0f\"" % (obj2,
                DMScoords[0],DMScoords[1],DMScoords[2])


        coords2 = testMount.getNowTo2000(coords1['RA Now'],coords1['DEC Now'])
        DMScoords = testMount.getAngleToDMS(coords2[0])
        print "%s RA     (epoch 2000) = %02.0fh %02.0fm %02.0fs" % (obj2,
                DMScoords[0],DMScoords[1],DMScoords[2])
        DMScoords = testMount.getAngleToDMS(coords2[1])
        print "%s Dec    (epoch 2000) = %02.0fd %02.0f' %02.0f\"" % (obj2,
                DMScoords[0],DMScoords[1],DMScoords[2])

        # test getRADecToAzAlt()
        print
        azAlt = testMount.getRADecToAzAlt(coords2[0],coords2[1])
        azimuth = testMount.getAngleToDMS(azAlt[0])
        print "%s Azimuth  = %02.0fd %02.0fm %02.0fs" % (obj2,
                azimuth[0],azimuth[1],azimuth[2])
        altitude = testMount.getAngleToDMS(azAlt[1])
        print "%s Altitude = %02.0fd %02.0fm %02.0fs" % (obj2,
                altitude[0],altitude[1],altitude[2])
        print
    else:
        print "%s could not be found." % obj2

RUNNING THE SCRIPT
As before, testing this version of the 'cMount' class is simply a matter of loading the source code into the Python IDE and running the module by hitting the F5 key. If the Sky6 is not already running, it will be loaded before the unit test executes. The source listing for 'cMount' can be downloaded from cMount_2b.zip. Experiment with the script by running it multiple times and selecting different objects for The Sky6 to locate and display information about.

WHAT'S NEXT?
In the next post I will complete the 'cMount' class by introducing methods that allow the script to control pointing of the telescope and syncing the the scope with a particular point in the sky. I will also create a new unit test listing to verify correct operation of the features added to this class.

CLICK HERE FOR NEXT POST IN THIS SERIES

Automated Astrophotography with Python - Part 2a

2011-05-31T21:07:00.004-04:00

THE cMOUNT CLASS
The next piece of code we will look at is the 'cMount' class. This class will interact with various objects exposed by The Sky6 planetarium and telescope control software. The Python code for 'cMount' is shown below. (Note: Docstrings have been removed from this listing for brevity and readability purposes.)

import time
import win32com.client

ERROR = True
NOERROR = False

##------------------------------------------------------------------------------
## Class: cMount
##------------------------------------------------------------------------------
class cMount:
    def __init__(self):
        self.__info = {}
        self.__objectName = ''
        print "Connecting to The Sky6..."
        self.__SKYCHART = win32com.client.Dispatch("TheSky6.StarChart")
        self.__SKYINFO = win32com.client.Dispatch("TheSky6.ObjectInformation")

    def findObject(self,objToFind):
        self.__objectName = objToFind
        if len(self.__objectName) > 0:
            try:
                self.__SKYCHART.Find(self.__objectName)
                for index in range(189):
                    skyProperty = self.__SKYINFO.Property(index)
                    if self.__SKYINFO.PropertyApplies(index):
                        self.__info[self.__SKYINFO.PropertyName(index)] = \
                                    skyProperty
                return NOERROR     
            except:
                return ERROR
        
    def getCoordinates(self):
        raDec = {}
        if self.__info.has_key('RA (current epoch)'):
            raDec['RA Now'] = self.__info['RA (current epoch)']
        if self.__info.has_key('Dec (current epoch)'):
            raDec['DEC Now'] = self.__info['Dec (current epoch)']
        if self.__info.has_key('RA (epoch 2000)'):
            raDec['RA J2000'] = self.__info['RA (epoch 2000)']
        if self.__info.has_key('Dec (epoch 2000)'):
            raDec['DEC J2000'] = self.__info['Dec (epoch 2000)']
        return raDec
    
    def getAltAzimuth(self):
        altAzimuth = {}
        if self.__info.has_key('Altitude'):
            altAzimuth['Altitude'] = self.__info['Altitude']
        if self.__info.has_key('Azimuth'):
            altAzimuth['Azimuth'] = self.__info['Azimuth']
        return altAzimuth
        
    def getTimes(self):
        objTimes = {}
        if self.__info.has_key('Date'):
            objTimes['Date Now'] = self.__info['Date']
        if self.__info.has_key('Time'):
            objTimes['Time Now'] = self.__info['Time']
        if self.__info.has_key('Transit time'):
            objTimes['Transit time'] = self.__info['Transit time']
        if self.__info.has_key('Rise time'):
            objTimes['Rise time'] = self.__info['Rise time']
        if self.__info.has_key('Set time'):
            objTimes['Set time'] = self.__info['Set time']
        return objTimes
        
    def getImagingLocation(self):
        return self.__SKYCHART.DocumentProperty(63)

    def checkObjectInWest(self):
        azimuth = self.getAltAzimuth()['Azimuth']
        if azimuth >= 180.00 and azimuth < 360.00:
            return True
        else:
            return False

##
##    END OF 'cMount' Class
##

The first two lines of the listing are the same 'import' statements that we saw in the 'cCamera' class. The listing for the 'cMount' class follows the 'import' statements and consists of seven methods. The '__init__' method is the constructor for 'cMount' and is executed whenever an instance of the 'cMount' object is created. This method creates a class attribute '__info' which is initialized as an empty dictionary data structure and '__objName' which will hold a string representation of the object that The Sky6 will find. This method also creates a '__SKYCHART' object that is bound to the Sky6's 'Skychart' object and a '__SKYINFO' object that is bound to the Sky6's 'Skyinfo' object. (See help for The Sky6 under scripting for more information regarding attributes and methods relating to these two objects.)

The next method is 'findObject' which takes as an argument the string representation of the object to find. After making sure the string 'objToFind' is not empty, the Sky6's 'Find' method is used to actually locate the object in its database. If the object is found, the remainder of the method loads all of the properties relating to that object into the '__info' dictionary. The contents of this dictionary will be used by most of the remaining methods of the 'cMount' class.

The next method, 'getCoordinates', strips out the RA and Declination information from the '__info' dictionary and builds a new dictionary called 'raDec' to hold this data. Likewise, the 'getAltAzimuth' and 'getTimes' methods similarly strip relevant information from the '__info' dictionary and build new dictionaries called 'altAzimuth' and 'objTimes' respectively.

Finally, the 'getImagingLocation' method extracts the current location in use by the Sky6's planetarium and returns it to the calling routine. Also, the 'checkObjectInWest' method uses the 'getAltAzimuth' method to determine if the located object is in the eastern or western sky. It returns TRUE if the object is in the western sky and FALSE if the object is in the eastern sky.

cMOUNT UNIT TEST
The following listing shows the unit test code for this version of the 'cMount' class. After creating an instance of the class, the user is prompted to enter an object for The Sky6 to locate. The test then prints out the current location for The Sky6 then locates the object in its database (or returns an error if it cannot be located.) Next, the script checks whether the object is in the eastern or western sky then prints out the current system time and date before printing out the object's rise, transit, and set times (or transit time only for circumpolar objects). The object's RA and Declination for the current epoch and for the year 2000 epoch are then printed. Finally, the 'getAltAzimuth' method is called and the object's current altitude and azimuth are printed to screen.

if __name__ == "__main__":
    
    # create an instance of the cMount object
    testMount = cMount()

    # prompt for name of object to locate
    print
    obj = raw_input("Enter object to find: ")
    
    # test getImagingLocation method
    print
    print "The Sky6 Location: %s" % testMount.getImagingLocation()

    # test findObject method
    print
    if not testMount.findObject(obj):
        # test checkObjectInWest method
        if testMount.checkObjectInWest():
            print "%s is west of the meridian" % obj
        else:
            print "%s is east of the meridian" % obj

        # test getTimes function
        times = testMount.getTimes()
        print "System Date = %s" % times['Date Now']
        print "System Time = %s" % times['Time Now']
        if times.has_key('Rise time'):
            print "%s rise time    = %0.3f" % (obj,times['Rise time'])
        if times.has_key('Transit time'):
            print "%s transit time = %0.3f" % (obj,times['Transit time'])
        if times.has_key('Set time'):
            print "%s set time     = %0.3f" % (obj,times['Set time'])
        
        # test getCoordinates function
        coords = testMount.getCoordinates()
        print
        print "%s RA  (current epoch) = %0.3f" % (obj,coords['RA Now'])
        print "%s Dec (current epoch) = %0.3f" % (obj,coords['DEC Now'])
        print "%s RA  (epoch 2000)    = %0.3f" % (obj,coords['RA J2000'])
        print "%s Dec (epoch 2000)    = %0.3f" % (obj,coords['DEC J2000'])
        
        # test getAltAzimuth function
        altazi = testMount.getAltAzimuth()
        print
        print "%s Altitude = %0.3f" % (obj,altazi['Altitude'])
        print "%s Azimuth  = %0.3f" % (obj,altazi['Azimuth'])
        print
    else:
        print "%s could not be found." % obj

RUNNING THE SCRIPT
Testing this version of the 'cMount' class is simply a matter of loading the source code into the Python IDE and running the module by hitting the F5 key. If the Sky6 is not already running, it will be loaded before the unit test executes. The source listing for 'cMount' can be downloaded from cMount_2a.zip. Experiment with the script by running it multiple times and selecting different objects for The Sky6 to locate and display information about.

WHAT'S NEXT?
In the next post I will continue to expand the 'cMount' class by introducing more methods and properties that utilize planetarium and telescope control features of the Sky6. I will also create a new unit test listing to verify correct operation of the features added to this class.

CLICK HERE FOR NEXT POST IN THIS SERIES

Automated Astrophotography with Python - Part 1d

2011-05-28T06:15:00.008-04:00

AUTOGUIDING
The last major functionality to add to the 'cCamera' class is the ability to perform autoguiding during long exposures. Instead of showing the complete 'cCamera' class listing as I have in previous posts, here I show the new attributes and methods that must be added to the 'cCamera' class that I've built up so far. The first listing shows the new class attributes.

self.__guideStarXPos = 0 # x-coordinate of guide star
self.__guideStarYPos = 0 # y-coordinate of guide star
self.__guideExposure = 1.0 # default guide exposure in seconds
self.__guideSettleLimit = 0.40 # max pixel error before imaging can occur
self.__guideSettleMaxTime = 120 # max time for autoguider to settle

The first two attributes contain the x- and y-coordinates of the guide star that will be used for autoguiding and the attribute '__guideExposure' specifies the length of exposure for each guide image. The attribute '__guideSettleLimit' sets the limit which the guide errors must fall under before an image exposure will start. (ex. In this case, guide errors for both axes must settle under 0.40 pixels before an image exposure will begin.) The '__guideSettleMaxTime' attribute holds the maximum number of seconds allowed for the guide errors to settle under '__guideSettleLimit'.

The next listing shows the new methods added to the 'cCamera' class.

def autoGuide(self,autoGuideStar,exposure):
    if autoGuideStar:
        self.__CAMERA.GuiderAutoSelectStar = True
        if self.__guideStarYPos == 0 or self.__guideStarYPos == 0:
            self.__guideExposure = exposure
            if self.exposeGuider(self.__guideExposure):
                return ERROR
            self.__guideStarXPos = self.__CAMERA.GuiderXStarPosition
            self.__guideStarYPos = self.__CAMERA.GuiderYStarPosition
            print
            print "Guider Setup:"
            print "Guider:                %s" % self.__CAMERA.GuiderName
            print "Guide star selection:  Auto"
            print "Guide star exposure:   %0.2f" % self.__guideExposure
            print "Aggressiveness X-Axis: %0.2f" % \
                   self.__CAMERA.GuiderAggressivenessX
            print "Aggressiveness Y-Axis: %0.2f" % \
                   self.__CAMERA.GuiderAggressivenessY
            print "Max Move X-Axis:       %0.2f" % self.__CAMERA.GuiderMaxMoveX
            print "Max Move Y-Axis:       %0.2f" % self.__CAMERA.GuiderMaxMoveY
            print "Min Move X-Axis:       %0.2f" % self.__CAMERA.GuiderMinMoveX
            print "Min Move Y-Axis:       %0.2f" % self.__CAMERA.GuiderMinMoveY
    else:
        self.__CAMERA.GuiderAutoSelectStar = False
        ## if necessary, set up the guider for autoguiding
        if self.__guideStarXPos == 0 or self.__guideStarYPos == 0:
            # prompt operator to manually select a guide star
            print
            print " *** INPUT NEEDED ***"
            print " 1. In MaxIm, manually expose the guide camera."
            print " 2. Click on a guide star and enter a guide exposure value."
            print " 3. Verify that MaxIm correctly tracks on the guide star."
            raw_input(" 4. Press ENTER key when ready to proceed: ")
            self.__guideStarXPos = self.__CAMERA.GuiderXStarPosition
            self.__guideStarYPos = self.__CAMERA.GuiderYStarPosition
            print
            exposure = raw_input(" Enter Guide Star Exposure (sec): ")
            try:
                self.__guideExposure = float(exposure)
            except:
                print " ERROR: Invalid input. Expecting float value...try again"
                exposure = raw_input(" Enter Guide Star Exposure: ")
                try:
                    self.__guideExposure = float(exposure)
                except:
                    print "ERROR: Invalid input for guide star exposure"
                    return ERROR
            print
            print "Guider Setup:"
            print "Guider:                %s" % self.__CAMERA.GuiderName
            print "Guide star selection:  Manual"
            print "Guide star exposure:   %0.2f" % self.__guideExposure
            print "Aggressiveness X-Axis: %0.2f" % \
                   self.__CAMERA.GuiderAggressivenessX
            print "Aggressiveness Y-Axis: %0.2f" % \
                   self.__CAMERA.GuiderAggressivenessY
            print "Max Move X-Axis:       %0.2f" % self.__CAMERA.GuiderMaxMoveX
            print "Max Move Y-Axis:       %0.2f" % self.__CAMERA.GuiderMaxMoveY
            print "Min Move X-Axis:       %0.2f" % self.__CAMERA.GuiderMinMoveX
            print "Min Move Y-Axis:       %0.2f" % self.__CAMERA.GuiderMinMoveY

    self.__CAMERA.GuiderBinning = 1
    self.__CAMERA.GuiderSetStarPosition(self.__guideStarXPos,
                                        self.__guideStarYPos)
    print "Guider Declination = %d" % self.__CAMERA.GuiderDeclination
    print "Tracking on guide star at X = %d, Y = %d" % \
           (self.__guideStarXPos,self.__guideStarYPos)
    # start autoguiding
    try:
        guideStatus = self.__CAMERA.GuiderTrack(self.__guideExposure)
    except:
        print "ERROR: While attempting to start the autoguider"
        return ERROR
    else:
        if guideStatus:
            print "Start autoguiding..."
        else:
            print "ERROR: Autoguider did not start successfully"
            return ERROR
    print "Waiting for guider to settle below %0.2f px (max wait %d sec)" % \
           (self.__guideSettleLimit,self.__guideSettleMaxTime)
    started = time.time()
    cnt = 0
    while True:
        if (time.time() - started) > self.__guideSettleMaxTime:
            print "ERROR: Guider not settled within the max allowable time"
            return ERROR
        if self.__CAMERA.GuiderNewMeasurement:
            recentErrorX = self.__CAMERA.GuiderXError
            recentErrorY = self.__CAMERA.GuiderYError
            # ignore the first reading
            if cnt != 0:
                print "X-Error: %7.3f  Y-Error: %7.3f" % \
                       (recentErrorX,recentErrorY)
                if (abs(recentErrorX) < self.__guideSettleLimit and
                    abs(recentErrorY) < self.__guideSettleLimit):
                    break
        cnt += 1
        time.sleep(0.5)
    return NOERROR

def stopAutoGuide(self):
    try:
        self.__CAMERA.GuiderStop()
    except TypeError:
        print "Stop Autoguiding..."
        time.sleep(2)
    except:
        print "ERROR: Unexpected error while attempting to stop autoguider"

def checkGuiderRunning(self):
    return self.__CAMERA.GuiderRunning
    
def resetGuideStar(self):
    self.__guideStarXPos = 0
    self.__guideStarYPos = 0

Not surprisingly, 'autoGuide' is the new method that initiates all autoguiding operations. This method takes a boolean argument called 'autoGuideStar' to determine if autoguiding will use automatic or manual guide star selection. Additionally, the 'exposure' argument specifies the guide exposure length to use when automatic guide star selection is chosen and is not relevant when manual guide star selection is specified. If 'True' is passed in to the 'autoGuideStar' argument, the MaxIm DL attribute 'GuiderAutoSelectStar' is set to 'True', and, if a guide star has not been previously selected, a guide image is taken, and class attributes are populated with the position of the brightest guide star that MaxIm DL finds. All guide settings are then printed to the screen. If the 'autoGuideStar' argument is passed in as 'False', the MaxIm DL attribute 'GuiderAutoSelectStar' is set to 'False', and if a guide star has not previously been identified, the user is prompted to manually take a guide exposure, click on a potential guide star, then test tracking to make sure it is suitable. After pressing the 'ENTER' key, the user is then prompted to enter a length of exposure for all guide images and then all guide settings are printed to the screen.

After the guide star has been identified and set up, the guider binning is set then messages are printed to screen that show the current declination of the guider and the x- and y-coordinates of the chosen guide star. At this point, the autoguider is started with the MaxIm DL 'GuiderTrack' method inside a 'try', 'except', 'else' construct. The 'autoGuide' method then enters a loop that repeats until the guide errors fall under the pixel value defined by the class attribute '__guideSettleLimit'. If the errors do not settle within '__guideSettleMaxTime' seconds an error is returned to the calling routine. Assuming autoguiding starts okay and guide errors settle out, imaging can now begin.

The other two new methods added to this class are a procedure to stop the autoguider and a procedure to check to see if the autoguider is running. The 'checkGuiderRunning' method simply returns the result of MaxIm DL's 'GuiderRunning' attribute to the calling routine. The 'stopAutoGuide' method is complicated by a minor bug in MaxIm DL that causes a call to MaxIm's 'GuiderStop' method to always throw a 'TypeError' exception even though the autoguider is successfully stopped. This expected error is trapped in a 'except TypeError' block and any other exception generates an error statement to the screen.

cCAMERA UNIT TEST
The following listing shows the unit test code for this version of the 'cCamera' class. The script sets the simulator imaging camera up for full-frame mode with 1x1 binning then sets a CCD temperature and waits for the temperature to stabilize. As a first test, the script initiates autoguiding with automatic guide star selection and uses 1-second exposures for guide images. After making sure that autoguiding is in progress, it begins taking three 10-second images through the blue filter. When all images are complete, autoguiding is stopped. After resetting the guide star's x- and y-coordinates to zero, the process is started again with auto guide star selection and with 2.5-second guide images. This time, three 20-second images through the blue filter are taken before autoguiding is stopped. As a last test, the guide star cooridinates are zeroed out and autoguiding is started with manual guide star selection. After the user switches to MaxIm DL, takes a guide exposure, clicks on a guide star, and tests tracking for that star, autoguiding is started and three 15-second images through the blue filter are initiated. After all images are finished, autoguiding is stopped and the CCD is warmed to ambient temperature.

if __name__ == "__main__":

    # Create an instance of the cCamera class
    testCamera = cCamera()

    # Setup Maxim DL to take a full frame image 
    testCamera.setFullFrame()
    # Setup binning for 1x1
    testCamera.setBinning(1)

    # Set CCD Temperature
    testCamera.setCCDTemp('-15C')
    # Goto CCD Temperature
    testCamera.gotoCCDTemp()
    
    # Start camera autoguiding with auto guide star select
    # Guide exposure = 1.0 second
    if testCamera.autoGuide(True,1.0):
        testCamera.stopAutoGuide()
    # Make sure autoguider is running
    if testCamera.checkGuiderRunning():
        # Take 3 images
        for i in range(3):
            # Expose filter slot 2 (Blue) for 10 seconds
            testCamera.exposeLight(10,2,'m51_B')
        # Stop autoguider after all images complete
        testCamera.stopAutoGuide()    
    else:
        print "ERROR - Autoguider not running as expected"

    # Reset guide star positions for next test
    testCamera.resetGuideStar()
    # Start camera autoguiding with auto guide star select
    # Guide exposure = 2.5 seconds
    if testCamera.autoGuide(True,2.5):
        testCamera.stopAutoGuide()
    # Make sure autoguider is running 
    if testCamera.checkGuiderRunning():
        # Take 3 images
        for i in range(3):
            # Expose filter slot 2 (Blue) for 20 seconds
            testCamera.exposeLight(20,2,'m51_B')
        # Stop autoguider after all images complete
        testCamera.stopAutoGuide()    
    else:
        print "ERROR - Autoguider not running as expected"
    
    # Reset guide star positions for next test
    testCamera.resetGuideStar()
    # Start camera autoguiding with manual guide star select
    if testCamera.autoGuide(False,0):
        testCamera.stopAutoGuide()
    if testCamera.checkGuiderRunning():
        # Take 3 images
        for i in range(3):
            # Expose filter slot 2 (Blue) for 15 seconds
            testCamera.exposeLight(15,2,'m51_B')
        # Stop autoguider after all images complete
        testCamera.stopAutoGuide()    
    else:
        print "ERROR - Autoguider not running as expected"

    # Warm the CCD to ambient
    testCamera.warmCCD()

RUNNING THE SCRIPT
Testing this version of the 'cCamera' class using the camera simulator follows the same procedure described in Part 1a of this series. The new listing for 'cCamera' can be downloaded from cCamera_1d.zip. Experiment with the script by changing guide star selection mode (automatic or manual) and/or guide image exposure time to verify the script operates as expected.

WHAT'S NEXT?
This is the final post that will cover the 'cCamera' class (although occasionally new attributes or methods may be added to the class, as needed). In the next post I will begin building the 'cMount' class. This class will interface with methods and attributes provided by the Sky's telescope control and planetarium classes.

CLICK HERE FOR NEXT POST IN THIS SERIES

Automated Astrophotography with Python - Part 1c

2011-05-24T11:59:00.009-04:00

CCD TEMPERATURE CONTROL
A feature of most serious astronomical CCD cameras is the ability to set and regulate the temperature of the CCD chip via use of thermo-electric cooling (TEC). To this point, the 'cCamera' class has not addressed this feature. The listing show below now includes new constants, a class attribute, and three new methods that add TEC control to the script. (Python code added to this version of the script is shown in light cyan text; existing code is shown in yellow text.)

import time
import os
import win32com.client

LIGHT_PATH = r"c:\\astro_images\\"
SETTLE_TIME = 120  # minimum time for stable temp at set point 
SETTLE_MAX  = 480  # maximum time for temp to stabilize
ERROR = True
NOERROR = False

##------------------------------------------------------------------------------
## Class: cCamera
##------------------------------------------------------------------------------
class cCamera:
    def __init__(self):
        self.__CCDTemp = 'Skip' # CCD Temperature (Skip = don't change temp)

        print "Connecting to MaxIm DL..."
        self.__CAMERA = win32com.client.Dispatch("MaxIm.CCDCamera")
        self.__CAMERA.DisableAutoShutdown = True
        try:
            self.__CAMERA.LinkEnabled = True
        except:
            print "... cannot connect to camera"
            print "--> Is camera hardware attached?"
            print "--> Is some other application already using camera hardware?"
            raise EnvironmentError, 'Halting program'
        if not self.__CAMERA.LinkEnabled:
            print "... camera link DID NOT TURN ON; CANNOT CONTINUE"
            raise EnvironmentError, 'Halting program'

    def setCCDTemp(self,strtemp):
        if strtemp.upper() == 'SKIP':
            print "No CCD Cooling Specified"
            self.__CCDTemp = -99
            return NOERROR
        if strtemp.endswith("C"):
            try:
                flttemp = float(strtemp[:-1])
            except:
                print "ERROR: Specified CCD Temperature - Invalid format"
                return ERROR
        else:
            try:
                flttemp = float(strtemp)
            except:
                print "ERROR: Specified CCD Temperature - Invalid format"
                return ERROR
        self.__CCDTemp = flttemp
        return NOERROR
        
    def gotoCCDTemp(self):
        if self.__CCDTemp > -90:
            # set the CCD temperature set-point
            self.__CAMERA.TemperatureSetpoint = self.__CCDTemp
            print "CCD temperature setpoint: %0.2fC" % self.__CCDTemp
            # make sure the cooler is on, just in case
            if not self.__CAMERA.CoolerOn:
                print "Turning CCD cooler on"
                self.__CAMERA.CoolerOn = True
            print "Waiting for CCD temperature to stabilize"
            started = time.time()
            cnt = 0
            # Check CCD temp to stabilize
            while cnt < SETTLE_TIME and (time.time() - started) < SETTLE_MAX:
                currentTemp = self.__CAMERA.Temperature
                if (currentTemp < self.__CCDTemp - 0.5 or
                    currentTemp > self.__CCDTemp + 0.5):
                    cnt = 0
                time.sleep(1)
                cnt += 1
            if cnt == SETTLE_TIME and (time.time() - started) < SETTLE_MAX:
                print "CCD Temperature Stable at %0.2fC" % self.__CAMERA.Temperature
                try:
                    power = self.__CAMERA.CoolerPower
                    print "CCD Cooler Power: %d%%" % power
                except:
                    print "CCD cooler power could not be read"
                    return NOERROR
                return NOERROR
            else:
                print "CCD Temperature Did Not Stabilize"
                return ERROR
        else:
            print "Skipping temp stabilization."
            return NOERROR

    def warmCCD(self):
        if self.__CAMERA.CoolerOn:
            print "Starting to gradually warm CCD temperature to ambient"
            power = 100
            setTemp = self.__CAMERA.Temperature
            while power > 3:
                setTemp = setTemp + 5.0
                self.__CAMERA.TemperatureSetpoint = setTemp
                print "CCD temperature setpoint: %0.2fC" % setTemp
                print "Waiting 2.5 minutes for temperature to rise"
                time.sleep(150)
                print "CCD Cooler Temp : %0.2fC" % self.__CAMERA.Temperature
                try:
                    power = self.__CAMERA.CoolerPower
                    print "CCD Cooler Power: %d%%" % power
                except:
                    print "CCD cooler power could not be read"
                    power = 0
            print "CCD warming complete. Turning CCD cooler off"
            self.__CAMERA.CoolerOn = False
        else:
            print "CCD Cooler is off. CCD warming not necessary."

    def generateFilename(self,path,baseName):
        # path is the path to where the file will be saved
        baseName.replace(':', '_')      # colons become underscores
        baseName.replace(' ', '_')      # blanks become underscores
        baseName.replace('\\', '_')     # backslash becomes underscore
        # make sure the base filename has an '_' at the end
        if not baseName.endswith("_"):
            baseName = baseName + "_"
        # add 1 to use next available number
        seqMax = self.getSequenceNumber(path,baseName) 
        seqNext = seqMax + 1
        filename = "%s%s%05d.fit" % (path,baseName,seqNext)
        return filename

    def getSequenceNumber(self,path,baseName):
        # get a list of files in the image directory
        col = os.listdir(path)
        # Loop over these filenames and see if any match the basename
        retValue = 0
        for name in col:
            front = name[0:-9]
            back = name[-9:]
            if front == baseName:
                # baseName match found, now get sequence number for this file
                seqString = name[-9:-4]  # get last 5 chars of name (seq number)
                try:
                    seqInt = int(seqString)
                    if seqInt > retValue:
                        retValue = seqInt    # store greatest sequence number
                except:
                    pass
        return retValue

    def exposeLight(self,length,filterSlot,name):
        print "Exposing light frame..."
        self.__CAMERA.Expose(length,1,filterSlot)
        while not self.__CAMERA.ImageReady:
            time.sleep(1)
        print "Light frame exposure and download complete!"
        # save image
        filename = self.generateFilename(LIGHT_PATH,name)
        print "Saving light image -> %s" % filename
        self.__CAMERA.SaveImage(filename)

    def setFullFrame(self):
        self.__CAMERA.SetFullFrame()
        print "Camera set to full-frame mode"
        
    def setBinning(self,binmode):
        tup = (1,2,3)
        if binmode in tup:
            self.__CAMERA.BinX = binmode
            self.__CAMERA.BinY = binmode
            print "Camera binning set to %dx%d" % (binmode,binmode)
            return NOERROR
        else:
            print "ERROR: Invalid binning specified"
            return ERROR

##
##    END OF 'cCamera' Class
##

The first new method is called 'setCCDTemp' and takes a string (ex. '-15.5C') as its argument. This method first checks to see if the string is 'skip' (meaning don't change the currently set TEC regulated temperature) and if it is, sets the new class attribute '__CCDTemp' to -99. If the string is not 'skip', it strips off the trailing 'C' (if it exists) and then attempts to convert the string to a float. If successful, '__CCDTemp' is set to the float value, and if not successful, the method ends with an invalid format error message and returns an error flag back to the calling routine.

The second new method, 'gotoCCDTemp', sets the MaxIm DL property 'TemperatureSetpoint' to the desired temperature and sets the 'CoolerOn' property to TRUE to activate the TEC. The remainder of the method reads the CCD temperature and looks for it to be stable (setpoint temp plus or minus 0.5C) for a two minute period (SETTLE_TIME) before reading the TEC power and continuing. The method also imposes a maximum of 8 minutes (SETTLE_MAX) for the temperature to become stable before returning an error flag back to the calling routine.

The third method is a simple CCD warming routine that raises the chip's temperature by 5C, waits 150 seconds, then reads the TEC power. If the TEC power is above 3%, the temperature setpoint is raised another 5C and another 2.5 minute wait is initiated. This procedure repeats until the TEC power falls below 3% at which point the 'CoolerOn' property is set to FALSE. (The cooler is also turned off if the method is unable to read the TEC power - as is the case with the MaxIm DL autoguider simulator.) NOTE: This method is probably not really needed since the risk of damaging the CCD by thermal shock from turning off the cooler without warming is minimal or nonexistent.

cCAMERA UNIT TEST
The following listing shows the unit test code for this version of the 'cCamera' class. The script sets the simulator camera up for full-frame mode with 1x1 binning. It then sets a CCD temperature and takes three images then sets a different CCD temperature and takes three more images. The test script then sets the CCD temp to 'Skip' and takes more images to verify that the temperature doesn't change before warming the CCD back to ambient.

if __name__ == "__main__":

    # Create an instance of the cCamera class
    testCamera = cCamera()

    # Setup Maxim DL to take a full frame image 
    testCamera.setFullFrame()
    # Setup binning for 1x1
    testCamera.setBinning(1)

    # Set CCD Temperature
    testCamera.setCCDTemp('-20C')
    # Goto CCD Temperature
    testCamera.gotoCCDTemp()
 
    # Take 3 images
    for i in range(3):
        # Expose filter slot 1 (Green) for 10 seconds
        testCamera.exposeLight(10,1,'m51_G')
    
    # Set CCD Temperature
    testCamera.setCCDTemp('-15C')
    # Goto CCD Temperature
    testCamera.gotoCCDTemp()
 
    # Take 3 images
    for i in range(3):
        # Expose filter slot 1 (Green) for 10 seconds
        testCamera.exposeLight(10,1,'m51_G')
    
    # Set CCD Temperature
    testCamera.setCCDTemp('skip')
    # Goto CCD Temperature
    testCamera.gotoCCDTemp()
 
    # Take 3 images
    for i in range(3):
        # Expose filter slot 1 (Green) for 10 seconds
        testCamera.exposeLight(10,1,'m51_G')
    
    # Warm the CCD to ambient
    testCamera.warmCCD()

RUNNING THE SCRIPT
Testing this version of the 'cCamera' class follows the same procedure described in Part 1a of this series. The new listing for 'cCamera' can be downloaded from cCamera_1c.zip. Experiment with the script by running it multiple times and by changing the CCD temperature, binning, filter, exposure length, or file base name in the unit test section to verify the script operates as expected.

WHAT'S NEXT?
In the next post I will continue to expand the 'cCamera' class by introducing more methods and properties that allow for autoguide tracking during imaging. I will also expand the unit test listing to verify correct operation of the features added to this class.

CLICK HERE FOR NEXT POST IN THIS SERIES

Automated Astrophotography with Python - Part 1b

2011-05-23T06:29:00.016-04:00

SAVING IMAGES
The script of the 'cCamera' class presented in Part 1a of this series suffered from one major problem - it only provided for exposing and downloading an image but did not provide for saving the image to storage media. The script shown below addresses that deficiency. (Python code added to this version of the script is shown in light cyan text; existing code is shown in yellow text.)

import time
import os
import win32com.client

LIGHT_PATH = r"c:\\astro_images\\"
ERROR = True
NOERROR = False

##------------------------------------------------------------------------------
## Class: cCamera
##------------------------------------------------------------------------------
class cCamera:
    def __init__(self):
        print "Connecting to MaxIm DL..."
        self.__CAMERA = win32com.client.Dispatch("MaxIm.CCDCamera")
        self.__CAMERA.DisableAutoShutdown = True
        try:
            self.__CAMERA.LinkEnabled = True
        except:
            print "... cannot connect to camera"
            print "--> Is camera hardware attached?"
            print "--> Is some other application already using camera hardware?"
            raise EnvironmentError, 'Halting program'
        if not self.__CAMERA.LinkEnabled:
            print "... camera link DID NOT TURN ON; CANNOT CONTINUE"
            raise EnvironmentError, 'Halting program'

    def generateFilename(self,path,baseName):
        # path is the path to where the file will be saved
        baseName.replace(':', '_')      # colons become underscores
        baseName.replace(' ', '_')      # blanks become underscores
        baseName.replace('\\', '_')     # backslash becomes underscore
        # make sure the base filename has an '_' at the end
        if not baseName.endswith("_"):
            baseName = baseName + "_"
        # add 1 to use next available number
        seqMax = self.getSequenceNumber(path,baseName) 
        seqNext = seqMax + 1
        filename = "%s%s%05d.fit" % (path,baseName,seqNext)
        return filename

    def getSequenceNumber(self,path,baseName):
        # get a list of files in the image directory
        col = os.listdir(path)
        # Loop over these filenames and see if any match the basename
        retValue = 0
        for name in col:
            front = name[0:-9]
            back = name[-9:]
            if front == baseName:
                # baseName match found, now get sequence number for this file
                seqString = name[-9:-4]  # get last 5 chars of name (seq number)
                try:
                    seqInt = int(seqString)
                    if seqInt > retValue:
                        retValue = seqInt    # store greatest sequence number
                except:
                    pass
        return retValue

    def exposeLight(self,length,filterSlot,name):
        print "Exposing light frame..."
        self.__CAMERA.Expose(length,1,filterSlot)
        while not self.__CAMERA.ImageReady:
            time.sleep(1)
        print "Light frame exposure and download complete!"
        # save image
        filename = self.generateFilename(LIGHT_PATH,name)
        print "Saving light image -> %s" % filename
        self.__CAMERA.SaveImage(filename)

    def setFullFrame(self):
        self.__CAMERA.SetFullFrame()
        print "Camera set to full-frame mode"
        
    def setBinning(self,binmode):
        tup = (1,2,3)
        if binmode in tup:
            self.__CAMERA.BinX = binmode
            self.__CAMERA.BinY = binmode
            print "Camera binning set to %dx%d" % (binmode,binmode)
            return NOERROR
        else:
            print "ERROR: Invalid binning specified"
            return ERROR

##
##    END OF 'cCamera' Class
##

As you can see, two new methods have been added to the script. The 'generateFilename' script takes as arguments a path and a base name that usually should include the object name, filter, and binning used during the exposure (ex. m106_R_2x2). The first thing this method does is to take the 'baseName' parameter and strip out any characters that should not be in a filename and replace them with the '_' (underscore) character. It also appends an underscore character to 'baseName'. This method then calls the other new method, 'getSequenceNumber', and provides it with the path and new name arguments. The 'getSequenceNumber' method then uses the 'listdir' method of the 'os' object (hence, the new 'import os' at the top of the listing) to generate a list of all files in the directory specified by 'path'. The method then iterates through the list of directory files looking for one with a matching base name. If one is found, it checks the last five characters before '.fit' and tries to convert these characters into an integer. If successful, it returns the highest integer it can find back to the calling method. The 'generateFilename' method then uses this number to assign the next image with a similar base name the next number in the sequence.

Additional new code has been added to the existing 'exposeLight' method. This new code makes the call to the 'generateFilename' method, prints a message to the screen showing the path and filename of the saved image, then calls the MaxIm DL 'SaveImage' method to actually transfer the image to storage.

cCAMERA UNIT TEST
The following listing shows the unit test code for this version of the 'cCamera' class. The main difference is the requirement for the new 'name' parameter in the 'exposeLight' method.

if __name__ == "__main__":

    # Create an instance of the cCamera class
    testCamera = cCamera()

    # Setup MaxIm DL to take a full frame image 
    testCamera.setFullFrame()
    # Setup binning for 2x2
    if not testCamera.setBinning(2):
        for i in range(4):
            # Expose filter slot 0 (Red) for 15 seconds
            testCamera.exposeLight(15,0,'m51_R_2x2')
    else:
        print "Images not taken due to previous error"

RUNNING THE SCRIPT
Testing this version of the 'cCamera' class follows the same procedure described in Part 1a of this series. Note: Remember that the path specified by the constant 'LIGHT_PATH' must exist prior to running the script. The new listing for 'cCamera' can be downloaded from cCamera_1b.zip. Experiment with the script by running it multiple times and by changing the binning, filter, exposure length, or file base name in the unit test section to verify the script operates as expected.

WHAT'S NEXT?
In the next post I will continue to expand the 'cCamera' class by introducing more methods and properties that allow for control of the camera's thermo-electric cooler (TEC). I will also expand the unit test listing to verify correct operation of the features added to this class.

CLICK HERE FOR NEXT POST IN THIS SERIES

Automated Astrophotography with Python - Part 1a

2011-05-22T07:48:00.009-04:00

GETTING THINGS TO WORK
The very first step in this process is to verify that Python and Python Extension for Windows are properly communicating with a suitable Windows application. In this case, we will use MaxIm DL and its built-in camera simulator.

THE cCAMERA CLASS
The first piece of code that we will look at is the 'cCamera' class. The Python code for 'cCamera' is shown below. (Note: Docstrings have been removed from this listing for brevity and readability purposes.)

import time
import win32com.client

ERROR = True
NOERROR = False

##------------------------------------------------------------------------------
## Class: cCamera
##------------------------------------------------------------------------------
class cCamera:
    def __init__(self):
        print "Connecting to MaxIm DL..."
        self.__CAMERA = win32com.client.Dispatch("MaxIm.CCDCamera")
        self.__CAMERA.DisableAutoShutdown = True
        try:
            self.__CAMERA.LinkEnabled = True
        except:
            print "... cannot connect to camera"
            print "--> Is camera hardware attached?"
            print "--> Is some other application already using camera hardware?"
            raise EnvironmentError, 'Halting program'
        if not self.__CAMERA.LinkEnabled:
            print "... camera link DID NOT TURN ON; CANNOT CONTINUE"
            raise EnvironmentError, 'Halting program'

    def exposeLight(self,length,filterSlot):
        print "Exposing light frame..."
        self.__CAMERA.Expose(length,1,filterSlot)
        while not self.__CAMERA.ImageReady:
            time.sleep(1)
        print "Light frame exposure and download complete!"

    def setFullFrame(self):
        self.__CAMERA.SetFullFrame()
        print "Camera set to full-frame mode"
        
    def setBinning(self,binmode):
        tup = (1,2,3)
        if binmode in tup:
            self.__CAMERA.BinX = binmode
            self.__CAMERA.BinY = binmode
            print "Camera binning set to %dx%d" % (binmode,binmode)
            return NOERROR
        else:
            print "ERROR: Invalid binning specified"
            return ERROR
            
##
##    END OF 'cCamera' Class
##

The first two lines of the listing are 'import' statements that identify and allow use of the 'time' and 'win32com.client' library objects in the script. The listing for the 'cCamera' class follows the 'import' statements and consists of four methods. The '__init__' method is the constructor method for 'cCamera' and is executed whenever an instance of the cCamera object is created. This method creates a '__CAMERA' object that is an instance of MaxIm DL's 'CCDCamera' object. The '__CAMERA' object then can be used to access all the properties and methods found in the scripting section of MaxIm DL's help file (for CCDCamera object). This method also uses 'try' and 'except' statements to determine if a link has been successfully established to the program. If MaxIm DL has not already been loaded and connection to the camera established manually, the script will load MaxIm DL and make the camera connection automatically.

Next in the listing is the 'exposeLight' method that takes as arguments a length of exposure (float) and an integer that specifies the filter to use for the exposure (zero-based). This method uses MaxIm DL's 'Expose' method to start the exposure and polls the 'ImageReady' parameter to determine when the exposure and image download have completed (indicated when 'ImageReady' goes True).

The third method of 'cCamera' calls the MaxIm DL method 'SetFullFrame' and the last method sets the 'BinX' and 'BinY' properties. For more details regarding 'SetFullFrame()', 'BinX', and 'BinY' refer to MaxIm DL help under 'Scripting' and under 'CCDCamera' methods or properties.

cCAMERA UNIT TEST
The listing given below is inserted onto the end of the source listing and allows unit testing the 'cCamera' class. The first step is to create an instance of the 'cCamera' object called 'testCamera'. In turn, the 'setFullFrame' and 'setBinning' methods of 'testCamera' are called to set MaxIm to full-frame mode and to set binning to 1x1. If 'setBinning' finished without error, the 'exposeLight' method is called and initiates a 12.5 second exposure through the simulator's blue filter (slot 2).

if __name__ == "__main__":

    # Create an instance of the cCamera class
    testCamera = cCamera()

    # Setup MaxIm DL to take a full frame image 
    testCamera.setFullFrame()
    # Setup binning for 2x2
    if not testCamera.setBinning(2):
        # Expose filter slot 2 (Blue) for 12.5 seconds
        testCamera.exposeLight(12.5,2)
    else:
        print "Image not taken due to previous error"

RUNNING THE SCRIPT
Follow the steps below to execute the script described in this post:

Download and extract the script from cCamera_1a.zip.
Start MaxIm DL and open the Camera Control window. Under 'Setup Camera' for Camera 1, choose 'Simulator' and under 'Setup Filter' for Camera 1 choose 'Simulator' also. For Camera 2, choose 'Simulator' and under 'Setup Filter' for Camera 2 leave unselected.
Change focus to the IDLE window containing your script listing, click the 'Run' menu item and pull down to 'Run Module', or simply press the F5 key.
If everything is working correctly, you should see MaxIm DL kick off a 12.5 second exposure through the blue filter and eventually display an image from the simulated camera. You can inspect the FITS header to verify the binning, exposure, and filter for this image.
Modify the parameters in the unit test section of the listing to take exposures of different lengths, through different filters, using different binnings to verify that all work as expected.

WHAT'S NEXT?
In the next post I will continue to expand the 'cCamera' class by introducing methods that allow saving light images to disk. I will also expand the unit test listing to verify correct operation of the new features added to this class.

CLICK HERE FOR NEXT POST IN THIS SERIES

Automated Astrophotography with Python - Introduction

2011-05-21T18:22:00.005-04:00

INTRODUCTION
As anyone past the beginner stage of astronomical imaging quickly finds out, an executive software application that controls all aspects of the imaging process becomes a desirable tool. There are various applications available (CCD Commander, ACP, CCD Autopilot) that I highly recommend and that perform very well but that also come with relatively high price tags. (Although the price is typically a fraction of the costs tied up in equipment and other software for the average imager.) However, an alternative to using an application that someone else has created and maintains is to create your own control software that directs the imaging process EXACTLY how you would wish it to be executed. This introductory post is the first in a series of posts that will detail how you can easily create and maintain your own executive application at no cost (other than your time learning and programming in Python).

WHY PYTHON?
Python is a agile programming language that is freely available, well supported, and easy to learn for beginners. Python syntax is very easy to read and understand, and the language supports object-oriented programming practices. Python is also an interpreted language which means there is no compilation process. You simply execute the script and it runs! Most importantly, Python supports the COM (Common Object Model) architecture under which most astronomical imaging software exposes their properties and methods to the outside world. This means that Python can seamlessly communicate with and control all major astronomical software applications like CCDSoft, MaxIm DL, the Sky, etc. For more information regarding the question of "Why Python?" click here.

WHERE TO GET PYTHON?
Python can be downloaded from this web page. Simply choose the installer that corresponds with your operating system and follow the prompts. (Although Python is written for Windows, Mac, and Unix platforms, you will need the Windows 32-bit or 64-bit OS installer since virtually all of the major astronomical imaging software packages you'll hook into are Windows-based.) The installer will also install IDLE which is the Python IDE (Integrated Development Environment) which you can use to write, test, and debug your scripts. Click here for a beginner's guide to downloading Python.

NOTE: All scripts presented in this series have been tested using the latest stable version of Python which is 2.7.1 as of the date of this post. The scripts should also work under the latest version of Python 3 but this claim has not been verified. Additionally, in order to have COM support, you must also load the Python Extensions for Windows package that corresponds to the version of Python that you have chosen to use. The latest package (Build 216 as of the date of this post) can be found here.

HOW TO LEARN PYTHON?
An on-line search of "Learning Python" or "Python tutorial" will return hundreds of on-line tutorials and PDF documents to help you get started. Another list of learning resources can be found here. One on-line PDF document that I found useful, even though it is somewhat dated, can be found here and the official Python tutorial can be found here.

BENEFITS OF CREATING AND RUNNING YOUR OWN SCRIPT

No Cost (other than your time)
Great opportunity to learn computer programming if you've never done it before or to learn a new programming language if you're already an experienced programmer
COMPLETE control of all aspects of the automated imaging process
Fine-tuned to the particular set of software that YOU use for imaging
You maintain the application...no waiting for someone else to get around to fixing a bug or implementing an improvement
Implement only the features that you want in exactly the way you want them to function

MY IMAGING ENVIRONMENT
The computer that I use for astronomical imaging is a 6-year old Toshiba laptop running Windows XP Home Edition. My Python script accesses the following imaging applications:

MaxIm DL 5 (For Camera Control)
The Sky6 (For Mount Control)
FocusMax (For Automated Focusing)
CCDSoft (For Plate Solving)

My imaging equipment is all portable. Since I don't have a suitable dark location near my home, I perform all image acquisition at a dark site that is approximately 200 miles away. Consequently, I don't have any script examples for dome control, weather monitoring equipment, or any other hardware that you would typically find with a permanently mounted setup. These features can be easily added to your Python script if required.

MY SCRIPT
The following is a very top-level description of my script's operation during acquisition of normal, light frames of astronomical objects. I will be describing in detail how each of these steps is implemented in the course of these posts.

Read in the input text file that specifies the object to image and contains a list of images to take that includes filter, exposure, and number of frames. (An example of an input text file can be downloaded here.) Also, read in other options such as CCD temp, minimum altitude, warm CCD after all images etc. that apply to this set of images.
Find the object in the Sky and wait for object to cross the meridian (since I only image on the west side of the sky). If the object has already crossed the meridian, continue immediately with the next step.
Locate a suitable focus star (from a preselected list of candidate stars) that is close to the object, slew to the star, plate solve, then resync and reslew if needed. Using FocusMax's focus method, auto-focus through the specified filter then check focus using FocusMax's HFD measurement method.
Slew to the object, plate solve, then resync and reslew if needed to reduce the pointing error.
Expose the guide camera, identify a guide star, begin autoguiding, then wait until guide errors fall below a specified threshold.
Begin acquiring images until the specified number of images have been captured or until it is time to perform the periodic focus check (required after 'x' number of images have be captured).
When the periodic focus check is required, slew to the same focus star used in step 3 (with plate solve, resync, and reslew if required) and check focus using FocusMax's HFD measurement method. If the HFD has changed by a specified threshold, repeat FocusMax's focus method. Otherwise, continue directly to the next step.
Slew to the object and plate solve, then resync and reslew if required.
Return to step 6 until all images have been acquired for the current set of images.
For the next set of images return to step 3.
When all image sets have been acquired or when the object drops below the specified altitude, end the script. If required, warm the CCD to ambient temperature and/or slew the mount to a safe position.

DISCLAIMER
The scripts contained in the following posts have been written, debugged, and verified as working by me FOR MY PARTICULAR SETUP only. There are no guarantees that they will work, as is, with anyone else's setup. Therefore, I assume no responsibility for damage to equipment, lost time, or other losses anyone may incur. Furthermore, the scripts are not guaranteed to be without bugs that I haven't found yet. Indeed, they probably DO have bugs that I haven't found yet. The message is: Use the information contained in these posts at your own risk. The scripts in these posts are meant only as a STARTING POINT for your own scripts and are not meant to be used as is.

ACKNOWLEDGMENT
For some time I had been thinking about writing my own scripts even while using CCD Commander on a regular basis. It wasn't until I ran across the series of three articles in the on-line magazine "AstroPhoto Insight" titled "Automated Imaging on a Budget" by Joe Ulowetz that I found the jump-start that I needed. Specifically, at the end of the article, Joe graciously provided a link to allow a download of the complete Python code that controlled the automation described in his article. By pouring through Joe's code and using it as a starting point, I was eventually able to drop CCD Commander and begin the process of writing, testing, debugging, and, eventually, using my own executive software application.

WHAT'S NEXT?
In the next post, I will begin diving into the Python code. Specifically, I'll introduce and begin describing methods contained in the Camera class. I'll also show how these methods can be easily tested using only the camera simulator built into MaxIm DL.

CLICK HERE FOR NEXT POST IN THIS SERIES

M5 - Globular Cluster

2011-05-20T08:24:00.004-04:00

(Click image to go to info page)

M5 is a large, bright globular cluster located in the constellation Serpens (Caput). This naked eye object can be found about 20 arc-minutes to the northwest of the 5th magnitude star 5 Serpentis. It's core is extremely compressed and slightly elliptical in shape. At magnitude 5.7, M5 lies at a distance of approximately 25,000 light years and was discovered in 1702 by Gottfried Kirch.

The data for this luminance-only photo was captured on 1 May and 2 May 2011. All images were taken at the Chiefland Astronomy Village in Chiefland, Florida. Complete details regarding this image and more images of M5 at various resolutions can be found by clicking on the image above or by clicking here.

M106 - Spiral Galaxy

2011-05-19T08:43:00.005-04:00

(Click image to go to info page)

The spiral galaxy M106 (NGC 4258) is a very large and bright galaxy located in the constellation Canes Venatici. M106 has a magnitude of approximately 8.3, lies at a distance of around 22 million light years, and was first discovered by Pierre Mechain in 1781.

The luminance data for the photo above was captured on 4 March 2011 and the color information was collected between 30 April and 2 May 2011. All images were taken at the Chiefland Astronomy Village in Chiefland, Florida. Complete details regarding this image and more images of M106 at various resolutions can be found by clicking on the image above or by clicking here.

STS-134 Endeavour SRB Separation

2011-05-18T17:06:00.002-04:00

(Click image to enlarge)

Approximately one minute thirty seconds after launch the space shuttle SRBs (solid rocket boosters) are separated from the external fuel tank and fall back to the ocean to be recovered and reused. The photo above has been enlarged and enhanced from this photo to show the back-end of Endeavour, the two SRBs falling away from the external fuel tank, and the exhaust trail that extends backwards along the flight path. Click on the image above to view a larger version of this photo.

STS-134 Launch of Space Shuttle Endeavour

2011-05-18T15:40:00.003-04:00

(Click image above to enlarge)

Here's a collection of photos of the May 16, 2011 launch of Endeavour made from my house which is approximately 30 miles south of the launch pad. Despite low clouds at the launch pad, the sky was mostly clear at my location. Click on the links below for other photos of the climb to orbit.

Photo 1
Photo 2
Photo 3
Photo 4
Photo 5
Photo 6
Photo 7
Photo 8
Photo 9
Photo 10
Photo 11
Photo 12

M63 - The Sunflower Galaxy

2011-05-18T13:04:00.006-04:00

(Click image to go to info page)

M63, also cataloged as NGC 5055, is a prominent spiral galaxy in the constellation Canes Venatici. Due to its flowery appearance in photographs, it is also commonly referred to as the Sunflower galaxy. M63 shines with the light of over 10 billion suns and sports a disk approximately 86,000 light years in diameter. This magnitude 8.6 galaxy is located approximately 23.5 million light years away and was first discovered by Pierre Mechain in 1779.

The photo above was captured between 30 April and 2 May 2011 at the Chiefland Astronomy Village in Chiefland, Florida. Complete details regarding this image and more images of M63 at various resolutions can be found by clicking on the image above or by clicking here.