Shopping Cart :Check Out
EMAIL : contact@embeddedact.com

C for Embedded Development using Linux GCC /VC

Prerequisites:

Realtime OS, Basics of C, Any one of Programming Language experience.

Hours:

• 25-30 Hours ( MON-FRI 15hrs SAT-SUN 12hrs)

Instruction Required:

• XP Professional, VMWARE 8 , Linux OS Image for VM with GCC, Visual Studio for VC++

Course Contents

Introduction to Embedded C Programming Operators Variables Types and Constants
Overview Opertors Overview Variables Overview
Embedded C and Standard C Expressions Basic Variable Types
Simple Embedded C Program Assignment Opertor Sizes of Data Types
Comments Chaining Assignments Declaring Variables
Preprocessor Directives Arithmetic Opertors Declaring Multiple Variables
Functions Example of Remainder Stack & Heap Concepts
main Increment and Decrement Operators Initializing variables at declaration
stdio Postfix Increment and Decrement Casting- Type Conversion
Libraries Relational Operators Decimal, Octal and Hexadecimal Notations
Practical-Compiling the program Logical Negation
Knowing your Assembly Logical Operators
Benefits of Using C for Embedded Systems Short- Circuting
C in the Embedded Environment Compound Assignment Opertors
C in the Real time Linux Environment
Arrays Flow Control Functions
Array Basics Overview overview
Array Example The If Statement The Role of Functions
Looping Over an Array Assignment and Equality Functions-Syntax
Array Sizes Nested if Statements Return Values
Copying Arrays The for Loop Function Arguments
Initializing Arrays for Loop Syntax Local Variables
Strings The while Loop Scope and Lifetime
Evaluating Expressions The do-while Loop A look at the Stack
Truth Values Infinite Loops Functions Calling Functions
Precedence break Statement Call-by-Value
Associativity continue Statement Definition and Declaration
Operand Evaluation Conditional Operator Definition After Use
Casting - Type Conversion Switch statment
Operator Precedence Table switch Caveats
Pointers Data Stuctures The Preprocessor and Multiple-File Programs
Overview Overview overview
What is a Pointer? Defining Structures Standard Headers
Creating a Pointer Using Structures The Preprocessor
Pointer Types Initializing Structure Variables the #define Directive
Un Initialized Pointers Problems with Initialing Structures Large Programs
Null Pointers Initializing Arrays of Structures Deciding How to Split a Program
Pointers as Function Arguments Pointers to Sturctures Sharing Declarations
Pointers and Arrays Passing Structures to Functions Using Header Files
Pointer Arithmetic Passing Structures Pointers Writing a Header File
Using sizeof Structures as Data Types Conditional Compilation
Array / Pointer Equivalence Module-Private Functions
Passing Arrays to Functions Module-Private Variables
Pointers to Constand Data Function-Private Variables
Passing Pointers-to-Const Public Module Variables
Passing Pointers-to-Const When to Use Global Variables
Converting Pointers-to-Const
String Handling Self-Referential and Dynamic Data Structures Further Pointers
Passing Strings to Functions Objectives Pointers to Pointers
String Handling Common Data Structures Using Pointers to Pointers to Structures
Standard String Functions Circular Buffers Pointers to Constand Values
Character Classes Race Conditions Constand Pointers
Available Character Classes Singly Lined List Increment Operators and Pointers
Letter Case Data Allocation Pointers to Functions
Converting a String to a Number Using malloc and free Initializing Function Pointer Values
Converting a Number to a String Heap allocation example Calling Functions Through Pointers
String Input Details of malloc and free Call-Back Functions
Supporting Functions Arrays of Pointers to Functions
Doubly Linked Lists Functions Pointers for State machines
State machine Example: a Toaster
Building Software with Make Advanced Use of the Preprocessor Efficient C Programming
Introduction Parametric Macros Basics
Different Versions of Make Problems with Macros Principal Causes of Inefficiency
A Simple Project Macros and Scope Architecture Issues
Software Building Concepts Macros and Precedence Efficient Algorithms
Targets and Prerequisites in Make Testing Assertions Coding Tactics and Compilers
Building an Object File with make Stringification Difficulties with Code Optimisation
Pattern Rule Variables Assertions with Side Effects Common Tricks-Sub Expressions
Building an Executable with Make Token Pasting Using Register Variables
Rebuilding When Prerequisites Change When to Use Parametric Macros Loop Unrolling
Default Rules Space-Time Tradeoffs
Substitution References Floating-Point Arithmetic
Implicit Rules Compiler Optimization
Configuring Implicit Rules
Adding More Rules
Advanced Features