ADS1220: ADC resolution and sampling rate

Thank you Bob, that helped me.

I'm having another issue. I have a PSoC connected with the ADS1220 through SPI communication. When the data is received from the ADS1220, the data is send to Matlab through UART. However, the resolution is very bad. I'm having huge steps. Do you have any idea why? I have attached the hardware configuration of the ADC, and this is the code in PSoC:

#include "project.h"
#include "stdio.h"
#include <stdlib.h>
#include <math.h>


#define FALSE  0
#define TRUE   1
#define TRANSMIT_BUFFER_SIZE  4

uint32 dummy = 0;

int main(void)
{
    
     /* Variable to store ADC result */
   int OutputBuffer[3];
   int32 Output = 0B00000000000000000000000000000000;
int32 test = 0;
int32 check = 0B00000000000000000000000000000000;

   int32 cancel;
    /* Variable to store UART received character */
    uint8 Ch;

    /* Flags used to store transmit data commands */
    uint8 ContinuouslySendData;
    uint8 SendSingleByte;
    uint8 SendEmulatedData;
    /* Transmit Buffer */
    
    char TransmitBuffer[1];

    /* Start the components */

    UART_1_Start();
    SPIM_Start();
    
    /* Initialize Variables */
    ContinuouslySendData = FALSE;
    SendSingleByte = FALSE;
    SendEmulatedData = FALSE;
    uint8 resetData = TRUE;

    
    /* Start the ADC conversion */
    ADC_DelSig_1_StartConvert();
    
    /* Send message to verify COM port is connected properly */
    UART_1_PutString("COM Port Open");
    
    
    CyGlobalIntEnable; /* Enable global interrupts. */

    /* Place your initialization/startup code here (e.g. MyInst_Start()) */


SPIM_WriteTxData(0B00000110); // Reset ADC
CyDelayUs(1000);
SPIM_WriteTxData(0B00001000); // START ADC


/*Configuring control register with : 

SPIM_WriteTxData(0x43);
SPIM_WriteTxData(0B0110000); //R0 
SPIM_WriteTxData(0B11010100); //R1
SPIM_WriteTxData(0B11100111); //R2
SPIM_WriteTxData(0B00000000); //R3




int i = 0;

LED_Write(0);
for(i = 0; i<6;i++)
{
    LED_Write(!LED_Read());
    CyDelay(300);
    
}

    for(;;)
    {
      
   
           /* Non-blocking call to get the latest data recieved  */
        Ch = UART_1_GetChar();
        
        /* Set flags based on UART command */
        
                switch(Ch)
        {
            case 0:
            
                break;
            case 'C':
            case 'c':
                SendSingleByte = TRUE;
                break;
            case 'S':
            case 's':
                ContinuouslySendData = TRUE;
                break;
            case 'X':
            case 'x':
                ContinuouslySendData = FALSE;
                break;
            case 'E':
            case 'e':
                SendEmulatedData = TRUE;
                break;
            default:
              
                break;    
        }
        
        

        //Læse ADC OUT
      SPIM_WriteTxData(0x10); // SPIM_WriteTxData(0x23);
           SPIM_WriteTxData(0x00000000);
                SPIM_WriteTxData(0x00000000);
                  SPIM_WriteTxData(0x00000000);
                  
   
                   
  



          //
for(int i = 0; i<2; i++)
{
OutputBuffer[i] = (OutputBuffer[i] & 0B00000000);
}
Output = (Output & 0B00000000000000000000000000000000);


OutputBuffer[0] = SPIM_ReadRxData();
OutputBuffer[1] = SPIM_ReadRxData();
OutputBuffer[2] = SPIM_ReadRxData();



Output = OutputBuffer[2];
Output = Output << 8;
Output += OutputBuffer[1];
Output = Output << 8;
Output += OutputBuffer[0];

Output = Output & 0B00000000111111111111111111111111;


           
        if(ContinuouslySendData == TRUE)
		{	
			UART_1_ClearTxBuffer();
			//UART_1_PutString(TransmitBuffer);	
     
        

            
            UART_1_PutChar(Output);
            UART_1_PutChar(Output>>8);
            UART_1_PutChar(Output>>16);
            UART_1_PutChar(Output>>24);


            
            
			LED_Write(1);
			CyDelay(35);
			UART_1_ClearTxBuffer();
            
		}
		else
		{
			UART_1_ClearTxBuffer();
            LED_Write(0);
		}
        
        
        
        
    }
    
   
 

}

And Matlab Serial communication is configured like this:

serial_PSoC=serial('COM1','BaudRate',115200,'Parity','none','DataBits',8,'StopBits',1);
set(serial_PSoC,'InputBufferSize',4096,'ByteOrder','littleEndian');

I forgot to attach picture of Matlab results. The vertical axis is the resolution, and the horizontal axis is samples.

Thank you again.

Hi Sadoun,

The first thing I noticed is that you have DRDY connected to +5V. DRDY is an actively driven output. You have the supply shorting to GND when DRDY goes to a low state. Most likely the part is damaged.

I'm not familiar with PSoC operation. It is not clear if you have both a transmit and receive buffer FIFO. With many processors you need to read the contents of RX after the byte in the TX buffer has transmitted to maintain some form of synchronicity between the transmit and receive. It is quite possible that you are attempting to read the RX buffer before the TX buffer has fully transmitted.

If the RX data is in a FIFO, you read out the data in the same way it was transmitted, which is MSB first. In your code you are assembling the byte in reverse.

The ADS1220 sends the result as binary 2's complement. You need to properly sign-extend the result to the 32-bit variable.

It is not clear what the register settings are that you are using as the code is commented out. It is also not clear how you are determining when a result is ready to be read from the ADS1220. What is the input voltage to the ADS1220 and what you are expecting as a result?

I would suggest using an oscilloscope or logic analyzer to verify your communication and timing. You can then compare the data seen on the scope and compare to the results transmitted. I'm guessing you have a number of timing errors due to the sequential nature of the code relative to automatic operation of the micro peripherals.

Best regards,
Bob B