Scribd
Upload
24 views4 pages

Helloworld C

The document describes a program that initializes an ADC and GPIO device on a Zynq chip. It takes readings from various ADC channels and prints the raw and converted values. It also toggles an LED based on the state of a push button.

Uploaded by

khin600
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
24 views4 pages

Helloworld C

The document describes a program that initializes an ADC and GPIO device on a Zynq chip. It takes readings from various ADC channels and prints the raw and converted values. It also toggles an LED based on the state of a push button.

Uploaded by

khin600
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
You are on page 1/ 4

/*

* 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 "xgpiops.h"
#include "xil_types.h"

#define XPAR_AXI_XADC_0_DEVICE_ID 0

#define ledpin 47
#define pbsw 51
#define LED_DELAY 10000000
//void print(char *str);

static XAdcPs XADCMonInst;


XGpioPs Gpio; /* The driver instance for GPIO Device. */

int main()
{

XAdcPs_Config *ConfigPtr;
XAdcPs *XADCInstPtr = &XADCMonInst;

int Status;
int delay;
u32 sw;
int toggle;
XGpioPs_Config *GPIOConfigPtr;

//status of initialisation
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");

//GPIO Initilization
GPIOConfigPtr = XGpioPs_LookupConfig(XPAR_XGPIOPS_0_DEVICE_ID);
Status = XGpioPs_CfgInitialize(&Gpio, GPIOConfigPtr,GPIOConfigPtr->BaseAddr);
if (Status != XST_SUCCESS) {
print("GPIO INIT FAILED\n\r");
return XST_FAILURE;
}

//set direction and enable output


XGpioPs_SetDirectionPin(&Gpio, ledpin, 1);
XGpioPs_SetOutputEnablePin(&Gpio, ledpin, 1);

//set direction input pin


XGpioPs_SetDirectionPin(&Gpio, pbsw, 0x0);

//XADC initilization

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);

// XGpioPs_WritePin(&Gpio, ledpin, 0x0);

for( delay = 0; delay < LED_DELAY; delay++)//wait


{}

sw = XGpioPs_ReadPin(&Gpio, pbsw);

if (sw == 1) {
toggle = !toggle;

}
printf("switch value %lu \n\r",sw);
XGpioPs_WritePin(&Gpio, ledpin, toggle);

return 0;
}

You might also like

pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy