How to program MAX22007 Configurable Analog Output

Abstract

The MAX22007 is a Configurable Analog Output device. It supports 4 channels and each channel can be individually programmed as a 0V to +10V Voltage output or a 0mA to +20mA current output.

A microcontroller compatible serial peripheral interface (SPI) provides access to many advanced features. This application note provides example C-code implementing setup, monitoring, and diagnostic functions in the microcontroller.

Introduction

The MAX22007 integrates four 12-bit DACs (digital-to-analog converters) to create four channels with software-configurable outputs that support either 0V to +10V or 0mA to +20mA analog outputs. Each channel can also detect the load impedance and determine if the load is a voltage or current input.

The MAX22007 functional diagram

Figure 1. The MAX22007 functional diagram.

This application note illustrates a series of functions for a faster and proven way to program the MAX22007. The functions are written in C and are easy to port to any common microcontroller. Refer to the MAX22007 data sheet for detailed information on the MAX22007 pins, operating modes, and control registers.

MAX22007 SPI

The MAX22007 serial peripheral interface (SPI) commands are 24 bits (8-bit instruction + 16-bit data) with CRC-disabled, and 32 bits with CRC-enabled. Table 1 shows the SPI command structure. The SPI mode for the MAX22007 is CPOL = 0 (CLK idle = 0) and CPHA = 0 (rising/first edge samples the data). The data/commands must first be clocked in most significant byte (MSB).

Table 1. The MAX22007 SPI Command Structure
Address Control Data
7-bits A[6:0], MSB to least significant byte (LSB) R/W bit, Read = 1, Write = 0 16-bits D[15:0], MSB to LSB

The MAX22007 data sheet has full details of the SPI read and write cycles, register tables, and instructions.

Figure 1 shows the main function blocks of the MAX22007. There are four channels that can be individually programmed to be the voltage or current output, and a control logic with a SPI port to access all the registers and hardware flags for diagnostics.

The MAX22007 supports eight logic-level GPIOs (general purpose input/output) to simplify systems which require galvanic isolation. The GPIOs can control external components such as multiplexers, FETs (field-effect transistors) or enabling power supplies to be switched, or digital signals to be read back through the isolation barrier. The device also supports the daisy-chain mode, which also reduces the number of IO pins required for isolated designs.

Source Code

This application note provides C source code examples, providing driver functions to access the multiple registers within the MAX22007 for configuration, control, and diagnostic features.

Note that the CONFIGURATION Register 0x03 LD_CNFG[3:0], bits 15 to 12, are set to 0 at power-up. All the four outputs update simultaneously upon a high to low transition on the LDAC pin. Set the LD_CNFG bits to 1 if the channels are required to be transparent and update immediately.

Global Variables for Channel/Mode Selection

        public enum Register_address
        {
            // All Registers
            REVISION_ID       = 0x00,
            STATUS_INTERRUPTS = 0x01,
            INTERRUPT_ENABLE  = 0x02,
            CONFIGURATION     = 0x03,
            CONTROL           = 0x04,
            CHANNEL_MODE      = 0x05,
            SOFT_RESET        = 0x06,
            CHANNEL0_DATA     = 0x07,
            CHANNEL1_DATA     = 0x08,
            CHANNEL2_DATA     = 0x09,
            CHANNEL3_DATA     = 0x0a,
            GPIO_CONTROL      = 0x0b,
            GPIO_DATA         = 0x0c,
            GPI_EDGE_CTRL     = 0x0d,
            GPI_EDGE_STATUS   = 0x0e,
        };

        public enum AOut_Mode
        {
            high_impedance = 0,
            AO_12V         = 1,
            AO_25mA        = 2,
            out_of_range1  = 3,
        };




 
//********************************************************************
//*
//* Function: MAX22007_read_register
//* Description: Read one Register from MAX22007
//*
//* Input: Register-Address (take from definitions in header-file)
//* Output: 16bit register content
//*
//* if CRC is enabled, then crc8-Command is required
//*
//********************************************************************/
public UInt32 MAX22007EVKIT_read_register(Register_address address)
{
     if (CRC_Enabled == false)
     {
         max22007_port.SPI_CS0Enable();
         max22007_port.SPI_W_transaction_8( (ushort) ( ((byte)address << 1) + 0x01 )  );
         result = max22007_port.SPI_R_transaction_16();
         max22007_port.SPI_CS0Disable();
     }
     else
     {
         max22007_port.SPI_CS0Enable();
         max22007_port.SPI_W_transaction_8( (ushort) ( ((byte)address << 1) + 0x01 )  );
         result = max22007_port.SPI_R_transaction_16();
         max22007_port.SPI_CS0Disable();

         CRC_result = max22007_port.SPI_R_transaction_8();  // read the CRC
         byte CRC_TX1 = (address << 1) + 0x01;
         byte CRC_RX1 = ((result >> 8) & 0xff);
         byte CRC_RX2 = ((result     ) & 0xff);
         byte CRC_Calc = crc8(CRC_TX1, CRC_RX1, CRC_RX2);

         if (CRC_Calc != CRC_result)
         {
            result = 0xfffffffe; // return a 32 bit value to flag an error
         }
     }
}



//********************************************************************
//*
//* Function: MAX22007_write_register
//* Description: Write one Register to MAX22007
//*
//* Input: Register-Address (take from definitions in header-file)
//*        16bit data (new register content)
//*
//********************************************************************/
public void MAX22007EVKIT_write_register(Register_address address, UInt16 data)
{
    byte CRC_TX1 = (byte)((byte)address << 1);

    if (CRC_Enabled == false)
    {
        max22007_port.SPI_CS0Enable();
        max22007_port.SPI_W_transaction_8( (ushort) ( ((byte)address << 1) )  );
        max22007_port.SPI_W_transaction_16(data);
        max22007_port.SPI_CS0Disable();
    }
    else
    {
        byte CRC_TX2 = (byte)((data>> 8) & 0xff);
        byte CRC_TX3 = (byte)( data      & 0xff);
        byte CRC_Calc = crc8(CRC_TX1, CRC_TX2, CRC_TX3);

        max22007_port.SPI_CS0Enable();
        max22007_port.SPI_W_transaction_8( (ushort) ( ((byte)address << 1) )  );
        max22007_port.SPI_W_transaction_16(data);
        max22007_port.SPI_W_transaction_8( CRC_Calc );
        max22007_port.SPI_CS0Disable();
    }
}


 
// ********************************************************************
//
// Function: MAX22007_Mode_Set
// Description: Sets up MAX22007 Mode for one of the 4 Channels
//
// Input: mode:    Desired Mode
//        Channel: Desired Channel
// Output: None (The selected channel of MAX22007 will be setup by this routine)
//
// ******************************************************************** 
private void MAX22007_Mode_Set(byte Channel, AOut_Mode mode)
{
   // Set AO Mode (Register 0x05: CHANNEL_MODE)
   UInt32 previous_mode = MAX22007EVKIT_read_register(Register_address.CHANNEL_MODE);
   UInt16 new_mode = (UInt16) previous_mode;
            
   switch (Channel)
   {
     case 0:
              if (mode == AOut_Mode.high_impedance)
              {   new_mode = (new_mode & 0xeeff);   // High-Impedance, set to Voltage Mode and Power-Off - Channel 0
              }
              if (mode == AOut_Mode.AO_12V)
              {   new_mode = (new_mode & 0xefff);   // Voltage Output, set CHNL_MODE to 1 for this         Channel 0
                  new_mode = (new_mode | 0x0100);   // make sure the Channel is enabled                    Channel 0
              }
              if (mode == AOut_Mode.AO_25mA)
              {   new_mode = (new_mode | 0x1000);   // Current Output, set CHNL_MODE to 1 for this         Channel 0
                  new_mode = (new_mode | 0x0100);   // make sure the Channel is enabled                    Channel 0
              }
              break;
     case 1:
              if (mode == AOut_Mode.high_impedance)
              {   new_mode = (new_mode & 0xddff);   // High-Impedance, set to Voltage Mode and Power-Off - Channel 1
              }
              if (mode == AOut_Mode.AO_12V)
              {   new_mode = (new_mode & 0xdfff);   // Voltage Output, set CHNL_MODE to 1 for this         Channel 1
                  new_mode = (new_mode | 0x0200);   // make sure the Channel is enabled                    Channel 1
              }
              if (mode == AOut_Mode.AO_25mA)
              {   new_mode = (new_mode | 0x2000);   // Current Output, set CHNL_MODE to 1 for this         Channel 1
                  new_mode = (new_mode | 0x0200);   // make sure the Channel is enabled                    Channel 1
              }
              break;
     case 2:
              if (mode == AOut_Mode.high_impedance)
              {   new_mode = (new_mode & 0xbbff);   // High-Impedance, set to Voltage Mode and Power-Off - Channel 2
              }
              if (mode == AOut_Mode.AO_12V)
              {   new_mode = (new_mode & 0xbfff);   // Voltage Output, set CHNL_MODE to 1 for this         Channel 2
                  new_mode = (new_mode | 0x0400);   // make sure the Channel is enabled                    Channel 2
              }
              if (mode == AOut_Mode.AO_25mA)
              {   new_mode = (new_mode | 0x4000);   // Current Output, set CHNL_MODE to 1 for this         Channel 2
                  new_mode = (new_mode | 0x0400);   // make sure the Channel is enabled                    Channel 2
              }
              break;
     case 3:
              if (mode == AOut_Mode.high_impedance)
              {   new_mode = (new_mode & 0x77ff);   // High-Impedance, set to Voltage Mode and Power-Off - Channel 3
              }
              if (mode == AOut_Mode.AO_12V)
              {   new_mode = (new_mode & 0x7fff);   // Voltage Output, set CHNL_MODE to 1 for this         Channel 3
                  new_mode = (new_mode | 0x0800);   // make sure the Channel is enabled                    Channel 3
              }
              if (mode == AOut_Mode.AO_25mA)
              {   new_mode = (new_mode | 0x8000);   // Current Output, set CHNL_MODE to 1 for this         Channel 3
                  new_mode = (new_mode | 0x0800);   // make sure the Channel is enabled                    Channel 3
              }
                    break;
    }
    MAX22007EVKIT_write_register(Register_address.CHANNEL_MODE,  new_mode);
}
 
// ********************************************************************
//
// Function: MAX22007_convert_Voltage_to_LSB
// Description: Converts a voltage to an LSB value for the DAC
//
// Input:  float:  Voltage
// Output: UInt16  LSB Value for the DAC
//
// ********************************************************************
private UInt16 MAX22007_convert_Voltage_to_LSB (float voltage)
{
    UInt16 new_hex_value = 0;
    float result = 0;
    float phy_AO_12V_factor  = (float) 12.5 / (float) 4095;

    // check for errors
    if (voltage > 12.5)    { return 0xfffe; } // return out of range value to highlight there was an error
    if (voltage < 0)       { return 0xfffe; } // return out of range value to highlight there was an error

    // convert voltage to LSB value
    result = (voltage / phy_AO_12V_factor);
    new_hex_value = (UInt16) result;

    return new_hex_value;
}



// ********************************************************************
//
// Function: MAX22007_convert_Current_to_LSB
// Description: Converts a current in mA to an LSB value for the DAC
//
// Input:  float:  Current in mA
// Output: UInt16  LSB Value for the DAC
//
// ********************************************************************
private UInt16 MAX22007_convert_Current_to_LSB (float current_mA)
{
    UInt16 new_hex_value = 0;
    float result = 0;
    float phy_AO_25mA_factor = (float) 25 / (float) 4095;

    // check for errors
    if (current_mA > 25)    { return 0xfffe; } // return out of range value to highlight there was an error
    if (current_mA < 0)     { return 0xfffe; } // return out of range value to highlight there was an error

    // convert voltage to LSB value
    result = (current_mA / phy_AO_25mA_factor);
    new_hex_value = (UInt16) result;

    return new_hex_value;
}
 
// ********************************************************************
//
// Function: MAX22007_DAC_Set_LSB
// Description: Writes a new LSB value to the DAC,
//              assuming it is already setup in a specific mode, use DAC_Setup first
//              If LDAC-pin is high, it must be toggled after setting up update the output
//
// Input: new DAC value in LSB
// Output: None
//
// ********************************************************************
private void MAX22007_Set_DAC(byte Channel, UInt16 LSB_code)
{
  UInt16 DAC_out_register = (UInt16) (LSB_code << 4); // Shift bits to match with register

  switch (Channel)
  {
   case 0:
            MAX22007EVKIT_write_register (Register_address.CHANNEL0_DATA, DAC_out_register); // Write AO Data register CH0
            break;
   case 1:
            MAX22007EVKIT_write_register (Register_address.CHANNEL1_DATA, DAC_out_register); // Write AO Data register CH1
            break;
   case 2:
            MAX22007EVKIT_write_register (Register_address.CHANNEL2_DATA, DAC_out_register); // Write AO Data register CH2
            break;
   case 3:
            MAX22007EVKIT_write_register (Register_address.CHANNEL3_DATA, DAC_out_register); // Write AO Data register CH3
            break;
  }

}


// ********************************************************************
//
// Function: main
// Description: The follwoing function would setup:
//              1. ALL outputs to immediately update on write
//              2. Channel 0 in Voltage mode and drive 5V
//              3. Channel 1 in Current mode and drive 10mA
//
// Input:  float:  Current in mA
// Output: UInt16  LSB Value for the DAC
//
// ********************************************************************
private void setup_main ()
{
    MAX22007EVKIT_write_register (Register_address.CONFIGURATION, 0xf000);       // Set all Latch bits

    MAX22007_Mode_Set(0, AOut_Mode.AO_12V);                          // setup Channel 0 to Voltage Mode
    MAX22007_Mode_Set(1, AOut_Mode.AO_25mA);                         // setup Channel 1 to Current Mode

    UInt16 DAC_LSB_value = 0;

    DAC_LSB_value = MAX22007_convert_Voltage_to_LSB ((float) 5.0);   // get integer value for 5.0 Volt
    MAX22007_Set_DAC(0, DAC_LSB_value);                              // write this 5V value to Channel 0

    DAC_LSB_value = MAX22007_convert_Current_to_LSB ((float)10.0);   // get integer value for 10.0 mA
    MAX22007_Set_DAC(1, DAC_LSB_value);                              // write this 10.0mA value to Channel 1

}

 
// ********************************************************************
//
// Function: MAX22007_GPIO_Setup
// Description: Sets up all 8 GPIO Pins, bit0=GPIO0, bit1=GPIO1, ...
//              Since the command includes everything Enable/Disable as well as
//              GPIO Direction, this function is faster than GPO_Set
//              because it does not have to read back the setup from the part
//
// Input:  GPIO_enable (byte)    Bit0 = GPIO0, Bit1 = GPIO1, ... (0 = Off,   1 = On)
//         GPIO_direction (byte) Bit0 = GPIO0, Bit1 = GPIO1, ... (0 = Input, 1 = Output)
//
// Output: None
//
// ********************************************************************
void MAX22007_GPIO_Setup (byte GPIO_enable, byte GPIO_direction)
{
    UInt16 new_gpio_value = (UInt16) ( ( (GPIO_enable & 0xff) << 8) + ( (GPIO_direction & 0xff) ) );
    MAX22007EVKIT_write_register(Register_address.GPIO_CONTROL,  new_gpio_value);
}


// ********************************************************************
//
// Function: MAX22007_GPO_Set
// Description: Sets GPOs high or low, bit0=GPIO0, bit1=GPIO1, ...
//              GPOs must be setup and enabled prior this use MAX22007_GPO_Set
//
// Input: GPO Setting, bit0=GPIO0, bit1=GPIO1, ... (0 = Low, 1 = High)
// Output: None
//
// ********************************************************************
void MAX22007_GPO_Set (byte GPO_Setting)
{
    UInt16 GPO_data = (UInt16) ((GPO_Setting<<8) & 0xff00);                  // Shift bits for GPO

    MAX22007EVKIT_write_register(Register_address.GPIO_DATA, GPO_Setting);   // Write new GPO settings
                                                                             // Inputs are read only, no need to
                                                                             // worry about writing these bits
}

// ********************************************************************
//
// Function: MAX22007_GPI_Get
// Description: Gets all GPI readings high or low, bit0=GPIO0, bit1=GPIO1, ...
//              GPIs must be setup and enabled prior this use MAX22007_GPI_Get
//
// Input: None
// Output: GPI Setting, bit0=GPIO0, bit1=GPIO1, ... (0 = Low, 1 = High)
//
// ********************************************************************
byte  MAX22007_GPI_Get ()
{
    UInt32 gpi_result = MAX22007EVKIT_read_register(Register_address.GPIO_DATA);  // read GPI Data
    byte result = (byte) (gpi_result & 0xff);

    return result;
}

CRC Function

The CRC function and calculation are described in more detail in the AN7072 for a device with 24-bit registers. The MAX22007 has only 16-bit registers. The CRC calculation in AN7072 is the same concept for the MAX22007, but the calculation is only 3 bytes instead of 4 as described in the AN7072. This following function can be used as-is for MAX22007.

// ********************************************************************
//
// Function: MAX22007_crc8
// Description: Calculates CRC for MAX22007 commands (read or write)
//
// Input: BYTE1:     Command byte (register address + R/W bit)
//        BYTE2:     MS-Byte of the register value
//        BYTE3:     LS-Byte of the register value
// Output byte:      crc8 of Input 
//                   -> for write commands send result as the CRC code
//                   -> for read commands compare result to check for errors
//
// ******************************************************************** 
public byte MAX22007_crc8(byte BYTE1, byte BYTE2, byte BYTE3)
{
    byte crc8_start = 0x00;
    byte crc8_poly  = 0x8c; // rotated 0x31, which is our polinomial
    byte crc_result = crc8_start;

    // BYTE1
    for (int i=0; i<8; i++)
    {
        if( ( (( BYTE1>>i ) ^ (crc_result) ) & 0x01 ) > 0 )      // IF(XOR(C6;BITAND(D5;2^4)/2^4)
        { crc_result = (byte) (crc8_poly ^ crc_result>>1 );  }   // BITXOR($D$1;BITAND((D5*2);31))
        else
        { crc_result = (byte) (crc_result>>1);               }
    }

    // BYTE2
    for (int i=0; i<8; i++)
    {
        if( ( (( BYTE2>>i ) ^ (crc_result) ) & 0x01 ) > 0 )      // IF(XOR(C6;BITAND(D5;2^4)/2^4)
        { crc_result = (byte) (crc8_poly ^ crc_result>>1 );  }   // BITXOR($D$1;BITAND((D5*2);31))
        else
        { crc_result = (byte) (crc_result>>1);               }
    }

    // BYTE3
    for (int i=0; i<8; i++)
    {
        if( ( (( BYTE3>>i ) ^ (crc_result) ) & 0x01 ) > 0 )      // IF(XOR(C6;BITAND(D5;2^4)/2^4)
        { crc_result = (byte) (crc8_poly ^ crc_result>>1 );  }   // BITXOR($D$1;BITAND((D5*2);31))
        else
        { crc_result = (byte) (crc_result>>1);               }
    }
    return crc_result;
}

Conclusion

This application note shows how the MAX22007 can be programmed for all possible use cases. The MAX22007 EV kit was used to test this code. The C-code examples in this application note are a proven solution to implement an interface quickly and easily between popular microcontrollers and the MAX22007.