source: multiio/pcmmio/original/mio_io.c @ 2bae2aa

basewinsystems
Last change on this file since 2bae2aa was 2bae2aa, checked in by Joel Sherrill <joel.sherrill@…>, on 06/08/09 at 14:52:43

Initial import.

  • Property mode set to 100644
File size: 40.8 KB
Line 
1/* mio_io.c WinSystems support module file for the  PCM-MIO Linux driver */
2/*
3*  $Header$
4*
5*  $Id$
6*
7*  $Log$
8*
9*  This file implements all of the supported 'C' language functions. Where necessary
10*  ioctl call are made into the kernel driver to access the actual hardware.
11*/
12
13#define LIB_DEFINED
14
15/* #define DEBUG 1 */
16
17#include "mio_io.h"   
18
19#include <stdio.h>
20#include <fcntl.h>      /* open */
21#include <unistd.h>     /* exit */
22#include <sys/ioctl.h>  /* ioctl */
23
24/* These image variable help out where a register is not
25   capable of a read/modify/write operation
26*/
27
28unsigned char dio_port_images[8];
29unsigned char adc1_port_image =0;
30unsigned char adc2_port_image =0;
31unsigned char dac1_port_image =0;
32unsigned char dac2_port_image =0;
33
34
35/* The channel selects on the ADC are non contigous. In order to avoid shifting and such
36   with each channel select, we simple bild an array for selection.
37*/
38
39unsigned char adc_channel_select[16] = {ADC_CH0_SELECT, ADC_CH1_SELECT, ADC_CH2_SELECT,
40        ADC_CH3_SELECT, ADC_CH4_SELECT, ADC_CH5_SELECT, ADC_CH6_SELECT, ADC_CH7_SELECT,
41        ADC_CH0_SELECT, ADC_CH1_SELECT, ADC_CH2_SELECT, ADC_CH3_SELECT, ADC_CH4_SELECT,
42        ADC_CH5_SELECT, ADC_CH6_SELECT, ADC_CH7_SELECT };
43
44/* Mode selection can also be time consuming and we'd also like the mode to "Stick" from
45   call to call. This array will eventually hold the actual command byte to send to the
46   ADC controller for each channel according to the mode set with adc_set_channel_mode
47*/
48
49unsigned char adc_channel_mode[16] = {ADC_CH0_SELECT, ADC_CH1_SELECT, ADC_CH2_SELECT,
50        ADC_CH3_SELECT, ADC_CH4_SELECT, ADC_CH5_SELECT, ADC_CH6_SELECT, ADC_CH7_SELECT,
51        ADC_CH0_SELECT, ADC_CH1_SELECT, ADC_CH2_SELECT, ADC_CH3_SELECT, ADC_CH4_SELECT,
52        ADC_CH5_SELECT, ADC_CH6_SELECT, ADC_CH7_SELECT };
53
54
55/* This array and the index value are used internally for the adc_convert_all_channels
56  and for the adc_buffered_conversion routines.
57*/
58unsigned char adc_channel_buff[18] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,15,0xff,0xff};
59unsigned char *adc_input_buffer;
60unsigned short *adc_user_buffer;
61
62/* Becaues of the nature of the ADC beast. It's necessary to keep track of the last
63  channel and the previous channel in order to retrieve the data amd know who it belongs to
64*/
65
66int adc_last_channel, adc_current_channel;
67
68/* Various index pointers for the above arrays and misc globals */
69
70int adc_ch_index =0;
71int adc_out_index=0;
72int adc_repeat_channel;
73int adc_repeat_count;
74
75
76
77
78
79/**************************************************************************
80*
81*               USER LIBRARY FUNCTIONS
82*
83***************************************************************************
84*/
85
86int handle = 0;
87char *device_id ="pcmmio";
88char *dev_id    = "/dev/pcmmio";
89
90///////////////////////////////////////////////////////////////////////////////
91//
92//              DISABLE_DIO_INTERRUPT
93//
94//////////////////////////////////////////////////////////////////////////////
95
96int disable_dio_interrupt(void)
97{
98        mio_error_code = MIO_SUCCESS;
99
100    if(check_handle())   /* Check for chip available */
101                return -1;
102
103        adc1_port_image = adc1_port_image | 0x10;
104        mio_write_reg(0x03, adc1_port_image);   // Access the int enable register
105        mio_write_reg(0x02, 0);
106        adc1_port_image = adc1_port_image & 0xef;
107        mio_write_reg(0x03,adc1_port_image );   // Disable the interrupt
108       
109        return(0);
110}
111
112
113///////////////////////////////////////////////////////////////////////////////
114//
115//              ENABLE_DIO_INTERRUPT
116//
117//////////////////////////////////////////////////////////////////////////////
118
119int enable_dio_interrupt(void)
120{
121unsigned char vector;
122
123        mio_error_code = MIO_SUCCESS;
124
125        if(check_handle())   /* Check for chip available */
126                return -1;
127
128        /* We read the assign IRQ from the driver, so we can program the hardware to
129           match,  but only if an aaplication desires such.
130    */
131
132        vector = mio_read_irq_assigned();
133
134        if(vector == 0)
135        {
136                mio_error_code = MIO_MISSING_IRQ;
137                sprintf(mio_error_string,"MIO(DIO) : enable_dio_interrupt - No IRQ assigned");
138                return(1);
139        }
140
141        adc1_port_image = adc1_port_image | 0x10;
142        mio_write_reg(0x03, adc1_port_image);   // Access the int enable register
143        mio_write_reg(0x02, vector);
144        adc1_port_image = adc1_port_image & 0xef;
145        mio_write_reg(0x03, adc1_port_image);   // Enable the interrupt
146
147        return(0);
148}
149
150
151///////////////////////////////////////////////////////////////////////////////
152//
153//              DISABLE_DAC_INTERRUPT
154//
155//////////////////////////////////////////////////////////////////////////////
156
157int disable_dac_interrupt(int dac_num)
158{
159        mio_error_code = MIO_SUCCESS;
160
161        if(check_handle())   /* Check for chip available */
162                return -1;
163
164        if(dac_num)
165        {
166                dac2_port_image = dac2_port_image & 0xfe;
167                dac2_port_image = dac2_port_image | 0x08;
168                mio_write_reg(0x0f, dac2_port_image);   // Access the int enable register
169                mio_write_reg(0x0e, 0);
170                dac2_port_image = dac2_port_image & 0xf7;
171                mio_write_reg(0x0f, dac2_port_image);   // Disable the interrupt
172        }
173        else
174        {
175                dac1_port_image = dac1_port_image & 0xfe;
176                dac1_port_image = dac1_port_image | 0x08;
177                mio_write_reg(0x0b, dac1_port_image);   // Access the int enable register
178       
179                mio_write_reg(0x0a, 0);
180
181                dac1_port_image = dac1_port_image & 0xf7;
182                mio_write_reg(0x0b, dac1_port_image);   // Disable the interrupt
183        }
184        return(0);
185}
186
187///////////////////////////////////////////////////////////////////////////////
188//
189//              ENABLE_DAC_INTERRUPT
190//
191//////////////////////////////////////////////////////////////////////////////
192
193int enable_dac_interrupt(int dac_num)
194{
195unsigned char vector;
196
197
198        mio_error_code = MIO_SUCCESS;
199
200        if(check_handle())   /* Check for chip available */
201                return -1;
202
203        /* We read the assign IRQ from the driver, so we can program the hardware to
204           match,  but only if an aaplication desires such.
205    */
206
207        vector = mio_read_irq_assigned();
208
209        if(vector == 0)
210        {
211                mio_error_code = MIO_MISSING_IRQ;
212                sprintf(mio_error_string,"MIO(DAC) : enable_dac_interrupt - No IRQ assigned");
213                return(1);
214        }
215
216
217        if(dac_num)
218        {
219                dac2_port_image = dac2_port_image & 0xfe;
220                dac2_port_image = dac2_port_image | 0x08;
221                mio_write_reg(0x0f, dac2_port_image);   // Access the int enable register
222
223                mio_write_reg(0x0e, vector);
224
225                dac2_port_image = dac2_port_image & 0xf7;
226                dac2_port_image = dac2_port_image | 0x01;
227                mio_write_reg(0x0f, dac2_port_image);   // Enable the interrupt
228        }
229        else
230        {
231                dac1_port_image = dac1_port_image & 0xfe;
232                dac1_port_image = dac1_port_image | 0x08;
233                mio_write_reg(0x0b, dac1_port_image);   // Access the int enable register
234
235                mio_write_reg(0x0a, vector);
236
237                dac1_port_image = dac1_port_image & 0xf7;
238                dac1_port_image = dac1_port_image | 0x01;
239                mio_write_reg(0x0b, dac1_port_image);   // Enable the interrupt
240        }
241        return(0);
242}
243
244
245
246///////////////////////////////////////////////////////////////////////////////
247//
248//              DISABLE_ADC_INTERRUPT
249//
250//////////////////////////////////////////////////////////////////////////////
251
252int disable_adc_interrupt(int adc_num)
253{
254
255        mio_error_code = MIO_SUCCESS;
256
257        if(check_handle())   /* Check for chip available */
258                return -1;
259
260        if(adc_num)
261        {
262                adc2_port_image = adc2_port_image & 0xfe;
263                adc2_port_image = adc2_port_image | 0x08;
264                mio_write_reg(0x07, adc2_port_image);   // Access the int enable register
265
266                mio_write_reg(0x06, 0);
267
268                adc2_port_image = adc2_port_image & 0xf7;
269                mio_write_reg(0x07, adc2_port_image);   // Disable the interrupt
270        }
271        else
272        {
273                adc1_port_image = adc1_port_image & 0xfe;
274                adc1_port_image = adc1_port_image | 0x08;
275                mio_write_reg(0x03, adc1_port_image);   // Access the int enable register
276
277                mio_write_reg(0x02, 0);
278
279                adc1_port_image = adc1_port_image & 0xf7;
280                mio_write_reg(0x03, adc1_port_image);   // Disable the interrupt
281        }
282        return(0);
283}
284
285
286///////////////////////////////////////////////////////////////////////////////
287//
288//              ENABLE_ADC_INTERRUPT
289//
290//////////////////////////////////////////////////////////////////////////////
291
292int enable_adc_interrupt(int adc_num)
293{
294unsigned char vector;
295
296
297        mio_error_code = MIO_SUCCESS;
298
299        if(check_handle())   /* Check for chip available */
300                return -1;
301
302        /* We read the assign IRQ from the driver, so we can program the hardware to
303           match,  but only if an aaplication desires such.
304    */
305
306        vector = mio_read_irq_assigned();
307
308        if(vector == 0)
309        {
310                mio_error_code = MIO_MISSING_IRQ;
311                sprintf(mio_error_string,"MIO(ADC) : enable_adc_interrupt - No IRQ assigned");
312
313                return(1);
314        }
315
316        if(adc_num)
317        {
318                adc2_port_image = adc2_port_image & 0xfe;
319                adc2_port_image = adc2_port_image | 0x08;
320                mio_write_reg(0x07, adc2_port_image);   // Access the int enable register
321
322                mio_write_reg(0x06, vector);
323
324                adc2_port_image = adc2_port_image & 0xf7;
325                adc2_port_image = adc2_port_image | 0x01;
326                mio_write_reg(0x07, adc2_port_image);   // Enable the interrupt
327        }
328        else
329        {
330                adc1_port_image = adc1_port_image & 0xfe;
331                adc1_port_image = adc1_port_image | 0x08;
332                mio_write_reg(0x03, adc1_port_image);   // Access the int enable register
333
334                mio_write_reg(0x02, vector);
335
336                adc1_port_image = adc1_port_image & 0xf7;
337                adc1_port_image = adc1_port_image | 0x01;
338                mio_write_reg(0x03, adc1_port_image);   // Enable the interrupt
339        }
340        return(0);
341}
342
343
344///////////////////////////////////////////////////////////////////////////////
345//
346//              MIO_READ_IRQ_ASSIGNED
347//
348//////////////////////////////////////////////////////////////////////////////
349
350int mio_read_irq_assigned(void)
351{
352unsigned char val;
353
354        mio_error_code = MIO_SUCCESS;
355
356        if(check_handle())   /* Check for chip available */
357                return -1;
358
359
360        /* All of our programming of the hardware is handled at this level so that
361           all of the routines that need to shove and IRQ value into hardware will
362           use this call.
363   */
364
365    val = ioctl(handle,READ_IRQ_ASSIGNED,NULL);
366
367        return val & 0xff;
368}
369
370
371///////////////////////////////////////////////////////////////////////////////
372//
373//              SET_DAC_SPAN
374//
375//////////////////////////////////////////////////////////////////////////////
376
377int set_dac_span(int channel, unsigned char span_value)
378{
379unsigned char select_val;
380
381        mio_error_code = MIO_SUCCESS;
382
383        if(check_handle())   /* Check for chip available */
384                return -1;
385
386        if((channel < 0) || (channel > 7))
387        {
388                mio_error_code = MIO_BAD_CHANNEL_NUMBER;
389                sprintf(mio_error_string,"MIO(DAC) : Set_dac_span - bad channel number %d",channel);
390                return(1);
391        }
392
393
394        /* This function sets up the output range for the DAC channel */
395
396        select_val = (channel % 4) << 1;
397
398        write_dac_data(channel / 4, span_value);
399        if(mio_error_code)
400                return 1;
401
402        write_dac_command(channel / 4, 0x60 | select_val);
403        if(mio_error_code)
404                return(1);
405
406        if(wait_dac_ready(channel))
407                return 1;
408
409        return 0;
410}
411
412///////////////////////////////////////////////////////////////////////////////
413//
414//              WAIT_DAC_READY
415//
416//////////////////////////////////////////////////////////////////////////////
417
418int wait_dac_ready(int channel)
419{
420unsigned long retry;
421
422        retry = 100000L;
423
424        /* This may seem like an absurd way to handle waiting and violates the
425        "no busy waiting" policy. The fact is that the hardware is normally so fast that we
426        usually only need one time through the loop anyway. The longer timeout is for rare
427        occasions and for detecting non-existant hardware.
428        */
429
430        while(retry--)
431        {
432                if(dac_read_status(channel / 4) & DAC_BUSY)
433                        return 0;
434
435        }
436        return 1;
437
438}
439
440
441///////////////////////////////////////////////////////////////////////////////
442//
443//              SET_DAC_OUTPUT
444//
445//////////////////////////////////////////////////////////////////////////////
446
447int set_dac_output(int channel, unsigned short dac_value)
448{
449unsigned char select_val;
450
451        mio_error_code = MIO_SUCCESS;
452
453        if(check_handle())   /* Check for chip available */
454                return -1;
455
456        select_val = (channel % 4) << 1;
457        write_dac_data(channel / 4, dac_value);
458        if(mio_error_code)
459                return(1);
460        write_dac_command(channel / 4, 0x70 | select_val);
461        if(mio_error_code)
462                return(1);
463
464        if(wait_dac_ready(channel))
465                return 1;
466
467        return 0;
468}
469
470///////////////////////////////////////////////////////////////////////////////
471//
472//              SET_DAC_VOLTAGE
473//
474//////////////////////////////////////////////////////////////////////////////
475
476int set_dac_voltage(int channel, float voltage)
477{
478unsigned short  value;
479float bit_val;
480
481        mio_error_code = MIO_SUCCESS;
482
483        if(check_handle())   /* Check for chip available */
484                return -1;
485
486        /* This output function is auto-ranging in that it picks the span that will
487        give the most precision for the voltage specified. This has one side-effect that
488        may be objectionable to some applications. When call to set_dac_span completes the
489        new range is set and the output will respond immediately using whatever value was last
490        in the output registers. This may cause a spike (up or down) in the DAC output until the
491        new output value is sent to the controller.
492        */
493
494        if((voltage < -10.0) || (voltage > 10.0))
495        {
496                mio_error_code = MIO_ILLEGAL_VOLTAGE;
497                sprintf(mio_error_string,"MIO(DAC) :Set DAC Voltage - Illegal Voltage %9.5f",voltage);
498                return 1;
499        }
500
501        if((voltage >= 0.0) && (voltage < 5.0))
502        {
503                set_dac_span(channel,DAC_SPAN_UNI5);
504                if(mio_error_code)
505                        return(1);
506                bit_val = 5.0 / 65536;
507                value = (unsigned short) (voltage / bit_val);
508        }
509
510        if(voltage >= 5.0)
511        {
512                set_dac_span(channel,DAC_SPAN_UNI10);
513                if(mio_error_code)
514                        return(1);
515                bit_val = 10.0 / 65536;
516                value = (unsigned short) (voltage / bit_val);
517        }
518
519        if((voltage < 0.0) && (voltage > -5.0))
520        {
521                set_dac_span(channel, DAC_SPAN_BI5);
522                if(mio_error_code)
523                        return(1);
524                bit_val = 10.0 / 65536;
525                value = (unsigned short) ((voltage + 5.0) / bit_val);
526        }
527
528        if(voltage <= -5.0)
529        {
530                set_dac_span(channel, DAC_SPAN_BI10);
531                if(mio_error_code)
532                        return(1);
533                bit_val = 20.0 / 65536;
534                value  = (unsigned short) ((voltage + 10.0) / bit_val);
535        }
536
537        if(wait_dac_ready(channel))
538                return 1;
539
540        set_dac_output(channel,value);
541        if(mio_error_code)
542                return(1);
543
544        return 0;
545}
546
547///////////////////////////////////////////////////////////////////////////////
548//
549//              READ_DIO_BYTE
550//
551//////////////////////////////////////////////////////////////////////////////
552
553unsigned char read_dio_byte(int offset)
554{
555int val;
556
557        mio_error_code = MIO_SUCCESS;
558
559        if(check_handle())   /* Check for chip available */
560                return -1;
561
562        /* All bit operations are handled at this level so we need only
563        read and write bytes from the actual hardware using the driver
564        to handle our ioctl call for it.
565        */
566
567    val = ioctl(handle,READ_DIO_BYTE,offset);
568
569        return (unsigned char) (val & 0xff);;
570}
571
572///////////////////////////////////////////////////////////////////////////////
573//
574//              MIO_READ_REG
575//
576//////////////////////////////////////////////////////////////////////////////
577
578unsigned char mio_read_reg(int offset)
579{
580int val;
581
582        mio_error_code = MIO_SUCCESS;
583
584        if(check_handle())   /* Check for chip available */
585                return -1;
586
587
588        /* This is a catchall register read routine that allows reading of
589           ANY of the registers on the PCM-MIO. It is used primarily for
590           retreiving control and access values in the hardware.
591   */
592
593     val = ioctl(handle,MIO_READ_REG,offset);
594
595        return (unsigned char) (val & 0xff);
596}
597
598///////////////////////////////////////////////////////////////////////////////
599//
600//              MIO_WRITE_REG
601//
602//////////////////////////////////////////////////////////////////////////////
603
604int mio_write_reg(int offset, unsigned char value)
605{
606unsigned short param;
607int val;
608
609        mio_error_code = MIO_SUCCESS;
610
611        if(check_handle())   /* Check for chip available */
612                return -1;
613
614        param = offset & 0xff;
615
616        param = param | (value << 8);
617   
618        /* This function like the previous allow unlimited
619           write access to ALL of the registers on the PCM-MIO
620   */
621
622        val = ioctl(handle,MIO_WRITE_REG,param);
623       
624        return 0;
625}
626
627
628///////////////////////////////////////////////////////////////////////////////
629//
630//              WRITE_DIO_BYTE
631//
632//////////////////////////////////////////////////////////////////////////////
633
634int write_dio_byte(int offset, unsigned char value)
635{
636unsigned short param;
637int val;
638
639        mio_error_code = MIO_SUCCESS;
640
641        if(check_handle())   /* Check for chip available */
642                return -1;
643
644        param = offset & 0xff;
645
646        param = param | (value << 8);
647   
648        /* All bit operations for the DIO are handled at this level
649           and we need the driver to allow access to the actual
650           DIO registers to update the value.
651    */
652
653        val = ioctl(handle,WRITE_DIO_BYTE,param);
654       
655        return 0;
656}
657
658
659///////////////////////////////////////////////////////////////////////////////
660//
661//              WRITE_DAC_COMMAND
662//
663//////////////////////////////////////////////////////////////////////////////
664
665int write_dac_command(int dac_num,unsigned char value)
666{
667unsigned short param;
668int val;
669
670        mio_error_code = MIO_SUCCESS;
671
672        if(check_handle())   /* Check for chip available */
673                return -1;
674
675        param = dac_num & 0xff;
676
677        param = param | (value << 8);
678
679        val = ioctl(handle,WRITE_DAC_COMMAND,param);
680
681        return 0;
682}
683
684
685///////////////////////////////////////////////////////////////////////////////
686//
687//              ADC_START_CONVERSION
688//
689//////////////////////////////////////////////////////////////////////////////
690
691int adc_start_conversion(int channel)
692{
693        mio_error_code = MIO_SUCCESS;
694
695        if((channel <0) || (channel > 15))
696        {
697                mio_error_code = MIO_BAD_CHANNEL_NUMBER;
698                sprintf(mio_error_string,"MIO(ADC) : Start conversion bad channel number %d",channel);
699                return(1);
700        }
701
702        adc_last_channel = adc_current_channel;
703        adc_current_channel = channel;
704
705        write_adc_command(channel / 8,adc_channel_mode[channel]);
706       
707        if(mio_error_code)
708                return(1);
709
710        return 0;
711}
712
713///////////////////////////////////////////////////////////////////////////////
714//
715//              ADC_GET_CHANNEL_VOLTAGE
716//
717//////////////////////////////////////////////////////////////////////////////
718
719float adc_get_channel_voltage(int channel)
720{
721unsigned short value;
722float result;
723
724        mio_error_code = MIO_SUCCESS;
725
726        // Start two conversions so that we can have current data
727
728        adc_start_conversion(channel);
729        if(mio_error_code)
730                return(0.0);
731
732        adc_wait_ready(channel);
733        if(mio_error_code)
734                return(0.0);
735
736        adc_start_conversion(channel);
737        if(mio_error_code)
738                return(0.0);
739
740        adc_wait_ready(channel);
741        if(mio_error_code)
742                return(0.0);
743
744        // Read out the conversion's raw data
745
746        value = adc_read_conversion_data(channel);
747        if(mio_error_code)
748                return(0.0);
749
750        // Convert the raw data to a voltage
751
752        value = value + adc_adjust[channel];
753        result = value * adc_bitval[channel];
754        result = result + adc_offset[channel];
755
756        return(result);
757}
758
759///////////////////////////////////////////////////////////////////////////////
760//
761//              ADC_CONVERT_ALL_CHANNELS
762//
763//////////////////////////////////////////////////////////////////////////////
764
765int adc_convert_all_channels(unsigned short *buffer)
766{
767int x;
768
769        mio_error_code = MIO_SUCCESS;
770
771        if(check_handle())   /* Check for chip available */
772                return -1;
773
774        // Initialize global variables including transferinng the
775        // address of the user's ouput buffer to an internal buffer pointer
776
777        adc_user_buffer = buffer;
778        adc_input_buffer = adc_channel_buff;
779        adc_ch_index =0;
780        adc_out_index = 0;
781
782        adc_start_conversion(0);
783        if(mio_error_code)
784                return(1);
785
786        adc_wait_ready(0);
787        if(mio_error_code)
788                return(1);
789
790        // This is old data throw it out
791
792        adc_read_conversion_data(0);
793        if(mio_error_code)
794                return(1);
795
796        // Finish the rest of the channels
797
798        for(x=1; x<8; x++)
799        {
800                adc_start_conversion(x);
801                if(mio_error_code)
802                        return(1);
803
804                adc_wait_ready(x);
805                if(mio_error_code)
806                        return(1);
807
808                // Store the results in the user's buffer
809
810                adc_user_buffer[adc_out_index++] = adc_read_conversion_data(x);
811                if(mio_error_code)
812                        return(1);
813        }
814
815        // A final dummy conversion is required to get out the last data
816
817        adc_start_conversion(7);
818        if(mio_error_code)
819                return(1);
820
821        adc_wait_ready(7);
822        if(mio_error_code)
823                return(1);
824
825        adc_user_buffer[adc_out_index++] = adc_read_conversion_data(7);
826        if(mio_error_code)
827                return(1);
828
829        // Now start on the second controller
830
831        adc_start_conversion(8);
832        if(mio_error_code)
833                return(1);
834
835        adc_wait_ready(8);
836        if(mio_error_code)
837                return(1);
838
839        // This data is old - Throw it out
840
841        adc_read_conversion_data(8);
842        if(mio_error_code)
843                return(1);
844
845        for(x=9; x<16; x++)
846        {
847                adc_start_conversion(x);
848                if(mio_error_code)
849                        return(1);
850
851                adc_wait_ready(x);
852                if(mio_error_code)
853                        return(1);
854
855                adc_user_buffer[adc_out_index++] = adc_read_conversion_data(x);
856                if(mio_error_code)
857                        return(1);
858        }
859
860        // A final dummy conversion is required to get the last data
861
862        adc_start_conversion(15);
863        if(mio_error_code)
864                return(1);
865
866        adc_wait_ready(15);
867        if(mio_error_code)
868                return(1);
869
870        adc_user_buffer[adc_out_index++] = adc_read_conversion_data(15);
871        if(mio_error_code)
872                return(1);
873
874        return 0;
875}
876
877///////////////////////////////////////////////////////////////////////////////
878//
879//              ADC_CONVERT_TO_VOLTS
880//
881//////////////////////////////////////////////////////////////////////////////
882
883float adc_convert_to_volts(int channel, unsigned short value)
884{
885float result;
886
887                if((channel < 0) || (channel > 15))
888                        return(0.0);
889
890                value = value + adc_adjust[channel];
891                result = value * adc_bitval[channel];
892                result = result + adc_offset[channel];
893                return result;
894}
895
896
897///////////////////////////////////////////////////////////////////////////////
898//
899//              ADC_CONVERT_SINGLE_REPEATED
900//
901//////////////////////////////////////////////////////////////////////////////
902
903int adc_convert_single_repeated(int channel, unsigned short count, unsigned short *buffer)
904{
905        int x;
906
907        mio_error_code = MIO_SUCCESS;
908
909        if(check_handle())   /* Check for chip available */
910                return -1;
911
912        // Setup global variables including transferring the address of the
913        // user's output buffer to a global variable the ISR knows about.
914
915        adc_user_buffer = buffer;
916        adc_out_index = 0;
917        adc_repeat_channel = channel;
918        adc_repeat_count = count;
919
920        adc_start_conversion(adc_repeat_channel);
921        if(mio_error_code)
922                return(1);
923
924        adc_wait_ready(adc_repeat_channel);
925        if(mio_error_code)
926                return(1);
927
928        // This data is old, we don't want it
929
930        adc_read_conversion_data(adc_repeat_channel);
931        if(mio_error_code)
932                return(1);
933
934        // Perform the requested number of conversions. Place the results into
935        // the user's buffer.
936
937        for(x=0; x<=adc_repeat_count; x++)
938        {
939                adc_start_conversion(adc_repeat_channel);
940                if(mio_error_code)
941                        return(1);
942
943                adc_wait_ready(adc_repeat_channel);
944                if(mio_error_code)
945                        return(1);
946
947                adc_user_buffer[adc_out_index++] = adc_read_conversion_data(adc_repeat_channel);
948                if(mio_error_code)
949                        return(1);
950        }
951
952        // One last dummy conversion to retrieve our last data
953
954        adc_start_conversion(adc_repeat_channel);
955        if(mio_error_code)
956                return(1);
957
958        adc_wait_ready(adc_repeat_channel);
959        if(mio_error_code)
960                return(1);
961
962        adc_user_buffer[adc_out_index++] = adc_read_conversion_data(adc_repeat_channel);
963        if(mio_error_code)
964                return(1);
965
966        return 0;
967}
968
969///////////////////////////////////////////////////////////////////////////////
970//
971//              ADC_BUFFERED_CHANNEL_CONVERSIONS
972//
973//////////////////////////////////////////////////////////////////////////////
974
975int adc_buffered_channel_conversions(unsigned char *input_channel_buffer,unsigned short *buffer)
976{
977int adc_next_channel;
978
979        mio_error_code = MIO_SUCCESS;
980
981        if(check_handle())   /* Check for chip available */
982                return -1;
983
984
985        adc_ch_index = 0;
986        adc_out_index = 0;
987       
988        adc_user_buffer = buffer;
989        adc_input_buffer = input_channel_buffer;
990
991        // Reset all of the array index pointers
992
993        adc_start_conversion(adc_input_buffer[adc_ch_index]);
994
995        if(mio_error_code)
996                return(1);
997
998        adc_wait_ready(adc_input_buffer[adc_ch_index++]);
999
1000        if(mio_error_code)
1001                return(1);
1002
1003        // While there are channel numbers in the buffer (1= 0xff)
1004        // convert the requested channel and place the result in the
1005        // user's output buffer
1006
1007        while(adc_input_buffer[adc_ch_index] != 0xff)
1008        {
1009                adc_next_channel = adc_input_buffer[adc_ch_index];
1010
1011
1012                /* This function is particularly tricky because of the
1013                fact that the data is delayed by one conversion and if
1014                we switch back and forth between the two controllers
1015                we'll need to run an extra conversion in order to get the
1016                last data offering from the previous controller. The
1017                conditional code in the next several lines handles the
1018                switches from one controller to the other.
1019                */
1020
1021                if(adc_current_channel < 8 && adc_next_channel > 7)
1022                {
1023                        adc_start_conversion(adc_current_channel);
1024                        if(mio_error_code)
1025                                return(1);
1026
1027                        adc_wait_ready(adc_current_channel);
1028                        if(mio_error_code)
1029                                return(1);
1030
1031                        adc_user_buffer[adc_out_index++] = adc_read_conversion_data(adc_current_channel);
1032                        if(mio_error_code)
1033                                return(1);
1034
1035                        adc_start_conversion(adc_input_buffer[adc_ch_index]);
1036                        if(mio_error_code)
1037                                return(1);
1038
1039                        adc_wait_ready(adc_input_buffer[adc_ch_index++]);
1040                        if(mio_error_code)
1041                                return(1);
1042                }
1043                else if(adc_current_channel > 7 && adc_next_channel < 8)
1044                {
1045                        adc_start_conversion(adc_current_channel);
1046                        if(mio_error_code)
1047                                return(1);
1048
1049                        adc_wait_ready(adc_current_channel);
1050                        if(mio_error_code)
1051                                return(1);
1052
1053                        adc_user_buffer[adc_out_index++] = adc_read_conversion_data(adc_current_channel);
1054                        if(mio_error_code)
1055                                return(1);
1056
1057                        adc_start_conversion(adc_input_buffer[adc_ch_index]);
1058                        if(mio_error_code)
1059                                return(1);
1060
1061                        adc_wait_ready(adc_input_buffer[adc_ch_index++]);
1062                        if(mio_error_code)
1063                                return(1);
1064                }
1065                adc_start_conversion(adc_input_buffer[adc_ch_index]);
1066                if(mio_error_code)
1067                        return(1);
1068
1069                adc_wait_ready(adc_input_buffer[adc_ch_index++]);
1070                if(mio_error_code)
1071                        return(1);
1072
1073                adc_user_buffer[adc_out_index++] = adc_read_conversion_data(adc_current_channel);
1074                if(mio_error_code)
1075                        return(1);
1076        }
1077
1078        // One last conversion allows us to retrieve our real last data
1079
1080        adc_start_conversion(adc_input_buffer[--adc_ch_index]);
1081        if(mio_error_code)
1082                return(1);
1083        adc_wait_ready(adc_input_buffer[adc_ch_index]);
1084        if(mio_error_code)
1085                return(1);
1086
1087        adc_user_buffer[adc_out_index++] = adc_read_conversion_data(adc_last_channel);
1088        if(mio_error_code)
1089                return(1);
1090
1091        return 0;
1092}
1093
1094///////////////////////////////////////////////////////////////////////////////
1095//
1096//              ADC_WAIT_READY
1097//
1098//////////////////////////////////////////////////////////////////////////////
1099
1100int adc_wait_ready(int channel)
1101{
1102long retry;
1103       
1104        mio_error_code = MIO_SUCCESS;
1105        retry = 100000l;
1106
1107        /* Like with the DAC timeout routine, under normal circumstances we'll
1108        barely make it through the loop one time beacuse the hadrware is plenty
1109        fast. We have the delay for the rare occasion and when the hadrware is not
1110        responding properly.
1111        */
1112
1113        while(retry--)
1114        {
1115                if(adc_read_status(channel / 8) & 0x80)
1116                        return 0;
1117        }
1118
1119        mio_error_code = MIO_TIMEOUT_ERROR;
1120        sprintf(mio_error_string,"MIO(ADC) : Wait ready - Device timeout error");
1121        return(1);
1122}
1123
1124///////////////////////////////////////////////////////////////////////////////
1125//
1126//              WRITE_ADC_COMMAND
1127//
1128//////////////////////////////////////////////////////////////////////////////
1129
1130int write_adc_command(int adc_num,unsigned char value)
1131{
1132unsigned short param;
1133int ret_val;
1134
1135        mio_error_code = MIO_SUCCESS;
1136
1137        if(check_handle())   /* Check for chip available */
1138                return -1;
1139
1140        param = adc_num & 0xff;
1141
1142        param = param | (value << 8);
1143
1144    ret_val = ioctl(handle,WRITE_ADC_COMMAND,param);
1145
1146        return 0;
1147}
1148
1149///////////////////////////////////////////////////////////////////////////////
1150//
1151//              BUFFERED_DAC_OUTPUT
1152//
1153//////////////////////////////////////////////////////////////////////////////
1154
1155int buffered_dac_output(unsigned char *cmd_buff,unsigned short *data_buff)
1156{
1157int x= 0;
1158
1159        mio_error_code = MIO_SUCCESS;
1160
1161        if(check_handle())   /* Check for chip available */
1162                return -1;
1163
1164        while(1)
1165        {
1166                if(cmd_buff[x] == 0xff)
1167                        return 0;
1168
1169                if(set_dac_output(cmd_buff[x], data_buff[x]))
1170                        return 1;
1171
1172                x++;
1173        }
1174}
1175
1176///////////////////////////////////////////////////////////////////////////////
1177//
1178//              WRITE_DAC_DATA
1179//
1180//////////////////////////////////////////////////////////////////////////////
1181
1182int write_dac_data(int dac_num, unsigned short value)
1183{
1184int ret_val;
1185unsigned char buffer[3];
1186
1187        mio_error_code = MIO_SUCCESS;
1188
1189        if(check_handle())   /* Check for chip available */
1190                return -1;
1191
1192        buffer[0] = dac_num;
1193        buffer[1] = value & 0xff;
1194        buffer[2] = value >> 8;
1195
1196    ret_val = ioctl(handle,WRITE_DAC_DATA,buffer);
1197       
1198        return 0;
1199}
1200
1201///////////////////////////////////////////////////////////////////////////////
1202//
1203//              DAC_READ_STATUS
1204//
1205//////////////////////////////////////////////////////////////////////////////
1206
1207unsigned char dac_read_status(int dac_num)
1208{
1209int ret_val;
1210
1211        mio_error_code = MIO_SUCCESS;
1212
1213        if(check_handle())   /* Check for chip available */
1214                return -1;
1215
1216    ret_val = ioctl(handle,READ_DAC_STATUS,dac_num);
1217
1218        return ret_val & 0xff;
1219}
1220
1221///////////////////////////////////////////////////////////////////////////////
1222//
1223//              ADC_READ_STATUS
1224//
1225//////////////////////////////////////////////////////////////////////////////
1226
1227unsigned char adc_read_status(int adc_num)
1228{
1229int ret_val;
1230
1231        mio_error_code = MIO_SUCCESS;
1232
1233        if(check_handle())   /* Check for chip available */
1234                return -1;
1235
1236    ret_val = ioctl(handle,READ_ADC_STATUS,adc_num);
1237
1238        return (ret_val & 0xff);
1239}
1240
1241///////////////////////////////////////////////////////////////////////////////
1242//
1243//              ADC_SET_CHANNEL_MODE
1244//
1245//////////////////////////////////////////////////////////////////////////////
1246
1247int adc_set_channel_mode(int channel, int input_mode,int duplex,int range)
1248{
1249unsigned char command_byte;
1250
1251        mio_error_code = MIO_SUCCESS;
1252
1253        if(channel < 0 || channel > 15)
1254        {
1255                mio_error_code = MIO_BAD_CHANNEL_NUMBER;
1256                sprintf(mio_error_string,"MIO(ADC) : Set Channel Mode - Bad Channel Number %d",channel);
1257                return(1);
1258        }
1259
1260        // Check for illegal modes
1261
1262        if((input_mode != ADC_SINGLE_ENDED) && (input_mode != ADC_DIFFERENTIAL))
1263        {
1264                mio_error_code = MIO_BAD_MODE_NUMBER;
1265                sprintf(mio_error_string,"MIO(ADC) : Set Channel Mode - Bad Mode Number");
1266                return(1);
1267        }
1268
1269        if((duplex != ADC_UNIPOLAR) && (duplex != ADC_BIPOLAR))
1270        {
1271                mio_error_code = MIO_BAD_MODE_NUMBER;
1272                sprintf(mio_error_string,"MIO(ADC) : Set Channel Mode - Bad Mode Number");
1273                return(1);
1274        }
1275
1276        if((range != ADC_TOP_5V) && (range != ADC_TOP_10V))
1277        {
1278                mio_error_code = MIO_BAD_RANGE;
1279                sprintf(mio_error_string,"MIO(ADC) : Set Channel Mode - Bad Range Value");
1280                return(1);
1281        }
1282
1283        command_byte = adc_channel_select[channel];
1284        command_byte = command_byte | input_mode | duplex | range;
1285
1286        /* Building these four arrays at mode set time is critical for speed
1287           as we don't need to calculate anything when we want to start an ADC
1288           conversion. WE simply retrieve the command byte from the array
1289           and send it to the controller.
1290
1291           Likewise, when doing conversion from raw 16-bit values to a voltage
1292           the mode controls the worth of each individual bit as well as binary
1293           bias and offset values.
1294   */
1295
1296        adc_channel_mode[channel] = command_byte;
1297
1298        /* Calculate bit values, offset, and adjustment values */
1299
1300        if((range == ADC_TOP_5V) && (duplex == ADC_UNIPOLAR))
1301        {
1302                adc_bitval[channel] = 5.00 / 65536.0;
1303                adc_adjust[channel] = 0;
1304                adc_offset[channel] = 0.0;
1305        }
1306
1307        if((range == ADC_TOP_5V) && (duplex == ADC_BIPOLAR))
1308        {
1309                adc_bitval[channel] = 10.0 / 65536.0;
1310                adc_adjust[channel] = 0x8000;
1311                adc_offset[channel] = -5.000;
1312        }
1313
1314        if((range == ADC_TOP_10V) && (duplex == ADC_UNIPOLAR))
1315        {
1316                adc_bitval[channel] = 10.0 / 65536.0;
1317                adc_adjust[channel] = 0;
1318                adc_offset[channel] = 0.0;
1319        }
1320
1321        if((range == ADC_TOP_10V) && (duplex == ADC_BIPOLAR))
1322        {
1323                adc_bitval[channel] = 20.0 / 65536.0;
1324                adc_adjust[channel] = 0x8000;
1325                adc_offset[channel] = -10.0;
1326        }
1327
1328        return 0;
1329}
1330
1331///////////////////////////////////////////////////////////////////////////////
1332//
1333//              ADC_READ_CONVERSION_DATA
1334//
1335//////////////////////////////////////////////////////////////////////////////
1336
1337unsigned short adc_read_conversion_data(int channel)
1338{
1339int ret_val;
1340int adc_num;
1341
1342        mio_error_code = MIO_SUCCESS;
1343
1344        if(check_handle())   /* Check for chip available */
1345                return -1;
1346
1347        if(channel > 7)
1348                adc_num = 1;
1349        else
1350                adc_num = 0;
1351
1352    ret_val = ioctl(handle,READ_ADC_DATA,adc_num);
1353       
1354        return (ret_val & 0xffff);
1355}
1356
1357
1358////////////////////////////////////////////////////////////////////////////////
1359//
1360//
1361//              ADC_AUTO_GET_CHANNEL_VOLTAGE
1362//
1363//
1364/////////////////////////////////////////////////////////////////////////////////
1365
1366float adc_auto_get_channel_voltage(int channel)
1367{
1368unsigned short value;
1369float result;
1370
1371        mio_error_code = MIO_SUCCESS;
1372
1373        if(check_handle())   /* Check for chip available */
1374                return -1;
1375
1376        // Start out on a +/-10 Volt scale
1377
1378        adc_set_channel_mode(channel,ADC_SINGLE_ENDED,ADC_BIPOLAR,ADC_TOP_10V);
1379        if(mio_error_code)
1380                return(0.0);
1381
1382        adc_start_conversion(channel);
1383        if(mio_error_code)
1384                return(0.0);
1385
1386        adc_wait_ready(channel);
1387        if(mio_error_code)
1388                return(0.0);
1389
1390        adc_start_conversion(channel);
1391        if(mio_error_code)
1392                return(0.0);
1393
1394        adc_wait_ready(channel);
1395        if(mio_error_code)
1396                return(0.0);
1397
1398        value = adc_read_conversion_data(channel);
1399        if(mio_error_code)
1400                return(0.0);
1401
1402        // Convert the raw data to voltage
1403
1404        value = value + adc_adjust[channel];
1405        result = value * adc_bitval[channel];
1406        result = result + adc_offset[channel];
1407
1408#ifdef DEBUG
1409        printf("auto_get_channel_voltage : Raw = %04x, adjust = %d, bitval = %9.5f, offset = %9.5f,  result = %9.5f\n",
1410                                                value - adc_adjust[channel],adc_adjust[channel],adc_bitval[channel],adc_offset[channel],result);
1411#endif
1412
1413        // If the voltage is less than -5.00 volts, we're as precise as we can get
1414
1415        if(result <= -5.00)
1416                return(result);
1417
1418        // If the result is between -4.99 and 0.0 we can  to the +/- 5V scale.
1419
1420        if(result < 0.0)
1421                adc_set_channel_mode(channel,ADC_SINGLE_ENDED,ADC_BIPOLAR,ADC_TOP_5V);
1422
1423        if(mio_error_code)
1424                return(0.0);
1425
1426        // If the result is above 5 volts a 0 - 10V range will work best
1427
1428        if(result >= 5.00)
1429                adc_set_channel_mode(channel,ADC_SINGLE_ENDED,ADC_UNIPOLAR,ADC_TOP_10V);
1430
1431        if(mio_error_code)
1432                return(0.0);
1433
1434        // Lastly if we're greater than 0 and less than 5 volts the 0-5V scale is best
1435
1436        if((result >= 0.0) && (result < 5.00))
1437                adc_set_channel_mode(channel, ADC_SINGLE_ENDED, ADC_UNIPOLAR,ADC_TOP_5V);
1438
1439        if(mio_error_code)
1440                return(0.0);
1441
1442        // Now that the values is properly ranged, we take two more samples
1443        // to get a current reading at the new scale.
1444
1445        adc_start_conversion(channel);
1446
1447        if(mio_error_code)
1448                return(0.0);
1449
1450        adc_wait_ready(channel);
1451
1452        if(mio_error_code)
1453                return(0.0);
1454
1455        adc_start_conversion(channel);
1456
1457        if(mio_error_code)
1458                return(0.0);
1459
1460        adc_wait_ready(channel);
1461
1462        if(mio_error_code)
1463                return(0.0);
1464
1465        value = adc_read_conversion_data(channel);
1466        if(mio_error_code)
1467                return(0.0);
1468
1469        // Convert the raw data to voltage
1470
1471        value = value + adc_adjust[channel];
1472        result = value * adc_bitval[channel];
1473        result = result + adc_offset[channel];
1474
1475#ifdef DEBUG
1476        printf("auto_get_channel_voltage : Raw = %04x, adjust = %d, bitval = %9.5f, offset = %9.5f,  result = %9.5f\n",
1477                                                value - adc_adjust[channel],adc_adjust[channel],adc_bitval[channel],adc_offset[channel],result);
1478#endif
1479
1480        return(result);
1481}
1482
1483////////////////////////////////////////////////////////////////////////////////
1484//
1485//
1486//              DIO_READ_BIT
1487//
1488//
1489/////////////////////////////////////////////////////////////////////////////////
1490
1491int dio_read_bit(int bit_number)
1492{
1493unsigned char port;
1494int val;
1495
1496        mio_error_code = MIO_SUCCESS;
1497
1498        if(check_handle())   /* Check for chip available */
1499                return -1;
1500
1501        // Adjust for 0 - 47 bit numbering
1502
1503        --bit_number;
1504
1505        port = bit_number / 8;
1506
1507        val = read_dio_byte(port);
1508
1509        // Get just the bit we specified
1510
1511        val = val & (1 << (bit_number % 8));
1512
1513        // adjust the return for a 0 or 1 value
1514
1515        if(val)
1516                return 1;
1517
1518        return 0;
1519}
1520
1521////////////////////////////////////////////////////////////////////////////////
1522//
1523//
1524//              DIO_WRITE_BIT
1525//
1526//
1527/////////////////////////////////////////////////////////////////////////////////
1528
1529int dio_write_bit(int bit_number, int val)
1530{
1531unsigned char port;
1532unsigned char temp;
1533unsigned char mask;
1534
1535        mio_error_code = MIO_SUCCESS;
1536
1537        if(check_handle())   /* Check for chip available */
1538                return -1;
1539
1540        // Adjust bit numbering for 0 based numbering
1541
1542        --bit_number;
1543
1544        // Calculate the address of the port based on bit number
1545
1546        port = bit_number / 8;
1547
1548        // Use the image value to avoid having to read from the port first
1549
1550        temp = dio_port_images[bit_number / 8];
1551
1552        // Calculate the bit mask for the specifed bit
1553
1554        mask = (1 << (bit_number %8));
1555
1556        // Check whether the request was to set or clear the bit
1557
1558        if(val)
1559                temp = temp | mask;
1560        else
1561                temp = temp & ~mask;
1562
1563        // Update the image value with the value we're about to write
1564
1565        dio_port_images[bit_number / 8] = temp;
1566
1567        write_dio_byte(port, temp);
1568
1569        return 0;
1570}
1571
1572
1573////////////////////////////////////////////////////////////////////////////////
1574//
1575//
1576//              DIO_SET_BIT
1577//
1578//
1579/////////////////////////////////////////////////////////////////////////////////
1580
1581int dio_set_bit(int bit_number)
1582{
1583        mio_error_code = MIO_SUCCESS;
1584
1585        if(check_handle())   /* Check for chip available */
1586                return -1;
1587
1588        dio_write_bit(bit_number,1);
1589
1590        return 0;
1591}
1592
1593////////////////////////////////////////////////////////////////////////////////
1594//
1595//
1596//              DIO_CLR_BIT
1597//
1598//
1599/////////////////////////////////////////////////////////////////////////////////
1600
1601int dio_clr_bit(int bit_number)
1602{
1603        mio_error_code = MIO_SUCCESS;
1604
1605        if(check_handle())   /* Check for chip available */
1606                return -1;
1607
1608        dio_write_bit(bit_number,0);
1609
1610        return 0;
1611}
1612
1613////////////////////////////////////////////////////////////////////////////////
1614//
1615//
1616//              DIO_ENAB_BIT_INT
1617//
1618//
1619/////////////////////////////////////////////////////////////////////////////////
1620
1621int dio_enab_bit_int(int bit_number, int polarity)
1622{
1623unsigned char port;
1624unsigned char temp;
1625unsigned char mask;
1626
1627
1628        mio_error_code = MIO_SUCCESS;
1629
1630        if(check_handle())   /* Check for chip available */
1631                return -1;
1632
1633        // Adjust the bit number for 0 based numbering
1634
1635        --bit_number;
1636
1637        // Calculate the offset for the enable port
1638
1639        port = (bit_number / 8) + 8;
1640
1641        // Calculate the proper bit mask for this bit number
1642
1643        mask = (1 << (bit_number % 8));
1644
1645        // Turn on access to page 2 registers
1646
1647        write_dio_byte(0x07,0x80);
1648
1649        // Get the current state of the enable register
1650
1651        temp = read_dio_byte(port);
1652
1653        // Set the enable bit for our bit number
1654
1655        temp = temp | mask;
1656
1657        // Now update the interrupt enable register
1658
1659        write_dio_byte(port, temp);
1660
1661        // Turn on access to page 1 for polarity control
1662
1663        write_dio_byte(0x07,0x40);
1664
1665        temp = read_dio_byte(port);
1666
1667        // Set the polarity according to the argument value
1668
1669        if(polarity)
1670                temp = temp | mask;
1671        else
1672                temp = temp & ~mask;
1673
1674        write_dio_byte(port, temp);
1675
1676        // Set access back to page 0
1677
1678        write_dio_byte(0x07,0);
1679
1680        return 0;
1681}
1682
1683
1684////////////////////////////////////////////////////////////////////////////////
1685//
1686//
1687//              DIO_DISAB_BIT_INT
1688//
1689//
1690/////////////////////////////////////////////////////////////////////////////////
1691
1692int dio_disab_bit_int(int bit_number)
1693{
1694unsigned char port;
1695unsigned char temp;
1696unsigned char mask;
1697
1698        mio_error_code = MIO_SUCCESS;
1699
1700        if(check_handle())   /* Check for chip available */
1701                return -1;
1702
1703        // Adjust the bit number for 0 based numbering
1704
1705        --bit_number;
1706
1707        // Calculate the offset for the enable port
1708
1709        port = (bit_number / 8) + 8;
1710
1711        // Calculate the proper bit mask for this bit number
1712
1713        mask = (1 << (bit_number % 8));
1714
1715        // Turn on access to page 2 registers
1716
1717        write_dio_byte(0x07,0x80);
1718
1719        // Get the current state of the enable register
1720
1721        temp = read_dio_byte(port);
1722
1723        // Clear the enable bit for the our bit
1724
1725        temp = temp & ~mask;
1726
1727        // Update the enable register with the new data
1728
1729        write_dio_byte(port,temp);
1730
1731        // Set access back to page 0
1732
1733        write_dio_byte(0x07,0);
1734
1735        return 0;
1736}
1737
1738
1739////////////////////////////////////////////////////////////////////////////////
1740//
1741//
1742//              DIO_CLR_INT
1743//
1744//
1745/////////////////////////////////////////////////////////////////////////////////
1746
1747int dio_clr_int(int bit_number)
1748{
1749unsigned short port;
1750unsigned short temp;
1751unsigned short mask;
1752
1753        // Adjust for 0 based numbering
1754        mio_error_code = MIO_SUCCESS;
1755
1756        if(check_handle())   /* Check for chip available */
1757                return -1;
1758
1759        --bit_number;
1760
1761        // Calculate the correct offset for our enable register
1762
1763        port = (bit_number / 8) + 8;
1764
1765        // Calculate the bit mask for this bit
1766
1767        mask = (1 << (bit_number % 8));
1768
1769        // Set access to page 2 for the enable register
1770
1771        write_dio_byte(0x07,0x80);
1772
1773        // Get the current state of the register
1774
1775        temp = read_dio_byte(port);
1776
1777        // Temporarily clear only our enable. This clears the interrupt
1778
1779        temp = temp & ~mask;
1780
1781        // Write out the temporary value
1782
1783        write_dio_byte(port, temp);
1784
1785        temp = temp | mask;
1786
1787        write_dio_byte(port, temp);
1788
1789        // Set access back to page 0
1790
1791        write_dio_byte(0x07,0);
1792
1793        return 0;
1794}
1795
1796
1797int dio_get_int(void)
1798{
1799int c;
1800
1801    c=ioctl(handle,DIO_GET_INT,NULL);
1802
1803    return (c & 0xff);
1804
1805}
1806
1807
1808int wait_adc_int(int adc_num)
1809{
1810int c;
1811
1812
1813    if(check_handle())   /* Check for chip available */
1814                return -1;
1815
1816        if(adc_num)
1817            c=ioctl(handle,WAIT_A2D_INT_1,NULL);
1818        else
1819            c=ioctl(handle,WAIT_A2D_INT_2,NULL);
1820
1821
1822    return (c & 0xff);
1823
1824}
1825
1826
1827int wait_dac_int(int dac_num)
1828{
1829int c;
1830
1831    if(check_handle())   /* Check for chip available */
1832                return -1;
1833
1834        if(dac_num)
1835            c=ioctl(handle,WAIT_DAC_INT_1,NULL);
1836        else
1837            c=ioctl(handle,WAIT_DAC_INT_2,NULL);
1838
1839    return (c & 0xff);
1840
1841}
1842
1843
1844int wait_dio_int(void)
1845{
1846int c;
1847
1848
1849    if(check_handle())   /* Check for chip available */
1850                return -1;
1851
1852    c=ioctl(handle,WAIT_DIO_INT,NULL);
1853
1854    return (c & 0xff);
1855
1856}
1857
1858
1859
1860int check_handle(void)
1861{
1862    if(handle > 0)      /* If it's already a valid handle */
1863                return 0;
1864
1865    if(handle == -1)    /* If it's already been tried */
1866        {
1867                mio_error_code = MIO_OPEN_ERROR;
1868                sprintf(mio_error_string,"MIO - Unable to open device PCMMIO");
1869                return -1;
1870        }
1871
1872    /* Try opening the device file, in case it hasn't been opened yet */
1873
1874    handle = open(device_id,0);
1875
1876        /* Try an alternate open at /dev */
1877
1878        if(handle < 0)
1879                handle = open(dev_id,0);
1880
1881    if(handle > 0)      /* If it's now a valid handle */
1882                return 0;
1883
1884        mio_error_code = MIO_OPEN_ERROR;
1885        sprintf(mio_error_string,"MIO - Unable to open device PCMMIO");
1886    handle = -1;
1887        return -1;
1888}
1889
Note: See TracBrowser for help on using the repository browser.