Revision 2:0897873979f3, committed 2019-09-05

Comitter:

MitchAD

Date:

Thu Sep 05 20:50:43 2019 +0000

Parent:

1:cbad662d8c2c

Commit message:

Initial commit for the AD7124 Example Program

Changed in this revision

--- a/AD7124_no_OS.lib	Wed Sep 04 22:14:13 2019 +0000
+++ b/AD7124_no_OS.lib	Thu Sep 05 20:50:43 2019 +0000
@@ -1,1 +1,1 @@
-https://os.mbed.com/teams/AnalogDevices/code/AD7124_no_OS/#d18c9afa4bcb
+https://os.mbed.com/users/MitchAD/code/AD7124_no_OS/#22ed45e195a9

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ad7124_regs_configs.h	Thu Sep 05 20:50:43 2019 +0000
@@ -0,0 +1,13 @@
+#ifndef AD7124_REGS_CONFIGS_H_
+#define AD7124_REGS_CONFIGS_H_
+
+#include "ad7124.h"
+
+/*
+ * Arrays holding the info for the AD7124 registers - address, initial value,
+ * size and access type.
+ */
+extern struct ad7124_st_reg ad7124_regs_default[AD7124_REG_NO];
+extern struct ad7124_st_reg ad7124_regs_custom[AD7124_REG_NO];
+
+#endif /* AD7124_REGS_CONFIGS_H_ */
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ad7124_regs_custom.cpp	Thu Sep 05 20:50:43 2019 +0000
@@ -0,0 +1,83 @@
+/*
+   Power Mode: Low Power Mode
+   (Channel #, Enable, Setup, Gain, Filter, Filter Data Rate)
+   =============================================================
+   Channel 00: 1, 0, 001, Sinc4, 384
+   Channel 01: 1, 1, 002, Sinc4, 384
+   Channel 02: 0, 2, 004, Sinc4, 384
+   Channel 03: 0, 3, 008, Sinc4, 384
+   Channel 04: 0, 4, 016, Sinc4, 384
+   Channel 05: 0, 5, 032, Sinc4, 384
+   Channel 06: 0, 6, 064, Sinc4, 384
+   Channel 07: 0, 7, 128, Sinc4, 384
+   Channel 08: 0, 0, 001, Sinc4, 384
+   Channel 09: 0, 0, 001, Sinc4, 384
+   Channel 10: 0, 0, 001, Sinc4, 384
+   Channel 11: 0, 0, 001, Sinc4, 384
+   Channel 12: 0, 0, 001, Sinc4, 384
+   Channel 13: 0, 0, 001, Sinc4, 384
+   Channel 14: 0, 0, 001, Sinc4, 384
+   Channel 15: 0, 0, 001, Sinc4, 384
+
+*/
+#include "ad7124_regs_configs.h"
+
+struct ad7124_st_reg ad7124_regs_custom[AD7124_REG_NO] = {
+      {0x00, 0x000081, 1, 2},
+      {0x01, 0x000100, 2, 1},
+      {0x02, 0x7fe779, 3, 2},
+      {0x03, 0x000000, 3, 1},
+      {0x04, 0x000000, 2, 1},
+      {0x05, 0x000014, 1, 2},
+      {0x06, 0x000000, 3, 2},
+      {0x07, 0x000040, 3, 1},
+      {0x08, 0x000000, 1, 2},
+      {0x09, 0x008001, 2, 1},
+      {0x0a, 0x009043, 2, 1},
+      {0x0b, 0x002085, 2, 1},
+      {0x0c, 0x0030c7, 2, 1},
+      {0x0d, 0x004109, 2, 1},
+      {0x0e, 0x00514b, 2, 1},
+      {0x0f, 0x00618d, 2, 1},
+      {0x10, 0x0071cf, 2, 1},
+      {0x11, 0x000001, 2, 1},
+      {0x12, 0x000001, 2, 1},
+      {0x13, 0x000001, 2, 1},
+      {0x14, 0x000001, 2, 1},
+      {0x15, 0x000001, 2, 1},
+      {0x16, 0x000001, 2, 1},
+      {0x17, 0x000001, 2, 1},
+      {0x18, 0x000001, 2, 1},
+      {0x19, 0x000870, 2, 1},
+      {0x1a, 0x000871, 2, 1},
+      {0x1b, 0x000862, 2, 1},
+      {0x1c, 0x000863, 2, 1},
+      {0x1d, 0x000864, 2, 1},
+      {0x1e, 0x000865, 2, 1},
+      {0x1f, 0x000866, 2, 1},
+      {0x20, 0x000867, 2, 1},
+      {0x21, 0x060180, 3, 1},
+      {0x22, 0x060180, 3, 1},
+      {0x23, 0x060180, 3, 1},
+      {0x24, 0x060180, 3, 1},
+      {0x25, 0x060180, 3, 1},
+      {0x26, 0x060180, 3, 1},
+      {0x27, 0x060180, 3, 1},
+      {0x28, 0x060180, 3, 1},
+      {0x29, 0x800000, 3, 1},
+      {0x2a, 0x800000, 3, 1},
+      {0x2b, 0x800000, 3, 1},
+      {0x2c, 0x800000, 3, 1},
+      {0x2d, 0x800000, 3, 1},
+      {0x2e, 0x800000, 3, 1},
+      {0x2f, 0x800000, 3, 1},
+      {0x30, 0x800000, 3, 1},
+      {0x31, 0x555260, 3, 1},
+      {0x32, 0x555260, 3, 1},
+      {0x33, 0x555260, 3, 1},
+      {0x34, 0x555260, 3, 1},
+      {0x35, 0x555260, 3, 1},
+      {0x36, 0x555260, 3, 1},
+      {0x37, 0x555260, 3, 1},
+      {0x38, 0x555260, 3, 1},
+};

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ad7124_regs_default.cpp	Thu Sep 05 20:50:43 2019 +0000
@@ -0,0 +1,61 @@
+#include "ad7124_regs_configs.h"
+
+struct ad7124_st_reg ad7124_regs_default[AD7124_REG_NO] = {
+    {0x00, 0x00,   1, 2}, /* AD7124_Status */
+    {0x01, 0x0100, 2, 1}, /* AD7124_ADC_Control */
+    {0x02, 0x0000, 3, 2}, /* AD7124_Data */
+    {0x03, 0x0000, 3, 1}, /* AD7124_IOCon1 */
+    {0x04, 0x0000, 2, 1}, /* AD7124_IOCon2 */
+    {0x05, 0x02,   1, 2}, /* AD7124_ID */
+    {0x06, 0x0000, 3, 2}, /* AD7124_Error */
+    {0x07, 0x0040, 3, 1}, /* AD7124_Error_En */
+    {0x08, 0x00,   1, 2}, /* AD7124_Mclk_Count */
+    {0x09, 0x8001, 2, 1}, /* AD7124_Channel_0 */
+    {0x0A, 0x9043, 2, 1}, /* AD7124_Channel_1 */
+    {0x0B, 0x2085, 2, 1}, /* AD7124_Channel_2 */
+    {0x0C, 0x30C7, 2, 1}, /* AD7124_Channel_3 */
+    {0x0D, 0x4109, 2, 1}, /* AD7124_Channel_4 */
+    {0x0E, 0x514B, 2, 1}, /* AD7124_Channel_5 */
+    {0x0F, 0x618D, 2, 1}, /* AD7124_Channel_6 */
+    {0x10, 0x71CF, 2, 1}, /* AD7124_Channel_7 */
+    {0x11, 0x0001, 2, 1}, /* AD7124_Channel_8 */
+    {0x12, 0x0001, 2, 1}, /* AD7124_Channel_9 */
+    {0x13, 0x0001, 2, 1}, /* AD7124_Channel_10 */
+    {0x14, 0x0001, 2, 1}, /* AD7124_Channel_11 */
+    {0x15, 0x0001, 2, 1}, /* AD7124_Channel_12 */
+    {0x16, 0x0001, 2, 1}, /* AD7124_Channel_13 */
+    {0x17, 0x0001, 2, 1}, /* AD7124_Channel_14 */
+    {0x18, 0x0001, 2, 1}, /* AD7124_Channel_15 */
+    {0x19, 0x0870, 2, 1}, /* AD7124_Config_0 */
+    {0x1A, 0x0871, 2, 1}, /* AD7124_Config_1 */
+    {0x1B, 0x0862, 2, 1}, /* AD7124_Config_2 */
+    {0x1C, 0x0863, 2, 1}, /* AD7124_Config_3 */
+    {0x1D, 0x0864, 2, 1}, /* AD7124_Config_4 */
+    {0x1E, 0x0865, 2, 1}, /* AD7124_Config_5 */
+    {0x1F, 0x0866, 2, 1}, /* AD7124_Config_6 */
+    {0x20, 0x0867, 2, 1}, /* AD7124_Config_7 */
+    {0x21, 0x060180, 3, 1}, /* AD7124_Filter_0 */
+    {0x22, 0x060180, 3, 1}, /* AD7124_Filter_1 */
+    {0x23, 0x060180, 3, 1}, /* AD7124_Filter_2 */
+    {0x24, 0x060180, 3, 1}, /* AD7124_Filter_3 */
+    {0x25, 0x060180, 3, 1}, /* AD7124_Filter_4 */
+    {0x26, 0x060180, 3, 1}, /* AD7124_Filter_5 */
+    {0x27, 0x060180, 3, 1}, /* AD7124_Filter_6 */
+    {0x28, 0x060180, 3, 1}, /* AD7124_Filter_7 */
+    {0x29, 0x800000, 3, 1}, /* AD7124_Offset_0 */
+    {0x2A, 0x800000, 3, 1}, /* AD7124_Offset_1 */
+    {0x2B, 0x800000, 3, 1}, /* AD7124_Offset_2 */
+    {0x2C, 0x800000, 3, 1}, /* AD7124_Offset_3 */
+    {0x2D, 0x800000, 3, 1}, /* AD7124_Offset_4 */
+    {0x2E, 0x800000, 3, 1}, /* AD7124_Offset_5 */
+    {0x2F, 0x800000, 3, 1}, /* AD7124_Offset_6 */
+    {0x30, 0x800000, 3, 1}, /* AD7124_Offset_7 */
+    {0x31, 0x500000, 3, 1}, /* AD7124_Gain_0 */
+    {0x32, 0x500000, 3, 1}, /* AD7124_Gain_1 */
+    {0x33, 0x500000, 3, 1}, /* AD7124_Gain_2 */
+    {0x34, 0x500000, 3, 1}, /* AD7124_Gain_3 */
+    {0x35, 0x500000, 3, 1}, /* AD7124_Gain_4 */
+    {0x36, 0x500000, 3, 1}, /* AD7124_Gain_5 */
+    {0x37, 0x500000, 3, 1}, /* AD7124_Gain_6 */
+    {0x38, 0x500000, 3, 1}, /* AD7124_Gain_7 */
+};
\ No newline at end of file

--- a/main.cpp	Wed Sep 04 22:14:13 2019 +0000
+++ b/main.cpp	Thu Sep 05 20:50:43 2019 +0000
@@ -34,25 +34,1189 @@
 
 2019-01-10-7CBSD SLA
 
+                              USING THE PROGRAM
+ * While using this program, the user has the option of selecting between two
+ * different configurations: Default and Custom. These configurations represent
+ * two unique register maps which can be altered by the user throughout using
+ * the program. There are sixteen unique channels and eight unique setups
+ * associated with the AD7124. Each of the channels is assigned a setup which
+ * includes fields such as gain and filter options associated with it. The
+ * following guide will detail how to get the most out of the program.
+ *
+ * After running the program.
+ * 1) Press menu item (11) "Print Device Register Map (User Friendly Mode)".
+ * This will show you each channel's information. There are only two channels
+ * enabled, one using setup "0" and the other using setup "1".
+ *
+ * 2) Press menu item (3) "Assign Channel Setup"
+ * You can now assign any channel any setup continuously until you elect to quit.
+ * Select channel (0) and assign it to setup (2), then quit (16).
+ *
+ * 3) Press menu item (11) "Print Device Register Map (User Friendly Mode)".
+ * You can now see that channel "0" uses setup "2".
+ *
+ * 4) Press menu item (7) "Select Filter/Filter Data Rate".
+ * Select setup (2) to change and then change the filter to Fast Settling (3)
+ * and select data rate (128).
+ *
+ * 5) Press menu item (11) "Print Device Register Map (User Friendly Mode)".
+ * As you can see, every channel with setup "2" has had their filters and filter
+ * data rate changed.
+ * ***NOTE***
+ * When modifying a setup, it will affect every channel using that setup
+ *
+ * 6) Press menu item (12) "Print Device Register Map (Raw Data Mode)"
+ * Lets say you found a configuration that works for your application, you can
+ * now directly copy the current configuration's register map and paste it into
+ * the "ad7124_regs_custom.cpp" file to "save" that configuration for future use.
+ * This allows the user to further modify configurations when tweaking is needed
+ * so that the complete flexibilty of the AD7124 is at the hands of the particular
+ * application.
+ *
+ * Additional Information:
+ * There are many other features of this part that are not in this program.
+ * The way that the structs are set up, it is easy to add additional
+ * functionality for features such as "Analog positive/negative input" and
+ * "Clock source". Feel free to modify this program to suit your needs even
+ * further.
  */
 
+/***Libraries***/
+#include <stdio.h>
+#include <string.h>
+
 #include "mbed.h"
+#include "platform_drivers.h"
 
-Serial pc(USBTX, USBRX); // tx, rx
-DigitalOut awakeSignal(LED4);
-DigitalOut led1(LED1);
+#include "ad7124.h"
+#include "ad7124_regs.h"
+#include "ad7124_regs_configs.h"
+
+/***Defines for SPI Protocol***/
+#define SPI_PLATFORM                   MBED
+#define SPI_TYPE                       GENERIC_SPI
+#define SPI_ID                         0
+#define SPI_MAX_FREQUENCY              1500000
+#define SPI_MODE                       SPI_MODE_3
+#define SPI_POLL_COUNT                 10000
+
+/***Defines for UART Protocol***/
+#define BAUD_RATE                      115200
+
+/***Defines for Code to Voltage***/
+#define VREF                           2.5
+#define NUM_BITS                       24
+
+/***Defines for Active Channels Array***/
+#define NUM_OF_CHANNELS                16
+#define NUM_OF_SETUPS                  8
+
+/***Defines for Operating Modes***/
+#define CONTINOUS_CONV_MODE            0x0
+#define SINGLE_CONV_MODE               0x1
+#define STANDBY_MODE                   0x2
+#define POWER_DOWN_MODE                0x3
+#define IDLE_MODE                      0x4
+#define INTERNAL_ZERO_SCALE            0x5
+#define INTERNAL_FULL_SCALE            0x6
+#define SYSTEM_ZERO_SCALE              0x7
+#define SYSTEM_FULL_SCALE              0x8
+
+/***Defines for Power Modes***/
+#define LOW_POWER_MODE                 0x0
+#define MED_POWER_MODE                 0x1
+#define HIGH_POWER_MODE                0x2
+
+/***Defines for Filters***/
+#define SINC4                          0x0
+#define SINC3                          0x2
+#define FAST_SETTLING                  0x4
+#define FAST_SETTLING_SINC3            0x5
+#define POST                           0x7
+
+/***Defines for Gains***/
+#define GAIN_1                         0x0
+#define GAIN_2                         0x1
+#define GAIN_4                         0x2
+#define GAIN_8                         0x3
+#define GAIN_16                        0x4
+#define GAIN_32                        0x5
+#define GAIN_64                        0x6
+#define GAIN_128                       0x7
+
+/***Defines for Register Reads***/
+#define POWER_MODE_READ(x)             (((x) >> 6) & 0x3)
+#define GAIN_READ(x)                   (((x) >> 0) & 0x7)
+#define FILTER_READ(x)                 (((x) >> 21) & 0x7)
+#define DATA_RATE_READ(x)              (((x) >> 0) & 0x7FF)
+#define SETUP_READ(x)                  (((x) >> 12) & 0x7)
+
+/***Configuration Defines***/
+#define DEF_CONFIG                     0
+#define CUSTOM_CONFIG                  1
+
+/*Connecting Hardware Pin Names
+  to Software Variables*/
+DigitalOut SS(SDP_SPI_CS_A);
+mbed::SPI spi(SDP_SPI_MOSI, SDP_SPI_MISO, SDP_SPI_SCK);
+mbed::I2C i2c(SDP_I2C_SDA, SDP_I2C_SCL);
+
+/*Configure and instantiate UART protocol
+  and baud rate*/
+Serial port(USBTX, USBRX, BAUD_RATE);
+
+/***Global Variables***/
+uint8_t adc_conf = DEF_CONFIG;
 
-#define SLEEP_TIME                  500 // (msec)
+const char* conf_strings[] =
+{"Default Configuration","Custom Configuration"};
+const char* power_strings[] =
+{"Low Power Mode","Medium Power Mode","High Power Mode"};
+const char* filter_strings[] =
+{"Sinc4","","Sinc3","","Fast Settling","Fast Settling + Sinc3","","Post"};
+
+/***Menu Function Declarations***/
+static int8_t menu_config_select(struct ad7124_dev ** dev, int8_t sel_conf);
+
+static int8_t menu_assign_setup(struct ad7124_dev * dev);
+
+static int8_t menu_enable_disable_channels(struct ad7124_dev * dev);
+
+static int8_t menu_sample_channels(struct ad7124_dev * dev);
+
+static int8_t menu_select_gain(struct ad7124_dev * dev);
+
+static int8_t menu_select_filter_options(struct ad7124_dev * dev);
+
+static int8_t menu_select_calibration(struct ad7124_dev * dev);
+
+static int8_t menu_select_power_mode(struct ad7124_dev * dev);
+
+static int8_t menu_print_ID(struct ad7124_dev * dev);
+
+static int8_t menu_print_channel_register_map_view_mode(struct ad7124_dev * dev);
+
+static int8_t menu_print_channel_register_map_raw_mode(struct ad7124_dev * dev);
+
+static int8_t menu_print_setups(struct ad7124_dev * dev);
+
+/***Support Functions***/
+static void print_title(void);
+
+static void print_prompt(void);
+
+static int8_t fill_structs(struct ad7124_dev * dev);
+
+static int8_t write_device(struct ad7124_dev * dev);
+
+static int8_t update_write_reg(struct ad7124_dev * dev, uint8_t reg, uint32_t mask, uint32_t val);
+
+static void code_to_voltage(uint32_t code, uint8_t channel);
 
-// main() runs in its own thread in the OS
+static int8_t err_detect(int8_t ret);
+
+static int8_t setup_select(uint8_t *setup);
+
+static int8_t channel_select(uint8_t *channel);
+
+/*SPI Initialization Parameters*/
+spi_init_param spi_params = {
+    SPI_PLATFORM,
+    SPI_TYPE,
+    SPI_ID,
+    SPI_MAX_FREQUENCY,
+    SPI_MODE,
+    SDP_SPI_CS_A
+};
+
+/*Struct with individual channel information*/
+struct channel_setup {
+    uint8_t setup_id;
+    bool bipolar;
+    uint8_t gain;
+    uint8_t filter;
+    uint16_t data_rate;
+};
+
+/*Struct with individual setup information*/
+struct channel_info {
+    uint8_t power_mode;
+    bool enable;
+    float sample;
+    struct channel_setup *setup;
+};
+
+/*Declaring array of 16 channels and 8 setups*/
+struct channel_info channels[NUM_OF_CHANNELS];
+struct channel_setup setups[NUM_OF_SETUPS];
+
+struct ad7124_dev * dev = NULL; /*Device Handler (AD7124)*/
+
+/* Main function
+ *
+ * Parameters: None
+ * Return Value: SUCCESS(0), FAILURE (Negative)
+ */
 int main()
 {
-    awakeSignal = 1;
-    pc.printf("Hello World!");
-    while (true) {
-        // Blink LED and wait 0.5 seconds
-        led1 = !led1;
-        wait_ms(SLEEP_TIME); 
+    uint8_t user_command;
+
+    /*Setup device handler and write register map to device from
+      the defailt configuration*/
+    int8_t connected = menu_config_select(&dev, DEF_CONFIG);
+
+    print_title();
+
+    while(err_detect(connected) != FAILURE) {
+
+        print_prompt();
+        port.scanf("%d", (int *) &user_command);
+
+        switch (user_command) {
+            case 1:
+                menu_config_select(&dev, DEF_CONFIG);
+                break;
+
+            case 2:
+                menu_config_select(&dev, CUSTOM_CONFIG);
+                break;
+
+            case 3:
+                menu_assign_setup(dev);
+                break;
+
+            case 4:
+                menu_enable_disable_channels(dev);
+                break;
+
+            case 5:
+                menu_sample_channels(dev);
+                break;
+
+            case 6:
+                menu_select_gain(dev);
+                break;
+
+            case 7:
+                menu_select_filter_options(dev);
+                break;
+
+            case 8:
+                menu_select_calibration(dev);
+                break;
+
+            case 9:
+                menu_select_power_mode(dev);
+                break;
+
+            case 10:
+                menu_print_ID(dev);
+                break;
+
+            case 11:
+                menu_print_channel_register_map_view_mode(dev);
+                break;
+
+            case 12:
+                menu_print_channel_register_map_raw_mode(dev);
+                break;
+
+            case 13:
+                menu_print_setups(dev);
+                break;
+
+            default:
+                port.printf("\t***Illegal Entry***\n\n");
+                break;
+        }
+    }
+    return FAILURE;
+}
+
+/***Function Definitions***/
+
+/* Print title of the program
+ *
+ * Parameters: None
+ * Return Value: None
+ */
+static void print_title()
+{
+    port.printf("\n*****************************************************************\n");
+    port.printf("*   EVAL-AD7124 Demonstration Program                             *\n");
+    port.printf("*                                                                 *\n");
+    port.printf("*   This program demonstrates how to interface and configure the  *\n");
+    port.printf("*   AD7124 High-Precision Sigma-Delta ADC                         *\n");
+    port.printf("*                                                                 *\n");
+    port.printf("*                                                                 *\n");
+    port.printf("*   Set the baud rate to 115200 and select the newline terminator.*\n");
+    port.printf("*                                                                 *\n");
+    port.printf("*******************************************************************\n");
+}
+
+/*Print command summary
+ *
+ *Parameters: None
+ *Return Value: None
+ */
+static void print_prompt()
+{
+    port.printf("\n\n\tMain Menu Summary\n");
+    port.printf("\tConfiguration Selected: %s\n", conf_strings[adc_conf]);
+    port.printf("\t=======================================\n");
+    port.printf("\t  1 - Select Configuration (A) - Default\n");
+    port.printf("\t  2 - Select Configuration (C) - Custom\n\n");
+    port.printf("\t  3 - Assign Channel Setup\n");
+    port.printf("\t  4 - Enable/Disable Channel\n\n");
+    port.printf("\t  5 - Sample Channel\n");
+    port.printf("\t  6 - Select Gain\n");
+    port.printf("\t  7 - Select Filter/Filter Data Rate\n");
+    port.printf("\t  8 - Select Calibration\n");
+    port.printf("\t  9 - Select Power Mode\n\n");
+    port.printf("\t 10 - Print Device ID\n");
+    port.printf("\t 11 - Print Device Register Map (User Friendly Mode)\n");
+    port.printf("\t 12 - Print Device Register Map (Raw Data Mode)\n");
+    port.printf("\t 13 - Print Setup Information\n\n");
+}
+
+/* Switch between default and custom configurations
+ *
+ * Parameters: Double pointer to device handler, configuration selection variable
+ * Return Value: SUCCESS (0) , FAILURE (Negative)
+ */
+static int8_t menu_config_select(struct ad7124_dev ** dev, int8_t sel_conf)
+{
+    int8_t ret;
+
+    /*Free device handler*/
+    ret = ad7124_remove(*dev);
+    if (err_detect(ret) == FAILURE)
+        return FAILURE;
+
+    /*Use user selected register map (default, custom)*/
+    struct ad7124_init_param ad7124_params = {
+        spi_params,
+        (sel_conf == DEF_CONFIG) ? ad7124_regs_default : ad7124_regs_custom,
+        SPI_POLL_COUNT
+    };
+
+    /*Setup device handler with corresponding register map*/
+    ret = ad7124_setup(dev, ad7124_params);
+    if (err_detect(ret) == FAILURE)
+        return FAILURE;
+
+    /*Fill up channel and setup structs with register map information*/
+    ret = fill_structs(*dev);
+    if (err_detect(ret) == FAILURE)
+        return FAILURE;
+
+    /*Switch global configuration variable*/
+    adc_conf = (sel_conf == DEF_CONFIG) ? DEF_CONFIG : CUSTOM_CONFIG;
+
+    return SUCCESS;
+}
+
+/* Assign any channel to a given setup. This channel will then use that setup's
+ * features when it is sampled. This function continues to probe the user for
+ * more channels to change the setup of until the proper "main menu" command
+ * is input.
+ *
+ * Paremeters: Device handler
+ * Return Value: SUCCESS (0), FAILURE (Negative)
+ */
+static int8_t menu_assign_setup(struct ad7124_dev * dev)
+{
+    uint8_t channel, setup;
+    int8_t ret;
+
+    /*Fill all structs with register map information from device*/
+    ret = fill_structs(dev);
+    if (err_detect(ret) == FAILURE)
+        return FAILURE;
+
+    /*Continue until user wants to quit*/
+    while (1) {
+        /*Obtain Channel*/
+        port.printf("\n\tSelect Channel to Assign Setup\n");
+        ret = channel_select(&channel);
+        if (err_detect(ret) == FAILURE)
+            return FAILURE;
+
+        /*Obtain Setup*/
+        port.printf("\n\tSelect Setup to Assign to Channel %d\n", channel);
+        ret = setup_select(&setup);
+        if (err_detect(ret) == FAILURE)
+            return FAILURE;
+
+        /*Write back to device*/
+        channels[channel].setup = &setups[setup];
+        channels[channel].setup->setup_id = setup;
+        ret = write_device(dev);
+        if (err_detect(ret) == FAILURE)
+            return FAILURE;
+    }
+}
+
+/* Offers the feature of enabling and disabling any channels that the user
+ * selects. It also continuously probes the user for more channels to
+ * enable/disable until the "main menu" command is input.
+ *
+ * Parameters: Device handler
+ * Return Value: SUCCESS(0), FAILURE (Negative)
+ */
+static int8_t menu_enable_disable_channels(struct ad7124_dev * dev)
+{
+    uint8_t channel, enable;
+    int8_t ret;
+
+    /*Fill all structs with register map information from device*/
+    ret = fill_structs(dev);
+    if (err_detect(ret) == FAILURE)
+        return FAILURE;
+
+    while (1) {
+        /*Obtain channel*/
+        port.printf("\n\tSelect Channel to Enable/Disable\n");
+        ret = channel_select(&channel);
+        if (err_detect(ret) == FAILURE)
+            return FAILURE;
+
+        /*Obtain enable/disable command*/
+        port.printf("\n\tChoose to Enable or Disable Channel %d\n", channel);
+        port.printf("\t===============================\n");
+        port.printf("\t 1 - Disable\n");
+        port.printf("\t 2 - Enable\n\n");
+        port.printf("\t 3 - Main Menu\n\n");
+
+        port.scanf("%d", (int *) &enable);
+        if (enable > 2)
+            return FAILURE;
+
+        /*Write back to device*/
+        channels[channel].enable = enable - 1;
+        ret = write_device(dev);
+        if (err_detect(ret) == FAILURE)
+            return FAILURE;
+    }
+}
+
+/* Sample all active channels and print out the corresponding voltages. The first
+ * option is single conversion mode where all the channels are sampled one after
+ * the other. The device is put into standby mode after. The next option is
+ * continuous conversion mode where all channels are sampled continuously. The user
+ * can press any key to stop the continuous sampling.
+ *
+ * Parameters: Device handler
+ * Return Value: SUCCESS (0) , FAILURE (Negative)
+ */
+static int8_t menu_sample_channels(struct ad7124_dev * dev)
+{
+    struct ad7124_st_reg *regs;
+    uint32_t bitfield_mask, temp_val, ones_mask = 0xFFFFFFFF;
+    uint8_t conversion_mode, channel, previous_channel;
+    int8_t ret;
+
+    regs = dev->regs;
+
+    /*Fill up channel and setup structs with register map information*/
+    ret = fill_structs(dev);
+    if (err_detect(ret) == FAILURE)
+        return FAILURE;
+
+    port.printf("\n\tSelect Conversion Mode\n");
+    port.printf("\t=======================================\n");
+    port.printf("\t 1 - Single Conversion Mode\n");
+    port.printf("\t 2 - Continuous Conversion Mode\n");
+    port.printf("\t 3 - Main Menu\n\n");
+
+    /*Obtain user input and check validity*/
+    port.scanf("%d", (int *) &conversion_mode);
+    if ((conversion_mode < 1) || (conversion_mode > 2))
+        return FAILURE;
+
+    /*Update ADC operating mode to single/continous conversion mode*/
+    bitfield_mask = AD7124_ADC_CTRL_REG_MODE(ones_mask);
+    temp_val = (conversion_mode == SINGLE_CONV_MODE) ? AD7124_ADC_CTRL_REG_MODE(SINGLE_CONV_MODE):
+               AD7124_ADC_CTRL_REG_MODE(CONTINOUS_CONV_MODE);
+    ret = update_write_reg(dev, AD7124_ADC_Control, bitfield_mask, temp_val);
+    if (err_detect(ret) == FAILURE)
+        return FAILURE;
+
+    /*Continue to sample*/
+    while (1) {
+
+        /*Wait for conversion complete, then obtain sample*/
+        ad7124_wait_for_conv_ready(dev, dev->spi_rdy_poll_cnt);
+        ret = ad7124_read_register(dev, &regs[AD7124_Data]);
+        if (err_detect(ret) == FAILURE)
+            return FAILURE;
+
+        /*Save previous channel*/
+        previous_channel = channel;
+
+        /*Read status register to find out which channel was sampled*/
+        ret = ad7124_read_register(dev, &regs[AD7124_Status]);
+        if (err_detect(ret) == FAILURE)
+            return FAILURE;
+
+        channel = AD7124_STATUS_REG_CH_ACTIVE(regs[AD7124_Status].value);
+
+        /*Print out samples if a new channel was sampled*/
+        if (channel != previous_channel) {
+            code_to_voltage(regs[AD7124_Data].value, channel);
+            port.printf("Channel %d: %f\n", channel, channels[channel].sample);
+        }
+        
+        /*In all modes, print out conversions until user says stop*/
+        if (!port.readable())
+            return SUCCESS;
     }
 }
 
+/* Updates the gain of the setup selected.
+ *
+ * Parameters: Device handler
+ * Return Value: SUCCESS (0), FAILURE (Negative)
+ */
+static int8_t menu_select_gain(struct ad7124_dev * dev)
+{
+    uint8_t setup, gain;
+    int8_t ret;
+
+    /*Fill all structs with register map information from device*/
+    ret = fill_structs(dev);
+    if (err_detect(ret) == FAILURE)
+        return FAILURE;
+
+    port.printf("Select Setup to Change the Gain of\n");
+    ret = setup_select(&setup);
+    if (err_detect(ret) == FAILURE)
+        return FAILURE;
+
+    port.printf("Select the Gain to Assign to Setup %d\n", setup);
+    port.printf("\t=======================================\n");
+    port.printf("\t 1 - Gain 1\n");
+    port.printf("\t 2 - Gain 2\n");
+    port.printf("\t 3 - Gain 4\n");
+    port.printf("\t 4 - Gain 8\n");
+    port.printf("\t 5 - Gain 16\n");
+    port.printf("\t 6 - Gain 32\n");
+    port.printf("\t 7 - Gain 64\n");
+    port.printf("\t 8 - Gain 128\n");
+    port.printf("\t 9 - Main Menu\n\n");
+
+    port.scanf("%d", (int *) &gain);
+    if (gain > 8)
+        return FAILURE;
+
+    /*Write to device*/
+    setups[setup].gain = gain-1;
+    ret = write_device(dev);
+    if (err_detect(ret) == FAILURE)
+        return FAILURE;
+
+    return SUCCESS;
+}
+
+/* Updates the filter options of the ADC for a given setup. The user selects
+ * the filter and the data rate of the filter. Also updates the data rate of the
+ * filter selected.
+ *
+ * Parameters: Device handler
+ * Return Value: SUCCESS (0), FAILURE (Negative)
+ */
+static int8_t menu_select_filter_options(struct ad7124_dev * dev)
+{
+    uint8_t setup, filter;
+    uint16_t data_rate;
+    int8_t ret;
+
+    /*Fill all structs with register map information from device*/
+    ret = fill_structs(dev);
+    if (err_detect(ret) == FAILURE)
+        return FAILURE;
+
+    port.printf("Select Setup to Change the Filter of\n");
+    ret = setup_select(&setup);
+    if (err_detect(ret) == FAILURE)
+        return FAILURE;
+
+    port.printf("\n\tSelect Filter\n");
+    port.printf("\t=======================================\n");
+    port.printf("\t 1 - Sinc4\n");
+    port.printf("\t 2 - Sinc3\n");
+    port.printf("\t 3 - Fast Settling\n");
+    port.printf("\t 4 - Fast Settling + Sinc3\n");
+    port.printf("\t 5 - Post\n");
+    port.printf("\t 6 - Main Menu\n\n");
+
+    port.scanf("%d", (int *) &filter);
+    if ((filter < 1) || (filter > 5))
+        return FAILURE;
+
+    switch(filter) {
+        case 1:
+            setups[setup].filter = SINC4;
+            break;
+
+        case 2:
+            setups[setup].filter = SINC3;
+            break;
+
+        case 3:
+            setups[setup].filter = FAST_SETTLING;
+            break;
+
+        case 4:
+            setups[setup].filter = FAST_SETTLING_SINC3;
+            break;
+
+        case 5:
+            setups[setup].filter = POST;
+            break;
+
+        default:
+            port.printf("\t***Illegal Entry***\n\n");
+            return FAILURE;
+    }
+
+    /*Write back to device*/
+    ret = write_device(dev);
+    if (err_detect(ret) == FAILURE)
+        return FAILURE;
+
+    port.printf("Select Data Rate for the Filter\n");
+    port.printf("\t=======================================\n");
+    port.printf("\t (1-2047)\n");
+    port.printf("\t 2048 - Main Menu\n");
+
+    port.scanf("%d", (int *) &data_rate);
+    if ((data_rate < 1) || (data_rate > 2047))
+        return FAILURE;
+
+    /*Write back to device*/
+    setups[setup].data_rate = data_rate;
+    ret = write_device(dev);
+    if (err_detect(ret) == FAILURE)
+        return FAILURE;
+
+    return SUCCESS;
+}
+
+/* Select one of the four claibration modes of the ADC. There are specific
+ * things that the user must do before selecting any of the calibrations.
+ * These are outlined on page 53 of the data sheet.
+ *
+ * Parameters: Device handler
+ * Return Value: SUCCESS (0), FAILURE (Negative)
+ */
+static int8_t menu_select_calibration(struct ad7124_dev * dev)
+{
+    uint32_t bitfield_mask, temp_val, ones_mask = 0xFFFFFFFF;
+    uint8_t channel, calibration;
+    bool active_channels[NUM_OF_CHANNELS];
+    int8_t ret;
+
+    ret = channel_select(&channel);
+    if (err_detect(ret) == FAILURE)
+        return FAILURE;
+
+    port.printf("\n\tSelect Calibration Mode\n");
+    port.printf("\t=======================================\n");
+    port.printf("\t 1 - Internal Zero Scale\n");
+    port.printf("\t 2 - Internal Full Scale\n");
+    port.printf("\t 3 - System Zero Scale\n");
+    port.printf("\t 4 - System Full Scale\n");
+    port.printf("\t 5 - Main Menu\n\n");
+
+    port.scanf("%d", (int *) &calibration);
+    if ((calibration < 1) || (calibration > 4))
+        return FAILURE;
+
+    /*Disable all channels except for one being calibrated*/
+    for (int channel_index = 0; channel_index < NUM_OF_CHANNELS; channel_index++) {
+        if (channel != channel_index)
+            if (channels[channel_index].enable == true)
+                active_channels[channel_index] = true;
+        channels[channel_index].enable = false;
+    }
+    ret = write_device(dev);
+    if (err_detect(ret) == FAILURE)
+        return FAILURE;
+
+    /*Put into low power mode*/
+    bitfield_mask = AD7124_ADC_CTRL_REG_POWER_MODE(ones_mask);
+    temp_val = AD7124_ADC_CTRL_REG_POWER_MODE(LOW_POWER_MODE);
+    ret = update_write_reg(dev, AD7124_ADC_Control, bitfield_mask, temp_val);
+    if (err_detect(ret) == FAILURE)
+        return FAILURE;
+
+    /*Put into standy mode*/
+    bitfield_mask = AD7124_ADC_CTRL_REG_MODE(ones_mask);
+    temp_val = AD7124_ADC_CTRL_REG_MODE(LOW_POWER_MODE);
+    ret = update_write_reg(dev, AD7124_ADC_Control, bitfield_mask, temp_val);
+    if (err_detect(ret) == FAILURE)
+        return FAILURE;
+
+    /*Switch based off calibration mode selected*/
+    bitfield_mask = AD7124_ADC_CTRL_REG_MODE(ones_mask);
+    switch(calibration) {
+        case 1:
+            temp_val = AD7124_ADC_CTRL_REG_MODE(INTERNAL_ZERO_SCALE);
+            break;
+
+        case 2:
+            update_write_reg(dev, channels[channel].setup->setup_id + AD7124_Gain_0, ones_mask, 0x800000);
+            temp_val = AD7124_ADC_CTRL_REG_MODE(INTERNAL_FULL_SCALE);
+            break;
+
+        case 3:
+            temp_val = AD7124_ADC_CTRL_REG_MODE(SYSTEM_ZERO_SCALE);
+            break;
+
+        case 4:
+            temp_val = AD7124_ADC_CTRL_REG_MODE(SYSTEM_FULL_SCALE);
+            break;
+
+        default:
+            port.printf("\t***Illegal Entry***\n\n");
+            return FAILURE;
+    }
+    ret = update_write_reg(dev, AD7124_ADC_Control, bitfield_mask, temp_val);
+    if (err_detect(ret) == FAILURE)
+        return FAILURE;
+
+    ad7124_wait_for_conv_ready(dev, SPI_POLL_COUNT);
+    port.printf("\tSuccessfully Calibrated\n\n");
+    wait(1);
+
+    /*Re-activate disabled channels*/
+    for (int channel_index = 0; channel_index < NUM_OF_CHANNELS; channel_index++) {
+        if (active_channels[channel_index] == true)
+            channels[channel_index].enable = true;
+    }
+    ret = write_device(dev);
+    if (err_detect(ret) == FAILURE)
+        return FAILURE;
+
+    port.printf("\tSuccess\n");
+    return SUCCESS;
+}
+
+/* Choose the power mode of the device
+ *
+ * Parameters: Device handler
+ * Return Value: SUCCESS (0), FAILURE (Negative)
+ */
+static int8_t menu_select_power_mode(struct ad7124_dev * dev)
+{
+    uint8_t power_mode;
+    int8_t ret;
+
+    /*Fill all structs with register map information from device*/
+    ret = fill_structs(dev);
+    if (err_detect(ret) == FAILURE)
+        return FAILURE;
+
+    port.printf("\n\tSelect Filter\n");
+    port.printf("\t=======================================\n");
+    port.printf("\t 1 - Low Power Mode\n");
+    port.printf("\t 2 - Medium Power Mode\n");
+    port.printf("\t 3 - High Power Mode\n");
+    port.printf("\t 4 - Main Menu\n");
+
+    port.scanf("%d", (int *) &power_mode);
+    if ((power_mode < 1) || (power_mode > 3))
+        return FAILURE;
+
+    /*Write to device*/
+    channels[0].power_mode = power_mode - 1;
+    ret = write_device(dev);
+    if (err_detect(ret) == FAILURE)
+        return FAILURE;
+
+    return SUCCESS;
+}
+
+/* Print out the device ID. This is helpful for debugging SPI serial
+ * communication with the ADC
+ *
+ * Parameters: Device handler
+ * Return Value: SUCCESS (0), FAILURE (Negative)
+ */
+static int8_t menu_print_ID(struct ad7124_dev * dev)
+{
+    struct ad7124_st_reg *regs;
+    int8_t ret;
+
+    regs = dev->regs;
+
+    ret = ad7124_read_register(dev, &regs[AD7124_ID]);
+    if (err_detect(ret) == FAILURE)
+        return FAILURE;
+
+    port.printf("\tSuccessfully Read Device ID\n");
+    port.printf("\tID: %#x\n", regs[AD7124_ID].value);
+
+    return SUCCESS;
+}
+
+/* Updates a specific bitfield for a particular register. This function allows
+ * for a register to only be altered in the area that is required
+ *
+ * Example to change power mode from low to medium power:
+ *
+ * (Mask of all ones)
+ * ones_mask = 0xFFFFFFFF;
+ *
+ * (Isolate power mode area)
+ * bitfield_mask = AD7124_ADC_CTRL_REG_POWER_MODE(ones_mask);
+ *
+ * (Provide new value)
+ * temp_val = AD7124_ADC_CTRL_REG_POWER_MODE(MED_POWER_MODE);
+ *
+ * (Update Value)
+ * update_write_reg(dev, AD7124_ADC_Control, bitfield_mask, temp_val;
+ *
+ * Parameters: Device handler, register, bitfield area mask (ones), value to be written
+ * Return Value: SUCCESS (0), FAILURE (Negative)
+ */
+static int8_t update_write_reg(struct ad7124_dev * dev,
+                               uint8_t reg, uint32_t mask, uint32_t val)
+{
+    struct ad7124_st_reg *regs;
+    int8_t ret;
+
+    regs = dev->regs;
+
+    ret = ad7124_read_register(dev, &regs[reg]);
+    if (err_detect(ret) == FAILURE)
+        return FAILURE;
+
+    regs[reg].value = (regs[reg].value & ~mask) | (val & mask);
+    ret = ad7124_write_register(dev, regs[reg]);
+    if (err_detect(ret) == FAILURE)
+        return FAILURE;
+
+    return SUCCESS;
+}
+
+/* Converts a single channel's sample from the ADC into voltage based off
+ * neccessary information about the setup associated with that channel
+ *
+ * Parameters: code from ADC, channel being sampled
+ * Return Value: None
+ */
+static void code_to_voltage(uint32_t code, uint8_t channel)
+{
+    uint8_t gain = 1 << (channels[channel].setup->gain);
+    uint8_t bipolar = channels[channel].setup->bipolar;
+
+    if (bipolar)
+        channels[channel].sample = (((float)(code)/(1 << (NUM_BITS-1)))-1)*(2.5*gain);
+    else if (!bipolar)
+        channels[channel].sample = (float)code*VREF/((1 << NUM_BITS)*gain);
+}
+
+/* Prints out all channel struct information in a user friendly format after
+ * reading the register map from the ADC. It only prints out channel member
+ * information, but can be modified to keep track of anything else.
+ *
+ * Parameters: Device handler
+ * Return Value: SUCCESS (0), FAILURE (Negative)
+ */
+static int8_t menu_print_channel_register_map_view_mode(struct ad7124_dev * dev)
+{
+    uint8_t channel = 0;
+    int8_t ret;
+
+    ret = fill_structs(dev);
+    if (err_detect(ret) == FAILURE )
+        return FAILURE;
+
+    port.printf("\tPower Mode: %s\n", power_strings[channels[channel].power_mode]);
+    port.printf("\t(Channel #, Enable, Setup, Gain, Filter, Filter Data Rate)\n");
+    port.printf("\t=============================================================\n");
+    for (channel = 0; channel < 16; channel++) {
+        port.printf("\tChannel %02d: %d, %d, %03d, %s, %d\n",
+                    channel, channels[channel].enable, channels[channel].setup->setup_id,
+                    1 << channels[channel].setup->gain, filter_strings[channels[channel].setup->filter],
+                    channels[channel].setup->data_rate);
+    }
+    return SUCCESS;
+}
+
+/* Prints out the user friendly register map mode as well as the raw register map
+ * values. After selecting this function, the user can immediately copy over the
+ * current register map and paste it in the custom configuration register map file.
+ * This function waits for a key to be pressed to go back to the main menu to allow
+ * the user to easily copy the raw data from the serial monitor.
+ *
+ * Parameters: Device handler
+ * Return Value: SUCCESS (0), FAILURE (Negative)
+ */
+static int8_t menu_print_channel_register_map_raw_mode(struct ad7124_dev * dev)
+{
+    struct ad7124_st_reg *regs;
+    uint8_t reg_nr;
+    int8_t ret;
+
+    regs = dev->regs;
+
+    port.printf("=====================================================\n");
+    port.printf("                   COPY BELOW HERE                   \n");
+    port.printf("=====================================================\n\n");
+
+    port.printf("/*\n\n");
+    menu_print_channel_register_map_view_mode(dev);
+    port.printf("\n*/\n");
+
+    port.printf("#include \"ad7124_regs_configs.h\"\n\n");
+    port.printf("struct ad7124_st_reg ad7124_regs_custom[AD7124_REG_NO] = {\n");
+    for (reg_nr = AD7124_Status; reg_nr < AD7124_REG_NO; reg_nr++) {
+        ret = ad7124_read_register(dev, &regs[reg_nr]);
+        if (err_detect(ret) == FAILURE)
+            return FAILURE;
+
+        port.printf("\t\t{0x%02x, 0x%06x, %d, %d},\n",
+                    regs[reg_nr].addr, regs[reg_nr].value,
+                    regs[reg_nr].size, regs[reg_nr].rw);
+    }
+    port.printf("};\n");
+    /*Wait until user enters a command to allow time to copy information*/
+    while(1) {
+        if (!port.readable())
+            return SUCCESS;
+    }
+}
+
+/* Print all of the setup's information in a user friendly format. 
+ * 
+ * Parameters: Device handler
+ * Return Value: SUCCESS (0), FAILURE (Negative)
+ */
+static int8_t menu_print_setups(struct ad7124_dev * dev)
+{
+    uint8_t setup;
+    int8_t ret;
+
+    ret = fill_structs(dev);
+    if (err_detect(ret) == FAILURE )
+        return FAILURE;
+
+    port.printf("\t(Setup #: Gain, Filter, Filter Data Rate)\n");
+    port.printf("\t=============================================================\n");
+    for (setup = 0; setup < NUM_OF_SETUPS; setup++) {
+        port.printf("\tSetup %d: %03d, %s, %d\n",
+                    setup, 1 << setups[setup].gain, filter_strings[setups[setup].filter],
+                    setups[setup].data_rate);
+    }
+    return SUCCESS;
+}
+
+/* Function to fill up structs based off what has been written to the ADC's
+ * register map. Using this function along with "write_device", the user
+ * can at all times have an up to date register map that can be written to thea
+ * ADC's register map or updated with the most current values of the ADC.
+ *
+ * Parameters: Device handler
+ * Return Value: SUCCESS (0) , FAILURE (Negative)
+ */
+static int8_t fill_structs(struct ad7124_dev * dev)
+{
+    struct ad7124_st_reg *regs;
+    uint8_t reg_nr, index = 0;
+    int8_t ret;
+
+    regs = dev->regs;
+
+    for (reg_nr = AD7124_Status ; reg_nr < AD7124_Offset_0; reg_nr++) {
+        /*Read register information from device*/
+        ret = ad7124_read_register(dev, &regs[reg_nr]);
+        if (err_detect(ret) == FAILURE)
+            return FAILURE;
+
+        if (reg_nr == AD7124_ADC_Control) {
+            /*Update power mode (0th channel only)*/
+            channels[index].power_mode = POWER_MODE_READ(regs[reg_nr].value);
+
+        } else if ((reg_nr > AD7124_Mclk_Count) && (reg_nr < AD7124_Config_0)) {
+            /*Updating enable bit*/
+            channels[index].enable = (regs[reg_nr].value & AD7124_CH_MAP_REG_CH_ENABLE);
+
+            /*Updating setup*/
+            channels[index].setup = &setups[SETUP_READ(regs[reg_nr].value)];
+
+            /*Updating setup id*/
+            channels[index++].setup->setup_id = SETUP_READ(regs[reg_nr].value);
+
+            /*Reset index*/
+            if (reg_nr == AD7124_Channel_15)
+                index = 0;
+
+        } else if ((reg_nr > AD7124_Channel_15) && (reg_nr < AD7124_Filter_0)) {
+            /*Updating bipolar bit*/
+            setups[index].bipolar = (regs[reg_nr].value & AD7124_CFG_REG_BIPOLAR);
+
+            /*Updating gain*/
+            setups[index++].gain = GAIN_READ(regs[reg_nr].value);
+
+            /*Reset index*/
+            if (reg_nr == AD7124_Config_7)
+                index = 0;
+
+        } else if ((reg_nr > AD7124_Config_7) && (reg_nr < AD7124_Offset_0)) {
+            /*Updating filter*/
+            setups[index].filter = FILTER_READ(regs[reg_nr].value);
+
+            /*Updating filter data rate*/
+            setups[index++].data_rate = DATA_RATE_READ(regs[reg_nr].value);
+        }
+    }
+    return SUCCESS;
+}
+
+/* Write back struct channel and setup struct values to the device. This
+ * function only writes back the members of those structs. This function can
+ * be modified in conjunction with the "fill_structs" function to add other
+ * fields that you would like to modify and keep track of. Ex. AINP, AINM values
+ *
+ * Parameters: Device handler
+ * Return Value: SUCCESS (0), FAILURE (Negative)
+ */
+static int8_t write_device(struct ad7124_dev * dev)
+{
+    uint32_t ones_mask = 0xFFFFFFFF;
+    uint32_t bitfield_mask, temp_val;
+    uint8_t reg_nr, index = 0;
+    int8_t ret;
+
+    for (reg_nr = AD7124_Status; reg_nr < AD7124_Offset_0; reg_nr++) {
+
+        if (reg_nr == AD7124_ADC_Control) {
+
+            /*Write power mode*/
+            bitfield_mask = AD7124_ADC_CTRL_REG_POWER_MODE(ones_mask);
+            temp_val = AD7124_ADC_CTRL_REG_POWER_MODE(channels[0].power_mode);
+            ret = update_write_reg(dev, AD7124_ADC_Control, bitfield_mask, temp_val);
+            if (err_detect(ret) == FAILURE)
+                return FAILURE;
+
+        } else if ((reg_nr > AD7124_Mclk_Count) && (reg_nr < AD7124_Config_0)) {
+            /*Set enable bits*/
+            bitfield_mask = AD7124_CH_MAP_REG_CH_ENABLE;
+            temp_val = (channels[index].enable == 1) ? AD7124_CH_MAP_REG_CH_ENABLE:
+                       !AD7124_CH_MAP_REG_CH_ENABLE;
+            /*Write to device*/
+            ret = update_write_reg(dev, reg_nr, bitfield_mask, temp_val);
+            if (err_detect(ret) == FAILURE)
+                return FAILURE;
+
+            /*Set setup bits*/
+            bitfield_mask = AD7124_CH_MAP_REG_SETUP(ones_mask);
+            temp_val = AD7124_CH_MAP_REG_SETUP(channels[index].setup->setup_id);
+            ret = update_write_reg(dev, reg_nr, bitfield_mask, temp_val);
+            if (err_detect(ret) == FAILURE)
+                return FAILURE;
+
+            index++;
+            /*Reset index*/
+            if (reg_nr == AD7124_Channel_15)
+                index = 0;
+
+        } else if ((reg_nr > AD7124_Channel_15) && (reg_nr < AD7124_Filter_0)) {
+            /*Set gain bits*/
+            bitfield_mask = AD7124_CFG_REG_PGA(ones_mask);
+            temp_val = AD7124_CFG_REG_PGA(setups[index++].gain);
+
+            /*Write to device*/
+            ret = update_write_reg(dev, reg_nr, bitfield_mask, temp_val);
+            if (err_detect(ret) == FAILURE)
+                return FAILURE;
+
+            /*Reset index*/
+            if (reg_nr == AD7124_Config_7)
+                index = 0;
+
+        } else if ((reg_nr > AD7124_Config_7) && (reg_nr < AD7124_Offset_0)) {
+            /*Set filter bits*/
+            bitfield_mask = AD7124_FILT_REG_FILTER(ones_mask);
+            temp_val = AD7124_FILT_REG_FILTER(setups[index].filter);
+            ret = update_write_reg(dev, reg_nr, bitfield_mask, temp_val);
+            if (err_detect(ret) == FAILURE)
+                return FAILURE;
+
+            /*Set data rate bits*/
+            bitfield_mask = AD7124_FILT_REG_FS(ones_mask);
+            temp_val = AD7124_FILT_REG_FS(setups[index++].data_rate);
+            ret = update_write_reg(dev, reg_nr, bitfield_mask, temp_val);
+            if (err_detect(ret) == FAILURE)
+                return FAILURE;
+        }
+    }
+    return SUCCESS;
+}
+
+/* Prints out the error message corresponding to the No-OS drivers functions
+ *
+ * Parameters: Return value from some function
+ * Return Value: SUCCESS (0), FAILURE (Negative)
+ */
+static int8_t err_detect(int8_t ret)
+{
+    switch(ret) {
+        case -1:
+            port.printf("\tInvalid Argument...\n");
+            wait(1);
+            return FAILURE;
+
+        case -2:
+            port.printf("\tCommunication Error on Receive...\n");
+            wait(1);
+            return FAILURE;
+
+        case -3:
+            port.printf("\tA Timeout has Occured...\n");
+            wait(1);
+            return FAILURE;
+
+        default:
+            return SUCCESS;
+    }
+}
+
+/* Obtains the setup that the user would like to select
+ *
+ * Parameters: None
+ * Return Value: SUCCESS (0), FAILURE (Negative)
+ */
+static int8_t setup_select(uint8_t *setup)
+{
+    port.printf("\t===============================\n");
+    port.printf("\t Setup (0 - 7)\n");
+    port.printf("\t 8 - Main Menu\n\n");
+
+    port.scanf("%d", (int *) setup);
+    if (*setup > 7)
+        return FAILURE;
+
+    return SUCCESS;
+}
+
+/* Obtains the channel that the user would like to select
+ *
+ * Parameters: None
+ * Return Value: SUCCESS (0), FAILURE (Negative)
+ */
+static int8_t channel_select(uint8_t *channel)
+{
+    port.printf("\t===============================\n");
+    port.printf("\t Channel (0 - 15)\n");
+    port.printf("\t 16 - Main Menu\n\n");
+
+    port.scanf("%d", (int *) channel);
+    if (*channel > 15)
+        return FAILURE;
+
+    return SUCCESS;
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/platform_drivers.lib	Thu Sep 05 20:50:43 2019 +0000
@@ -0,0 +1,1 @@
+https://os.mbed.com/users/MitchAD/code/platform_drivers/#d61bb2021c34