June 9 - Reading a signal using MAX11205

1) We should add a dc bias of 1.6V to a sine wave from a function generate and use an amplitude of 1.6 V (to stay below 3.3V). '

The maximum voltage that you use depends on the voltage of AVDD which is controlled by JP1.  When JP1 is in the position 1-2 (I think this is the default position), the maximum voltage is 2.85V, while in position 2-3, it is dictated by the Zedboard and is probably 3.3V.

Leave jumper JP1 in position 1-2 and limit the maximum voltage to 2.85V.  I always use an oscilloscope to confirm voltages befor I connect to equipment as the function generator controls are sometimes confusing.

2) Three pins are available.  They include V_in, Gnd, and Ref. '

V_in+ - Connect this to the output of the function generator.  The signal should be no more than 2.85V and no less than 0V.

V_in- - Connect this to the ground of the function generator.  It is also connected to the ground of the Zedboard though the Pmod connector.

Ref - This is an output from the board.  Leave Ref unconnected.

We made the following circuit that will allow us to offset the sine wave so that the wave will go from 0V to 2.8V.



However, we are reading in all zeros so we decided to start with just a constant voltage from the Zedboard. We connected ground from the pmod to ground on the max11205 peripheral and 3.3V from the pmod to the Vin on the peripheral. We used the following code:


 /* Input is on pin 3.  The program reads 8 bits of data sequentially and stores them as an 8 bit value.
The process of storage is shown using the LEDs.  Each bit is shifted to the left.  This is a program to
understand the bit-bang process and how the Maxim Integrated 11205 ADC works.*/

/* Include Files */
#include "xparameters.h"
#include "xgpio.h"
#include "xstatus.h"
#include "xil_printf.h"
#include "time.h"

/* Definitions */
#define GPIO_DEVICE_ID  XPAR_AXI_GPIO_0_DEVICE_ID /* GPIO device that LEDs are connected to */
#define LED 0xFC          /* Initial LED value - XX0000XX */
#define PMOD 0xFC         /* Initial LED value - XX0000XX */
#define LED_DELAY 100000000       /* Software delay length */
#define LED_CHANNEL 1        /* GPIO port for LEDs */
#define PMOD_CHANNEL 1        /* GPIO port for PMODs */
#define printf xil_printf       /* smaller, optimised printf */
#define PMOD_JA1_DEVICE_ID  XPAR_AXI_GPIO_1_DEVICE_ID
#define ABOUT_ONE_SECOND 74067512      //!< approx 1 second delay when used as argument with function delay(numberCyclesToDelay)
// Update this if uBlaze/Zynq CPU core frequency is changed, or if the external memory timing changes.
// Although emprirically tested to 1.0000003 seconds, it is not meant to be used for precise timing purposes

/* Definitions */
#define CLOCK_on 0x08    //high for the clock
#define DATAREADY_high 0x04   //high for data ready pin 3


XGpio Gpio, GpioP;           /* GPIO Device driver instance */



int LEDOutputExample(void)
{


 volatile int Delay;
 int Status;
 int led = LED; /* Hold current LED value. Initialise to LED definition */
 int pmod = PMOD;
 int WritetoLEDs;
 int i;
 u32 x;
 u8 uchPortWriteData=0;
 u8 uchPortReadData=0;
 u32 adcValue=0;
 int uchUseCalibrationMode;
 u32 storedValues[]={};
 int nClockCount;
 int j;

  /* GPIO driver initialisation */
  Status = XGpio_Initialize(&Gpio, GPIO_DEVICE_ID);
  if (Status != XST_SUCCESS) {
   return XST_FAILURE;
  }
  Status = XGpio_Initialize(&GpioP, PMOD_JA1_DEVICE_ID);
   if (Status != XST_SUCCESS) {
    return XST_FAILURE;
  }

  /*Set the direction for the LEDs to output. */
  XGpio_SetDataDirection(&Gpio, LED_CHANNEL, 0x00);


  /*Set the direction for the PMod - pin 3 is an input, rest are outputs. */
    XGpio_SetDataDirection(&GpioP, PMOD_CHANNEL, 0x04);

    WritetoLEDs =0x01;
    for(i =1;i<8;i++){
        XGpio_DiscreteWrite(&Gpio, LED_CHANNEL, WritetoLEDs);
        delay(ABOUT_ONE_SECOND/3);
        WritetoLEDs=(int)(1<<i);
    }


  //  printf("Ready to receive.\n \r");
    delay(10);
    XGpio_DiscreteWrite(&Gpio, LED_CHANNEL, 0xFF);

for(j=0;j<=50;j++)
{
    XGpio_DiscreteWrite(&Gpio, LED_CHANNEL, 0x00);
 for(i=15;i>=0;i--)
    {
        // Send clock high
        uchPortWriteData |= CLOCK_on;
        XGpio_DiscreteWrite(&GpioP, 1, uchPortWriteData);

        delay(10);  // small delay, then read
        uchPortReadData = XGpio_DiscreteRead(&GpioP,1);
        delay(10);
        // Shift the GPIO read data to the lowest bit, mask off all the other bits, then shift i (15:0)
        // number of bits to set the appropriate bit in the
        if(((uchPortReadData >> 2) & 0x01)==0x01) // the serial bit is a one, set the bit
        {
            if(i==15)
                adcValue = 0xFFFF8000;  // extend the sign of the 2s complement number to bits 31..16, and set bit 15 = 1
            else
                adcValue |= (int)(1 << i);  // bit shift
        }
        uchPortWriteData &= ~CLOCK_on;// Clock in data via negative edge
        XGpio_DiscreteWrite(&GpioP, 1, uchPortWriteData);
        //XGpio_DiscreteWrite(&Gpio, LED_CHANNEL, adcValue);


        // The 11205 device requires 25 clocks total to complete a read.
            // We have already sent (16) clocks, so send 9 more clocks.
            // (If self-calibration mode set then we send 10 more clocks.)
        uchUseCalibrationMode=0;
        if(uchUseCalibrationMode==1)
                nClockCount = 9;
            else
                nClockCount=8;
            for(i=nClockCount;i>=0;i--)
            {
                // Send clock high
                uchPortWriteData |= CLOCK_on;
                XGpio_DiscreteWrite(&GpioP, 1, uchPortWriteData);

                delay(10);  // small delay, then read
                uchPortWriteData &= ~CLOCK_on;// Clock in data via negative edge
                XGpio_DiscreteWrite(&GpioP, 1, uchPortWriteData);
                delay(10);
            }

    }


          printf("The ADC Value  %d \n \r", adcValue);
        storedValues[j]= adcValue;
        printf("The J Value  %d \n \r", j );
        printf("The STORED Values  %d \n \r", storedValues[j]);
        XGpio_DiscreteWrite(&Gpio, LED_CHANNEL, 0x01);
        sleep(1);
        XGpio_DiscreteWrite(&Gpio, LED_CHANNEL, 0x00);
        sleep(1);

}
  return XST_SUCCESS; /* Should be unreachable */
}



void delay(int nStopValue)
/**
* \brief       Loop for nStopValue iterations to provide a delay.
* \par         Details
*              It is commonly used with the constant 'ABOUT_ONE_SECOND' defined in maximPMOD.h for
*              setting approximate delays
*
* \param[in]   nStopValue    - number of iterations to loop
*
* \retval      None
*/
{
    int i=0;
    int a=0;

    for(i=0;i<nStopValue;i++)
    {
        a=i;
    }
}


/* Main function. */
int main(void){


 int Status;


 /* Execute the LED output. */
 Status = LEDOutputExample();
 if (Status != XST_SUCCESS) {
  xil_printf("GPIO output to the LEDs failed!\r\n");
 }


 return 0;
}



This is the output that we are getting and we are going to start debugging to understand why we are getting the weird values that we are getting and why it stops running after a certain amount of time.