Cover image for Architecting High-Performance Embedded Systems

Architecting High-Performance Embedded Systems

Release Date: 2021/02/01
ISBN: 9781789955965
Topic:
0%
18
Chapters
0-1
Hours read
0k
Total Words
    Start Reading Now    
       Add to Wishlist       
View table of contents

Explore the complete process of developing systems based on field-programmable gate arrays (FPGAs), including the design of electronic circuits and the construction and debugging of prototype embedded devices

Key Features

  • Learn the basics of embedded systems and real-time operating systems
  • Understand how FPGAs implement processing algorithms in hardware
  • Design, construct, and debug custom digital systems from scratch using KiCad

Book Description

Modern digital devices used in homes, cars, and wearables contain highly sophisticated computing capabilities composed of embedded systems that generate, receive, and process digital data streams at rates up to multiple gigabits per second. This book will show you how to use Field Programmable Gate Arrays (FPGAs) and high-speed digital circuit design to create your own cutting-edge digital systems.

Architecting High-Performance Embedded Systems takes you through the fundamental concepts of embedded systems, including real-time operation and the Internet of Things (IoT), and the architecture and capabilities of the latest generation of FPGAs. Using powerful free tools for FPGA design and electronic circuit design, you'll learn how to design, build, test, and debug high-performance FPGA-based IoT devices. The book will also help you get up to speed with embedded system design, circuit design, hardware construction, firmware development, and debugging to produce a high-performance embedded device – a network-based digital oscilloscope. You'll explore techniques such as designing four-layer printed circuit boards with high-speed differential signal pairs and assembling the board using surface-mount components.

By the end of the book, you'll have a solid understanding of the concepts underlying embedded systems and FPGAs and will be able to design and construct your own sophisticated digital devices.

What you will learn

  • Understand the fundamentals of real-time embedded systems and sensors
  • Discover the capabilities of FPGAs and how to use FPGA development tools
  • Learn the principles of digital circuit design and PCB layout with KiCad
  • Construct high-speed circuit board prototypes at low cost
  • Design and develop high-performance algorithms for FPGAs
  • Develop robust, reliable, and efficient firmware in C
  • Thoroughly test and debug embedded device hardware and firmware

Who this book is for

This book is for software developers, IoT engineers, and anyone who wants to understand the process of developing high-performance embedded systems. You'll also find this book useful if you want to learn about the fundamentals of FPGA development and all aspects of firmware development in C and C++. Familiarity with the C language, digital circuits, and electronic soldering is necessary to get started.

Table of Contents

  1. Architecting High-Performance Embedded Systems
  2. Why subscribe?
  3. Contributors
  4. About the author
  5. About the reviewer
  6. Packt is searching for authors like you
  7. Preface
    1. Intended audience for this book
    2. What this book covers
    3. To get the most out of this book
    4. Download the example code files
    5. Download the color images
    6. Conventions used
    7. Get in touch
    8. Reviews
  8. Section 1: Fundamentals of High-Performance Embedded Systems
  9. Chapter 1: Architecting High-Performance Embedded Systems
    1. Technical requirements
    2. Elements of embedded systems
    3. Power source
    4. Digital processing
    5. Software and firmware
    6. Specialized circuitry
    7. Input from the environment
    8. Output to the environment
    9. Operating in real time
    10. Periodic operation
    11. Event-driven operation
    12. Real-time operating systems
    13. FPGAs in embedded systems
    14. Digital logic gates
    15. Flip-flops
    16. Elements of FPGAs
    17. FPGA synthesis
    18. Hardware design languages
    19. The benefits of using FPGAs in embedded system designs
    20. Xilinx FPGAs and development tools
    21. Summary
  10. Chapter 2: Sensing the World
    1. Technical requirements
    2. Introducing passive, active, and smart sensors
    3. Applying analog-to-digital converters
    4. The types of sensors used in embedded systems
    5. Light
    6. Temperature
    7. Pressure
    8. Humidity
    9. Fluid flow
    10. Force
    11. Ultrasonic
    12. Audio
    13. Magnetic
    14. Chemical
    15. Ionizing radiation
    16. Radar
    17. Lidar
    18. Video and infrared
    19. Inertial
    20. GPS
    21. Communicating with sensors
    22. GPIO
    23. Analog voltage
    24. I2C
    25. SPI
    26. CAN bus
    27. Wireless
    28. Processing sensor data
    29. Summary
  11. Chapter 3: Operating in Real Time
    1. Technical requirements
    2. What does real-time mean?
    3. Attributes of a real-time embedded system
    4. Performing multiple tasks
    5. Rate-monotonic scheduling
    6. Understanding key RTOS features and challenges
    7. Mutexes
    8. Semaphores
    9. Queues
    10. Event flags
    11. Timers
    12. Dynamic memory allocation
    13. Deadlock
    14. Priority inversion
    15. Popular real-time operating systems
    16. embOS
    17. FreeRTOS
    18. INTEGRITY
    19. Neutrino
    20. µc/OS-III
    21. VxWorks
    22. Summary
  12. Section 2: Designing and Constructing High-Performance Embedded Systems
  13. Chapter 4: Developing Your First FPGA Program
    1. Technical requirements
    2. Using FPGAs in real-time embedded system designs
    3. Block RAM and distributed RAM
    4. FPGA I/O pins and associated features
    5. Specialized hardware resources
    6. Processor cores
    7. FPGA implementation languages
    8. VHDL
    9. Verilog
    10. Block diagrams
    11. C/C++
    12. The FPGA development process
    13. Defining system requirements
    14. Allocating functionality to the FPGA
    15. Identifying required FPGA features
    16. Implementing the FPGA design
    17. Testing the implementation
    18. Developing your first FPGA project
    19. Project description
    20. Installing the Vivado tools
    21. Creating a project
    22. Creating VHDL source files
    23. Testing the logic behavior
    24. Defining I/O signals
    25. Creating a top-level VHDL file
    26. Synthesizing and implementing the FPGA bitstream
    27. Downloading the bitstream to the board
    28. Programming the bitstream to onboard flash memory
    29. Summary
  14. Chapter 5: Implementing systems with FPGAs
    1. Technical requirements
    2. The FPGA compilation process
    3. Design entry
    4. Logic synthesis
    5. Design optimization
    6. High-level synthesis
    7. Optimization and constraints
    8. Algorithm types most suitable for FPGA implementation
    9. Algorithms that process high-speed data streams
    10. Parallel algorithms
    11. Algorithms using nonstandard data sizes
    12. Kicking off the oscilloscope FPGA project
    13. Project description
    14. Baseline Vivado project
    15. Summary
  15. Chapter 6: Designing Circuits with KiCad
    1. Technical requirements
    2. Introducing KiCad
    3. Basic KiCad procedures
    4. Placing and connecting circuit components
    5. Creating component symbols
    6. Developing the project schematic diagram
    7. Adding text annotations
    8. Adding signal labels
    9. Adding global labels
    10. Creating differential signal pairs
    11. Creating offboard connections
    12. Symbol annotation and electrical rules checking
    13. Laying out the PCB
    14. Prototyping the circuit board
    15. Summary
  16. Chapter 7: Building High-Performance Digital Circuits
    1. Technical requirements
    2. Circuit board assembly tools and procedures
    3. Optical magnification
    4. Tweezers
    5. Flux
    6. Solder
    7. Electrostatic discharge protection
    8. Hand soldering
    9. Solder wick
    10. Solder paste application
    11. Reflow soldering
    12. Preparing for assembly and placing parts
    13. Reflow soldering and hand soldering
    14. Hand soldering
    15. Post-assembly board cleaning and inspection
    16. Summary
  17. Section 3: Implementing and Testing Real-Time Firmware
  18. Chapter 8: Bringing Up the Board for the First Time
    1. Technical requirements
    2. Preparing for power-up
    3. Supplying power to the board
    4. Checking our circuit's basic functionality
    5. Testing the board power supplies
    6. Testing the analog amplifiers
    7. Testing the ADC
    8. Adapting the circuit in case of problems
    9. Cutting PCB traces
    10. Installing solder jumpers and jumper wires
    11. Removing components
    12. Adding components
    13. Generating the ADC encoder clock and 1 KHz calibration signal
    14. Summary
  19. Chapter 9: The Firmware Development Process
    1. Technical requirements
    2. Designing and implementing the FPGA algorithm
    3. Digital oscilloscope system overview
    4. Adding the deserializer
    5. Adding a FIFO buffer
    6. Adding the AXI bus interface
    7. Adding the MQTT protocol
    8. Coding style
    9. Naming things
    10. Comments in code
    11. Avoid literal numeric values
    12. Braces, indentation, and vertical spacing
    13. Prioritize readability and correctness
    14. Avoid premature optimization
    15. Avoid implementation-defined behavior
    16. Avoid unconditional jumps
    17. Minimize the scope of identifiers
    18. Indicate that constant things are constant
    19. Automated code formatters
    20. Statically analyzing source code
    21. What is static code analysis?
    22. Static code analysis tools
    23. Using static code analysis effectively
    24. Working with existing code
    25. Begin with only the most severe messages
    26. Resolving analyzer output messages
    27. Common source code analyzer messages
    28. Source code version control
    29. Version control with Git
    30. Test-driven development
    31. TDD applied to embedded systems
    32. Summary
  20. Chapter 10: Testing and Debugging the Embedded System
    1. Technical requirements
    2. Designing system-level tests
    3. Requirements-driven testing
    4. Testing under nominal and off-nominal conditions
    5. Unit testing versus functional testing
    6. Negative testing and penetration testing
    7. Testing in a simulated environment
    8. Achieving repeatable test results
    9. Developing a test plan
    10. Conducting tests and recording results
    11. Identify the data to be collected
    12. Configuring the system under test
    13. Executing the test procedures
    14. Quick-look assessment of test results
    15. Repeating tests when necessary
    16. Regression testing existing code
    17. Ensuring comprehensive test coverage
    18. Requirements traceability matrix
    19. Tracking code coverage
    20. Dealing with syntax and compilation errors and warnings
    21. Working with static code analysis and unit testing
    22. Define the problem clearly and attempt to duplicate it
    23. Determine whether the input is correct
    24. Find ways to gain visibility into the system
    25. Using a binary search debugging process
    26. temporarily removing portions of functionality
    27. Make the smallest program that demonstrates the problem
    28. Summary of best practices for high-performance embedded system development
    29. Designing for test
    30. Leave room for growth
    31. Design hardware with future capabilities in mind
    32. Developing only the code you need right now
    33. Maintain strict version control
    34. Develop unit tests as code is in development
    35. Begin system-level testing as soon as functionality is present
    36. Summary
  21. Other Books You May Enjoy
    1. Leave a review - let other readers know what you think
3.22.248.208