aardvark.cs

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

 * returned.
 */
public static int aa_spi_bitrate (
    int  aardvark,
    int  bitrate_khz
)
{
    if (!AA_LIBRARY_LOADED) return (int)AardvarkStatus.AA_INCOMPATIBLE_LIBRARY;
    return c_aa_spi_bitrate(aardvark, bitrate_khz);
}

/*
 * These configuration parameters specify how to clock the
 * bits that are sent and received on the Aardvark SPI
 * interface.
 * 
 *   The polarity option specifies which transition
 *   constitutes the leading edge and which transition is the
 *   falling edge.  For example, AA_SPI_POL_RISING_FALLING
 *   would configure the SPI to idle the SCK clock line low.
 *   The clock would then transition low-to-high on the
 *   leading edge and high-to-low on the trailing edge.
 * 
 *   The phase option determines whether to sample or setup on
 *   the leading edge.  For example, AA_SPI_PHASE_SAMPLE_SETUP
 *   would configure the SPI to sample on the leading edge and
 *   setup on the trailing edge.
 * 
 *   The bitorder option is used to indicate whether LSB or
 *   MSB is shifted first.
 * 
 * See the diagrams in the Aardvark datasheet for
 * more details.
 */
// enum AardvarkSpiPolarity  (from declaration above)
//     AA_SPI_POL_RISING_FALLING = 0
//     AA_SPI_POL_FALLING_RISING = 1

// enum AardvarkSpiPhase  (from declaration above)
//     AA_SPI_PHASE_SAMPLE_SETUP = 0
//     AA_SPI_PHASE_SETUP_SAMPLE = 1

// enum AardvarkSpiBitorder  (from declaration above)
//     AA_SPI_BITORDER_MSB = 0
//     AA_SPI_BITORDER_LSB = 1

/* Configure the SPI master or slave interface */
public static int aa_spi_configure (
    int                  aardvark,
    AardvarkSpiPolarity  polarity,
    AardvarkSpiPhase     phase,
    AardvarkSpiBitorder  bitorder
)
{
    if (!AA_LIBRARY_LOADED) return (int)AardvarkStatus.AA_INCOMPATIBLE_LIBRARY;
    return c_aa_spi_configure(aardvark, polarity, phase, bitorder);
}

/* Write a stream of bytes to the downstream SPI slave device. */
public static int aa_spi_write (
    int         aardvark,
    byte[]      data_out,
    ref byte[]  data_in
)
{
    if (!AA_LIBRARY_LOADED) return (int)AardvarkStatus.AA_INCOMPATIBLE_LIBRARY;
    short num_bytes = ((short)data_out.Length);
    return c_aa_spi_write(aardvark, num_bytes, data_out, ref data_in[0]);
}

/* Enable/Disable the Aardvark as an SPI slave device */
public static int aa_spi_slave_enable (
    int  aardvark
)
{
    if (!AA_LIBRARY_LOADED) return (int)AardvarkStatus.AA_INCOMPATIBLE_LIBRARY;
    return c_aa_spi_slave_enable(aardvark);
}

public static int aa_spi_slave_disable (
    int  aardvark
)
{
    if (!AA_LIBRARY_LOADED) return (int)AardvarkStatus.AA_INCOMPATIBLE_LIBRARY;
    return c_aa_spi_slave_disable(aardvark);
}

/*
 * Set the slave response in the event the Aardvark is put
 * into slave mode and contacted by a Master.
 */
public static int aa_spi_slave_set_response (
    int     aardvark,
    byte[]  data_out
)
{
    if (!AA_LIBRARY_LOADED) return (int)AardvarkStatus.AA_INCOMPATIBLE_LIBRARY;
    byte num_bytes = ((byte)data_out.Length);
    return c_aa_spi_slave_set_response(aardvark, num_bytes, data_out);
}

/* Read the bytes from an SPI slave reception */
public static int aa_spi_slave_read (
    int         aardvark,
    short       num_bytes,
    ref byte[]  data_in
)
{
    if (!AA_LIBRARY_LOADED) return (int)AardvarkStatus.AA_INCOMPATIBLE_LIBRARY;
    return c_aa_spi_slave_read(aardvark, num_bytes, ref data_in[0]);
}

/*
 * Change the output polarity on the SS line.
 * 
 * Note: When configured as an SPI slave, the Aardvark will
 * always be setup with SS as active low.  Hence this function
 * only affects the SPI master functions on the Aardvark.
 */
// enum AardvarkSpiSSPolarity  (from declaration above)
//     AA_SPI_SS_ACTIVE_LOW  = 0
//     AA_SPI_SS_ACTIVE_HIGH = 1

public static int aa_spi_master_ss_polarity (
    int                    aardvark,
    AardvarkSpiSSPolarity  polarity
)
{
    if (!AA_LIBRARY_LOADED) return (int)AardvarkStatus.AA_INCOMPATIBLE_LIBRARY;
    return c_aa_spi_master_ss_polarity(aardvark, polarity);
}


/*=========================================================================
| GPIO API
 ========================================================================*/
/*
 * The following enumerated type maps the named lines on the
 * Aardvark I2C/SPI line to bit positions in the GPIO API.
 * All GPIO API functions will index these lines through an
 * 8-bit masked value.  Thus, each bit position in the mask
 * can be referred back its corresponding line through the
 * enumerated type.
 */
// enum AardvarkGpioBits  (from declaration above)
//     AA_GPIO_SCL  = 0x01
//     AA_GPIO_SDA  = 0x02
//     AA_GPIO_MISO = 0x04
//     AA_GPIO_SCK  = 0x08
//     AA_GPIO_MOSI = 0x10
//     AA_GPIO_SS   = 0x20

/*
 * Configure the GPIO, specifying the direction of each bit.
 * 
 * A call to this function will not change the value of the pullup
 * mask in the Aardvark.  This is illustrated by the following
 * example:
 *   (1) Direction mask is first set to 0x00
 *   (2) Pullup is set to 0x01
 *   (3) Direction mask is set to 0x01
 *   (4) Direction mask is later set back to 0x00.
 * 
 * The pullup will be active after (4).
 * 
 * On Aardvark power-up, the default value of the direction
 * mask is 0x00.
 */
public const byte AA_GPIO_DIR_INPUT = 0;
public const byte AA_GPIO_DIR_OUTPUT = 1;
public static int aa_gpio_direction (
    int   aardvark,
    byte  direction_mask
)
{
    if (!AA_LIBRARY_LOADED) return (int)AardvarkStatus.AA_INCOMPATIBLE_LIBRARY;
    return c_aa_gpio_direction(aardvark, direction_mask);
}

/*
 * Enable an internal pullup on any of the GPIO input lines.
 * 
 * Note: If a line is configured as an output, the pullup bit
 * for that line will be ignored, though that pullup bit will
 * be cached in case the line is later configured as an input.
 * 
 * By default the pullup mask is 0x00.
 */
public const byte AA_GPIO_PULLUP_OFF = 0;
public const byte AA_GPIO_PULLUP_ON = 1;
public static int aa_gpio_pullup (
    int   aardvark,
    byte  pullup_mask
)
{
    if (!AA_LIBRARY_LOADED) return (int)AardvarkStatus.AA_INCOMPATIBLE_LIBRARY;
    return c_aa_gpio_pullup(aardvark, pullup_mask);
}

/*
 * Read the current digital values on the GPIO input lines.
 * 
 * The bits will be ordered as described by AA_GPIO_BITS.  If a
 * line is configured as an output, its corresponding bit
 * position in the mask will be undefined.
 */
public static int aa_gpio_get (
    int  aardvark
)
{
    if (!AA_LIBRARY_LOADED) return (int)AardvarkStatus.AA_INCOMPATIBLE_LIBRARY;
    return c_aa_gpio_get(aardvark);
}

/*
 * Set the outputs on the GPIO lines.
 * 
 * Note: If a line is configured as an input, it will not be
 * affected by this call, but the output value for that line
 * will be cached in the event that the line is later
 * configured as an output.
 */
public static int aa_gpio_set (
    int   aardvark,
    byte  value
)
{
    if (!AA_LIBRARY_LOADED) return (int)AardvarkStatus.AA_INCOMPATIBLE_LIBRARY;
    return c_aa_gpio_set(aardvark, value);
}

/*
 * Block until there is a change on the GPIO input lines.
 * Pins configured as outputs will be ignored.
 * 
 * The function will return either when a change has occurred or
 * the timeout expires.  The timeout, specified in millisecods, has
 * a precision of ~16 ms. The maximum allowable timeout is
 * approximately 4 seconds. If the timeout expires, this function
 * will return the current state of the GPIO lines.
 *
 * This function will return immediately with the current value
 * of the GPIO lines for the first invocation after any of the
 * following functions are called: aa_configure,
 * aa_gpio_direction, or aa_gpio_pullup.
 *
 * If the function aa_gpio_get is called before calling
 * aa_gpio_change, aa_gpio_change will only register any changes
 * from the value last returned by aa_gpio_get.
 */
public static int aa_gpio_change (
    int    aardvark,
    short  timeout
)
{
    if (!AA_LIBRARY_LOADED) return (int)AardvarkStatus.AA_INCOMPATIBLE_LIBRARY;
    return c_aa_gpio_change(aardvark, timeout);
}


/*=========================================================================
| NATIVE DLL BINDINGS
 ========================================================================*/
[DllImport ("aardvark")]
private static extern int c_aa_find_devices (int nelem, ref short devices);

[DllImport ("aardvark")]
private static extern int c_aa_find_devices_ext (int nelem, ref short devices, ref int unique_ids);

[DllImport ("aardvark")]
private static extern int c_aa_open (int port_number);

[DllImport ("aardvark")]
private static extern int c_aa_open_ext (int port_number, ref AardvarkExt aa_ext);

[DllImport ("aardvark")]
private static extern int c_aa_close (int aardvark);

[DllImport ("aardvark")]
private static extern int c_aa_port (int aardvark);

[DllImport ("aardvark")]
private static extern int c_aa_features (int aardvark);

[DllImport ("aardvark")]
private static extern int c_aa_unique_id (int aardvark);

[DllImport ("aardvark")]
private static extern IntPtr c_aa_status_string (int status);

[DllImport ("aardvark")]
private static extern int c_aa_log (int aardvark, int level, int handle);

[DllImport ("aardvark")]
private static extern int c_aa_version (int aardvark, ref AardvarkVersion version);

[DllImport ("aardvark")]
private static extern int c_aa_configure (int aardvark, AardvarkConfig config);

[DllImport ("aardvark")]
private static extern int c_aa_target_power (int aardvark, byte power_mask);

[DllImport ("aardvark")]
private static extern int c_aa_sleep_ms (int milliseconds);

[DllImport ("aardvark")]
private static extern int c_aa_async_poll (int aardvark, int timeout);

[DllImport ("aardvark")]
private static extern int c_aa_i2c_free_bus (int aardvark);

[DllImport ("aardvark")]
private static extern int c_aa_i2c_bitrate (int aardvark, int bitrate_khz);

[DllImport ("aardvark")]
private static extern int c_aa_i2c_read (int aardvark, short slave_addr, AardvarkI2cFlags flags, short num_bytes, ref byte data_in);

[DllImport ("aardvark")]
private static extern int c_aa_i2c_read_ext (int aardvark, short slave_addr, AardvarkI2cFlags flags, short num_bytes, ref byte data_in, ref short num_read);

[DllImport ("aardvark")]
private static extern int c_aa_i2c_write (int aardvark, short slave_addr, AardvarkI2cFlags flags, short num_bytes, byte[] data_out);

[DllImport ("aardvark")]
private static extern int c_aa_i2c_write_ext (int aardvark, short slave_addr, AardvarkI2cFlags flags, short num_bytes, byte[] data_out, ref short num_written);

[DllImport ("aardvark")]
private static extern int c_aa_i2c_slave_enable (int aardvark, byte addr, short maxTxBytes, short maxRxBytes);

[DllImport ("aardvark")]
private static extern int c_aa_i2c_slave_disable (int aardvark);

[DllImport ("aardvark")]
private static extern int c_aa_i2c_slave_set_response (int aardvark, byte num_bytes, byte[] data_out);

[DllImport ("aardvark")]
private static extern int c_aa_i2c_slave_write_stats (int aardvark);

[DllImport ("aardvark")]
private static extern int c_aa_i2c_slave_read (int aardvark, ref byte addr, short num_bytes, ref byte data_in);

[DllImport ("aardvark")]
private static extern int c_aa_i2c_slave_write_stats_ext (int aardvark, ref short num_written);

[DllImport ("aardvark")]
private static extern int c_aa_i2c_slave_read_ext (int aardvark, ref byte addr, short num_bytes, ref byte data_in, ref short num_read);

[DllImport ("aardvark")]
private static extern int c_aa_i2c_monitor_enable (int aardvark);

[DllImport ("aardvark")]
private static extern int c_aa_i2c_monitor_disable (int aardvark);

[DllImport ("aardvark")]
private static extern int c_aa_i2c_monitor_read (int aardvark, short num_bytes, ref short data);

[DllImport ("aardvark")]
private static extern int c_aa_i2c_pullup (int aardvark, byte pullup_mask);

[DllImport ("aardvark")]
private static extern int c_aa_spi_bitrate (int aardvark, int bitrate_khz);

[DllImport ("aardvark")]
private static extern int c_aa_spi_configure (int aardvark, AardvarkSpiPolarity polarity, AardvarkSpiPhase phase, AardvarkSpiBitorder bitorder);

[DllImport ("aardvark")]
private static extern int c_aa_spi_write (int aardvark, short num_bytes, byte[] data_out, ref byte data_in);

[DllImport ("aardvark")]
private static extern int c_aa_spi_slave_enable (int aardvark);

[DllImport ("aardvark")]
private static extern int c_aa_spi_slave_disable (int aardvark);

[DllImport ("aardvark")]
private static extern int c_aa_spi_slave_set_response (int aardvark, byte num_bytes, byte[] data_out);

[DllImport ("aardvark")]
private static extern int c_aa_spi_slave_read (int aardvark, short num_bytes, ref byte data_in);

[DllImport ("aardvark")]
private static extern int c_aa_spi_master_ss_polarity (int aardvark, AardvarkSpiSSPolarity polarity);

[DllImport ("aardvark")]
private static extern int c_aa_gpio_direction (int aardvark, byte direction_mask);

[DllImport ("aardvark")]
private static extern int c_aa_gpio_pullup (int aardvark, byte pullup_mask);

[DllImport ("aardvark")]
private static extern int c_aa_gpio_get (int aardvark);

[DllImport ("aardvark")]
private static extern int c_aa_gpio_set (int aardvark, byte value);

[DllImport ("aardvark")]
private static extern int c_aa_gpio_change (int aardvark, short timeout);


} // class AardvarkApi

} // namespace TotalPhase