/*-----------------------------------------------------------*/ static void prvLed_Task( void *pvParameters ) { unsigned int uiLedFlag = 0; for (;;) { if ( xSemaphoreTake( xSemaphore_led, ( portTickType ) portMAX_DELAY ) == pdTRUE ) { uiLedFlag ^= 1; if (uiLedFlag) { /* * Set the GPIO Output to High. */ XGpioPs_WritePin(&Gpio, OUTPUT_PIN, 0x1); } else { /* * Set the GPIO Output to Low. */ XGpioPs_WritePin(&Gpio, OUTPUT_PIN, 0x0); } } else { xil_printf("xSemaphore_led take fail\r\n"); /* Call shutdown */ prvShutdown(); } } }
void config_oled() { printf("****configuring oled!!!!!!!!!!!!!****\n\r"); XGpioPs_WritePin(&Gpio, dc, 0); XSpiPs_SetSlaveSelect(&SpiInstance_EMIO, 0x01); XSpiPs_PolledTransfer(&SpiInstance_EMIO, init_vector, NULL, 23); XGpioPs_WritePin(&Gpio, dc, 1); printf("****done configuring oled!!!!!!!!!!!!!****\n\r"); }
void Timer_InterruptHandler(void *data, u8 TmrCtrNumber) { print("\r\n"); print("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\r\n"); print(" Inside Timer ISR \n \r "); XTmrCtr_Stop(&TimerInstancePtr,TmrCtrNumber); XGpioPs_WritePin(&psGpioInstancePtr,iPinNumber,0); XGpioPs_WritePin(&psGpioInstancePtr,55,0); XTmrCtr_Reset(&TimerInstancePtr,TmrCtrNumber); print(" Timer ISR Exit\n \n \r"); print("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\r\n"); }
static void FPGAIntrHandler(void *CallBackRef) { printf("FPGA Interrupt Event\n\r"); XGpioPs_WritePin(&Gpio, intpin, 0); }
/***************************************************************************//** * @brief gpio_data *******************************************************************************/ void gpio_data(uint8_t pin, uint8_t data) { #ifdef _XPARAMETERS_PS_H_ XGpioPs_WritePin(&gpio_instance, pin, data); #else uint32_t config = 0; uint32_t data_reg_addr; if (pin >= 32) { data_reg_addr = XGPIO_DATA2_OFFSET; pin -= 32; } else data_reg_addr = XGPIO_DATA_OFFSET; config = Xil_In32((gpio_config->BaseAddress + data_reg_addr)); if(data) { config |= (1 << pin); } else { config &= ~(1 << pin); } Xil_Out32((gpio_config->BaseAddress + data_reg_addr), config); #endif }
/*-----------------------------------------------------------*/ void prvSetGpioHardware( void ) { int Status; /* * Initialize the GPIO driver. */ ConfigPtr = XGpioPs_LookupConfig(GPIO_DEVICE_ID); Status = XGpioPs_CfgInitialize(&Gpio, ConfigPtr, ConfigPtr->BaseAddr); if (Status != XST_SUCCESS) { xil_printf("GPIO Initialize failed\n"); } /* * Set the direction for the pin to be output and * Enable the Output enable for the LED Pin. */ XGpioPs_SetDirectionPin(&Gpio, OUTPUT_PIN, 1); XGpioPs_SetOutputEnablePin(&Gpio, OUTPUT_PIN, 1); /* * Set the GPIO output to be low. */ XGpioPs_WritePin(&Gpio, OUTPUT_PIN, 0x0); }
void JtagInitGpio () { js_printf("===== Initializing PS GPIO pins...\n\r"); XGpioPs_Config *ptrConfigPtrPs = XGpioPs_LookupConfig(0); XGpioPs_CfgInitialize(&structXGpioPs,ptrConfigPtrPs,ptrConfigPtrPs->BaseAddr); /* Unlock the SLCR block */ Xil_Out32 (0xF8000000 + 0x8, 0xDF0D); GpioConfig((GPIO_BASE_ADDR+(g_mio_jtag_tdi*4)),GPIO_MASK_VAL, GPIO_TDI_VAL); GpioConfig((GPIO_BASE_ADDR+(g_mio_jtag_tdo*4)),GPIO_MASK_VAL, GPIO_TDO_VAL); GpioConfig((GPIO_BASE_ADDR+(g_mio_jtag_tck*4)),GPIO_MASK_VAL, GPIO_TCK_VAL); GpioConfig((GPIO_BASE_ADDR+(g_mio_jtag_tms*4)),GPIO_MASK_VAL, GPIO_TMS_VAL); GpioConfig((GPIO_BASE_ADDR+(g_mio_jtag_mux_sel*4)),GPIO_MASK_VAL, GPIO_MUX_SEL_VAL); XGpioPs_SetDirectionPin(&structXGpioPs,MIO_TCK,1); XGpioPs_SetOutputEnablePin(&structXGpioPs,MIO_TCK,1); XGpioPs_SetDirectionPin(&structXGpioPs,MIO_TMS,1); XGpioPs_SetOutputEnablePin(&structXGpioPs,MIO_TMS,1); XGpioPs_SetDirectionPin(&structXGpioPs,MIO_TDI,1); XGpioPs_SetOutputEnablePin(&structXGpioPs,MIO_TDI,1); XGpioPs_SetDirectionPin(&structXGpioPs,MIO_MUX_SELECT,1); XGpioPs_SetOutputEnablePin(&structXGpioPs,MIO_MUX_SELECT,1); XGpioPs_WritePin(&structXGpioPs, MIO_MUX_SELECT, g_mux_sel_def_val); XGpioPs_SetDirectionPin(&structXGpioPs,MIO_TDO,0); XGpioPs_SetOutputEnablePin(&structXGpioPs,MIO_TDO,0); } /* initGpio() */
/***************************************************************************//** * @brief gpio_set_value *******************************************************************************/ int32_t gpio_set_value(uint8_t pin, uint8_t data) { #ifdef _XPARAMETERS_PS_H_ XGpioPs_WritePin(&gpio_instance, pin, data); #else uint32_t channel = 1; uint32_t config = 0; /* We assume that pin 32 is the first pin from channel 2 */ if (pin >= 32) { channel = 2; pin -= 32; } config = XGpio_DiscreteRead(&gpio_instance, channel); if(data) { config |= (1 << pin); } else { config &= ~(1 << pin); } XGpio_DiscreteWrite(&gpio_instance, channel, config); #endif return 0; }
int main() { XGpioPs_Config *GPIOConfigPtr; //gpio config //int io; init_platform(); //GPIO Initilization GPIOConfigPtr = XGpioPs_LookupConfig(XPAR_XGPIOPS_0_DEVICE_ID); XGpioPs_CfgInitialize(&Gpio, GPIOConfigPtr,GPIOConfigPtr->BaseAddr); //set direction and enable output XGpioPs_SetDirectionPin(&Gpio, intpin, 1); XGpioPs_SetOutputEnablePin(&Gpio, intpin, 1); XGpioPs_WritePin(&Gpio, intpin, 0); //set direction input pin XGpioPs_SetDirectionPin(&Gpio, pbsw, 0); SetupInterruptSystem(&Intc,&FPGA,FPGA_INT,&Gpio, GPIO_INTERRUPT_ID); printf("system running\n\r"); while(1){ } return 0; }
static void GPIOIntrHandler(void *CallBackRef, int Bank, u32 Status) { printf("Push button Interrupt Event\n\r"); XGpioPs *Gpioint = (XGpioPs *)CallBackRef; XGpioPs_WritePin(&Gpio, intpin, 1); XGpioPs_IntrClearPin(Gpioint, pbsw); }
void EMIO_Button_InterruptHandler(void *CallBackRef, int Bank, u32 Status) { print("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\r\n"); print(" Inside EMIO GPIO ISR \n \r "); XGpioPs_WritePin(&psGpioInstancePtr,55,1); print("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\r\n"); XTmrCtr_Start(&TimerInstancePtr,0); XGpioPs_IntrClear(&psGpioInstancePtr, XGPIOPS_BANK2, 0x1); }
void Button_InterruptHandler(void *data) { print("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\r\n"); print(" Inside GPIO ISR \n \r "); XGpioPs_WritePin(&psGpioInstancePtr,iPinNumber, 1); print("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\r\n"); XTmrCtr_Start(&TimerInstancePtr,0); XGpio_InterruptClear(&GPIOInstance_Ptr, 0x1); }
void vParTestToggleLED( unsigned portBASE_TYPE uxLED ) { BaseType_t xLEDState; ( void ) uxLED; xLEDState = XGpioPs_ReadPin( &xGpio, partstLED_OUTPUT ); XGpioPs_WritePin( &xGpio, partstLED_OUTPUT, !xLEDState ); }
/***************************************************************************** * * This function sets GPIO LED device state configured as OUTPUT. * * @param None. * * @return 0 if successful, else -1. * * @note None. * ****************************************************************************/ int ps_gpio_set_led(zed_ali3_controller_demo_t *pDemo, int led_number, int led_state) { /* * Set the direction for the GPIO pin to be output and * Enable the Output enable for the LED Pin. */ #ifdef PS_GPIO_USER_LED0 if (led_number == 0) { XGpioPs_SetDirectionPin(&(pDemo->gpio_driver), PS_GPIO_USER_LED0, 1); XGpioPs_SetOutputEnablePin(&(pDemo->gpio_driver), PS_GPIO_USER_LED0, 1); } #ifdef PS_GPIO_USER_LED1 else if (led_number == 1) { XGpioPs_SetDirectionPin(&(pDemo->gpio_driver), PS_GPIO_USER_LED1, 1); XGpioPs_SetOutputEnablePin(&(pDemo->gpio_driver), PS_GPIO_USER_LED1, 1); } #endif #else XGpioPs_SetDirectionPin(&(pDemo->gpio_driver), (PS_GPIO_USER_LED_START + led_number), 1); XGpioPs_SetOutputEnablePin(&(pDemo->gpio_driver), (PS_GPIO_USER_LED_START + led_number), 1); #endif /* * Set the GPIO output to the specified state. */ #ifdef PS_GPIO_USER_LED0 if (led_number == 0) { XGpioPs_WritePin(&(pDemo->gpio_driver), PS_GPIO_USER_LED0, led_state); } #ifdef PS_GPIO_USER_LED1 else if (led_number == 1) { XGpioPs_WritePin(&(pDemo->gpio_driver), PS_GPIO_USER_LED1, led_state); } #endif #else XGpioPs_WritePin(&(pDemo->gpio_driver), (PS_GPIO_USER_LED_START + led_number), led_state); #endif return 0; }
/** * @brief Enable the output direction of the specified GPIO. * @param desc - The GPIO descriptor. * @param value - The value. * Example: GPIO_HIGH * GPIO_LOW * @return SUCCESS in case of success, FAILURE otherwise. */ int32_t gpio_direction_output(struct gpio_desc *desc, uint8_t value) { XGpioPs_SetDirectionPin(&desc->instance, desc->number, 1); XGpioPs_SetOutputEnablePin(&desc->instance, desc->number, 1); XGpioPs_WritePin(&desc->instance, desc->number, value); return SUCCESS; }
void blank_oled() { u8 cmd[1]; u8 data[1]; int loop; cmd[0] = (u8) 0xB0; data[0] = (u8) 0x00; XGpioPs_WritePin(&Gpio, dc, 0); XSpiPs_SetSlaveSelect(&SpiInstance_EMIO, 0x01); XSpiPs_PolledTransfer(&SpiInstance_EMIO, cmd, NULL, 1); XGpioPs_WritePin(&Gpio, dc, 1); for(loop=0;loop<128;loop++){ XSpiPs_SetSlaveSelect(&SpiInstance_EMIO, 0x01); XSpiPs_PolledTransfer(&SpiInstance_EMIO, data, NULL, 1); } cmd[0] = (u8) 0xB2; data[0] = (u8) 0x00; XGpioPs_WritePin(&Gpio, dc, 0); XSpiPs_SetSlaveSelect(&SpiInstance_EMIO, 0x01); XSpiPs_PolledTransfer(&SpiInstance_EMIO, cmd, NULL, 1); XGpioPs_WritePin(&Gpio, dc, 1); for(loop=0;loop<128;loop++){ XSpiPs_SetSlaveSelect(&SpiInstance_EMIO, 0x01); XSpiPs_PolledTransfer(&SpiInstance_EMIO, data, NULL, 1); } cmd[0] = (u8) 0xB1; data[0] = (u8) 0x00; XGpioPs_WritePin(&Gpio, dc, 0); XSpiPs_SetSlaveSelect(&SpiInstance_EMIO, 0x01); XSpiPs_PolledTransfer(&SpiInstance_EMIO, cmd, NULL, 1); XGpioPs_WritePin(&Gpio, dc, 1); for(loop=0;loop<128;loop++){ XSpiPs_SetSlaveSelect(&SpiInstance_EMIO, 0x01); XSpiPs_PolledTransfer(&SpiInstance_EMIO, data, NULL, 1); } cmd[0] = (u8) 0xB3; data[0] = (u8) 0x00; XGpioPs_WritePin(&Gpio, dc, 0); XSpiPs_SetSlaveSelect(&SpiInstance_EMIO, 0x01); XSpiPs_PolledTransfer(&SpiInstance_EMIO, cmd, NULL, 1); XGpioPs_WritePin(&Gpio, dc, 1); for(loop=0;loop<128;loop++){ XSpiPs_SetSlaveSelect(&SpiInstance_EMIO, 0x01); XSpiPs_PolledTransfer(&SpiInstance_EMIO, data, NULL, 1); } }
/***************************************************************************** * * This function sets GPIO LED device state configured as OUTPUT. * * @param None. * * @return 0 if successful, else -1. * * @note None. * ****************************************************************************/ int ps_gpio_set_led(zed_ali3_controller_demo_t *pDemo, int led_number, int led_state) { /* * Set the direction for the GPIO pin to be output and * Enable the Output enable for the LED Pin. */ XGpioPs_SetDirectionPin(&(pDemo->gpio_driver), (PS_GPIO_USER_LED_START + led_number), 1); XGpioPs_SetOutputEnablePin(&(pDemo->gpio_driver), (PS_GPIO_USER_LED_START + led_number), 1); /* * Set the GPIO output to the specified state. */ XGpioPs_WritePin(&(pDemo->gpio_driver), (PS_GPIO_USER_LED_START + led_number), led_state); return 0; }
void vParTestInitialise( void ) { XGpioPs_Config *pxConfigPtr; BaseType_t xStatus; /* Initialise the GPIO driver. */ pxConfigPtr = XGpioPs_LookupConfig( XPAR_XGPIOPS_0_DEVICE_ID ); xStatus = XGpioPs_CfgInitialize( &xGpio, pxConfigPtr, pxConfigPtr->BaseAddr ); configASSERT( xStatus == XST_SUCCESS ); ( void ) xStatus; /* Remove compiler warning if configASSERT() is not defined. */ /* Enable outputs and set low. */ XGpioPs_SetDirectionPin( &xGpio, partstLED_OUTPUT, partstDIRECTION_OUTPUT ); XGpioPs_SetOutputEnablePin( &xGpio, partstLED_OUTPUT, partstOUTPUT_ENABLED ); XGpioPs_WritePin( &xGpio, partstLED_OUTPUT, 0x0 ); }
/***************************************************************************//** * @brief gpio_data *******************************************************************************/ void gpio_data(uint8_t pin, uint8_t data) { #ifdef _XPARAMETERS_PS_H_ XGpioPs_WritePin(&gpio_instance, pin, data); #else uint32_t config = 0; config = Xil_In32((gpio_config->BaseAddress + XGPIO_DATA_OFFSET)); if(data) { config |= (1 << pin); } else { config &= ~(1 << pin); } Xil_Out32((gpio_config->BaseAddress + XGPIO_DATA_OFFSET), config); #endif }
/** * * This function does a minimal test on the GPIO device configured as OUTPUT. * * @param None. * * @return - XST_SUCCESS if the example has completed successfully. * - XST_FAILURE if the example has failed. * * @note None. * ****************************************************************************/ static int GpioOutputExample(void) { u32 Data; volatile int Delay; u32 LedLoop; /* * Set the direction for the pin to be output and * Enable the Output enable for the LED Pin. */ XGpioPs_SetDirectionPin(&Gpio, OUTPUT_PIN, 1); XGpioPs_SetOutputEnablePin(&Gpio, OUTPUT_PIN, 1); /* * Set the GPIO output to be low. */ XGpioPs_WritePin(&Gpio, OUTPUT_PIN, 0x0); for (LedLoop = 0; LedLoop < LED_MAX_BLINK; LedLoop ++) { #ifndef __SIM__ /* * Wait a small amount of time so the LED is visible. */ for (Delay = 0; Delay < LED_DELAY; Delay++); #endif /* * Set the GPIO Output to High. */ XGpioPs_WritePin(&Gpio, OUTPUT_PIN, 0x1); /* * Read the state of the data and verify. If the data * read back is not the same as the data written then * return FAILURE. */ Data = XGpioPs_ReadPin(&Gpio, OUTPUT_PIN); if (Data != 1 ) { return XST_FAILURE; } #ifndef __SIM__ /* * Wait a small amount of time so the LED is visible. */ for (Delay = 0; Delay < LED_DELAY; Delay++); #endif /* * Clear the GPIO Output. */ XGpioPs_WritePin(&Gpio, OUTPUT_PIN, 0x0); /* * Read the state of the data and verify. If the data * read back is not the same as the data written then * return FAILURE. */ Data = XGpioPs_ReadPin(&Gpio, OUTPUT_PIN); if (Data != 0) { return XST_FAILURE; } } return XST_SUCCESS; }
int main() { XSpiPs_Config *SpiConfig_EMIO; XGpioPs_Config *GPIOConfigPtr; //gpio config int delay; u8 cmd[1]; int byte_i, temp; int loop; init_platform(); printf("SPI Demo MicroZed Chronicles\n\r"); SpiConfig_EMIO = XSpiPs_LookupConfig((u16)SPI_EMIO); XSpiPs_CfgInitialize(&SpiInstance_EMIO, SpiConfig_EMIO,SpiConfig_EMIO->BaseAddress); XSpiPs_SetOptions(&SpiInstance_EMIO,XSPIPS_MASTER_OPTION | XSPIPS_FORCE_SSELECT_OPTION); XSpiPs_SetClkPrescaler(&SpiInstance_EMIO, XSPIPS_CLK_PRESCALE_256); GPIOConfigPtr = XGpioPs_LookupConfig(XPAR_XGPIOPS_0_DEVICE_ID); XGpioPs_CfgInitialize(&Gpio, GPIOConfigPtr,GPIOConfigPtr->BaseAddr); //set direction and enable output XGpioPs_SetDirectionPin(&Gpio, sig, 1); XGpioPs_SetOutputEnablePin(&Gpio, sig, 1); XGpioPs_SetDirectionPin(&Gpio, res, 1); XGpioPs_SetOutputEnablePin(&Gpio, res, 1); XGpioPs_SetDirectionPin(&Gpio, vdd, 1); XGpioPs_SetOutputEnablePin(&Gpio, vdd, 1); XGpioPs_SetDirectionPin(&Gpio, bat, 1); XGpioPs_SetOutputEnablePin(&Gpio, bat, 1); XGpioPs_SetDirectionPin(&Gpio, dc, 1); XGpioPs_SetOutputEnablePin(&Gpio, dc, 1); XGpioPs_WritePin(&Gpio, sig, 0); XGpioPs_WritePin(&Gpio, res, 0); XGpioPs_WritePin(&Gpio, vdd, 1); XGpioPs_WritePin(&Gpio, bat, 1); XGpioPs_WritePin(&Gpio, dc, 1); XGpioPs_WritePin(&Gpio, vdd, 0); for( delay = 0; delay < DELAY; delay++)//wait {} XGpioPs_WritePin(&Gpio, res, 1); config_oled(); XGpioPs_WritePin(&Gpio, bat, 0); blank_oled();//clear screen //output page 1 for(loop=0;loop<16;loop++){ temp = (line_1[loop] * 8); for(byte_i=0;byte_i<8;byte_i++){ data_conv[byte_i] = font[temp+byte_i]; } conv_alg(data_conv); //convert to array for(byte_i=0;byte_i<8;byte_i++){ page_0[(line_start-(char_size*loop))-byte_i] = results[byte_i]; } } cmd[0] = (u8) 0xB0; XGpioPs_WritePin(&Gpio, dc, 0); XSpiPs_SetSlaveSelect(&SpiInstance_EMIO, 0x01); XSpiPs_PolledTransfer(&SpiInstance_EMIO, cmd, NULL, 1); XGpioPs_WritePin(&Gpio, dc, 1); XSpiPs_SetSlaveSelect(&SpiInstance_EMIO, 0x01); XSpiPs_PolledTransfer(&SpiInstance_EMIO, page_0, NULL, 128); //output page 2 for(loop=0;loop<16;loop++){ //loop =0; temp = (line_2[loop] * 8); for(byte_i=0;byte_i<8;byte_i++){ data_conv[byte_i] = font[temp+byte_i]; } conv_alg(data_conv); //convert to array for(byte_i=0;byte_i<8;byte_i++){ page_1[(line_start-(char_size*loop))-byte_i] = results[byte_i]; } } cmd[0] = (u8) 0xB1; XGpioPs_WritePin(&Gpio, dc, 0); XSpiPs_SetSlaveSelect(&SpiInstance_EMIO, 0x01); XSpiPs_PolledTransfer(&SpiInstance_EMIO, cmd, NULL, 1); XGpioPs_WritePin(&Gpio, dc, 1); XSpiPs_SetSlaveSelect(&SpiInstance_EMIO, 0x01); XSpiPs_PolledTransfer(&SpiInstance_EMIO, page_1, NULL, 128); //output page 3 for(loop=0;loop<16;loop++){ //loop =0; temp = (line_3[loop] * 8); for(byte_i=0;byte_i<8;byte_i++){ data_conv[byte_i] = font[temp+byte_i]; } conv_alg(data_conv); //convert to array for(byte_i=0;byte_i<8;byte_i++){ page_2[(line_start-(char_size*loop))-byte_i] = results[byte_i]; } } cmd[0] = (u8) 0xB2; XGpioPs_WritePin(&Gpio, dc, 0); XSpiPs_SetSlaveSelect(&SpiInstance_EMIO, 0x01); XSpiPs_PolledTransfer(&SpiInstance_EMIO, cmd, NULL, 1); XGpioPs_WritePin(&Gpio, dc, 1); XSpiPs_SetSlaveSelect(&SpiInstance_EMIO, 0x01); XSpiPs_PolledTransfer(&SpiInstance_EMIO, page_2, NULL, 128); //output page 4 for(loop=0;loop<16;loop++){ //loop =0; temp = (line_4[loop] * 8); for(byte_i=0;byte_i<8;byte_i++){ data_conv[byte_i] = font[temp+byte_i]; } conv_alg(data_conv); //convert to array for(byte_i=0;byte_i<8;byte_i++){ page_3[(line_start-(char_size*loop))-byte_i] = results[byte_i]; } } cmd[0] = (u8) 0xB3; XGpioPs_WritePin(&Gpio, dc, 0); XSpiPs_SetSlaveSelect(&SpiInstance_EMIO, 0x01); XSpiPs_PolledTransfer(&SpiInstance_EMIO, cmd, NULL, 1); XGpioPs_WritePin(&Gpio, dc, 1); XSpiPs_SetSlaveSelect(&SpiInstance_EMIO, 0x01); XSpiPs_PolledTransfer(&SpiInstance_EMIO, page_3, NULL, 128); return 0; }
void vParTestSetLED( UBaseType_t uxLED, BaseType_t xValue ) { ( void ) uxLED; XGpioPs_WritePin( &xGpio, partstLED_OUTPUT, xValue ); }
/***************************************************************************//** * @brief gpio_data *******************************************************************************/ void gpio_data(uint8_t pin, uint8_t data) { #ifdef _XPARAMETERS_PS_H_ XGpioPs_WritePin(&gpio_instance, pin, data); #endif }
int main (void) { XGpio sw, led; int i, pshb_check, sw_check; XGpioPs_Config*GpioConfigPtr; int xStatus; int iPinNumberEMIO = 54; u32 uPinDirectionEMIO = 0x0; u32 uPinDirection = 0x1; xil_printf("-- Start of the Program --\r\n"); // AXI GPIO switches Intialization XGpio_Initialize(&sw, XPAR_SWITCHES_DEVICE_ID); // AXI GPIO leds Intialization XGpio_Initialize(&led, XPAR_LEDS_DEVICE_ID); // PS GPIO Intialization GpioConfigPtr = XGpioPs_LookupConfig(XPAR_PS7_GPIO_0_DEVICE_ID); if(GpioConfigPtr == NULL) return XST_FAILURE; xStatus = XGpioPs_CfgInitialize(&psGpioInstancePtr, GpioConfigPtr, GpioConfigPtr->BaseAddr); if(XST_SUCCESS != xStatus) print(" PS GPIO INIT FAILED \n\r"); //PS GPIO pin setting to Output XGpioPs_SetDirectionPin(&psGpioInstancePtr, iPinNumber,uPinDirection); XGpioPs_SetOutputEnablePin(&psGpioInstancePtr, iPinNumber,1); //EMIO PIN Setting to Input port XGpioPs_SetDirectionPin(&psGpioInstancePtr, iPinNumberEMIO,uPinDirectionEMIO); XGpioPs_SetOutputEnablePin(&psGpioInstancePtr, iPinNumberEMIO,0); xil_printf("-- Press BTNR (Zedboard) or BTN3 (Zybo) to see the LED light --\r\n"); xil_printf("-- Change slide switches to see corresponding output on LEDs --\r\n"); xil_printf("-- Set slide switches to 0x0F to exit the program --\r\n"); while (1) { sw_check = XGpio_DiscreteRead(&sw, 1); XGpio_DiscreteWrite(&led, 1, sw_check); pshb_check = XGpioPs_ReadPin(&psGpioInstancePtr,iPinNumberEMIO); XGpioPs_WritePin(&psGpioInstancePtr,iPinNumber,pshb_check); if((sw_check & 0x0f)==0x0F) break; for (i=0; i<9999999; i++); // delay loop } xil_printf("-- End of Program --\r\n"); #ifdef MULTIBOOT // Driver Instantiations XDcfg XDcfg_0; u32 MultiBootReg = 0; #define PS_RST_CTRL_REG (XPS_SYS_CTRL_BASEADDR + 0x200) #define PS_RST_MASK 0x1 /* PS software reset */ #define SLCR_UNLOCK_OFFSET 0x08 // Initialize Device Configuration Interface XDcfg_Config *Config = XDcfg_LookupConfig(XPAR_XDCFG_0_DEVICE_ID); XDcfg_CfgInitialize(&XDcfg_0, Config, Config->BaseAddr); MultiBootReg = 0; // Once done, boot the master image stored at 0xfc00_0000 Xil_Out32(0xF8000000 + SLCR_UNLOCK_OFFSET, 0xDF0DDF0D); // unlock SLCR XDcfg_WriteReg(XDcfg_0.Config.BaseAddr, XDCFG_MULTIBOOT_ADDR_OFFSET, MultiBootReg); // write to multiboot reg // synchronize __asm__( "dsb\n\t" "isb" ); Xil_Out32(PS_RST_CTRL_REG, PS_RST_MASK); #endif return 0; }
void vApplicationSetupHardware( void ) { XScuGic * InterruptController = prvGetInterruptControllerInstance(); int iPinNumberEMIO = 54; u32 uPinDirectionEMIO = 0x0; u32 uPinDirection = 0x1; print("##### Application Starts #####\n\r"); print("\r\n"); //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //Step-1 :AXI GPIO Initialization //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ u32 xStatus = XGpio_Initialize(&GPIOInstance_Ptr,XPAR_AXI_GPIO_0_DEVICE_ID); if(XST_SUCCESS != xStatus) print("GPIO INIT FAILED\n\r"); //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //Step-2 :AXI GPIO Set the Direction //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ XGpio_SetDataDirection(&GPIOInstance_Ptr, 1,1); //set up GPIO interrupt XGpio_InterruptEnable(&GPIOInstance_Ptr, 0x1); XGpio_InterruptGlobalEnable(&GPIOInstance_Ptr); //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //Step-3 :AXI Timer Initialization //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ xStatus = XTmrCtr_Initialize(&TimerInstancePtr, XPAR_AXI_TIMER_0_DEVICE_ID); if(XST_SUCCESS != xStatus) print("TIMER INIT FAILED \n\r"); //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //Step-4 :Set Timer Handler //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ XTmrCtr_SetHandler(&TimerInstancePtr, Timer_InterruptHandler, &TimerInstancePtr); //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //Step-5 :Setting timer Reset Value //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ XTmrCtr_SetResetValue(&TimerInstancePtr, 0, 0x0F000000); //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //Step-6 :Setting timer Option (Interrupt Mode And Auto Reload ) //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ XTmrCtr_SetOptions(&TimerInstancePtr, XPAR_AXI_TIMER_0_DEVICE_ID, (XTC_INT_MODE_OPTION | XTC_AUTO_RELOAD_OPTION | XTC_DOWN_COUNT_OPTION)); //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //Step-7 :PS GPIO Intialization //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GpioConfigPtr = XGpioPs_LookupConfig(XPAR_PS7_GPIO_0_DEVICE_ID); if(GpioConfigPtr == NULL) print(" PS GPIO config lookup FAILED \n\r"); xStatus = XGpioPs_CfgInitialize(&psGpioInstancePtr, GpioConfigPtr, GpioConfigPtr->BaseAddr); if(XST_SUCCESS != xStatus) print(" PS GPIO INIT FAILED \n\r"); //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //Step-8 :PS GPIO pin setting to Output //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ XGpioPs_SetDirectionPin(&psGpioInstancePtr, 54, uPinDirection); XGpioPs_SetOutputEnablePin(&psGpioInstancePtr, 54,1); // XGpioPs_SetDirectionPin(&psGpioInstancePtr, 8,uPinDirection); // XGpioPs_SetOutputEnablePin(&psGpioInstancePtr, 8, 1); print(" INITED MIO \n\r"); //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //Step-9 :EMIO PIN Setting to Input port //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ XGpioPs_SetDirectionPin(&psGpioInstancePtr, iPinNumberEMIO, uPinDirectionEMIO); XGpioPs_SetOutputEnablePin(&psGpioInstancePtr, iPinNumberEMIO, 0); //XGpioPs_IntrEnable(&psGpioInstancePtr, XGPIOPS_BANK2, 0x1); // instance, bank, edge, rising, single edge XGpioPs_IntrEnablePin(&psGpioInstancePtr, iPinNumberEMIO); XGpioPs_SetIntrType(&psGpioInstancePtr, XGPIOPS_BANK2, 1, 1, 0); XGpioPs_SetCallbackHandler(&psGpioInstancePtr, (void *) &psGpioInstancePtr, EMIO_Button_InterruptHandler); print(" INITED FIRST EMIO \n\r"); // EMIO output XGpioPs_SetDirectionPin(&psGpioInstancePtr, 55, uPinDirection); XGpioPs_SetOutputEnablePin(&psGpioInstancePtr, 55, 1); //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //Step-10 : SCUGIC interrupt controller Initialization //Registration of the Timer ISR //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ u32 Status = XScuGic_Connect(InterruptController, XPAR_FABRIC_AXI_TIMER_0_INTERRUPT_INTR, (Xil_ExceptionHandler)XTmrCtr_InterruptHandler, (void *)&TimerInstancePtr); if (Status != XST_SUCCESS) { print(" Error connection timer interrupt \n \r"); } Status = XScuGic_Connect(InterruptController, XPAR_FABRIC_AXI_GPIO_0_IP2INTC_IRPT_INTR, (Xil_ExceptionHandler)Button_InterruptHandler, (void *)&GPIOInstance_Ptr); if (Status != XST_SUCCESS) { print(" Error connection button interrupt \n \r"); } /* * Connect the device driver handler that will be called when an * interrupt for the device occurs, the handler defined above performs * the specific interrupt processing for the device. */ Status = XScuGic_Connect(InterruptController, XPS_GPIO_INT_ID, (Xil_ExceptionHandler)XGpioPs_IntrHandler, (void *)&psGpioInstancePtr); if (Status != XST_SUCCESS) { print(" Error connection button EMIO interrupt \n \r"); } /* * Enable the interrupt for the device and then cause (simulate) an * interrupt so the handlers will be called */ XScuGic_Enable(InterruptController, XPAR_FABRIC_AXI_GPIO_0_IP2INTC_IRPT_INTR); XScuGic_Enable(InterruptController, XPS_GPIO_INT_ID); XScuGic_Enable(InterruptController, XPAR_FABRIC_AXI_TIMER_0_INTERRUPT_INTR); // turn off all LEDs XGpioPs_WritePin(&psGpioInstancePtr, iPinNumber, 0); XGpioPs_WritePin(&psGpioInstancePtr, 55, 0); print(" End of init \n\r"); }
int setPin (int pin, int value) { int status = 1; XGpioPs_WritePin(&structXGpioPs, pin, value); return (status); }