int SetupPeripherals( void )
{
int status;
XGpio_Initialize(&gpio_blinky, XPAR_AXI_GPIO_LED_DEVICE_ID);
XGpio_SetDataDirection(&gpio_blinky, 2, 0);
XGpio_SetDataDirection(&gpio_blinky, 1, 0);
XGpio_DiscreteWrite(&gpio_blinky, 1, 0);
XGpio_DiscreteWrite(&gpio_blinky, 2, 0);
XGpio_Initialize(&gpio_gain, XPAR_AXI_GPIO_GAIN_DEVICE_ID);
XGpio_SetDataDirection(&gpio_gain, 1, 0); // out
XGpio_Initialize(&gpio_sw_test, XPAR_AXI_GPIO_SWITCH_TEST_MODES_DEVICE_ID);
XGpio_SetDataDirection(&gpio_sw_test, 1, 3);
XGpio_Initialize(&gpio_sw_tx_pa, XPAR_AXI_GPIO_PA_DEVICE_ID);
XGpio_SetDataDirection(&gpio_sw_tx_pa, 1, 1+2+4+8+16);
XGpio_Initialize(&gpio_btn, XPAR_AXI_GPIO_BUTTON_DEVICE_ID);
XGpio_SetDataDirection(&gpio_btn, 1, 1);
pUartPsConfig = XUartPs_LookupConfig(XPAR_PS7_UART_1_DEVICE_ID);
if (NULL == pUartPsConfig) {
return XST_FAILURE;
}
status = XUartPs_CfgInitialize(&uartPs, pUartPsConfig, pUartPsConfig->BaseAddress);
if (status != XST_SUCCESS) {
return XST_FAILURE;
}
XUartPs_SetBaudRate(&uartPs, 115200);
return XST_SUCCESS;
}
int main (void)
{
XGpio dip, push;
int i, psb_check, dip_check;
xil_printf("-- Start of the Program --\r\n");
XGpio_Initialize(&dip, XPAR_SW_4BIT_DEVICE_ID);
XGpio_SetDataDirection(&dip, 1, 0xffffffff);
XGpio_Initialize(&push, XPAR_BTNS_4BIT_DEVICE_ID);
XGpio_SetDataDirection(&push, 1, 0xffffffff);
while (1)
{
psb_check = XGpio_DiscreteRead(&push, 1);
xil_printf("Push Buttons Status %x\r\n", psb_check);
dip_check = XGpio_DiscreteRead(&dip, 1);
xil_printf("DIP Switch Status %x\r\n", dip_check);
for (i=0; i<9999999; i++);
}
}
int main(void){
int status;
int delay = 100000;
int temp=148;
//INITILIZE THE GPIO
status = XGpio_Initialize(&SwitchInst, SWITCH_DEVICE_ID);
if(status != XST_SUCCESS) return XST_FAILURE;
status = XGpio_Initialize(&DutycycleInst, DUTYCYCLE_DEVICE_ID);
if(status != XST_SUCCESS) return XST_FAILURE;
//SET GPIO DATA DIRECTIONS
XGpio_SetDataDirection(&SwitchInst, 1, 0xFF);
XGpio_SetDataDirection(&DutycycleInst, 1, 0x00);
//DO SOMETHING HERE IN MAIN **EDIT**
while(1){
switch_value = XGpio_DiscreteRead(&SwitchInst, 1);
//for(int i = 0; i < delay; i++);
temp = (100+(switch_value*5.625));
XGpio_DiscreteWrite(&DutycycleInst, 1, temp);
}
return 0;
}
int main (void)
{
XGpio dip, push;
int i, psb_check, dip_check;
xil_printf("-- Start of the Program --\r\n");
XGpio_Initialize(&dip, XPAR_SW_4BIT_DEVICE_ID); // Modify this
XGpio_SetDataDirection(&dip, 1, 0xffffffff);
XGpio_Initialize(&push, XPAR_BTNS_4BIT_DEVICE_ID); // Modify this
XGpio_SetDataDirection(&push, 1, 0xffffffff);
while (1)
{
psb_check = XGpio_DiscreteRead(&push, 1);
xil_printf("Push Buttons Status %x\r\n", psb_check);
dip_check = XGpio_DiscreteRead(&dip, 1);
xil_printf("DIP Switch Status %x\r\n", dip_check);
// output dip switches value on LED_ip device
LED_IP_mWriteReg(XPAR_LED_IP_0_S_AXI_BASEADDR,0,dip_check);
for (i=0; i<9999999; i++);
}
}
void Initialize()
{
XGpio_Initialize(&Dips, XPAR_DIP_DEVICE_ID);
XGpio_SetDataDirection(&Dips, 1, 0xff);
XGpio_Initialize(&Btns, XPAR_BUTTON_DEVICE_ID);
XGpio_SetDataDirection(&Btns, 1, 0xff);
XIntc_Initialize(&intCtrl, XPAR_AXI_INTC_0_DEVICE_ID);
XGpio_InterruptEnable(&Btns, 1);
XGpio_InterruptGlobalEnable(&Btns);
XGpio_InterruptEnable(&Dips, 1);
XGpio_InterruptGlobalEnable(&Dips);
XIntc_Enable(&intCtrl, XPAR_AXI_INTC_0_BUTTON_IP2INTC_IRPT_INTR);
XIntc_Enable(&intCtrl, XPAR_AXI_INTC_0_DIP_IP2INTC_IRPT_INTR);
XIntc_Connect(&intCtrl, XPAR_AXI_INTC_0_BUTTON_IP2INTC_IRPT_INTR,
(XInterruptHandler)PushBtnHandler, (void *)0);
XIntc_Connect(&intCtrl, XPAR_AXI_INTC_0_DIP_IP2INTC_IRPT_INTR,
(XInterruptHandler)SwitchHandler,(void *)0);
microblaze_enable_interrupts();
microblaze_register_handler((XInterruptHandler)XIntc_InterruptHandler, (void *)&intCtrl);
XIntc_Start(&intCtrl, XIN_REAL_MODE);
}
void initGPIO()
{
XGpio_Initialize(&xgpio_pushButtons, XPAR_PUSH_BUTTONS_5BITS_DEVICE_ID);
XGpio_SetDataDirection(&xgpio_pushButtons, 1, 0x0000001F);
XGpio_Initialize(&xgpio_LEDs, XPAR_LEDS_8BITS_DEVICE_ID);
XGpio_SetDataDirection(&xgpio_LEDs, 1, 0x00000000);
XGpio_Initialize(&xgpio_switches, XPAR_SLIDE_SWITCHES_8BITS_DEVICE_ID);
XGpio_SetDataDirection(&xgpio_switches, 1, 0x000000FF);
}
int init_axi_gpio() {
// Initialize the LED
if (XGpio_Initialize(&XGpio_LED, LED_DEVICE_ID) != XST_SUCCESS) {
return XST_FAILURE;
}
// Set the direction for all signals to be outputs
XGpio_SetDataDirection(&XGpio_LED, LED_CHANNEL, 0x0);
// Set the GPIO outputs to low
XGpio_DiscreteWrite(&XGpio_LED, LED_CHANNEL, 0x0);
// Initialize the DEBUG output
if (XGpio_Initialize(&XGpio_debug, DEBUG_DEVICE_ID) != XST_SUCCESS) {
return XST_FAILURE;
}
// Set the direction for all signals to be outputs
XGpio_SetDataDirection(&XGpio_debug, DEBUG_CHANNEL, 0x0);
// Set the GPIO outputs to low
XGpio_DiscreteWrite(&XGpio_debug, DEBUG_CHANNEL, 0x0);
// Initialize the Guard Trigger
if (XGpio_Initialize(&XGpio_Guard_Trigger, GUARD_TRIGGER_DEVICE_ID) != XST_SUCCESS) {
return XST_FAILURE;
}
// Set the direction for all signals to be outputs
XGpio_SetDataDirection(&XGpio_Guard_Trigger, GUARD_TRIGGER_CHANNEL, 0x0);
// Set the GPIO outputs to low
XGpio_DiscreteWrite(&XGpio_Guard_Trigger, GUARD_TRIGGER_CHANNEL, 0x0);
// Initialize the BTN
if (XGpio_Initialize(&XGpio_BTN, BTN_DEVICE_ID) != XST_SUCCESS) {
return XST_FAILURE;
}
// Set the direction for all signals to be inputs
XGpio_SetDataDirection(&XGpio_BTN, BTN_CHANNEL, 0xF);
// Initialize the SW
if (XGpio_Initialize(&XGpio_SW, SW_DEVICE_ID) != XST_SUCCESS) {
return XST_FAILURE;
}
// Set the direction for all signals to be inputs
XGpio_SetDataDirection(&XGpio_SW, SW_CHANNEL, 0xF);
return 0;
}
void do_gpio_init(void) {
FUNC_ENTER();
// direction: Bits set to 0 are output and bits set to 1 are input.
XGpio_Initialize(&m_gpioDIP8, XPAR_DIP_SWITCHES_8BIT_DEVICE_ID);
XGpio_SetDataDirection(&m_gpioDIP8, 1, 0xFFFFFFFF); // dip switches are inputs
XGpio_Initialize(&m_gpioPBs5, XPAR_PUSH_BUTTONS_5BIT_DEVICE_ID);
XGpio_SetDataDirection(&m_gpioPBs5, 1, 0xFFFFFFFF); // push buttons are inputs
XGpio_Initialize(&m_gpioLEDs8, XPAR_LEDS_8BIT_DEVICE_ID);
XGpio_SetDataDirection(&m_gpioLEDs8, 1, 0x00000000); // LEDs are outputs
}
static void prvSetupHardware( void )
{
portBASE_TYPE xStatus;
const unsigned char ucSetToOutput = 0U;
/* Initialize the GPIO for the LEDs. */
xStatus = XGpio_Initialize( &xOutputGPIOInstance, XPAR_LEDS_4BITS_DEVICE_ID );
if( xStatus == XST_SUCCESS )
{
/* All bits on this channel are going to be outputs (LEDs). */
XGpio_SetDataDirection( &xOutputGPIOInstance, ulGPIOOutputChannel, ucSetToOutput );
/* Start with all LEDs off. */
ucGPIOState = 0U;
XGpio_DiscreteWrite( &xOutputGPIOInstance, ulGPIOOutputChannel, ucGPIOState );
}
/* Initialise the GPIO for the button inputs. */
if( xStatus == XST_SUCCESS )
{
xStatus = XGpio_Initialize( &xInputGPIOInstance, XPAR_PUSH_BUTTONS_4BITS_DEVICE_ID );
}
if( xStatus == XST_SUCCESS )
{
/* Install the handler defined in this task for the button input.
*NOTE* The FreeRTOS defined xPortInstallInterruptHandler() API function
must be used for this purpose. */
xStatus = xPortInstallInterruptHandler( XPAR_MICROBLAZE_0_INTC_PUSH_BUTTONS_4BITS_IP2INTC_IRPT_INTR, prvButtonInputInterruptHandler, NULL );
if( xStatus == pdPASS )
{
/* Set buttons to input. */
XGpio_SetDataDirection( &xInputGPIOInstance, ulGPIOInputChannel, ~( ucSetToOutput ) );
/* Enable the button input interrupts in the interrupt controller.
*NOTE* The vPortEnableInterrupt() API function must be used for this
purpose. */
vPortEnableInterrupt( XPAR_MICROBLAZE_0_INTC_PUSH_BUTTONS_4BITS_IP2INTC_IRPT_INTR );
/* Enable GPIO channel interrupts. */
XGpio_InterruptEnable( &xInputGPIOInstance, ulGPIOInputChannel );
XGpio_InterruptGlobalEnable( &xInputGPIOInstance );
}
}
configASSERT( ( xStatus == pdPASS ) );
}
int main()
{
XScuTimer_Config *TMRConfigPtr; //timer config
//Disable cache on OCM
Xil_SetTlbAttributes(0xFFFF0000,0x14de2); // S=b1 TEX=b100 AP=b11, Domain=b1111, C=b0, B=b0
print("CPU1: starting\n\r");
//GPIO Initilization
XGpio_Initialize(&Gpio, GPIO_DEVICE_ID);
XGpio_SetDataDirection(&Gpio, CHANNEL, 0x00);
XGpio_DiscreteWrite(&Gpio,CHANNEL, 0xff);
//timer initialisation
TMRConfigPtr = XScuTimer_LookupConfig(TIMER_DEVICE_ID);
XScuTimer_CfgInitialize(&Timer, TMRConfigPtr,TMRConfigPtr->BaseAddr);
XScuTimer_SelfTest(&Timer);
//load the timer
XScuTimer_LoadTimer(&Timer, TIMER_LOAD_VALUE);
SetupInterruptSystem(&Intc, &Timer,TIMER_IRPT_INTR);
XScuTimer_Start(&Timer);
print("CPU1: configured\n\r");
while(1){
}
return 0;
}
void init_mb_adc_parallel()
{
//Initialize ADC Data GPIO
XGpio_Initialize(&ADCData, XPAR_OPB_GPIO_0_DEVICE_ID);
//Set lower 8 bits to input
XGpio_SetDataDirection(&ADCData, 1, 0xFF);
//Initialize ADC Control GPIO
XGpio_Initialize(&ADCControl, XPAR_OPB_GPIO_1_DEVICE_ID);
//Set direction, only input is busy signal
XGpio_SetDataDirection(&ADCControl, 1, 0x2);
XGpio_DiscreteWrite(&ADCControl, 1, MB_ADC_PARALLEL_RD);
}
/*
* Setup the IO for the LED outputs.
*/
err_t
led_init(void)
{
portBASE_TYPE xStatus;
const u8 ucSetToOutput = 0U;
/* Initialise the GPIO for the LEDs. */
xStatus = XGpio_Initialize(
&xOutputGPIOInstance,
LED_GPIO_DEVICE_ID);
if (xStatus == XST_SUCCESS) {
/* All bits on this channel are going to be outputs (LEDs). */
XGpio_SetDataDirection(
&xOutputGPIOInstance,
uxGPIOOutputChannel,
ucSetToOutput);
/* Start with all LEDs off. */
ucGPIOState = 0U;
XGpio_DiscreteWrite( &xOutputGPIOInstance, uxGPIOOutputChannel, ucGPIOState );
}
/* FIXME return valid FlexCOS error code */
return xStatus;
}
/*****
* do_init() - initialize the system
*
* This function is executed once at start-up and after a reset. It initializes
* the peripherals and registers the interrupt handlers
*****/
XStatus do_init(void) {
XStatus Status; // status from Xilinx Lib calls
// initialize the N3EIF driver
// rotary encoder is set to increment from 0 by 1
// NOTE: it's the relative change from the last time the rotary encoder was sampled
// not the absolute change that matters. The actual change is handled in main() so we
// can apply a "speedup" factor if the knob is being turned quickly.
N3EIF_init(N3EIF_BASEADDR);
ROT_init(1, false);
ROT_clear();
// initialize the GPIO instance
Status = XGpio_Initialize(&GPIOInst, GPIO_DEVICE_ID);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
// GPIO channel 1 is an 8-bit output port that your application can
// use. None of the bits are used by this program
XGpio_SetDataDirection(&GPIOInst, GPIO_OUTPUT_CHANNEL, 0xF0);
XGpio_DiscreteWrite(&GPIOInst, GPIO_OUTPUT_CHANNEL, gpio_port);
// initialize the PWM timer/counter instance but do not start it
// do not enable PWM interrupts
Status = PWM_Initialize(&PWMTimerInst, PWM_TIMER_DEVICE_ID, false);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
// initialize the PmodCtlSys
Status = PmodCtlSys_init(&SPIInst, SPI_DEVICEID);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
// initialize the interrupt controller
Status = XIntc_Initialize(&IntrptCtlrInst, INTC_DEVICE_ID);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
// connect the fixed interval timer (FIT) handler to the interrupt
Status = XIntc_Connect(&IntrptCtlrInst, FIT_INTERRUPT_ID,
(XInterruptHandler) FIT_Handler, (void *) 0);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
// start the interrupt controller such that interrupts are enabled for
// all devices that cause interrupts, specifically real mode so that
// the the FIT can cause interrupts thru the interrupt controller.
Status = XIntc_Start(&IntrptCtlrInst, XIN_REAL_MODE);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
// enable the FIT interrupt
XIntc_Enable(&IntrptCtlrInst, FIT_INTERRUPT_ID);
return XST_SUCCESS;
}
int LEDOutputExample(void)
{
volatile int Delay;
int Status;
int led = LED; /* Hold current LED value. Initialize to LED definition */
/* GPIO driver initialization */
Status = XGpio_Initialize(&Gpio, GPIO_DEVICE_ID);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*Set the direction for the LEDs to output. */
XGpio_SetDataDirection(&Gpio, LED_CHANNEL, 0x00);
/* Loop forever blinking the LED. */
while (1) {
/* Write output to the LEDs. */
XGpio_DiscreteWrite(&Gpio, LED_CHANNEL, led);
/* Flip LEDs. */
led = ~led;
/* Wait a small amount of time so that the LED blinking is visible. */
for (Delay = 0; Delay < LED_DELAY; Delay++);
}
return XST_SUCCESS; /* Ideally unreachable */
}
int main() {
init_platform();
// Initialize the GPIO peripherals.
XGpio_Initialize(&gpPB, XPAR_PUSH_BUTTONS_5BITS_DEVICE_ID);
// Set the push button peripheral to be inputs.
XGpio_SetDataDirection(&gpPB, 1, 0x0000001F);
// Enable the global GPIO interrupt for push buttons.
XGpio_InterruptGlobalEnable(&gpPB);
// Enable all interrupts in the push button peripheral.
XGpio_InterruptEnable(&gpPB, 0xFFFFFFFF);
interrupts_init();
print("made it past interrupts_init\n\r");
// apparently we don't need to init it, just HardReset
XAC97_HardReset(XPAR_AXI_AC97_0_BASEADDR);
XAC97_WriteReg(XPAR_AXI_AC97_0_BASEADDR, AC97_ExtendedAudioStat, 1);
XAC97_WriteReg(XPAR_AXI_AC97_0_BASEADDR, AC97_PCM_DAC_Rate, AC97_PCM_RATE_11025_HZ);
XAC97_mSetControl(XPAR_AXI_AC97_0_BASEADDR, AC97_ENABLE_IN_FIFO_INTERRUPT);
XAC97_WriteReg(XPAR_AXI_AC97_0_BASEADDR, AC97_MasterVol, AC97_VOL_MAX);
XAC97_WriteReg(XPAR_AXI_AC97_0_BASEADDR, AC97_PCMOutVol, AC97_VOL_MAX);
while (1);
cleanup_platform();
return 0;
}
/**
*
* This function performs a test on the GPIO driver/device with the GPIO
* configured as INPUT
*
* @param DeviceId is the XPAR_<GPIO_instance>_DEVICE_ID value from
* xparameters.h
* @param DataRead is the pointer where the data read from GPIO Input is
* returned
*
* @return XST_SUCCESS if the Test is successful, otherwise XST_FAILURE
*
* @note None.
*
******************************************************************************/
int GpioInputExample(u16 DeviceId, u32 *DataRead)
{
int Status;
/*
* Initialize the GPIO driver so that it's ready to use,
* specify the device ID that is generated in xparameters.h
*/
Status = XGpio_Initialize(&GpioInput, DeviceId);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Set the direction for all signals to be inputs
*/
XGpio_SetDataDirection(&GpioInput, LED_CHANNEL, 0xFFFFFFFF);
/*
* Read the state of the data so that it can be verified
*/
*DataRead = XGpio_DiscreteRead(&GpioInput, LED_CHANNEL);
return XST_SUCCESS;
}
int main(int argc, char *argv[])
{
XGpio led_gpio; /* LED Instance */
/* Initialize LED GPIO settings */
XGpio_Initialize(&led_gpio, XPAR_AXI_GPIO_0_DEVICE_ID);
XGpio_SetDataDirection(&led_gpio, 1, 0);
/* Output something via UART1, 115200 baudrate */
printf("Start to blink led_gpio !!!\n\r");
int led_value = 0x03; /* default led_gpio value */
while(1) {
printf("led_gpio value set to 0x%X\n\r", led_value);
/* Set GPIO Channel 1 value. */
XGpio_DiscreteWrite(&led_gpio, 1 , led_value);
/* sleep and change led_gpio value */
simple_delay(10000000);
led_value = ~led_value;
}
return 0;
}
void init_GPIO_BUTTONS(XGpio *InstancePtr, u16 Device_ID)
{
int Status;
XGpio_Config *Config;
Config = XGpio_LookupConfig(Device_ID);
Status = XGpio_CfgInitialize(InstancePtr, Config, Config->BaseAddress);
// Initialise GPIO devices
Status = XGpio_Initialize(InstancePtr, Device_ID);
// Set GPIO direction (output for LEDs and input for BTNS)
XGpio_SetDataDirection(InstancePtr, 1, 0xFF);
if(Status != XST_FAILURE) {
xil_printf("BUTTONS initialized!\n \r");
}
XGpio_InterruptEnable(&ButtonsInstancePtr, 1);
XGpio_InterruptGlobalEnable(&ButtonsInstancePtr);
// Initialize interrupt controller
//IntcInitFunction(INTCONTROLLER_DEVICE_ID, InstancePtr);
}
int main(void)
{
u32 Data;
u32 InData;
int Status;
volatile int Delay;
char test_vect_idx =0;
char charidx = 0;
u8 DataWrittenDone = 0;
char curchar;
init_platform();
/*
* Initialize the GPIO driver
*/
Status = XGpio_Initialize(&Gpio, GPIO_EXAMPLE_DEVICE_ID);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
for (test_vect_idx=0;test_vect_idx<num_test_vectors;test_vect_idx++)
{
for (charidx=0;charidx<64;charidx++)
{
curchar = testvector[test_vect_idx][charidx]; //Read the current character
Data = createDataPacket(curchar,charidx,test_vect_idx); //Send the 'A' character to byte 3 of testvector 1
print("Sending character \n");
XGpio_DiscreteWrite(&Gpio, OUPTPUT_CHANNEL, Data); //Write into the PL
//Double check by reading from the PL
for (Delay = 0; Delay < LED_DELAY; Delay++); //Wait for a while
//Read back the data from the PL side to see its status
do
{
InData = XGpio_DiscreteRead(&Gpio, INPUT_CHANNEL);
for (Delay = 0; Delay < LED_DELAY; Delay++); //Wait for a while before recheck
}
while (InData&(1<<31));
if ((InData&0xFF)==(Data&0xFF))
{
print("Correct\n");
}
else
{
print("Incorrect\n");
}
XGpio_DiscreteWrite(&Gpio, OUPTPUT_CHANNEL, 0x00000000); //Release the bus immediately
for (Delay = 0; Delay < LED_DELAY; Delay++); //Wait for a while
}
}
print("Done sending. Please press the center button to begin...");
cleanup_platform();
return XST_SUCCESS;
}
void init_mb_dipsw()
{
//Initialize ADC Data GPIO
XGpio_Initialize(&DipSW, XPAR_DIPSWS_4BIT_DEVICE_ID);
//Set lower 8 bits to input
XGpio_SetDataDirection(&DipSW, 1, 0xFF);
}
/*****
* do_init() - initialize the system
*
* This function is executed once at start-up and after resets. It initializes
* the peripherals and registers the interrupt handlers
*****/
XStatus do_init(void)
{
XStatus Status; // status from Xilinx Lib calls
// initialize the S3E starter board interface
// rotary encoder is set to increment from 0 by DUTY_CYCLE_CHANGE
N3EIF_init(N3EIF_BASEADDR);
ROT_init(DUTY_CYCLE_CHANGE, true);
ROT_clear();
// initialize the GPIO instance
Status = XGpio_Initialize(&GPIOInst, GPIO_DEVICE_ID);
if (Status != XST_SUCCESS)
{
return XST_FAILURE;
}
// GPIO channel 1 is an 8-bit input port. bit[7:1] = reserved, bit[0] = PWM output (for duty cycle calculation)
// GPIO channel 2 is an 8-bit output port. bit[7:1] = reserved, bit[0] = FIT clock
XGpio_SetDataDirection(&GPIOInst, GPIO_OUTPUT_CHANNEL, 0xFE);
// initialize the PWM timer/counter instance but do not start it
// do not enable PWM interrupts
Status = PWM_Initialize(&PWMTimerInst, PWM_TIMER_DEVICE_ID, false);
if (Status != XST_SUCCESS)
{
return XST_FAILURE;
}
// initialize the interrupt controller
Status = XIntc_Initialize(&IntrptCtlrInst,INTC_DEVICE_ID);
if (Status != XST_SUCCESS)
{
return XST_FAILURE;
}
// connect the fixed interval timer (FIT) handler to the interrupt
Status = XIntc_Connect(&IntrptCtlrInst, FIT_INTERRUPT_ID,
(XInterruptHandler)FIT_Handler,
(void *)0);
if (Status != XST_SUCCESS)
{
return XST_FAILURE;
}
// start the interrupt controller such that interrupts are enabled for
// all devices that cause interrupts.
Status = XIntc_Start(&IntrptCtlrInst, XIN_REAL_MODE);
if (Status != XST_SUCCESS)
{
return XST_FAILURE;
}
// enable the FIT interrupt
XIntc_Enable(&IntrptCtlrInst, FIT_INTERRUPT_ID);
return XST_SUCCESS;
}
int init_gpio(XGpio *GpioInstancePtr){
int Status;
Status = XGpio_Initialize(GpioInstancePtr, GPIO_DEVICE_ID);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
XGpio_SetDataDirection(GpioInstancePtr, LED_CHANNEL, 0x0);
return XST_SUCCESS;
}
int SetupPeripherals( void )
{
XGpio_Initialize(&gpio_blinky, XPAR_AXI_GPIO_LED_DEVICE_ID);
XGpio_SetDataDirection(&gpio_blinky, 2, 0);
XGpio_SetDataDirection(&gpio_blinky, 1, 0);
XGpio_DiscreteWrite(&gpio_blinky, 1, 0);
XGpio_DiscreteWrite(&gpio_blinky, 2, 0);
return XST_SUCCESS;
}
int main(void){
printf ("-- Entering main () -- \r\n");
int status;
int statusAll = 1;
XGpio dip, leds;
int i, dip_check;
int count=0;
status = XGpio_Initialize (&dip, XPAR_DIP_SWITCHES_8BIT_DEVICE_ID);
if (status != XST_SUCCESS){
statusAll = 0;
printf("DIP switch initialization failure! \r \n");
}
else {
XGpio_SetDataDirection (&dip, 1, 0xffffffff);\
printf("DIP switch initialization success. \r \n");
}
status = XGpio_Initialize(&leds, XPAR_LEDS_8BIT_DEVICE_ID);
if (status != XST_SUCCESS){
statusAll = 0;
printf("LEDs initialization failure! \r \n");
}
else {
XGpio_SetDataDirection (&leds, 1, 0x00000000);
printf("LEDs initialization Success! \r \n");
}
while(1){
dip_check = XGpio_DiscreteRead(&dip,1);
printf("Prog2: DIP switches status %x \r\n", dip_check);
XGpio_DiscreteWrite (&leds, 1, count);
for(i=0; i<999999; i++);
count++;
}
printf("--Exiting main() -- \r\n");
return 0;
}
int status_init(void) {
int rv;
// initialize the GPIO hardware
XGpio_Initialize(&LED, XPAR_XPS_GPIO_1_DEVICE_ID );
XGpio_SetDataDirection(&LED, 1, 0 );
XGpio_DiscreteWrite(&LED,1,0x1F);
XGpio_Initialize(&JP1, XPAR_XPS_GPIO_0_DEVICE_ID );
XGpio_SetDataDirection(&JP1, 1, 0xF );
status_set( 0, s_init );
#ifdef __XMK__
// I think using pthread_create is OK since this thread does not access any LwIP stuff.
return pthread_create( &status_tid, NULL, status_thread, NULL );
#else
return 0;
#endif
}
void init_all(void) {
XIntc_Initialize(&intc, XPAR_XPS_INTC_0_DEVICE_ID);
microblaze_enable_interrupts();
XIntc_mMasterEnable(XPAR_INTC_0_BASEADDR);
XUartLite_mEnableIntr(XPAR_UARTLITE_0_BASEADDR);
//// пецхярпюжхъ напюанрвхйнб ////////////////////////////////////////////
XIntc_RegisterHandler(XPAR_XPS_INTC_0_BASEADDR,
XPAR_INTC_0_UARTLITE_0_VEC_ID,
(XInterruptHandler)handler_RS232,
(void *)0);
XIntc_RegisterHandler(XPAR_XPS_INTC_0_BASEADDR,
XPAR_INTC_0_TMRCTR_0_VEC_ID,
(XInterruptHandler)handler_Timer,
(void *)0);
///////////////////////////////////////////////////////////////////////////////
//// мюярпнийю рюилепю //////////////////////////////////////////////////////
XTmrCtr_mSetLoadReg(XPAR_XPS_TIMER_0_BASEADDR,
0,
0x61a8 //(25 MHz / 25000 = 1mS
//0x124F8//(75 MHz : 75.000 = 1 mS
);
XIntc_mEnableIntr(XPAR_INTC_0_BASEADDR,
// XPAR_XPS_TIMER_0_INTERRUPT_MASK |
XPAR_XPS_UARTLITE_0_INTERRUPT_MASK);
XTmrCtr_mSetControlStatusReg(XPAR_XPS_TIMER_0_BASEADDR,
0,
XTC_CSR_ENABLE_TMR_MASK |
XTC_CSR_ENABLE_INT_MASK |
XTC_CSR_AUTO_RELOAD_MASK |
XTC_CSR_DOWN_COUNT_MASK);
/////////////////////////////////////////////////////////////////////////////////
///////// мюярпнийю сярпниярб ббндю-бшбндю ////////////////////////////////////
XGpio_Initialize(&photo, XPAR_XPS_GPIO_0_DEVICE_ID);
XGpio_Initialize(&ircom, XPAR_XPS_GPIO_1_DEVICE_ID);
XGpio_Initialize(&kt, XPAR_XPS_GPIO_2_DEVICE_ID);
XGpio_SetDataDirection(&photo, 1, 0xffffffff); // ББНД
XGpio_SetDataDirection(&photo, 2, 0x00); // БШБНД
XGpio_SetDataDirection(&ircom, 1, 0x00); // БШБНД
XGpio_SetDataDirection(&ircom, 2, 0x00); // БШБНД
XGpio_SetDataDirection(&kt, 1, 0x00); // БШБНД
};
/*
* Initialize GPIO
*/
int initGpio() {
//Variables
int status;
//Initialize GPIOs
status = XGpio_Initialize(&outGpio, OUTGPIO_DEVICE_ID);
status = XGpio_Initialize(&inGpio, INGPIO_DEVICE_ID);
//Set Direction
XGpio_SetDataDirection(&outGpio, LED_CHANNEL, DIR_OUT);
XGpio_SetDataDirection(&inGpio, 1, DIR_IN);
XGpio_SetDataDirection(&inGpio, 2, DIR_IN);
//Clear LEDs
if (status == XST_SUCCESS) {
clearLEDs(status, &outGpio);
}
return XST_SUCCESS;
}
/**
*
* This function does a minimal test on the GPIO device configured as OUTPUT
* and driver as a example.
*
*
* @param DeviceId is the XPAR_<GPIO_instance>_DEVICE_ID value from
* xparameters.h
* @param GpioWidth is the width of the GPIO
*
* @return XST_SUCCESS if successful, XST_FAILURE if unsuccessful
*
* @note None
*
****************************************************************************/
void GpioOutputExample(Xuint16 DeviceId, Xuint32 GpioWidth)
{
volatile int Delay;
Xuint32 LedBit;
Xuint32 LedLoop;
XStatus Status;
int numTimes = 1;
/*
* Initialize the GPIO driver so that it's ready to use,
* specify the device ID that is generated in xparameters.h
*/
Status = XGpio_Initialize(&GpioOutput, DeviceId);
if (Status != XST_SUCCESS)
{
print("Gpio Instance Didn't Initialize!\r\n");
}
/*
* Set the direction for all signals to be outputs
*/
XGpio_SetDataDirection(&GpioOutput, 1, 0x0);
/*
* Set the GPIO outputs to low
*/
XGpio_DiscreteWrite(&GpioOutput, 1, 0x0);
while (numTimes > 0) {
for (LedBit = 0x0; LedBit < GpioWidth; LedBit++) {
for (LedLoop = 0; LedLoop < 1; LedLoop++) {
/*
* Set the GPIO Output to High
*/
XGpio_DiscreteWrite(&GpioOutput, 1, 1 << LedBit);
/*
* Wait a small amount of time so the LED is visible
*/
for (Delay = 0; Delay < (500000/2); Delay++)
{
// Dummy read; to ensure the delay has no Cache effect
XGpio_DiscreteRead(&GpioOutput, 1);
}
/*
* Clear the GPIO Output
*/
XGpio_DiscreteClear(&GpioOutput, 1, 1 << LedBit);
}
}
numTimes--;
}
}
void initInterrupts()
{
// Initialize the GPIO peripherals. NOTE: We wait to do this till after the HDMI to ensure that nothing happens before the HDMI is enabled.
XGpio_Initialize(&gpPB, XPAR_PUSH_BUTTONS_5BITS_DEVICE_ID);
// Set the push button peripheral to be inputs.
XGpio_SetDataDirection(&gpPB, 1, 0x0000001F);
XGpio_Initialize(&gpswitches, XPAR_SLIDE_SWITCHES_8BITS_DEVICE_ID);
XGpio_SetDataDirection(&gpswitches, 1, 0x000000FF);
microblaze_register_handler(interrupt_handler_dispatcher, NULL);
XIntc_EnableIntr(XPAR_INTC_0_BASEADDR,
(XPAR_PIT_0_INTERRUPT_MASK
| XPAR_PUSH_BUTTONS_5BITS_IP2INTC_IRPT_MASK
| XPAR_AXI_AC97_0_INTERRUPT_MASK
| XPAR_PS2CTRL_0_INTERRUPT_MASK));
XIntc_MasterEnable(XPAR_INTC_0_BASEADDR);
microblaze_enable_interrupts();
}
void TFTGPIO_init() {
if (initFlag)
return; // Already initialized, just return.
int status;
status = XGpio_Initialize(&gpioTft, TFTGPIO_DEVICE_ID);
if (status != XST_SUCCESS) {
printf("XGPIO_Initialize (TFT) failed\n\r.");
}
// Set the direction for all signals to be outputs (0 = output).
XGpio_SetDataDirection(&gpioTft, 1, 0); // 0 is a bit-mask that will set all pins as outputs.
initFlag = true;
}
