Embedded Linux Programming – 2021 Release

Learn to Write and Debug Linux Programs on Real Target Hardware

545.00 $

Delivery Type: The Course is taken online
Length of Access: 1 year
Features: 24/7 Access, Real Instructors, Classroom Materials and Exercise Guides. Exam Prep and Instructor Support.

Online Classes

Flexible Schedule

Interactive

High Quality

Certifications

Instructor Help

Loading...

Description

 

This course is designed to give you practical, hands-on experience in writing and debugging Linux-based application programs on real target hardware.  In this course you will learn how to:

  • Install a cross-development environment
  • Use the Eclipse IDE
  • Run and debug applications on an embedded target
  • Configure and build the Linux kernel
  • Boot the target
  • 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 Linux kernel v4.19, Eclipse 2020-03 and CentOS 7.

Course Highlights:

  • Understanding the Host and Target Environments and How They Interact
  • Application Development and Debugging using the Eclipse IDE
  • Multi-Threaded and Network Programming
  • Patching, Configuring, and Building the Linux Kernel
  • Device Drivers

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.

In this course you will learn:

Upon completing this course, you will understand how to:

  • Set up a cross development environment on a Linux workstation
  • Create, build, and debug applications on a target board using the Eclipse IDE
  • Write multi-threaded and networked applications
  • Configure and build the Linux kernel
  • Install and boot the application in product form

Pre-requisites:

The course is intended for engineers and programmers involved in developing embedded computing systems and devices using the Linux Operating System. Attendees should be very comfortable programming in C.  If you are not comfortable with C Programming we recommend you take C Programming Bootcamp part 1 and part 2.  Some familiarity with Linux is helpful, but not essential.

Students who possess proficient knowledge of these prerequisite courses as well as the bullet points below may enroll in this course.

  • Fluency in C Programming
  • Some familiarity with basic digital hardware components such as network and serial ports
  • Some experience using Linux both from a command shell and a graphical desktop environment
  • Some experience debugging application code is helpful

This is a hands-on course and requires students to have the target hardware in order to execute the examples in the class.  When you purchase this course the Embedded Linux Learning Kit from Intellimetrix will be sent to you. You will be contacted on the next business day to confirm your address.

Outline

Module 00: Introduction to Embedded Linux 

Module 01: Introducing and Installing Linux

  • Linux Background and Open Source
  • Installing Linux—Options
    • Exercise: Installing Linux

Module 2: Linux Features and the File System

  • Linux Features
  • Tour of the Linux File System

Module 3: KDE Desktop Environment

  • Elements of KDE
  • KDE File Manager
  • Application Launcher

Module 4:  Exploring the Desktop Demo

Module 5:  File Manager Demo

Module 6: The Linux Command Shell

  • Elements of the Shell
  • File Permissions
  • Getting Help
  • Installing Class Files
  • Viewing Lessons on Linux

Module 7: Shell Basics Demo

  • Shell Basics
  • Exercise: Using the Shell

Module 8:  Graphical Help Demo

Module 9:  Installing Class Software

Module 10: The Eclipse Development Environment

  • Background
  • Basic Features
  • Creating a Project

Module 11: The Eclipse Menu

Module 12: Eclipse Integrated Development Environment Demo

  • Exercise: Creating a Project (hello)

Module 13: Creating an Eclipse Project 

  • Creating a Project (record_sort)
    • Exercise: Create the Project
    • Build the Project, Find the Errors

Module 14:  Debugging with Eclipse Demo

  • Set up Debug Configuration
  • The Debug Perspective
  • Exercise: Debugging record_sort

Module 15:  Configuring Eclipse Demo

  • Overview of Configuration
  • C/C++
  • Project Settings

Module 16: Configure Minicom

  • Review Installed Software
  • Configure minicom
  • Become Member of Dialout Group
  • Exercise: Configure minicom

Module 17:  Configure Networking & Target Board

  • Configure Networking
    • Exercise: Configure Networking
  • Connecting and Powering up the Target Board
    • Exercise: Starting the Target Board

Module 18: Building and Running Target Applications

  • The Target Linux Environment
  • Accessing Peripherals from User Space – the /sys File System
  • Our First Program
  • Using the A/D Converter

Module 19:  Sys File System Demo

  • The /sys File System
  • The /proc File System
  • Exercise: Flashing LEDs from the Command Shell

Module 20:  Code Review Demo

  • Code Review of led.c
  • Create a makefile Project
  • Exercise: Create a makefile Project

Module 21: Debugging: On the Target and the Workstation

  • Remote Debugging Using Eclipse
  • High Level Simulation—A Thermostat
  • Debugging on the Workstation

Module 22:  SSH & Remote Debugger Demo

  • Configuring SSH Connection
  • Exercise: Configure SSH Connection
  • Configuring Remote Debugger
  • Exercise: Configuring Remote Debugger

Module 23:  Simulation Debug Configuration Demo

  • Set up Simulation Debug Configuration
  • Exercise: Write and Debug Thermostat App

Module 24: Multi-threading

  • Approaches to Multiple Threads
    • The fork() Function
    • Processes vs Threads
  • Posix Threads
  • Thermostat with Adjustable Parameters

Module 25: Code Review: monitor.c Demo

  • Set up New Makefile Project
  • Code Review: monitor.c
  • Exercise: Adapt thermostat.c to Work with monitor.c and Debug

Module 26: Networking Part 1

  • Networking Basics—Sockets
  • Basic Network Server and Client
  • Networked Thermostat

Module 27:  Networking Code Review Demo

  • Code Review: netserve.c, netclient.c
  • Exercise: Build and Exercise Basic Server/Client with Server on Host and on Target
  • Exercise: Adapt monitor.c to Work with Network

Module 28: Networking Part 2

  • Multiple Client Connections
  • Embedded Web Server—Monkey

Module 29:  Testing Multiple Clients Demo

  • Testing Multiple Clients
  • Exercise: Adapt monitor.c to Support Multiple Clients

Module 30:  Monkey Web Server Demo

  • Monkey Web Server
  • Exercise: Configure, Build and Run Monkey

Module 31: Graphics Device Driver

  • What’s a Device Driver?
  • The SPI Bus
  • Framebuffer and Framebuffer Driver
  • The Graphics Library

Module 32:  Graphics Code Review Demo

  • Code Review: oled.c
  • Exercise: Build and Run oledtest
  • Exercise: Thermostat Display

Module 33: Configuring and Building the Linux Kernel

  • The Kernel Source Tree
  • Building the Kernel: First Steps
  • Make xconfig
  • The .config File
  • Kconfig Configuration Language
  • Build and Test the Kernel

Module 34: Tour of the Kernel Source Tree Demo

  • Tour of the Kernel Source Tree
  • Exercise: Building the Kernel: First Steps

 Module 35:  Make xconfig Demo

  • Make xconfig
  • The .config File
  • A kconfig File
  • Exercise: Make xconfig
  • Exercise: Build and Test the Kernel

Module 36: Busybox

  • Background
  • Hard vs. Soft (symbolic) Links
  • Configuring and Building Busybox

Module 37:  Busybox Demo

  • Target /bin Directory
  • Hard and Soft Links
  • Exercise: Configure, Build and Install Busybox

Module 38:  Booting the Raspberry Pi

  • Booting the Raspberry Pi
  • Configuring and Installing U-boot
  • Booting the Kernel Over the Network with TFTP

Module 39:  U-boot Demo

  • U-boot Environment Variables
  • Configure, Build and Install U-boot
  • Exercise: U-boot
  • Exercise: Boot the Kernel Over the Network

Module 40: Booting the Application—Getting Ready to Ship

  • Linux Initialization
  • inittab and Startup Scripts
  • Boot Target from SD Card
  • Create a File System Image

Module 41: Startup Demo

  • Demo: The inittab File and Startup Scripts
  • Exercise: Startup Script for Thermostat
  • Exercise: Ship it!

 Module 42:  Systemd

  • Systemd—the New Way to Initialize

Module 43: Course Summary

  • Install and Get Familiar with Linux
  • Configure Workstation, Boot up Target Board
  • Application Development in a Cross-Tool Environment
  • Network Programming
  • Tools and Components
  • The Linux Kernel
  • Busybox
  • U-boot
  • Booting the Application, Getting Ready to Ship
  • Resources for Further Study

 

*To watch the videos and access the materials that come with this course, please follow the instructions that were sent to you when you purchased the course.

Special offer

Reviews

There are no reviews yet.

Be the first to review “Embedded Linux Programming – 2021 Release”

Your email address will not be published. Required fields are marked *

Select your currency
EUREuro