AD5933 Console Application#

Supported Hardware#

Supported Devices:

Supported Evaluation Boards:

Supported Carrier Boards:

Introduction#

The AD5933 Mbed support software (also supports AD5934) can be used as a starting point for developing your own code for Analog Devices AD5933 products in your own environment utilizing the benefits of the Mbed platform. Analog Devices is an MBED Partner and develops code on the platform for multiple products. The Analog Devices Mbed code-repo can be found in the links below.

This guide will focus on the Analog Devices SDP-K1 controller board, as it is directly compatible with the AD5933 family of evaluation boards and is an MBED-Enabled device. Customers are of course, not limited to using the SDP-K1 board for code development, given that any ARM-based, MBED-enabled board that satisfies a small set of requirements can use the provided code and it will work with only minor changes to the source (see below).

This guide uses the Pmod IA evaluation board. This is a convenient, inexpensive path to evaluating the AD5933.

Hardware Connections#

The SDP-K1 board has two ways to connect to most ADI evaluation boards, it can use the 120-pin SDP connector on the underside of the board, or the Arduino connector can be used together with jumper wires as described below. Currently an ADI evaluation board with an SDP connector does not exist for the AD5933. As such, it is necessary to connect to the Arduino headers using short jumper wires.

The Getting Started with Mbed page describes the Arduino Uno Header, the SDP connector, pinouts and other information related to understanding the SDP-K1 controller board.

The SDP-K1 can operate with the 120-pin SDP connector of the evaluation board supports it, or, as in this case, it can also use the Arduino header pins (or indeed any available I2C port on the controller board) using wires to the evaluation board. This is shown here for the SDP-K1 board connected to the Digilent Pmod IA evaluation board using the Arduino Header, but different boards might have their SPI/I2C/GPIO ports exposed differently. The pins on the Arduino header must be shorted to the evaluation board as follows. The pin mappings for these are controlled in the app_config.h file and should match your controller board.

Arduino PIN

MBED NAME

Pmod IA PIN

D15

I2C_SCL

SCLK/A0

D14

I2C_SDA

SDO/SDA

Note

If using the Arduino header pins, compile the software only after adding the #define ARDUINO to app_config.h (set by default)

../../../_images/ad5933_hardware_connections.jpg

Note

One thing to note here is that power and ground for the evaluation need to be provided and can be conveniently taken from the Arduino header as shown above. If using a different evaluation board to the DIGILENT PMOD IA, then consult the relevant evaluation board guides available through the product-page for your selected board.

AD5933 Mbed Firmware#

This guide focuses on the SDP-K1, connected to the Pmod IA evaluation board, but it should be general enough to cover any compatible controller board (the controller board should be Mbed-enabled, and expose I2C and some GPIO’s).

The software described below allows for an Mbed enabled controller board to be connected with the Pmod IA. Unmodified, the code will communicate over any serial terminal emulator (CoolTerm, putty, etc) using the UART provided by the controller board over USB.

Build Guide#

Build Prerequisites#

Prior to building a firmware project, it is required to set up an environment so that the build process may find the necessary tools (compiler, linker, SDK etc.). Use the following steps to prepare your environment for building firmware projects for respective platform.

  • Clone Precision Converters Firmware repository with the –recursive flag (not needed if building with web IDE for Mbed platform):

git clone --recursive https://github.com/analogdevicesinc/precision-converters-firmware

  • If however you’ve already cloned the repository without the –recursive flag, you may initialize all the submodules in an existing cloned repo with:

git submodule update --recursive --init

  • Install Make in the root of ‘C’ drive without any spaces in the installation path. The path must be C:\GnuWin32\…. Add this path into the system environmental path variable (as shown in below screenshot).

  • Install Git and add a path of C:\Program Files\Git\usr\bin\ directory into system environmental path variable (please verify your git installation path is correct).

  • Install Mbed CLI 1 as per guide here.

  • Install GNU Arm Embedded compiler (for the development, 9-2019-q4-major version is used) and add a path of GNU Arm Embedded Toolchain bin directory into the system environmental path variable (as shown in below screenshot).

  • Configure the compiler location with Mbed CLI. This can be carried out by running the mbed config -G GCC_ARM_PATH <path-to-your-gcc-compiler> in Command Prompt. For example you can run mbed config -G GCC_ARM_PATH “C:\Program Files (x86)\GNU Tools ARM Embedded\9 2019-q4-major\bin” in command prompt. It will set mentioned compiler path to all the Mbed Projects.

Building a project#

Once the build enviornment is setup, follow the guide below to build your project and generate executable file (.bin/.hex)

  • Clone the Precision Converters Firmware repository into Keil Studio using “File->clone…” menu.

  • Once the project repository is imported, wait until all library dependencies are imported as shown in below screenshot. Now, open the ‘.medignore’ file present in the root directory of repository. Add comment syntax (two forward slashes) in front of the project name which you want to build. This will ignore all other projects and build only the comment syntax selected project.

  • Select the target device (default used for development is SDP-K1) and click on ‘Clean build’ option to build the project. After a successful build a binary will be downloaded to your computer- store this on your drive. Drag and drop this binary to the USB drive hosted by your controller board to flash the MCU.

Note

If you intend to build different project, then modify the .medignore file in the root directory as mentioned in step2 and clean build project as mentioned in step3

  • Open Git bash and change current directory to project directory (eg. precision-converters-firmware/projects/ad4130_iio directory) which you want to build.

  • Type make on the git bash command prompt to build a project.

  • After successful build, binary file will be created into the Project_Name/build directory.

  • If you want to clean build, type make reset on git bash command which deletes all generated build files for the given project.

Note

Default TARGET_BOARD is SDP_K1 and COMPILER is GCC_ARM. Current Make based build only support GCC_ARM Compiler.

  • By default project is built for “SDP_K1” Board and “GCC_ARM” Compiler. If you want to build for other Mbed Board, For example If you want to build the project for “DISCO_F769NI” Board then run make TARGET_BOARD=DISCO_F769NI command in git bash command prompt. If you want to clean build, run make reset TARGET_BOARD=DISCO_F769NI command to delete the generated build files for the given project.

  • Open the respective project directory by navigating into the “precision_converters_firmware/projects/” folder.

  • In the “STM32” folder present within the project directory, double click and open the .ioc file present within.

  • Click on the “Generate Code” option seen on the top right corner

  • Upon successful generation of drivers for the selected MCU, the autogenerated files would be seen in the same directory where the .ioc file was present. Double click and open the “.project” file seen in the list of files

  • After the project is loaded to the STM32CubeIDE, unfold the adxxxx_iio project seen in the project explorer, right click the “app” folder, select “Settings” under the “C/C++ Build” section on the left pane and un-check the “Exclude resources from build” checkbox. This would ensure that the project specific files are included by the build system

  • In order to choose STM32 platform in the firmware, select the “ACTIVE_PLATFORM” as “STM32_PLATFORM” in the app_config.h from the respective project. Alternately , add compiler flag “ACTIVE_PLATFORM=value of STM32_PLATFORM in app_config.h” for selecting stm32 platform.

  • Add compiler flags “-u _printf_float” to the project settings.

  • Program by clicking on the “Run adxxxx_iio” option seen or by performing a copy->paste option of the .hex file seen in the STM32/Debug folder

Running a project#

Once the firmware build is successful and binary file is generated, copy the generated binary into USB drive hosted by your MCU board (e.g. USB drive hosted by SDP-K1 board on windows). This will flash the binary file into MCU present on the controller board. Programming might vary based on the tools used for building a project. The ‘Project Build’ section above talks about this exception at the end of all build steps.

Quick Start#

If you have some familiarity with the Mbed platform, the following is a basic list of steps required to start running the code, see below for more detail:

  • Connect the evaluation-board to the Mbed-enabled controller board.

  • Connect the controller board to your computer over USB.

  • Follow the steps mentioned in the Build Guide section above (Edit app_config.h file (defaults to SDP connector and AD5686R device) if evaluating any other device).

  • Start up a serial terminal emulator (e.g. Tera Term)

    • Find the com-port your controller board is connected on and select it.

    • Set the baud-rate for 230400

    • Reset the controller board and connect.

  • Use the menu provided over the terminal window to access the evaluation board.

Using the Firmware#

The firmware is delivered as a basic, text-based user-interface that operates through a UART on the controller board using the same USB cable that is used to flash the firmware to the boards. Any terminal-emulator should work, but it is not possible for Analog Devices to test everyone. It is necessary to connect a serial terminal-emulator to interact with the running firmware.

Here CoolTerm is used as an example, Analog Devices does not endorse any particular program for this, but CoolTerm works well and is made freely available, other terminals such as Tera Term, or PuTTY will work just as well. Set the baud-rate for 115200 and keep the defaults for everything else. The actual values used can be found by looking at the source code in main.cpp

The software is provided as a demo. The demo covers the essential operation of the AD5933 and it is hoped to be a good starting point for developing your own firmware. The code is also written with a view to keeping things simple, you do not have to be a coding-ninja to understand and expand upon the delivered functions.

It is hoped that the most common functions of the AD5933 family are coded, but it’s likely that some special functionality is not implemented.

The software comes with an app_config.h file which allows the pins for the I2C interface to be selected.

  • Configure the pins you want to use to connect the controller board to the evaluation board.

  • They default to the I2C exposed on the Arduino header.

AD5933 DEMO#

This demo will keep things simple by only using resistances. The AD5933 operates is a ratiometric device and because of this it requires a calibration gain-factor to be calculated. This demo will use a 200KΩ calibration and will test the operation of the impedance calculation with a different resistance (300KΩ is arbitrarily chosen).

Note

Use Command option 1 to read the temperature from the AD5933. This ensures basic connectivity is established. The firmware does a temperature read following a board reset.

Step 1: Configure System

  1. Place a 200KΩ resistance between the 2 SMB connectors on the PMOD IA

  2. Select Option 2 and provide the data will prompted, example for 200KΩ is done here.

    1. Select option 3: 1Vpp typical (to ensure amplifiers are not saturated)

    2. Select PGA gain of X1

    3. Select Internal Clock

    4. Enter start frequency of 10Khz (this is arbitrary, as we are using only resistances for the demo)

    5. Enter frequency increment of 10 (again arbitrary)

    6. Give the number of increments (20 for example)

    7. Let the number of settling sample = 5

    8. Settling-time multiplier = X1

  3. The software will report the values chosen - this configuration only has to be done once, the values are stored, both in the software and on the AD5933.

Step 2: Calculate the Gain Factor The gain factor is the calibration for the signal path and only needs to be set once.

  1. Select option 3 from the main-menu

  2. Enter your calibration resistance, in Ohms - e.g 200000

  3. The calculated gain-factor will be returned and stored in software and on-chip

Step 3: Calculate unknown impedance Any impedance can now be placed between the SMB connectors on the PMOD IA board and option 4 from the main-menu will perform a sweep according to the settings configured in Step 1. The results will be displayed on the terminal. For this demo the 200KΩ was replaced with a 300KΩ and an impedance sweep performed. It returned the results shown below. Consult the extensive documentation available on the product page to help understand the process

Support#

Feel free to ask questions in the EngineerZone