Index: /branches/dimm-0-5/Ohana/src/opihi/dimm/Analysis.c =================================================================== --- /branches/dimm-0-5/Ohana/src/opihi/dimm/Analysis.c (revision 11221) +++ /branches/dimm-0-5/Ohana/src/opihi/dimm/Analysis.c (revision 11221) @@ -0,0 +1,112 @@ +# include "dimm.h" + +/* should this all be wrapped within an opihi implementation? */ + +int subtractImage (Image *a, Image *b) { + + if (a[0].Nx != b[0].Nx) return (FALSE); + if (a[0].Ny != b[0].Ny) return (FALSE); + + Npix = a[0].Nx*a[0].Ny; + ap = (float *) a[0].buffer; + bp = (float *) b[0].buffer; + for (i = 0; i < Npix; i++, ap++, bp++) { + *ap -= *bp; + } + return (FALSE); +} + +void statsImage (Image *image, Stats *stats) { + + val = (float *)image[0].buffer; + max = min = val[0]; + Npix = image[0].Nx*image[0].Ny; + for (i = 0; i < Npix; i++, val++) { + N1 += *val; + N2 += (*val)*(*val); + max = MAX (max, *val); + min = MIN (min, *val); + } + stats[0].mean = N1 / Npix; + stats[0].sigma = sqrt (N2 / Npix - SQ(stats[0].mean)); + stats[0].min = min; + stats[0].max = max; + + stats[0].median = stats[0].mean; + range = MAX (0.5, 0xffff / (max - min)); + if (range == 0) return; + + ALLOCATE (hist, int, 0x10000); + bzero (hist, 0x10000*sizeof(int)); + + val = (float *)image[0].buffer; + for (i = 0; i < Npix; i++) { + bin = MIN (MAX (0, (*val - min) * range), 0xffff); + hist[bin] ++; + } + + Nhist = 0; + for (i = 0; (i < 0xffff) && (Nhist < 0.5*Npix); i++) + Nhist += hist[i]; + stats[0].median = i / range + min; + free (hist); + + return; +} + +# if (0) +void findStars (Image *image, Stars **stars, int *Nstars, double threshold) { + + /* binarize @ threshold */ + + binimage = createImage (image[0].Nx, image[0].Ny); + + Npix = image[0].Nx*image[0].Ny; + ap = image[0].buffer; + bp = binimage[0].buffer; + bzero (bp, Npix*sizeof (short)); + + for (i = 0; i < Npix; i++, ap++, bp++) { + if (*ap > threshold) * bp = 1; + } + + clearpix (); + + for (i = 0; i < Ny; i++) { + for (j = 0; j < Nx; j++) { + pix = j + i*Ny; + if (binimage.buffer[pix]) { + addpix (pix); + binimage.buffer[pix] = 0; + /* continue in row to end */ + for (k = j + 1; k < Nx; k++) { + pix = k + i*Nx; + if (!binimage.buffer[pix]) { + } + } + +# endif + +/* find stars: + - binarize @ threshold + - find all contiguous blobs + - find geom center of each blob +*/ + + + +/* + +..................... +....x................ +...xxx............... +....x...xxx.......... +.........xx.......... +..................... +..................... +..................... +..................... +..................... + + + */ Index: /branches/dimm-0-5/Ohana/src/opihi/dimm/Camera.c =================================================================== --- /branches/dimm-0-5/Ohana/src/opihi/dimm/Camera.c (revision 11221) +++ /branches/dimm-0-5/Ohana/src/opihi/dimm/Camera.c (revision 11221) @@ -0,0 +1,223 @@ +# include "dimm.h" + +static struct sbig_init info; + +int InitCamera (int port) { + + int i, state; + + for (i = 0; i < 10; i++) { + state = sbig_init (port, SBIG_IMAGING_CCD, &info); + if (state == -6) state = 0; + if (state == 0) { + DumpCameraInfo (); + return (TRUE); + } + gprint (GP_ERR, "retry...\n"); + } + + gprint (GP_ERR, "failed to init sbig camera on %d\n", port); + gprint (GP_ERR, "%s\n", sbig_show_error (state)); + return (FALSE); +} + +void DumpCameraInfo () { + + gprint (GP_ERR, "opened sbig camera:\n"); + gprint (GP_ERR, "linux_version: %f\n", info.linux_version); + gprint (GP_ERR, "nmbr_bad_columns: %d\n", info.nmbr_bad_columns); + gprint (GP_ERR, "imaging_abg_type: %d\n", info.imaging_abg_type); + gprint (GP_ERR, "serial_number: %s\n", info.serial_number); + gprint (GP_ERR, "firmware_version: %d\n", info.firmware_version); + gprint (GP_ERR, "camera_name: %s\n", info.camera_name); + gprint (GP_ERR, "nmbr_readout_modes: %d\n", info.camera_info[0].nmbr_readout_modes); + gprint (GP_ERR, "mode: %d\n", info.camera_info[0].readout_mode[0].mode); + gprint (GP_ERR, "width: %d\n", info.camera_info[0].readout_mode[0].width); + gprint (GP_ERR, "height: %d\n", info.camera_info[0].readout_mode[0].height); + gprint (GP_ERR, "gain: %d\n", info.camera_info[0].readout_mode[0].gain); + gprint (GP_ERR, "pixel_width: %d\n", info.camera_info[0].readout_mode[0].pixel_width); + gprint (GP_ERR, "pixel_height: %d\n", info.camera_info[0].readout_mode[0].pixel_height); + + gprint (GP_ERR, "ST5_AD_size: %d\n", info.ST5_AD_size); + gprint (GP_ERR, "ST5_filter_type: %d\n", info.ST5_filter_type); +} + +void CameraFullSize (int *x, int *y) { + *x = info.camera_info[0].readout_mode[0].width; + *y = info.camera_info[0].readout_mode[0].height; +} + +int SetTemperature (double temp) { + + int state; + struct sbig_cool cool; + + if (temp < -50) return (FALSE); + if (temp > +20) return (FALSE); + + cool.regulation = SBIG_TEMP_REGULATION_ON; + cool.temperature = (int) (10.0*temp + 0.5); + cool.direct_drive = 0; + + state = sbig_set_cooling (&cool); + if (state < 0) { + gprint (GP_ERR, "sbig error: %s\n", sbig_show_error (state)); + return (FALSE); + } + return (TRUE); +} + +double GetTemperature () { + + int state; + double temp; + struct sbig_status status; + + state = sbig_get_status (&status); + if (state < 0) { + gprint (GP_ERR, "sbig error: %s\n", sbig_show_error (state)); + return (-200.0); + } + temp = (status.ccd_temperature - 0.5) / 10.0; + return (temp); +} + +int DumpCameraStatus () { + + int state; + double temp; + struct sbig_status status; + + state = sbig_get_status (&status); + if (state < 0) { + gprint (GP_ERR, "sbig error: %s\n", sbig_show_error (state)); + return (FALSE); + } + + gprint (GP_ERR, "imaging_ccd_status: %d\n", status.imaging_ccd_status); + gprint (GP_ERR, "tracking_ccd_status: %d\n", status.tracking_ccd_status); + gprint (GP_ERR, "fan_on: %d\n", status.fan_on); + gprint (GP_ERR, "shutter_state: %d\n", status.shutter_state); + gprint (GP_ERR, "led_state: %d\n", status.led_state); + gprint (GP_ERR, "shutter_edge: %d\n", status.shutter_edge); + gprint (GP_ERR, "plus_x_relay: %d\n", status.plus_x_relay); + gprint (GP_ERR, "minus_x_relay: %d\n", status.minus_x_relay); + gprint (GP_ERR, "plus_y_relay: %d\n", status.plus_y_relay); + gprint (GP_ERR, "minus_y_relay: %d\n", status.minus_y_relay); + gprint (GP_ERR, "pulse_active: %d\n", status.pulse_active); + gprint (GP_ERR, "temperature_regulation: %d\n", status.temperature_regulation); + gprint (GP_ERR, "temperature_setpoint: %d\n", status.temperature_setpoint); + gprint (GP_ERR, "cooling_power: %d\n", status.cooling_power); + gprint (GP_ERR, "air_temperature: %d\n", status.air_temperature); + gprint (GP_ERR, "ccd_temperature: %d\n", status.ccd_temperature); + + return (TRUE); +} + +/* block until exposure is complete */ +int Exposure (double exptime) { + + int i, state; + struct sbig_expose expose; + struct sbig_status status; + + expose.ccd = SBIG_IMAGING_CCD; + expose.exposure_time = (int)(100.0*exptime); + expose.abg_state = SBIG_ABG_OFF; + expose.shutter = SBIG_EXPOSE_SHUTTER_NORMAL; /* shuttermode = ? */ + + /* drop this ? */ + /* usleep ((int)(exptime*1000000)); */ + state = sbig_expose (&expose); + if (state < 0) { + gprint (GP_ERR, "exposure error\n"); + gprint (GP_ERR, "%s\n", sbig_show_error (state)); + return (FALSE); + } + + for (i = 0; i < expose.exposure_time + 10; ++i) { + state = sbig_get_status (&status); + /* gprint (GP_ERR, "%d\n", state); */ + /* gprint (GP_ERR, "%d %d\n", status.imaging_ccd_status, status.shutter_state); */ + /* if (state == 0) return (TRUE); */ + if (status.imaging_ccd_status == -SBIG_NO_EXPOSURE_IN_PROGRESS) return (TRUE); + if (status.imaging_ccd_status == -SBIG_EXPOSURE_IN_PROGRESS) { + usleep (10000); + continue; + } + gprint (GP_ERR, "exposure error\n"); + gprint (GP_ERR, "%s\n", sbig_show_error (state)); + return (FALSE); + } + gprint (GP_ERR, "exposure timeout\n"); + return (FALSE); +} + +int readout_abort; +float readout_percent; +static int readout_callback (float percent) { + /* return 1 to continue, 0 to abort */ + if (((int)(percent) % 10) == 0) { gprint (GP_ERR, "."); } + readout_percent = percent; + if (readout_abort) return 0; + return 1; +} + +int ReadOut (int x, int y, int dx, int dy, int binning, unsigned short *buffer) { + + int state, Nbytes; + static struct sbig_readout readout; + + readout.x = x; + readout.y = y; + readout.width = dx; + readout.height = dy; + + Nbytes = readout.width*readout.height*sizeof(short); + + /* for bin 2x2 or 3x3, need to adjust dx, dy above */ + readout.ccd = SBIG_IMAGING_CCD; + readout.binning = SBIG_BIN_1X1; + readout.data = buffer; + readout.data_size_in_bytes = Nbytes; + readout.callback = readout_callback; + + gprint (GP_ERR, "%d, %d : %d x %d\n", readout.x, readout.y, readout.width, readout.height); + sync (); + readout_abort = FALSE; + state = sbig_readout (&readout); + gprint (GP_ERR, "\n"); + if (state < 0) { + gprint (GP_ERR, "sbig error: %s\n", sbig_show_error (state)); + return (FALSE); + } + return (TRUE); +} + +int OpenShutter () { + + int state; + struct sbig_control control; + + control.shutter = SBIG_OPEN_SHUTTER; + state = sbig_control (&control); + if (state < 0) { + gprint (GP_ERR, "sbig error: %s\n", sbig_show_error (state)); + return (FALSE); + } + return (TRUE); +} + +int CloseShutter () { + + int state; + struct sbig_control control; + + control.shutter = SBIG_CLOSE_SHUTTER; + state = sbig_control (&control); + if (state < 0) { + gprint (GP_ERR, "sbig error: %s\n", sbig_show_error (state)); + return (FALSE); + } + return (TRUE); +} Index: /branches/dimm-0-5/Ohana/src/opihi/dimm/Image.c =================================================================== --- /branches/dimm-0-5/Ohana/src/opihi/dimm/Image.c (revision 11221) +++ /branches/dimm-0-5/Ohana/src/opihi/dimm/Image.c (revision 11221) @@ -0,0 +1,85 @@ +# include "dimm.h" + +/*** this uses an Image structure from DIMM which + is different from the Image structure in DVO ***/ + +static Image *images = (Image *) NULL; +static int Nimages = 0; + +Image *createImage (int Nx, int Ny) { + + int N; + + if (Nx*Ny <= 0) return ((Image *) NULL); + + N = Nimages; + Nimages ++; + if (images == (Image *) NULL) { + ALLOCATE (images, Image, MAX (1, Nimages)); + } else { + REALLOCATE (images, Image, MAX (1, Nimages)); + } + + images[N].Nx = Nx; + images[N].Ny = Ny; + images[N].Nbytes = Nx*Ny*sizeof (short); + ALLOCATE (images[N].buffer, char, images[N].Nbytes); + + return (&images[N]); +} + +int freeImage (Image *entry) { + + int i, j, N; + + N = -1; + for (i = 0; (i < Nimages) && (N == -1) ; i++) { + if (&images[i] == entry) N = i; + } + if (N == -1) return (FALSE); + + free (images[N].buffer); + + for (j = N; j < Nimages - 1; j++) { + images[j] = images[j+1]; + } + + Nimages --; + REALLOCATE (images, Image, MAX (1, Nimages)); + return (TRUE); +} + +int writeImage (char *filename, Image *image) { + + Header header; + Matrix matrix; + + header.Naxes = 2; + header.Naxis[0] = image[0].Nx; + header.Naxis[1] = image[0].Ny; + header.bitpix = 16; + header.bzero = 0; + header.bscale = 1; + + gfits_create_header (&header); + gfits_create_matrix (&header, &matrix); + free (matrix.buffer); + + matrix.buffer = image[0].buffer; + + /* write meta-data to header */ + gfits_print (&header, "RA", "%lf", 1, image[0].ra); + gfits_print (&header, "DEC", "%lf", 1, image[0].dec); + gfits_print (&header, "EQUINOX", "%lf", 1, 2000.0); + + gfits_print (&header, "AIRMASS", "%lf", 1, image[0].airmass); + gfits_print (&header, "CCDTEMP", "%lf", 1, image[0].ccdtemp); + gfits_print (&header, "AIRTEMP", "%lf", 1, image[0].airtemp); + gfits_print (&header, "EXPTIME", "%lf", 1, image[0].exptime); + + gfits_write_header (filename, &header); + gfits_write_matrix (filename, &matrix); + + return (TRUE); +} + Index: /branches/dimm-0-5/Ohana/src/opihi/dimm/Makefile =================================================================== --- /branches/dimm-0-5/Ohana/src/opihi/dimm/Makefile (revision 11221) +++ /branches/dimm-0-5/Ohana/src/opihi/dimm/Makefile (revision 11221) @@ -0,0 +1,70 @@ +include ../../../Configure +default: dimm + +HOME = $(ROOT)/src/opihi +BIN = $(HOME)/bin +LIB = $(HOME)/lib +INC = $(HOME)/include +SRC = $(HOME)/dimm +DATA = $(DESTDATA)/dimm + +# link flags +LIBS1 = -ldvo -lkapa -lFITS -lohana $(LIBFLAGS) +LIBS2 = -lbasiccmd -ldatacmd -lastrocmd -lshell -ldata -lsbig +LFLAGS = -L$(LIB) -L$(DESTLIB) $(LIBDIRS) $(LIBS2) $(LIBS1) + +# dimm user commands and support functions ##################### + +funcs = \ +$(SRC)/Camera.$(ARCH).o \ +$(SRC)/Serial.$(ARCH).o \ +$(SRC)/Telescope.$(ARCH).o + +cmds = \ +$(SRC)/init.$(ARCH).o \ +$(SRC)/dimm.$(ARCH).o \ +$(SRC)/altaz.$(ARCH).o \ +$(SRC)/camera.$(ARCH).o \ +$(SRC)/findstars.$(ARCH).o \ +$(SRC)/telescope.$(ARCH).o \ +$(SRC)/version.$(ARCH).o + +libs = \ +$(DESTLIB)/libshell.a \ +$(DESTLIB)/libdata.a \ +$(DESTLIB)/libbasiccmd.a \ +$(DESTLIB)/libastrocmd.a \ +$(DESTLIB)/libdatacmd.a \ +$(DESTLIB)/libsbig.a + +dimm: sbig $(BIN)/dimm.$(ARCH) +$(SRC)/dimm.$(ARCH).o : $(libs) +$(BIN)/dimm.$(ARCH) : $(funcs) $(cmds) + +install: $(DESTBIN)/dimm help modules + +help: cmd.basic.help cmd.data.help cmd.astro.help dimm.help + +modules: dimm.modules + +# SBIG install functions +sbig: $(DESTINC)/sbig.h $(DESTLIB)/libsbig.a + @echo sbig code installed + +$(DESTINC)/sbig.h: $(SRC)/sbig/sbig.h + cp $(SRC)/sbig/sbig.h $(DESTINC)/sbig.h + +$(DESTLIB)/libsbig.a: $(SRC)/sbig/sbig.a + cp $(SRC)/sbig/sbig.a $(DESTLIB)/libsbig.a + +$(SRC)/sbig/sbig.a: $(SRC)/sbig/sbig.a.src + cp $(SRC)/sbig/sbig.a.src $(SRC)/sbig/sbig.a + +.PHONY: dimm + +include ../Makefile.Common + +# are these used or replaced? +# $(SRC)/analysis.$(ARCH).o \ +# $(SRC)/Analysis.$(ARCH).o \ +# $(SRC)/Image.$(ARCH).o \ Index: /branches/dimm-0-5/Ohana/src/opihi/dimm/Serial.c =================================================================== --- /branches/dimm-0-5/Ohana/src/opihi/dimm/Serial.c (revision 11221) +++ /branches/dimm-0-5/Ohana/src/opihi/dimm/Serial.c (revision 11221) @@ -0,0 +1,388 @@ +# include "dimm.h" +# include + +# define CR 0x0D +# define LF 0x0A +# define BEEP 0x07 +# define OPENERR -1 /* Port could not be opened */ +# define PORTERR -2 /* Opened port is not a serial (tty) port */ +# define BADCMDERR -3 /* Command sent to camera is not understood */ +# define TIMEOUTERR -4 /* No response */ + +# define SER_VERBOSE 0 +# define SER_DEBUG 0 + +# ifndef SER_VERBOSE +# define SER_VERBOSE 1 /* Be verbose? */ +# endif +# ifndef SER_DEBUG +# define SER_DEBUG 1 +# endif + +/* Defines for Serial Port */ +typedef struct { + int f; + int rate; + int parity; + int bits; + int stpbit; + char port[64]; +} Serial; + +static Serial serial = {0, 0, 0, 0, 0}; +static int SER_ECHO = 0; + +int SerialOpen (char *); + +int SerialVerbose (int mode) { + + SER_ECHO = mode; + return (TRUE); + +} + +int SerialInit (char *port) { + + strcpy (serial.port, port); + serial.rate = 2400; + serial.rate = 9600; + serial.parity = 0; + serial.bits = 8; + serial.stpbit = 1; + + serial.f = SerialOpen (serial.port); + if (serial.f <= 0) { + gprint (GP_ERR, "Error opening serial port %s - error %d.\n", serial.port, serial.f); + return (FALSE); + } + if (SerialBaudRate (serial.f, serial.rate)) return (FALSE); + if (SerialParity (serial.f, serial.parity)) return (FALSE); + if (SerialDataBits (serial.f, serial.bits)) return (FALSE); + if (SerialStopBit (serial.f, serial.stpbit)) return (FALSE); + return (TRUE); +} + +/********************************** Open *********************************/ +int SerialOpen (char *port) { + + int err = 0; + struct termios term; + char prefix[100]; + int fdesc = -1; + int locked; + struct flock lock; + + /* open serial line */ + if (SER_VERBOSE) printf ("Opening the serial port %s for read/write.\n", port); + fdesc = open (port, O_RDWR); + if (fdesc == -1) { + if (SER_VERBOSE) gprint (GP_ERR, "Cannot open %s for read/write.\n", port); + return OPENERR; + } + /* lock serial line */ + lock.l_type = F_WRLCK; + lock.l_len = 0; + lock.l_start = 0; + lock.l_whence = 0; + locked = fcntl (fdesc, F_SETLK, &lock); + if (locked == -1) { + gprint (GP_ERR, "can't lock serial line\n"); + close (fdesc); + return OPENERR; + } + + /* Get the serial port's attributes... */ + if (tcgetattr (fdesc, &term) == -1) { + if (SER_VERBOSE) gprint (GP_ERR, "Port is not a tty\n"); + return PORTERR; + } + + /* cfmakeraw (&term); */ + term.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON); + term.c_oflag &= ~OPOST; + term.c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN); + term.c_cflag &= ~(CSIZE|PARENB); + term.c_cflag |= CS8; + term.c_cc[VMIN] = 0; /* MIN setting...if 0, wait only for timeout */ + term.c_cc[VTIME] = 2; /* TIME setting...wait at most 1 sec for response + (ignored if c_cc[VMIN]>0) */ + tcsetattr (fdesc, TCSAFLUSH, &term); + +# if (0) + term.c_lflag &= ~ICANON; /* Turn OFF canonical input + (so it does it character by character) */ + term.c_cc[VMIN] = 0; /* MIN setting...if 0, wait only for timeout */ + term.c_cc[VTIME] = 10; /* TIME setting...wait at most 1 sec for response + (ignored if c_cc[VMIN]>0) */ + term.c_lflag &= ~ECHO; /* Turn OFF echoing... */ + term.c_iflag &= ~ICRNL; /* Don't map CR to NL on input */ + + /* Set port (terminal) to reflect the change...(flush first) */ + tcsetattr (fdesc, TCSAFLUSH, &term); +# endif + + return fdesc; +} + +/******************************* Baud Rate *******************************/ +int SerialBaudRate (int fdesc, int rate) { + int err = 0; + struct termios term; + + /* Get the serial port's attributes... */ + if (SER_VERBOSE) printf("Setting the serial port's baud rate.\n"); + if (tcgetattr (fdesc, &term) == -1) { + if (SER_VERBOSE) gprint (GP_ERR, "Port is not a tty\n"); + return PORTERR; + } + + /* Set the input and output baud rates to 'rate'... */ + switch (rate) { + case 1200: /* Set speed to 1200 */ + if (cfgetospeed(&term) != B1200) cfsetospeed(&term, B1200); + if (cfgetispeed(&term) != B1200) cfsetispeed(&term, B1200); + break; + case 2400: /* Set speed to 2400 */ + if (cfgetospeed(&term) != B2400) cfsetospeed(&term, B2400); + if (cfgetispeed(&term) != B2400) cfsetispeed(&term, B2400); + break; + case 9600: /* Set speed to 9600 */ + if (cfgetospeed(&term) != B9600) cfsetospeed(&term, B9600); + if (cfgetispeed(&term) != B9600) cfsetispeed(&term, B9600); + break; + case 19200: /* Set speed to 19200 */ + if (cfgetospeed(&term) != B19200) cfsetospeed(&term, B19200); + if (cfgetispeed(&term) != B19200) cfsetispeed(&term, B19200); + break; + default: + printf ("ERROR: Unknown Baud Rate\n"); + break; + } + + /* Set port (terminal) to reflect the change...(flush first) */ + tcsetattr(fdesc, TCSAFLUSH, &term); + return (FALSE); +} + +/****************************** Parity ********************************/ +int SerialParity (int fdesc, int parity) { + int err=0; + struct termios term; + char *prefix = "/dev/term/"; + + /* Get the serial port's attributes... */ + if (SER_VERBOSE) printf("Setting the serial port's parity.\n"); + if (tcgetattr(fdesc, &term) == -1) { + if (SER_VERBOSE) gprint (GP_ERR, "Port is not a tty\n"); + return PORTERR; + } + + if (parity == 0) /* Turn off parity generation... */ + term.c_cflag &= ~PARENB; + else if (parity == 1) { + term.c_cflag |= PARENB; /* Turn on parity generation... */ + term.c_cflag |= PARODD; /* Sets parity to odd */ + } + else if (parity == 2) /* Turn on parity generation... */ + term.c_cflag |= PARENB; /* Defaults parity to even */ + else + printf ("ERROR: Unknown parity specification\n"); + + /* Set port (terminal) to reflect the change...(flush first) */ + tcsetattr(fdesc, TCSAFLUSH, &term); + return (FALSE); +} + +/****************************Data Bit Size ***************************/ +int SerialDataBits(int fdesc, int bits) { + int err=0; + struct termios term; + + /* Get the serial port's attributes... */ + if (SER_VERBOSE) printf("Setting the serial port's data bit size.\n"); + if (tcgetattr(fdesc, &term) == -1) { + if (SER_VERBOSE) gprint (GP_ERR, "Port is not a tty\n"); + return PORTERR; + } + + switch (bits) { + case 5: /* Sets data bits to 5 */ + term.c_cflag &= ~CSIZE; + term.c_cflag |= CS5; + break; + case 6: /* Sets data bits to 6 */ + term.c_cflag &= ~CSIZE; + term.c_cflag |= CS6; + break; + case 7: /* Sets data bits to 7 */ + term.c_cflag &= ~CSIZE; + term.c_cflag |= CS7; + break; + case 8: /* Sets data bits to 8 */ + term.c_cflag &= ~CSIZE; + term.c_cflag |= CS8; + break; + default: + printf ("ERROR: Illegal data bit size\n"); + break; + } + + /* Set port (terminal) to reflect the change...(flush first) */ + tcsetattr(fdesc, TCSAFLUSH, &term); + return (FALSE); +} + +/****************************** Stop Bit ****************************/ +int SerialStopBit(int fdesc, int stpbit) { + int err=0; + struct termios term; + + /* Get the serial port's attributes... */ + if (SER_VERBOSE) printf("Setting the serial port's stop bit.\n"); + if (tcgetattr(fdesc, &term) == -1) { + if (SER_VERBOSE) gprint (GP_ERR, "Port is not a tty\n"); + return PORTERR; + } + + if (stpbit == 1) { /* Sets stop bit to 1 */ + if (term.c_cflag & CSTOPB) term.c_cflag |= CSTOPB; + } else { /* Else stop bit to 2 */ + term.c_cflag & CSTOPB; + } + + /* Set port (terminal) to reflect the change...(flush first) */ + tcsetattr(fdesc, TCSAFLUSH, &term); + return (FALSE); +} + +/**************************** Stop ***********************************/ +void SerialStop (int fdesc) { + if (SER_VERBOSE) printf("Closing the serial port.\n"); + close(fdesc); /* Close up shop... */ +} + +# define D_NREAD 1024 + +/* send a string to the serial port, wait for an answer */ +/* answer is returned on the pointer provided */ + +/**************************** Command ***********************************/ +int SerialCommand (char *in, char **out, int wait) { + + int i, j; + char *line; + int done, Nread, Nin, NREAD; + + if (SER_ECHO) gprint (GP_ERR, "command: %s\n", in); + + if (serial.f <= 0) { + gprint (GP_ERR, "serial line closed\n"); + if (out != (char **) NULL) { + *out = strcreate ("SERIAL OFF"); + /* return (char *) NULL instead? */ + } + return (FALSE); + } + + /* flush out the line */ + tcflush (serial.f, TCIOFLUSH); + +# if (0) + for (i = 0; i < strlen(in); i++) { + gprint (GP_ERR, "%d %x\n", i, in[i]); + } +# endif + + /* send command to serial line */ + Nin = write (serial.f, in, strlen(in)); + if (Nin != strlen(in)) { + gprint (GP_ERR, "Serial Command not sent\n"); + return (FALSE); + } + usleep (20000); + /* LX200 GPS requires some lead time (10msec) to check ready state */ + + /* create space to store answer */ + NREAD = D_NREAD; + ALLOCATE (line, char, NREAD); + bzero (line, NREAD); + Nread = Nin = 0; + + /* read data back from serial line until no response (Nin == 0) + or timeout (Nin == -1) && (i == wait) */ + + done = FALSE; + for (i = 0; !done && (i < wait); i++) { + Nin = read (serial.f, &line[Nread], 256); +# if (SER_DEBUG) + gprint (GP_ERR, "%d ", Nin); +# endif + if (Nin < 0) { /* error, check value */ + gprint (GP_ERR, "error?"); + continue; + } + if (Nin > 0) { + Nread += Nin; + line[Nread] = 0; + i = 0; + } + if (Nread > D_NREAD - 257) { + NREAD += D_NREAD; + REALLOCATE (line, char, NREAD); + } + if ((i > 0) && (Nin == 0)) done = TRUE; + usleep (2000); + } + + if (SER_ECHO) gprint (GP_ERR, "answer: %s\n", line); + + if (out == (char **) NULL) { + free (line); + } else { + *out = line; + } + return (TRUE); +} + + +/* raw: + cfmakeraw sets the terminal attributes as follows: + termios_p->c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON); + termios_p->c_oflag &= ~OPOST; + termios_p->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN); + termios_p->c_cflag &= ~(CSIZE|PARENB); + termios_p->c_cflag |= CS8; + + there conditions are turned off: + c_iflag: + IGNBRK ignore BREAK condition on input + BRKINT If IGNBRK is not set, generate SIGINT on BREAK condition, else read BREAK as + character \0. + PARMRK if IGNPAR is not set, prefix a character with a parity error or framing + error with \377 \0. If neither IGNPAR nor PARMRK is set, read a character + with a parity error or framing error as \0. + (IGNPAR ignore framing errors and parity errors.) + + ISTRIP strip off eighth bit + INLCR translate NL to CR on input + IGNCR ignore carriage return on input + ICRNL translate carriage return to newline on input (unless IGNCR is set) + IXON enable XON/XOFF flow control on output + + c_oflag: + OPOST enable implementation-defined output processing + + c_lflag: + ECHO echo input characters. + ECHONL if ICANON is also set, echo the NL character even if ECHO is not set. + ICANON enable canonical mode. This enables the special characters EOF, EOL, EOL2, + ERASE, KILL, REPRINT, STATUS, and WERASE, and buffers by lines. + ISIG when any of the characters INTR, QUIT, SUSP, or DSUSP are received, generate + the corresponding signal. + IEXTEN enable implementation-defined input processing. + + c_cflag: + CSIZE character size mask. Values are CS5, CS6, CS7, or CS8. (CS8 set). + PARENB enable parity generation on output and parity checking for input. + +*/ Index: /branches/dimm-0-5/Ohana/src/opihi/dimm/Telescope.c =================================================================== --- /branches/dimm-0-5/Ohana/src/opihi/dimm/Telescope.c (revision 11221) +++ /branches/dimm-0-5/Ohana/src/opihi/dimm/Telescope.c (revision 11221) @@ -0,0 +1,361 @@ +# include "dimm.h" + +# define SER_TIMEOUT 10 +# define SLEW_TIMEOUT 30 +# define dCOS(A) ((double) cos ((double)RAD_DEG*A)) +# define dSIN(A) ((double) sin ((double)RAD_DEG*A)) + +double distSky (double r1, double r2, double d1, double d2) { + + double x1, y1, z1; + double x2, y2, z2; + double cosT, dist; + + x1 = dCOS (r1) * dCOS (d1); + y1 = dSIN (r1) * dCOS (d1); + z1 = dSIN (d1); + + x2 = dCOS (r2) * dCOS (d2); + y2 = dSIN (r2) * dCOS (d2); + z2 = dSIN (d2); + + cosT = x1*x2 + y1*y2 + z1*z2; + dist = DEG_RAD * acos (cosT); + + return (dist); +} + +int getRD (double *r, double *d) { + + int status; + char *rastr, *decstr; + + status = SerialCommand (":GR#", &rastr, SER_TIMEOUT); + if (!status) return (FALSE); + + status = SerialCommand (":GD#", &decstr, SER_TIMEOUT); + if (!status) return (FALSE); + + status = str_to_radec (r, d, rastr, decstr); + if (!status) return (FALSE); + + free (rastr); + free (decstr); + + return (TRUE); +} + +int gotoRD (double r, double d) { + + double R, D, dist; + int Ntry, status; + char *str, *answer, cmd[64]; + + /* error on ra, dec means coords out of range */ + + /* set telescope coords, send */ + str = meade_ra_to_str (r); + sprintf (cmd, ":Sr%s#", str); free (str); + status = SerialCommand (cmd, &answer, SER_TIMEOUT); + if (!status) return (FALSE); + if (answer == (char *) NULL) return (FALSE); + if (strcmp (answer, "1")) return (FALSE); + free (answer); + + str = meade_dec_to_str (d); + sprintf (cmd, ":Sd%s#", str); free (str); + status = SerialCommand (cmd, &answer, SER_TIMEOUT); + if (!status) return (FALSE); + if (answer == (char *) NULL) return (FALSE); + if (strcmp (answer, "1")) return (FALSE); + free (answer); + + Ntry = 0; + status = SerialCommand (":MS#", &answer, SER_TIMEOUT); + if (!status) return (FALSE); + if (answer == (char *) NULL) return (FALSE); + if (strcmp (answer, "0")) { + gprint (GP_ERR, "error: %s\n", answer); + return (FALSE); + } + free (answer); + + /* watch for response? */ + status = FALSE; + while (!status) { + getRD (&R, &D); + dist = distSky (R, r, D, d); + if (dist < 0.1) return (TRUE); + usleep (100000); + Ntry ++; + if (Ntry > SLEW_TIMEOUT) return (FALSE); + } + return (status); +} + +/* actual offsets are x,y, convert to arcmin */ +int offset (char *direction, double distance) { + + /* Four rate choices: + slew (RS) - 8 degree / sec : rate 1 + find (RM) - 30 arcmin / sec : rate 2 + center (RC) - 4 arcmin / sec : rate 3 + guide (RG) - 15 arcsec / sec : rate 4 + + communication requires ~1.0 sec: + offset should use rate which gives shortest time > 2.0 sec + */ + +# define NRATE 4 + static double delay[NRATE] = {0.1, 0.1, 0.1, 0.1}; + static double rate[NRATE] = {480.0, 30.0, 4.0, 0.25}; + static char rcmd[NRATE][16] = {"RS", "RM", "RC", "RG"}; + + int i, status, rsel; + char dir, cmd[32]; + double tsel, dt; + + dir = 0; + if (!strcasecmp (direction, "y")) dir = (distance > 0) ? 'n' : 's'; + if (!strcasecmp (direction, "x")) dir = (distance > 0) ? 'w' : 'e'; + if (!dir) return (FALSE); + + /* distance is in arcmin */ + distance = fabs (distance); + + /* logic is bad -- does not catch too small distances */ + rsel = -1; + tsel = SLEW_TIMEOUT; + for (i = 0; i < NRATE; i++) { + dt = distance / rate[i] - delay[i]; + if ((dt > 0) && (dt < tsel)) { + rsel = i; + tsel = dt; + } + } + if (tsel < 0) { + gprint (GP_ERR, "offset %f arcmin below minimum\n", distance); + return (FALSE); + } + if (tsel > SLEW_TIMEOUT) { + gprint (GP_ERR, "offset %f arcmin above maximum\n", distance); + return (FALSE); + } + gprint (GP_ERR, "offsetting %c for %f seconds\n", dir, tsel); + + sprintf (cmd, ":%s#", rcmd[rsel]); + status = SerialCommand (cmd, (char **) NULL, SER_TIMEOUT); + if (!status) return (FALSE); + + sprintf (cmd, ":M%c#", dir); + status = SerialCommand (cmd, (char **) NULL, SER_TIMEOUT); + if (!status) return (FALSE); + + usleep ((int)(tsel*1000000)); + + sprintf (cmd, ":Q%c#", dir); + status = SerialCommand (cmd, (char **) NULL, SER_TIMEOUT); + if (!status) return (FALSE); + + return (TRUE); +} + +/* actual offsets are x,y, convert to arcmin */ +int toffset (char *direction, char *rate, double duration) { + +# define NRATE 6 + /* static char rcmd[NRATE][16] = {"RS", "RM", "RC", "RG"};*/ + static char rcmd[NRATE][64] = {"RS", "RM", "RC", "RG", "RA0.0085", "RE0.0085"}; + + int i, status, rsel; + char dir, cmd[32]; + double tsel, dt; + + dir = 0; + if (!strcasecmp (direction, "x")) dir = (duration > 0) ? 'w' : 'e'; + if (!strcasecmp (direction, "y")) dir = (duration > 0) ? 'n' : 's'; + if (!dir) return (FALSE); + duration = fabs (duration); + + status = FALSE; + for (i = 0; i < NRATE; i++) if (!strcmp (rcmd[i], rate)) status = TRUE; + if (!status) { + gprint (GP_ERR, "bad rate: %s\n", rate); + return (FALSE); + } + + sprintf (cmd, ":%s#", rate); + status = SerialCommand (cmd, (char **) NULL, SER_TIMEOUT); + if (!status) return (FALSE); + + sprintf (cmd, ":M%c#", dir); + status = SerialCommand (cmd, (char **) NULL, SER_TIMEOUT); + if (!status) return (FALSE); + + usleep ((int)(duration*1000000)); + + sprintf (cmd, ":Q%c#", dir); + status = SerialCommand (cmd, (char **) NULL, SER_TIMEOUT); + if (!status) return (FALSE); + + return (TRUE); +} + +int getXY (double *x, double *y) { + + char *answer; + + SerialCommand (":GA#", &answer, SER_TIMEOUT); + dms_to_ddd (x, answer); + free (answer); + + SerialCommand (":GZ#", &answer, SER_TIMEOUT); + dms_to_ddd (y, answer); + free (answer); + + return (TRUE); +} + +/* need error checking on these */ +int setRD (double r, double d) { + + char *str, *answer, cmd[64]; + + /* set telescope coords, send */ + str = meade_ra_to_str (r); + sprintf (cmd, ":Sr%s#", str); + SerialCommand (cmd, (char **) NULL, SER_TIMEOUT); + free (str); + + str = meade_dec_to_str (d); + sprintf (cmd, ":Sd%s#", str); + SerialCommand (cmd, (char **) NULL, SER_TIMEOUT); + free (str); + + SerialCommand (":CM#", &answer, SER_TIMEOUT); + gprint (GP_ERR, "result: %s\n", answer); + free (answer); + return (TRUE); +} + +int setSite (char *sitename, double lon, double lat) { + + struct tm *gmt; + struct timeval now; + char *str, line[32]; + + gprint (GP_ERR, "careful, this causes problems\n"); + return (FALSE); + + SerialCommand (":W1#", (char **) NULL, SER_TIMEOUT); + + /* Set site name 1 */ + sprintf (line, ":SM %s#", sitename); + SerialCommand (line, (char **) NULL, SER_TIMEOUT); + + /* Set site long */ + str = meade_deg_to_str (lon); + str[6] = 0; + sprintf (line, ":Sg%s#", str); + SerialCommand (line, (char **) NULL, SER_TIMEOUT); + free (str); + + /* Set site lat */ + str = meade_dec_to_str (lat); + sprintf (line, ":St%s#", str); + SerialCommand (line, (char **) NULL, SER_TIMEOUT); + free (str); + + /* set UTC offset to 0.0: offset + local = gmt */ + sprintf (line, ":SG+00#"); + SerialCommand (line, (char **) NULL, SER_TIMEOUT); + + /* Set local */ + gettimeofday (&now, (struct timezone *) NULL); + gmt = gmtime (&now.tv_sec); + sprintf (line, ":SL%02d:%02d:%02d#", gmt[0].tm_hour, gmt[0].tm_min, gmt[0].tm_sec); + SerialCommand (line, (char **) NULL, SER_TIMEOUT); + + return (TRUE); +} + +int setTime (char *lst) { + + struct tm *gmt; + struct timeval now; + char line[32], *answer; + + /* set UTC offset to 0.0: offset + local = gmt */ + sprintf (line, ":SG+10#"); + SerialCommand (line, (char **) NULL, SER_TIMEOUT); + + /* Set local */ + gettimeofday (&now, (struct timezone *) NULL); + gmt = localtime (&now.tv_sec); + sprintf (line, ":SL%02d:%02d:%02d#", gmt[0].tm_hour, gmt[0].tm_min, gmt[0].tm_sec); + SerialCommand (line, (char **) NULL, SER_TIMEOUT); + + /* + sprintf (line, ":SS%s#", lst); + SerialCommand (line, (char **) NULL, SER_TIMEOUT); + */ + + return (TRUE); +} + +int getSite (double *lon, double *lat, double *lst) { + + struct tm *gmt; + struct timeval now; + char *str, *answer, line[32]; + + /* : get latitude */ + SerialCommand (":Gt#", &answer, SER_TIMEOUT); + dms_to_ddd (lat, answer); + free (answer); + + /* : get longitude */ + SerialCommand (":Gg#", &answer, SER_TIMEOUT); + dms_to_ddd (lon, answer); + free (answer); + + /* : get LST */ + SerialCommand (":GS#", &answer, SER_TIMEOUT); + dms_to_ddd (lst, answer); + free (answer); + + return (TRUE); +} + +int ParkScope() { + + char *str, *answer, line[32]; + + SerialCommand (":hP#", &answer, SER_TIMEOUT); + free (answer); + + return (TRUE); + +} + +int SleepScope() { + + char *str, *answer, line[32]; + + SerialCommand (":hN#", &answer, SER_TIMEOUT); + free (answer); + + return (TRUE); + +} + +int WakeScope() { + + char *str, *answer, line[32]; + + SerialCommand (":hW#", &answer, SER_TIMEOUT); + free (answer); + + return (TRUE); + +} Index: /branches/dimm-0-5/Ohana/src/opihi/dimm/altaz.c =================================================================== --- /branches/dimm-0-5/Ohana/src/opihi/dimm/altaz.c (revision 11221) +++ /branches/dimm-0-5/Ohana/src/opihi/dimm/altaz.c (revision 11221) @@ -0,0 +1,88 @@ +# include "dimm.h" + +# define dCOS(A) ((double) cos ((double)RAD_DEG*A)) +# define dSIN(A) ((double) sin ((double)RAD_DEG*A)) + +double atan2 (double y, double x); + +int altaz (int argc, char **argv) { + + double alt, az, lat, rot; + double ha, dec; + double sind, sinh, cosh; + char *latstr; + + if (argc != 6) goto usage; + + if (!strcmp (argv[1], "-h")) goto radec; + if (!strcmp (argv[1], "-c")) goto altaz; + + radec: + /* ha/dec -> alt/az */ + ha = atof (argv[2]); + dec = atof (argv[3]); + + latstr = get_variable ("LATITUDE"); + if (latstr == (char *) NULL) { + gprint (GP_ERR, "please define $LATITUDE\n"); + return (FALSE); + } + lat = atof (latstr); + free (latstr); + + sind = dSIN (dec) * dSIN (lat) + dCOS (dec) * dCOS (ha) * dCOS (lat); + alt = DEG_RAD * asin (sind); + + sinh = - dCOS (dec) * dSIN (ha); + cosh = dSIN (dec) * dCOS (lat) - dCOS (dec) * dCOS (ha) * dSIN (lat); + + az = DEG_RAD * atan2 (sinh, cosh); + set_variable (argv[4], alt); + set_variable (argv[5], az); + + sinh = -dCOS(az) * dSIN(alt) * dSIN(ha) * dSIN(lat) + dSIN(az) * dSIN(alt) * dCOS(ha) - dSIN(ha) * dCOS(alt) * dCOS(lat); + cosh = -dSIN(az) * dSIN(ha) * dSIN(lat) - dCOS(az) * dCOS(ha); + rot = -DEG_RAD * atan2 (sinh, cosh); + set_variable ("ROT", rot); + + return (TRUE); + + altaz: + /* alt/az -> ha/dec */ + alt = atof (argv[4]); + az = atof (argv[5]); + + latstr = get_variable ("LATITUDE"); + if (latstr == (char *) NULL) { + gprint (GP_ERR, "please define $LATITUDE\n"); + return (FALSE); + } + lat = atof (latstr); + free (latstr); + + sind = dSIN (alt) * dSIN (lat) + dCOS (alt) * dCOS (az) * dCOS (lat); + dec = DEG_RAD * asin (sind); + + sinh = -dCOS (alt) * dSIN (az); + cosh = dSIN (alt) * dCOS (lat) - dCOS (alt) * dCOS (az) * dSIN (lat); + + ha = DEG_RAD * atan2 (sinh, cosh); + set_variable (argv[2], ha); + set_variable (argv[3], dec); + + sinh = -dCOS(az) * dSIN(alt) * dSIN(ha) * dSIN(lat) + dSIN(az) * dSIN(alt) * dCOS(ha) - dSIN(ha) * dCOS(alt) * dCOS(lat); + cosh = -dSIN(az) * dSIN(ha) * dSIN(lat) - dCOS(az) * dCOS(ha); + rot = -DEG_RAD * atan2 (sinh, cosh); + set_variable ("ROT", rot); + + return (TRUE); + + usage: + gprint (GP_ERR, "USAGE: altaz -h (ha) (dec) (alt) (az)\n"); + gprint (GP_ERR, "USAGE: altaz -c (ha) (dec) (alt) (az)\n"); + gprint (GP_ERR, " -h alt/az to ha/dec, -c ha/dec to alt/az\n"); + gprint (GP_ERR, " returned values in variables provided\n"); + return (FALSE); + +} + Index: /branches/dimm-0-5/Ohana/src/opihi/dimm/analysis.c =================================================================== --- /branches/dimm-0-5/Ohana/src/opihi/dimm/analysis.c (revision 11221) +++ /branches/dimm-0-5/Ohana/src/opihi/dimm/analysis.c (revision 11221) @@ -0,0 +1,184 @@ + +/* should this all be wrapped within an opihi implementation? */ + +typedef struct { + + /* image data area */ + int Nx, Ny; + char *buffer; + int Nbytes; + + /* image metadata */ + double ccdtemp; + double airtemp; + double ra, dec, airmass; + double exptime; + int binning; +} Image; + +subtractImage (Image *a, Image *b) { + + if (a[0].Nx != b[0].Nx) return (FALSE); + if (a[0].Ny != b[0].Ny) return (FALSE); + + Npix = a[0].Nx*a[0].Ny; + ap = (float *) a[0].buffer; + bp = (float *) b[0].buffer; + for (i = 0; i < Npix; i++, ap++, bp++) { + *ap -= *bp; + } + return (FALSE); +} + +statsImage (Image *image, Stats *stats) { + + val = (float *)image[0].buffer; + max = min = val[0]; + Npix = image[0].Nx*image[0].Ny; + for (i = 0; i < Npix; i++, val++) { + N1 += *val; + N2 += (*val)*(*val); + max = MAX (max, *val); + min = MIN (min, *val); + } + stats[0].mean = N1 / Npix; + stats[0].sigma = sqrt (N2 / Npix - SQ(stats[0].mean)); + stats[0].min = min; + stats[0].max = max; + + stats[0].median = stats[0].mean; + range = MAX (0.5, 0xffff / (max - min)); + if (range == 0) return (); + + ALLOCATE (hist, int, 0x10000); + bzero (hist, 0x10000*sizeof(int)); + + val = (float *)image[0].buffer; + for (i = 0; i < Npix; i++) { + bin = MIN (MAX (0, (*val - min) * range), 0xffff); + hist[bin] ++; + } + + Nhist = 0; + for (i = 0; (i < 0xffff) && (Nhist < 0.5*Npix); i++) + Nhist += hist[i]; + stats[0].median = i / range + min; + free (hist); + + return (); +} + +findStars (Image *image, Stars **stars, int *Nstars, double threshold) { + + /* binarize @ threshold */ + + binimage = createImage (image[0].Nx, image[0].Ny); + + Npix = image[0].Nx*image[0].Ny; + ap = image[0].buffer; + bp = binimage[0].buffer; + bzero (bp, Npix*sizeof (short)); + + for (i = 0; i < Npix; i++, ap++, bp++) { + if (*ap > threshold) * bp = 1; + } + + clearpix (); + + for (j = 0; j < Ny; j++) { + for (i = 0; i < Nx; i++) { + if (binimage.buffer[j*Nx + i]) { + status = fillrow (binimage.buffer, Nx, j*Nx, i, &xs, &xe); + for (J = j + 1; (J < Ny) && status; J++) { + for (I = xs; !binimage.buffer[J*Nx + I] && (I < xe); I++); + if (binimage.buffer[J*Nx + I]) { + status = fillrow (binimage.buffer, Nx, J*Nx, I, &xs, &xe); + } + } + /* we now have a stack of pixels, convert to a single star */ + statpix (&x, &y, image[0].buffer, Nx); + addstar (x, y); + clearpix (); + } + } + } +} + +/* find contiguous trigger pixels in row from starting point */ + +int fillrow (float *buffer, int Nx, int offset, int sx, int *xs, int *xe) { + + trigger = FALSE; + for (i = sx, pix = offset + i; buffer[pix] && (i < Nx); i++, pix++) { + addpix (pix); + buffer[pix] = 0; + trigger = TRUE; + *xe = i; + } + for (i = sx - 1, pix = offset + i; (i >= 0) && buffer[pix]; i--, pix--) { + addpix (pix); + buffer[pix] = 0; + trigger = TRUE; + *xs = i; + } + return (trigger); +} + +static int Npix = 0; +static int *Pix = (int *) NULL; + +addpix (int pix) { + Npix ++; + if (Pix == (int *) NULL) { + ALLOCATE (Pix, int, MAX (1, Npix)); + } else { + REALLOCATE (Pix, int, MAX (1, Npix)); + } + Pix[Npix - 1] = pix; +} + +clearpix () { + Npix = 0; + REALLOCATE (Pix, int, 1); +} + +statpix (double *x, double *y, float *buffer, int Nx) { + + int X, Y; + double Sx, Sy, So; + + So = Sx = Sy = 0; + for (i = 0; i < Npix; i++) { + Y = pix / Nx; + X = pix % Nx; + So += buffer[pix]; + Sx += X * buffer[pix]; + Sy += Y * buffer[pix]; + } + *x = Sx / So; + *y = Sy / So; +} + +/* find stars: + - binarize @ threshold + - find all contiguous blobs + - find geom center of each blob +*/ + + + +/* + +..................... +....x................ +...xxx............... +..........xxx.......... +.........xx.......... +..................... +..................... +..................... +..................... +..................... + + + */ Index: /branches/dimm-0-5/Ohana/src/opihi/dimm/camera.c =================================================================== --- /branches/dimm-0-5/Ohana/src/opihi/dimm/camera.c (revision 11221) +++ /branches/dimm-0-5/Ohana/src/opihi/dimm/camera.c (revision 11221) @@ -0,0 +1,130 @@ +# include "dimm.h" +# define EXIT_STATUS(S) { seteuid (UID); return (S); } + +static uid_t UID, EUID; + +SetEUID () { + + /* save the UID (ID of calling process) and EUID (should be root) */ + UID = getuid (); + EUID = geteuid (); + seteuid (UID); +} + +int camera (int argc, char **argv) { + + /* USAGE: + camera init port + camera expose exptime + camera readout x y dx dy + camera temp set value + camera temp get var + */ + + if (argc < 2) goto usage; + + seteuid (EUID); + + if (!strcasecmp (argv[1], "init")) { + int port, status; + + if (argc != 3) { + gprint (GP_ERR, "USAGE: camera init (port)\n"); + EXIT_STATUS (FALSE); + } + sscanf (argv[2], "%x", &port); + status = InitCamera (port); + EXIT_STATUS (status); + } + + if (!strcasecmp (argv[1], "expose")) { + + int status; + double exptime; + + if (argc != 3) { + gprint (GP_ERR, "USAGE: camera expose (exptime)\n"); + EXIT_STATUS (FALSE); + } + exptime = atof (argv[2]); + status = Exposure (exptime); + EXIT_STATUS (status); + } + + if (!strcasecmp (argv[1], "temp")) { + + int status; + double temp; + + if (argc != 3) { + gprint (GP_ERR, "USAGE: camera temp (temperature)\n"); + EXIT_STATUS (FALSE); + } + temp = atof (argv[2]); + status = SetTemperature (temp); + EXIT_STATUS (status); + } + + if (!strcasecmp (argv[1], "status")) { + + int status; + double temp; + + if (argc != 2) { + gprint (GP_ERR, "USAGE: camera status\n"); + EXIT_STATUS (FALSE); + } + DumpCameraStatus (); + EXIT_STATUS (TRUE); + } + + if (!strcasecmp (argv[1], "readout")) { + + int Nbuf, status; + double temp; + int x, y, dx, dy, NX, NY; + Buffer *buf; + + if ((argc != 7) && (argc != 3)) { + gprint (GP_ERR, "USAGE: camera readout (buffer) x y dx dy\n"); + EXIT_STATUS (FALSE); + } + + if ((buf = SelectBuffer (argv[2], OLDBUFFER, TRUE)) == NULL) EXIT_STATUS (FALSE); + + CameraFullSize (&NX, &NY); + x = y = 0; + dx = NX; + dy = NY; + if (argc == 7) { + x = atof (argv[3]); + y = atof (argv[4]); + dx = atof (argv[5]); + dy = atof (argv[6]); + } + + /* generate a buffer to store the image */ + gfits_free_matrix (&buf[0].matrix); + gfits_free_header (&buf[0].header); + CreateBuffer (buf, dx, dy, -32, 0.0, 1.0); + strcpy (buf[0].file, "(empty)"); + + ReadOut (x, y, dx, dy, 1, buf[0].matrix.buffer); + + gfits_convert_format (&buf[0].header, &buf[0].matrix, -32, 1.0, 0.0, FT_UNSIGN_MODE); + + EXIT_STATUS (TRUE); + } + +usage: + gprint (GP_ERR, "camera init port\n"); + gprint (GP_ERR, "camera expose exptime\n"); + gprint (GP_ERR, "camera readout x y dx dy\n"); + gprint (GP_ERR, "camera temp set value\n"); + gprint (GP_ERR, "camera temp get var\n"); + seteuid (UID); + return (FALSE); + +} + + Index: /branches/dimm-0-5/Ohana/src/opihi/dimm/dimm.c =================================================================== --- /branches/dimm-0-5/Ohana/src/opihi/dimm/dimm.c (revision 11221) +++ /branches/dimm-0-5/Ohana/src/opihi/dimm/dimm.c (revision 11221) @@ -0,0 +1,60 @@ +# include "opihi.h" + +# define opihi_name "DIMM" +# define opihi_prompt "dimm: " +# define opihi_description "DIMM telescope controller\n" +# define opihi_history ".dimm" +# define opihi_rcfile ".dimmrc" + +/* program-dependent initialization */ +void program_init (int *argc, char **argv) { + + auto_break = TRUE; + + /* load the commands used by this implementation */ + InitBasic (); + InitData (); + InitAstro (); + InitDIMM (); + + rl_readline_name = opihi_name; + rl_attempted_completion_function = command_completer; + + set_str_variable ("HISTORY", opihi_history); + set_str_variable ("PROMPT", opihi_prompt); + set_str_variable ("RCFILE", opihi_rcfile); + +# ifdef DATADIR_DEFAULT + { + char *datadir; + char *helpdir; + char *modules; + datadir = MACRO_NAME(DATADIR_DEFAULT); + /* set_str_variable ("DATADIR", datadir); */ + ALLOCATE (helpdir, char, strlen(datadir) + strlen("/help") + 2); + sprintf (helpdir, "%s/help", datadir); + set_str_variable ("HELPDIR", helpdir); + free (helpdir); + ALLOCATE (modules, char, strlen(datadir) + strlen("/modules") + 2); + sprintf (modules, "%s/modules", datadir); + set_str_variable ("MODULES:0", modules); + set_int_variable ("MODULES:n", 1); + free (modules); + } +# endif + + return; +} + +/* standard welcome message */ +void welcome () { + gprint (GP_ERR, "\n"); + gprint (GP_ERR, "Welcome to %s - %s\n\n", opihi_name, opihi_description); +} + +/* add program-dependent exit functions here */ +void cleanup () { + QuitImage (); + QuitGraph (); + return; +} Index: /branches/dimm-0-5/Ohana/src/opihi/dimm/findstars.c =================================================================== --- /branches/dimm-0-5/Ohana/src/opihi/dimm/findstars.c (revision 11221) +++ /branches/dimm-0-5/Ohana/src/opihi/dimm/findstars.c (revision 11221) @@ -0,0 +1,152 @@ +# include "dimm.h" + +int fillrow (char *buffer, int Nx, int offset, int sx, int *xs, int *xe); +int addpix (int pix); +int clearpix (); +int freepix (); +int statpix (float *x, float *y, float *buffer, int Nx); +int addstar (double x, double y); + +Vector *vecx, *vecy, *vecf, *vecn; + +int findstars (int argc, char **argv) { + + int i, j, I, J, Npix, Nbuf, status; + int xs, xe, Nx, Ny; + char *binary, *bp; + float *ap, threshold, x, y; + Buffer *buf; + + if (argc != 3) { + gprint (GP_ERR, "USAGE: findstars (buffer) (threshold)\n"); + return (FALSE); + } + + if ((buf = SelectBuffer (argv[1], OLDBUFFER, TRUE)) == NULL) return (FALSE); + threshold = atof (argv[2]); + + if ((vecx = SelectVector ("star_x", ANYVECTOR, TRUE)) == NULL) return (FALSE); + if ((vecy = SelectVector ("star_y", ANYVECTOR, TRUE)) == NULL) return (FALSE); + if ((vecf = SelectVector ("star_f", ANYVECTOR, TRUE)) == NULL) return (FALSE); + if ((vecn = SelectVector ("star_n", ANYVECTOR, TRUE)) == NULL) return (FALSE); + + vecx[0].Nelements = vecy[0].Nelements = 0; + vecf[0].Nelements = vecn[0].Nelements = 0; + + REALLOCATE (vecx[0].elements, float, 1); + REALLOCATE (vecy[0].elements, float, 1); + REALLOCATE (vecf[0].elements, float, 1); + REALLOCATE (vecn[0].elements, float, 1); + + /* binarize @ threshold */ + Nx = buf[0].header.Naxis[0]; + Ny = buf[0].header.Naxis[1]; + Npix = Nx*Ny; + ALLOCATE (binary, char, Npix); + + ap = (float *) buf[0].matrix.buffer; + bp = binary; + bzero (bp, Npix); + + for (i = 0; i < Npix; i++, ap++, bp++) { + if (*ap > threshold) *bp = 1; + } + + for (j = 0; j < Ny; j++) { + for (i = 0; i < Nx; i++) { + if (binary[j*Nx + i]) { + clearpix (); + status = fillrow (binary, Nx, j*Nx, i, &xs, &xe); + for (J = j + 1; (J < Ny) && status; J++) { + for (I = xs; !binary[J*Nx + I] && (I <= xe); I++); + status = fillrow (binary, Nx, J*Nx, I, &xs, &xe); + } + /* we now have a stack of pixels, find geometric center */ + statpix (&x, &y, (float *)buf[0].matrix.buffer, Nx); + } + } + } + freepix (); + return (TRUE); +} + +/* find contiguous trigger pixels in row from starting point */ +int fillrow (char *buffer, int Nx, int offset, int sx, int *xs, int *xe) { + + int i, pix, trigger; + + *xe = *xs = sx; + trigger = FALSE; + for (i = sx, pix = offset + i; buffer[pix] && (i < Nx); i++, pix++) { + addpix (pix); + buffer[pix] = 0; + trigger = TRUE; + *xe = i; + } + for (i = sx - 1, pix = offset + i; (i >= 0) && buffer[pix]; i--, pix--) { + addpix (pix); + buffer[pix] = 0; + trigger = TRUE; + *xs = i; + } + return (trigger); +} + +static int Npixlist = 0; +static int *pixlist = (int *) NULL; + +addpix (int pix) { + Npixlist ++; + if (pixlist == (int *) NULL) { + ALLOCATE (pixlist, int, MAX (1, Npixlist)); + } else { + REALLOCATE (pixlist, int, MAX (1, Npixlist)); + } + pixlist[Npixlist - 1] = pix; +} + +clearpix () { + Npixlist = 0; + REALLOCATE (pixlist, int, 1); +} + +freepix () { + Npixlist = 0; + free (pixlist); + pixlist = (int *) NULL; +} + +statpix (float *x, float *y, float *buffer, int Nx) { + + int i, X, Y, pix, Nv, No; + double Sx, Sy, So; + + So = Sx = Sy = 0; + for (i = 0; i < Npixlist; i++) { + pix = pixlist[i]; + Y = pix / Nx; + X = pix % Nx; + So += buffer[pix]; + Sx += X * buffer[pix]; + Sy += Y * buffer[pix]; + } + *x = Sx / So; + *y = Sy / So; + gprint (GP_ERR, "%f %f %f %d\n", *x, *y, So, Npixlist); + + No = vecx[0].Nelements; + Nv = No + 1; + vecx[0].Nelements = vecy[0].Nelements = Nv; + vecf[0].Nelements = vecn[0].Nelements = Nv; + + REALLOCATE (vecx[0].elements, float, MAX (Nv, 1)); + REALLOCATE (vecy[0].elements, float, MAX (Nv, 1)); + REALLOCATE (vecf[0].elements, float, MAX (Nv, 1)); + REALLOCATE (vecn[0].elements, float, MAX (Nv, 1)); + + vecx[0].elements[No] = *x; + vecy[0].elements[No] = *y; + vecf[0].elements[No] = So; + vecn[0].elements[No] = Npixlist; + +} Index: /branches/dimm-0-5/Ohana/src/opihi/dimm/init.c =================================================================== --- /branches/dimm-0-5/Ohana/src/opihi/dimm/init.c (revision 11221) +++ /branches/dimm-0-5/Ohana/src/opihi/dimm/init.c (revision 11221) @@ -0,0 +1,25 @@ +# include "dimm.h" + +int altaz PROTO((int, char **)); +int camera PROTO((int, char **)); +int findstars PROTO((int, char **)); +int telescope PROTO((int, char **)); +int version PROTO((int, char **)); + +static Command cmds[] = { + {"altaz", altaz, "altaz / celestial coord conversions"}, + {"camera", camera, "camera functions"}, + {"findstars", findstars, "find objects on image"}, + {"telescope", telescope, "telescope communications"}, + {"version", version, "show version information"}, +}; + +void InitDIMM () { + + int i; + + for (i = 0; i < sizeof (cmds) / sizeof (Command); i++) { + AddCommand (&cmds[i]); + } + +} Index: /branches/dimm-0-5/Ohana/src/opihi/dimm/sbig/sbig.h =================================================================== --- /branches/dimm-0-5/Ohana/src/opihi/dimm/sbig/sbig.h (revision 11221) +++ /branches/dimm-0-5/Ohana/src/opihi/dimm/sbig/sbig.h (revision 11221) @@ -0,0 +1,222 @@ +#ifndef _SBIG_H +#define _SBIG_H + +#define VERSION 2.0 + +struct sbig_init { + float linux_version; + int nmbr_bad_columns; /* bad columns in imaging CCD */ + int bad_columns[4]; + int imaging_abg_type; /* 0 no ABG, 1 ABG present */ + char serial_number[10]; + unsigned firmware_version; + char camera_name[64]; + struct camera_info { + int nmbr_readout_modes; + struct readout_mode { + int mode; + int width; /* pixels */ + int height; /* height */ + int gain; /* in 0.01 e-/ADU */ + unsigned pixel_width; /* in nanometers */ + unsigned pixel_height; /* in nanometers */ + } readout_mode[12]; + } camera_info[2]; + int ST5_AD_size; + int ST5_filter_type; +}; +extern int sbig_init(int port, int options, struct sbig_init *); + +#define SBIG_IMAGING_CCD 0 +#define SBIG_TRACKING_CCD 1 + +#define SBIG_CCD_STATUS_IDLE 0 +#define SBIG_CCD_STATUS_IN_PROGRESS 2 +#define SBIG_CCD_STATUS_COMPLETE 3 + +#define SBIG_CCD_SHUTTER_OPENED 0 +#define SBIG_CCD_SHUTTER_CLOSED 1 +#define SBIG_CCD_SHUTTER_OPENING 2 +#define SBIG_CCD_SHUTTER_CLOSING 3 + +struct sbig_status { + int imaging_ccd_status; + int tracking_ccd_status; + int fan_on; + int shutter_state; + int led_state; + int shutter_edge; + int plus_x_relay; + int minus_x_relay; + int plus_y_relay; + int minus_y_relay; + int pulse_active; + int temperature_regulation; + int temperature_setpoint; + int cooling_power; + int air_temperature; + int ccd_temperature; +}; +extern int sbig_get_status(struct sbig_status *); + + +#define SBIG_LEAVE_SHUTTER 0 +#define SBIG_OPEN_SHUTTER 1 +#define SBIG_CLOSE_SHUTTER 2 +#define SBIG_INITIALIZE_SHUTTER 3 + +#define SBIG_LED_OFF 0 +#define SBIG_LED_ON 1 +#define SBIG_LED_BLINK_SLOW 2 +#define SBIG_LED_BLINK_FAST 3 + +struct sbig_control { + int fan_on; + int shutter; + int led; +}; +extern int sbig_control(struct sbig_control *); + +struct sbig_pulse { + int nmbr_pulses; /* 0 to 255 */ + int pulse_width; /* microsec, min 9 */ + int pulse_interval; /* microsec, min 27+pulse_width */ +}; +extern int sbig_pulse(struct sbig_pulse *); + +struct sbig_relay { + int x_plus_time; + int x_minus_time; + int y_plus_time; + int y_minus_time; +}; +extern int sbig_activate_relay(struct sbig_relay *); + + +/* + * Shutter control. 0 for no change in shutter (i.e. control of shutter + * using SBigControl class), 1 normal shutter (open during exposure, + * closed otherwise), 2 shutter closed (for taking dark frames). + */ +#define SBIG_EXPOSE_SHUTTER_UNCHANGED 0 +#define SBIG_EXPOSE_SHUTTER_NORMAL 1 +#define SBIG_EXPOSE_SHUTTER_CLOSED 2 + +struct sbig_expose { + int ccd; + int exposure_time; + int abg_state; + int shutter; +}; +extern int sbig_expose(struct sbig_expose *); + + +/* + * Terminate the image and read it out. + * Use width == 0 and height == 0 to abort an image with no readout (all + * params other than ccd ignored) + */ +#define SBIG_BIN_1X1 0 +#define SBIG_BIN_2X2 1 +#define SBIG_BIN_3X3 2 + +struct sbig_readout { + int ccd; + int binning; + int x, y; + int width, height; + unsigned short *data; + int data_size_in_bytes; + int (*callback)(float percent_complete); +}; +extern int sbig_readout(struct sbig_readout *); + +#define SBIG_NO_SHUTTER_DELAY 0x0001 /* don't wait for shutter to close */ +struct sbig_readout2 { + int flags; /* see immediately above */ + int ccd; + int binning; + int x, y; + int width, height; + unsigned short *data; + int data_size_in_bytes; + int (*callback)(float percent_complete); +}; +extern int sbig_readout2(struct sbig_readout2 *); + + +#define SBIG_TEMP_REGULATION_OFF 0 +#define SBIG_TEMP_REGULATION_ON 1 +#define SBIG_TEMP_REGULATION_DIRECT_DRIVE 2 + +/* + * Antiblooming gate control values + */ +#define SBIG_ABG_OFF 0 +#define SBIG_ABG_LOW 1 +#define SBIG_ABG_MEDIUM 2 +#define SBIG_ABG_HIGH 3 + +struct sbig_cool { + int regulation; /* 0 off, 1 on, 2 direct_drive */ + int temperature; /* in 0.1 deg C, if 'on' */ + int direct_drive; /* power [0..255], direct_drive */ +}; +extern int sbig_set_cooling(struct sbig_cool *); + +extern int sbig_set_ao7_deflection(int x_deflection, int y_deflection); + +extern int sbig_set_ao7_focus(int type); + +#define SBIG_AO7_FOCUS_SOFT_CENTER 4 +#define SBIG_AO7_FOCUS_HARD_CENTER 3 +#define SBIG_AO7_FOCUS_STEP_TOWARD_SCOPE 2 +#define SBIG_AO7_FOCUS_STEP_FROM_SCOPE 1 + +/* + * Return Error Codes + * + * These are the error codes returned by the driver + * function. They are prefixed with CE_ to designate + * them as camera errors. + * + * The return codes from the sbig_xxx() routines will + * be the NEGATIVE of these on an error. + * + */ +#define SBIG_CAMERA_NOT_FOUND -1 +#define SBIG_EXPOSURE_IN_PROGRESS -2 +#define SBIG_NO_EXPOSURE_IN_PROGRESS -3 +#define SBIG_UNKNOWN_COMMAND -4 +#define SBIG_BAD_CAMERA_COMMAND -5 +#define SBIG_BAD_PARAMETER -6 +#define SBIG_TX_TIMEOUT -7 +#define SBIG_RX_TIMEOUT -8 +#define SBIG_NAK_RESBIGIVED -9 +#define SBIG_CAN_RESBIGIVED -10 +#define SBIG_UNKNOWN_RESPONSE -11 +#define SBIG_BAD_LENGTH -12 +#define SBIG_AD_TIMEOUT -13 +#define SBIG_CHECKSUM_ERROR -14 +#define SBIG_EEPROM_ERROR -15 +#define SBIG_SHUTTER_ERROR -16 +#define SBIG_UNKNOWN_CAMERA -17 +#define SBIG_DRIVER_NOT_FOUND -18 +#define SBIG_DRIVER_NOT_OPEN -19 +#define SBIG_DRIVER_NOT_CLOSED -20 +#define SBIG_SHARE_ERROR -21 +#define SBIG_TSBIG_NOT_FOUND -22 +#define SBIG_NEXT_ERROR -23 +#define SBIG_NOT_ROOT -24 +char *sbig_show_error(int); + +/* + * IO strategy flags + */ +#define SBIG_DISABLE_INTERRUPTS 0x001 +#define SBIG_LOCK_ALL 0x002 +#define SBIG_SHORT_DELAYS 0x004 +#define SBIG_DEFAULT_STRATEGY (SBIG_DISABLE_INTERRUPTS|SBIG_LOCK_ALL) +void sbig_set_linux_strategy(int); + +#endif /* S_BIG_H */ Index: /branches/dimm-0-5/Ohana/src/opihi/dimm/sbig/sp_ccdcontrol.c =================================================================== --- /branches/dimm-0-5/Ohana/src/opihi/dimm/sbig/sp_ccdcontrol.c (revision 11221) +++ /branches/dimm-0-5/Ohana/src/opihi/dimm/sbig/sp_ccdcontrol.c (revision 11221) @@ -0,0 +1,470 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "sbig.h" +#include "fh/fh.h" /* CFHT FITS Handling library */ + +#define N_FITS_ENTRIES 33 + +/* + * The following hack is needed if you want to use sbig.a w/ libc5 + */ +#ifndef __bzero +void __bzero(void* s, int n) +{ + memset(s, 0, n); +} +#endif + +static struct sbig_init info; + +static int write_fits(int width, int height, double etime, int binmode, unsigned short *data); + +static struct sbig_readout readout; + +/* + * This is the 'progress' callback + * passed to sbig_readout() + */ +static int readout_callback(float percent) +{ + gprint (GP_ERR, "progress: Reading %d x %d pixels (%d%%)\r", + readout.width, readout.height, (int)percent); + /* return 1 to continue, 0 to abort */ + return 1; +} + +/* + * Start an exposure, wait for it, then download from the camera + * in bands. This is somewhat complex, since it handles any size + * subimage of the CCD, and bands too. + */ +static void take_picture(double etime, int binmode, int shuttermode, int x, int y, int w, int h) +{ + int ret, i, needed; + static unsigned short *buffer; + static int buffer_size; + struct sbig_expose expose; + struct sbig_status status; + double f; + + expose.ccd = 0; /* Always in imaging mode, not tracking + since CFHT PF does the tracking*/ + + if(binmode<0 || binmode>3){ + gprint (GP_ERR, "Imaging binmode options: [0=1x1, *1=2x2, 2=3x3]\n"); + exit(EXIT_FAILURE); + } + readout.binning=binmode; + + readout.x=x; + readout.y=y; + readout.width=w; + readout.height=h; + if (readout.width == 0) { + readout.width = + info.camera_info[expose.ccd].readout_mode[readout.binning].width - x; + } else + if (readout.width + x > + info.camera_info[expose.ccd].readout_mode[readout.binning].width) { + gprint (GP_ERR, "Raster X or Width parameter out of range.\n"); + exit(EXIT_FAILURE); + } + + if (readout.height == 0) { + readout.height = + info.camera_info[expose.ccd].readout_mode[readout.binning].height - y; + } else + if (readout.height + y > + info.camera_info[expose.ccd].readout_mode[readout.binning].height) { + gprint (GP_ERR, "Raster Y or Height parameter out of range.\n"); + exit(EXIT_FAILURE); + } + + f = etime; + expose.exposure_time = (int)(100.0*f); + expose.abg_state = SBIG_ABG_OFF; /* SBIG_ABG_MEDIUM */ + + expose.shutter = shuttermode; /* No shutter present */ + + sync(); + ret = sbig_expose(&expose); + if (ret < 0) + gprint (GP_ERR, "sbig error: %s\n", sbig_show_error(ret)); + + gprint (GP_ERR, "progress: Sleeping for %g seconds\r", 0.01*expose.exposure_time); + + if (expose.exposure_time > 100) { + for (i = 0; i < expose.exposure_time; i += 100) { + sbig_get_status(&status); + gprint (GP_ERR, "progress: Exposure in progress; ccd_status=%d, shutter=%d (%d%%)\r", + status.imaging_ccd_status, status.shutter_state, + i * 100 / expose.exposure_time); + sleep(1); + } + } else + usleep(expose.exposure_time*10000); + + /* wait for exposure to complete */ + gprint (GP_ERR, "progress: Waiting for controller (100%%)\r"); + + for (i = 0; i < 1000; ++i) { + ret = sbig_get_status(&status); + if (ret < 0) { + gprint (GP_ERR, "sbig error: %s\n", sbig_show_error(ret)); + break; + } + if (status.imaging_ccd_status != 3) + gprint (GP_ERR, "logonly: ccd_status=%d\n", status.imaging_ccd_status); + + if (readout.ccd == 0) { + if (status.imaging_ccd_status != 2) + break; + } else { + if (status.tracking_ccd_status != 2) + break; + } + usleep(50000); + } + if (i) + gprint (GP_ERR, "warning: Exposure took an extra %g seconds\n", 0.050*i); + + if (i == 1000) + gprint (GP_ERR, "error: EXPOSURE DIDN'T FINISH!\n"); + else + gprint (GP_ERR, "progress: Exposure complete (100%%)\n"); + + readout.ccd = expose.ccd; + readout.binning = readout.binning; + needed = readout.height*readout.width*sizeof(short); + if (buffer_size < needed) { + if (buffer != NULL) + free(buffer); + buffer = malloc(buffer_size = needed); + } + readout.data = buffer; + readout.data_size_in_bytes = buffer_size; + readout.callback = readout_callback; + + sync(); + if ((ret = sbig_readout(&readout)) < 0) { + gprint (GP_ERR, "sbig error: %s\n", sbig_show_error(ret)); + return; + } + + gprint (GP_ERR, "progress: Writing FITS data to stdout\n"); + + if(write_fits(readout.width, readout.height, etime, binmode, buffer)==-1) + gprint (GP_ERR, "error: Could not write FITS file to stdout.\n"); + gprint (GP_ERR, "progress: sp_ccdcontrol done.\n"); +} + +static int write_fits(int w, int h, double etime, int binmode, unsigned short *data) +{ + HeaderUnit hu; + register int i; + double datamin = DBL_MAX, datamax = DBL_MIN; + unsigned short u; + char str[80]; /* For building string FITS headers */ + time_t date; + + int ret; /* Return value for sbig_status */ + struct sbig_status sbstat; /* Status structure */ + + /* Get status to add to FITS header */ + sync(); + ret = sbig_get_status(&sbstat); + + if (ret < 0) { + gprint (GP_ERR, "error: sbig_get_status failed: %s\n", sbig_show_error(ret)); + exit(EXIT_FAILURE); + } + + /* shouldn't we scale this to fit, first? */ + for (i = w*h; --i >= 0; ) + { + u = data[i]; + if (u > datamax) datamax = u; + if (u < datamin) datamin = u; + data[i] = ((u<<8)|(u>>8)) ^ 0x0080; /* -32768 */ + } + + time(&date); + + hu = fh_create(); + fh_reserve(hu, 50); /* Reserve space for 50 cards (TCS, Elixir?, etc.) */ + fh_set_bool(hu, 0., "SIMPLE", 1, "Standard FITS"); + fh_set_int(hu, 1.0, "BITPIX", 16,"16-bit data"); + fh_set_int(hu, 2.0, "NAXIS", 2, "Number of axes"); + fh_set_int(hu, 2.1, "NAXIS1", w, "Number of pixel columns"); + fh_set_int(hu, 2.2, "NAXIS2", h, "Number of pixel rows"); + fh_set_int(hu, 5.0, "PCOUNT", 0, "No 'random' parameters"); + fh_set_int(hu, 6.0, "GCOUNT", 1, "Only one group"); + + strftime(str, sizeof(str)-1, "%Y-%m-%dT%T", gmtime(&date)); + fh_set_str(hu, 104, "DATE", str, "UTC Date of file creation"); + strftime(str, sizeof(str)-1, "%a %b %d %H:%M:%S %Z %Y", localtime(&date)); + fh_set_str(hu, 104.1, "HSTTIME", str, "Local time in Hawaii"); + + fh_set_str(hu, 105, "ORIGIN", "CFHT", "Canada-France-Hawaii Telescope"); + + fh_set_flt(hu, 141.,"BZERO", 32768.0, 6, "Zero factor"); + fh_set_flt(hu, 142.,"BSCALE", 1.0, 2, "Scale factor"); + fh_set_flt(hu, 150, "DATAMIN", datamin, 6, "Minimum value of the data"); + fh_set_flt(hu, 151, "DATAMAX", datamax, 6, "Maximum value of the data"); + fh_set_flt(hu, 160, "SATURATE", 4016.0, 6, "Saturation value"); + + fh_set_flt(hu, 220, "EXPTIME", etime, 5, "Integration time (seconds)"); + sprintf(str, "%d %d", binmode + 1, binmode + 1); + fh_set_str(hu, 230, "CCDSUM", str, "Binning factors"); + fh_set_int(hu, 231, "CCDBIN1", binmode + 1, "Binning factor along first axis"); + fh_set_int(hu, 232, "CCDBIN2", binmode + 1, "Binning factor along second axis"); + + fh_set_com(hu, 1400.0, "COMMENT", ""); + fh_set_com(hu, 1400.1, "COMMENT", " SBIG status record:"); + fh_set_com(hu, 1400.2, "COMMENT", ""); + if (sbstat.imaging_ccd_status==0) + fh_set_str(hu, 1500, "DETSTAT", "ok", "(SBIG imaging_ccd_status is 0)"); + else + fh_set_int(hu, 1500, "DETSTAT", sbstat.imaging_ccd_status, "SBIG error!"); + fh_set_flt(hu, 1500.1, "DETTEM", sbstat.ccd_temperature/10., 3, "Detector temperature"); + fh_set_int(hu, 1500.2, "DETTEMRG", sbstat.temperature_regulation, "1=set temp 0=set power"); + fh_set_int(hu, 1500.3, "DETTEMSP", sbstat.temperature_setpoint, "Temperature setpoint"); + fh_set_int(hu, 1500.4, "DETTEMCP", sbstat.cooling_power, "Cooling power"); + fh_set_flt(hu, 1510, "CAMTEM", sbstat.air_temperature/10., 3, "Outside air temperature"); + fh_set_com(hu, 1600.0, "COMMENT", ""); + fh_set_com(hu, 1600.1, "COMMENT", " SBIG info record:"); + fh_set_com(hu, 1600.2, "COMMENT", ""); + sprintf(str, "%u", info.firmware_version); + fh_set_str(hu, 1600.9, "CONSWV", str, "SBIG firmware version"); + fh_set_str(hu, 1601,"DETECTOR", info.camera_name, info.serial_number); + fh_set_bool(hu, 1700, "ABGON", info.imaging_abg_type, "Antiblooming gate present"); + fh_set_int(hu, 1701, "ABGMODE", info.imaging_abg_type, "Antiblooming gate control value"); + fh_set_int(hu, 1800, "BADCOL", info.nmbr_bad_columns, "Number of bad columns"); + for (i = 0; i < info.nmbr_bad_columns; ++i){ + sprintf(str, "BADCOL%d", i); + fh_set_int(hu, 1800 + 0.1 + 0.1 * i, str, info.bad_columns[i], "Bad column"); + } + fh_set_int(hu, 1901, "ST5ADSIZ", info.ST5_AD_size, ""); + fh_set_int(hu, 1902, "ST5FLTYP", info.ST5_filter_type, ""); + + if (fh_write(hu, STDOUT_FILENO) != FH_SUCCESS) + exit(EXIT_FAILURE); + + if (fh_write_padded_image(hu, STDOUT_FILENO, data, w*h*sizeof(unsigned short), FH_TYPESIZE_RAW) != FH_SUCCESS) + exit(EXIT_FAILURE); + + gprint (GP_ERR, "logonly: Wrote %d pixels, min=%g, max=%g\n", w*h, datamin, datamax); + sync(); + return 0; +} + +static void show_format(void){ + gprint (GP_ERR, "Format for sp_ccdcontrol, SkyProbe CCD controller:\n" + "Writes FITS file to stdout, status messages to stderr.\n" + "NOTE: -port {hex} is an option for all forms of sp_ccdcontrol,\n" + " to specify a hex adress for the parallel port.\n" + "sp_ccdcontrol expose -etime {Exp time}\n" + " [-binmode {Binning mode}]\n" + " [-shuttermode {Shutter mode}]\n" + " [-raster X Y W H]\n" + "Exp time: Exposure time given in seconds.\n" + "Binning mode: 0=1x1, 1=2x2, 2=3x3. Note, 3x3 not allowed in -track mode.\n" + " OR \n" + "sp_ccdcontrol cool {coolmode} [temp|power]\n" + "coolmode: 0=OFF, 1=ON, 2=Direct Drive\n" + "For coolmode=0: Do not specify temp or power\n" + "For coolmode=1: Specify temp in deg C\n" + "For coolmode=2: Specify power (0-255)\n"); + exit(EXIT_FAILURE); +} + + +int main(int argc, char *argv[]) +{ + /* char buffer[80], last_command[80]; */ + int ret = -1, i, port; + int is_small_camera; + + /* Simon Kras--command line variables */ + char cmd[80]; + double etime; + int binmode; + int shuttermode; + int coolmode; + int raster_x, raster_y, raster_h, raster_w; + double cooltemp, coolpwr; + + if(argc>1) strcpy(cmd, argv[1]); + else show_format(); + + port = 1; /* 0x378 */ + for (i = 1; i < argc; ++i) { + if (!strcmp(argv[i], "-port")) { + sscanf(argv[++i], "%x", &port); + gprint (GP_ERR, "port override to 0x%x\n", port); + } + } + + for (i = 0; i < 4; ++i) { + sync(); + /* set our verbosity to 0 (range is 0 to 5) */ + ret = sbig_init(port, 0, &info); + if (ret == -6) ret = 0; /* %%% It always returns this error, but actually it worked. + * Since the library is binary only, we can't fix it. + */ + if (ret == 0) break; + gprint (GP_ERR,"logonly: sbig_init() failed: %s\n", sbig_show_error(ret)); + usleep(100000); + } + if (ret < 0) { + gprint (GP_ERR, "error: cannot open camera, giving up\n"); + exit(EXIT_FAILURE); + } + + is_small_camera = (strstr(info.camera_name, "237") != NULL || + index(info.camera_name, '5') != NULL); + for (i = 0; i < info.camera_info[0].nmbr_readout_modes; ++i) { + struct readout_mode *rmp; + rmp = &info.camera_info[0].readout_mode[i]; +#ifdef DEBUG + gprint (GP_ERR, "debug: ImagingCCD mode %d: w=%d h=%d " + "gain=%f " + "pw=%g ph=%g\n", rmp->mode, rmp->width, + rmp->height, 0.01*rmp->gain, 0.001*rmp->pixel_width, + 0.001*rmp->pixel_height); +#endif + } + + for (i = 0; i < info.camera_info[1].nmbr_readout_modes; ++i) { + struct readout_mode *rmp; + + rmp = &info.camera_info[1].readout_mode[i]; +#ifdef DEBUG + gprint (GP_ERR, "debug: TrackingCCD mode %d: w=%d h=%d " + "gain=%f " + "pw=%g ph=%g\n" + , rmp->mode, rmp->width, rmp->height, + 0.01*rmp->gain, + 0.001*rmp->pixel_width, 0.001*rmp->pixel_height); +#endif + } + if(!strcmp(cmd, "expose")){ + etime=-999.; + for(i=1;i(i+1)) etime = atof(argv[++i]); + else + gprint (GP_ERR, "No argument given to -etime\n"); + } + } + if(etime==-999.){ + gprint (GP_ERR, "Must specify exposure time.\n"); + exit(EXIT_FAILURE); + } + + binmode=-999; + for(i=1;i(i+1)) binmode = atoi(argv[++i]); + else{ + gprint (GP_ERR, "No argument given for -binmode\n"); + exit(EXIT_FAILURE); + } + } + } + if(binmode==-999) binmode=0; + + shuttermode=0; + for (i=1; i(i+1)) shuttermode = atoi(argv[++i]); + else{ + gprint (GP_ERR, "No argument given for -shuttermode\n"); + exit(EXIT_FAILURE); + } + } + } + + raster_x=0; + raster_y=0; + raster_w=0; + raster_h=0; + for (i=1; i(i+4)) { + raster_x = atoi(argv[++i]); + raster_y = atoi(argv[++i]); + raster_w = atoi(argv[++i]); + raster_h = atoi(argv[++i]); + } + else{ + gprint (GP_ERR, "-raster requires 4 arguments: x y w h\n"); + exit(EXIT_FAILURE); + } + } + } + + take_picture(etime, binmode, shuttermode, raster_x, raster_y, raster_w, raster_h); + + } else if(!strcmp(cmd, "cool")){ + double f; + struct sbig_cool cool; + + if(argc<3){ + gprint (GP_ERR, "Too few arguments for cool mode\n"); + exit(EXIT_FAILURE); + } + coolmode = atoi(argv[2]); + + if(coolmode<0 || coolmode>2){ + gprint (GP_ERR, "Cooling mode values allowed: [0 Off, 1 *On, 2 DirectDrive]\n"); + exit(EXIT_FAILURE); + } + cool.regulation = coolmode; + cool.direct_drive = 0; + if (cool.regulation == 2){ + if(argc<4){ + gprint (GP_ERR, "Must specify cooling power (0-255)\n"); + exit(EXIT_FAILURE); + } + coolpwr=atof(argv[3]); + if(coolpwr<0 || coolpwr>255){ + gprint (GP_ERR, "Cooling power must be 0-255.\n"); + exit(EXIT_FAILURE); + } + cool.direct_drive = coolpwr; + } + else if (cool.regulation == 1) { + if(argc<4){ + gprint (GP_ERR, "Must specify temperature in deg C\n"); + exit(EXIT_FAILURE); + } + cooltemp=atof(argv[3]); + if(cooltemp<-50 || cooltemp>20){ + gprint (GP_ERR, "Cooling temperature must be -50 to 20 deg C.\n"); + exit(EXIT_FAILURE); + } + f = cooltemp; + i = 10.0*f + 0.5; + cool.temperature = i; + } + sync(); + ret = sbig_set_cooling(&cool); + if (ret < 0){ + gprint (GP_ERR, "sbig error: %s\n", sbig_show_error(ret)); + } + }else{ + gprint (GP_ERR, "Illegal command: '%s'\n", cmd); + show_format(); + } + exit(EXIT_SUCCESS); +} + Index: /branches/dimm-0-5/Ohana/src/opihi/dimm/telescope.c =================================================================== --- /branches/dimm-0-5/Ohana/src/opihi/dimm/telescope.c (revision 11221) +++ /branches/dimm-0-5/Ohana/src/opihi/dimm/telescope.c (revision 11221) @@ -0,0 +1,236 @@ +# include "dimm.h" + +double distSky (double r1, double r2, double d1, double d2); + +int telescope (int argc, char **argv) { + + if (argc < 2) goto usage; + + if (!strcasecmp (argv[1], "init")) { + if (argc != 3) { + gprint (GP_ERR, "USAGE: telescope init (port)\n"); + return (FALSE); + } + if (!SerialInit (argv[2])) return (FALSE); + gprint (GP_ERR, "telescope on port %s\n", argv[2]); + return (TRUE); + } + + if (!strcasecmp (argv[1], "cmd")) { + + int status; + char *answer = (char *) NULL; + + if (argc != 3) { + gprint (GP_ERR, "USAGE: telescope cmd (string)\n"); + return (FALSE); + } + status = SerialCommand (argv[2], &answer, 10); + gprint (GP_ERR, "status: %d\n", status); + if (answer != (char *) NULL) { + gprint (GP_ERR, "answer: ..%s..\n", answer); + } + return (TRUE); + } + + if (!strcasecmp (argv[1], "ack")) { + + int status; + char line[32], *answer; + + if (argc != 3) { + gprint (GP_ERR, "USAGE: telescope cmd (string)\n"); + return (FALSE); + } + line[0] = 0x06; + line[1] = 0; + status = SerialCommand (line, &answer, 10); + gprint (GP_ERR, "status: %d\n", status); + if (answer != (char *) NULL) { + gprint (GP_ERR, "answer: ..%s..\n", answer); + } + return (TRUE); + } + + if (!strcasecmp (argv[1], "slew")) { + + double ra, dec; + int status; + + if (argc != 4) { + gprint (GP_ERR, "USAGE: telescope slew (ra) (dec)\n"); + return (FALSE); + } + + ra = atof (argv[2]); + dec = atof (argv[3]); + while (ra < 360.0) ra += 360.0; + while (ra > 360.0) ra -= 360.0; + + status = gotoRD (ra, dec); + + if (!status) return (FALSE); + return (TRUE); + } + + if (!strcasecmp (argv[1], "coords")) { + + int status; + double ra, dec; + char line[64]; + + if (argc != 2) { + gprint (GP_ERR, "USAGE: telescope coords\n"); + return (FALSE); + } + + if (!getRD (&ra, &dec)) return (FALSE); + gprint (GP_ERR, "%f %f\n", ra, dec); + set_variable ("RA", ra); + set_variable ("DEC", dec); + dms_format (line, (ra/15.0)); + set_str_variable ("Rs", line); + dms_format (line, dec); + set_str_variable ("Ds", line); + + return (TRUE); + } + + if (!strcasecmp (argv[1], "altaz")) { + + int status; + double x, y; + + if (argc != 2) { + gprint (GP_ERR, "USAGE: telescope altaz\n"); + return (FALSE); + } + + if (!getXY (&x, &y)) return (FALSE); + gprint (GP_ERR, "%f %f\n", x, y); + set_variable ("ALT", x); + set_variable ("AZ", y); + return (TRUE); + } + + if (!strcasecmp (argv[1], "site")) { + + int status; + double lon, lat, LST; + + if (argc != 2) { + gprint (GP_ERR, "USAGE: telescope site\n"); + return (FALSE); + } + + if (!getSite (&lon, &lat, &LST)) return (FALSE); + gprint (GP_ERR, "%f %f %f\n", lon, lat, LST); + set_variable ("LON", lon); + set_variable ("LAT", lat); + set_variable ("LST", LST); + return (TRUE); + } + + if (!strcasecmp (argv[1], "setsite")) { + + double lon, lat; + + if (argc != 5) { + gprint (GP_ERR, "USAGE: telescope setsite (name) (longitude) (latitude)\n"); + return (FALSE); + } + + lon = atof (argv[3]); + lat = atof (argv[4]); + if (!setSite (argv[2], lon, lat)) return (FALSE); + set_variable ("LON", lon); + set_variable ("LAT", lat); + return (TRUE); + } + + if (!strcasecmp (argv[1], "settime")) { + + if (argc != 3) { + gprint (GP_ERR, "USAGE: telescope settime (lst)\n"); + return (FALSE); + } + + if (!setTime (argv[2])) return (FALSE); + return (TRUE); + } + + if (!strcasecmp (argv[1], "verbose")) { + + int mode; + + if (argc != 3) { + gprint (GP_ERR, "USAGE: telescope verbose (mode)\n"); + return (FALSE); + } + + mode = atoi (argv[2]); + SerialVerbose (mode); + return (TRUE); + } + + if (!strcasecmp (argv[1], "setcoords")) { + + int status; + double ra, dec; + + if (argc != 4) { + gprint (GP_ERR, "USAGE: telescope setcoords (ra) (dec)\n"); + return (FALSE); + } + + ra = atof (argv[2]); + dec = atof (argv[3]); + + if (!setRD (ra, dec)) return (FALSE); + return (TRUE); + } + + if (!strcasecmp (argv[1], "offset")) { + + int status; + + if (argc != 4) { + gprint (GP_ERR, "USAGE: telescope offset (direction) (distance)\n"); + gprint (GP_ERR, " direction : x or y\n"); + gprint (GP_ERR, " distance : +arcmin or -arcmin\n"); + return (FALSE); + } + status = offset (argv[2], atof (argv[3])); + + if (!status) return (FALSE); + return (TRUE); + } + + if (!strcasecmp (argv[1], "toffset")) { + + int status; + + if (argc != 5) { + gprint (GP_ERR, "USAGE: telescope toffset (direction) (rate) (duration)\n"); + gprint (GP_ERR, "example: telescope toffset x RC 1.5\n"); + return (FALSE); + } + status = toffset (argv[2], argv[3], atof(argv[4])); + + if (!status) return (FALSE); + return (TRUE); + } + + usage: + gprint (GP_ERR, "telescope init port - set serial port (eg, /dev/ttyS0)\n"); + gprint (GP_ERR, "telescope site - get site information\n"); + gprint (GP_ERR, "telescope altaz - g\n"); + gprint (GP_ERR, "telescope setcoords (ra) (dec)\n"); + gprint (GP_ERR, "telescope setsite (name) (longitute) (latitude)\n"); + gprint (GP_ERR, "telescope coords\n"); + gprint (GP_ERR, "telescope slew (ra) (dec)\n"); + gprint (GP_ERR, "telescope offset (direction) (duration)\n"); + gprint (GP_ERR, "telescope toffset (direction) (rate) (duration)\n"); + return (FALSE); +} + Index: /branches/dimm-0-5/Ohana/src/opihi/dimm/version.c =================================================================== --- /branches/dimm-0-5/Ohana/src/opihi/dimm/version.c (revision 11221) +++ /branches/dimm-0-5/Ohana/src/opihi/dimm/version.c (revision 11221) @@ -0,0 +1,17 @@ +# include "dimm.h" +static char *name = "$Name: not supported by cvs2svn $"; + +int version (int argc, char **argv) { + + char *tmp; + + gprint (GP_LOG, "\n"); + gprint (GP_LOG, "pclient version: %s\n", (tmp = strip_version (name))); free (tmp); + + gprint (GP_LOG, "opihi version: %s\n", (tmp = strip_version (opihi_version()))); free (tmp); + gprint (GP_LOG, "ohana version: %s\n", (tmp = strip_version (ohana_version()))); free (tmp); + gprint (GP_LOG, "gfits version: %s\n", (tmp = strip_version (gfits_version()))); free (tmp); + + gprint (GP_LOG, "compiled on %s %s\n", __DATE__, __TIME__); + return (TRUE); +}