hello world - Adam taylor Part 8.docx Vivado 2018.2

helloworld.c

/*
 * Copyright (c) 2009 Xilinx, Inc.  All rights reserved.
 *
 * Xilinx, Inc.
 * XILINX IS PROVIDING THIS DESIGN, CODE, OR INFORMATION "AS IS" AS A
 * COURTESY TO YOU.  BY PROVIDING THIS DESIGN, CODE, OR INFORMATION AS
 * ONE POSSIBLE   IMPLEMENTATION OF THIS FEATURE, APPLICATION OR
 * STANDARD, XILINX IS MAKING NO REPRESENTATION THAT THIS IMPLEMENTATION
 * IS FREE FROM ANY CLAIMS OF INFRINGEMENT, AND YOU ARE RESPONSIBLE
 * FOR OBTAINING ANY RIGHTS YOU MAY REQUIRE FOR YOUR IMPLEMENTATION.
 * XILINX EXPRESSLY DISCLAIMS ANY WARRANTY WHATSOEVER WITH RESPECT TO
 * THE ADEQUACY OF THE IMPLEMENTATION, INCLUDING BUT NOT LIMITED TO
 * ANY WARRANTIES OR REPRESENTATIONS THAT THIS IMPLEMENTATION IS FREE
 * FROM CLAIMS OF INFRINGEMENT, IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 */

/*
 * helloworld.c: simple test application
 */

#include <stdio.h>
#include "platform.h"
#include "xadcps.h"
#include "xil_types.h"
#define XPAR_AXI_XADC_0_DEVICE_ID 0

static XAdcPs XADCMonInst;

int main()
{
  XAdcPs_Config *ConfigPtr;
  XAdcPs *XADCInstPtr = &XADCMonInst;

  //status of initialization
  int Status_ADC;

  //temperature readings
  u32 TempRawData;
  float TempData;

  //Vcc Int readings
  u32 VccIntRawData;
  float VccIntData;

  //Vcc Aux readings
  u32 VccAuxRawData;
  float VccAuxData;

  //Vbram readings
  u32 VBramRawData;
  float VBramData;

  //VccPInt readings
  u32 VccPIntRawData;
  float VccPIntData;

  //VccPAux readings
  u32 VccPAuxRawData;
  float VccPAuxData;

  //Vddr readings
  u32 VDDRRawData;
  float VDDRData;

  init_platform();

  printf("Adam Edition MicroZed Using Vivado How To Printf \n\r");

  //XADC initialization

  ConfigPtr = XAdcPs_LookupConfig(XPAR_AXI_XADC_0_DEVICE_ID);
  if (ConfigPtr == NULL) {
    return XST_FAILURE;
  }

  Status_ADC = XAdcPs_CfgInitialize(XADCInstPtr,ConfigPtr,ConfigPtr->BaseAddress);
  if(XST_SUCCESS != Status_ADC){
    print("ADC INIT FAILED\n\r");
    return XST_FAILURE;
  }

  //self test
  Status_ADC = XAdcPs_SelfTest(XADCInstPtr);
  if (Status_ADC != XST_SUCCESS) {
    return XST_FAILURE;
  }

  //stop sequencer
  XAdcPs_SetSequencerMode(XADCInstPtr,XADCPS_SEQ_MODE_SINGCHAN);

  //disable alarms
  XAdcPs_SetAlarmEnables(XADCInstPtr, 0x0);

  //configure sequencer to just sample internal on chip parameters
  XAdcPs_SetSeqInputMode(XADCInstPtr, XADCPS_SEQ_MODE_SAFE);

  //configure the channel enables we want to monitor
  XAdcPs_SetSeqChEnables(XADCInstPtr,
                         XADCPS_CH_TEMP|
                         XADCPS_CH_VCCINT|
                         XADCPS_CH_VCCAUX|
                         XADCPS_CH_VBRAM|
                         XADCPS_CH_VCCPINT|
                         XADCPS_CH_VCCPAUX|
                         XADCPS_CH_VCCPDRO);

  while(1){
    TempRawData = XAdcPs_GetAdcData(XADCInstPtr, XADCPS_CH_TEMP);
    TempData = XAdcPs_RawToTemperature(TempRawData);
    printf("Raw Temp %lu Real Temp %f \n\r", TempRawData, TempData);

    VccIntRawData = XAdcPs_GetAdcData(XADCInstPtr, XADCPS_CH_VCCINT);
    VccIntData = XAdcPs_RawToVoltage(VccIntRawData);
    printf("Raw VccInt %lu Real VccInt %f \n\r", VccIntRawData, VccIntData);

    VccAuxRawData = XAdcPs_GetAdcData(XADCInstPtr, XADCPS_CH_VCCAUX);
    VccAuxData = XAdcPs_RawToVoltage(VccAuxRawData);
    printf("Raw VccAux %lu Real VccAux %f \n\r", VccAuxRawData, VccAuxData);

    // VrefPRawData = XAdcPs_GetAdcData(XADCInstPtr, XADCPS_CH_VREFP);
    // VrefPData = XAdcPs_RawToVoltage(VrefPRawData);
    // printf("Raw VRefP %lu Real VRefP %f \n\r", VrefPRawData, VrefPData);

    // VrefNRawData = XAdcPs_GetAdcData(XADCInstPtr, XADCPS_CH_VREFN);
    // VrefNData = XAdcPs_RawToVoltage(VrefNRawData);
    // printf("Raw VRefN %lu Real VRefN %f \n\r", VrefNRawData, VrefNData);

    VBramRawData = XAdcPs_GetAdcData(XADCInstPtr, XADCPS_CH_VBRAM);
    VBramData = XAdcPs_RawToVoltage(VBramRawData);
    printf("Raw VccBram %lu Real VccBram %f \n\r", VBramRawData, VBramData);

    VccPIntRawData = XAdcPs_GetAdcData(XADCInstPtr, XADCPS_CH_VCCPINT);
    VccPIntData = XAdcPs_RawToVoltage(VccPIntRawData);
    printf("Raw VccPInt %lu Real VccPInt %f \n\r", VccPIntRawData, VccPIntData);

    VccPAuxRawData = XAdcPs_GetAdcData(XADCInstPtr, XADCPS_CH_VCCPAUX);
    VccPAuxData = XAdcPs_RawToVoltage(VccPAuxRawData);
    printf("Raw VccPAux %lu Real VccPAux %f \n\r", VccPAuxRawData, VccPAuxData);

    VDDRRawData = XAdcPs_GetAdcData(XADCInstPtr, XADCPS_CH_VCCPDRO);
    VDDRData = XAdcPs_RawToVoltage(VDDRRawData);
    printf("Raw VccDDR %lu Real VccDDR %f \n\r", VDDRRawData, VDDRData);
  }

  return 0;
}