Search the Community

Showing results for tags 'interrupts'.

More search options

  • Search By Tags

    Type tags separated by commas.
  • Search By Author

Content Type


  • News
    • New Users Introduction
    • Announcements
  • Digilent Technical Forums
    • FPGA
    • Digilent Microcontroller Boards
    • Non-Digilent Microcontrollers
    • Add-on Boards
    • Scopes & Instruments
    • LabVIEW
    • FRC
    • Other
  • General Discussion
    • Project Vault
    • Learn
    • Suggestions & Feedback
    • Buy, Sell, Trade
    • Sales Questions
    • Off Topic
    • Educators
    • Technical Based Off-Topic Discussions

Find results in...

Find results that contain...

Date Created

  • Start


Last Updated

  • Start


Filter by number of...


  • Start





Website URL







Found 7 results

  1. Hello everyone! I'm Harri, an EE Master's student. Me and my team are currently working on assignments for three different courses around the topics of FreeRTOS, digital filtering and hardware-in-the-loop with MATLAB and Simulink. We are using the Zybo Z7-10 board and Vivado/SDK v.2018.2. In the first project, we are trying to use the Xilinx port of FreeRTOS to run a control engineering state-space-model on the ARM side. The vision is to have the model, which is a DC-converter, run at 10 kHz and the output of the model is shown as PWM to the onboard RGB LED. The project should also have a menu system via UART/Ethernet or by buttons and switches. These should be mutually exclusive, so when one input method is in use, the other will be blocked. We are kind of puzzled with this one, because our initial plan was to enable interrupts for GPIO and UART and then have those either take a semaphore from the ISR or send a struct to a queue from ISR. So far using the xscugic and registering the interrupts has been a huge puzzle for us and the workflow around this is unclear to us. We have managed to get task notifications to work from button press to periodic task, but trying anything more than that e.g. queues seems to not work. Any help on these topics would be highly appreciated! The other two project are on digital filtering. We are simply trying to run some simple audio effects on the music from LINE/MIC IN -> OUR FILTER -> HPHOUT. We have used this example as a starting point and got that to work. Now we would like to remove the DMA part and just add our filtering IP in the middle. The PS side and buttons would be used for simple visuals for amplitude on LEDs or enable/disable certain effects inside the block. Any guidance on this one? We have already read the audio codec manual/register map, but we are missing something. Also, if someone has experience with Mathworks MATLAB and Simulink and this Zybo Z7-10 board, that would be awesome, as the other project is actually more focused on the filter design part and not FPGA stuff. Also, our professor would be glad to have this kind of HIL setup demoed: We have tried following the setup guide for that one, but we are tripping at the point of connecting to the board and running the simulation. The SD card setup also is not well explained. I'm hoping to get help, ideas and inspiration from here! I'll be glad to also share the projects when they're done. Cheers, Harri
  2. Hi all, I have been working with the CMOD A7 board using vivado 2018 and sdk. I have been trying to get the microblaze soft core to respond to the interrupts generated by the peripherals. I started with the timer but have since moved simpler to the uart. I have connected my hardware as shown here. And the code that I am testing is an imported example from drivers board support package. Specifically, it is the one from the uartlite and it is the interrupt exapmle. /****************************************************************************** * * Copyright (C) 2002 - 2015 Xilinx, Inc. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * Use of the Software is limited solely to applications: * (a) running on a Xilinx device, or * (b) that interact with a Xilinx device through a bus or interconnect. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * XILINX BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. * * Except as contained in this notice, the name of the Xilinx shall not be used * in advertising or otherwise to promote the sale, use or other dealings in * this Software without prior written authorization from Xilinx. * ******************************************************************************/ /******************************************************************************/ /** * * @file xuartlite_intr_example.c * * This file contains a design example using the UartLite driver (XUartLite) and * hardware device using the interrupt mode. * * @note * * The user must provide a physical loopback such that data which is * transmitted will be received. * * MODIFICATION HISTORY: * <pre> * Ver Who Date Changes * ----- ---- -------- ----------------------------------------------- * 1.00a jhl 02/13/02 First release * 1.00b rpm 10/01/03 Made XIntc declaration global * 1.00b sv 06/09/05 Minor changes to comply to Doxygen and coding guidelines * 2.00a ktn 10/20/09 Updated to use HAL Processor APIs and minor changes * for coding guidelnes. * 3.2 ms 01/23/17 Added xil_printf statement in main function to * ensure that "Successfully ran" and "Failed" strings * are available in all examples. This is a fix for * CR-965028. * </pre> ******************************************************************************/ /***************************** Include Files *********************************/ #include "xparameters.h" #include "xuartlite.h" #include "xintc.h" #include "xil_exception.h" #include "xil_printf.h" /************************** Constant Definitions *****************************/ /* * The following constants map to the XPAR parameters created in the * xparameters.h file. They are defined here such that a user can easily * change all the needed parameters in one place. */ #define UARTLITE_DEVICE_ID XPAR_UARTLITE_0_DEVICE_ID #define INTC_DEVICE_ID XPAR_INTC_0_DEVICE_ID #define UARTLITE_INT_IRQ_ID XPAR_INTC_0_UARTLITE_0_VEC_ID /* * The following constant controls the length of the buffers to be sent * and received with the UartLite device. */ #define TEST_BUFFER_SIZE 100 /**************************** Type Definitions *******************************/ /***************** Macros (Inline Functions) Definitions *********************/ /************************** Function Prototypes ******************************/ int UartLiteIntrExample(u16 DeviceId); int SetupInterruptSystem(XUartLite *UartLitePtr); void SendHandler(void *CallBackRef, unsigned int EventData); void RecvHandler(void *CallBackRef, unsigned int EventData); /************************** Variable Definitions *****************************/ XUartLite UartLite; /* The instance of the UartLite Device */ XIntc InterruptController; /* The instance of the Interrupt Controller */ /* * The following variables are shared between non-interrupt processing and * interrupt processing such that they must be global. */ /* * The following buffers are used in this example to send and receive data * with the UartLite. */ u8 SendBuffer[TEST_BUFFER_SIZE]; u8 ReceiveBuffer[TEST_BUFFER_SIZE]; /* * The following counters are used to determine when the entire buffer has * been sent and received. */ static volatile int TotalReceivedCount; static volatile int TotalSentCount; /******************************************************************************/ /** * * Main function to call the UartLite interrupt example. * * @param None * * @return XST_SUCCESS if successful, XST_FAILURE if unsuccessful * * @note None * *******************************************************************************/ int main(void) { int Status; /* * Run the UartLite Interrupt example, specify the Device ID that is * generated in xparameters.h. */ Status = UartLiteIntrExample(UARTLITE_DEVICE_ID); if (Status != XST_SUCCESS) { xil_printf("Uartlite interrupt Example Failed\r\n"); return XST_FAILURE; } xil_printf("Successfully ran Uartlite interrupt Example\r\n"); return XST_SUCCESS; } /****************************************************************************/ /** * * This function does a minimal test on the UartLite device and driver as a * design example. The purpose of this function is to illustrate * how to use the XUartLite component. * * This function sends data and expects to receive the same data through the * UartLite. The user must provide a physical loopback such that data which is * transmitted will be received. * * This function uses interrupt driver mode of the UartLite device. The calls * to the UartLite driver in the handlers should only use the non-blocking * calls. * * @param DeviceId is the Device ID of the UartLite Device and is the * XPAR_<uartlite_instance>_DEVICE_ID 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 UartLiteIntrExample(u16 DeviceId) { int Status; int Index; /* * Initialize the UartLite driver so that it's ready to use. */ Status = XUartLite_Initialize(&UartLite, DeviceId); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Perform a self-test to ensure that the hardware was built correctly. */ Status = XUartLite_SelfTest(&UartLite); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Connect the UartLite to the interrupt subsystem such that interrupts can * occur. This function is application specific. */ Status = SetupInterruptSystem(&UartLite); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Setup the handlers for the UartLite that will be called from the * interrupt context when data has been sent and received, specify a * pointer to the UartLite driver instance as the callback reference so * that the handlers are able to access the instance data. */ XUartLite_SetSendHandler(&UartLite, SendHandler, &UartLite); XUartLite_SetRecvHandler(&UartLite, RecvHandler, &UartLite); /* * Enable the interrupt of the UartLite so that interrupts will occur. */ XUartLite_EnableInterrupt(&UartLite); /* * Initialize the send buffer bytes with a pattern to send 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; ReceiveBuffer[Index] = 0; } /* * Start receiving data before sending it since there is a loopback. */ XUartLite_Recv(&UartLite, ReceiveBuffer, TEST_BUFFER_SIZE); /* * Send the buffer using the UartLite. */ XUartLite_Send(&UartLite, 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 ((TotalReceivedCount != TEST_BUFFER_SIZE) || (TotalSentCount != TEST_BUFFER_SIZE)) { } /* * Verify the entire receive buffer was successfully received. */ for (Index = 0; Index < TEST_BUFFER_SIZE; Index++) { if (ReceiveBuffer[Index] != SendBuffer[Index]) { return XST_FAILURE; } } return XST_SUCCESS; } /*****************************************************************************/ /** * * This function is the handler which performs processing to send data to the * UartLite. It is called from an interrupt context such that the amount of * processing performed should be minimized. It is called when the transmit * FIFO of the UartLite is empty and more data can be sent through the UartLite. * * This handler provides an example of how to handle data for the UartLite, * but is application specific. * * @param CallBackRef contains a callback reference from the driver. * In this case it is the instance pointer for the UartLite driver. * @param EventData contains the number of bytes sent or received for sent * and receive events. * * @return None. * * @note None. * ****************************************************************************/ void SendHandler(void *CallBackRef, unsigned int EventData) { TotalSentCount = EventData; } /****************************************************************************/ /** * * This function is the handler which performs processing to receive data from * the UartLite. It is called from an interrupt context such that the amount of * processing performed should be minimized. It is called data is present in * the receive FIFO of the UartLite such that the data can be retrieved from * the UartLite. The size of the data present in the FIFO is not known when * this function is called. * * This handler provides an example of how to handle data for the UartLite, * but is application specific. * * @param CallBackRef contains a callback reference from the driver, in * this case it is the instance pointer for the UartLite driver. * @param EventData contains the number of bytes sent or received for sent * and receive events. * * @return None. * * @note None. * ****************************************************************************/ void RecvHandler(void *CallBackRef, unsigned int EventData) { TotalReceivedCount = EventData; } /****************************************************************************/ /** * * This function setups the interrupt system such that interrupts can occur * for the UartLite device. This function is application specific since the * actual system may or may not have an interrupt controller. The UartLite * could be directly connected to a processor without an interrupt controller. * The user should modify this function to fit the application. * * @param UartLitePtr contains a pointer to the instance of the UartLite * component which is going to be connected to the interrupt * controller. * * @return XST_SUCCESS if successful, otherwise XST_FAILURE. * * @note None. * ****************************************************************************/ int SetupInterruptSystem(XUartLite *UartLitePtr) { int Status; /* * Initialize the interrupt controller driver so that it is ready to * use. */ Status = XIntc_Initialize(&InterruptController, INTC_DEVICE_ID); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Connect a device driver handler that will be called when an interrupt * for the device occurs, the device driver handler performs the * specific interrupt processing for the device. */ Status = XIntc_Connect(&InterruptController, UARTLITE_INT_IRQ_ID, (XInterruptHandler)XUartLite_InterruptHandler, (void *)UartLitePtr); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Start the interrupt controller such that interrupts are enabled for * all devices that cause interrupts, specific real mode so that * the UartLite can cause interrupts through the interrupt controller. */ Status = XIntc_Start(&InterruptController, XIN_REAL_MODE); if (Status != XST_SUCCESS) { return XST_FAILURE; } /* * Enable the interrupt for the UartLite device. */ XIntc_Enable(&InterruptController, UARTLITE_INT_IRQ_ID); /* * Initialize the exception table. */ Xil_ExceptionInit(); /* * Register the interrupt controller handler with the exception table. */ Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT, (Xil_ExceptionHandler)XIntc_InterruptHandler, &InterruptController); /* * Enable exceptions. */ Xil_ExceptionEnable(); return XST_SUCCESS; } The problem is that the code gets stuck in the while loop (as it did with the other interrupt examples) and is always waiting for the interrupt. In either case the event that triggers the interrupt has occurred and the interrupt signal goes high but the controller never acknowledges the interrupt nor runs the handler. I am needing some help as to what is going wrong here and I'm not sure if its the hardware or software. Thanks,
  3. Hello, I am using Arty board to collect GPS data every second and prints it out to terminal. To do this, I modified PmodGPS example code on github which is attached (I wrote my code in C++, rather than the original code which was in C). I wanted to completely disable interrupts and poll data every second by myself, so I removed the interrupt part of the code, but apparently PmodGPS is not working without interrupts. Even though the GPS is getting a lock, I do not see any information printed out in terminal which means never goes to 1. Am I doing something wrong or the GPS is not actually working without interrupts? Any help is appreciated. Best, Mahdi
  4. Hello, i have an issue with the uio Interrupt handling. An AXI-GPIO ip core with enabled interrupt is connected with the interrupt system of the Zynq on an Arty-Z7-20 board. With petalinux i created an minimalistic Linux image which is running on that design and gives the GPIO-HW an uio device. I can read and write data throu that GPIO-HW via the Linux uio device. Now i wish to use the Interrupt ability. I know that i must make a blocking read Operation on the uio device to wait for an incomming Interrupt. If i push the "make Interrupt"-Button, then i do not receive an Interrupt (blocking read does not return). The GPIO IP core was configured like on a bare metal System. The "proc/Interrupts" file is empty, so Linux detected no Interrupts. I think that i must configure petalinux (e.g. petalinux-config -c kernel) to process Interrupts with Linux but i do not know which part of the large configuration i should Change and in which way. So here my questions: 1. What are the needed petalinux config items and there values to enable the uio Interrupt handling on Linux (petalinux)? 2. Are there special c function calls to enable the Linux Interrupt ability? 3. Has anybody ever seen an uio interrupt handling application on a zynq and could you give me the example code? 4. Is there a digilent eval board with a demo app uses that Technologie? 5. What is the Price in US-$ to get that informations? Thank you...
  5. Dear Experts I need help regarding interrupt handling using UIO. I am using Vivado 2015.4 and Petalinux 2015.4. The board used is Zedboard. I made the following vivado project attached as image. The interrupts from AXI and Fabric (PL-PS) are enabled. Afterwards i was able to export it as UIO and it shows in /dev as uio0. Now I implemented the following code by following this link: My code is as follows: /* * File: main.c * Author: fss * * Created on August 23, 2017, 12:35 PM */ #include <sys/mman.h> #include <stdio.h> #include <stdint.h> #include <stdlib.h> #include <poll.h> #include <fcntl.h> #include <errno.h> #define GPIO_DATA_OFFSET 0x00 #define GPIO_TRI_OFFSET 0x04 #define GPIO_DATA2_OFFSET 0x08 #define GPIO_TRI2_OFFSET 0x0C #define GPIO_GLOBAL_IRQ 0x11C #define GPIO_IRQ_CONTROL 0x128 #define GPIO_IRQ_STATUS 0x120 unsigned int get_memory_size(char *sysfs_path_file) { FILE *size_fp; unsigned int size; // open the file that describes the memory range size that is based on the // reg property of the node in the device tree size_fp = fopen(sysfs_path_file, "r"); if (size_fp == NULL) { printf("unable to open the uio size file\n"); exit(-1); } // get the size which is an ASCII string such as 0xXXXXXXXX and then be stop // using the file fscanf(size_fp, "0x%08X", &size); fclose(size_fp); return size; } void reg_write(void *reg_base, unsigned long offset, unsigned long value) { *((volatile unsigned long *)(reg_base + offset)) = value; } unsigned long reg_read(void *reg_base, unsigned long offset) { return *((volatile unsigned long *)(reg_base + offset)); } uint8_t wait_for_interrupt(int fd_int, void *gpio_ptr) { static unsigned int count = 0, bntd_flag = 0, bntu_flag = 0; int flag_end=0; int pending = 0; int reenable = 1; unsigned int reg; unsigned int value; // block (timeout for poll) on the file waiting for an interrupt struct pollfd fds = { .fd = fd_int, .events = POLLIN, }; int ret = poll(&fds, 1, 100); printf("ret is : %d\n", ret); if (ret >= 1) { read(fd_int, (void *)&reenable, sizeof(int)); // &reenable -> &pending // channel 1 reading value = reg_read(gpio_ptr, GPIO_DATA_OFFSET); if ((value & 0x00000001) != 0) { printf("Interrupt recieved"); } count++; usleep(50000); // anti rebond if(count == 10) flag_end = 1; // the interrupt occurred for the 1st GPIO channel so clear it reg = reg_read(gpio_ptr, GPIO_IRQ_STATUS); if (reg != 0) reg_write(gpio_ptr, GPIO_IRQ_STATUS, 1); // re-enable the interrupt in the interrupt controller thru the // the UIO subsystem now that it's been handled write(fd_int, (void *)&reenable, sizeof(int)); } return ret; } int main(void) { int fd = open("/dev/uio0", O_RDWR); if (fd < 0) { perror("open"); exit(EXIT_FAILURE); } int gpio_size = get_memory_size("/sys/class/uio/uio0/maps/map0/size"); /* mmap the UIO devices */ void * ptr_axi_gpio = mmap(NULL, gpio_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0); while (1) { wait_for_interrupt(fd,ptr_axi_gpio); } close(fd); exit(EXIT_SUCCESS); } But the issue is that this code is not catching the interrupt. Kindly help me in this. Any suggestion/links are more than welcomed Regards
  6. Hello All, Have been attempting to enable interrupts on a project using the Arty and was running into issues with the intc_SelfTest failing. I loaded the Arty BSD from github thinking I had some issue with the project itself but am getting the same exact result. Any suggestions as to what I may need to change? I changed nothing in the BSD so I'm assuming it should be correct. Also followed multiple online tutorials and have been unable to solve the issue. All suggestions are greatly appreciated. Thx!
  7. Confession: Part of original post was: "Using Uno board with an Analog Shield. What fixed resources does the Analog Shield library use? I have code that stopped interrupts from occuring by doing only #include <analogShield.h> , but the interrupts resumed after commenting out the include. This code was to establish a timed interrupt for accessing the Analog Shield, and I did not get to integrating in my analog access stuff." Well, my problem was really stupid. I had a call to the lcd inside an ISR. Duh.