Initial import of argyll version 1.5.1-8debian/1.5.1-8

1 files changed, 898 insertions, 0 deletions

diff --git a/spectro/dtp51.c b/spectro/dtp51.c
new file mode 100644
index 0000000..7e49f3e
--- /dev/null
+++ b/spectro/dtp51.c
@@ -0,0 +1,898 @@
+/* 
+ * Argyll Color Correction System
+ *
+ * Xrite DTP51 related functions
+ *
+ * Author: Graeme W. Gill
+ * Date:   5/10/96
+ *
+ * Copyright 1996 - 2013, 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.
+ */
+
+/* 
+   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:
+
+	Recovery from needing calibration may not work properly ?
+
+ */
+
+#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 "dtp51.h"
+
+#undef DEBUG
+
+/* Default flow control */
+#define DEFFC fc_Hardware
+
+static inst_code dtp51_interp_code(inst *pp, int ec);
+
+#define MAX_MES_SIZE 500		/* Maximum normal message reply size */
+#define MAX_RD_SIZE 5000		/* Maximum reading messagle reply size */
+
+/* Extract an error code from a reply string */
+/* Return -1 if no error code can be found */
+static int 
+extract_ec(char *s) {
+	char *p;
+	char tt[3];
+	int rv;
+	p = s + strlen(s);
+	/* Find the trailing '>' */
+	for (p--; p >= s;p--) {
+		if (*p == '>')
+			break;
+	}
+	if (  (p-3) < s
+	   || p[0] != '>'
+	   || p[-3] != '<')
+		return -1;
+	tt[0] = p[-2];
+	tt[1] = p[-1];
+	tt[2] = '\000';
+	if (sscanf(tt,"%x",&rv) != 1)
+		return -1;
+	return rv & 0x7f;		/* Mask out MSB */
+}
+
+/* Interpret an icoms error into a DTP51 error */
+static int icoms2dtp51_err(int se) {
+	if (se != ICOM_OK) {
+		if (se & ICOM_TO)
+			return DTP51_TIMEOUT; 
+		return DTP51_COMS_FAIL;
+	}
+	return DTP51_OK;
+}
+
+/* Do a full featured command/response echange with the dtp51 */
+/* Return the dtp error code. End on the specified number */
+/* of specified characters, or expiry if the specified timeout */
+/* Assume standard error code if tc = '>' and ntc = 1 */
+/* Return a DTP51 error code */
+static int
+dtp51_fcommand(
+	struct _dtp51 *p,
+	char *in,			/* In string */
+	char *out,			/* Out string buffer */
+	int bsize,			/* Out buffer size */
+	char tc,			/* Terminating character */
+	int ntc,			/* Number of terminating characters */
+	double to) {		/* Timout in seconts */
+	int rv, se;
+
+	if ((se = p->icom->write_read(p->icom, in, out, bsize, tc, ntc, to)) != 0) {
+		a1logd(p->log, 1, "dtp51_fcommand: serial i/o failure on write_read '%s'\n",icoms_fix(in));
+		return icoms2dtp51_err(se);
+	}
+	rv = DTP51_OK;
+	if (tc == '>' && ntc == 1) {
+		rv = extract_ec(out);
+		if (rv > 0) {
+			rv &= inst_imask;
+			if (rv != DTP51_OK) {	/* Clear the error */
+				char buf[MAX_MES_SIZE];
+				p->icom->write_read(p->icom, "CE\r", buf, MAX_MES_SIZE, '>', 1, 0.5);
+			}
+		}
+	}
+	a1logd(p->log, 4, "dtp51_fcommand: command '%s' returned '%s', value 0x%x\n",
+	                                          icoms_fix(in), icoms_fix(out),rv);
+	return rv;
+}
+
+/* Do a standard command/response echange with the dtp51 */
+/* Return the dtp error code */
+static inst_code
+dtp51_command(dtp51 *p, char *in, char *out, int bsize, double to) {
+	int rv = dtp51_fcommand(p, in, out, bsize, '>', 1, to);
+	return dtp51_interp_code((inst *)p, rv);
+}
+
+/* Just read a response from the dtp51 */
+/* Return the dtp error code. */
+static int
+dtp51_read(
+struct _dtp51 *p,
+char *out,			/* Out string buffer */
+int bsize,			/* Out buffer size */
+double to) {		/* Timout in seconts */
+	char tc = '>';		/* Terminating character */
+	int ntc = 1;		/* Number of terminating characters */
+	int rv, se;
+
+	if ((se = p->icom->read(p->icom, out, bsize, tc, ntc, to)) != 0) {
+		a1logd(p->log, 1, "dtp51_fcommand: serial i/o failure on read\n");
+		return icoms2dtp51_err(se);
+	}
+	rv = DTP51_OK;
+	if (tc == '>' && ntc == 1) {
+		rv = extract_ec(out);
+		if (rv > 0) {
+			rv &= inst_imask;
+			if (rv != DTP51_OK) {	/* Clear the error */
+				char buf[MAX_MES_SIZE];
+				p->icom->write_read(p->icom, "CE\r", buf, MAX_MES_SIZE, '>', 1, 0.5);
+			}
+		}
+	}
+	a1logd(p->log, 4, "dtp51_read: returned '%s', value 0x%x\n", icoms_fix(out),rv);
+
+	return rv;
+}
+
+/* Establish communications with a DTP51 */
+/* Use the baud rate given, and timeout in to secs */
+/* Return DTP_COMS_FAIL on failure to establish communications */
+static inst_code
+dtp51_init_coms(inst *pp, baud_rate br, flow_control fc, double tout) {
+	dtp51 *p = (dtp51 *)pp;
+	static char buf[MAX_MES_SIZE];
+	baud_rate brt[5] = { baud_9600, baud_19200, baud_4800, baud_2400, baud_1200 };
+	char *brc[5]     = { "30BR\r",  "60BR\r",   "18BR\r",  "0CBR\r",  "06BR\r" };
+	char *fcc;
+	unsigned int etime;
+	int ci, bi, i, se;
+	inst_code ev = inst_ok;
+
+	a1logd(p->log, 2, "dtp51_init_coms: About to init Serial I/O\n");
+
+	/* Deal with flow control setting */
+	if (fc == fc_nc)
+		fc = DEFFC;
+	if (fc == fc_XonXOff) {
+		fcc = "0304CF\r";
+	} else if (fc == fc_Hardware) {
+		fcc = "0104CF\r";
+	} else {
+		fc = fc_none;
+		fcc = "0004CF\r";
+	}
+
+	/* Figure DTP51 baud rate being asked for */
+	for (bi = 0; bi < 5; bi++) {
+		if (brt[bi] == br)
+			break;
+	}
+	if (bi >= 5)
+		bi = 0;	
+
+	/* Figure current icoms baud rate */
+	for (ci = 0; ci < 5; ci++) {
+		if (brt[ci] == p->icom->br)
+			break;
+	}
+	if (ci >= 5)
+		ci = bi;	
+
+	/* The tick to give up on */
+	etime = msec_time() + (long)(1000.0 * tout + 0.5);
+
+	while (msec_time() < etime) {
+
+		/* Until we time out, find the correct baud rate */
+		for (i = ci; msec_time() < etime;) {
+			if ((se = p->icom->set_ser_port(p->icom, fc_none, brt[i], parity_none,
+				                                    stop_1, length_8)) != ICOM_OK) { 
+				a1logd(p->log, 1, "dtp51_init_coms: set_ser_port failed ICOM err 0x%x\n",se);
+				return dtp51_interp_code((inst *)p, icoms2dtp51_err(se));
+			}
+
+			if (((ev = dtp51_command(p, "\r", buf, MAX_MES_SIZE, 0.5)) & inst_mask)
+				                                                 != inst_coms_fail)
+				break;		/* We've got coms */
+
+			/* Check for user abort */
+			if (p->uicallback != NULL) {
+				inst_code ev;
+				if ((ev = p->uicallback(p->uic_cntx, inst_negcoms)) == inst_user_abort) {
+					a1logd(p->log, 1, "dtp22_init_coms: user aborted\n");
+					return inst_user_abort;
+				}
+			}
+			if (++i >= 5)
+				i = 0;
+		}
+		break;		/* Got coms */
+	}
+
+	if (msec_time() >= etime) {		/* We haven't established comms */
+		return inst_coms_fail;
+	}
+
+	/* Set the handshaking */
+	if ((ev = dtp51_command(p, fcc, buf, MAX_MES_SIZE, 1.5)) != inst_ok)
+		return ev;
+
+	/* Change the baud rate to the rate we've been told */
+	if ((se = p->icom->write_read(p->icom, brc[bi], buf, MAX_MES_SIZE, '>', 1, 1.5)) != 0) {
+		if (extract_ec(buf) != DTP51_OK)
+			return inst_coms_fail;
+	}
+
+	/* Configure our baud rate and handshaking as well */
+	if ((se = p->icom->set_ser_port(p->icom, fc, brt[bi], parity_none, stop_1, length_8))
+		                                                                      != ICOM_OK) { 
+		a1logd(p->log, 1, "dtp51_init_coms: set_ser_port failed ICOM err 0x%x\n",se);
+		return dtp51_interp_code((inst *)p, icoms2dtp51_err(se));
+	}
+
+	/* Loose a character (not sure why) */
+	p->icom->write_read(p->icom, "\r", buf, MAX_MES_SIZE, '>', 1, 0.5);
+
+	/* Check instrument is responding */
+	if ((ev = dtp51_command(p, "\r", buf, MAX_MES_SIZE, 1.5)) != inst_ok)
+		return inst_coms_fail;
+
+	if (p->log->verb) {
+		int i, j;
+		if ((ev = dtp51_command(p, "GI\r", buf, MAX_MES_SIZE, 0.2)) != inst_ok
+		 && (ev & inst_imask) != DTP51_BAD_COMMAND)
+			return ev;
+
+		if ((ev & inst_imask) == DTP51_BAD_COMMAND) { /* Some fimware doesn't support GI */
+			a1logv(p->log, 1, "dtp51: Firware doesn't support GI command\n");
+		} else {
+			for (j = i = 0; ;i++) {
+				if (buf[i] == '<' || buf[i] == '\000')
+					break;
+				if (buf[i] == '\r') {
+					buf[i] = '\000';
+					a1logv(p->log, 1, " %s\n",&buf[j]);
+					if (buf[i+1] == '\n')
+						i++;
+					j = i+1;
+				}
+			}
+		}
+	}
+
+	a1logd(p->log, 4, "dtp51: Got coms OK\n");
+	p->gotcoms = 1;
+	return inst_ok;
+}
+
+/* Build a strip definition as a set of passes */
+static void
+build_strip(
+char *tp,			/* pointer to string buffer */
+char *name,			/* Strip name (7 chars) */
+int npatch,			/* Number of patches in the pass */
+char *pname,		/* Pass name (3 chars) */
+int sguide) {		/* Guide number */
+	int i;
+
+	/* Per strip */
+	for (i = 0; i < 7 && *name != '\000'; i++)
+		*tp++ = *name++;	/* Strip name padded to 7 characters */
+	for (; i < 7; i++)
+		*tp++ = ' ';
+	*tp++ = '1'; *tp++ = '0'; *tp++ = '0'; *tp++ = '0';	/* N factor */
+	*tp++ = 'F';				/* Forward order */
+	*tp++ = '1';				/* No min/max transmitted */
+	*tp++ = '0';				/* No absolute data, no extra steps */
+	*tp++ = '0'; *tp++ = '0'; *tp++ = '0'; *tp++ = '0'; *tp++ = '0';	/* Reserved */
+
+	/* Per pass */
+	for (i = 0; i < 3 && *pname != '\000'; i++)
+		*tp++ = *pname++;		/* Pass name padded to 3 characters */
+	for (; i < 3; i++)
+		*tp++ = ' ';
+	/* *tp++ = '4'; */			/* Lab data */
+	*tp++ = '5';				/* XYZ data */
+	*tp++ = '8';				/* Auto color */
+	*tp++ = '0' + (char)(npatch/10);	/* Number of patches MS */
+	*tp++ = '0' + (char)(npatch%10);	/* Number of patches LS */
+	*tp++ = '0' + (char)(sguide/10);	/* Guide location MS */
+	*tp++ = '0' + (char)(sguide%10);	/* Guide location LS */
+	*tp++ = '0';				/* (Data output type) */
+	*tp++ = '0';				/* Extra steps */
+	*tp++ = '0';				/* Reserved */
+
+	*tp++ = '\r';				/* The CR */
+	*tp++ = '\000';				/* The end */
+}
+		
+/* Initialise the DTP51. The spectral flag is ignored. */
+/* return non-zero on an error, with dtp error code */
+static inst_code
+dtp51_init_inst(inst *pp) {
+	dtp51 *p = (dtp51 *)pp;
+	static char tbuf[100], buf[MAX_MES_SIZE];
+	int rv;
+	inst_code ev = inst_ok;
+
+	a1logd(p->log, 2, "dtp51_init_inst: called\n");
+
+	if (p->gotcoms == 0)
+		return inst_internal_error;		/* Must establish coms before calling init */
+
+	/* Reset it */
+	if ((ev = dtp51_command(p, "0PR\r", buf, MAX_MES_SIZE, 1.5)) != inst_ok)
+		return ev;
+	sleep(2);	/* Let it recover from reset */
+
+	/* Turn echoing of characters off */
+	if ((ev = dtp51_command(p, "EC\r", buf, MAX_MES_SIZE, 1.5)) != inst_ok)
+		return ev;
+
+	/* Get the model and version number */
+	if ((ev = dtp51_command(p, "SV\r", buf, MAX_MES_SIZE, 1.5)) != inst_ok)
+		return ev;
+
+	/* Check that it is a DTP51 or 52 */
+	if (   strlen(buf) < 12
+	    || strncmp(buf,"X-Rite DTP5",11) != 0
+	    || (buf[11] != '1' && buf[11] != '2'))
+		return inst_unknown_model;
+
+	/* Set the A/D Conversion rate to normal */
+	if ((ev = dtp51_command(p, "00AD\r", buf, MAX_MES_SIZE, 1.5)) != inst_ok)
+		return ev;
+
+	/* Disable Bar code reading to save time */
+	if ((ev = dtp51_command(p, "0BC\r", buf, MAX_MES_SIZE, 1.5)) != inst_ok)
+		return ev;
+
+	/* Set the Calibration Check tolerance to default of 0.15D */
+	if ((ev = dtp51_command(p, "0FCC\r", buf, MAX_MES_SIZE, 1.5)) != inst_ok)
+		return ev;
+
+	/* Set Automatic Transmit off */
+	if ((ev = dtp51_command(p, "0005CF\r", buf, MAX_MES_SIZE, 1.5)) != inst_ok)
+		return ev;
+
+	/* Set Read Status on */
+	if ((ev = dtp51_command(p, "1RS\r", buf, MAX_MES_SIZE, 1.5)) != inst_ok)
+		return ev;
+
+	/* Set decimal pont on */
+	if ((ev = dtp51_command(p, "0106CF\r", buf, MAX_MES_SIZE, 1.5)) != inst_ok)
+		return ev;
+
+	/* Set color data separator to TAB */
+	if ((ev = dtp51_command(p, "0207CF\r", buf, MAX_MES_SIZE, 1.5)) != inst_ok)
+		return ev;
+
+	/* Set default strip format to off */
+	if ((ev = dtp51_command(p, "0009CF\r", buf, MAX_MES_SIZE, 1.5)) != inst_ok)
+		return ev;
+
+	/* Set extra digit resolution */
+	if ((ev = dtp51_command(p, "010ACF\r", buf, MAX_MES_SIZE, 1.5)) != inst_ok)
+		return ev;
+
+	/* Set data after pass to off */
+	if ((ev = dtp51_command(p, "000BCF\r", buf, MAX_MES_SIZE, 1.5)) != inst_ok)
+		return ev;
+
+#ifdef NEVER	/* Doesn't seem to work on DTP51 */
+	/* Set the patch detection window to default HRW = 3, LRW 0.122% */
+	if ((ev = dtp51_command(p, "2CW\r", buf, MAX_MES_SIZE, 1.5)) != inst_ok)
+		return ev;
+#endif
+
+	/* Enable the LCD display */
+	if ((ev = dtp51_command(p, "EL\r", buf, MAX_MES_SIZE, 1.5)) != inst_ok)
+		return ev;
+
+	/* Enable the read microswitch */
+	if ((ev = dtp51_command(p, "1SM\r", buf, MAX_MES_SIZE, 1.5)) != inst_ok)
+		return ev;
+
+	/* Set a strip length of 1, to ensure parsing is invalidated */
+	build_strip(tbuf, "       ", 1, "   ", 30);
+	
+	if ((rv = dtp51_fcommand(p, "0105DS\r", buf, MAX_MES_SIZE, '*', 1, 0.5)) != DTP51_OK)
+		return dtp51_interp_code(pp, rv); 
+
+	/* Expect '*' as response */
+	if (buf[0] != '*' || buf[1] != '\000')
+		return inst_coms_fail;
+
+	/* Send strip definition */
+	if ((ev = dtp51_command(p, tbuf, buf, MAX_MES_SIZE, 4.0)) != inst_ok)
+		return ev;
+
+	/* This is the only mode supported */
+	p->trig = inst_opt_trig_switch;
+
+	p->inited = 1;
+	a1logd(p->log, 2, "dtp51_init_inst: instrument inited OK\n");
+
+	return inst_ok;
+}
+
+/* Read a set of strips */
+/* Return the dtp error code */
+static inst_code
+dtp51_read_strip(
+inst *pp,
+char *name,			/* Strip name (up to first 7 chars used) */
+int npatch,			/* Number of patches in the pass */
+char *pname,		/* Pass name (up to first 3 chars used) */
+int sguide,			/* Guide number */
+double pwid,		/* Patch length in mm (For DTP41) */
+double gwid,		/* Gap length in mm (For DTP41) */
+double twid,		/* Trailer length in mm (For DTP41T) */
+ipatch *vals) {		/* Pointer to array of instrument patch values */
+	dtp51 *p = (dtp51 *)pp;
+	char tbuf[200], *tp;
+	static char buf[MAX_RD_SIZE];
+	int i, rv;
+	inst_code ev = inst_ok;
+
+	if (!p->gotcoms)
+		return inst_no_coms;
+	if (!p->inited)
+		return inst_no_init;
+
+	build_strip(tbuf, name, npatch, pname, sguide);
+	
+	if ((rv = dtp51_fcommand(p, "0105DS\r", buf, MAX_RD_SIZE, '*', 1, 0.5)) != DTP51_OK)
+		return dtp51_interp_code(pp, rv); 
+
+	/* Expect '*' as response */
+	if (buf[0] != '*' || buf[1] != '\000')
+		return inst_coms_fail;
+
+	/* Send strip definition */
+	if ((ev = dtp51_command(p, tbuf, buf, MAX_RD_SIZE, 4.0)) != inst_ok)
+		return ev; 
+
+	/* Do a strip read */
+	if ((ev = dtp51_command(p, "5SW\r", buf, MAX_RD_SIZE, 1.5)) != inst_ok) {
+		if ((ev & inst_mask) == inst_needs_cal)
+			p->need_cal = 1;
+		return ev;
+	}
+
+	/* Wait for the Read status, or a user abort (no user trigger!) */
+	for (;;) {
+		if ((ev = dtp51_read(p, buf, MAX_RD_SIZE, 0.5)) != inst_ok) {
+			if ((ev & inst_mask) == inst_needs_cal)
+				p->need_cal = 1;
+
+			if ((ev & inst_imask) == DTP51_TIMEOUT) {	/* Timed out */
+				if (p->uicallback != NULL) {	/* Check for user trigger */
+					if ((ev = p->uicallback(p->uic_cntx, inst_armed)) == inst_user_abort) {
+						return ev;		/* User abort */
+					}
+				}
+			} else
+				return ev;			/* Instrument or comms error */
+
+		} else {
+			break;					/* Switch activated */
+		}
+	}
+
+	if (p->uicallback)	/* Notify of trigger */
+		p->uicallback(p->uic_cntx, inst_triggered); 
+
+	/* Gather the results */
+	if ((ev = dtp51_command(p, "TS\r", buf, MAX_RD_SIZE, 0.5 + npatch * 0.1)) != inst_ok)
+		return ev;
+
+	/* Parse the buffer */
+	/* Replace '\r' with '\000' */
+	for (tp = buf; *tp != '\000'; tp++) {
+		if (*tp == '\r')
+			*tp = '\000';
+	}
+	for (tp = buf, i = 0; i < npatch; i++) {
+		if (*tp == '\000')
+			return inst_protocol_error;
+		if (sscanf(tp, " X %lf Y %lf Z %lf ",
+		           &vals[i].XYZ[0], &vals[i].XYZ[1], &vals[i].XYZ[2]) != 3) {
+			if (sscanf(tp, " x %lf y %lf z %lf ",
+			           &vals[i].XYZ[0], &vals[i].XYZ[1], &vals[i].XYZ[2]) != 3) {
+				return inst_protocol_error;
+			}
+		}
+		vals[i].mtype = inst_mrt_reflective;
+		vals[i].XYZ_v = 1;
+		vals[i].sp.spec_n = 0;
+		vals[i].duration = 0.0;
+		tp += strlen(tp) + 1;
+	}
+
+#ifdef NEVER
+	/* Disable the read microswitch */
+	if ((ev = dtp51_command(p, "0SM\r", buf, MAX_RD_SIZE)) != inst_ok)
+		return ev;
+#endif
+
+	return inst_ok;
+}
+
+/* Return needed and available inst_cal_type's */
+static inst_code dtp51_get_n_a_cals(inst *pp, inst_cal_type *pn_cals, inst_cal_type *pa_cals) {
+	dtp51 *p = (dtp51 *)pp;
+	inst_cal_type n_cals = inst_calt_none;
+	inst_cal_type a_cals = inst_calt_none;
+		
+	if (p->need_cal)
+		n_cals |= inst_calt_ref_white;
+	a_cals |= inst_calt_ref_white;
+
+	if (pn_cals != NULL)
+		*pn_cals = n_cals;
+
+	if (pa_cals != NULL)
+		*pa_cals = a_cals;
+
+	return inst_ok;
+}
+
+/* Request an instrument calibration. */
+/* This is used if the user decides they want to do a calibration, */
+/* in anticipation of a calibration (needs_calibration()) to avoid */
+/* requiring one during measurement, or in response to measuring */
+/* returning inst_needs_cal. Initially us an inst_cal_cond of inst_calc_none, */
+/* and then be prepared to setup the right conditions, or ask the */
+/* user to do so, each time the error inst_cal_setup is returned. */
+/* NOTE :- we can trigger a calibration ! */
+/* Perhaps we should do so ??? */
+inst_code dtp51_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) */
+) {
+	dtp51 *p = (dtp51 *)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 = dtp51_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,"dtp51_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_white) {
+
+		if (*calc != inst_calc_uop_ref_white) {
+			*calc = inst_calc_uop_ref_white;	/* Ask user to do calibration */
+			return inst_cal_setup;
+		}
+		p->need_cal = 0;
+		*calt &= ~inst_calt_ref_white;
+	}
+	return inst_ok;
+}
+
+/* Error codes interpretation */
+static char *
+dtp51_interp_error(inst *pp, int ec) {
+//	dtp51 *p = (dtp51 *)pp;
+	ec &= inst_imask;
+	switch (ec) {
+		case DTP51_INTERNAL_ERROR:
+			return "Internal software error";
+		case DTP51_COMS_FAIL:
+			return "Communications failure";
+		case DTP51_UNKNOWN_MODEL:
+			return "Not a DTP51 or DTP52";
+		case DTP51_DATA_PARSE_ERROR:
+			return "Data from DTP didn't parse as expected";
+		case DTP51_OK:
+			return "No device error";
+		case DTP51_BAD_COMMAND:
+			return "Unrecognized command";
+		case DTP51_PRM_RANGE:
+			return "Command parameter out of range";
+		case DTP51_DISPLAY_OVERFLOW:
+			return "Display overflow";
+		case DTP51_MEMORY_OVERFLOW:
+			return "Memory bounds error";
+		case DTP51_INVALID_BAUD_RATE:
+			return "Invalid baud rate";
+		case DTP51_TIMEOUT:
+			return "Receive timeout";
+		case DTP51_INVALID_PASS:
+			return "Invalid pass";
+		case DTP51_INVALID_STEP:
+			return "Invalid step";
+		case DTP51_NO_DATA_AVAILABLE:
+			return "No data availble";
+		case DTP51_LAMP_MARGINAL:
+			return "Lamp marginal";
+		case DTP51_LAMP_FAILURE:
+			return "Lamp failure";
+		case DTP51_STRIP_RESTRAINED:
+			return "Strip was restrained";
+		case DTP51_BAD_CAL_STRIP:
+			return "Bad calibration strip";
+		case DTP51_MOTOR_ERROR:
+			return "Motor error";
+		case DTP51_BAD_BARCODE:
+			return "Bad barcode on cal strip";
+		case DTP51_INVALID_READING:
+			return "Invalid strip reading";
+		case DTP51_WRONG_COLOR:
+			return "Wrong color strip";
+		case DTP51_BATTERY_TOO_LOW:
+			return "Battery too low";
+		case DTP51_NEEDS_CALIBRATION:
+			return "Needs calibration";
+		case DTP51_COMP_TABLE_MISMATCH:
+			return "Compensation table mismatch";
+		case DTP51_BAD_COMP_TABLE:
+			return "Bad compensation table";
+		case DTP51_NO_VALID_DATA:
+			return "No valid data found";
+		case DTP51_BAD_PATCH:
+			return "Bad patch in strip";
+		case DTP51_BAD_STRING_LENGTH:
+			return "Bad strip def. string length";
+		case DTP51_BAD_CHARACTER:
+			return "Bad chareter";
+		case DTP51_BAD_MEAS_TYPE:
+			return "Bad measure type field";
+		case DTP51_BAD_COLOR:
+			return "Bad color field";
+		case DTP51_BAD_STEPS:
+			return "Bad step field";
+		case DTP51_BAD_STOP_LOCATION:
+			return "Bad guide stop field";
+		case DTP51_BAD_OUTPUT_TYPE:
+			return "Bad output type field";
+		case DTP51_MEMORY_ERROR:
+			return "Memory error (need AC supply)";
+		case DTP51_BAD_N_FACTOR:
+			return "Bad N factore";
+		case DTP51_STRIP_DOESNT_EXIST:
+			return "Strip doesn't exist";
+		case DTP51_BAD_MIN_MAX_VALUE:
+			return "Bad min/max field value";
+		case DTP51_BAD_SERIAL_NUMBER:
+			return "Bad serial number";
+		default:
+			return "Unknown error code";
+	}
+}
+
+
+/* Convert a machine specific error code into an abstract dtp code */
+static inst_code 
+dtp51_interp_code(inst *pp, int ec) {
+//	dtp51 *p = (dtp51 *)pp;
+
+	ec &= inst_imask;
+	switch (ec) {
+
+		case DTP51_OK:
+			return inst_ok;
+
+		case DTP51_INTERNAL_ERROR:
+			return inst_internal_error | ec;
+
+		case DTP51_COMS_FAIL:
+			return inst_coms_fail | ec;
+
+		case DTP51_UNKNOWN_MODEL:
+			return inst_unknown_model | ec;
+
+		case DTP51_DATA_PARSE_ERROR:
+			return inst_protocol_error | ec;
+
+		case DTP51_NO_DATA_AVAILABLE:
+		case DTP51_LAMP_MARGINAL:
+		case DTP51_LAMP_FAILURE:
+		case DTP51_STRIP_RESTRAINED:
+		case DTP51_MOTOR_ERROR:
+		case DTP51_INVALID_READING:
+		case DTP51_WRONG_COLOR:
+		case DTP51_BATTERY_TOO_LOW:
+		case DTP51_COMP_TABLE_MISMATCH:
+		case DTP51_BAD_COMP_TABLE:
+		case DTP51_NO_VALID_DATA:
+		case DTP51_BAD_PATCH:
+			return inst_misread | ec;
+
+		case DTP51_NEEDS_CALIBRATION:
+			return inst_needs_cal | ec;
+	}
+	return inst_other_error | ec;
+}
+
+/* Destroy ourselves */
+static void
+dtp51_del(inst *pp) {
+	dtp51 *p = (dtp51 *)pp;
+	if (p->icom != NULL)
+		p->icom->del(p->icom);
+	free(p);
+}
+
+/* Return the instrument mode capabilities */
+void dtp51_capabilities(inst *pp,
+inst_mode *pcap1,
+inst2_capability *pcap2,
+inst3_capability *pcap3) {
+	inst_mode cap1= 0;
+	inst2_capability cap2 = 0;
+
+	cap1 |= inst_mode_ref_strip
+	     |  inst_mode_colorimeter
+	        ;
+
+	cap2 |= inst2_switch_trig	/* Can only be triggered by microswitch */
+	        ;
+
+	if (pcap1 != NULL)
+		*pcap1 = cap1;
+	if (pcap2 != NULL)
+		*pcap2 = cap2;
+	if (pcap3 != NULL)
+		*pcap3 = inst3_none;
+}
+
+/* Check device measurement mode */
+inst_code dtp51_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 reflection strip measurement mode suported */
+	if (!IMODETST(m, inst_mode_ref_strip)) {
+		return inst_unsupported;
+	}
+
+	return inst_ok;
+}
+
+/* Set device measurement mode */
+inst_code dtp51_set_mode(inst *pp, inst_mode m) {
+	inst_code ev;
+
+	if ((ev = dtp51_check_mode(pp, m)) != inst_ok)
+		return ev;
+
+	return inst_ok;
+}
+
+/* !! It's not clear if there is a way of knowing */
+/* whether the instrument has a UV filter. */
+
+/* 
+ * set or reset an optional mode
+ *
+ * Since there is no interaction with the instrument,
+ * was assume that all of these can be done before initialisation.
+ */
+static inst_code
+dtp51_get_set_opt(inst *pp, inst_opt_type m, ...)
+{
+	dtp51 *p = (dtp51 *)pp;
+	static char buf[MAX_MES_SIZE];
+
+	/* Record the trigger mode */
+	if (m == inst_opt_trig_switch) {	/* Can only be triggered this way */
+		p->trig = m;
+		return inst_ok;
+	}
+
+	return inst_unsupported;
+}
+
+/* Constructor */
+extern dtp51 *new_dtp51(icoms *icom, instType itype) {
+	dtp51 *p;
+	if ((p = (dtp51 *)calloc(sizeof(dtp51),1)) == NULL) {
+		a1loge(icom->log, 1, "new_dtp51: malloc failed!\n");
+		return NULL;
+	}
+
+	p->log = new_a1log_d(icom->log);
+
+	p->init_coms    	= dtp51_init_coms;
+	p->init_inst    	= dtp51_init_inst;
+	p->capabilities 	= dtp51_capabilities;
+	p->check_mode       = dtp51_check_mode;
+	p->set_mode     	= dtp51_set_mode;
+	p->get_set_opt      = dtp51_get_set_opt;
+	p->read_strip   	= dtp51_read_strip;
+	p->get_n_a_cals     = dtp51_get_n_a_cals;
+	p->calibrate    	= dtp51_calibrate;
+	p->interp_error 	= dtp51_interp_error;
+	p->del          	= dtp51_del;
+
+	p->icom = icom;
+	p->itype = icom->itype;
+
+	return p;
+}