The Linux Master Package

Learning to program is both fun and easy by taking this brand new and exciting Introduction to Programming for Non-Programmers course! Not only will you learn the foundations of how to program, but you’ll also gain a solid foundation in the world’s most popular computer language: JavaScript.  Without having to install any special software, and using only your web browser and your text editor, you’ll journey into the exacting world of programming. Using an easy to learn training style, you’ll learn about the JavaScript language, functions, variables, making decisions, looping, and more. At the end of the course, you’ll be in a great position to take other introductory programming language course.

Module 00: Course Introduction

Module 01: Introduction to Programming

• What is a computer language?
• Why should you learn a computer language?
• What computer language should you learn first?
• Demo: Let's Make our First Statement in JavaScript!
• Lab Exercise: hello.html

Module 02: Introduction to JavaScript 

• JavaScript Advantages
• Web Browser and JavaScript
• .html File Extension
• Editing hello.html
• // and /* … */
• Demo: Hello World
• Lab Exercise: Hello World

Module 03: Functions Part 1  

• About Functions
• alert() w/o input parameter
• Semicolon
• alert() w/Input parameter
• Strings

Module 04: Functions Part 2 

• Defining Functions without inputs
• Defining Functions with inputs
• Returning values from Functions
• Demo: Using the Alert Function
• Lab Exercise: Using the Alert Function

Module 05: Variables 

• JavaScript Variables
• var keyword
• String variables
• Number variables
• Operators: +, -, *, /
• Confirm Function
• true, false
• prompt() Function
• Demo: Using Variables
• Lab Exercise: Using Variables

Module 06: Making Decisions 

• if statement
• if else statement
• confirm() with if statement
• confirm() with if-else statement
• Compare Operators: ==, <. >, <=, >=
• if-else-if…
• Demo: Making Decisions
• Lab Exercise: Making Decisions

Module 07: Repeating Steps 

• Repeating fixed number of times
• Repeating variable number of times
• while statement
• while statement with prompt()
• Checking for null
• Demo: Repeating Steps
• Lab Exercise: Repeating Steps 

Module 08: Course Summary

• Put All Skills Together To Write a Javascript App
• Review the key concepts
• Write a temperature conversion script!

The only prerequisite is a basic familiarity with computers, along with an eagerness to learn programming. You do not need any programming experience.

This course provides a fundamental understanding of the functions within any modern operating system. Most users of computers, like Windows 10 or Redhat V8, only deal with the GUI (graphical user interface). This course explores the functions used by those GUIs and provides an understanding of what is really happening. Used either stand-alone to gain a basic understanding of operating system concepts or with a companion textbook, Modern Operating Systems by Andrew S. Tanenbaum, while viewing the course or as a resource for later reference, this course provides a solid foundation that would enhance understanding for other courses, such as USB 2.0 Architecture Part 1, Oracle 12c Real Application Clusters Part 2: Performance Tuning, Administration and Backup, PCI Express (PCIe) Overview, Cloud Computing Foundation, and any programming course.  This course is a pre-requisite for the Linux V7 Essentials course.

Module 00: Course Introduction - Fundamentals of Operating Systems

Module 01:  Introduction to Operating Systems

• What is an operating system?
• History of Operating Systems
• Types of Operating Systems

Module 02: Operating Systems and Hardware

• Operating Systems Concepts
• Processor and Processor Features
• Processor Pipeline and Execution
• Operating Systems and Processors
• Memory Overview
• I/O Devices Overview
• Operating Systems and Hardware Quiz

Module 03: Operating System Concepts

• Types of Operating Systems
• Services Provided by Operating Systems
• Invoking Operating System Services
• Operating System Concepts Quiz

Module 04: Operating System Structure

• Monolithic Systems
• Layered Systems
• Virtual Machines
• Other Structures 
• Operating System Structure Quiz

Module 05: Processes and Threads

• The Process Model
• The Thread Model
• Implementation Techniques
• Trade-offs 
• Processes and Threads Quiz

Module 06:  Interprocess Communication 

• Types of Interprocess Communication
• Operating System Implementations
• Add-on Implementations
• Interprocess Communication Quiz

Module 07:  Scheduling

• Introduction to Operating System Scheduling
• Types of Schedulers
• Policy Versus Mechanism
• Thread Scheduling
• Scheduling Quiz

Module 08:  Deadlocks

• What are deadlocks?
• Detection and Recovery
• Avoidance
• Prevention
• Other Issues 
• Deadlocks Quiz

Module 09:  Memory Management

• Basics of Memory Management
• Swapping
• Paging for Memory Management
• Paging for Virtual Memory
• Implementation Issues 
• Memory Management Quiz

Module 10:  Input/Output

• Principles of I/O Hardware
• Principles of I/O Software
• I/O Software Layers
• Types of I/O Devices
• Power Management
• Input/Output Quiz

Module 11:  Files Systems

• File Systems Basics 
• Files
• Directories
• Implementation
• Examples 
• File Systems Quiz

Module 12:  Multimedia Operating Systems

• Introduction to Multimedia Operating Systems
• Multimedia Files
• Multimedia Process Scheduling
• Multimedia File Systems
• Caching
• Disk Scheduling
• Multimedia Operating Systems Quiz

Module 13:  Multiple Processor Systems

• Types of Multiple Processors
• Multiple Processor Hardware  
• Multiple Processor Operating Systems
• Multiple Processor Scheduling
• Multiple Computers
• Multiple Processor Systems Quiz 

Module 14:  Operating System Security

• The Security Environment
• Basics of Cryptography
• User Authentication 
• Security Attacks 
• Protection Mechanisms
• Security Quiz

Module 15: Examples of Operating System Architectures

• Unix and Linux
• Windows 
• Others
• Operating System Architectures Quiz

Module 16: Course Summary

Course attendees should have a general understanding of computer use, including starting and using applications, creating and using files, and a basic exposure to using computers connected to some form of network. Some knowledge of programming, computer hardware and application design will be helpful but is not required.  If you do not have this experience, we recommend the following GogoTraining course, C Programming Bootcamp Part 1.

This hands-on class will teach you the basics of Linux V7 using Red Hat Linux, a powerful open-source operating system.  You will learn how to install, work with users and groups, and program using bash shell and the vi editor. This class, in addition to Linux V7 System Administration, prepares you to sit for the  Certified System Administrator exam given by Red Hat. This course also provides the necessary foundation for any version of Linux.

Module 00: Course Introduction - Red Hat Linux V7 Essentials 

Module 01: Introduction to Linux

• Linux history
• Advantages of Linux and Open-source
• Linux distributions
• Three basic parts of Linux

Module 02: V7 Installation

• Hardware compatibility
• Installer Features
• Install boot process
• First boot
• Lab Exercise: Installing Linux

Module 03: Linux Usage Basics 

• Logging in
• Accessing the command line
• Changing your password
• The root user
• Elevating privileges
• Editing text files
• Lab Exercise: Working with root user

Module 04: Running Linux Commands 

• Running commands
• Getting help
• The whatis command
• The --help option
• man and info
• Demo: Running Linux Command
• Lab Exercise: Trying date, man and info command

Module 05: Exploring the Filesystem Part 1

• Overview of the filesystem hierarchy
• pwd, pathname, ls and cd
• Demo: Commands to Explore the Filesystem

Module 06: Exploring the Filesystem Part 2 

• Copying and removing files
• Creating and removing directories
• Nautilus
• Determining file content, viewing files, file permissions
• Demo: Using Nautilus
• Lab Exercise: Using shell Commands

Module 07: Introduction to the bash Shell 

• Command line shortcuts and history tricks
• Command line expansion
• Command editing tricks
• gnome-terminal
• Demo: Bash and the Gnome Terminal
• Lab Exercise: Working with bash shell

Module 08: Standard Input/Output and Pipes

• Standard input, output and error
• Redirecting standard input and output
• Redirecting standard error
• Redirecting both standard input and standard error
• Using pipes
• Demo: Input and Output Redirection
• Lab Exercise: Redirecting Input and Output

Module 09: Introduction to Users and Groups 

• Linux security model
• Users and Groups
• Permission types
• Examining and changing permissions
• Lab Exercise: Using Permissions

Module 10: Text Processing Part 1

• Regex Patterns
• Sed
• Exercise: Word match with Regexes

Module 11: Text Processing Part 2

• Extracting and manipulating text with sed, awk and Perl
• Demo: sed and awk Examples
• Perl
• Lab Exercise: Write a sed Command

Module 12: Basic System Configuration 

• Configuring date and time
• Configuring printers
• Network configuration
• System logs
• Demo: - Configuring a Printer
• Lab Exercise: Configuring a Basic System

Module 13: The vi Editor Part 1

• Using vi
• Command vs. insert mode
• Demo: vi First Steps

Module 14: The vi Editor Part 2

• Changing, pasting, deleting, copying and importing text
• Joining, searching and replacing text
• Splitting screen
• Configuring vi
• Lab Exercise: Using vi Editor

Module 15: Configuring the bash Shell 

• bash variables
• Environment variables
• Aliases
• Startup and exit scripts
• Intro to shell scripting
• Lab Exercise: Configuring the bash Shell

Module 16: Shell Programming Part 1

• Create a simple shell program
• Execute a simple shell program
• Demo: Creating and Executing Shell Programs
• Lab Exercises

Module 17: Shell Programming Part 2

• Using variables
• read and expr, || and &&
• Demo: Variables, read and expr
• Lab Exercises

Module 18: Shell Programming Part 3

• The test command
• if, while, until, for, case
• Lab Exercises

Module 19: Network Applications Part 1 

• Firefox and other web browsers
• Evolution and other email clients
• Email, encryption and digital signatures
• The empathy messaging system

Module 20: Network Applications Part 2

• telnet and the “r” services
• ssh, scp
• FTP clients
• Connecting to Windows disk shares
• File transfer with Nautilus
• Lab Exercise: Using Network Application Tools

Module 21: Advanced Users and Groups Part 1

• User and group ID numbers
• /etc/passwd, /etc/group and /etc/shadow
• System users and groups
• Changing your identity

Module 22: Advanced Users and Groups Part 2

• Default permissions
• SUID, SGID and sticky bits
• Demo: SUID, SGID and sticky bits
• Lab Exercise: Using umask

Module 23: Finding Things

• which
• whatis
• man –k (aka. apropos)
• find
• locate
• The Gnome search tool
• Demo: Examples of Finding Files
• Lab Exercise: Finding Programs, Files, Pages

Module 24: Linux Processes Part 1 

• Intro to processes
• Viewing processes, process states

Module 25: Linux Processes Part 2 

• Sending signals and terminating processes
• Process management tools
• Running a process in the background
• Suspending a process
• cron and anacron
• Demo: Process Management
• Lab Exercise: Experiment with ps, top and kill

Module 26: Advanced File System Part 1

• Partitions and filesystems
• Inode numbers
• Checking free space

Module 27: Advanced File System Part 2

• Working with archive files
• Compression utilities
• Demo: Archiving Files
• Lab Exercise: Using labfile

Module 28: The Next Steps

• Next steps in Linux
• Other Linux training classes
• The Linux community

Students should have experience in basic programming usage or have taken:

• Introduction to Programming and Coding for Everyone with JavaScript
• Fundamentals of Operating Systems

This hands-on class will teach you the how to administer a Linux V7 system. You’ll learn how to install Linux V7, handle system initialization, work with disk partitions, and manage packages, users and groups. Additionally, the course will cover networking, using utilities to find things, discuss the Linux Kernel, the X Windows system and learn to troubleshoot. This course was written using Red Hat Linux and provides the necessary foundation for administering any version of Linux.

This class, in addition to Linux V7 Essentials, prepares you to sit for the Certified System Administrator exam. 

Module 00: Course Introduction - Linux V7 System Administration

Module 01: Linux Review

• Select best distribution
• Demos: Review Command Line Tools to Work with Files
• Lab Exercises: Experiment with the Essential Commands

Module 02: Linux V7 Installation

• Hardware compatibility
• Network information
• Installation, disk partitioning
• Install boot process
• Demos
• Lab Exercise: Install Linux V7

Module 03: Virtual Machines

• What is Virtualization?
• KVM
• Creating a Virtual Machine

Module 04: System Initialization Part 1

• Linux boot process
• GRUB
• The Kernels

Module 05: System Initialization Part 2

• init process
• Runlevels
• Start/Stop Scripts
• Demo: chkconfig
• Shutdown and Reboot
• Demo: Shutdown and Reboot
• Lab Exercise: System Initialization

Module 06: File System Management Part 1

• Mount Points
• System Directories
• Filesystem Types
• Journaling
• mount Command
• umount Command
• Demos: File System Directories, Umount, Mount

Module 07: File System Management Part 2

• Adding a new disk partition
• fdisk
• Checking a disk with fsck
• Swap space
• LVMs
• Demo: Creating LVMs
• Lab Exercise: Complete Creating LVMs

Module 08: More File Systems 

• File System Attributes
• SELinux
• Recovering from a Crash
• Demo: Recover from a Crash
• Lab Exercise: Work with ACLs and SELinux

Module 09: Package Management

• software "packages"
• rpm
• yum
• RedHat Network
• Demos: Demonstrate rpm, Demonstrate yum
• Lab Exercise: Working with Packages

Module 10: Managing Users and Groups

• /etc/passwd
• File Ownership
• Creating a User
• Modifying and Deleting a User
• Creating and Deleting a Group

Module 11: User Administration Part 1

• Login Scripts and More Account Utilities
• Switching Accounts
• Demos: Show order of login scripts by added echoes, Change the shell

Module 12: User Administration Part 2 

• SUID and SGID Executables
• The Sticky Bit
• Default File Permissions
• Demos: Perl program, SGID directories, sticky bit, and umask
• Lab Exercise: Working with Users and Groups

Module 13: ACL, PAM and Remote Authentication 

• ACL-Access Control Lists
• PAM
• Remote Authentication
• Demo: Remote Login

Module 14: Quotas and LUKS

• What is a Quota?
• Turning on Quotas
• Setting and Testing Quotas
• LUKS
• Demo: Quota Examples, LUKS
• Lab Exercise: Working with Quotas

Module 15: Networking and IP 

• Networking Basics
• Networking Interfaces
• IPv4
• IPv6

Module 16: More on Network Interfaces

• Starting and Stopping an Interface
• ifconfig
• ip
• Demo: ifconfig and ip

Module 17: More on Networking 

• Network config files
• Name resolution
• Network Diagnostics
• IPv6 tools
• cron and anacron
• Lab Exercise: Experimenting with Networking

Module 18: Finding Things 

• which
• whatis
• find
• Locate
• Lab Exercise: Experiment with the find command

Module 19: Linux Processes 

• Managing system logs
• System monitoring
• Killing processes
• Lab Exercise: Linux Processes

Module 20: Kernel Services 

• Introduction to the kernel
• Kernel modules
• The initramfs image

Module 21: More on the Kernel 

• Kernel configuration with sysctl
• Installing a new kernel
• /proc filesytem
• Lab Exercise: Exploring the Kernel

Module 22: Software RAID

• Software RAID
• Creating a RAID
• RAID Info
• Removing a RAID
• Demo: Creating a RAID
• Lab Exercise: Creating a RAID

Module 23: X Window System 

• X server
• Configuring X
• Exporting display
• Demo: Using X Host +
• Lab Exercise: Using X Host +

Module 24: Troubleshooting 

• Plan for a failure
• Troubleshooting X windows
• Troubleshooting the network
• Machine won't boot
• Fixing the MBR
• Demo: Rescue the Machine
• Lab Exercise: Troubleshooting

You need to have equivalent experience or taken the following GogoTraining courses:

• Introduction to Programming and Coding for Everyone with JavaScript
• Fundamentals of Operating Systems
• Linux V7 Essentials

Welcome to Linux Device Drivers: Programming at the Kernel Level with Doug Abbott.  If you are ready to learn with the experts, then this course is for you.  Doug has over 20 years’ experience working on the operating system and device driver level with emphasis on embedded Linux applications and is here to answer your questions.

Working with Doug you will become a master Linux programmer at the Device Driver level and be able to:

• Understand how device drivers interact with the Linux kernel 
• Work with the rich set of kernel APIs that provide a multitude of services to driver programmers.  
• See how Linux handles asynchronous I/O in a way that is totally transparent to applications.  
• Examine the unique problems of debugging in Kernel space.  
• Understand how much of a device driver involves interactions with the kernel that have nothing to do with accessing physical hardware. 

While taking this course you will have access to Doug’s video lectures, demos and hands on exercises where you will have ample opportunity to practice what you’ve learned. Most of the lab exercises run on a standard PC. Nevertheless, the code is easily ported to other architectures supported by Linux. 

The hands-on exercises can be done using any version of the Linux Kernel.  Because the Linux Kernel changes frequently we are here to support any questions you may have on the course exercises and solutions while you take the course.

Some of the exercise are hardware dependent and require either a parallel printer port, if your computer has one, or you can purchase a single board computer to use to do the exercises – see purchase options section below.
 

Module 00: Linux Device Drivers 2013: Programming at the Kernel Level - Course Introduction

Module 01: So what’s a Device Driver?

• Why device drivers
• User space I/O APIs
• Three types of devices
• The /dev directory
• Demo: The /dev directory
• Exercise: Examine the /dev directory

Module 02: Kernel Loadable Modules

• What is a kernel loadable module?
• Module utilities
• Modules are kernel version specific
• Demo: A module example
• Kernel modules and the GPL
• Exercise:  Loading a module

Module 03: Basic Character Driver

• Registering and initializing a Driver
• The file operations table, fops
• Demo:  The Driver Example
• Exercise:  Running a Basic Character Driver
• Mutual Exclusion, the mutex
• Demo:  The mutex code

Module 04: Debugging Kernel Code

• printk()
• strace
• The /proc file system
• Demo: proc file review
• Exercise: List the proc file
• ioctl()
• Demo: ioctl Code Review
• Exercise: Execute ioctl commands
• Kgdb

Module 05: Blocking I/O Part 1

• The wait queue
• Putting a process to sleep
• The device model and sysfs
• Demo: Blocking example
• Build and Run Blocking
• Exercise: Run a blocking device driver
• Exercise: Find the Bug

Module 06: Blocking I/O Part 2

• The seq file interface
• Demo: The seq file system
• Exercise: List a proc file
• Poll and select
• Demo: the poll method
• Asynchronous notification
• Demo: Code review
• Exercise: Using asynchronous notification

Module 07: Accessing Hardware Part 1

• Side effects and compiler optimization
• I/O APIs
• The hardware
• Demo: Code review of hardware access on an single board computer
• Exercise: Flash the LEDs

Module 08: Accessing Hardware Part 2

• Hardware and BIOS
• Demo: Code review of hardware access on a parallel printer port 
• Exercise: Flash the LEDs
• Advanced Exercise: Shell Script for Alternating 2 LEDs
• Barriers
• Accessing hardware from User Space
• Demo: Code Review of accessing hardware from UserSpace
• Exercise: Accessing hardware from UserSpace

Module 09: Handling Interrupts Part 1

• Interrupt context
• Registering an interrupt handler, the IRQ flags
• Demo: interrupt example
• Exercise: Execute Interrupt driver
• Probing for the interrupt source
• Exercise: Interrupt probing

Module 10: Handling Interrupts Part 2

• Deferred Interrupt – tasklets and workqueues
• Demo: Deferred Interrupt
• Exercise:  Deferred interrupt processing
• Simple_int with Bottom Half
• Advanced Exercise: Using simple_int

Module 11: Memory allocation

• kmalloc() and kfree()
• kmalloc() flags
• The slab allocator
• Demo: Slab allocator tools
• Exercise: Slab allocator tools
• get_free_pages()
• The buddy algorithm
• Demo: The buddy info proc file
• Exercise: The buddy info proc file
• vmalloc()

Module 12: Managing Time

• jiffies
• Current time
• Demo: Implementing time delays
• Exercise: Implementing time delays
• The timer callback
• Demo: Using timer callbacks
• Exercise: Using timer callbacks

Module 13: Synchronization

• Semaphores
• Spinlocks
• Mutexes

Module 14: Block Drivers

• The block subsystem
• I/O schedulers
• Device registration
• The request queue and function
• Demo: Block driver example
• Exercise: Build and Try a Block Driver

Module 15: Network Drivers

• Device registration
• The socket buffer
• Demo: Driver example – “snull”
• Exercise: A network driver
• NAPI – the “new” API
• Demo:  NAPI
• Exercise: A NAPI network driver

Module 16: PCI Drivers

• PCI addressing and bridging
• Demo: PCI tools
• Exercise: Using PCI tools
• Accessing configuration space
• PCI data structures and macros
• modules.pcimap
• Demo: Sample PCI driver

Module 17: USB Drivers

• USB structure and characteristics (put after slide 3)
• Demo: USB Tools
• Exercise: Using USB tools
• Device classes
• USB data structures and macros
• USB Request Block, URB
• Demo: Sample USB driver

Module 18: Linux Driver Model

• Overview, motivation
• kobject
• sysfs
• Demo: Using sysfs
• Exercise: Using sysfs
• Module parameters in sysfs
• Demo: Module parameters in sysfs
• Exercise: Module parameters in sysfs

Module 19: Integrating a Driver with the Kernel Source Tree

• Configuring and building the kernel
• The Kernel source tree
• Demo: Review of kernel source tree
• Exercise: Examine directories of kernel source code
• Xconfig
• Demo: Using xconfig
• Exercise: Using xconfig
• The .config file
• Source code mods
• Kconfig files
• Demo: Kconfig files
• Exercise: Examine Kconfig files

To successfully complete this course you will need to be proficient in C programming and Linux Essentials or have taken C Programming Bootcamp Part 1, C Programming Bootcamp Part 2 and Linux Essentials. 

You will need a PC running a fairly recent Linux distribution such as CentOS 7.  To complete the hardware-based exercises in modules 7 to 10 you will need either a standard 25-pin parallel port or a small single board computer with general purpose I/O ports. You can purchase a single board computer with your course below or directly from the instructor at www.intellimetrix.us/gogotraining.  If your laptop lacks a parallel port, a compatible docking station usually has one.
 

This course is your Go To source for mastering how to apply Linux to embedded computing devices.  You will learn how to install a cross-development environment, how to use the Eclipse IDE, how to run and debug applications on an embedded target, how to configure and build the Linux kernel, how to boot the target, and how to work with network applications.  You will also have many opportunities to watch demonstrations and do exercises to practice what you’ve learned. The exercises and demos have been built and tested using kernel v3.5.3, Eclipse, Juno and Fedora 17.

If you’re not familiar with Linux, we suggest taking the Red Hat Linux Essentials course. You’ll need a background in C, and the Introduction to C Programming Part 1 and Part 2 will enable you to meet that requirement.

Module 00: Introduction to Embedded Linux 2013 - Course Introduction

Module 01: Introducing Linux

• What is Open Source?
• Exercise: Installing Linux
• Linux features
• Tour of the file system

Module 02:  KDE Graphical Desktop and the Command Shell Part 1

• Elements of KDE
• Demo: Exploring the desktop
• File Manager
• Demo: File Manager
• Exercise: Using the File Manager
• K Menu
• Demo: K Menu

Module 03:  KDE Graphical Desktop and the Command Shell Part 2

• The Shell
• Demo: The Shell
• Exercise: Using the Shell
• Demo: Graphical Help
• Exercise: Installing course software

Module 04: The Eclipse Development Environment Part 1

• Introduction and background
• Workbench elements
• Demo: The Eclipse Workbench
• Exercise: Creating a Project
• Eclipse menus

Module 05: The Eclipse Development Environment Part 2

• Creating a project – the C/C++ perspective
• Debugging with Eclipse
• Demo: Debugging with Eclipse
• Exercise: Debugging with Eclipse
• Configuring Eclipse
• Demo: Eclipse Configuration

Module 06:  Configuring the Workstation

• Review installed software
• Configure workstation – minicom
• Exercise: Configure workstation-minicom
• Configure workstation –networking
• Exercise: Configure workstation-networking
• Connect and power up target
• Exercise:  Connect and power up target
• The U-boot environment
• Exercise: Examining the U-boot environment

Module 07: Building and Running Target Applications

• Flash memory and file systems
• The target file system
• Exercise: Examining the target file system
• Exercise: Write the first program
• Accessing peripherals from User space

• Demo: Accessing peripherals from User space
• Data acquisition example
• Demo: Creating a makefile project
• Exercise: Create a makefile projecft
• Demo: Code review
• Demo: Building and running the measure program
• Exercise:  Build and run the measure program

Module 08: Debugging Applications: On the Target and on the Workstation

• Debugging on the target
• Demo: Target Debug Configuration
• Exercise: Target Debug Configuration
• Building a high-level simulation
• Exercise: Write thermostat.c
• Debugging on the workstation
• Demo: Host debugging
• Exercise: Host debugging
• Exercise: Run thermostat on target

Module 09: Multi-threading

• The fork() function
• Posix threads
• Thermostat with threads
• Demo: the Posix project
• Exercise: Create the Posix project
• Exercise: Modify thermostat.c
• Demo: Debugging multi-threaded programs
• Exercise: Debugging multi-threaded programs
• Accessing hardware from device drivers

Module 10: Networking Part 1

• The “sockets” model
• Demo: Simple client/server example
• Exercise: Build the client/server and run them
• Networked thermostat
• Exercise: Modify monitor.c
• Demo: Running the network thermostat
• Exercise: Run the network thermostat

Module 11: Networking Part 2

• Multiple client connections
• Exercise: Create multimon.c
• Demo:  Testing multiple clients
• Exercise: Testing multiple clients
• Embedded web server
• Demo: Code Review, Running the web server
• Exercise: Build and run a simple web server
• Exercise: Enable boa web server

Module 12: Graphics Device Driver

•  What’s a device driver?
• Exercise: the /dev directory
• Demo:  the /proc directory
• ANSI escape sequences
• The console driver
• The framebuffer driver
• Demo: Display example
• Exercise:  Using ANSI escape sequences
• Exercise: Create an LCD thermostat

Module 13: Configuring the Linux Kernel

• The kernel source tree
• Demo: Review kernel source tree
• Patching software
• Exercise: Building the kernel: First steps
• Configuring the kernel - xconfig
• Demo: Configuring the kernel
• Exercise: Configure the kernel

Module 14: Building the Linux Kernel

• The .config file
• Demo: The .config file
• Kconfig files
• Demo: a Kconfig file
• Building the kernel
• Exercise: Build the kernel Part 1
• Exercise: Set up the TFTP server
• Exercise: Build the kernel Part 2

• Booting the new kernel over TFTP
• Exercise: Booting the new kernel over TFTP

Module 15: Busybox and U-boot

• The target/bin directory
• Demo: The target/bin directory
• Configuring and Building Busybox
• Demo:  Configuring and Building Busybox
• Exercise: Configuring and Building Busybox
• Configuring U-boot
• Demo: Configuring U-boot

Module 16: Booting the Application, Getting Ready to Ship

• How Linux boots up
• The init process and inittab file
• Demo: Editing the inittab
• Exercise: Editing the inittab
• Exercise: Create YAFFS file system
• Loading the root file system to NAND flash
• Demo: loading the root file system to NAND flash
• Exercise: loading the root file system to NAND flash
• Loading the kernel to NAND flash
• Demo: Loading the kernel to NAND flash
• Exercise: Loading the kernel to NAND flash

Module 17: Wrapping Up

• Install and get familiar with Linux
  • What’s this Open Source stuff all about?
• Eclipse
• Set up target board
• Install class software – cross tool chain
• Configure host networking and minicom
• Target’s root file system is on host

To successfully complete this course you should be proficient in C programming or have taken Introduction to C Programming Part 1 and Introduction to C Programming Part 2, and have taken Red Hat Linux Essentials or have some familiarity with Linux.

As this is very much a hands-on class, you’ll get more out of the class if you have the target hardware on which the examples are run.  The Embedded Linux Learning Kit from Intellimetrix is offered at a reduced price to GogoTraining members. This kit includes all of the required software on CD.  Go to www.intellimetrix.us/gogotraining.