Xilinx Demo Documentation 11.4

Jump to: navigation, search

Test Setup for Xilinx 11.4 SDK

There are a couple of ways to get the Treck demo up and running. The first way is to set up an SDK workspace and use the SDK to program the board. This method will allow the user to examine and modify the demo source code, set up compiler optimizations and run the debugger. The method for Setting up the SDK is detailed in the following section.

The second way to run the Treck demo is to download one of the pre-built executables to the board. Using the pre-built executable will allow the user to run the demo application immediately without any setup, only a couple of commands in a bash shell. The obvious disadvantage to this method is that the user won't be set up to modify the application or easily browse the application source. To use the prebuilt executable, follow the directions in the From a Bash Shell section of Programming the FPGA with the Hardware Description File (.bit) and the Programming the FPGA with the Application File (.elf) instructions. The board must be programmed with the hardware description file first and then the application file in order to run the demo.

The necessary files for the demo are contained within the demo kit, [treck_demo_virtex5.zip] or [treck_demo_spartan6.zip]. Extract the contents of the archive to a folder in the file system.


Note Note: If Windows is being used, the contents of this archive should be extracted to a folder whose path does not contain any spaces. Because the Xilinx tools use Unix emulation, using spaces in file names can cause problems.


Setting up the SDK: Placement of the Treck TCP/IP Library

Using the Pre-built Treck Library

The Treck TCP/IP software is built as a library and linked with the standalone application at compile time. The EDK tool searches though specific directories to find libraries to build as part of the LibGen process. For the SDK to find the Treck software and include it in the Software Platform settings dialogue, both directories contained in the /treck_demo_virtex5/sw_services and/or /treck_demo_spartan6/sw_services folder(s) must be placed in the proper directory for software libraries,

$XILINX_EDK\sw\<library_name>\sw_services

$XILINX_EDK is the location in which the EDK has been installed and <library_name> is the name of the library (often just "lib"), e.g., C:\Xilinx\11.1\EDK\sw\lib\sw_services for a Windows system or /opt/Xilinx/11.1/sw/lib/sw_services for a Linux system. The directory structure must be correct for the SDK to find the Treck library and allow it to be used in software projects. See the the section on the library generator, LibGen, in the [Embedded Systems Tools Reference Manual (UG111)] for additional details on the directories used.


Note Note: For Linux systems it is important to ensure that the permissions are correct when copying the Treck libraries into sw_services. Check to ensure the user that will be running the SDK has read/write/execute permissions for both of the Treck library folders after they are placed in sw_services. If not, see the Troubleshooting section in this guide for a method to grant the proper permissions to the user.

After the Treck libraries have been copied to the EDK sw_services directory, if any Xilinx software packages are running, restart them. Unless the Treck TCP/IP stack has been purchased, skip the following section, Building the Treck Library from Source, and go on to Setting up the SDK: Creating a Workspace.


Building the Treck Library from Source

If the Treck TCP/IP stack has been purchased it is possible to avoid the one hour time limit of the demo and compile the Treck library from source. Follow the instructions below.


1. Get the demo up and running using the pre-built library. Technically this step is not necessary, but it will make things easier and it will isolate any problems encountered as being issues with building the Treck library, not setting up an SDK project. The directions will assume that the pre-built libraries have been placed in $XILINX_EDK/sw/<library_name>/sw_services as done in Using the Pre-built Treck Library.


2. Begin by removing or renaming the pre-compiled Treck library, libtreck.a in the /ppc or /mb directory. For example, for compiling the library to run on the PPC under Xilkernel this library should be located in $XILINX_EDK/sw/lib/sw_services/treck_xmk_ppc_v1_00_c/src/ppc If the .tcl script sees a compiled library it will skip compiling a new library from source.


3. The library will be compiled using source code located in the $XILINX_EDK/sw/lib/sw_services/treck_library_name/src/ directory e.g., treck_xmk_ppc_v1_00_c/src/. You should copy the /source, /include and /snmpd (if applicable) directories from your Treck shipment into this directory.


4. It is recommended you retain the compile options from the pre-compiled library. To do this you must overwrite the trsystem.h file included in your shipment with the version used to compile the time-limited library. Using the same example as above, this file can be found in $XILINX_EDK/sw/treck_xmk_ppc_v1_00_c/src/ppc/include/trsystem.h. To remove the time-limit from the library you can modify this file and remove the following macro definition: TM_DEMO_TIME_LIMIT.


Note Note: It may be necessary to remove macros for other features in the demo if those features have not been purchased from Treck.

Only leave these defined if you have purchased HTTP:

#define TM_USE_HTTPD

#define TM_USE_HTTPD_CGI

Only leave this defined if you have purchased SNMP:

#define TM_SNMP_VERSION 2


5. Similarly, you will need to replace the trkernel.c file included in your Treck shipment with one appropriate for your environment. The trkernel.c file originally shipped with your Treck source code is a stub file intended to be replaced or modified by the user. Example kernel integration files can be found in the /source/kernel directory of your Treck shipment. The kernel integration file used to build the time-limited library can be found in $XILINX_EDK/sw/treck_xmk_ppc_v1_00_c/src/ppc/source. Replace the /source/trkernel.c file in your Treck shipment with the trkernel.c file that comes with the time limited libraries.


6.Finally, clean and rebuilt the Software Platform project. This can be done from the SDK by selecting Project->Clean... This process should take noticeably longer while compiling the Treck stack. If there are problems, the output of the Treck build is put into a file called logs (with no extension). You may view this file to see any compilation errors that may occur.


Setting up the SDK: Creating a Workspace

After the Treck libraries have been placed in the proper location, the SDK can properly import the application code for the demo.

1. Start the SDK. Click browse and select a folder that can serve as the location for a workspace. Any folder will work, but the path for the workspace you choose should not contain any spaces.

Figure 1: Workspace Selection Dialog

Figure 1: Workspace Selection Dialog

2. After the workspace has been chosen, the SDK will start. Assuming a new workspace has been selected, the SDK will prompt the user for the Hardware Specification File. The SDK is looking for a file called system.xml. For the ML507 demo this file is located in /treck_demo_virtex5/ml507_ppc440_emb_ref/SDK/SDK_Export/hw. Browse to the appropriate hardware specification file and click OK.

Figure 2: Hardware Specification File Dialog

Figure 2: Hardware Specification File Dialog

3. Once this has completed, the common_src folder located in /treck_demo_virtex5/TreckDemoSrc must be placed inside of the folder chosen as the workspace. For a specific example, if C:\SDK\appnote was chosen as the workspace, the common_src folder must be placed in C:\SDK\appnote using the operating system's file browser. This must be done before importing the projects into the workspace.


Setting up the SDK: Project Creation and Source Code

There are two methods for setting up the projects in the SDK. The first is to import the SDK projects from an archive file included with the demo. This method is the fastest and will require the least amount of interaction with the SDK settings. The second method is to create the projects from scratch. This method will work if there were any problems with the first method or if a more detailed understanding of working with the SDK is desired.


Method 1: Importing Included Projects

1. After the hardware specification file has been loaded and the common_src folder has been placed in the workspace directory, the SDK projects included with the demo can be imported. Go to File->Import... In the first window of the import wizard, choose Existing SDK Projects into Workspace and click Next.

Figure 3: Import Wizard

Figure 3: Import Wizard

2. On the next screen select Select archive file: and browse to import_these_projects.zip inside of /treck_demo_virtex5/. Make sure all of the projects are selected and click Finish.


Figure 4: Import Wizard - Project Selection

Figure 4: Import Wizard - Project Selection

3. Allow some time for the SDK to import the projects. After the import wizard is done, it will return to the default perspective in the SDK. There will be compile errors in the two managed make C applications indicated by red "x's" on the project folder icons, those errors will be fixed in the next few steps.


Warning Warning: Linked folders are not fully functional in the 12.1 and 12.2 versions of the Xilinx tools. This is a known problem and details can be found here and here. The workaround is to copy the contents of the common_src directory into the src directories for each project when using the 12.1 or 12.2 tools.

4. The next step is to create a linked folder. This is done through the advanced settings of the regular new folder dialog in the SDK. Right click on treck_xilkernel_app_ppc in the C/C++ Projects view. Go to New->Folder.

5. Click the Advanced >> button to expand the advanced options

6. Click Browse... navigate to the folder containing the current workspace and select the common_src folder that should have been placed in the root of the workspace directory in step 3 of Setting up the SDK: Creating a Workspace.

7. In the folder name: text box, type common_src. Click Finish.

Note Note: For the include paths in the project properties to work correctly, the common_src directory must be in the root of the workspace directory and the linked folder must be called "common_src".
Figure 5: Creating a Linked Folder

Figure 5: Creating a Linked Folder

8. Repeat steps 4 - 7 to set up a linked folder in the standalone project. The only difference is to right click on treck_standalone_app_ppc instead of treck_xilkernel_app_ppc in step 4.

9. Wait for the project to recompile. The demo should be ready to send to the board. See Programming the FPGA with the Hardware Description File and Programming the FPGA with the Application File to get the demo running on the FPGA.


Method 2: Creating the Projects from Scratch

If importing the projects included in the archive that came with the demo doesn't work, or a more hands on approach to setting up the SDK is desired, this method can be used to get the Treck demo up and running on the SDK.

Steps 1 -18 will set up the Xilkernel version of the demo. The standalone version setup is described in steps 19 - 32.

1. Click File->New->Software Platform... In the New Software Platform Project window that comes up choose a name for the software platform. For the platform type, choose Xilkernel.

Figure 6: Create a Software Platform

Figure 6: Create a Software Platform

2. Right click on the newly created software platform in the C/C++ Projects view on the left-hand side. Click Software Platform Settings... In the lower half of the settings window in the OS Version and Libraries Selection section, check the box next to treck_xmk_ppc for the Virtex-5 PPC demo and treck_xmk_mb for the Spartan-6 MicroBlaze demo. This will include the Treck library in the software platform, allowing Treck function calls in the application.

Figure 7: Select Treck Library

Figure 7: Select Treck Library

3. In the left hand panel in the Software Platform Settings window there are three options, Software Platform, OS and Libraries and Drivers. Click OS and Libraries. In the upper half of the window the operating system configuration settings can be modified. Use the settings below.


stdin RS232_Uart_1
stdout RS232_Uart_1
sysintc_spec xps_intc_0
systmr_spec true
systmr_dev none
systmr_freq 400000000 (for PPC)

100000000 (for MicroBlaze)

systmr_interval 10
config_pthread_support true
max_pthreads 10
pthread_stack_size 16384
config_pthread_mutex false
max_pthread_mutex 10
max_pthread_mutex_waitq 10
static_pthread_table Edit...
config_sched true
sched_type SCHED_PRIO
n_prio 32
max_readyq 10
config_time true
max_tmrs 10
config_sema true
max_sem 10
max_sem_waitq 10
config_named_sema false
config_msgq false
config_shm false
config_bufmalloc false
copyoutfiles false
config_debug_support false
enhanced_features true
config_kill false
config_yield true

4. After those settings match the ones in the table above, click OK and wait for the SDK to clean and build the project. After the project has finished rebuilding the newly created software platform, click File->New->Managed Make C Application Project... Choose a name for the application and make sure the software platform created in the previous step is selected as the software platform. Choose Empty Application and click Next. The next screen allows the build configurations to be selected for the project. Make sure all of the boxes are checked and click Next again.

Figure 8: Create a Managed Make C Project

Figure 8: Create a Managed Make C Project

Figure 9: Build Configuration Selection

Figure 9: Build Configuration Selection

5. In the C/C++ Indexer tab, choose Full C/C++ Indexer from the drop down. Click Finish.

6. Right click the newly created project in the C/C++ Projects view on the left-hand side. Click New->Source Folder. Call the new folder src.

7. Treck must be added as a library for this project. Right click the managed c project again and go to Properties. In the left pane click C/C++ Build. Under PowerPC C Linker, click Libraries and add treck as seen in the screenshot below.

Figure 10: Set the Library in the PPC Linker

Figure 10: Set the Library in the PPC Linker

8. From the same properties dialog used in step 7, under PowerPC C Compiler, click Include Paths. Add "../../common_src" excluding the quotation marks. This includes the common_src folder copied into the root of the workspace directory in step 3 of Setting up the SDK: Creating a Workspace. common_src must be placed in the workspace directory for the application to build properly.


Note Note: For Spartan-6 demos using EDK 11.4 there is a compiler issue that prevents the application from Setting up the SDK: Project Creation and Source Code being compiled with the default optimization setting of -O0. It is recommended to change the setting to -O2 as a workaround. For more details see the Troubleshooting section near the end of this document.

9. Open /treck_demo_virtex5/TreckDemoSrc/xilkernel using the operating system's file browser.

10.Select all of the src files in that folder and drag them into the source folder that was just created in the SDK. The files can be dragged directly to the src folder in the SDK window. If the source files are placed into the src folder using the operating systems file browser instead of dragging them directly into the SDK a refresh will be required for the new files to be recognized (right click the project and select Refresh).

11.Wait for the SDK to rebuild the project.


Warning Warning: Linked folders are not fully functional in the 12.1 and 12.2 versions of the Xilinx tools. This is a known problem and details can be found here and here. The workaround is to copy the contents of the common_src directory into the src directories for each project when using the 12.1 or 12.2 tools.

12.The next step is to create a linked folder. This is done through the advanced settings of the regular new folder dialog in the SDK. Right click on the managed make c application (not the software platform). Go to New->Folder.

13.Click the Advanced >> button to expand the advanced options

14.Click Browse..., navigate to the directory containing the current workspace and select the common_src folder that should have been placed in the root of the workspace directory in step 3 of Setting up the SDK: Creating a Workspace.

15.In the folder name: text box, enter common_src.


Note Note: For the include paths in the project properties to work correctly, the common_src directory must be in the root of the workspace directory and the linked folder must be called common_src.


Figure 11: Created a Linked Folder

Figure 11: Created a Linked Folder


16. Before the project can be run, a linker script must be generated. Go to Tools->Generate Linker Script... In the Linker Script Generator window, use both drop downs on the left hand side to select select DDR2_SDRAM_MEM_BASEADDR (DDR3_SDRAM_MEM_BASEADDR for the Spartan-6 devices). Also, in the Code Sections area under the Code Sections drop down, if there is not a .vectors section, use the Add Section button to add one (Section: .vectors, Size: 0x00000000, Memory: DDR2_SDRAM_MEM_BASEADDR

Note Note: A size of 0x00000000 is not the actual value, but the Linker Script Generator will correct this automatically, so just use 0x00000000 as a place holder). On the right-hand side, change the Heap and Stack sizes to 0x4000. Make sure the memory column for both the stack and heap size is set to the base address of the DDR SDRAM.
Figure 12: Generate the Linker Script

Figure 12: Generate the Linker Script

17. Click OK and wait for the SDK to rebuild the project. If generating the linker script fails or causes errors in the project the first time, repeat the procedure and try again double checking the settings.

18. Repeat step 1, but for the platform type choose standalone instead of Xilkernel.

19. Repeat step 2, but check the box next to treck_standalone_ppc instead of treck_xmk_ppc. After that, just click OK. Don't modify any of the settings in OS and Libraries as done in step 3.

20.Repeat step 4, but choose a different application name and make sure to select the standalone software platform created in step 18, not the Xilkernel platform.

21.Repeat step 5.

22.Repeat step 6, but make sure to right click the standalone project, not the Xilkernel one.

23.Repeat step 7, but make sure to right click the standalone project, not the Xilkernel one.

24.Repeat step 8.

25.Repeat step 9, but open /treck_demo_virtex5/TreckDemoSrc/standalone instead.

26.Repeat step 10, but drag the files into the src folder in the standalone project.

27.Repeat step 11.

28.Repeat step 12, but make sure the right click the standalone project, not the Xilkernel one.

Note Note: For steps 28 - 31, the common_src folder is the same folder used for the Xilkernel project. This allows the two projects to share common source files without having to maintain two separate copies.

29.Repeat step 13

30.Repeat step 14

31.Repeat step 15

32.Repeat step 16, this time a dialog will ask the user to choose which application project. Make sure to select the standalone project, not the XilKernel one.

Figure 13: Select App

Figure 13: Select App

Both applications should now be ready to be run. See Programming the FPGA with the Hardware Description File and Programming the FPGA with the Application File to get the demo running on the FPGA.


Setting up the SDK: Compiler Optimizations

Adjusting the compiler optimizations is not necessary to get the demo running, but it is the only way to get the best performance out of the demo application and the Treck TCP/IP stack. In most cases there will be a noticeable increase in transfer rate for both TCP and UDP performance tests. Also, understanding these SDK features can help to troubleshoot any problems with getting the demo to run on the board properly and introduce new features of the tool set.

The SDK automatically sets up three different build configurations for the project when the managed make C application is created (see step 4 of Method 2: Creating the Projects from Scratch). By default the SDK will be configured to build the demo applications using the debug configuration. This means that the compiler will not attempt to optimize the code at all. This allows for better communication with the debugger, but comes at the cost of speed. Release mode configures the compiler to optimize the code for speed, but doesn't include debug symbols, making communication with the debugger impossible. The SDK makes switching between the two build configurations very easy after the initial setup.

To change the build configuration for a Managed Make C Application:

1. Right click the application in the C/C++ Projects view and select Properties.

2. In the left-hand panel click C/C++ Build.

3. In the Active Configuration section, use the Configuration: drop-down to select the desired configuration, Debug, Release or Profile.


Figure 14: Change Build Configuration

Figure 14: Change Build Configuration

If this is a new configuration that hasn't been created before, there are some settings that need to be adjusted that don't carry over from the previous configuration.

1. Under PowerPC C Compiler, click Include Paths. Add "../../common_src" excluding the quotation marks (just as was done in step 8 of Method 2: Creating the Projects from Scratch).

2. Under PowerPC C Linker, click Libraries. Add treck to Libraries (see step 7 of Method 2: Creating the Projects from Scratch] for a screen shot).

3. Click OK and wait for the SDK to build a new binary. In the the C/C++ Projects view, a new folder will be created in the application project.

4. A new run configuration will have to be created for the new binary. Right click the application and select Run As->Run... Follow the instructions in steps 2 - 6 of From the SDK from Programming the FPGA with the Application File (.elf) to create a new run configuration.

Note Note: When running the application, the build configuration and the run configuration must match. The run configuration specifies the location of the binary, so if a different run configuration is used, either another binary from the previous build configuration that hasn't been automatically built will be run, or the SDK won't be able to find a binary.


Programming the FPGA with the Hardware Description File (.bit)

Before the application can be run on the board, it must be programmed with the hardware design. There are several ways to program the FPGA with the bitstream file using the Xilinx tool-set. It can be done from the SDK, iMPACT via a bash shell or through XPS.


From the SDK (.bit)

Programming the board from the SDK is simple.

1. Just click Tools->Program FPGA... The bit file and bmm file locations the dialog requests should be auto-populated, but if not they are in /treck_demo_virtex5/ml507_ppc440_emb_ref/SDK/SDK_Export/hw/, the same place system.xml is located.

Figure 15: Program the FPGA from the SDK

Figure 15: Program the FPGA from the SDK

2. Click Save and Program to program the FPGA with the bit file.


From a Bash Shell (.bit)

A bash shell can be opened either through the SDK (Tools->Bash Shell...), XPS (Project->Launch Xilinx Bash Shell), the Windows start menu (Start->Xilinx ISE Design Suite 11->EDK- >Accessories->Bash Shell) or by simply opening a terminal window in Linux.


1. Change directories to the /treck_demo_virtex5/ready_for_download directory.

2. Use iMPACT to download the bitstream by using the following: impact -batch ug511.cmd

Note Note: In Linux, if this command produces "bash: impact: command not found", make sure that the directory containing the impact binary is in the path variable or use the absolute path, making the command /opt/Xilinx/11.1/ISE/bin/lin/impact -batch ug511.cmd, assuming /opt/Xilinx is where the Xilinx tool-set was installed.


From XPS (.bit)

XPS allows the user to regenerate the bitstream file as well as program the FPGA. If the user just needs to program the board, the second step can be skipped.

1. Open /treck_demo_virtex5/ml507_ppc440_emb_ref/system.xmp inside XPS.

2. Use Hardware->Generate Bitstream to generate a bitstream for the system.

Note Note: Regenerating the bitstream can take a very long time. On the computer used to document this demo it took approximately 50 minutes.


Note Note: This document does not cover modifying the hardware design. The XPS project is provided as a reference to give a more full description of the underlying hardware. But if the newly generated bitstream is to be used with the SDK, the SDK export utility must be used. See the procedure provided [here] for more information.

3. Download the bitstream to the board with Device Configuration->Download Bitstream.


Programming the FPGA with the Application File (.elf)

Once the FPGA has been programmed with the bitstream, the application can be sent to and run on the board. This can be done by using the SDK, a bash shell or XPS.

Note Note: Before running the application, read the section on Optimizing the PC Network Connection and the Running the Application section of this document for information on setting up the computer to properly communicate over the serial port and Ethernet.


From the SDK (.elf)

After the SDK has been properly set up as detailed in the Test Setup section of this document, running the program is very straightforward.

1. Right click on the project to be run (the Managed Make C Application, not the Software Platform) and click Run As->Run...

2. If this is the first time the application is being run, click the New button on the left-hand side of the run dialog and continue to step 3. Otherwise, select the correct run configuration and click Run.

3. Type a name for the new configuration.

4. Click Browse to the right of the Project: text field and select the project to be run.

5. Click Browse next to the C/C++ Application text field and find the .elf file for the project. The location of the .elf file will depend on the build configuration set for the project. By default the build configuration is Debug, so the .elf file will be located at Debug/project_name.elf, but if the Release build configuration is being used, the .elf file will be at Release/project_name.elf. See Setting up the SDK: Compiler Optimizations for more details.

Figure 16: SDK Run Dialog

Figure 16: SDK Run Dialog

6. Finally, click Run and the project should begin to execute.


From a Bash Shell (.elf)

A bash shell can be opened either through the SDK (Tools->Bash Shell...), XPS (Project->Launch Xilinx Bash Shell), the Windows start menu (Start->Xilinx ISE Design Suite 11->EDK- >Accessories->Bash Shell) or by simply opening a terminal window in Linux.

1. Change directories to /treck_demo_virtex5/ready_for_download

Note Note: If an elf file other than the pre-built one is to be downloaded, change to the directory of that elf file.

2. Start xmd with xmd

Note Note: In Linux, if this command produces "bash: xmd: command not found", make sure that the directory containing the xmd binary is in the path variable or use the absolute path, making the command /opt/Xilinx/11.1/EDK/bin/lin/xmd, assuming /opt/Xilinx is where the Xilinx tool-set was installed.

3. Enter connect hw ppc

4. To download the .elf file, type dow treck_demo.elf (or the name of the .elf file to be downloaded)

5. Once the download has completed, run the program with run

6. The program can be stopped with stop or reset with rst


From XPS (.elf)

This demo does provide the hardware reference design, ml507_ppc440_emb_ref, as an XPS project, but the XPS project is not set up to build or run either of the Treck demo applications. It is only a hardware design. It is possible to use the Treck application source code to create a project in XPS to get the applications to build and run, but that process is not covered in this document and it is not supported by Treck Inc. To build and run the demo applications, use the SDK or the pre-built executables provided in treck_demo_virtex5.zip or treck_demo_spartan6.zip. Below is the procedure to run pre-built .elf executables for the ML507 using XPS.

1. Click Debug->Launch XMD...

2. Change directories to /treck_demo_virtex5/ready_for_download

Note Note: If an .elf file other than the pre-built one is to be downloaded, change to the directory of that elf file

3. Enter connect hw ppc'

4. Change directory to the location of the .elf file

5. To download the .elf file, type dow treck_demo.elf (or the name of the .elf file to be downloaded)

6. Once the download has completed, run the program with run

7. The program can be stopped with stop or reset with rst


Running the Application

Now you can return to Running the Application.


Results

The test results can be found here.


Conclusion

The demo provided demonstrates the versatility and speed of the Treck TCP/IP stack running in many applications utilizing protocols including TCP, UDP, HTTP, FTP, Telnet and SNMP across different software platforms and architectures. The example code not only provides a method for obtaining performance numbers, but serves as an excellent starting point for using the Treck TCP/IP stack in combination with Xilinx hardware and tool-sets. Combined with the Xilinx Tri-Mode Ethernet MAC (TEMAC), the Treck stack is able to achieve exceptional performance in embedded applications.

For more information about Treck or purchasing information, visit http://www.treck.com or contact sales@treck.com.


References

XAPP1041: Reference System: XPS LL Tri-Mode Ethernet MAC Embedded Systems for MicroBlaze and PowerPC Processors

XAPP1043: Measuring Treck TCP/IP Performance Using the XPS LocalLink TEMAC in an Embedded Processor System

UG111: Embedded System Tools Reference Guide EDK 11.3.1

UG347: ML505/ML506/ML507 Evaluation Platform User Guide

Virtex-6 FPGA Embedded Kit Reference Design and Documentation

OS and Libraries Document Collection (UG 643 April 19, 2010)


Revision History

Date Version Revision
8/19/09 0.9 Draft release to partners
8/27/09 1.0 Initial release to treck.com, demo kit only includes ML507 hardware design
1/29/10 2.0 Updated to include SP605 demo
8/10/10 3.0 Converted to MediaWiki format. All future revision history will be maintained by the wiki.
1/14/10 4.0 Split from main documentation to separate page.


Notice of Disclaimer

ALL MATERIALS, INFORMATION, DEMO SOFTWARE, AND SERVICES SET FORTH IN THIS DEMO PACKAGE ARE PROVIDED "AS IS" WITH NO WARRANTY OF ANY KIND. TRECK DISCLAIMS ALL WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. TRECK DOES NOT WARRANT THAT THE CONTENT OF THIS DEMO PACKAGE, OR ANY DEMO SOFTWARE ASSOCIATED THEREWITH, IS ACCURATE, RELIABLE, CORRECT, FREE OF ERRORS OR DEFECTS. YOUR USE OF THIS DEMO PACKAGE IS SOLELY AT YOUR RISK. TRECK AND ITS PARTNERS SHALL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, PUNITIVE, INCIDENTAL, SPECIAL OR CONSEQUENTIAL DAMAGES THAT RESULT FROM THE USE OF THIS DEMO PACKAGE OR DEMONSTRATION SOFTWARE AVAILABLE VIA USE OF THIS DEMO. THIS LIMITATION APPLIES WHETHER THE ALLEGED LIABILITY IS BASED ON CONTRACT, TORT, NEGLIGENCE, STRICT LIABILITY OR ANY OTHER BASIS, EVEN IF TRECK HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.