Course Description

NEW: Learn the Essentials of creating uBoot, Linux and YOCTO for a board

This is a step-by-step course. During this course you will learn the essentials about porting uBoot, Linux and YOCTO on a custom board.

After this course you will know how to get source code of uBoot, Linux and YOCTO for OpenRex board, you will know how to change the source, add a custom board support, compile it and test it. You can use similar steps to port uBoot, Kernel and YOCTO to your own boards.

Get “The Essentials of Porting Software” Certificate



Every student who actively engage with the course activities will receive a personal “The Essentials of Porting Software” Certificate.

Click here to see the course certificate
Watch this short video about the course (Duration: 1min 23s)

THIS COURSE IS FOR: Beginners, Hobbyists, Students and Engineers.

What will you learn?

All these you will learn during this course:

  • Lesson 1:
  • Prepare a host machine (how to prepare a Linux virtual computer with everything you need for compilation)
  • Download YOCTO and create uBoot, Kernel, Device Tree and Filesystem for the reference board (learn how to create images for the reference board)
  • Lesson 2:
  • Compile YOCTO for a custom board (bitbake YOCTO for OpenRex)
  • Create an SD Card needed to boot up a custom board (locate the output files, create SD card with uBoot and Linux)
  • Boot up your board to try the generated software (learn how to try the new uBoot, Kernel, Device Tree and Filesystem)
  • Setup a new repository with your source code (learn how to setup GitHub and how to use a repository to store your source code)
  • Start adding support for your custom board into uBoot (learn how to find which files need to be created and how to modify them)
  • Lesson 3:
  • Create initial uBoot files with support for your custom hardware (learn which files are important to create and edit)
  • Compile uBoot for your custom board (learn what commands you need to run to compile uBoot)
  • How to run DDR3 calibration to get values for memory controller (it’s important to get DDR3 controller register values, learn how to get them)
  • Lesson 4:
  • Uploading and starting uBoot directly from CPU (learn how to run uBoot on a board without any firmware)
  • Editing uBoot files to add custom board support (finding the important files and editing them)
  • Configuring pins of CPU in uBoot (learn how to setup the proper pin function and pin properties)
  • Working with repositories (learn how to upload code changes to GitHub)
  • Lesson 5:
  • Create files with custom hardware support in Kernel source code (learn which files are important to create and edit)
  • Compile Linux for your custom board (learn what commands will compile Kernel)
  • How to use uBoot to download and test the new Kernel and Device tree (learn commands to use uBoot for file transfer)
  • Lesson 6:
  • Create a new meta-layer for a custom board in YOCTO (learn how to tell YOCTO about your new board)
  • Add support for your custom board into YOCTO uBoot (learn how to tell YOCTO to compile your uBoot source code)
  • Add support for your custom board into YOCTO Kernel (learn how to tell YOCTO to compile your Kernel source code)
  • Lesson 7:
  • Compile / Bitbake YOCTO for your custom hardware (learn how to generate images from YOCTO for a custom board)
  • Create SD card with the new custom images (learn how to create the SD card which will boot up to Linux)
  • Rebuild your YOCTO project from scratch (test how your clients and customers will be rebuilding your YOCTO custom source code)
  • Lesson 8:
  • Add variant support into uBoot for your custom board (learn how to add support into uBoot for a board variant with different CPU and memory size)
  • Methods of flashing uBoot (learn how to flash uBoot on the new boards or update it on running boards)
  • FUSES / eFUSES / Bootstrap options (learn how to tell CPU from what peripheral it should boot up)
  • Lesson 9:
  • Add variant support into Kernel for your custom board (learn how to add support into Kernel for a board variant with different CPU and memory size)
  • Procedure of updating Kernel on SD card (learn how to update Kernel on existing board)
  • How to prepare a downloaded filesystem (learn how to prepare an SD card with downloaded filesystem)
  • About uBoot environmental variables and kernel command line (learn essentials about updating uBoot environmental variables and Kernel command line)
  • apt-get command in filesystem (learn how to get a filesystem with working apt-get command)
  • Lesson 10:
  • Add variant support into YOCTO for a custom board (learn how to add support into YOCTO for a board variant with different CPU and memory size)
  • Show other people / clients/ customers how they can compile your YOCTO (be sure, other people can compile code for your boards)
uBoot Bootloader

  • Learn how to download source code and add support for your own board into uBoot (learn how to find what files need to be created and modify them)
  • Learn how to compile uBoot (learn what commands to run to compile uBoot)
  • Learn how to add variant support into uBoot (learn how to add support into uBoot for a board variant with different CPU and memory size)
  • Learn how to run DDR3 calibration to get memory controller values (why we need to run DDR3 calibration and how to do it)
  • How to upload uBoot directly into CPU (how to test and flash the new boards from production or boards with no or corrupted software)
  • How to update / flash uBoot and how to use important uBoot commands (learn the essential commands of uBoot for downloading, testing and updates)
  • About bootstrap options / Fuses / eFuses (learn how to tell CPU to boot up from a particular interface e.g. SPI memory)
  • About uBoot environmental variables and kernel command line (learn essentials about updating uBoot environmental variables and Kernel command line)

Linux Kernel

  • Learn how to download source code and add support for your own board into Linux Kernel (learn how to find what files need to be created and modify them)
  • Learn how to compile Linux Kernel (learn what commands to run to compile Kernel)
  • Learn how to add variant support into Linux Kernel (learn how to add support into Kernel for a board variant with different CPU and memory size)
  • Learn how to try your custom Kernel & DeviceTree, learn how to update Kernel and DeviceTree on SD card (learn ways to try Linux after compilation)
  • Generate filesystem through YOCTO and learn how to use a downloaded filesystem (learn how you can update filesystem on your SD card)

YOCTO Project

  • Learn how to add support for your own board into YOCTO (learn how to find what files need to be created and modify them)
  • Learn how to compile / bitbake YOCTO (learn what steps to run to generate output files from YOCTO project)
  • Learn how to add variant support into YOCTO (learn how to add support into YOCTO for a board variant with different CPU and memory size)

Other

  • Prepare a host machine (how to prepare a Linux virtual computer with everything you need for compilation)
  • Download YOCTO and create uBoot, Kernel, Device Tree and Filesystem for the reference board (how to create images for the reference board)
  • How to prepare SD card which will boot up (learn how to create an SD card which will boot up to Linux)
  • Learn how to setup and work with repositories (we will use GitHub, but you can use your own repository software)

More Information

Price
Starting from 99 USD

Duration
10 Lessons. Each lesson has a tutoring video that is approximately one hour long (the last lesson is shorter). Watch when it’s best for you + activities for practicing.

Technical Requirements
Windows or Linux PC

Optional
OpenRex MAX board. This board is not required for the course, but it will help you to test your code.

100% Money Back Guaranteed for up to 30-days !

Check Prices OR Subscribe Here > > >