linse/sicspsi
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- New HM driver for Delcam CCD camera

Browse Source
This commit is contained in:
koennecke
2007-03-06 10:07:55 +00:00
parent 791cc9382c
commit bdea1d46a3
8 changed files with 1454 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

498
delcam.c Normal file
View File

@ -0,0 +1,498 @@
/*-----------------------------------------------------------------------------
* This is a driver for the DELCam Neutron CCD camera. This driver has some
* limitations:
* - Due to the dark current of a CCD, only timer measurements
* are useful.
* - If there is no beam, the measurement has to be aborted.
* - While reading the CCD, the computer locks up.
* - No intermediate results can be retrieved while data acquisition is
* active. This is due to the nature of the CCD readout: Each line is
* swapped into a line buffer which then is sequentially read. This
* may be a consequence of the fact that exposure just generates charges
* on the CCD.
* - This driver requires a Linux kernel module to be loaded beforehand.
* - The DELCam's paralell port connector MUST be connected to the
* paralell port of the computer running the SICServer.
* - This code works only on Linux, porting to other OS requires different
* drivers.
* The DELCam uses a CCD which was originally developed as CCD for amateur
* astronomers. The name of the project is Audine. This driver uses the
* audine driver code. Look in audinelib.h for a WWW pointer.
*
* copyright: see file COPYRIGHT
*
* Mark Koennecke, March 2007
*/
#include <errno.h>
#include <unistd.h>
#include <sics.h>
#include <countdriv.h>
#include <counter.h>
#include <HistMem.h>
#include <stringdict.h>
#include <HistDriv.i>
#include "audinelib.h"
/* This delay is not the real value, but approximated */
/* time in ms to activate amplifier before use */
#define AMPLIFIER_DELAY 1
/* Time in ms to activate shutter before/after exposure */
#define SHUTTER_DELAY 200
/*=================== DaDa Structure =========================*/
typedef struct {
AUD_HANDLE aud_handle;
int amplictrl;
int shutterctrl;
int nClear;
int running;
int error;
int schnarch;
int width, height;
pCounter count;
}Delcam, *pDelcam;
/*====================== codes =============================================*/
#define NOBEAM -120
#define FAULT -121
/*-------------------------------------------------------------------
Configures the HM from the options in pOpt and the HM data structure
Returns 1 on success, 0 on failure
---------------------------------------------------------------------*/
static int DelcamConfigure(pHistDriver self, SConnection *pCon,
pStringDict pOpt, SicsInterp *pSics){
pDelcam pPriv = NULL;
char buffer[80];
int status, w, h;
pPriv =(pDelcam)self->pPriv;
if(StringDictGet(pOpt,"amplictrl",buffer, 79) == 1){
pPriv->amplictrl = atoi(buffer);
} else {
pPriv->amplictrl = 0;
}
if(pPriv->amplictrl < 0 || pPriv->amplictrl > 8){
SCWrite(pCon,"ERROR: invalid amplictrl value, range 0 - 8",eError);
pPriv->amplictrl = 0;
}
if(StringDictGet(pOpt,"shutterctrl",buffer, 79) == 1){
pPriv->shutterctrl = atoi(buffer);
} else {
pPriv->shutterctrl = 0;
}
if(StringDictGet(pOpt,"clear",buffer, 79) == 1){
pPriv->nClear = atoi(buffer);
} else {
pPriv->nClear = 1;
}
if(StringDictGet(pOpt,"schnarch",buffer, 79) == 1){
pPriv->schnarch = atoi(buffer);
} else {
pPriv->schnarch = 1;
}
if(StringDictGet(pOpt,"counter",buffer, 79) == 1){
pPriv->count = (pCounter)FindCommandData(pServ->pSics,
buffer, "SingleCounter");
}
if(pPriv->count == NULL){
SCWrite(pCon,"ERROR: no slave counter configured: need it desperatly!",
eError);
return 0;
}
pPriv->running = 0;
if(pPriv->aud_handle == NULL){
pPriv->aud_handle = aud_open();
if(pPriv->aud_handle == NULL){
SCWrite(pCon,"ERROR: failed to open DELCam", eError);
return 0;
}
}
status = aud_geometry_get(pPriv->aud_handle, 0, 0, &w, &h,0);
if(status != 0) {
snprintf(buffer,80,"ERROR: errno %d while trying to read geometry",
errno);
SCWrite(pCon,buffer,eError);
return 0;
}
sprintf(buffer,"%d",w);
StringDictUpdate(self->pOption,"dim0",buffer);
sprintf(buffer,"%d",h);
StringDictUpdate(self->pOption,"dim1",buffer);
configureHMdata(self->data,self->pOption,pCon);
if(!resizeBuffer(self->data)) {
SCWrite(pCon,"ERROR: out of memory allocating HMData for DELCam",eError);
return 0;
}
pPriv->width = w;
pPriv->height = h;
return 1;
}
/*--------------------------------------------------------------------
Start histogramming, Returns HWFault on failure, 1 on success
----------------------------------------------------------------------*/
static int DelcamStart(pHistDriver self,SConnection *pCon){
pDelcam pPriv = NULL;
int status, i;
char buffer[80];
pPriv =(pDelcam)self->pPriv;
/*
* configure counter
*/
if(self->eCount != eTimer){
SCWrite(pCon,"WARNING: bad count mode switched to preset time",
eWarning);
}
SetCounterMode(pPriv->count, eTimer);
SetCounterPreset(pPriv->count,self->fCountPreset);
/*
* deal with amplifier
*/
if(pPriv->amplictrl |= 0){
status = aud_amplifier_ctrl_set (pPriv->aud_handle, pPriv->amplictrl);
if(status != 0){
snprintf(buffer,80,"ERROR: failed to set amplifier, errno = %d",
errno);
SCWrite(pCon,buffer,eError);
pPriv->error = FAULT;
return HWFault;
}
}
status = aud_amplifier_set(pPriv->aud_handle, 0);
if(status != 0){
snprintf(buffer,80,"ERROR: failed to start amplifier, errno = %d",
errno);
SCWrite(pCon,buffer,eError);
pPriv->error = FAULT;
return HWFault;
}
usleep(AMPLIFIER_DELAY*1000);
/*
* deal with shutter
*/
if(pPriv->shutterctrl |= 0){
status = aud_shutter_ctrl_set (pPriv->aud_handle, pPriv->shutterctrl);
if(status != 0){
snprintf(buffer,80,"ERROR: failed to set shutterctrl, errno = %d",
errno);
SCWrite(pCon,buffer,eError);
pPriv->error = FAULT;
return HWFault;
}
status = aud_shutter_set(pPriv->aud_handle, 1);
if(status != 0){
snprintf(buffer,80,"ERROR: failed to start shutter, errno = %d",
errno);
SCWrite(pCon,buffer,eError);
pPriv->error = FAULT;
return HWFault;
}
usleep(SHUTTER_DELAY*1000);
}
/*
* clear
*/
status = aud_clear(pPriv->aud_handle, pPriv->nClear);
if(status != 0){
snprintf(buffer,80,"ERROR: failed to clear CCD, errno = %d",
errno);
SCWrite(pCon,buffer,eError);
pPriv->error = FAULT;
return HWFault;
}
pPriv->running = 1;
clearHMData(self->data);
return pPriv->count->pDriv->Start(pPriv->count->pDriv);
}
/*--------------------------------------------------------------------
Stops histogramming, Returns HWFault on failure, 1 on success
----------------------------------------------------------------------*/
static int DelcamHalt(pHistDriver self){
pDelcam pPriv = NULL;
pPriv =(pDelcam)self->pPriv;
return pPriv->count->pDriv->Halt(pPriv->count->pDriv);
}
/*--------------------------------------------------------------------
Checks histogramming status, Returns HWFault on failure,
HWIdle when finished, HWBusy when counting
----------------------------------------------------------------------*/
static int DelcamCountStatus(pHistDriver self,SConnection *pCon){
pDelcam pPriv = NULL;
int status, color, imSize = 0, i;
float val;
char buffer[80];
unsigned short *imData = NULL;
char *shittyCompiler = NULL;
pPriv =(pDelcam)self->pPriv;
status = pPriv->count->pDriv->GetStatus(pPriv->count->pDriv,&val);
if(status == HWNoBeam) {
SCWrite(pCon,"ERROR: NO BEAM, aborting CCD measurement",eError);
DelcamHalt(self);
pPriv->error = NOBEAM;
status = HWFault;
}
if(status != HWBusy && pPriv->running == 1) {
pPriv->running = 0;
/*
* stop the CCD and transfer data
*/
if(pPriv->shutterctrl |= 0){
status = aud_shutter_set(pPriv->aud_handle, 0);
if(status != 0){
snprintf(buffer,80,"ERROR: failed to close shutter, errno = %d",
errno);
SCWrite(pCon,buffer,eError);
pPriv->error = FAULT;
status = HWFault;
}
usleep(SHUTTER_DELAY*1000);
}
status = aud_amplifier_set(pPriv->aud_handle, 1);
if(status != 0){
snprintf(buffer,80,"ERROR: failed to stop amplifier, errno = %d",
errno);
SCWrite(pCon,buffer,eError);
pPriv->error = FAULT;
status = HWFault;
}
/* usleep(AMPLIFIER_DELAY*1000); */
usleep(pPriv->schnarch*1000);
SCWrite(pCon,
"WARNING: computer freeze for ~15 sec is normal during readout",
eWarning);
status = aud_image_read(pPriv->aud_handle, &shittyCompiler,
&imSize, &pPriv->width,
&pPriv->height, &color);
imData = (unsigned short *)shittyCompiler;
if(status != 0){
snprintf(buffer,80,"ERROR: failed to read DELCam with errno = %d",
errno);
SCWrite(pCon,buffer,eError);
pPriv->error = FAULT;
status = HWFault;
}
if(imData != NULL){
for(i = 0; i < pPriv->width*pPriv->height; i++){
self->data->localBuffer[i] = (int) imData[i];
}
free(imData);
}
}
return status;
}
/*--------------------------------------------------------------------
Get info on error after last HWFault, returns 1 always.
Puts an int error code into *code and errLen chars of
error description into error
----------------------------------------------------------------------*/
static int DelcamGetError(pHistDriver self,int *code,
char *error, int errLen){
pDelcam pPriv = NULL;
pPriv =(pDelcam)self->pPriv;
switch(pPriv->error){
case FAULT:
snprintf(error,errLen,"ERROR: DELcam fault");
*code = FAULT;
break;
case NOBEAM:
snprintf(error,errLen,"ERROR: ABORT for beam interruption");
*code = FAULT;
break;
default:
return pPriv->count->pDriv->GetError(pPriv->count->pDriv,
code, error, errLen);
}
return 0;
}
/*--------------------------------------------------------------------
Try to fix the HM error in code. Returns COREDO when the last
operation needs to be redone, COTERM when the error cannot be
fixed.
----------------------------------------------------------------------*/
static int DelcamFixIt(pHistDriver self,int code){
pDelcam pPriv = NULL;
pPriv =(pDelcam)self->pPriv;
switch(code){
case FAULT:
case NOBEAM:
return COTERM;
break;
default:
return
pPriv->count->pDriv->TryAndFixIt(pPriv->count->pDriv,code);
break;
}
return COTERM;
}
/*--------------------------------------------------------------------
GetData reads updates the internal cache of monitor values
from the hardware, Returns 1 or HWFault
----------------------------------------------------------------------*/
static int DelcamGetData(pHistDriver self,SConnection *pCon){
pDelcam pPriv = NULL;
pPriv =(pDelcam)self->pPriv;
return 1;
}
/*--------------------------------------------------------------------
GetMonitor reads the monitor value i. Returns either the monitor
value or -9999 if no such monitor exists or an error occurred
----------------------------------------------------------------------*/
static long DelcamGetMonitor(pHistDriver self,int i, SConnection *pCon){
pDelcam pPriv = NULL;
pPriv =(pDelcam)self->pPriv;
return GetMonitor(pPriv->count,i,pCon);
}
/*--------------------------------------------------------------------
GetTime reads the total counting time. Returns either the
value or -9999.99 if no such value exists or an error occurred
----------------------------------------------------------------------*/
static float DelcamGetTime(pHistDriver self,SConnection *pCon){
pDelcam pPriv = NULL;
pPriv =(pDelcam)self->pPriv;
return GetCountTime(pPriv->count,pCon);
}
/*--------------------------------------------------------------------
Pause histogramming, Returns HWFault on failure, 1 on success
----------------------------------------------------------------------*/
static int DelcamPause(pHistDriver self,SConnection *pCon){
pDelcam pPriv = NULL;
pPriv =(pDelcam)self->pPriv;
SCWrite(pCon,"WARNING: pausing pointless for CCD, IGNORED!",eWarning);
return 1;
}
/*--------------------------------------------------------------------
Continue histogramming, Returns HWFault on failure, 1 on success
----------------------------------------------------------------------*/
static int DelcamContinue(pHistDriver self,SConnection *pCon){
pDelcam pPriv = NULL;
pPriv =(pDelcam)self->pPriv;
SCWrite(pCon,"WARNING: pausing pointless for CCD, IGNORED!",eWarning);
return 1;
}
/*--------------------------------------------------------------------
Free the data associated with the private data structure of the driver
----------------------------------------------------------------------*/
static int DelcamFree(pHistDriver self){
pDelcam pPriv = NULL;
pPriv =(pDelcam)self->pPriv;
aud_close(pPriv->aud_handle);
free(pPriv);
return 1;
}
/*--------------------------------------------------------------------
Set The HM data or a subset of it. Returns HWFault or 1
----------------------------------------------------------------------*/
static int DelcamSetHistogram(pHistDriver self,
SConnection *pCon,
int i, int iStart, int iEnd, HistInt *pData){
pDelcam pPriv = NULL;
int j;
pPriv =(pDelcam)self->pPriv;
SCWrite(pCon,"WARNING: driver does not support setting HM",eWarning);
return 1;
}
/*--------------------------------------------------------------------
Set HM to a preset value, Returns HWFault on failure, 1 on success
----------------------------------------------------------------------*/
static int DelcamPreset(pHistDriver self,SConnection *pCon,
HistInt value){
pDelcam pPriv = NULL;
int j;
pPriv =(pDelcam)self->pPriv;
for(j = 0; j < pPriv->width*pPriv->height; j++){
self->data->localBuffer[j] = value;
}
return 1;
}
/*--------------------------------------------------------------------
get The HM data or a subset of it. Returns HWFault or 1
----------------------------------------------------------------------*/
static int DelcamGetHistogram(pHistDriver self,
SConnection *pCon,
int i, int iStart, int iEnd, HistInt *pData){
pDelcam pPriv = NULL;
HistInt *data = NULL;
pPriv =(pDelcam)self->pPriv;
data = self->data->localBuffer + iStart;
if(iEnd > getHMDataLength(self->data) || iStart < 0){
SCWrite(pCon,"ERROR: data length out of range",eError);
return 0;
}
memcpy(pData,data,(iEnd - iStart)*sizeof(HistInt));
return 1;
}
/*--------------------------------------------------------------------
Make the HMDriver, returns a driver or NULL on failure
----------------------------------------------------------------------*/
pHistDriver MakeDelcamHM(pStringDict pOption){
pHistDriver pNew = NULL;
pDelcam pPriv = NULL;
/* create the general driver */
pNew = CreateHistDriver(pOption);
if(!pNew){
return NULL;
}
/*Create private data structure*/
pPriv = NULL;
pPriv = (pDelcam)malloc(sizeof(Delcam));
if(pPriv == NULL){
return NULL;
}
memset(pPriv,0,sizeof(Delcam));
pPriv->width = 768;
pPriv->height = 512;
pNew->pPriv = pPriv;
/* add our options */
StringDictAddPair(pOption,"amplictrl","0");
StringDictAddPair(pOption,"shutterctrl","0");
StringDictAddPair(pOption,"clear","1");
StringDictAddPair(pOption,"schnarch","1");
StringDictAddPair(pOption,"counter","unkown");
/* configure all those functions */
pNew->Configure = DelcamConfigure;
pNew->Start = DelcamStart;
pNew->Halt = DelcamHalt;
pNew->GetCountStatus = DelcamCountStatus;
pNew->GetError = DelcamGetError;
pNew->TryAndFixIt = DelcamFixIt;
pNew->GetData = DelcamGetData;
pNew->GetHistogram = DelcamGetHistogram;
pNew->SetHistogram = DelcamSetHistogram;
pNew->GetMonitor = DelcamGetMonitor;
pNew->GetTime = DelcamGetTime;
pNew->Preset = DelcamPreset;
pNew->FreePrivate = DelcamFree;
pNew->Pause = DelcamPause;
pNew->Continue = DelcamContinue;
return pNew;
}