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; }
/** * * This function does a minimal test on the XUartPs driver. * * * @param DeviceId is the XPAR_<UARTPS_instance>_DEVICE_ID value from * xparameters.h * * @return XST_SUCCESS if succesful, otherwise XST_FAILURE * * @note None * ****************************************************************************/ int UartPsSelfTestExample(u16 DeviceId) { int Status; XUartPs_Config *Config; /* * Initialize the UART driver so that it's ready to use * Look up the configuration in the config table, * then initialize it. */ Config = XUartPs_LookupConfig(DeviceId); if (NULL == Config) { return XST_FAILURE; } Status = XUartPs_CfgInitialize(&Uart_Ps, Config, Config->BaseAddress); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Perform a self-test to check hardware build. */ Status = XUartPs_SelfTest(&Uart_Ps); if (Status != XST_SUCCESS) { return XST_FAILURE; } return XST_SUCCESS; }
/** * * This function sends 'Hello World' to an external terminal in polled mode. * The purpose of this function is to illustrate how to use the XUartPs driver. * * * @param DeviceId is the unique ID for the device from hardware build. * * @return * - XST_FAILURE if the UART driver could not be initialized * successfully. * - A non-negative number indicating the number of characters * sent. * * @note None. * ****************************************************************************/ int UartPsHelloWorldExample(u16 DeviceId) { u8 HelloWorld[] = "Hello World"; int SentCount = 0; int Status; XUartPs_Config *Config; /* * Initialize the UART driver so that it's ready to use * Look up the configuration in the config table and then initialize it. */ Config = XUartPs_LookupConfig(DeviceId); if (NULL == Config) { return XST_FAILURE; } Status = XUartPs_CfgInitialize(&Uart_Ps, Config, Config->BaseAddress); if (Status != XST_SUCCESS) { return XST_FAILURE; } XUartPs_SetBaudRate(&Uart_Ps, 115200); while (SentCount < (sizeof(HelloWorld) - 1)) { /* Transmit the data */ SentCount += XUartPs_Send(&Uart_Ps, &HelloWorld[SentCount], 1); } return SentCount; }
void init_uart() { #ifdef STDOUT_IS_PS7_UART /* Use the PS UART for Zynq devices */ XUartPs Uart_Ps_0; XUartPs_Config *Config_0 = XUartPs_LookupConfig(UART_DEVICE_ID); XUartPs_CfgInitialize(&Uart_Ps_0, Config_0, Config_0->BaseAddress); XUartPs_SetBaudRate(&Uart_Ps_0, UART_BAUD); #elif defined(STDOUT_IS_16550) XUartNs550_SetBaud(STDOUT_BASEADDR, XPAR_XUARTNS550_CLOCK_HZ, UART_BAUD); XUartNs550_SetLineControlReg(STDOUT_BASEADDR, XUN_LCR_8_DATA_BITS); #endif }
/* * See the serial2.h header file. */ xComPortHandle xSerialPortInitMinimal( uint32_t ulWantedBaud, UBaseType_t uxQueueLength ) { BaseType_t xStatus; XUartPs_Config *pxConfig; /* Create the queue used to hold received characters. NOTE THE COMMENTS AT THE TOP OF THIS FILE REGARDING THE USE OF QUEUES FOR THIS PURPSOE. */ xRxQueue = xQueueCreate( uxQueueLength, sizeof( char ) ); configASSERT( xRxQueue ); /* Create the semaphore used to signal the end of a transmission, then take the semaphore so it is in the correct state the first time xSerialSendString() is called. A block time of zero is used when taking the semaphore as it is guaranteed to be available (it was just created). */ xTxCompleteSemaphore = xSemaphoreCreateBinary(); configASSERT( xTxCompleteSemaphore ); xSemaphoreTake( xTxCompleteSemaphore, 0 ); /* Look up the UART configuration then initialise the dirver. */ pxConfig = XUartPs_LookupConfig( XPAR_XUARTPS_0_DEVICE_ID ); /* Initialise the driver. */ xStatus = XUartPs_CfgInitialize( &xUARTInstance, pxConfig, XPAR_PS7_UART_1_BASEADDR ); configASSERT( xStatus == XST_SUCCESS ); ( void ) xStatus; /* Remove compiler warning if configASSERT() is not defined. */ /* Misc. parameter configuration. */ XUartPs_SetBaudRate( &xUARTInstance, ulWantedBaud ); XUartPs_SetOperMode( &xUARTInstance, XUARTPS_OPER_MODE_NORMAL ); /* Install the interrupt service routine that is defined within this file. */ xStatus = XScuGic_Connect( &xInterruptController, XPAR_XUARTPS_1_INTR, (Xil_ExceptionHandler) prvUART_Handler, (void *) &xUARTInstance ); configASSERT( xStatus == XST_SUCCESS ); ( void ) xStatus; /* Remove compiler warning if configASSERT() is not defined. */ /* Ensure interrupts start clear. */ XUartPs_WriteReg( XPAR_PS7_UART_1_BASEADDR, XUARTPS_ISR_OFFSET, XUARTPS_IXR_MASK ); /* Enable the UART interrupt within the GIC. */ XScuGic_Enable( &xInterruptController, XPAR_XUARTPS_1_INTR ); /* Enable the interrupts of interest in the UART. */ XUartPs_SetInterruptMask( &xUARTInstance, XUARTPS_IXR_RXFULL | XUARTPS_IXR_RXOVR | XUARTPS_IXR_TOUT | XUARTPS_IXR_TXEMPTY ); /* Set the receive timeout. */ XUartPs_SetRecvTimeout( &xUARTInstance, 8 ); return ( xComPortHandle ) 0; }
//Function to initialize the UART port int init_uart(){ int Status; //Look up the configuration in the config table and then initialize it. Config = XUartPs_LookupConfig(XPAR_PS7_UART_1_DEVICE_ID); if (NULL == Config) { return XST_FAILURE; } Status = XUartPs_CfgInitialize(&uart, Config, Config->BaseAddress); if (Status != XST_SUCCESS) { return XST_FAILURE; } return XST_SUCCESS; //setting receiver reset after each operation //XUartPs_SetOptions(&uart,XUARTPS_OPTION_RESET_RX); //setting the sender reset after each operation //XUartPs_SetOptions(&uart,XUARTPS_OPTION_RESET_TX); }
void BSP_Init (void) { CPU_IntDis(); /* Disable all interrupts. */ Xil_ICacheEnable(); /* Enable the instruction cache. */ Xil_DCacheEnable(); /* Enable the Data cache. */ CSP_IntInit(); /* Initialize Interrupt controller module. */ #ifdef STDOUT_IS_PS7_UART XUartPs Uart_Ps_0; /* Use the PS UART for Zynq devices. */ XUartPs_Config *Config_0; Config_0 = XUartPs_LookupConfig(UART_DEVICE_ID); XUartPs_CfgInitialize(&Uart_Ps_0, Config_0, Config_0->BaseAddress); XUartPs_SetBaudRate(&Uart_Ps_0, 115200); #elif defined(STDOUT_IS_16550) XUartNs550_SetBaud(STDOUT_BASEADDR, XPAR_XUARTNS550_CLOCK_HZ, UART_BAUD); XUartNs550_SetLineControlReg(STDOUT_BASEADDR, XUN_LCR_8_DATA_BITS); #endif }
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); 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 Init_UART(void) { int Status = XST_SUCCESS; XUartPs_Config *Config_0; /* * Initialize the UART 0 and 1 driver so that it's ready to use * Look up the configuration in the config table, * then initialize it. */ Config_0 = XUartPs_LookupConfig(UART_DEVICE_ID); if (NULL == Config_0) { return XST_FAILURE; } Status = XUartPs_CfgInitialize(&Uart_Pss_0, Config_0, Config_0->BaseAddress); if (Status != XST_SUCCESS) { return XST_FAILURE; } XUartPs_SetBaudRate(&Uart_Pss_0, 9600); return XST_SUCCESS; }
void init_UART(XUartPs *InstancePtr, int Device_ID) { int Status; XUartPs_Config *Config; Config = XUartPs_LookupConfig(Device_ID); if (NULL == Config) { //return XST_FAILURE; } Status = XUartPs_CfgInitialize(InstancePtr, Config, Config->BaseAddress); if (Status != XST_SUCCESS) { //return XST_FAILURE; xil_printf("UART%i initialization FAILED!\n \r",Device_ID); } else { xil_printf("UART%i initialization SUCCESS!\n \r",Device_ID); } }
/** * * This function does a minimal test on the UartPS device and driver as a * design example. The purpose of this function is to illustrate * how to use the XUartPs driver. * * This function sends data and expects to receive the same data through the * device using the local loopback mode. * * This function uses interrupt mode of the device. * * @param IntcInstPtr is a pointer to the instance of the Scu Gic driver. * @param UartInstPtr is a pointer to the instance of the UART driver * which is going to be connected to the interrupt controller. * @param DeviceId is the device Id of the UART device and is typically * XPAR_<UARTPS_instance>_DEVICE_ID value from xparameters.h. * @param UartIntrId is the interrupt Id and is typically * XPAR_<UARTPS_instance>_INTR value from xparameters.h. * * @return XST_SUCCESS if successful, otherwise XST_FAILURE. * * @note * * This function contains an infinite loop such that if interrupts are not * working it may never return. * **************************************************************************/ int UartPsIntrExample(XScuGic *IntcInstPtr, XUartPs *UartInstPtr, u16 DeviceId, u16 UartIntrId) { int Status; XUartPs_Config *Config; int Index; u32 IntrMask; int BadByteCount = 0; /* * Initialize the UART driver so that it's ready to use * Look up the configuration in the config table, then initialize it. */ Config = XUartPs_LookupConfig(DeviceId); if (NULL == Config) { return XST_FAILURE; } Status = XUartPs_CfgInitialize(UartInstPtr, Config, Config->BaseAddress); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Check hardware build */ Status = XUartPs_SelfTest(UartInstPtr); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Connect the UART to the interrupt subsystem such that interrupts * can occur. This function is application specific. */ Status = SetupInterruptSystem(IntcInstPtr, UartInstPtr, UartIntrId); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Setup the handlers for the UART that will be called from the * interrupt context when data has been sent and received, specify * a pointer to the UART driver instance as the callback reference * so the handlers are able to access the instance data */ XUartPs_SetHandler(UartInstPtr, (XUartPs_Handler)Handler, UartInstPtr); /* * Enable the interrupt of the UART so interrupts will occur, setup * a local loopback so data that is sent will be received. */ IntrMask = XUARTPS_IXR_TOUT | XUARTPS_IXR_PARITY | XUARTPS_IXR_FRAMING | XUARTPS_IXR_OVER | XUARTPS_IXR_TXEMPTY | XUARTPS_IXR_RXFULL | XUARTPS_IXR_RXOVR; XUartPs_SetInterruptMask(UartInstPtr, IntrMask); XUartPs_SetOperMode(UartInstPtr, XUARTPS_OPER_MODE_LOCAL_LOOP); /* * Set the receiver timeout. If it is not set, and the last few bytes * of data do not trigger the over-water or full interrupt, the bytes * will not be received. By default it is disabled. * * The setting of 8 will timeout after 8 x 4 = 32 character times. * Increase the time out value if baud rate is high, decrease it if * baud rate is low. */ XUartPs_SetRecvTimeout(UartInstPtr, 8); /* * Initialize the send buffer bytes with a pattern and the * the receive buffer bytes to zero to allow the receive data to be * verified */ for (Index = 0; Index < TEST_BUFFER_SIZE; Index++) { SendBuffer[Index] = (Index % 26) + 'A'; RecvBuffer[Index] = 0; } /* * Start receiving data before sending it since there is a loopback, * ignoring the number of bytes received as the return value since we * know it will be zero */ XUartPs_Recv(UartInstPtr, RecvBuffer, TEST_BUFFER_SIZE); /* * Send the buffer using the UART and ignore the number of bytes sent * as the return value since we are using it in interrupt mode. */ XUartPs_Send(UartInstPtr, SendBuffer, TEST_BUFFER_SIZE); /* * Wait for the entire buffer to be received, letting the interrupt * processing work in the background, this function may get locked * up in this loop if the interrupts are not working correctly. */ while (1) { if ((TotalSentCount == TEST_BUFFER_SIZE) && (TotalReceivedCount == TEST_BUFFER_SIZE)) { break; } } /* * Verify the entire receive buffer was successfully received */ for (Index = 0; Index < TEST_BUFFER_SIZE; Index++) { if (RecvBuffer[Index] != SendBuffer[Index]) { BadByteCount++; } } /* * Set the UART in Normal Mode */ XUartPs_SetOperMode(UartInstPtr, XUARTPS_OPER_MODE_NORMAL); /* * If any bytes were not correct, return an error */ if (BadByteCount != 0) { return XST_FAILURE; } return XST_SUCCESS; }
int setupUartControl(){ int Status; u32 IntrMask; Config = XUartPs_LookupConfig(UART_DEVICE_ID); if (NULL == Config) { return XST_FAILURE; } Status = XUartPs_CfgInitialize(&Uart_Ps, Config, Config->BaseAddress); if (Status != XST_SUCCESS) { return XST_FAILURE; } XUartPs_SetBaudRate(&Uart_Ps, 115200); /* * Check hardware build. */ Status = XUartPs_SelfTest(&Uart_Ps); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Connect the UART to the interrupt subsystem such that interrupts * can occur. This function is application specific. */ Status = SetupInterruptSystem(&InterruptController, &Uart_Ps, UART_INT_IRQ_ID); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Setup the handlers for the UART that will be called from the * interrupt context when data has been sent and received, specify * a pointer to the UART driver instance as the callback reference * so the handlers are able to access the instance data */ XUartPs_SetHandler(&Uart_Ps, (XUartPs_Handler)Handler, &Uart_Ps); /* * Enable the interrupt of the UART so interrupts will occur */ IntrMask = XUARTPS_IXR_TOUT | XUARTPS_IXR_PARITY | XUARTPS_IXR_FRAMING | XUARTPS_IXR_OVER | XUARTPS_IXR_TXEMPTY | XUARTPS_IXR_RXFULL | XUARTPS_IXR_RXOVR; XUartPs_SetInterruptMask(&Uart_Ps, IntrMask); /* * Set the receiver timeout. If it is not set, and the last few bytes * of data do not trigger the over-water or full interrupt, the bytes * will not be received. By default it is disabled. * * The setting of 8 will timeout after 8 x 4 = 32 character times. * Increase the time out value if baud rate is high, decrease it if * baud rate is low. */ XUartPs_SetRecvTimeout(&Uart_Ps, 255); return 0; }
/** * * This function does a minimal test on the XUartPs device in polled mode. * * This function sends data and expects to receive the data thru the UART * using the local loopback mode. * * * @param DeviceId is the unique device id from hardware build. * * @return XST_SUCCESS if successful, XST_FAILURE if unsuccessful * * @note * This function polls the UART, it may hang if the hardware is not * working correctly. * ****************************************************************************/ int UartPsPolledExample(u16 DeviceId) { int Status; XUartPs_Config *Config; unsigned int SentCount; unsigned int ReceivedCount; u16 Index; u32 LoopCount = 0; /* * Initialize the UART driver so that it's ready to use. * Look up the configuration in the config table, then initialize it. */ Config = XUartPs_LookupConfig(DeviceId); if (NULL == Config) { return XST_FAILURE; } Status = XUartPs_CfgInitialize(&Uart_PS, Config, Config->BaseAddress); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Check hardware build. */ Status = XUartPs_SelfTest(&Uart_PS); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Use local loopback mode. */ XUartPs_SetOperMode(&Uart_PS, XUARTPS_OPER_MODE_LOCAL_LOOP); /* * Initialize the send buffer bytes with a pattern and zero out * the receive buffer. */ for (Index = 0; Index < TEST_BUFFER_SIZE; Index++) { SendBuffer[Index] = '0' + Index; RecvBuffer[Index] = 0; } /* * Block sending the buffer. */ SentCount = XUartPs_Send(&Uart_PS, SendBuffer, TEST_BUFFER_SIZE); if (SentCount != TEST_BUFFER_SIZE) { return XST_FAILURE; } /* * Wait while the UART is sending the data so that we are guaranteed * to get the data the 1st time we call receive, otherwise this function * may enter receive before the data has arrived */ while (XUartPs_IsSending(&Uart_PS)) { LoopCount++; } /* * Block receiving the buffer. */ ReceivedCount = 0; while (ReceivedCount < TEST_BUFFER_SIZE) { ReceivedCount += XUartPs_Recv(&Uart_PS, &RecvBuffer[ReceivedCount], (TEST_BUFFER_SIZE - ReceivedCount)); } /* * Check the receive buffer against the send buffer and verify the * data was correctly received */ for (Index = 0; Index < TEST_BUFFER_SIZE; Index++) { if (SendBuffer[Index] != RecvBuffer[Index]) { return XST_FAILURE; } } /* * Restore to normal mode. */ XUartPs_SetOperMode(&Uart_PS, XUARTPS_OPER_MODE_NORMAL); return XST_SUCCESS; }
//////////////////////////// MAIN //////////////////// MAIN ////////////// int main() { // Local Variables for main() int i = 0; // index int menusel = 99999; // Menu Select int mode = 9; // Mode of Operation int enable_state = 0; // 0: disabled, 1: enabled int thres = 0; // Trigger Threshold char updateint = 'N'; // switch to change integral values u32 databuff = 0; // size of the data buffer // Initialize System init_platform(); // This initializes the platform, which is ... ps7_post_config(); Xil_DCacheDisable(); // InitializeAXIDma(); // Initialize the AXI DMA Transfer Interface Xil_Out32 (XPAR_AXI_GPIO_16_BASEADDR, 16384); Xil_Out32 (XPAR_AXI_GPIO_17_BASEADDR , 1); InitializeInterruptSystem(XPAR_PS7_SCUGIC_0_DEVICE_ID); for (i=0; i<32; i++ ) { RecvBuffer[i] = '_'; } // Clear RecvBuffer Variable for (i=0; i<32; i++ ) { SendBuffer[i] = '_'; } // Clear SendBuffer Variable //*******************Setup the UART **********************// XUartPs_Config *Config = XUartPs_LookupConfig(UART_DEVICEID); if (NULL == Config) { return 1;} Status = XUartPs_CfgInitialize(&Uart_PS, Config, Config->BaseAddress); if (Status != 0){ return 1; } /* Conduct a Selftest for the UART */ Status = XUartPs_SelfTest(&Uart_PS); if (Status != 0) { return 1; } /* Set to normal mode. */ XUartPs_SetOperMode(&Uart_PS, XUARTPS_OPER_MODE_NORMAL); //*******************Setup the UART **********************// //*******************Receive and Process Packets **********************// Xil_Out32 (XPAR_AXI_GPIO_0_BASEADDR, 11); Xil_Out32 (XPAR_AXI_GPIO_1_BASEADDR, 71); Xil_Out32 (XPAR_AXI_GPIO_2_BASEADDR, 167); Xil_Out32 (XPAR_AXI_GPIO_3_BASEADDR, 2015); Xil_Out32 (XPAR_AXI_GPIO_4_BASEADDR, 12); Xil_Out32 (XPAR_AXI_GPIO_5_BASEADDR, 75); Xil_Out32 (XPAR_AXI_GPIO_6_BASEADDR, 75); Xil_Out32 (XPAR_AXI_GPIO_7_BASEADDR, 5); Xil_Out32 (XPAR_AXI_GPIO_8_BASEADDR, 25); //*******************Receive and Process Packets **********************// //******************Setup Detector and Module Objects*****************// //LDetector *Detector = LDetector(); //Detector->SetMode(1); // Processed Data Mode //******************Setup Detector and Module Objects*****************// // *********** Setup the Hardware Reset GPIO ****************// GPIOConfigPtr = XGpioPs_LookupConfig(XPAR_PS7_GPIO_0_DEVICE_ID); Status = XGpioPs_CfgInitialize(&Gpio, GPIOConfigPtr, GPIOConfigPtr ->BaseAddr); if (Status != XST_SUCCESS) { return XST_FAILURE; } XGpioPs_SetDirectionPin(&Gpio, SW_BREAK_GPIO, 1); // *********** Setup the Hardware Reset MIO ****************// // ******************* POLLING LOOP *******************// xil_printf("\n\r Turn on Local Echo: under Terminal-Setup in Tera Term \n\r"); xil_printf(" Code is expecting a 'Return' after Each Command \n\r"); while(1){ sw = 0; // stop switch reset to 0 XUartPs_SetOptions(&Uart_PS,XUARTPS_OPTION_RESET_RX); // Clear UART Read Buffer for (i=0; i<32; i++ ) { RecvBuffer[i] = '_'; } // Clear RecvBuffer Variable sleep(0.5); // Built in Latency ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 0.5 s xil_printf("\n\r MAIN MENU \n\r"); xil_printf("******************************\n\r"); xil_printf(" 0) Set Mode of Operation\n\r"); xil_printf(" 1) Enable or disable the system\n\r"); xil_printf(" 2) Continuously Read of Processed Data\n\r"); xil_printf("\n\r **Setup Parameters ** \n\r"); xil_printf(" 3) Set Trigger Threshold\n\r"); xil_printf(" 4) Set Integration Times (number of clock cycles * 4ns) \n\r"); xil_printf("\n\r ** Additional Commands ** \n\r"); xil_printf(" 5) Perform a DMA transfer of Waveform Data\n\r"); xil_printf(" 6) Perform a DMA transfer of Processed Data\n\r"); xil_printf(" 7) Check the Size of the Data Buffered (Max = 4095) \n\r"); xil_printf(" 8) Clear the Processed Data Buffers\n\r"); xil_printf(" 9) Execute Print of Data on DRAM \n\r"); xil_printf("******************************\n\n\r"); while (XUartPs_IsSending(&Uart_PS)) {i++;} // Wait until Write Buffer is Sent // Wait for Input, Check // If input is valid break while and enter case statement // If input is invalid break and try again ReadCommandPoll(); menusel = 99999; sscanf(RecvBuffer,"%01d",&menusel); if ( menusel < 0 || menusel > 9 ) { xil_printf(" Invalid Command: Enter 0-9 \n\r"); sleep(1); // Built in Latency ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 s } switch (menusel) { // Switch-Case Menu Select case 0: //Set Mode of Operation mode = 99; //Detector->GetMode(); xil_printf("\n\r Waveform Data: \t Enter 0 <return>\n\r"); xil_printf(" LPF Waveform Data: \t Enter 1 <return>\n\r"); xil_printf(" DFF Waveform Data: \t Enter 2 <return>\n\r"); xil_printf(" TRG Waveform Data: \t Enter 3 <return>\n\r"); xil_printf(" Processed Data: \t Enter 4 <return>\n\r"); ReadCommandPoll(); sscanf(RecvBuffer,"%01d",&mode); if (mode < 0 || mode > 4 ) { xil_printf("Invalid Command\n\r"); break; } // mode = 0, AA waveform // mode = 1, LPF waveform // mode = 2, DFF waveform // mode = 3, TRG waveform // mode = 4, Processed Data //Detector->SetMode(mode); // Set Mode for Detector Xil_Out32 (XPAR_AXI_GPIO_14_BASEADDR, ((u32)mode)); // Register 14 if ( mode == 0 ) { xil_printf("Transfer AA Waveforms\n\r"); } if ( mode == 1 ) { xil_printf("Transfer LPF Waveforms\n\r"); } if ( mode == 2 ) { xil_printf("Transfer DFF Waveforms\n\r"); } if ( mode == 3 ) { xil_printf("Transfer TRG Waveforms\n\r"); } if ( mode == 4 ) { xil_printf("Transfer Processed Data\n\r"); } sleep(1); // Built in Latency ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 s break; case 1: //Enable or disable the system xil_printf("\n\r Disable: Enter 0 <return>\n\r"); xil_printf(" Enable: Enter 1 <return>\n\r"); ReadCommandPoll(); sscanf(RecvBuffer,"%01d",&enable_state); if (enable_state != 0 && enable_state != 1) { xil_printf("Invalid Command\n\r"); break; } Xil_Out32(XPAR_AXI_GPIO_18_BASEADDR, ((u32)enable_state)); // Register 18 Out enabled, In Disabled if ( enable_state == 1 ) { xil_printf("DAQ Enabled\n\r"); } if ( enable_state == 0 ) { xil_printf("DAQ Disabled\n\r"); } sleep(1); // Built in Latency ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 s break; case 2: //Continuously Read of Processed Data xil_printf("\n\r ********Data Acquisition:\n\r"); xil_printf(" Press 'q' to Stop or Press Hardware USR reset button \n\r"); xil_printf(" Press <return> to Start"); ReadCommandPoll(); DAQ(); sw = 0; // broke out of the read loop, stop swith reset to 0 break; case 3: //Set Threshold xil_printf("\n\r Existing Threshold = %d \n\r",Xil_In32(XPAR_AXI_GPIO_10_BASEADDR)); xil_printf(" Enter Threshold (6144 to 10240) <return> \n\r"); ReadCommandPoll(); sscanf(RecvBuffer,"%04d",&thres); Xil_Out32(XPAR_AXI_GPIO_10_BASEADDR, ((u32)thres)); xil_printf("New Threshold = %d \n\r",Xil_In32(XPAR_AXI_GPIO_10_BASEADDR)); sleep(1); // Built in Latency ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 s break; case 4: //Set Integration Times xil_printf("\n\r Existing Integration Times \n\r"); xil_printf(" Time = 0 ns is when the Pulse Crossed Threshold \n\r"); xil_printf(" Baseline Integral Window \t [-200ns,%dns] \n\r",-52 + ((int)Xil_In32(XPAR_AXI_GPIO_0_BASEADDR))*4 ); xil_printf(" Short Integral Window \t [-200ns,%dns] \n\r",-52 + ((int)Xil_In32(XPAR_AXI_GPIO_1_BASEADDR))*4 ); xil_printf(" Long Integral Window \t [-200ns,%dns] \n\r",-52 + ((int)Xil_In32(XPAR_AXI_GPIO_2_BASEADDR))*4 ); xil_printf(" Full Integral Window \t [-200ns,%dns] \n\r",-52 + ((int)Xil_In32(XPAR_AXI_GPIO_3_BASEADDR))*4 ); xil_printf(" Change: (Y)es (N)o <return>\n\r"); ReadCommandPoll(); sscanf(RecvBuffer,"%c",&updateint); if (updateint == 'N' || updateint == 'n') { break; } if (updateint == 'Y' || updateint == 'y') { SetIntegrationTimes(0); } sleep(1); // Built in Latency ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 s break; case 5: //Perform a DMA transfer xil_printf("\n\r Perform DMA Transfer of Waveform Data\n\r"); xil_printf(" Press 'q' to Exit Transfer \n\r"); Xil_Out32 (XPAR_AXI_DMA_0_BASEADDR + 0x48, 0xa000000); Xil_Out32 (XPAR_AXI_DMA_0_BASEADDR + 0x58 , 65536); sleep(1); // Built in Latency ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 s PrintData(); // Display data to console. sw = 0; // broke out of the read loop, stop swith reset to 0 break; case 6: //Perform a DMA transfer of Processed data xil_printf("\n\r ********Perform DMA Transfer of Processed Data \n\r"); xil_printf(" Press 'q' to Exit Transfer \n\r"); //Xil_Out32 (XPAR_AXI_GPIO_18_BASEADDR, 0); // Disable : GPIO Reg Capture Module Xil_Out32 (XPAR_AXI_GPIO_15_BASEADDR, 1); // Enable: GPIO Reg to Readout Data MUX //sleep(1); // Built in Latency ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 s Xil_Out32 (XPAR_AXI_DMA_0_BASEADDR + 0x48, 0xa000000); // Transfer from BRAM to DRAM, start address 0xa000000, 16-bit length Xil_Out32 (XPAR_AXI_DMA_0_BASEADDR + 0x58 , 65536); sleep(1); // Built in Latency ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 s Xil_Out32 (XPAR_AXI_GPIO_15_BASEADDR, 0); // Disable: GPIO Reg turn off Readout Data MUX ClearBuffers(); PrintData(); // Display data to console. //Xil_Out32 (XPAR_AXI_GPIO_18_BASEADDR, 1); // Enable : GPIO Reg Capture Module sw = 0; // broke out of the read loop, stop swith reset to 0 sleep(1); // Built in Latency ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 s break; case 7: //Check the Size of the Data Buffers databuff = Xil_In32 (XPAR_AXI_GPIO_11_BASEADDR); xil_printf("\n\r BRAM Data Buffer Size = %d \n\r",databuff); sleep(1); // Built in Latency ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 s break; case 8: //Clear the processed data buffers xil_printf("\n\r Clear the Data Buffers\n\r"); ClearBuffers(); sleep(1); // Built in Latency ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 s break; case 9: //Print DMA Data xil_printf("\n\r Print Data\n\r"); PrintData(); break; default : break; } // End Switch-Case Menu Select } // ******************* POLLING LOOP *******************// cleanup_platform(); // Clean up the platform, which is ... return 0; }
int main() { char buff[4]; init_platform(); int Status; XUartPs_Config *Config; int Index; u32 IntrMask = 0; int BadByteCount = 0; if (XGetPlatform_Info() == XPLAT_ZYNQ_ULTRA_MP) { #ifdef XPAR_XUARTPS_1_DEVICE_ID DeviceId = XPAR_XUARTPS_1_DEVICE_ID; #endif } /* * Initialize the UART driver so that it's ready to use * Look up the configuration in the config table, then initialize it. */ Config = XUartPs_LookupConfig(UART_DEVICE_ID); if (NULL == Config) { return XST_FAILURE; } Status = XUartPs_CfgInitialize(&uart, Config, Config->BaseAddress); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* Check hardware build */ Status = XUartPs_SelfTest(&uart); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Connect the UART to the interrupt subsystem such that interrupts * can occur. This function is application specific. */ Status = SetupInterruptSystem(&intc, &uart, UART_INT_IRQ_ID); if (Status != XST_SUCCESS) { return XST_FAILURE; } //force receive interrupt for every byte (char) XUartPs_SetFifoThreshold(&uart, 1); /* * Setup the handlers for the UART that will be called from the * interrupt context when data has been sent and received, specify * a pointer to the UART driver instance as the callback reference * so the handlers are able to access the instance data */ XUartPs_SetHandler(&uart, (XUartPs_Handler)Handler, &uart); /* * Enable the interrupt of the UART so interrupts will occur */ IntrMask = XUARTPS_IXR_TOUT | XUARTPS_IXR_PARITY | XUARTPS_IXR_FRAMING | XUARTPS_IXR_OVER | XUARTPS_IXR_TXEMPTY | XUARTPS_IXR_RXFULL | XUARTPS_IXR_RXOVR; if (uart.Platform == XPLAT_ZYNQ_ULTRA_MP) { IntrMask |= XUARTPS_IXR_RBRK; } XUartPs_SetInterruptMask(&uart, IntrMask); //XUartPs_SetOperMode(UartInstPtr, XUARTPS_OPER_MODE_LOCAL_LOOP); /* Set the UART in Normal Mode */ XUartPs_SetOperMode(&uart, XUARTPS_OPER_MODE_NORMAL); /* * Set the receiver timeout. If it is not set, and the last few bytes * of data do not trigger the over-water or full interrupt, the bytes * will not be received. By default it is disabled. * * The setting of 8 will timeout after 8 x 4 = 32 character times. * Increase the time out value if baud rate is high, decrease it if * baud rate is low. */ //XUartPs_SetRecvTimeout(&uart, 8); /* Run the UartPs Interrupt example, specify the the Device ID */ //currently sets up some of uart.Need to pull out what is needed Status = UartPsIntrExample(&intc, &uart,UART_DEVICE_ID, UART_INT_IRQ_ID); /* if (Status != XST_SUCCESS) { xil_printf("UART Interrupt Example Test Failed\r\n"); return XST_FAILURE; } */ xil_printf("Successfully ran UART Interrupt Example Test\r\n"); xil_printf("count = %i\r\n", count); return XST_SUCCESS; cleanup_platform(); return 0; }