aardvark.c

Aardvark Example Source Code Version: 4.00 Date: 2007-04-20 Source code which shows how to use the

    return c_aa_target_power(aardvark, power_mask);
}


static u32 (*c_aa_sleep_ms) (u32) = 0;
u32 aa_sleep_ms (
    u32 milliseconds
)
{
    if (c_aa_sleep_ms == 0) {
        int res = 0;
        if (!(c_aa_sleep_ms = _loadFunction("c_aa_sleep_ms", &res)))
            return res;
    }
    return c_aa_sleep_ms(milliseconds);
}


static int (*c_aa_async_poll) (Aardvark, int) = 0;
int aa_async_poll (
    Aardvark aardvark,
    int      timeout
)
{
    if (c_aa_async_poll == 0) {
        int res = 0;
        if (!(c_aa_async_poll = _loadFunction("c_aa_async_poll", &res)))
            return res;
    }
    return c_aa_async_poll(aardvark, timeout);
}


static int (*c_aa_i2c_free_bus) (Aardvark) = 0;
int aa_i2c_free_bus (
    Aardvark aardvark
)
{
    if (c_aa_i2c_free_bus == 0) {
        int res = 0;
        if (!(c_aa_i2c_free_bus = _loadFunction("c_aa_i2c_free_bus", &res)))
            return res;
    }
    return c_aa_i2c_free_bus(aardvark);
}


static int (*c_aa_i2c_bitrate) (Aardvark, int) = 0;
int aa_i2c_bitrate (
    Aardvark aardvark,
    int      bitrate_khz
)
{
    if (c_aa_i2c_bitrate == 0) {
        int res = 0;
        if (!(c_aa_i2c_bitrate = _loadFunction("c_aa_i2c_bitrate", &res)))
            return res;
    }
    return c_aa_i2c_bitrate(aardvark, bitrate_khz);
}


static int (*c_aa_i2c_read) (Aardvark, u16, AardvarkI2cFlags, u16, u08 *) = 0;
int aa_i2c_read (
    Aardvark         aardvark,
    u16              slave_addr,
    AardvarkI2cFlags flags,
    u16              num_bytes,
    u08 *            data_in
)
{
    if (c_aa_i2c_read == 0) {
        int res = 0;
        if (!(c_aa_i2c_read = _loadFunction("c_aa_i2c_read", &res)))
            return res;
    }
    return c_aa_i2c_read(aardvark, slave_addr, flags, num_bytes, data_in);
}


static int (*c_aa_i2c_read_ext) (Aardvark, u16, AardvarkI2cFlags, u16, u08 *, u16 *) = 0;
int aa_i2c_read_ext (
    Aardvark         aardvark,
    u16              slave_addr,
    AardvarkI2cFlags flags,
    u16              num_bytes,
    u08 *            data_in,
    u16 *            num_read
)
{
    if (c_aa_i2c_read_ext == 0) {
        int res = 0;
        if (!(c_aa_i2c_read_ext = _loadFunction("c_aa_i2c_read_ext", &res)))
            return res;
    }
    return c_aa_i2c_read_ext(aardvark, slave_addr, flags, num_bytes, data_in, num_read);
}


static int (*c_aa_i2c_write) (Aardvark, u16, AardvarkI2cFlags, u16, const u08 *) = 0;
int aa_i2c_write (
    Aardvark         aardvark,
    u16              slave_addr,
    AardvarkI2cFlags flags,
    u16              num_bytes,
    const u08 *      data_out
)
{
    if (c_aa_i2c_write == 0) {
        int res = 0;
        if (!(c_aa_i2c_write = _loadFunction("c_aa_i2c_write", &res)))
            return res;
    }
    return c_aa_i2c_write(aardvark, slave_addr, flags, num_bytes, data_out);
}


static int (*c_aa_i2c_write_ext) (Aardvark, u16, AardvarkI2cFlags, u16, const u08 *, u16 *) = 0;
int aa_i2c_write_ext (
    Aardvark         aardvark,
    u16              slave_addr,
    AardvarkI2cFlags flags,
    u16              num_bytes,
    const u08 *      data_out,
    u16 *            num_written
)
{
    if (c_aa_i2c_write_ext == 0) {
        int res = 0;
        if (!(c_aa_i2c_write_ext = _loadFunction("c_aa_i2c_write_ext", &res)))
            return res;
    }
    return c_aa_i2c_write_ext(aardvark, slave_addr, flags, num_bytes, data_out, num_written);
}


static int (*c_aa_i2c_slave_enable) (Aardvark, u08, u16, u16) = 0;
int aa_i2c_slave_enable (
    Aardvark aardvark,
    u08      addr,
    u16      maxTxBytes,
    u16      maxRxBytes
)
{
    if (c_aa_i2c_slave_enable == 0) {
        int res = 0;
        if (!(c_aa_i2c_slave_enable = _loadFunction("c_aa_i2c_slave_enable", &res)))
            return res;
    }
    return c_aa_i2c_slave_enable(aardvark, addr, maxTxBytes, maxRxBytes);
}


static int (*c_aa_i2c_slave_disable) (Aardvark) = 0;
int aa_i2c_slave_disable (
    Aardvark aardvark
)
{
    if (c_aa_i2c_slave_disable == 0) {
        int res = 0;
        if (!(c_aa_i2c_slave_disable = _loadFunction("c_aa_i2c_slave_disable", &res)))
            return res;
    }
    return c_aa_i2c_slave_disable(aardvark);
}


static int (*c_aa_i2c_slave_set_response) (Aardvark, u08, const u08 *) = 0;
int aa_i2c_slave_set_response (
    Aardvark    aardvark,
    u08         num_bytes,
    const u08 * data_out
)
{
    if (c_aa_i2c_slave_set_response == 0) {
        int res = 0;
        if (!(c_aa_i2c_slave_set_response = _loadFunction("c_aa_i2c_slave_set_response", &res)))
            return res;
    }
    return c_aa_i2c_slave_set_response(aardvark, num_bytes, data_out);
}


static int (*c_aa_i2c_slave_write_stats) (Aardvark) = 0;
int aa_i2c_slave_write_stats (
    Aardvark aardvark
)
{
    if (c_aa_i2c_slave_write_stats == 0) {
        int res = 0;
        if (!(c_aa_i2c_slave_write_stats = _loadFunction("c_aa_i2c_slave_write_stats", &res)))
            return res;
    }
    return c_aa_i2c_slave_write_stats(aardvark);
}


static int (*c_aa_i2c_slave_read) (Aardvark, u08 *, u16, u08 *) = 0;
int aa_i2c_slave_read (
    Aardvark aardvark,
    u08 *    addr,
    u16      num_bytes,
    u08 *    data_in
)
{
    if (c_aa_i2c_slave_read == 0) {
        int res = 0;
        if (!(c_aa_i2c_slave_read = _loadFunction("c_aa_i2c_slave_read", &res)))
            return res;
    }
    return c_aa_i2c_slave_read(aardvark, addr, num_bytes, data_in);
}


static int (*c_aa_i2c_slave_write_stats_ext) (Aardvark, u16 *) = 0;
int aa_i2c_slave_write_stats_ext (
    Aardvark aardvark,
    u16 *    num_written
)
{
    if (c_aa_i2c_slave_write_stats_ext == 0) {
        int res = 0;
        if (!(c_aa_i2c_slave_write_stats_ext = _loadFunction("c_aa_i2c_slave_write_stats_ext", &res)))
            return res;
    }
    return c_aa_i2c_slave_write_stats_ext(aardvark, num_written);
}


static int (*c_aa_i2c_slave_read_ext) (Aardvark, u08 *, u16, u08 *, u16 *) = 0;
int aa_i2c_slave_read_ext (
    Aardvark aardvark,
    u08 *    addr,
    u16      num_bytes,
    u08 *    data_in,
    u16 *    num_read
)
{
    if (c_aa_i2c_slave_read_ext == 0) {
        int res = 0;
        if (!(c_aa_i2c_slave_read_ext = _loadFunction("c_aa_i2c_slave_read_ext", &res)))
            return res;
    }
    return c_aa_i2c_slave_read_ext(aardvark, addr, num_bytes, data_in, num_read);
}


static int (*c_aa_i2c_monitor_enable) (Aardvark) = 0;
int aa_i2c_monitor_enable (
    Aardvark aardvark
)
{
    if (c_aa_i2c_monitor_enable == 0) {
        int res = 0;
        if (!(c_aa_i2c_monitor_enable = _loadFunction("c_aa_i2c_monitor_enable", &res)))
            return res;
    }
    return c_aa_i2c_monitor_enable(aardvark);
}


static int (*c_aa_i2c_monitor_disable) (Aardvark) = 0;
int aa_i2c_monitor_disable (
    Aardvark aardvark
)
{
    if (c_aa_i2c_monitor_disable == 0) {
        int res = 0;
        if (!(c_aa_i2c_monitor_disable = _loadFunction("c_aa_i2c_monitor_disable", &res)))
            return res;
    }
    return c_aa_i2c_monitor_disable(aardvark);
}


static int (*c_aa_i2c_monitor_read) (Aardvark, u16, u16 *) = 0;
int aa_i2c_monitor_read (
    Aardvark aardvark,
    u16      num_bytes,
    u16 *    data
)
{
    if (c_aa_i2c_monitor_read == 0) {
        int res = 0;
        if (!(c_aa_i2c_monitor_read = _loadFunction("c_aa_i2c_monitor_read", &res)))
            return res;
    }
    return c_aa_i2c_monitor_read(aardvark, num_bytes, data);
}


static int (*c_aa_i2c_pullup) (Aardvark, u08) = 0;
int aa_i2c_pullup (
    Aardvark aardvark,
    u08      pullup_mask
)
{
    if (c_aa_i2c_pullup == 0) {
        int res = 0;
        if (!(c_aa_i2c_pullup = _loadFunction("c_aa_i2c_pullup", &res)))
            return res;
    }
    return c_aa_i2c_pullup(aardvark, pullup_mask);
}


static int (*c_aa_spi_bitrate) (Aardvark, int) = 0;
int aa_spi_bitrate (
    Aardvark aardvark,
    int      bitrate_khz
)
{
    if (c_aa_spi_bitrate == 0) {
        int res = 0;
        if (!(c_aa_spi_bitrate = _loadFunction("c_aa_spi_bitrate", &res)))
            return res;
    }
    return c_aa_spi_bitrate(aardvark, bitrate_khz);
}


static int (*c_aa_spi_configure) (Aardvark, AardvarkSpiPolarity, AardvarkSpiPhase, AardvarkSpiBitorder) = 0;
int aa_spi_configure (
    Aardvark            aardvark,
    AardvarkSpiPolarity polarity,
    AardvarkSpiPhase    phase,
    AardvarkSpiBitorder bitorder
)
{
    if (c_aa_spi_configure == 0) {
        int res = 0;
        if (!(c_aa_spi_configure = _loadFunction("c_aa_spi_configure", &res)))
            return res;
    }
    return c_aa_spi_configure(aardvark, polarity, phase, bitorder);
}


static int (*c_aa_spi_write) (Aardvark, u16, const u08 *, u08 *) = 0;
int aa_spi_write (
    Aardvark    aardvark,
    u16         num_bytes,
    const u08 * data_out,
    u08 *       data_in
)
{
    if (c_aa_spi_write == 0) {
        int res = 0;
        if (!(c_aa_spi_write = _loadFunction("c_aa_spi_write", &res)))
            return res;
    }
    return c_aa_spi_write(aardvark, num_bytes, data_out, data_in);
}


static int (*c_aa_spi_slave_enable) (Aardvark) = 0;
int aa_spi_slave_enable (
    Aardvark aardvark
)
{
    if (c_aa_spi_slave_enable == 0) {
        int res = 0;
        if (!(c_aa_spi_slave_enable = _loadFunction("c_aa_spi_slave_enable", &res)))
            return res;
    }
    return c_aa_spi_slave_enable(aardvark);
}


static int (*c_aa_spi_slave_disable) (Aardvark) = 0;
int aa_spi_slave_disable (
    Aardvark aardvark
)
{
    if (c_aa_spi_slave_disable == 0) {
        int res = 0;
        if (!(c_aa_spi_slave_disable = _loadFunction("c_aa_spi_slave_disable", &res)))
            return res;
    }
    return c_aa_spi_slave_disable(aardvark);
}


static int (*c_aa_spi_slave_set_response) (Aardvark, u08, const u08 *) = 0;
int aa_spi_slave_set_response (
    Aardvark    aardvark,
    u08         num_bytes,
    const u08 * data_out
)
{
    if (c_aa_spi_slave_set_response == 0) {
        int res = 0;
        if (!(c_aa_spi_slave_set_response = _loadFunction("c_aa_spi_slave_set_response", &res)))
            return res;
    }
    return c_aa_spi_slave_set_response(aardvark, num_bytes, data_out);
}


static int (*c_aa_spi_slave_read) (Aardvark, u16, u08 *) = 0;
int aa_spi_slave_read (
    Aardvark aardvark,
    u16      num_bytes,
    u08 *    data_in
)
{
    if (c_aa_spi_slave_read == 0) {
        int res = 0;
        if (!(c_aa_spi_slave_read = _loadFunction("c_aa_spi_slave_read", &res)))
            return res;
    }
    return c_aa_spi_slave_read(aardvark, num_bytes, data_in);
}


static int (*c_aa_spi_master_ss_polarity) (Aardvark, AardvarkSpiSSPolarity) = 0;
int aa_spi_master_ss_polarity (
    Aardvark              aardvark,
    AardvarkSpiSSPolarity polarity
)
{
    if (c_aa_spi_master_ss_polarity == 0) {
        int res = 0;
        if (!(c_aa_spi_master_ss_polarity = _loadFunction("c_aa_spi_master_ss_polarity", &res)))
            return res;
    }
    return c_aa_spi_master_ss_polarity(aardvark, polarity);
}


static int (*c_aa_gpio_direction) (Aardvark, u08) = 0;
int aa_gpio_direction (
    Aardvark aardvark,
    u08      direction_mask
)
{
    if (c_aa_gpio_direction == 0) {
        int res = 0;
        if (!(c_aa_gpio_direction = _loadFunction("c_aa_gpio_direction", &res)))
            return res;
    }
    return c_aa_gpio_direction(aardvark, direction_mask);
}


static int (*c_aa_gpio_pullup) (Aardvark, u08) = 0;
int aa_gpio_pullup (
    Aardvark aardvark,
    u08      pullup_mask
)
{
    if (c_aa_gpio_pullup == 0) {
        int res = 0;
        if (!(c_aa_gpio_pullup = _loadFunction("c_aa_gpio_pullup", &res)))
            return res;
    }
    return c_aa_gpio_pullup(aardvark, pullup_mask);
}


static int (*c_aa_gpio_get) (Aardvark) = 0;
int aa_gpio_get (
    Aardvark aardvark
)
{
    if (c_aa_gpio_get == 0) {
        int res = 0;
        if (!(c_aa_gpio_get = _loadFunction("c_aa_gpio_get", &res)))
            return res;
    }
    return c_aa_gpio_get(aardvark);
}


static int (*c_aa_gpio_set) (Aardvark, u08) = 0;
int aa_gpio_set (
    Aardvark aardvark,
    u08      value
)
{
    if (c_aa_gpio_set == 0) {
        int res = 0;
        if (!(c_aa_gpio_set = _loadFunction("c_aa_gpio_set", &res)))
            return res;
    }
    return c_aa_gpio_set(aardvark, value);
}


static int (*c_aa_gpio_change) (Aardvark, u16) = 0;
int aa_gpio_change (
    Aardvark aardvark,
    u16      timeout
)
{
    if (c_aa_gpio_change == 0) {
        int res = 0;
        if (!(c_aa_gpio_change = _loadFunction("c_aa_gpio_change", &res)))
            return res;
    }
    return c_aa_gpio_change(aardvark, timeout);
}