The method to determine a CCD’s readout noise contribution to the final signal is as follows¹:

1. Obtain two bias frames (0 length exposures).
2. Add a constant offset to one of the bias frames (e.g. 500).
3. Subtract the second bias frame from the offset bias frame.
4. Find the standard deviation for a region of the resulting frame.
5. Calculate Read Noise (e^- RMS) = StdDev * Gain / SQRT(2)

The results of performing these operations on ten pairs of bias frames is summarized in the table below:

¹From “Handbook of CCD Astronomy Second Edition” by Steve B. Howell

²Published read noise for this device = 9.3 e^- RMS

The first script that I have written and fully debugged is a routine that I use to capture dark and bias calibration frames. Typically, I do not spend time at my dark site capturing dark and bias frames. Instead, when I get home or when needed, I place the camera in the refrigerator (a dark and relatively cold place) and have the software automatically take the calibration frames while I sleep. On a typical night I might instruct the script to take, for example, 40 dark frames at 600 seconds each (10 minutes) at a CCD temperature of -10C and then take 100 bias frames at the same temperature.

When the program is started, the following menu is shown:

Exec_DarkBias.py
——————————-
1. Specify save path
2. Setup for Dark Frames
3. Setup for Bias Frames
4. Confirm setup
5. Reset settings
6. Begin script
7. Quit

Option ‘1′ displays the current save path and allows the operator either to accept this path or specify a new path for the calibration frames. The second option asks for operator input to specify the Dark frame exposure length, binning, number of frames and CCD temperature setpoint for these frames. Option ‘3′ asks for operator input to specify the Bias binning, number of frames, and CCD temperature. The fourth option displays the current settings for path, Dark frames, and Bias frames for operator verification. Option ‘5′ resets all path, Dark, and Bias settings to their default, startup values. Entering a ‘6′ starts the script operation and entering a ‘7′ quits the entire program.

When the script begins, the software first checks to make sure either Dark frames setup or Bias frames setup (or both) have been specified then it sets the Dark frame CCD temperature setpoint. Next a loop is entered where the CCD temperature is checked once a second. The CCD temperature is considered stable when the read-back temperature does not deviate more than +/-0.5C from the setpoint temperature for 120 consecutive readings (2-minutes). If the temperature does not stabilize within 8 minutes, the program fails, displays an error message, and terminates. Otherwise, the CCD temperature will be considered stable and Dark frame capture will begin. After all dark frames have been taken, the Bias frame CCD temperature will be set. If the Bias CCD temperature is the same as the Dark CCD temperature, no wait for stabilization will occur. Otherwise, the same CCD temperature stabilization loop will execute. After all Bias frames have been captured, the script will end and the program will return to the top-level menu. Here, another script can be set up or the program can be terminated.

This script makes use of the Maxim/DL CAMERA COM object only. Additionally, a log file is generated that saves the progress of the program for future reference. The program listing and a sample logfile for this program is available by clicking on the link below:

Exec_DarkBias.zip

As a comparison, here are similar photos of a recently re-coated 8″ mirror:

The executable version of this program can be downloaded here.

Here is the complete program listing (or may be downloaded here):

#include
#include
#include

#define BASE_YEAR 1900

/* constant string arrays of the days of the week and the months of the year */
const char *days[] = {“Sunday”,”Monday”,”Tuesday”,”Wednesday”,”Thursday”,”Friday”,”Saturday”};
const char *months[] = {“January”,”February”,”March”,”April”,”May”,”June”,”July”,
“August”,”September”,”October”,”November”,”December”};

/* prototypes of functions defined below */
void display_time(char *, struct tm *);
double julian_date(struct tm *, int);
double sidereal_time(double, struct tm *, double);

int main(void)
{
double julian, sidereal;
float longitude;
double sid_hr, sid_mn, sid_sc;
char c;
time_t timer;

/* Print header */
printf(“\n”);
printf(” ***********************************************************************************\n”);
printf(” * This program displays the computer’s local time, the Greenwich Mean Time (GMT), *\n”);
printf(” * the Julian date, and local sidereal time (LST). The only input required is the *\n”);
printf(” * the user’s longitude. This must be entered in degrees and decimal degrees *\n”);
printf(” * (dd.ddd) east or west the prime meridian. For locations east of the prime *\n”);
printf(” * meridian, the value entered should be positive (+). For locations west of the *\n”);
printf(” * prime meridian, the value should be negative (-). *\n”);
printf(” ***********************************************************************************\n”);
printf(“\n”);

/* Prompt user for longitude in decimal degrees */
printf(” Enter your longitude: “);
scanf(“%f”,&longitude);

do
{
/* Display the user’s longitude */
printf(“\n Longitude: \t%0.2f “,fabs(longitude));
if (longitude < 0.0)
printf("West\n");
else
printf("East\n");
/* Load time struct with current data. Show local time and GMT */
timer=time(NULL);
display_time(" Local: ",localtime(&timer));
display_time(" GMT: ",gmtime(&timer));

/* Call Julian date function and display result */
julian = julian_date(gmtime(&timer),0);
printf(" Julian Date:\t%0.6f\n",julian);

/* Call Julian date function for present day at 0h GMT then call sidereal time function */
julian = julian_date(gmtime(&timer),1);
sidereal = sidereal_time(julian,gmtime(&timer),longitude);

/* Split sidereal time into hours, minutes, and seconds then display */
sid_mn = modf(sidereal,&sid_hr) * 60;
sid_sc = modf(sid_mn,&sid_mn) * 60;
modf(sid_sc,&sid_sc);
printf(" LST: \t%02.0f:%02.0f:%02.0f\n",sid_hr,sid_mn,sid_sc);

/* Read to end of line or end of buf to flush the input stream */
do {
c = fgetc(stdin);
} while ((c != '\n') && (c != EOF));

/* Wait for user to press ENTER to end or 'r' to repeat */
printf("\n\n Press ENTER to exit or 'R' plus ENTER to repeat: ");
scanf("%c",&c);
} while ((c == 'r') || (c == 'R'));

return 0;
}

/* Displays the time and date contained in the data of the struct that 'time' points to */
void display_time(char *str, struct tm *time)
{
printf("%s\t%s, %02d %s",str,*(days+(time->tm_wday)),time->tm_mday,*(months+(time->tm_mon)));
printf(” %d”,time->tm_year + BASE_YEAR);
printf(” %02d:%02d:%02d\n”,time->tm_hour,time->tm_min,time->tm_sec);
}

/* Calculate the Julian date for the date and time contained in the struct that ‘time’ points to. */
/* For ‘t_zero’ = 0, show the exact Julian date. For ‘t_zero’ = 1, show the Julian date at prior 0h GMT. */
double julian_date(struct tm *time, int t_zero)
{
int A,B;
int year = time->tm_year + BASE_YEAR;
int month = time->tm_mon + 1;
double julian_day, DD;

if (!t_zero)
DD = time->tm_mday + ((time->tm_hour + time->tm_min/60.0 + time->tm_sec/3600.0)/24.0);
else
DD = time->tm_mday;

if (month < 2)
{
year -= 1;
month += 12;
}

A = year/100;
B = 2 - A + A/4;

julian_day = floor(365.25 * year) + floor(30.6001*(month + 1.0)) + DD + 1720994.5 + B;

/* Return 'julian_day' in decimal format */
return julian_day;
}

/* Calculate and return the sidereal time given inputs of the Julian date at prior 0h GMT, */
/* current GMT as given in struct that 'time' points to, and the user-inputed longitude. */
double sidereal_time(double julian, struct tm *time, double lngtd)
{
double T, UT;
double local_sidereal;

/* Calculate decimal equivalent of current GMT */
UT = time->tm_hour;
UT += time->tm_min/60.0 + time->tm_sec/3600.0;

T = (julian – 2415020.0) / 36525.0;
local_sidereal = 6.6460656 + 2400.051262 * T + 0.00002581 * T * T;

/* Normalize ‘local_sidereal between 0 and 23 */
while (local_sidereal > 24)
{
local_sidereal -= 24;
}

local_sidereal += 1.002737908 * UT;
local_sidereal += lngtd / 15.0;

/* Normalize ‘local_sidereal’ between 0 and 23 */
if (local_sidereal < 0)
{
local_sidereal += 24;
}
else if (local_sidereal > 24)
{
local_sidereal -= 24;
}

/* Return LST in decimal format */
return local_sidereal;
}

11″ Starmaster focal length = 11in. x 25.4mm/in. x 5.4 = 1509mm.

Magnification = (scope focal length) / (eyepiece focal length)

Eyepiece calculated field of view = (Apparent Field of View) / Magnfication

The eyepiece’s calculated field of view is found in a non-tracking scope by centering a star in a given eyepiece then timing how many seconds the star takes to leave the field of view. Divide this number of seconds by 120 to get the true size of the field of view in degrees. (Repeat several times for each eyepiece to be sure of the reading.)

My final results for this contest were:

Final score: 82,680

My final results for this contest were:

Final score: 220,704

LCD Monitor

After years of working with nothing more than a 15″ CRT monitor at any of my desktop computers, I have now purchased a 24″ widescreen LCD monitor. The monitor is a Samsung Model 2494SW with a native resolution of 1920×1080 pixels. This unit was purchased from amazon.com for $201.45 with free shipping.

Video Graphics Card

When considering this monitor or any widescreen, high resolution monitor, I quickly realized the integrated video on the computer’s motherboard would not be up to the task of driving any such monitor at its native resolution. This realization led me to start looking for a suitable video graphics card. Specifically, I was looking for a AGP card since my motherboard had an unused AGP slot (Advanced Graphics Port). After some looking and comparing, I settled on a SPARKLE SF8855DT GeForce FX 5500 256MB 128-bit DDR AGP 4X/8X video card purchased from newegg.com for $34.99 plus $5.99 shipping. This graphics card features NVIDIA chipset and 256MB of video RAM. It also has has one D-SUB connector for analog video, one DVI connector for digital video, and S-Video connector for a TV connection. An image of this video card is shown below:

DVD-RW Drive

Now having access to a widescreen, high resolution LCD monitor, I then decided I needd to replace the very old CD-ROM drive that originally came with this computer. After a short search, I replaced this IDE drive with a Sony Optiarc Black 24X DVD+R 8X DVD+RW 12X DVD+R DL 24X DVD-R 6X DVD-RW 12X DVD-RAM 16X DVD-ROM 48X CD-R 32X CD-RW 48X CD-ROM 2MB Cache SATA DVD/CD Rewritable serial ATA (SATA) drive. Since this is an OEM drive, I also had to purchase the SATA power adapter and data cable. These items were purchased from newegg.com for $27.99 (drive), $5.79 (cables), and $8.13 shipping. (Total order: $41.91)

Hardware Integration

The video card and DVD drive were installed in the computer case with no issues. The XP system automatically detected and loaded a driver for the DVD drive and I manually loaded the drivers for the video card and for the monitor from the supplied disks. Despite working the issue for a while, I was unable to get the graphics card to drive the monitor at its native resolution via the digital DVI cable but was able to get the native resolution via the analog interface. (I was pre-warned of this potential problem from user feedback on the newegg.com site for this graphics card.) For now, I will stick with driving the monitor through the analog cable.

Summary

I have now replaced every hardware item in this computer except the legacy floppy disk drive that I never use. In previous upgrades, the motherboard, motherboard memory, and power supply were replaced and the operating system was upgraded from Windows 95/98 to Windows XP Home. With a widescreen monitor in place, I now have enough room on the display to place windows side-by-side instead of having to stack them on top of each other. This capability will be particularly useful during radio contests where I was continually having to swap windows around due to a lack of room on the screen.