Overview

Introduction

ADC support in eCos is based around the standard character device interface. Hence all device IO function, or file IO functions may be used to access ADC devices.

ADC devices are presented as read-only serial channels that generate samples at a given rate. The size of each sample is hardware specific and is defined by the cyg_adc_sample_t type. The sample rate may be set at runtime by the application. Most ADC devices support several channels which are all sampled at the same rate. Therefore setting the rate for one channel will usually change the rate for all channels on that device.

Examples

The use of the ADC devices is best shown by example. The following is a simple example of using the eCos device interface to access the ADC:

        int res;
        cyg_io_handle_t handle;

        // Get a handle for ADC device 0 channel 0
        res = cyg_io_lookup( "/dev/adc00", &handle );

        if( res != ENOERR )
            handle_error(err);

        for(;;)
        {
            cyg_adc_sample_t sample;
            cyg_uint32 len = sizeof(sample);

            // read a sample from the channel
            res = cyg_io_read( handle, &sample, &len );

            if( res != ENOERR )
                handle_error(err);

            use_sample( sample );
        }

In this example, the required channel is looked up and a handle on it acquired. Conventionally ADC devices are named "/dev/adcXY" where X is the device number and Y the channel within that device. Following this, samples are read from the device sequentially.

ADC devices may also be accessed using FILEIO operations. These allow more sophisticated usage. The following example shows select() being used to gather samples from several devices.

        int fd1, fd2;

        // open channels, non-blocking
        fd1 = open( "/dev/adc01", O_RDONLY|O_NONBLOCK );
        fd2 = open( "/dev/adc02", O_RDONLY|O_NONBLOCK );

        if( fd1 < 0 || fd2 < 0 )
            handle_error( errno );

        for(;;)
        {
            fd_set rd;
            int maxfd = 0;
            int err;
            cyg_adc_sample_t samples[128];
            int len;

            FD_ZERO( &rd );

            FD_SET( fd1, &rd );
            FD_SET( fd2, &rd );
            maxfd = max(fd1,fd2);

            // select on available data on each channel.
            err = select( maxfd+1, &rd, NULL, NULL, NULL );

            if( err < 0 )
                handle_error(errno);

            // If channel 1 has data, handle it
            if( FD_ISSET( fd1, &rd ) )
            {
                len = read( fd1, &samples, sizeof(samples) );

                if( len > 0 )
                    handle_samples_chan1( &samples, len/sizeof(sample[0]) );
            }

            // If channel 2 has data, handle it
            if( FD_ISSET( fd2, &rd ) )
            {
                len = read( fd2, &samples, sizeof(samples) );

                if( len > 0 )
                    handle_samples_chan2( &samples, len/sizeof(sample[0]) );
            }

        }

This test uses FILEIO operations to access ADC channels. It starts by opening two channels for reading only and with blocking disabled. It then falls into a loop using select to wake up whenever either channel has samples available.

Details

As indicated, the main interface to ADC devices is via the standard character device interface. However, there are a number of aspects that are ADC specific.

int set_rate_io( cyg_io_handle_t handle, int rate )
{
    cyg_adc_info_t info;
    cyg_uint32 len = sizeof(info);

    info.rate = rate;

    return cyg_io_set_config( handle,
                              CYG_IO_SET_CONFIG_ADC_RATE,
                              &info,
                              &len);
}

int set_rate_fileio( int fd, int rate )
{
    cyg_adc_info_t info;

    info.rate = rate;

    return cyg_fs_fsetinfo( fd,
                            CYG_IO_SET_CONFIG_ADC_RATE,
                            &info,
                            sizeof(info) );
}

int disable_io( cyg_io_handle_t handle )
{
    return cyg_io_set_config( handle,
                              CYG_IO_SET_CONFIG_ADC_DISABLE,
                              NULL,
                              NULL);
}

int enable_io( cyg_io_handle_t handle )
{
    return cyg_io_set_config( handle,
                              CYG_IO_SET_CONFIG_ADC_DISABLE,
                              NULL,
                              NULL);
}

Configuration

The ADC package defines a number of generic configuration options that apply to all ADC implementations:

In addition to the generic options, each hardware device driver defines some parameters for each device and channel. The exact names of the following option depends on the hardware device driver, but options of this form should be available in all drivers.