pios_adc.c

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, see <http://www.gnu.org/licenses/>
 */

#include "pios.h"
#ifdef PIOS_INCLUDE_ADC

// Private types
enum pios_adc_dev_magic {
        PIOS_ADC_DEV_MAGIC = 0x58375169,
};

struct pios_adc_dev {
        enum pios_adc_dev_magic magic;
        uintptr_t lower_id;
        const struct pios_adc_driver *driver;
};

struct pios_adc_dev * pios_adc_dev;

// Private functions
static struct pios_adc_dev * PIOS_ADC_Allocate(void);
static bool PIOS_ADC_validate(struct pios_adc_dev *);

#ifndef PIOS_ADC_SUB_DRIVER_MAX_INSTANCES
#define PIOS_ADC_SUB_DRIVER_MAX_INSTANCES 2
#endif

/* Local Variables */
static struct sub_device_list_ {
        uint8_t number_of_devices;
        struct pios_adc_dev * sub_device_pointers[PIOS_ADC_SUB_DRIVER_MAX_INSTANCES];
} sub_device_list;

static bool PIOS_ADC_validate(struct pios_adc_dev *dev)
{
        if (dev == NULL)
                return false;

        return (dev->magic == PIOS_ADC_DEV_MAGIC);
}

static struct pios_adc_dev *PIOS_ADC_Allocate(void)
{
        struct pios_adc_dev *adc_dev;

        adc_dev = (struct pios_adc_dev *)PIOS_malloc_no_dma(sizeof(*adc_dev));
        if (!adc_dev)
                return (NULL );

        adc_dev->magic = PIOS_ADC_DEV_MAGIC;
        return (adc_dev);
}

int32_t PIOS_ADC_Init(uintptr_t *adc_id, const struct pios_adc_driver *driver, uintptr_t lower_id)
{
        PIOS_Assert(adc_id);
        PIOS_Assert(driver);
        if (sub_device_list.number_of_devices >= PIOS_ADC_SUB_DRIVER_MAX_INSTANCES)
                return -1;
        struct pios_adc_dev * adc_dev;

        adc_dev = (struct pios_adc_dev *) PIOS_ADC_Allocate();

        if (!adc_dev)
                return -1;

        adc_dev->driver = driver;
        adc_dev->lower_id = lower_id;
        *adc_id = (uintptr_t) adc_dev;
        sub_device_list.sub_device_pointers[sub_device_list.number_of_devices] = adc_dev;
        sub_device_list.number_of_devices++;
        return 0;
}

int32_t PIOS_ADC_GetChannelRaw(uint32_t channel)
{
        uint32_t offset = 0;
        for (uint8_t x = 0; x < sub_device_list.number_of_devices; ++x) {
                struct pios_adc_dev * adc_dev = sub_device_list.sub_device_pointers[x];
                if (!PIOS_ADC_validate(adc_dev)) {
                        PIOS_DEBUG_Assert(0);
                        continue;
                } else if (adc_dev->driver->number_of_channels) {
                        uint32_t num_channels_for_this_device = adc_dev->driver->number_of_channels(adc_dev->lower_id);
                        if (adc_dev->driver->get_pin && (channel < offset + num_channels_for_this_device)) {
                                return (adc_dev->driver->get_pin)(adc_dev->lower_id, channel - offset);
                        } else
                                offset += num_channels_for_this_device;
                }
        }
        return -1;
}

float PIOS_ADC_GetChannelVolt(uint32_t channel)
{
        uint32_t offset = 0;
        for (uint8_t x = 0; x < sub_device_list.number_of_devices; ++x) {
                struct pios_adc_dev * adc_dev = sub_device_list.sub_device_pointers[x];
                if (!PIOS_ADC_validate(adc_dev)) {
                        PIOS_DEBUG_Assert(0);
                        continue;
                } else if (adc_dev->driver->number_of_channels) {
                        uint32_t num_channels_for_this_device = adc_dev->driver->number_of_channels(adc_dev->lower_id);
                        if (adc_dev->driver->get_pin && (channel < offset + num_channels_for_this_device)) {
                                return (float)((adc_dev->driver->get_pin)(adc_dev->lower_id, channel - offset)) * (float)(adc_dev->driver->lsb_voltage)(adc_dev->lower_id);
                        } else
                                offset += num_channels_for_this_device;
                }
        }
        return -1;
}
#endif