sicspsi/audinelib.c

/*
 * -*- linux-c -*-
 * Linux Kernel Module for the Audine Camera
 * Copyright (C) 2001 Peter Kirchgessner
 * http://www.kirchgessner.net, mailto:peter@kirchgessner.net
 *
 * Modified by F. Manenti <oss_astr_cav@arcanet.it> for the use in the
 * NOVA environment (nova.sourceforge.net)
 *
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 * The sample interface routines for the module have been taken from the
 * Linux Kernel Module Programming Guide by Ori Pomerantz contained
 * in the Linux Documentation Project.
 *
 */

#include "audineccd.h"
#include "audinelib.h"

#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <sys/ioctl.h>
#include <errno.h>

#define AUD_DEVICE_FILE  "/dev/audine"

#define ERRNORET(a) return (errno = a, -(a))

#define AUD_HANDLE_CHECK(a) \
  { if (!(a)) ERRNORET (EINVAL); if ((a)->fd < 0) ERRNORET (EBADF); }

struct aud_handle_s {
  int fd;
  int single_read;
};


AUD_HANDLE aud_open(void)
{
  AUD_HANDLE aud = (AUD_HANDLE) calloc(1, sizeof(struct aud_handle_s));

  if (!aud)
    return 0;

  aud->fd = open(AUD_DEVICE_FILE, O_RDWR);
  if (aud->fd < 0) {
    free(aud);
    return 0;
  }

  aud->single_read = 1;

  return aud;
}


void aud_close(AUD_HANDLE aud)
{
  if (aud) {
    if (aud->fd >= 0)
      close(aud->fd);
    free(aud);
  }
}


char *aud_version(const AUD_HANDLE aud)
{
  static struct ccd_capability Info;
  char *version = "";
  int ret;

  if (aud) {
    ret = ioctl(aud->fd, CCD_RD_VER, &Info);
    if (ret == 0)
      version = &(Info.name[0]);
  }
  return version;
}


int aud_clear(const AUD_HANDLE aud, int nclear)
{
  int ret = 0;

  if (nclear > 0)
    ret = ioctl(aud->fd, CCD_CLR, &nclear);
  return ret;
}


int aud_binning_set(const AUD_HANDLE aud, int vb, int hb)
{
  struct ccd_capability Info;

  AUD_HANDLE_CHECK(aud);
  if ((vb < 1) || (vb > 4) || (hb < 1) || (hb > 4))
    ERRNORET(EINVAL);

  Info.width = vb;
  Info.height = hb;
  return ioctl(aud->fd, CCD_SET_BNN, &Info);
}


int aud_binning_get(const AUD_HANDLE aud, int *vb, int *hb)
{
  struct ccd_capability Info;
  int ret;

  AUD_HANDLE_CHECK(aud);

  Info.width = 0;
  Info.height = 0;
  ret = ioctl(aud->fd, CCD_SET_BNN, &Info);
  if (ret != 0)
    return ret;
  if (vb)
    *vb = Info.width;
  if (hb)
    *hb = Info.height;
  return 0;
}


int aud_geometry_set(const AUD_HANDLE aud, int x, int y, int width,
                     int height)
{
  struct ccd_capability Info;

  AUD_HANDLE_CHECK(aud);

  Info.minwidth = x;
  Info.minheight = y;
  Info.width = width;
  Info.height = height;
  return ioctl(aud->fd, CCD_SET_WND, &Info);
}


int aud_geometry_reset(const AUD_HANDLE aud)
{
  AUD_HANDLE_CHECK(aud);

  return ioctl(aud->fd, CCD_RST_WND);
}


int aud_geometry_get(const AUD_HANDLE aud, int *xorigin, int *yorigin,
                     int *winwidth, int *winheight, int *color)
{
  struct ccd_capability Info;
  int ret;

  AUD_HANDLE_CHECK(aud);

  ret = ioctl(aud->fd, CCD_RD_GEOM, &Info);
  if (ret != 0)
    return ret;

  if (xorigin)
    *xorigin = Info.minwidth;
  if (yorigin)
    *yorigin = Info.minheight;
  if (winwidth)
    *winwidth = Info.width;
  if (winheight)
    *winheight = Info.height;
  if (color)
    *color = Info.color;

  return 0;
}


int aud_port_set(const AUD_HANDLE aud, int base)
{
  AUD_HANDLE_CHECK(aud);
  if (base <= 0)
    return -EINVAL;
  return ioctl(aud->fd, CCD_SET_PRT, &base);
}


int aud_port_get(const AUD_HANDLE aud, int *base)
{
  AUD_HANDLE_CHECK(aud);
  if (!base)
    return -1;
  *base = 0;
  return ioctl(aud->fd, CCD_SET_PRT, base);
}


static int aud_line_ctrl_set(const AUD_HANDLE aud, int cmd, int ctrl)
{
  AUD_HANDLE_CHECK(aud);
  if ((ctrl != 1) && (ctrl != 2) && (ctrl != 4) && (ctrl != 8))
    ERRNORET(EINVAL);
  return ioctl(aud->fd, cmd, &ctrl);
}


static int aud_line_set(const AUD_HANDLE aud, int cmd, int on_off)
{
  AUD_HANDLE_CHECK(aud);
  if (on_off != 0)
    on_off = 1;
  return ioctl(aud->fd, cmd, &on_off);
}


int aud_amplifier_ctrl_set(const AUD_HANDLE aud, int ctrl)
{
  return aud_line_ctrl_set(aud, CCD_SET_AMP, ctrl);
}


int aud_amplifier_set(const AUD_HANDLE aud, int on_off)
{
  return aud_line_set(aud, CCD_SWTC_AMP, on_off);
}


int aud_shutter_ctrl_set(const AUD_HANDLE aud, int ctrl)
{
  return aud_line_ctrl_set(aud, CCD_SET_SHT, ctrl);
}


int aud_shutter_set(const AUD_HANDLE aud, int on_off)
{
  return aud_line_set(aud, CCD_SWTC_SHT, on_off);
}


int aud_aux0_ctrl_set(const AUD_HANDLE aud, int ctrl)
{
  return aud_line_ctrl_set(aud, CCD_SET_AX0, ctrl);
}


int aud_aux0_set(const AUD_HANDLE aud, int on_off)
{
  return aud_line_set(aud, CCD_SWTC_AX0, on_off);
}


int aud_aux1_ctrl_set(const AUD_HANDLE aud, int ctrl)
{
  return aud_line_ctrl_set(aud, CCD_SET_AX1, ctrl);
}


int aud_aux1_set(const AUD_HANDLE aud, int on_off)
{
  return aud_line_set(aud, CCD_SWTC_AX1, on_off);
}


int aud_ccd_info_get(const AUD_HANDLE aud, char **name, int *width,
                     int *height, int *color)
{
  static struct ccd_capability Info;
  int ret;

  AUD_HANDLE_CHECK(aud);
  if ((ret = ioctl(aud->fd, CCD_RD_CHIP, &Info)) != 0)
    return ret;

  if (name)
    *name = Info.name;
  if (width)
    *width = Info.width;
  if (height)
    *height = Info.height;
  if (color)
    *color = Info.color;

  return 0;
}


int aud_ccd_listentry_get(const AUD_HANDLE aud, int entry, char **name,
                          int *width, int *height, int *color)
{
  static struct ccd_capability Info;
  int ret;

  AUD_HANDLE_CHECK(aud);
  Info.color = entry;
  if ((ret = ioctl(aud->fd, CCD_RD_CCDL, &Info)) != 0)
    return ret;

  if (name)
    *name = Info.name;
  if (width)
    *width = Info.width;
  if (height)
    *height = Info.height;
  if (color)
    *color = Info.color;

  return 0;
}


void aud_single_read_set(AUD_HANDLE aud, int single_read)
{
  if (aud)
    aud->single_read = single_read;
}


int aud_image_read(const AUD_HANDLE aud, char **buf, int *bufsize,
                   int *width, int *height, int *color)
{
  int ret;
  int nbytes, nread, len;
  char *imgbuf;

  AUD_HANDLE_CHECK(aud);
  if ((!buf) || (!bufsize))
    ERRNORET(EINVAL);
  if ((!width) || (!height) || (!color))
    ERRNORET(EINVAL);

  if ((ret = aud_geometry_get(aud, 0, 0, width, height, color)) != 0)
    return ret;

  /* We get 2 bytes per pixel */
  nbytes = *width * *height * 2;

  /* Do we have to free the user buffer ? */
  if ((*bufsize < nbytes) && (*buf)) {
    free(*buf);
    *buf = 0;
    *bufsize = 0;
  }

  /* If buffer not supplied, allocate buffer */
  if (!(*buf)) {
    *buf = malloc(nbytes);
    if (!*buf)
      ERRNORET(ENOMEM);
    *bufsize = nbytes;
  }

  /* Start reading image */
  if ((ret = ioctl(aud->fd, CCD_RD_IMG)) != 0)
    return ret;

  imgbuf = *buf;
  while (nbytes > 0) {
    if (aud->single_read) {
      nread = nbytes;
    } else {
      nread = *width * 2;
      if (nread > nbytes)
        nread = nbytes;
    }
    len = read(aud->fd, imgbuf, nread);
    if (len <= 0)
      return -1;
    nbytes -= len;
    imgbuf += len;
  }
  return 0;
}


static void aud_ccdstruct_log(const char *fct, int ret,
                              const struct ccd_capability *info)
{
  printf("\nFunction %s returned %d\n", fct, ret);
  if (ret != 0)
    return;
  printf("Name : %-32s\n", info->name);
  printf
      ("Width: %-6d Height: %-6d Minwidth: %-6d Minheight: %-6d Color: %d\n",
       info->width, info->height, info->minwidth, info->minheight,
       info->color);
}


void aud_ioctl_test(AUD_HANDLE aud)
{
  int ret;
  struct ccd_capability info;
  char *buf = 0, *name;
  int bufsize = 0, width, height, color;
  int j;

  if ((!aud) || (aud->fd < 0))
    return;

  /* Read driver version */
  ret = ioctl(aud->fd, CCD_RD_VER, &info);
  aud_ccdstruct_log("CCD_RD_VER", ret, &info);

  /* Read chip information */
  ret = ioctl(aud->fd, CCD_RD_CHIP, &info);
  aud_ccdstruct_log("CCD_RD_CHIP", ret, &info);

  /* Read geometry */
  ret = ioctl(aud->fd, CCD_RD_GEOM, &info);
  aud_ccdstruct_log("CCD_RD_GEOM", ret, &info);

  /* Set Window */
  info.minwidth = 1;
  info.minheight = 2;
  info.width = 200;
  info.height = 100;
  ret = ioctl(aud->fd, CCD_SET_WND, &info);
  printf("\nCalled CCD_SET_WND: (1,2) (200,100)\n");

  /* Read geometry */
  ret = ioctl(aud->fd, CCD_RD_GEOM, &info);
  aud_ccdstruct_log("CCD_RD_GEOM", ret, &info);

  /* Set binning */
  info.width = 2;
  info.height = 3;
  printf("\nSet binning %dx%d", info.width, info.height);
  ret = ioctl(aud->fd, CCD_SET_BNN, &info);
  aud_ccdstruct_log("CCD_SET_BNN", ret, &info);

  /* Read geometry */
  ret = ioctl(aud->fd, CCD_RD_GEOM, &info);
  aud_ccdstruct_log("CCD_RD_GEOM", ret, &info);

  /* (Re-)Set binning */
  info.width = 1;
  info.height = 1;
  printf("\nSet binning %dx%d", info.width, info.height);
  ret = ioctl(aud->fd, CCD_SET_BNN, &info);
  aud_ccdstruct_log("CCD_SET_BNN", ret, &info);

  /* Read geometry */
  ret = ioctl(aud->fd, CCD_RD_GEOM, &info);
  aud_ccdstruct_log("CCD_RD_GEOM", ret, &info);

  /* Clear two times */
  info.width = 2;
  printf("\nStart clear %d times\n", info.width);
  fflush(stdout);
  ret = ioctl(aud->fd, CCD_CLR, &info.width);
  printf("Clear finished.\n");

  /* Reading */
  printf("Start reading image\n");
  ret = aud_image_read(aud, &buf, &bufsize, &width, &height, &color);
  printf
      ("Finished reading: ret=%d width=%d height=%d color=%d bufsize=%d\n",
       ret, width, height, color, bufsize);

  /* Set binning */
  info.width = 2;
  info.height = 3;
  printf("\nSet binning %dx%d", info.width, info.height);
  ret = ioctl(aud->fd, CCD_SET_BNN, &info);
  aud_ccdstruct_log("CCD_SET_BNN", ret, &info);

  /* Reading */
  printf("Start reading small image\n");
  ret = aud_image_read(aud, &buf, &bufsize, &width, &height, &color);
  printf
      ("Finished reading: ret=%d width=%d height=%d color=%d bufsize=%d\n",
       ret, width, height, color, bufsize);

  /* Reset window */
  ret = ioctl(aud->fd, CCD_RST_WND);
  printf("\nReset window\n");

  /* Reset binning */
  info.width = 1;
  info.height = 1;
  printf("\nSet binning %dx%d", info.width, info.height);
  ret = ioctl(aud->fd, CCD_SET_BNN, &info);
  aud_ccdstruct_log("CCD_SET_BNN", ret, &info);

  /* Read geometry */
  ret = ioctl(aud->fd, CCD_RD_GEOM, &info);
  aud_ccdstruct_log("CCD_RD_GEOM", ret, &info);

  /* Reading */
  printf("Start reading large image\n");
  ret = aud_image_read(aud, &buf, &bufsize, &width, &height, &color);
  printf
      ("Finished reading: ret=%d width=%d height=%d color=%d bufsize=%d\n",
       ret, width, height, color, bufsize);

  /* Read current port */
  ret = aud_port_get(aud, &j);
  printf("\naud_port_get returned with %d. Port=0x%x\n", ret, j);

  printf("\nList of supported CCDs:\n");
  j = 0;
  while (aud_ccd_listentry_get(aud, j, &name, &info.width, &info.height,
                               &info.color) == 0) {
    printf("%d: %s, %dx%d, %d\n", j, name, info.width, info.height,
           info.color);
    j++;
  }


}


#define FITS_WRITE_BOOLCARD(fp,key,value) \
{char card[81]; \
 sprintf (card, "%-8.8s= %20s%50s", key, value ? "T" : "F", " "); \
 fwrite (card, 1, 80, fp); }

#define FITS_WRITE_LONGCARD(fp,key,value) \
{char card[81]; \
 sprintf (card, "%-8.8s= %20ld%50s", key, (long)value, " "); \
 fwrite (card, 1, 80, fp); }

#define FITS_WRITE_DOUBLECARD(fp,key,value) \
{char card[81], dbl[21], *istr; \
 sprintf (dbl, "%20f", (double)value); istr = strstr (dbl, "e"); \
 if (istr) *istr = 'E'; \
 sprintf (card, "%-8.8s= %20.20s%50s", key, dbl, " "); \
 fwrite (card, 1, 80, fp); }

#define FITS_WRITE_STRINGCARD(fp,key,value) \
{char card[81]; int k;\
 sprintf (card, "%-8.8s= \'%s", key, value); \
 for (k = strlen (card); k < 81; k++) card[k] = ' '; \
 k = strlen (key); if (k < 8) card[19] = '\''; else card[11+k] = '\''; \
 fwrite (card, 1, 80, fp); }

#define FITS_WRITE_CARD(fp,value) \
{char card[81]; \
 sprintf (card, "%-80.80s", value); \
 fwrite (card, 1, 80, fp); }

int audine_fits_write(const char *fname, const char *img,
                      int width, int height)
{
  FILE *fp;
  char value[50];
  unsigned short *us_img = (unsigned short *) img;
  unsigned short *row;
  int x, y, high, low;
  long pos;
  time_t timp;

  fp = fopen(fname, "w");
  if (fp) {
    FITS_WRITE_BOOLCARD(fp, "SIMPLE", 1);
    FITS_WRITE_LONGCARD(fp, "BITPIX", 16);
    FITS_WRITE_LONGCARD(fp, "NAXIS", 2);
    FITS_WRITE_LONGCARD(fp, "NAXIS1", width);
    FITS_WRITE_LONGCARD(fp, "NAXIS2", height);
    FITS_WRITE_DOUBLECARD(fp, "BZERO", 0.0);
    FITS_WRITE_DOUBLECARD(fp, "BSCALE", 1.0);
    FITS_WRITE_DOUBLECARD(fp, "DATAMIN", 0.0);
    FITS_WRITE_DOUBLECARD(fp, "DATAMAX", 32767.0);
    FITS_WRITE_CARD(fp, " ");
    FITS_WRITE_CARD(fp, "HISTORY THIS FILE WAS GENERATED BY AUDINELIB");
    FITS_WRITE_CARD(fp, " ");

    timp = time(NULL);
    strftime(value, sizeof(value), "%d/%m/%Y", gmtime(&timp));
    FITS_WRITE_STRINGCARD(fp, "DATE", value);

    FITS_WRITE_CARD(fp, "END");

    /* Fill up primary HDU to multiple of 2880 bytes */
    fflush(fp);
    pos = ftell(fp) % 2880;
    if (pos != 0) {
      pos = 2880 - pos;
      while (pos-- > 0)
        putc(' ', fp);
    }

    /* FITS standard requires integer data to be most significant
       byte first, */
    /* image origin bottom left. We want to create an astronomical
       oriented image (top is bottom, left is right) */
    for (y = 0; y < height; y++) {
      row = us_img + y * width;
      for (x = width - 1; x >= 0; x--) {
        high = (row[x] >> 8) & 0xff;
        low = (row[x] & 0xff);
        putc(high, fp);
        putc(low, fp);
      }
    }
    /* Fill up file to multiple of 2880 bytes */
    fflush(fp);
    pos = ftell(fp) % 2880;
    if (pos != 0) {
      pos = 2880 - pos;
      while (pos-- > 0)
        putc(0, fp);
    }
    fclose(fp);
  } else {
    return -1;
  }
  return 0;
}