Embedded Software Development Expert


register

Course Description

This 4-day course is a combination of “Embedded Systems Development” and “Embedded Systems Software Development ”.

This course brings experienced FPGA designers up to speed on developing embedded systems using the Embedded Development Kit (EDK) and introduces participants to software design and development for Xilinx embedded processor systems. In particular, this workshop includes numerous practical exercises and is aimed at developers who already have basic experience of the XILINX design system.

Module 1: Embedded Systems Development
Xilinx FPGAs provide a new level of system design capabilities through soft MicroBlaze™ processors, hard PowerPC® processors, and silicon-efficient architectural resources. This course brings experienced FPGA designers up to speed on developing embedded systems using the Embedded Development Kit (EDK). The features and capabilities of the Xilinx MicroBlaze soft processor and the PowerPC 440 processor are also included in the lectures and labs. The hands-on labs provide experience with the development, debugging, and simulation of an embedded system.

Module 2: Embedded Systems Software Development
Introduces you to software design and development for Xilinx embedded processor systems. You will learn the basic tool use and concepts required for the software phase of the design cycle, after the hardware design is completed.

Topics are comprehensive, covering the design and implementation of the software platform for resource access and management. Major topics include device driver development and user application debugging and integration. Practical implementation tips and best practices are also provided throughout to enable you to make good design decisions and keep your design cycles to a minimum. You will have enough practical information to get started developing the software platform for a Xilinx embedded system based on a PowerPC® 440 or MicroBlaze™ processor.

Duration
4 days

Who Should Attend
FPGA design engineers, system architects, and system engineers who are interested in Xilinx embedded systems development flow. Software and hardware design engineers interested in system design and implementation, platform software support, and software application development and debugging. This course is not for the hardware-only embedded designer.

Prerequisites

  • Completion of Fundamentals of FPGA Design course or equivalent knowledge of Xilinx ISE implementation tools
  • Some HDL modeling experience
  • C or C++ programming experience, including general debugging techniques
  • Conceptual understanding of embedded processing systems including device drivers, interrupt routines writing / modifying scripts, user applications, and boot loader operation

Why this training pays huge dividends
After completing this comprehensive training, you will be able to:

  • Describe the various tools that encompass the Xilinx Embedded Development Kit (EDK)
  • Rapidly architect an embedded system containing a MicroBlaze or IBM PowerPC processor and Xilinx-supplied CoreConnect bus architecture IP by using the Base System Builder (BSB)
  • Utilize the Eclipse-based Software Development Kit (SDK) to develop software applications and debug software
  • Create and integrate your own IP into the EDK environment
  • Implement an effective software design for a Xilinx embedded system using the Xilinx tools
  • Write a basic user application using the Xilinx Software Development Kit (SDK) and run it on the embedded system.
  • Use Xilinx debugger tools to troubleshoot user applications
  • Apply software techniques to improve operability
  • Reduce embedded software development time

Course Outline

Day 1

  • EDK Overview Base System Builder
    Lab 1: Hardware Construction with the Base System Builder Software Development Using SDK
    Lab 2:     Software, Implementation, and Download System Buses Hardware Design Hardware Design Using EDK
  • Lab 3: Adding IP to a Hardware Design

Day 2

  • Adding Your Own IP to the Embedded System
  • Lab 4: Adding Custom IP to an Embedded System
  • Software Debugging
  • Linker Script Generator
  • Lab 5: Software Debugging
  • System Simulation

Day 3

  • Course Agenda
  • Procesors, Peripherals, and Tools
  • Software Platform Development
  • Software Development Using XPS
  • Lab 6: Basic System Implementation
  • Writing Code in the Xilinx Environment
  • Software Development Using SDK
  • Lab 7: Application Development
  • Interrupts
  • Lab 8: Software Interrupts

Day 4

  • Software Platform Download and Boot
  • Application Debugging
  • Lab 9: Debugging
  • Application Profiling
  • Lab 10: SDK Profiling
  • Wrigint a Custom Device Driver
  • Project Management with the Xilinx Design Tools
  • Lab 11: Writing a Device Driver

Lab Descriptions

  • Lab 1: Hardware Construction with the Base System Builder – Create an XPS project by using the Base System Builder to develop a basic hardware system and generate a series of netlists for the embedded design.
  • Lab 2: Software, Implementation, and Download – Complete the processes begun in Lab 1 by building the software libraries and applications, generating a bitstream file, merging the application into the bitstream, and downloading to the ML507 board.
  • Lab 3: Adding Custom IP to a Hardware Design – Learn to add IP from the many choices in the IP library. Use the GUI to add a general-purpose I/O module and access internal block RAM directly from the MHS file..
  • Lab 4: Adding Custom IP to an Embedded System – Add custom IP to your design by using the Create and Import Peripheral wizard.
  • Lab 5: Software Debugging – Run the Software Development Kit (SDK) to produce a debug perspective, set breakpoints, and debug the application.
  • Lab 6: Basic System Implementation – Construct the hardware and software platforms used for the labs in this course. Begin with Base System Builder to create the hardware design. Specify a basic software platform and add a software application to the system.
  • Lab 7: Application Development – Create a simple software application project from provided source files for a software loop-based stopwatch. Research hardware and software documentation to complete the application; then download it to hardware.
  • Lab 8: Software Interrupts – Replace a software timing loop with an interrupt-driven timer. Add the timer software and write an interrupt handler for the timer. Configure the FPGA, download, and test the application.
  • Lab 9: Debugging – Set up the SDK debug perspective and the previous lab’s stopwatch application for debugging, setting breakpoints, calculating latency, and stepping through the program’s operation.
  • Lab 10: SDK Profiling – Profile a program, interpret profile reports, then enable cache and rewrite code to archive optimal performance.
  • Lab 11: Writing a Device Driver – Create the skeleton driver framework, add an LCD device driver, create the BSP, and verify proper device driver operation via a download to hardware test.