← Back to branch summary

~ubuntu-branches/ubuntu/saucy/argyll/saucy

« back to all changes in this revision

Viewing changes to spectro/munki.c

  • Committer: Package Import Robot
  • Author(s): Christian Marillat
  • Date: 2012-04-25 07:46:07 UTC
  • mfrom: (1.2.2) (13.1.15 sid)
  • Revision ID: package-import@ubuntu.com-20120425074607-yjqadetw8kum9skc
Tags: 1.4.0-4
http://bugs.debian.org/670329
Should Build-Depends on libusb-dev (Closes: #670329).

Show diffs side-by-side

added added

removed removed

Lines of Context:
spectro/munki.c
45
45
#include "copyright.h"
46
46
#include "aconfig.h"
47
47
#include "numlib.h"
48
 
#endif  /* !SALONEINSTLIB */
 
48
#else /* SALONEINSTLIB */
 
49
#include "sa_config.h"
 
50
#include "numsup.h"
 
51
#endif /* SALONEINSTLIB */
49
52
#include "xspect.h"
50
53
#include "insttypes.h"
51
54
#include "icoms.h"
75
78
static inst_code
76
79
munki_init_coms(inst *pp, int port, baud_rate br, flow_control fc, double tout) {
77
80
        munki *p = (munki *) pp;
78
 
        char buf[16];
79
 
        int rsize;
80
 
        long etime;
81
 
        int bi, i, rv;
82
 
        inst_code ev = inst_ok;
83
81
        icomuflags usbflags = icomuf_none;
84
82
#ifdef __APPLE__
85
83
        /* If the ColorMunki software has been installed, then there will */
119
117
        return inst_ok;
120
118
}
121
119
 
122
 
/* Initialise the MUNKI */
123
 
/* return non-zero on an error, with dtp error code */
124
120
static inst_code
125
 
munki_init_inst(inst *pp) {
126
 
        munki *p = (munki *)pp;
127
 
        munki_code ev = MUNKI_OK;
128
 
 
129
 
        if (p->debug) fprintf(stderr,"munki: About to init instrument\n");
130
 
 
131
 
        if (p->gotcoms == 0)
132
 
                return munki_interp_code(p, MUNKI_INT_NO_COMS); /* Must establish coms before calling init */
133
 
        if ((ev = munki_imp_init(p)) != MUNKI_OK) {
134
 
                if (p->debug) fprintf(stderr,"munki_imp_init() failed\n");
135
 
                return munki_interp_code(p, ev);
136
 
        }
 
121
munki_discover_capabilities(munki *p) {
137
122
 
138
123
        /* Set the Munki capabilities mask */
139
124
        p->cap |= inst_ref_spot
165
150
                        | inst2_has_sensmode
166
151
                ;
167
152
 
168
 
        if (munki_imp_highres(p))
 
153
        if (munki_imp_highres(p))               /* Static */
169
154
                p->cap |= inst_highres;
170
155
 
 
156
        return inst_ok;
 
157
}
 
158
 
 
159
/* Initialise the MUNKI */
 
160
/* return non-zero on an error, with dtp error code */
 
161
static inst_code
 
162
munki_init_inst(inst *pp) {
 
163
        munki *p = (munki *)pp;
 
164
        munki_code ev = MUNKI_OK;
 
165
 
 
166
        if (p->debug) fprintf(stderr,"munki: About to init instrument\n");
 
167
 
 
168
        if (p->gotcoms == 0)
 
169
                return munki_interp_code(p, MUNKI_INT_NO_COMS); /* Must establish coms before calling init */
 
170
        if ((ev = munki_imp_init(p)) != MUNKI_OK) {
 
171
                if (p->debug) fprintf(stderr,"munki_imp_init() failed\n");
 
172
                return munki_interp_code(p, ev);
 
173
        }
 
174
 
 
175
        p->inited = 1;
 
176
        munki_discover_capabilities(p);
 
177
 
171
178
        return munki_interp_code(p, ev);
172
179
}
173
180
 
174
181
static char *munki_get_serial_no(inst *pp) {
175
182
        munki *p = (munki *)pp;
 
183
 
 
184
        if (!p->gotcoms)
 
185
                return "";
 
186
        if (!p->inited)
 
187
                return "";
 
188
 
176
189
        return munki_imp_get_serial_no(p);
177
190
}
178
191
 
192
205
        munki *p = (munki *)pp;
193
206
        munki_code rv;
194
207
 
 
208
        if (!p->gotcoms)
 
209
                return inst_no_coms;
 
210
        if (!p->inited)
 
211
                return inst_no_init;
 
212
 
195
213
        rv = munki_imp_measure(p, vals, npatch);
196
214
 
197
215
        return munki_interp_code(p, rv);
207
225
        munki *p = (munki *)pp;
208
226
        munki_code rv;
209
227
 
 
228
        if (!p->gotcoms)
 
229
                return inst_no_coms;
 
230
        if (!p->inited)
 
231
                return inst_no_init;
 
232
 
210
233
        rv = munki_imp_measure(p, val, 1);
211
234
 
212
235
        return munki_interp_code(p, rv);
217
240
/* and the first type of calibration needed. */
218
241
inst_cal_type munki_needs_calibration(inst *pp) {
219
242
        munki *p = (munki *)pp;
 
243
 
 
244
        if (!p->gotcoms)
 
245
                return inst_no_coms;
 
246
        if (!p->inited)
 
247
                return inst_no_init;
 
248
 
220
249
        return munki_imp_needs_calibration(p);
221
250
}
222
251
 
236
265
        munki *p = (munki *)pp;
237
266
        munki_code rv;
238
267
 
 
268
        if (!p->gotcoms)
 
269
                return inst_no_coms;
 
270
        if (!p->inited)
 
271
                return inst_no_init;
 
272
 
239
273
        rv = munki_imp_calibrate(p, calt, calc, id);
240
274
        return munki_interp_code(p, rv);
241
275
}
504
538
        inst_mode mm;                   /* Request measurement mode */
505
539
        mk_mode mmode = -1;     /* Instrument measurement mode */
506
540
 
 
541
        if (!p->gotcoms)
 
542
                return inst_no_coms;
 
543
        if (!p->inited)
 
544
                return inst_no_init;
 
545
 
507
546
        /* The measurement mode portion of the mode */
508
547
        mm = m & inst_mode_measurement_mask;
509
548
 
557
596
inst_status_type m,     /* Requested status type */
558
597
...) {                          /* Status parameters */                             
559
598
        munki *p = (munki *)pp;
560
 
        inst_code rv = inst_ok;
 
599
 
 
600
        if (!p->gotcoms)
 
601
                return inst_no_coms;
 
602
        if (!p->inited)
 
603
                return inst_no_init;
561
604
 
562
605
        /* Return the sensor mode */
563
606
        if (m == inst_stat_sensmode) {
574
617
 
575
618
                /* Get the device status */
576
619
                ev = munki_getstatus(p, &spos, NULL);
577
 
                if (ev != MUNKI_OK);
 
620
                if (ev != MUNKI_OK)
578
621
                        return munki_interp_code(p, ev);
579
622
 
580
623
                if (spos == mk_spos_proj)
581
624
                        *smode = inst_stat_smode_proj;
582
625
                else if (spos == mk_spos_surf)
583
 
                        *smode = inst_stat_smode_surf;
 
626
                        *smode = inst_stat_smode_ref | inst_stat_smode_disp;
584
627
                else if (spos == mk_spos_calib)
585
628
                        *smode = inst_stat_smode_calib;
586
629
                else if (spos == mk_spos_amb)
591
634
 
592
635
        /* Return the filter */
593
636
        else if (m == inst_stat_get_filter) {
594
 
                munki_code ev;
595
637
                inst_opt_filter *filt;
596
638
                va_list args;
597
639
 
616
658
munki_set_opt_mode(inst *pp, inst_opt_mode m, ...)
617
659
{
618
660
        munki *p = (munki *)pp;
619
 
        char buf[MAX_MES_SIZE];
620
 
        inst_code ev = inst_ok;
621
661
 
622
 
        /* Ignore these modes - not applicable, but be nice. */
623
 
        if (m == inst_opt_disp_crt
624
 
         || m == inst_opt_disp_lcd
625
 
         || m == inst_opt_proj_crt
626
 
         || m == inst_opt_proj_lcd) {
627
 
                return inst_ok;
628
 
        }
 
662
        if (!p->gotcoms)
 
663
                return inst_no_coms;
 
664
        if (!p->inited)
 
665
                return inst_no_init;
629
666
 
630
667
        if (m == inst_opt_noautocalib) {
631
668
                munki_set_noautocalib(p, 1);
772
809
}
773
810
 
774
811
/* Constructor */
775
 
extern munki *new_munki(icoms *icom, int debug, int verb)
 
812
extern munki *new_munki(icoms *icom, instType itype, int debug, int verb)
776
813
{
777
814
        munki *p;
778
815
        if ((p = (munki *)calloc(sizeof(munki),1)) == NULL)
783
820
        else
784
821
                p->icom = icom;
785
822
 
 
823
        /* Preliminary capabilities */
 
824
        munki_discover_capabilities(p);
786
825
        p->debug = debug;
787
826
        p->verb = verb;
788
827
 
794
833
        /* Inst methods */
795
834
        p->init_coms         = munki_init_coms;
796
835
        p->init_inst         = munki_init_inst;
797
 
        p->get_serial_no     = munki_get_serial_no;
798
836
        p->capabilities      = munki_capabilities;
799
837
        p->capabilities2     = munki_capabilities2;
 
838
        p->get_serial_no     = munki_get_serial_no;
800
839
        p->set_mode          = munki_set_mode;
801
840
        p->get_status        = munki_get_status;
802
841
        p->set_opt_mode      = munki_set_opt_mode;
807
846
        p->interp_error      = munki_interp_error;
808
847
        p->del               = munki_del;
809
848
 
810
 
        p->itype = instUnknown;         /* Until initalisation */
 
849
        p->itype = itype;
811
850
 
812
851
        return p;
813
852
}