ADVANCED

EMBEDDED SYSTEMS
TRAINING
20+ yrs
Real Time Expert
100%
Placement Assistance

Course Modules
ADVANCED C & DATA STRUCTURES
OPERATING SYSTEM CONCEPTS
EMBEDDED LINUX ON ARM BOARD
ARM PROCESSOR ARCHITECTURE (7/9/11/CORTEX)
LINUX SYSTEM PROGRAMMING
LINUX KERNAL AND DEVICE DRIVERS PROGRAMMING
USB, PCI, I2C, UART, SPI, WLAN, BLUETOOTH ETC...
EMBEDDED LINUX & ANDROID OS PORTING
EMBEDDED NETWORK PROTOCOLS (TCP/IP).
REAL TIME OS
BOOT-LOADERS (U-BOOT)
TRAINING ON ARM BOARDS

st
1 Floor VSSR Square, Vittal Rao Nagar, HITEC City, Hyderabad, Telangana 500081
+91 9347822722, 8897555722 www.vivenembedded.com [email protected]
 Course Modules
ADVANCED C & DATA STRUCTURES
Pointers with functions READING AND WRITING
Pointer to Pointer
INTRODUCTION TO C LANGUAGE Pointers to Arrays STRUCTURES TO FILES
Features of C
Arrays of Pointers In Ascii format
History
Void Pointers In Binary format
Structure of C Program.
Call By value and Call by reference Modifying a structure in the file
Keywords, Identifiers, Variables and Constants

DATA TYPES
Advanced pointer types
DEVELOPMENT TOOLS & UTILITIES
Pointers to functions
Primitive Data Types. Pointers and Strings LINUX COMMANDS USEFUL IN DEVELOPMENT
Aggregated Data Types. Vi editor
Pointers and Dynamic memory
GCC compiler
OPERATORS COMMAND LINE ARGUMENTS Four Stages of GCC
Binary Operators DYNAMIC MEMORY ALLOCATION Functionality of Preprocessor
Unary Operators Allocation (Malloc, Calloc, Realloc) Functionality of Compiler
Ternary Operators De-Allocation(Free) Functionality of Assembler
Special Operators Functionality of Linker
Order of evaluation. VARIABLE NUMBER OF Interrupting the Compiler
ARGUMENTS Compiling a C Program
PREPROCESSOR FEATURES Implementation of printf()
Preprocessor Features
Implementation of scanf()
CONTROL FLOW STATEMENTS Predefined Preprocessor Symbols
The Control Flow Program Statements DATA STRUCTURES Warnings and Extensions
Looping Statements Introduction Optimization
The Data-Checking Process Structured Representation GDB debugger
Statements and Control Structures Archive Utility
FUNCTIONS Abstract Data Types Make Utility
Role of Functions Static & Dynamic Data Types Object File format
Passing arguments to functions Arrays & Pointers Executable File Format
Returning values from functions Linked List
Recursive Functions Advanced Data Structures OPERATING SYSTEMS
Callback functions Data Structure Representation Learning of operating system concepts will help you in
Implications on Stack Analysis-Performance analysis of Time and understanding Desktop, Embedded & Real-time
Pass by value/reference Space Operating Systems easily in less time.
ARRAYS Design: Algorithm and Flowchart Introduction
Defining, initializing and using arrays Pseudo Code Processes
Multi Dimensional arrays LINKED LIST Threads
Arrays of Characters and Strings Introduction CPU Scheduling
Arrays and pointers Advantages of Linked List over an Array Process Synchronization
Passing arrays to functions Operation of Singly Linked Lists Deadlocks
String handling and its library functions Operations on Doubly Linked Lists Memory management
Virtual Memory.
STORAGE CLASSES Circular Double Linked Lists
File management & Disk management
Scope and lifetime of a variable Uses of Linked Lists
Difference between Arrays and Linked List
Internal LINUX SYSTEM PROGRAMMING
External/Global SORTING AND SEARCHING Linux is used in almost all system domains
Automatic
Static
TECHNIQUES (Networking/Telecom) and also most of the
Insertion sort RTOS are very similar to Linux.
Register
Selection sort So learning of Linux programming will help
Volatile
Bubble sort you in understanding and work easily in
STRUCTURES & UNIONS Merge sort system domain as well as in embedded
Usage of Structures Quick sort systems.
Declaration, initialization and accessing Heap sort
Nested Structures Linear search THE GNU C LIBRARY AND
Array of structures Binary search SYSTEM CALLS
Allocation of memory and holes Library Goals
Unions
FILE HANDLING CONCEPTS Library Standards
Concept of a FILE data type
BITWISE OPERATORS File Input, Output operations
GNU C Library - glibc
AND (&), OR (|), XOR (^) Library Functions vs. System Calls
Sequential Files
Compliment (~) Using System Calls
Random Access Files
Left-shift (<<), Right-shift (>>) Handling Errors with errno
Masking, Setting and Testing of Bit/Bits STANDARD I/O LIBRARY FUNCTIONS Making Sense of errno
fopen,fread,fwrite,fclose,fseek Using strace
POINTERS Relationship between file descriptor
The purpose of pointers and FILE pointer
Defining pointers Character at a time I/O
The & and * operators Line at a time I/O
Pointer assignment Formatted I/O
PROGRAM ARGUMENTS AND Using gdb to Autopsy a Crash INTRODUCTION TO EMBEDDED
ENVIRONMENT Debugging Libraries - ElectricFence
SYSTEMS
Program Startup Debugging with valgrind
Using argc/argv Profiling for Performance Programmer's view of hardware
CPU
Handling Options with getopt() BASIC FILE OPERATIONS Types of CPUs
Handling Options with getopt_long() Stream vs. System Calls
Environment CPU Characteristics
Opening/Closing Streams
Manipulating the Environment CPU Bus/Machine Cycles
Stream Input/Output Functions
Program Exit Memory
Stream Status/Errors
Registering Exit Handlers Memory types
Stream File Positioning
CPU Memory interface
BUILDING LIBRARIES Stream Buffering
I/O
Why Use Libraries? Temporary/Scratch Files
I/O controllers
Static Versus Shared Opening/Closing File Descriptors
CPU I/O interface
Static Library Benefits File Descriptor I/O
I/O methods/techniques
Shared Library Benefits Repositioning File Descriptors
Polled I/O or Programmed I/O
Creating a Static Library Stream/File Descriptor Conversions
Interrupt Support
Using Static Libraries cat using ANSI I/O
DMA Support
Creating a Shared Library cat using POSIX I/O
Using Shared Libraries COMMUNICATING WITH PIPES DEVELOPMENT ENVIRONMENT:
Shared Library Management Host-Target Environment
Introduction to Pipes
Library Locations Cross compilers
Standard I/O: popen()/pclose()
ldconfig Downloading methods
Using popen()/pclose()
TIME FUNCTIONS System Call: pipe()
Serial, Ethernet, Floppy, ROM
Emulators
When Does Time Begin? Using pipe()
Target based debugging
Time Data Types Named Pipes
Debug Monitors
Determining Real Time Using Named Pipes
Host based source level debugging
Converting time_t For Further Reading
Converting tm Structure
MANAGING SIGNALS ARM (32-BIT) PROCESSOR
Process Time What Signals Are
Time arithmetic Blocking/Checking Signals ARCHITECTURE & PROGRAMMING
Second Resolution Timers Working with Signal Sets The ARM is a 32-bit reduced instruction set computer
Fine-Grained Timers Example of Blocking Signals (RISC) instruction set architecture (ISA) developed by
Real Time Clock (RTC) Handling Signals with sigaction() ARM Holdings. It was known as the Advanced RISC
PROCESS MANAGEMENT sigaction() Example Machine. The ARM architecture is the most widely used
What a Process Is Handling Signals with signal() 32-bit ISA in terms of numbers produced. The relative
Process Relationships Sending Signals simplicity of ARM processors made them suitable for low
Create a Child Process PROGRAMMING WITH THREADS power applications. This has made them dominant in
Doing Something Else Introducing Threaded Programming the mobile and embedded electronics market, as
Related execve() Functions Applications Suited to Threads relatively low cost, and small microprocessors and
Wait For a Child Building Threaded Programs microcontrollers.
More Precise Waiting Creating Threads As of 2005, about 98 percent of the more than one billion
Changing Priority/Nice Thread Identity mobile phones sold each year use at least one ARM
Real Time Priority Synchronizing by Joining processor. As of 2009, ARM processors account for
THE GNU C LIBRARY AND Detaching Threads approximately 90% of all embedded 32-bit RISC
Stopping Threads processors. ARM processors are used extensively in
SYSTEM CALLS Synchronizing with Mutexes consumer electronics, including PDAs, mobile phones,
Library Goals Using Mutexes digital media and music players, hand-held game
Library Standards oRead/Write Locks consoles, calculators and computer peripherals such as
GNU C Library - glibc Conditional Variables hard drives and routers.
Library Functions vs. System Calls Using Conditional Variables Introduction to ARM (ARM7/ARM9)
Using System Calls ADVANCED FILE OPERATIONS ARM processor architecture & Features
Handling Errors with errno Directory Operations ARM programming model (Instruction set
Making Sense of errno File System Operations and assembly language programming).
Using strace Multiplexed I/O with select() RISC vs. CISC
MEMORY OPERATIONS Miscellaneous I/O Functions Pipelining concept
Allocating/Freeing Memory Memory Mapped I/O Fundamentals of ARM
Memory Alignment Using Memory Mapped I/O Processor modes
Locked Memory File Locking Exception Handling
Memory Copy/Initialization ARM versions
Memory Comparison/Search
INTERPROCESS COMMUNICATION Instruction Set & Addressing Modes
Interprocess Communication (IPC)
ARM(32-bit) Instruction Set
DEBUGGING POSIX IPC Overview
Thumb(16-bit) Instruction Set
What Is My Program Doing? POSIX Shared Memory
Pre & Post Indexed Addressing modes
Source Level Debugging POSIX Semaphores
Stack Orgranization
Invoking gdb POSIX Message Queues
Memory Organization
Getting Started with gdb System V IPC Overview
Mixed C and assembly programs
Examining and Changing Memory System V IPC Shared Memory
System Design & Development Tools
Debug info Libraries System V IPC Semaphore Arrays
Case studies on ARM Controllers
Using gdb with a Running Process System V IPC Message Queues
LINUX DEVICE DRIVERS MEMORY MANAGEMENT Porting, Development & Validation of
After Gaining knowledge on Advanced Pages USB Gadget Driver
Linux Programming you are ready to Zones NETWORK DRIVERS
learn Device Drivers. This is where you Getting Pages Understanding the network device
learn core of Linux Kernel and Device Slab Layer Initializing net device, sk_buff
Drivers programming. Slab Allocator Interface LAN(DM9000) driver
KERNEL CLASSIFICATIONS High Memory Mappings
Monolithic Kernels PerCPU Allocations BOARD BRING UP / PORTING
Micro Kernels DEBUGGING THE KERNEL OS STACK
THE USER SPACE & KERNEL Printk, Traces and Watches EMBEDDED LINUX
gdb, kgdb, kdb
SPACE TOOL CHAINS, User Mode Linux
Benefits of using Linux and open
source tools for embedded systems
LIBRARIES, THE MAKEFILE Qemu Components of Linux booting
GNU toolchain Proc & Sys File Systems Embedded Linux system architecture
Creation of Static & Dynamic Libraries
Portability support in the kernel
TIMERS & BOTTOM HALVES Linux booting sequence in x86 & ARM

THE LINUX KERNEL

HZ & Jiffies, Delays
CROSS COMPILER TOOL CHAIN
Kernel Timers
Getting the sources Need for cross tool-chain
Soft irgs
Configuring the kernel Using pre-build cross tool-chain
Tosklets
Diff and Patching utilities Building our own cross tool-chain
Work Queues
Compiling the kernel Kernel Data Types BOOT-LOADER
Installing & Booting the kernel Boot-loaders and its advantages
STEP BY STEP INTERRUPTS verview of U-boot source
Handling I/O
DEMYSTIFICATION OF LINUX 1/0 Architecture
Building U-boot for target
Booting target with U-boot
BOOT PROCEDURE I/O Mapped I/O
Boot time optimizations in u-boot
The HelloWorld Module Memory Mapped I/O
Module Stacking Interrupts & Registering Interrupt LINUX KERNEL
Module Parameters Handlers Supported hardware architectures
Overview System Calls Interrupt Context vs Process Context Modifying Architecture Specific code
Registering a System Coll
System Call Handler
BLOCK 1/0 LAYER Cross-compiling the kernel for target
Block Device Structure Understanding kernel boot arguments
CHARACTER DRIVERS Request queues System Call Implementation
Device Numbers Boot time optimizations in Linux kernel
Block Driver
Major and Minor Numbers
V/O Scheduling
Registering and Unregistering FILE SYSTEM
Static and Dynamic allocations UART DEVICE DRIVER Understanding NAND/NOR flash
Important Structures UART Driver Understanding Linux file system
File Operations UART Protocol hierarchy
Character Devices. UART Driver Layered Architecture Busy-Box/Build-Root/LTIB/YOCTO .
cdev structure UART subsystems Cross-compiling applications and
Adding, Allocating, Initializing and Porting, Development & Validation of libraries
Deleting UART Driver Creating File System Images(iffs, iffs2,
User Space Applications and Device I2C DEVICE DRIVER yoffs, yoffs2)
Driver mapping 2C Architecture & Protocol
Access methods within the driver, 2C subsystems
MISC
open,read, write and close Integrating Graphics/V4L/NETWORK
I2C Driver Layered Architecture
Advanced Character Drivers stacks in Filesystem F
Porting, Development & Validation of
IOCTL lashing Boot-loader Image
2C client Driver
VIRTUAL FILE SYSTEM Porting, Development & Validation of
Flashing Kernel Image
File System Interface Flashing File system Image
2C platform Driver
File System Abstraction Layer Android/Linux Porting on
Linux File Systems
PCI DEVICE DRIVER TI/Samsung/Freescole/Broadcomm
PCI Architecture & Protocol SOC's
VFS Objects
Busindependent device access
KERNEL SYNCHRONIZATION Understanding the PCI configuration
INTRODUCTION TO DEVICE
Critical Sections, Race Conditions
space DRIVERS
Concurrency and its Sources Module Programming
PCI Regions & Direct Memory Access
Mechanisms for Kernel Kernel Configuration and Compilation
PCI subsystems
Synchronization Semaphores Character Drivers
PCI Driver Layered Architecture
Reader/ Writer Semaphores Kernel Features
Porting, Development & Validation of
Spinlocks Interrupts and Exceptions
PCI client Driver
Reader/ Writer Spinlocks Completions
Sequential locks USB DEVICE DRIVER More on Modules
Debugging
Barriers USB Architecture & Protocol
Timers
Read Copy Update Types of Descriptors & URB
Synchronization techniques
Atomic Operations USB subsystems
ioctl's
Memory Allocation in the kernel USB Driver Layered Architecture
 The proc filesystem INTERNET PROTOCOL (IP)
Unified Device Model and sysfs
IP Concepts
Memory Management and Allocation
ICMP
User and Kernel Space
Routing concepts
communication
Autonomous systems
Sleep and Wait Queues
Routing Algorithms
Interrupt Handling
Routing protocols
Block Drivers
Interior/Exterior routing protocols.
PCI
Unicast/Multicast Routing protocols
Direct Memory Access
IGMP
Network Drivers
User datagram Protocol (UDP)
USB Drivers
Transmission Control Protocol (TCP)
MTD
Asynchronous I/O SOCKETS
I/O Scheduling Socket concepts
Socket API Interface
COMPUTER NETWORKS & Client VS Server
NETWORK PROGRAMMING Connectionless and connection oriented
client-server communication.
Need/Uses of Networking
Socket calls for UDP/TCP server/client
Use of Layered architecture
Iterative vs concurrent servers
OSI Protocol layers
Iterative Connection-less servers (UDP)
Physical layer functionalities
Iterative Connection-Oriented servers (TCP)
Data link layer functionalities
Concurrent server implementation
Network Layer functionalities
Using multiple processes,
Transport layer functionalities
Using Multi Threading
Presentation layer functionalities
Using select ( ) call (both UDP/TCP).
Session layer functionalities
Application layer functionalities MINI PROJECT: CASE STUDY ON
TCP/IP PROTOCOL LAYERS ONE OF BELOW TCP/IP
Line configurations APPLICATIONS:
Network topologies
Networking and internetworking devices TFTP
LAN, MAN, WAN SMTP
Typical media and Protocols used in each HTTP
LAN Standards BOOTP
Ethernet, Token Ring, Token Bus, FDDI DHCP
Ethernet Media (Thick, Thin, Twisted pair)
Ethernet frame formats
NETWORK SIMULATORS, SNIFFERS
WAN Standards AND TRAFFIC GENERATORS
Dial-up, Leased Line Ethereal
ISDN, DSL, PPP WireShark
ATM
REAL-TIME OS INTRODUCTION
TCP/IP STACK INTERNALS: What is RTOS?
Internet Addresses concepts.
Desktop OS vs. RTOS
IP Address vs H/W address
RTOS Key Characteristics
(unicast/broadcast/multicast).
RTOS Services
Subnetting/Supernetting.
Task Management
Switching
Inter task Communication Methods
ARP/RARP
Synchronization Techniques
Interrupt handling
Timers
Signals and Events
Priority Inversion/Inheritance
 COURSE HIGHLIGHTS
Training by Industrial Experts Having 20+ Yrs
of Experience at Various Mnc's
Training on High-end Arm Development
Boards
Training on Hardware & Firmware Which Our Students
Includes Design, Development, Testing,
Verification & Validation
Placed in Over
Live Exercises Relevant to Industry 200+ MNC's
Standards
Course Content Designed By Leading
Embedded Experts
Multiple Live Projects, a Well Equipped
Laboratory
Student Gets Hands on experience on Live
industrial real time Projects

RASPBERRY PI BEAGLE BONE

+91 9347822722, 8897555722

www.vivenembedded.com
[email protected]

st
1 Floor VSSR Square, Vittal Rao Nagar, HITEC City,
Hyderabad, Telangana 500081