Ada for the Embedded C Developer

This course introduces you to the Ada language by comparing it to C. It assumes that you have good knowledge of the C language. It also assumes that the choice of learning Ada is guided by considerations linked to reliability, safety or security. In that sense, it teaches you Ada paradigms that should be applied in replacement of those usually applied in C.

This course also introduces you to the SPARK subset of the Ada programming language, which removes a few features of the language with undefined behavior, so that the code is fit for sound static analysis techniques.

This course was written by Quentin Ochem, Robert Tice, Gustavo A. Hoffmann, and Patrick Rogers and reviewed by Patrick Rogers, Filip Gajowniczek, and Tucker Taft.

Note

The code examples in this course use an 80-column limit, which is a typical limit for Ada code. Note that, on devices with a small screen size, some code examples might be difficult to read.

Download PDF Download EPUB

• Introduction
  • So, what is this Ada thing anyway?
  • Ada — The Technical Details
• The C Developer's Perspective
  • What we mean by Embedded Software
  • The GNAT Toolchain
  • The GNAT Toolchain for Embedded Targets
  • Hello World in Ada
  • The Ada Syntax
  • Compilation Unit Structure
  • Packages
    • Declaration Protection
    • Hierarchical Packages
    • Using Entities from Packages
  • Statements and Declarations
  • Conditions
  • Loops
  • Type System
    • Strong Typing
    • Language-Defined Types
    • Application-Defined Types
    • Type Ranges
    • Unsigned And Modular Types
    • Attributes
    • Arrays and Strings
    • Heterogeneous Data Structures
    • Pointers
  • Functions and Procedures
    • General Form
    • Overloading
    • Aspects
• Concurrency and Real-Time
  • Understanding the various options
  • Tasks
  • Rendezvous
  • Selective Rendezvous
  • Protected Objects
  • Ravenscar
• Writing Ada on Embedded Systems
  • Understanding the Ada Run-Time
  • Low Level Programming
    • Representation Clauses
    • Embedded Assembly Code
  • Interrupt Handling
  • Dealing with Absence of FPU with Fixed Point
  • Volatile and Atomic data
    • Volatile
    • Atomic
  • Interfacing with Devices
    • Size aspect and attribute
    • Register overlays
    • Data streams
  • ARM and svd2ada
• Enhancing Verification with SPARK and Ada
  • Understanding Exceptions and Dynamic Checks
  • Understanding Dynamic Checks versus Formal Proof
  • Initialization and Correct Data Flow
  • Contract-Based Programming
  • Replacing Defensive Code
  • Proving Absence of Run-Time Errors
  • Proving Abstract Properties
  • Final Comments
• C to Ada Translation Patterns
  • Naming conventions and casing considerations
  • Manually interfacing C and Ada
  • Building and Debugging mixed language code
  • Automatic interfacing
  • Using Arrays in C interfaces
  • By-value vs. by-reference types
  • Naming and prefixes
  • Pointers
  • Bitwise Operations
  • Mapping Structures to Bit-Fields
    • Overlays vs. Unchecked Conversions
• Handling Variability and Re-usability
  • Understanding static and dynamic variability
  • Handling variability & reusability statically
    • Genericity
    • Simple derivation
    • Configuration pragma files
    • Configuration packages
  • Handling variability & reusability dynamically
    • Records with discriminants
    • Variant records
      • Variant records and unions
      • Optional components
      • Optional output information
    • Object orientation
      • Type extension
      • Overriding subprograms
      • Comparing untagged and tagged types
      • Dispatching calls
      • Interfaces
      • Deriving from multiple interfaces
      • Abstract tagged types
      • From simple derivation to OOP
      • Further resources
    • Pointer to subprograms
  • Design by components using dynamic libraries
• Performance Considerations
  • Overall expectations
  • Switches and optimizations
    • Optimizations levels
    • Inlining
  • Checks and assertions
    • Checks
    • Assertions
  • Dynamic vs. static structures
  • Pointers vs. data copies
    • Function returns
• Argumentation and Business Perspectives
  • What's the expected ROI of a C to Ada transition?
  • Who is using Ada today?
  • What is the future of the Ada technology?
  • Is the Ada toolset complete?
  • Where can I find Ada or SPARK developers?
  • How to introduce Ada and SPARK in an existing code base?
• Conclusion
• Hands-On: Object-Oriented Programming
  • System Overview
  • Non Object-Oriented Approach
    • Starting point in C
    • Initial translation to Ada
    • Improved Ada implementation
  • First Object-Oriented Approach
    • Interfaces
    • Base type
    • Derived types
    • Subprograms from parent
    • Type AB
    • Updated source-code
  • Further Improvements
    • Dispatching calls
    • Dynamic allocation
    • Limited controlled types
    • Updated source-code