By Adam Taylor
To wrap up this blog for the year, we are going to complete the SDSoC integration using the shared library.
To recap, we have generated a bit file using the Xilinx SDSoC development environment that implements the matrix multiply example using the PL (programmable logic) on the base PYNQ platform, which we previously defined using SDSoC. The final step is to get it all integrated and the first step is to upload the following files to the PYNQ board:
- bit – The bit file for the programmable logic
- tcl – The TCL file description of the block diagram with address ranges
- so – The generated shared library
The names are slightly different as I generated them as part of the previous blog.
Using a program like WinSCP, I uploaded these three files to the PYNQ bit stream directory, the same place we uploaded our previous design too.
The next step is to develop the Jupyter notebook so that we can drive the new overlay that we have created. To get this up and running we need to do the following:
- Download and verify the overlay
- Create an MMIO class to interface with the existing block RAM which remains in the overlay
- Create a CFFI class to interface with the shared library
- Write a simple example to interface the overlay using the MMIO and CFFI classes
This is very similar to what we have done previously with the exception of the creating the CFFI, so that is where the rest of this blog will focus.
The first thing we need to do is know the names of the function within the shared library, because SDSoC will create a different name from the actual accelerated function. We can find the renamed files under <project>/<build config>/_sds/swstubs while the hardware files are under <project>/<build config>/_sds/p0/ipi.
If you already have the shared library on your PYNQ board, then you can use the command nm -D <path & shared library name> to examine its contents if you access the PYNQ via an SSH session.
With the name of the function known we can create CFFI class within our Jupyter note book. In the class for this example we need to create two functions: one for initialization and another to interact with the library. The more complicated of the two is the initialization under which we must define the location of the shared library within the file system. As mentioned earlier, I have uploaded the shared library to the same location as the bit and TCL files. We also need to declare the functions contained within the shared library and the finally open the shared library.
The second function within the class is what we call when we wish to make use of the shared library. We can then make use of this class as we do any other within the rest of our program. In fact, this approach is used often in Python development to bind together C and Python.
This example shows just how easily we can create overlays using SDSoC and interface with them using Python and the PYNQ development system. If you want to try and you currently do not have a license for SDSoC, you can obtain a free 60 day evaluation here with the new release.
As I mentioned up top this is the last blog of 2016, I will resume writing in the New Year and to give you a taste of what we are going to be looking at in 2017. Amongst other things I will be featuring:
- Image Processing using the PYNQ
- Advanced sensor interfacing techniques using the Avnet EVK
- Interfacing to Servos and robotics
Until then, have a great Christmas and New Year and thanks for reading the series.
Code is available on Github as always.
If you want E book or hardback versions of previous MicroZed chronicle blogs, you can get them below.
All of Adam Taylor’s MicroZed Chronicles are cataloged here.
via Xcell Daily Blog articles http://ift.tt/2fBJIws
December 18, 2016 at 10:08PM