state from 2014-09-07 13:30 MESZ

1 files changed, 1674 insertions, 0 deletions

diff --git a/spectro/specbos.c b/spectro/specbos.c
new file mode 100644
index 0000000..f81f2d7
--- /dev/null
+++ b/spectro/specbos.c
@@ -0,0 +1,1674 @@
+
+/* 
+ * Argyll Color Correction System
+ *
+ * JETI specbos 1211/1201 related functions
+ *
+ * Author: Graeme W. Gill
+ * Date:   13/3/2013
+ *
+ * Copyright 1996 - 2014, Graeme W. Gill
+ * All rights reserved.
+ *
+ * This material is licenced under the GNU GENERAL PUBLIC LICENSE Version 2 or later :-
+ * see the License2.txt file for licencing details.
+ *
+ * Based on DTP92.c
+ */
+
+/* 
+   If you make use of the instrument driver code here, please note
+   that it is the author(s) of the code who take responsibility
+   for its operation. Any problems or queries regarding driving
+   instruments with the Argyll drivers, should be directed to
+   the Argyll's author(s), and not to any other party.
+
+   If there is some instrument feature or function that you
+   would like supported here, it is recommended that you
+   contact Argyll's author(s) first, rather than attempt to
+   modify the software yourself, if you don't have firm knowledge
+   of the instrument communicate protocols. There is a chance
+   that an instrument could be damaged by an incautious command
+   sequence, and the instrument companies generally cannot and
+   will not support developers that they have not qualified
+   and agreed to support.
+ */
+
+/*
+
+	TTBD:
+
+	Should add a reflective and transmissive modes,
+	by doing a white calibration and dividing the measurement.
+
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+#include <time.h>
+#include <stdarg.h>
+#ifndef SALONEINSTLIB
+#include "copyright.h"
+#include "aconfig.h"
+#include "numlib.h"
+#else	/* !SALONEINSTLIB */
+#include "sa_config.h"
+#include "numsup.h"
+#endif /* !SALONEINSTLIB */
+#include "xspect.h"
+#include "insttypes.h"
+#include "conv.h"
+#include "icoms.h"
+#include "specbos.h"
+
+/* Default flow control */
+#define DEFFC fc_none
+
+static inst_code specbos_interp_code(inst *pp, int ec);
+
+#define MAX_MES_SIZE 500		/* Maximum normal message reply size */
+#define MAX_RD_SIZE 8000		/* Maximum reading message reply size */
+
+/* Interpret an icoms error into a SPECBOS error */
+static int icoms2specbos_err(int se) {
+	if (se != ICOM_OK) {
+		if (se & ICOM_TO)
+			return SPECBOS_TIMEOUT; 
+		return SPECBOS_COMS_FAIL;
+	}
+	return SPECBOS_OK;
+}
+
+/* Do a full command/response echange with the specbos */
+/* (This level is not multi-thread safe) */
+/* Return the specbos error code. */
+static int
+specbos_fcommand(
+struct _specbos *p,
+char *in,			/* In string */
+char *out,			/* Out string buffer */
+int bsize,			/* Out buffer size */
+double to,			/* Timeout in seconds */
+int ntc,			/* Number or termination chars */
+int ctype,			/* 0 = normal, 1 = *init, 2 = refr reading */
+int nd				/* nz to disable debug messages */
+) {
+	int se;
+	char *cp, *tc = "", *dp;
+
+	if (ctype == 0)
+		tc = "\r\006\025";		/* Return, Ack or Nak */
+	else if (ctype == 1)
+		tc = "\007\025";		/* Bell or Nak */
+	else if (ctype == 2)
+		tc = "\r\025";			/* Return or Nak */
+
+	if ((se = p->icom->write_read(p->icom, in, out, bsize, tc, ntc, to)) != 0) {
+		if (!nd) a1logd(p->log, 1, "specbos_fcommand: serial i/o failure on write_read '%s' 0x%x\n",icoms_fix(in),se);
+		return icoms2specbos_err(se);
+	}
+
+	/* See if there was an error, and remove any enquire codes */
+	for (dp = cp = out; *cp != '\000' && (out - dp) < bsize; cp++) {
+		if (*cp == '\025') {	/* Got a Nak */
+			char buf[100];
+
+			if ((se = p->icom->write_read(p->icom, "*stat:err?\r", buf, 100, "\r", 1, 1.0)) != 0) {
+				if (!nd) a1logd(p->log, 1, "specbos_fcommand: serial i/o failure on write_read '%s'\n",icoms_fix(in));
+				if (sscanf(buf, "Error Code: %d ",&se) != 1) {
+					if (!nd) a1logd(p->log, 1, "specbos_fcommand: failed to parse error code '%s'\n",icoms_fix(buf));
+					return icoms2specbos_err(se);
+				}
+			}
+			break;
+		}
+		if (*cp == '\005')	/* Got an Enquire */
+			continue;		/* remove it */
+		*dp = *cp;
+		dp++;
+	}
+	out[bsize-1] = '\000';
+
+	if (!nd) a1logd(p->log, 4, "specbos_fcommand: command '%s' returned '%s'\n",
+	                                          icoms_fix(in), icoms_fix(out));
+
+	return SPECBOS_OK;
+}
+
+/* Do a normal command/response echange with the specbos. */
+/* (This level is not multi-thread safe) */
+/* Return the inst code */
+static inst_code
+specbos_command(
+struct _specbos *p,
+char *in,			/* In string */
+char *out,			/* Out string buffer */
+int bsize,			/* Out buffer size */
+double to) {		/* Timout in seconds */
+	int rv = specbos_fcommand(p, in, out, bsize, to, 1, 0, 0);
+	return specbos_interp_code((inst *)p, rv);
+}
+
+/* Read another line of response */
+/* (This level is not multi-thread safe) */
+/* Return the inst code */
+static int
+specbos_readresp(
+struct _specbos *p,
+char *out,			/* Out string buffer */
+int bsize,			/* Out buffer size */
+double to			/* Timeout in seconds */
+) {
+	int rv, se;
+	char *cp, *tc = "\r\006\025";		/* Return, Ack or Nak */
+
+	if ((se = p->icom->read(p->icom, out, bsize, tc, 1, to)) != 0) {
+		a1logd(p->log, 1, "specbos_readresp: serial i/o failure\n");
+		return icoms2specbos_err(se);
+	}
+	return inst_ok;
+}
+
+/* Establish communications with a specbos */
+/* Ignore the serial parameters - leave serial in default state. */
+/* Return SPECBOS_COMS_FAIL on failure to establish communications */
+static inst_code
+specbos_init_coms(inst *pp, baud_rate br, flow_control fc, double tout) {
+	specbos *p = (specbos *) pp;
+	char buf[MAX_MES_SIZE];
+	baud_rate brt[] = { baud_921600, baud_115200, baud_38400, baud_nc };
+	unsigned int etime;
+	unsigned int i;
+	instType itype = pp->itype;
+	int se;
+
+	inst_code ev = inst_ok;
+
+	a1logd(p->log, 2, "specbos_init_coms: About to init Serial I/O\n");
+
+	amutex_lock(p->lock);
+
+	if (p->icom->port_type(p->icom) != icomt_serial
+	 && p->icom->port_type(p->icom) != icomt_usbserial) {
+		amutex_unlock(p->lock);
+		a1logd(p->log, 1, "specbos_init_coms: wrong communications type for device!\n");
+		return inst_coms_fail;
+	}
+	
+	/* The tick to give up on */
+	etime = msec_time() + (long)(1500.0 + 0.5);
+
+	a1logd(p->log, 1, "specbos_init_coms: Trying different baud rates (%u msec to go)\n",etime - msec_time());
+
+	/* Until we time out, find the correct baud rate */
+	for (i = 0; msec_time() < etime; i++) {
+		if (brt[i] == baud_nc) {
+			i = 0;
+		}
+		a1logd(p->log, 5, "specbos_init_coms: trying baud ix %d\n",brt[i]);
+		if ((se = p->icom->set_ser_port(p->icom, fc_none, brt[i], parity_none,
+			                         stop_1, length_8)) != ICOM_OK) { 
+			amutex_unlock(p->lock);
+			a1logd(p->log, 5, "specbos_init_coms: set_ser_port failed with 0x%x\n",se);
+			return specbos_interp_code((inst *)p, icoms2specbos_err(se));;		/* Give up */
+		}
+
+
+		/* Check instrument is responding */
+		if (((ev = specbos_command(p, "*idn?\r", buf, MAX_MES_SIZE, 0.2)) & inst_mask)
+			                                                       != inst_coms_fail) {
+			break;		/* We've got coms or user abort */
+		}
+
+		/* Check for user abort */
+		if (p->uicallback != NULL) {
+			inst_code ev;
+			if ((ev = p->uicallback(p->uic_cntx, inst_negcoms)) == inst_user_abort) {
+				amutex_unlock(p->lock);
+				a1logd(p->log, 1, "specbos_init_coms: user aborted\n");
+				return inst_user_abort;
+			}
+		}
+	}
+
+	if (msec_time() >= etime) {		/* We haven't established comms */
+		amutex_unlock(p->lock);
+		a1logd(p->log, 2, "specbos_init_coms: failed to establish coms\n");
+		return inst_coms_fail;
+	}
+
+	/* Check the response */
+	p->model = 0;
+
+	if (strncmp (buf, "SB05", 4) == 0)		/* Special case */
+		p->model = 1201;
+	else {
+		if (strlen(buf) < 11
+		 || sscanf(buf, "JETI_SB%d\r", &p->model) != 1) {
+			amutex_unlock(p->lock);
+			a1logd(p->log, 2, "specbos_init_coms: unrecognised ident string '%s'\n",icoms_fix(buf));
+			return inst_protocol_error;
+		}
+	}
+
+	if (p->model != 1201 && p->model != 1211) {
+		amutex_unlock(p->lock);
+		a1logd(p->log, 2, "specbos_init_coms: unrecognised model %04d\n",p->model);
+		return inst_unknown_model;
+	}
+	a1logd(p->log, 2, "specbos_init_coms: init coms has suceeded\n");
+
+	p->gotcoms = 1;
+
+#ifdef NEVER 	/* Test a change in baud rate on next plug in */
+	a1logd(p->log, 2, "specbos_init_coms: changing baudrate\n");
+//	if ((ev = specbos_command(p, "*para:baud 384\r", buf, MAX_MES_SIZE, 1.0)) != inst_ok)
+//	if ((ev = specbos_command(p, "*para:baud 115\r", buf, MAX_MES_SIZE, 1.0)) != inst_ok)
+	if ((ev = specbos_command(p, "*para:baud 921\r", buf, MAX_MES_SIZE, 1.0)) != inst_ok)
+	{
+		amutex_unlock(p->lock);
+		return ev;
+	}
+	if ((ev = specbos_command(p, "*para:save\r", buf, MAX_MES_SIZE, 1.0)) != inst_ok) {
+		amutex_unlock(p->lock);
+		return ev;
+	}
+#endif
+
+	amutex_unlock(p->lock);
+
+	return inst_ok;
+}
+
+static inst_code set_default_disp_type(specbos *p);
+
+/*
+	Notes on commands
+
+	*conf is temporary, *para can be saved to instrument
+	Since we set the instrument up every time, use *conf ?
+	*PARAmeter:SAVE
+
+	Set calibration to auto on presense of ambient cap
+	*para:calibn 0
+
+	To check what mode it's in:
+	*contr:mhead?
+	0 for emissive, 1 for ambient.
+
+	Set auto exposure
+	*para:expo 1			// Adapt
+	*para:adap 2			// Adapt if under or over
+	*conf:maxtin 4000		// Limit to 4 secs for display measurement rather than 60000
+
+	Set output format
+	*conf:form 10			// interpolated ASCII with wavelength
+	*conf:form 12			// H/L 32 bit float with length & checksum - doesn't seem to work :-(
+
+	Measurement function
+	*conf:func 6				// Radiometric spectrum
+
+	Set to wavelength range and step
+	*conf:wran 350 850 1
+
+	Set to average just 1 reading
+	*conf:aver 1
+
+	Do a configured measurement
+	*init
+
+	Fetch the results
+	*fetch:XYZ				// Fetches XYZ whatever the function ?
+	*fetch 10				// Fetch configured function in format 10
+
+	Measure refresh
+	*conf:cycmod 1
+	*contr:cyctim 200 4000	// Returns msec
+
+	Set refresh sync mode
+	*conf:cycmod 1
+	*conf:cyctim cyctim 	// in usec
+
+	message terminations:
+		
+	*xxx?	\r 		after data \r\r after spectral ??
+			\025    Nak on error ??
+
+	*para
+	*conf
+	*contr	\006	Ack on success,
+			\025    Nak on error
+
+	All enquiries and parameter setting: '\r'
+
+	*init	\006	Ack on command accepted
+			\025	Nak on error
+	        \007	Bell on completion
+
+	*fetch
+	*calc
+	*calib
+	*stat
+	*help
+	*fetch	\r      after data, \r\r after spectral ??
+
+*/
+
+static inst_code specbos_get_diffpos(specbos *p, int *pos, int nd);
+
+/* Diffuser position thread. */
+/* Poll the instrument at 500msec intervals */
+int specbos_diff_thread(void *pp) {
+	int nfailed = 0;
+	specbos *p = (specbos *)pp;
+	inst_code rv = inst_ok; 
+	a1logd(p->log,3,"Diffuser thread started\n");
+	for (nfailed = 0; nfailed < 5;) {
+		int pos;
+
+		amutex_lock(p->lock);
+		rv = specbos_get_diffpos(p, &pos, 1); 
+		amutex_unlock(p->lock);
+
+		if (p->th_term) {
+			p->th_termed = 1;
+			break;
+		}
+		if (rv != inst_ok) {
+			nfailed++;
+			a1logd(p->log,3,"Diffuser thread failed with 0x%x\n",rv);
+			continue;
+		}
+		if (pos != p->dpos) {
+			p->dpos = pos;
+			if (p->eventcallback != NULL) {
+				p->eventcallback(p->event_cntx, inst_event_mconf);
+			}
+		}
+		msec_sleep(500);
+	}
+	a1logd(p->log,3,"Diffuser thread returning\n");
+	return rv;
+}
+
+/* Initialise the SPECBOS */
+/* return non-zero on an error, with dtp error code */
+static inst_code
+specbos_init_inst(inst *pp) {
+	specbos *p = (specbos *)pp;
+	char mes[100];
+	char buf[MAX_MES_SIZE];
+	inst_code ev = inst_ok;
+
+	a1logd(p->log, 2, "specbos_init_inst: called\n");
+
+	if (p->gotcoms == 0)
+		return inst_internal_error;		/* Must establish coms before calling init */
+
+	amutex_lock(p->lock);
+	
+	/* Restore the instrument to it's default settings */
+	if ((ev = specbos_command(p, "*conf:default\r", buf, MAX_MES_SIZE, 1.0)) != inst_ok)
+		return ev;
+
+	/* Set calibration type to auto on ambient cap */
+	if ((ev = specbos_command(p, "*para:calibn 0\r", buf, MAX_MES_SIZE, 1.0)) != inst_ok) {
+		amutex_unlock(p->lock);
+		return ev;
+	}
+
+	/* Set auto exposure/integration time */
+	/* Set calibration type to auto on ambient cap */
+	if ((ev = specbos_command(p, "*para:expo 1\r", buf, MAX_MES_SIZE, 1.0)) != inst_ok
+	 || (ev = specbos_command(p, "*para:adapt 2\r", buf, MAX_MES_SIZE, 1.0)) != inst_ok) {
+		amutex_unlock(p->lock);
+		return ev;
+	}
+
+	p->measto = 20.0;			/* default */
+
+	if (p->model == 1211)
+		p->measto = 5.0;		/* Same overall time as i1d3 ?? */
+	else if (p->model == 1201)
+		p->measto = 15.0;
+
+	/* Set maximum integration time to speed up display measurement */
+	sprintf(mes, "*conf:maxtin %d\r", (int)(p->measto * 1000.0+0.5));
+	if ((ev = specbos_command(p, mes, buf, MAX_MES_SIZE, 1.0)) != inst_ok) {
+		amutex_unlock(p->lock);
+		return ev;
+	}
+
+	/* Set the measurement function to be Radiometric spectrum */
+	if ((ev = specbos_command(p, "*conf:func 6\r", buf, MAX_MES_SIZE, 1.0)) != inst_ok) {
+		amutex_unlock(p->lock);
+		return ev;
+	}
+
+	/* Set the measurement format to ASCII */
+	if ((ev = specbos_command(p, "*conf:form 4\r", buf, MAX_MES_SIZE, 1.0)) != inst_ok) {
+		amutex_unlock(p->lock);
+		return ev;
+	}
+
+	if ((ev = specbos_command(p, "*para:wavbeg?\r", buf, MAX_MES_SIZE, 1.0)) != inst_ok) {
+		amutex_unlock(p->lock);
+		return ev;
+	}
+	if (sscanf(buf, "Predefined start wave: %lf ",&p->wl_short) != 1) {
+		amutex_unlock(p->lock);
+		a1loge(p->log, 1, "specbos_init_inst: failed to parse start wave\n");
+		return ev;
+	}
+	a1logd(p->log, 1, " Short wl range %f\n",p->wl_short);
+
+	if ((ev = specbos_command(p, "*para:wavend?\r", buf, MAX_MES_SIZE, 1.0)) != inst_ok) {
+		amutex_unlock(p->lock);
+		return ev;
+	}
+	if (sscanf(buf, "Predefined end wave: %lf ",&p->wl_long) != 1) {
+		amutex_unlock(p->lock);
+		a1loge(p->log, 1, "specbos_init_inst: failed to parse end wave\n");
+		return ev;
+	}
+	if (p->wl_long > 830.0)			/* Could go to 1000 with 1211 */
+		p->wl_long = 830.0;
+
+	a1logd(p->log, 1, " Long wl range %f\n",p->wl_long);
+
+	p->nbands = (int)((p->wl_long - p->wl_short + 1.0)/1.0 + 0.5);
+
+	/* Set the wavelength range and resolution */
+	sprintf(mes, "*conf:wran %d %d 1\r", (int)(p->wl_short+0.5), (int)(p->wl_long+0.5));
+	if ((ev = specbos_command(p, mes, buf, MAX_MES_SIZE, 1.0)) != inst_ok) {
+		amutex_unlock(p->lock);
+		return ev;
+	}
+
+	/* Set to average just 1 reading */
+	if ((ev = specbos_command(p, "*conf:aver 1\r", buf, MAX_MES_SIZE, 1.0)) != inst_ok) {
+		amutex_unlock(p->lock);
+		return ev;
+	}
+
+	if (p->log->verb) {
+		int val;
+		char *sp;
+
+		if ((ev = specbos_command(p, "*idn?\r", buf, MAX_MES_SIZE, 1.0)) != inst_ok) {
+			amutex_unlock(p->lock);
+			return ev;
+		}
+		if ((sp = strrchr(buf, '\r')) != NULL)
+			*sp = '\000';
+		a1logv(p->log, 1, " Identificaton:       %s\n",buf);
+		
+		if ((ev = specbos_command(p, "*vers?\r", buf, MAX_MES_SIZE, 1.0)) != inst_ok) {
+			amutex_unlock(p->lock);
+			return ev;
+		}
+		
+		if ((sp = strrchr(buf, '\r')) != NULL)
+			*sp = '\000';
+		a1logv(p->log, 1, " Firmware:            %s\n",buf);
+		
+		if ((ev = specbos_command(p, "*para:spnum?\r", buf, MAX_MES_SIZE, 1.0)) != inst_ok) {
+			amutex_unlock(p->lock);
+			return ev;
+		}
+		if (sscanf(buf, "spectrometer number: %d ",&val) == 1) {
+			a1logv(p->log, 1, " Spectrometer number: %d\n",val);
+		}
+		
+		if ((ev = specbos_command(p, "*para:serno?\r", buf, MAX_MES_SIZE, 1.0)) != inst_ok) {
+			amutex_unlock(p->lock);
+			return ev;
+		}
+		if (sscanf(buf, "serial number: %d ",&val) == 1) {
+			a1logv(p->log, 1, " Serial number:       %d\n",val);
+		}
+	}
+
+	/* Start the diffuser monitoring thread */
+	if ((p->th = new_athread(specbos_diff_thread, (void *)p)) == NULL) {
+		amutex_unlock(p->lock);
+		return SPECBOS_INT_THREADFAILED;
+	}
+
+	p->inited = 1;
+	a1logd(p->log, 2, "specbos_init_inst: instrument inited OK\n");
+	amutex_unlock(p->lock);
+
+	return inst_ok;
+}
+
+static inst_code specbos_measure_set_refresh(specbos *p);
+static inst_code specbos_imp_set_refresh(specbos *p);
+
+/* Get the ambient diffuser position */
+/* (This is not multithread safe) */
+static inst_code
+specbos_get_diffpos(
+	specbos *p,				/* Object */
+	int *pos,				/* 0 = display, 1 = ambient */
+	int nd					/* nz = no debug message */
+) {
+	char buf[MAX_RD_SIZE];
+	int ec;
+
+	/* See if we're in emissive or ambient mode */
+	if ((ec = specbos_fcommand(p, "*contr:mhead?\r", buf, MAX_MES_SIZE, 1.0, 1, 0, nd)) != inst_ok) {
+		return specbos_interp_code((inst *)p, ec);
+	}
+	if (sscanf(buf, "mhead: %d ",pos) != 1) {
+		a1logd(p->log, 2, "specbos_init_coms: unrecognised measuring head string '%s'\n",icoms_fix(buf));
+		return inst_protocol_error;
+	}
+	return inst_ok;
+}
+
+/* Read a single sample */
+/* Return the dtp error code */
+static inst_code
+specbos_read_sample(
+inst *pp,
+char *name,			/* Strip name (7 chars) */
+ipatch *val,		/* Pointer to instrument patch value */
+instClamping clamp) {		/* NZ if clamp XYZ/Lab to be +ve */
+	specbos *p = (specbos *)pp;
+	char buf[MAX_RD_SIZE];
+	int ec; 
+	int user_trig = 0;
+	int pos = -1;
+	inst_code rv = inst_protocol_error;
+
+	if (!p->gotcoms)
+		return inst_no_coms;
+	if (!p->inited)
+		return inst_no_init;
+
+	amutex_lock(p->lock);
+
+	if (p->trig == inst_opt_trig_user) {
+		amutex_unlock(p->lock);
+
+		if (p->uicallback == NULL) {
+			a1logd(p->log, 1, "specbos: inst_opt_trig_user but no uicallback function set!\n");
+			return inst_unsupported;
+		}
+
+		for (;;) {
+			if ((rv = p->uicallback(p->uic_cntx, inst_armed)) != inst_ok) {
+				if (rv == inst_user_abort) {
+					return rv;				/* Abort */
+				}
+				if (rv == inst_user_trig) {
+					user_trig = 1;
+					break;					/* Trigger */
+				}
+			}
+			msec_sleep(200);
+		}
+		/* Notify of trigger */
+		if (p->uicallback)
+			p->uicallback(p->uic_cntx, inst_triggered); 
+		amutex_lock(p->lock);
+
+	/* Progromatic Trigger */
+	} else {
+		/* Check for abort */
+		if (p->uicallback != NULL
+		 && (rv = p->uicallback(p->uic_cntx, inst_armed)) == inst_user_abort) {
+			amutex_unlock(p->lock);
+			return rv;				/* Abort */
+		}
+	}
+
+	/* See if we're in emissive or ambient mode */
+	if ((rv = specbos_get_diffpos(p, &pos, 0) ) != inst_ok) {
+		amutex_unlock(p->lock);
+		return rv;
+	}
+
+	if (p->mode & inst_mode_ambient) {
+		if (pos != 1) {
+			amutex_unlock(p->lock);
+			return specbos_interp_code((inst *)p, SPECBOS_SPOS_AMB);
+		}
+	} else {
+		if (pos != 0) {
+			amutex_unlock(p->lock);
+			return specbos_interp_code((inst *)p, SPECBOS_SPOS_EMIS);
+		}
+	}
+
+	/* Make sure the target laser is off */
+	if ((rv = specbos_command(p, "*contr:laser 0\r", buf, MAX_MES_SIZE, 1.0)) != inst_ok) {
+		amutex_unlock(p->lock);
+		return rv;
+	}
+
+	/* Attempt a refresh display frame rate calibration if needed */
+	if (p->refrmode != 0 && p->rrset == 0) {
+		if ((rv = specbos_measure_set_refresh(p)) != inst_ok) {
+			amutex_unlock(p->lock);
+			return rv; 
+		}
+	}
+		
+	/* Trigger a measurement */
+	if ((ec = specbos_fcommand(p, "*init\r", buf, MAX_MES_SIZE, 5.0 * p->measto + 2.0 , 1, 1, 0)) != SPECBOS_OK) {
+		amutex_unlock(p->lock);
+		return specbos_interp_code((inst *)p, ec);
+	}
+
+	/* Read the XYZ */
+	if ((ec = specbos_fcommand(p, "*fetch:XYZ\r", buf, MAX_RD_SIZE, 0.5, 3, 0, 0)) != SPECBOS_OK) {
+		amutex_unlock(p->lock);
+		return specbos_interp_code((inst *)p, ec);
+	}
+
+	if (sscanf(buf, " X: %lf Y: %lf Z: %lf ",
+           &val->XYZ[0], &val->XYZ[1], &val->XYZ[2]) == 3) {
+
+		/* This may not change anything since instrument may clamp */
+		if (clamp)
+			icmClamp3(val->XYZ, val->XYZ);
+		val->loc[0] = '\000';
+		if (p->mode & inst_mode_ambient) {
+			val->mtype = inst_mrt_ambient;
+		} else
+			val->mtype = inst_mrt_emission;
+		val->XYZ_v = 1;		/* These are absolute XYZ readings */
+		val->sp.spec_n = 0;
+		val->duration = 0.0;
+		rv = inst_ok;
+	} else {
+		amutex_unlock(p->lock);
+		a1logd(p->log, 1, "specbos_read_sample: failed to parse '%s'\n",buf);
+		return inst_protocol_error;
+	}
+
+	/* spectrum data is returned only if requested */
+	if (p->mode & inst_mode_spectral) {
+		int i, xsize;
+		char *cp, *ncp;
+ 
+		/* (Format 12 doesn't seem to work on the 1211) */
+		/* (Format 9 reportedly doesn't work on the 1201) */
+		/* The folling works on the 1211 and is reported to work on the 1201 */
+
+		/* Fetch the spectral readings */
+		if ((ec = specbos_fcommand(p, "*fetch:sprad\r", buf, MAX_RD_SIZE, 1.0, 2+p->nbands+1, 0, 0)) != SPECBOS_OK) {
+			return specbos_interp_code((inst *)p, ec);
+		}
+
+		val->sp.spec_n = p->nbands;
+		val->sp.spec_wl_short = p->wl_short;
+		val->sp.spec_wl_long = p->wl_long;
+
+		/* Spectral data is in W/nm/m^2 */
+		val->sp.norm = 1.0;
+		cp = buf;
+		for (i = -2; i < val->sp.spec_n; i++) {
+			if ((ncp = strchr(cp, '\r')) == NULL) {
+				amutex_unlock(p->lock);
+				a1logd(p->log, 1, "specbos_read_sample: failed to parse spectral\n");
+				return inst_protocol_error;
+			}
+			*ncp = '\000';
+			if (i >= 0) {
+				val->sp.spec[i] = 1000.0 * atof(cp);	/* Convert to mW/m^2/nm */
+				if (p->mode & inst_mode_ambient)
+					val->mtype = inst_mrt_ambient;
+			}
+			cp = ncp+1;
+		}
+	}
+	amutex_unlock(p->lock);
+
+
+	if (user_trig)
+		return inst_user_trig;
+	return rv;
+}
+
+/* Set the instrument to match the current refresh settings */
+/* (Not thread safe) */
+static inst_code
+specbos_imp_set_refresh(specbos *p) {
+	char buf[MAX_MES_SIZE];
+	inst_code rv;
+
+	if (p->model == 1201)
+		return inst_unsupported; 
+
+	/* Set synchronised read if we should do so */
+	if (p->refrmode != 0 && p->refrvalid) {
+		char mes[100];
+		if ((rv = specbos_command(p, "*conf:cycmod 1\r", buf, MAX_MES_SIZE, 1.0)) != inst_ok) {
+			return rv;
+		}
+		sprintf(mes,"*conf:cyctim %f\r",p->refperiod * 1e6);
+		if ((rv = specbos_command(p, mes, buf, MAX_MES_SIZE, 1.0)) != inst_ok) {
+			return rv;
+		}
+		a1logd(p->log,5,"specbos_imp_set_refresh set refresh rate to %f Hz\n",1.0/p->refperiod);
+	} else {
+		if ((rv = specbos_command(p, "*conf:cycmod 0\r", buf, MAX_MES_SIZE, 1.0)) != inst_ok) {
+			return rv;
+		}
+		a1logd(p->log,5,"specbos_imp_set_refresh set non-refresh mode\n");
+	}
+	return inst_ok;
+}
+
+/* Implementation of read refresh rate */
+/* (Not thread safe) */
+/* Return 0.0 if none detectable */
+static inst_code
+specbos_imp_measure_refresh(
+specbos *p,
+double *ref_rate
+) {
+	char buf[MAX_MES_SIZE], *cp;
+	double refperiod = 0.0;
+	int ec;
+	inst_code rv;
+
+	if (p->model == 1201)
+		return inst_unsupported; 
+
+	/* Make sure the target laser is off */
+	if ((rv = specbos_command(p, "*contr:laser 0\r", buf, MAX_MES_SIZE, 1.0)) != inst_ok) {
+		return rv;
+	}
+
+	if ((ec = specbos_fcommand(p, "*contr:cyctim 200 4000\r", buf, MAX_MES_SIZE, 5.0, 1, 2, 0)) != SPECBOS_OK) {
+		return specbos_interp_code((inst *)p, ec);
+	}
+
+	if ((cp = strchr(buf, 'c')) == NULL)
+		cp = buf;
+	if (sscanf(cp, "cyctim[ms]: %lf ", &refperiod) != 1) {
+		a1logd(p->log, 1, "specbos_read_refrate rate: failed to parse string '%s'\n",icoms_fix(buf));
+		*ref_rate = 0.0;
+		return inst_misread;
+	}
+
+	if (refperiod == 0.0)
+		*ref_rate = 0.0;
+	else
+		*ref_rate = 1000.0/refperiod;
+
+	return inst_ok;
+}
+
+/* Read an emissive refresh rate */
+static inst_code
+specbos_read_refrate(
+inst *pp,
+double *ref_rate
+) {
+	specbos *p = (specbos *)pp;
+	char buf[MAX_MES_SIZE];
+	double refrate;
+	inst_code rv;
+
+	if (!p->gotcoms)
+		return inst_no_coms;
+	if (!p->inited)
+		return inst_no_init;
+
+	amutex_lock(p->lock);
+	if ((rv = specbos_imp_measure_refresh(p, &refrate)) != inst_ok) {
+		amutex_unlock(p->lock);
+		return rv;
+	}
+	amutex_unlock(p->lock);
+
+	if (refrate == 0.0)
+		return inst_misread;
+
+	*ref_rate = refrate;
+
+	return inst_ok;
+}
+
+/* Measure and then set refperiod, refrate if possible */
+static inst_code
+specbos_measure_set_refresh(
+	specbos *p			/* Object */
+) {
+	inst_code rv;
+	double refrate = 0.0;
+	int mul;
+	double pval;
+
+	amutex_lock(p->lock);
+	if ((rv = specbos_imp_measure_refresh(p, &refrate)) != inst_ok) {
+		amutex_unlock(p->lock);
+		return rv;
+	}
+
+	if (refrate != 0.0) {
+		p->refrate = refrate;
+		p->refrvalid = 1;
+		p->refperiod = 1.0/refrate;
+	} else {
+		p->refrate = 0.0;
+		p->refrvalid = 0;
+		p->refperiod = 0.0;
+	}
+	p->rrset = 1;
+
+	if ((rv = specbos_imp_set_refresh(p)) != inst_ok) {
+		amutex_unlock(p->lock);
+		return rv;
+	}
+	amutex_unlock(p->lock);
+
+	return inst_ok;
+}
+
+/* Return needed and available inst_cal_type's */
+static inst_code specbos_get_n_a_cals(inst *pp, inst_cal_type *pn_cals, inst_cal_type *pa_cals) {
+	specbos *p = (specbos *)pp;
+	inst_cal_type n_cals = inst_calt_none;
+	inst_cal_type a_cals = inst_calt_none;
+		
+	if (p->refrmode != 0) {
+		if (p->rrset == 0)
+			n_cals |= inst_calt_ref_freq;
+		a_cals |= inst_calt_ref_freq;
+	}
+
+	if (pn_cals != NULL)
+		*pn_cals = n_cals;
+
+	if (pa_cals != NULL)
+		*pa_cals = a_cals;
+
+	return inst_ok;
+}
+
+/* Request an instrument calibration. */
+inst_code specbos_calibrate(
+inst *pp,
+inst_cal_type *calt,	/* Calibration type to do/remaining */
+inst_cal_cond *calc,	/* Current condition/desired condition */
+char id[CALIDLEN]		/* Condition identifier (ie. white reference ID) */
+) {
+	specbos *p = (specbos *)pp;
+	inst_code ev;
+    inst_cal_type needed, available;
+
+	if (!p->gotcoms)
+		return inst_no_coms;
+	if (!p->inited)
+		return inst_no_init;
+
+	id[0] = '\000';
+
+	if ((ev = specbos_get_n_a_cals((inst *)p, &needed, &available)) != inst_ok)
+		return ev;
+
+	/* Translate inst_calt_all/needed into something specific */
+	if (*calt == inst_calt_all
+	 || *calt == inst_calt_needed
+	 || *calt == inst_calt_available) {
+		if (*calt == inst_calt_all) 
+			*calt = (needed & inst_calt_n_dfrble_mask) | inst_calt_ap_flag;
+		else if (*calt == inst_calt_needed)
+			*calt = needed & inst_calt_n_dfrble_mask;
+		else if (*calt == inst_calt_available)
+			*calt = available & inst_calt_n_dfrble_mask;
+
+		a1logd(p->log,4,"specbos_calibrate: doing calt 0x%x\n",calt);
+
+		if ((*calt & inst_calt_n_dfrble_mask) == 0)		/* Nothing todo */
+			return inst_ok;
+	}
+
+	/* See if it's a calibration we understand */
+	if (*calt & ~available & inst_calt_all_mask) { 
+		return inst_unsupported;
+	}
+
+	if ((*calt & inst_calt_ref_freq) && p->refrmode != 0) {
+		inst_code ev = inst_ok;
+
+
+		if (*calc != inst_calc_emis_80pc) {
+			*calc = inst_calc_emis_80pc;
+			return inst_cal_setup;
+		}
+
+		/* Do refresh display rate calibration */
+		if ((ev = specbos_measure_set_refresh(p)) != inst_ok)
+			return ev; 
+
+		*calt &= ~inst_calt_ref_freq;
+	}
+	return inst_ok;
+}
+
+/* Return the last calibrated refresh rate in Hz. Returns: */
+static inst_code specbos_get_refr_rate(inst *pp,
+double *ref_rate
+) {
+	specbos *p = (specbos *)pp;
+	if (p->refrvalid) {
+		*ref_rate = p->refrate;
+		return inst_ok;
+	} else if (p->rrset) {
+		*ref_rate = 0.0;
+		return inst_misread;
+	}
+	return inst_needs_cal;
+}
+
+/* Set the calibrated refresh rate in Hz. */
+/* Set refresh rate to 0.0 to mark it as invalid */
+/* Rates outside the range 5.0 to 150.0 Hz will return an error */
+static inst_code specbos_set_refr_rate(inst *pp,
+double ref_rate
+) {
+	specbos *p = (specbos *)pp;
+	inst_code rv;
+
+	a1logd(p->log,5,"specbos_set_refr_rate %f Hz\n",ref_rate);
+
+	if (ref_rate != 0.0 && (ref_rate < 5.0 || ref_rate > 150.0))
+		return inst_bad_parameter;
+
+	p->refrate = ref_rate;
+	if (ref_rate == 0.0)
+		p->refrvalid = 0;
+	else {
+		p->refperiod = 1.0/ref_rate;
+		p->refrvalid = 1;
+	}
+	p->rrset = 1;
+
+	/* Set the instrument to given refresh rate */
+	amutex_lock(p->lock);
+	if ((rv = specbos_imp_set_refresh(p)) != inst_ok) {
+		amutex_unlock(p->lock);
+		return rv;
+	}
+	amutex_unlock(p->lock);
+
+	return inst_ok;
+}
+
+
+/* Error codes interpretation */
+static char *
+specbos_interp_error(inst *pp, int ec) {
+//	specbos *p = (specbos *)pp;
+	ec &= inst_imask;
+	switch (ec) {
+		case SPECBOS_INTERNAL_ERROR:
+			return "Internal software error";
+		case SPECBOS_TIMEOUT:
+			return "Communications timeout";
+		case SPECBOS_COMS_FAIL:
+			return "Communications failure";
+		case SPECBOS_UNKNOWN_MODEL:
+			return "Not a JETI specbos";
+		case SPECBOS_DATA_PARSE_ERROR:
+			return "Data from specbos didn't parse as expected";
+		case SPECBOS_SPOS_EMIS:
+			return "Ambient filter should be removed";
+		case SPECBOS_SPOS_AMB:
+			return "Ambient filter should be used";
+
+		case SPECBOS_OK:
+			return "No device error";
+
+		case SPECBOS_COMMAND:
+			return "Command";
+		case SPECBOS_PASSWORD:
+			return "Password";
+		case SPECBOS_DIGIT:
+			return "Digit";
+		case SPECBOS_ARG_1:
+			return "Argument 1";
+		case SPECBOS_ARG_2:
+			return "Argument 2";
+		case SPECBOS_ARG_3:
+			return "Argument 3";
+		case SPECBOS_ARG_4:
+			return "Argument 4";
+		case SPECBOS_PARAM:
+			return "Parameter argument";
+		case SPECBOS_CONFIG_ARG:
+			return "Config argument";
+		case SPECBOS_CONTROL_ARG:
+			return "Control argument";
+		case SPECBOS_READ_ARG:
+			return "Read argument";
+		case SPECBOS_FETCH_ARG:
+			return "Fetch argument";
+		case SPECBOS_MEAS_ARG:
+			return "Measuring argument";
+		case SPECBOS_CALC_ARG:
+			return "Calculation argument";
+		case SPECBOS_CAL_ARG:
+			return "Calibration argument";
+		case SPECBOS_PARAM_CHSUM:
+			return "Parameter checksum";
+		case SPECBOS_USERFILE_CHSUM:
+			return "Userfile checksum";
+		case SPECBOS_USERFILE2_CHSUM:
+			return "Userfile2 checksum";
+		case SPECBOS_USERFILE2_ARG:
+			return "Userfile2 argument";
+		case SPECBOS_OVEREXPOSED:
+			return "Overexposure";
+		case SPECBOS_UNDEREXPOSED:
+			return "Underexposure";
+		case SPECBOS_ADAPT_INT_TIME:
+			return "Adaption integration time";
+		case SPECBOS_NO_SHUTTER:
+			return "Shutter doesn't exist";
+		case SPECBOS_NO_DARK_MEAS:
+			return "No dark measurement";
+		case SPECBOS_NO_REF_MEAS:
+			return "No reference measurement";
+		case SPECBOS_NO_TRANS_MEAS:
+			return "No transmission measurement";
+		case SPECBOS_NO_RADMTRC_CALC:
+			return "No radiometric calculation";
+		case SPECBOS_NO_CCT_CALC:
+			return "No CCT calculation";
+		case SPECBOS_NO_CRI_CALC:
+			return "No CRI calculation";
+		case SPECBOS_NO_DARK_COMP:
+			return "No dark compensation";
+		case SPECBOS_NO_LIGHT_MEAS:
+			return "No light measurement";
+		case SPECBOS_NO_PEAK_CALC:
+			return "No peak calculation";
+		case SPECBOS_CAL_DATA:
+			return "Calibration data";
+		case SPECBOS_EXCEED_CAL_WL:
+			return "Exceeded calibration wavelength";
+		case SPECBOS_SCAN_BREAK:
+			return "Scan break";
+		case SPECBOS_TO_CYC_OPT_TRIG:
+			return "Timeout cycle on optical trigger";
+		case SPECBOS_DIV_CYC_TIME:
+			return "Divider cycle time";
+		case SPECBOS_WRITE_FLASH_PARM:
+			return "Write parameter to flash";
+		case SPECBOS_READ_FLASH_PARM:
+			return "Read parameter from flash";
+		case SPECBOS_FLASH_ERASE:
+			return "Erase flash";
+		case SPECBOS_NO_CALIB_FILE:
+			return "No calibration file";
+		case SPECBOS_CALIB_FILE_HEADER:
+			return "Calibration file header";
+		case SPECBOS_WRITE_CALIB_FILE:
+			return "Write calibration file";
+		case SPECBOS_CALIB_FILE_VALS:
+			return "Calibration file values";
+		case SPECBOS_CALIB_FILE_NO:
+			return "Calibration file number";
+		case SPECBOS_CLEAR_CALIB_FILE:
+			return "Clear calibration file";
+		case SPECBOS_CLEAR_CALIB_ARG:
+			return "Clear calibration file argument";
+		case SPECBOS_NO_LAMP_FILE:
+			return "No lamp file";
+		case SPECBOS_LAMP_FILE_HEADER:
+			return "Lamp file header";
+		case SPECBOS_WRITE_LAMP_FILE:
+			return "Write lamp file";
+		case SPECBOS_LAMP_FILE_VALS:
+			return "Lamp file values";
+		case SPECBOS_LAMP_FILE_NO:
+			return "Lamp file number";
+		case SPECBOS_CLEAR_LAMP_FILE:
+			return "Clear lamp file";
+		case SPECBOS_CLEAR_LAMP_FILE_ARG:
+			return "Clear lamp file argument";
+		case SPECBOS_RAM_CHECK:
+			return "RAM check";
+		case SPECBOS_DATA_OUTPUT:
+			return "Data output";
+		case SPECBOS_RAM_LOW:
+			return "Insufcient RAM";
+		case SPECBOS_FIRST_MEM_ALLOC:
+			return "First memory allocation";
+		case SPECBOS_SECOND_MEM_ALLOC:
+			return "Second memory allocation";
+		case SPECBOS_THIRD_MEM_ALLOC:
+			return "Third memory allocation";
+		case SPECBOS_RADMTRC_WL_RANGE:
+			return "Wavelength range for radiometric calculation";
+		case SPECBOS_BOOT_BAT_POWER:
+			return "Boot by battery power";
+		case SPECBOS_TRIG_CONF_1:
+			return "Trigger configuration 1";
+		case SPECBOS_TRIG_CONF_2:
+			return "Trigger configuration 2";
+
+		case SPECBOS_INT_THREADFAILED:
+			return "Starting diffuser position thread failed";
+
+		default:
+			return "Unknown error code";
+	}
+}
+
+
+/* Convert a machine specific error code into an abstract dtp code */
+static inst_code 
+specbos_interp_code(inst *pp, int ec) {
+
+	ec &= inst_imask;
+	switch (ec) {
+
+		case SPECBOS_OK:
+			return inst_ok;
+
+		case SPECBOS_INTERNAL_ERROR:
+		case SPECBOS_INT_THREADFAILED:
+			return inst_internal_error | ec;
+
+		case SPECBOS_TIMEOUT:
+		case SPECBOS_COMS_FAIL:
+			return inst_coms_fail | ec;
+
+		case SPECBOS_UNKNOWN_MODEL:
+			return inst_unknown_model | ec;
+
+		case SPECBOS_DATA_PARSE_ERROR:
+			return inst_protocol_error | ec;
+
+		case SPECBOS_SPOS_EMIS:
+		case SPECBOS_SPOS_AMB:
+			return inst_wrong_config | ec;
+
+		case SPECBOS_COMMAND:
+		case SPECBOS_DIGIT:
+		case SPECBOS_ARG_1:
+		case SPECBOS_ARG_2:
+		case SPECBOS_ARG_3:
+		case SPECBOS_ARG_4:
+		case SPECBOS_PARAM:
+		case SPECBOS_CONFIG_ARG:
+		case SPECBOS_CONTROL_ARG:
+		case SPECBOS_READ_ARG:
+		case SPECBOS_FETCH_ARG:
+		case SPECBOS_MEAS_ARG:
+		case SPECBOS_CALC_ARG:
+		case SPECBOS_CAL_ARG:
+			return inst_bad_parameter | ec;
+
+		case SPECBOS_OVEREXPOSED:
+		case SPECBOS_UNDEREXPOSED:
+			return inst_misread | ec;
+
+		case SPECBOS_PASSWORD:
+		case SPECBOS_PARAM_CHSUM:
+		case SPECBOS_USERFILE_CHSUM:
+		case SPECBOS_USERFILE2_CHSUM:
+		case SPECBOS_USERFILE2_ARG:
+		case SPECBOS_ADAPT_INT_TIME:
+		case SPECBOS_NO_SHUTTER:
+		case SPECBOS_NO_DARK_MEAS:
+		case SPECBOS_NO_REF_MEAS:
+		case SPECBOS_NO_TRANS_MEAS:
+		case SPECBOS_NO_RADMTRC_CALC:
+		case SPECBOS_NO_CCT_CALC:
+		case SPECBOS_NO_CRI_CALC:
+		case SPECBOS_NO_DARK_COMP:
+		case SPECBOS_NO_LIGHT_MEAS:
+		case SPECBOS_NO_PEAK_CALC:
+		case SPECBOS_CAL_DATA:
+		case SPECBOS_EXCEED_CAL_WL:
+		case SPECBOS_SCAN_BREAK:
+		case SPECBOS_TO_CYC_OPT_TRIG:
+		case SPECBOS_DIV_CYC_TIME:
+		case SPECBOS_WRITE_FLASH_PARM:
+		case SPECBOS_READ_FLASH_PARM:
+		case SPECBOS_FLASH_ERASE:
+		case SPECBOS_NO_CALIB_FILE:
+		case SPECBOS_CALIB_FILE_HEADER:
+		case SPECBOS_WRITE_CALIB_FILE:
+		case SPECBOS_CALIB_FILE_VALS:
+		case SPECBOS_CALIB_FILE_NO:
+		case SPECBOS_CLEAR_CALIB_FILE:
+		case SPECBOS_CLEAR_CALIB_ARG:
+		case SPECBOS_NO_LAMP_FILE:
+		case SPECBOS_LAMP_FILE_HEADER:
+		case SPECBOS_WRITE_LAMP_FILE:
+		case SPECBOS_LAMP_FILE_VALS:
+		case SPECBOS_LAMP_FILE_NO:
+		case SPECBOS_CLEAR_LAMP_FILE:
+		case SPECBOS_CLEAR_LAMP_FILE_ARG:
+		case SPECBOS_RAM_CHECK:
+		case SPECBOS_DATA_OUTPUT:
+		case SPECBOS_RAM_LOW:
+		case SPECBOS_FIRST_MEM_ALLOC:
+		case SPECBOS_SECOND_MEM_ALLOC:
+		case SPECBOS_THIRD_MEM_ALLOC:
+		case SPECBOS_RADMTRC_WL_RANGE:
+		case SPECBOS_BOOT_BAT_POWER:
+		case SPECBOS_TRIG_CONF_1:
+		case SPECBOS_TRIG_CONF_2:
+			return inst_hardware_fail | ec;
+	}
+	return inst_other_error | ec;
+}
+
+/* Destroy ourselves */
+static void
+specbos_del(inst *pp) {
+	if (pp != NULL) {
+		specbos *p = (specbos *)pp;
+		if (p->th != NULL) {		/* Terminate diffuser monitor thread  */
+			int i;
+			p->th_term = 1;			/* Tell thread to exit on error */
+			for (i = 0; p->th_termed == 0 && i < 5; i++)
+				msec_sleep(100);	/* Wait for thread to terminate */
+			if (i >= 5) {
+				a1logd(p->log,3,"specbos diffuser thread termination failed\n");
+			}
+			p->th->del(p->th);
+		}
+		if (p->icom != NULL)
+			p->icom->del(p->icom);
+		amutex_del(p->lock);
+		free(p);
+	}
+}
+
+/* Return the instrument mode capabilities */
+void specbos_capabilities(inst *pp,
+inst_mode *pcap1,
+inst2_capability *pcap2,
+inst3_capability *pcap3) {
+	specbos *p = (specbos *)pp;
+	inst_mode cap1 = 0;
+	inst2_capability cap2 = 0;
+
+	cap1 |= inst_mode_emis_tele
+	     |  inst_mode_ambient
+	     |  inst_mode_colorimeter
+	     |  inst_mode_spectral
+	     |  inst_mode_emis_refresh_ovd
+	     |  inst_mode_emis_norefresh_ovd
+	        ;
+
+	/* can inst2_has_sensmode, but not report it asynchronously */
+	cap2 |= inst2_prog_trig
+	     |  inst2_user_trig
+	     |  inst2_disptype
+	     |  inst2_has_target	/* Has a laser target */
+	        ;
+
+	if (p->model != 1201) {
+		cap2 |= inst2_emis_refr_meas;
+		cap2 |= inst2_set_refresh_rate;
+		cap2 |= inst2_get_refresh_rate;
+	}
+
+	if (pcap1 != NULL)
+		*pcap1 = cap1;
+	if (pcap2 != NULL)
+		*pcap2 = cap2;
+	if (pcap3 != NULL)
+		*pcap3 = inst3_none;
+}
+
+/* Return current or given configuration available measurement modes. */
+static inst_code specbos_meas_config(
+inst *pp,
+inst_mode *mmodes,
+inst_cal_cond *cconds,
+int *conf_ix
+) {
+	specbos *p = (specbos *)pp;
+	inst_code ev;
+	inst_mode mval;
+	int pos;
+
+	if (mmodes != NULL)
+		*mmodes = inst_mode_none;
+	if (cconds != NULL)
+		*cconds = inst_calc_unknown;
+
+	if (conf_ix == NULL
+	 || *conf_ix < 0
+	 || *conf_ix > 1) {
+		/* Return current configuration measrement modes */
+		amutex_lock(p->lock);
+		if ((ev = specbos_get_diffpos(p, &pos, 0)) != inst_ok) {
+			amutex_unlock(p->lock);
+			return ev;
+		}
+		amutex_unlock(p->lock);
+	} else {
+		/* Return given configuration measurement modes */
+		pos = *conf_ix;
+	}
+
+	if (pos == 1) {
+		mval = inst_mode_emis_ambient;
+	} else if (pos == 0) {
+		mval |= inst_mode_emis_tele;
+	}
+
+	/* Add the extra dependent and independent modes */
+	mval |= inst_mode_emis_refresh_ovd
+	     |  inst_mode_emis_norefresh_ovd
+	     |  inst_mode_colorimeter
+	     |  inst_mode_spectral;
+
+	if (mmodes != NULL)	
+		*mmodes = mval;
+
+	/* Return configuration index returned */
+	if (conf_ix != NULL)
+		*conf_ix = pos;
+
+	return inst_ok;
+}
+
+/* Check device measurement mode */
+inst_code specbos_check_mode(inst *pp, inst_mode m) {
+	inst_mode cap;
+
+	if (!pp->gotcoms)
+		return inst_no_coms;
+	if (!pp->inited)
+		return inst_no_init;
+
+	pp->capabilities(pp, &cap, NULL, NULL);
+
+	/* Simple test */
+	if (m & ~cap)
+		return inst_unsupported;
+
+	/* Only tele emission mode supported */
+	if (!IMODETST(m, inst_mode_emis_tele)
+	 && !IMODETST(m, inst_mode_emis_ambient)) {
+		return inst_unsupported;
+	}
+
+	return inst_ok;
+}
+
+/* Set device measurement mode */
+inst_code specbos_set_mode(inst *pp, inst_mode m) {
+	specbos *p = (specbos *)pp;
+	int refrmode;
+	inst_code ev;
+
+	if ((ev = specbos_check_mode(pp, m)) != inst_ok)
+		return ev;
+
+	p->mode = m;
+
+
+	if (p->model != 1201) {		/* Can't set refresh mode on 1201 */
+
+		/* Effective refresh mode may change */
+		refrmode = p->refrmode;
+		if (     IMODETST(p->mode, inst_mode_emis_norefresh_ovd)) {	/* Must test this first! */
+			refrmode = 0;
+		} else if (IMODETST(p->mode, inst_mode_emis_refresh_ovd)) {
+			refrmode = 1;
+		}
+		
+		if (p->refrmode != refrmode) {
+			p->rrset = 0;					/* This is a hint we may have swapped displays */
+			p->refrvalid = 0;
+		}
+		p->refrmode = refrmode; 
+	}
+
+	return inst_ok;
+}
+
+inst_disptypesel specbos_disptypesel[3] = {
+	{
+		inst_dtflags_default,
+		1,
+		"nl",
+		"Non-Refresh display",
+		0,
+		0
+	},
+	{
+		inst_dtflags_none,			/* flags */
+		2,							/* cbid */
+		"rc",						/* sel */
+		"Refresh display",			/* desc */
+		1,							/* refr */
+		1							/* ix */
+	},
+	{
+		inst_dtflags_end,
+		0,
+		"",
+		"",
+		0,
+		0
+	}
+};
+
+/* Get mode and option details */
+static inst_code specbos_get_disptypesel(
+inst *pp,
+int *pnsels,				/* Return number of display types */
+inst_disptypesel **psels,	/* Return the array of display types */
+int allconfig,				/* nz to return list for all configs, not just current. */
+int recreate				/* nz to re-check for new ccmx & ccss files */
+) {
+	specbos *p = (specbos *)pp;
+	inst_code rv = inst_ok;
+
+	if ((!allconfig && (p->mode & inst_mode_ambient))		/* If set to Ambient */
+	 || p->model == 1201) {			/* Or 1201, return empty list */
+
+		if (pnsels != NULL)
+			*pnsels = 0;
+	
+		if (psels != NULL)
+			*psels = NULL;
+
+		return inst_ok;
+	}
+
+
+	if (pnsels != NULL)
+		*pnsels = 2;
+
+	if (psels != NULL)
+		*psels = specbos_disptypesel;
+
+	return inst_ok;
+}
+
+/* Given a display type entry, setup for that type */
+static inst_code set_disp_type(specbos *p, inst_disptypesel *dentry) {
+	inst_code rv;
+	int refrmode;
+
+	refrmode = dentry->refr;
+
+	a1logd(p->log,5,"specbos set_disp_type refmode %d\n",refrmode);
+
+	if (     IMODETST(p->mode, inst_mode_emis_norefresh_ovd)) {	/* Must test this first! */
+		refrmode = 0;
+	} else if (IMODETST(p->mode, inst_mode_emis_refresh_ovd)) {
+		refrmode = 1;
+	}
+
+	if (p->refrmode != refrmode)
+		p->rrset = 0;					/* This is a hint we may have swapped displays */
+	p->refrmode = refrmode; 
+
+	amutex_lock(p->lock);
+	if ((rv = specbos_imp_set_refresh(p)) != inst_ok) {
+		amutex_unlock(p->lock);
+		return rv;
+	}
+	amutex_unlock(p->lock);
+
+	return inst_ok;
+}
+
+/* Set the display type */
+static inst_code specbos_set_disptype(inst *pp, int ix) {
+	specbos *p = (specbos *)pp;
+	inst_code ev;
+	inst_disptypesel *dentry;
+
+	if (!p->gotcoms)
+		return inst_no_coms;
+	if (!p->inited)
+		return inst_no_init;
+
+	if (p->model == 1201)			/* No display type to select on 1201 */
+		return inst_unsupported;
+
+	if (ix < 0 || ix >= 2)
+		return inst_unsupported;
+
+	a1logd(p->log,5,"specbos  specbos_set_disptype ix %d\n",ix);
+	dentry = &specbos_disptypesel[ix];
+
+	if ((ev = set_disp_type(p, dentry)) != inst_ok) {
+		return ev;
+	}
+
+	return inst_ok;
+}
+
+/* 
+ * set or reset an optional mode
+ *
+ * Some options talk to the instrument, and these will
+ * error if it hasn't been initialised.
+ */
+static inst_code
+specbos_get_set_opt(inst *pp, inst_opt_type m, ...)
+{
+	specbos *p = (specbos *)pp;
+	char buf[MAX_MES_SIZE];
+	inst_code ev = inst_ok;
+
+	a1logd(p->log, 5, "specbos_get_set_opt: opt type 0x%x\n",m);
+
+	/* Record the trigger mode */
+	if (m == inst_opt_trig_prog
+	 || m == inst_opt_trig_user) {
+		p->trig = m;
+		return inst_ok;
+	}
+
+	/* Set laser target state */
+	if (m == inst_opt_set_target_state) {
+		va_list args;
+		int state = 0;
+
+		va_start(args, m);
+		state = va_arg(args, int);
+		va_end(args);
+
+		amutex_lock(p->lock);
+		if (state == 2) { 
+			int lstate = -1;
+			if ((ev = specbos_command(p, "*contr:laser?\r", buf, MAX_MES_SIZE, 1.0)) != inst_ok) {
+				amutex_unlock(p->lock);
+				a1loge(p->log, 1, "specbos_get_set_opt: failed to send laser? command\n");
+				return ev;
+			}
+			if (sscanf(buf, "laser: %d ",&lstate) != 1) {
+				amutex_unlock(p->lock);
+				a1loge(p->log, 1, "specbos_get_set_opt: failed to parse laser state\n");
+				return ev;
+			}
+			a1logd(p->log, 5, " Laser state = %d\n",lstate);
+			if (lstate == 0)
+				lstate = 1;
+			else if (lstate == 1)
+				lstate = 0;
+			if (lstate == 0 || lstate == 1) {
+				char mes[100];
+				sprintf(mes,"*contr:laser %d\r",lstate);
+				if ((ev = specbos_command(p, mes, buf, MAX_MES_SIZE, 1.0)) != inst_ok) {
+					amutex_unlock(p->lock);
+					return ev;
+				}
+			}
+		} else if (state == 1) { 
+			if ((ev = specbos_command(p, "*contr:laser 1\r", buf, MAX_MES_SIZE, 1.0)) != inst_ok) {
+				amutex_unlock(p->lock);
+				return ev;
+			}
+		} else if (state == 0) {
+			if ((ev = specbos_command(p, "*contr:laser 0\r", buf, MAX_MES_SIZE, 1.0)) != inst_ok) {
+				amutex_unlock(p->lock);
+				return ev;
+			}
+		}
+		amutex_unlock(p->lock);
+		return inst_ok;
+	}
+
+	if (!p->gotcoms)
+		return inst_no_coms;
+	if (!p->inited)
+		return inst_no_init;
+
+	return inst_unsupported;
+}
+
+/* Constructor */
+extern specbos *new_specbos(icoms *icom, instType itype) {
+	specbos *p;
+	if ((p = (specbos *)calloc(sizeof(specbos),1)) == NULL) {
+		a1loge(icom->log, 1, "new_specbos: malloc failed!\n");
+		return NULL;
+	}
+
+	p->log = new_a1log_d(icom->log);
+
+	p->init_coms         = specbos_init_coms;
+	p->init_inst         = specbos_init_inst;
+	p->capabilities      = specbos_capabilities;
+	p->meas_config       = specbos_meas_config;
+	p->check_mode        = specbos_check_mode;
+	p->set_mode          = specbos_set_mode;
+	p->get_disptypesel   = specbos_get_disptypesel;
+	p->set_disptype      = specbos_set_disptype;
+	p->get_set_opt       = specbos_get_set_opt;
+	p->read_sample       = specbos_read_sample;
+	p->read_refrate      = specbos_read_refrate;
+	p->get_n_a_cals      = specbos_get_n_a_cals;
+	p->calibrate         = specbos_calibrate;
+	p->get_refr_rate     = specbos_get_refr_rate;
+	p->set_refr_rate     = specbos_set_refr_rate;
+	p->interp_error      = specbos_interp_error;
+	p->del               = specbos_del;
+
+	p->icom = icom;
+	p->itype = icom->itype;
+	if (p->itype == instSpecbos1201)
+		p->model = 1201;
+
+	amutex_init(p->lock);
+
+	return p;
+}
+