Getting Started Guide for DM368 DM365 LeopardBoard

From RidgeRun Developer Connection
Jump to: navigation, search

This guide includes instructions and tips users should follow to get their DM368 or DM365 Leopard Board to work with the RR Evaluation SDK. For this guide different commands need to be executed on the host machine and the target. Commands to be run on the Ubuntu host have a yellow background. Commands to be run on the DM368 DM365 LeopardBoard target hardware have an aqua background.


If you have the Professional SDK please ignore the section 1.1 and jump to 1.2.

Getting the RidgeRun LeopardBoard DM36x EVAL SDK

If you want to get the RidgeRun EVAL SDK for the LeopardBoard DM368 DM365 you need to go to our download center page and select the DM368 DM365 (for Leopardboard). You will be asked for your email address and some other information. Once you have submitted the required information you will receive an email with the following information:

  • A link to download the installer file for the RidgeRun DM368 DM365 evaluation SDK for LeopardBoard hardware. The installer file is for GNU/Linux based operating systems.
  • A username and password to download the installer.
  • A link to the installation instructions.

CodeSourcery Toolchain Installation

The RidgeRun evaluation SDK uses the Codesourcery toolchain for cross compilation. You need to download and install the Code Sourcery ARM toolchain before you can build the SDK.

DVSDK 4 Installation

In addition to the toolchain, it is necessary to install the TI's Digital Video Software Development Kit (DVSDK) package before installing the SDK. The evaluation SDK uses the DVSDK The download and installation instructions are detailed below:

 1. The dvsdk_dm365-evm_4_02_00_06_setuplinux binary file can be downloaded from TI's site.

Note :

Binary file name of DVSDK for DM368 Processor is : dvsdk_dm368-evm_4_02_00_06_setuplinux.

Binary file name of DVSDK for DM365 Processor is : dvsdk_dm365-evm_4_02_00_06_setuplinux.

2. Install it by executing the binary file with the following commands:

sudo chmod a+wrx dvsdk_dm368-evm_4_02_00_06_setuplinux
./dvsdk_dm368-evm_4_02_00_06_setuplinux --forcehost

3. You will be asked for the Toolchain's path, you need to specify the path to the binaries' directory of the toolchain as is shown in the following image:

DVSDK4 toolchain check.jpeg

4. Install the DVSDK with the default configuration.

OR for CONSOLE mode you can try below command

./ezsdk_dm814x-evm_5_05_02_00_setuplinux --forcehost --mode console

During the EZSDK installation process you will be asked for the toolchain's path, assuming that you installed it on /opt, the path that you need to provide is /opt/codesourcery/arm-2009q1/bin.

Install other required packages

Usually the SDK will ask you to install any missing package it requires that is not already installed on your host machine. You can install them using the following command:

sudo apt-get install package_name

The following is the list of the required packages by the SDK:

  • autoconf2.59
  • libgtk2.0-dev
  • bison
  • flex
  • mono-devel
  • libexpect-perl
  • libusb-dev
  • curl
  • minicom
  • libtool
  • libncurses5-dev

It is possible you need to install some additional packages when some features require them, the SDK will ask you for this packages in the form of a error message as is shown below:

Checking for host packages required by the SDK build system:
    buildsystem (build-essential) is installed
    make (make) is installed
    ncurses (libncurses5-dev) is installed
    texinfo (texinfo) is installed
 >> minicom (minicom) is NOT installed
    perl (perl) is installed
    quilt (quilt) is installed
    dc (dc) is installed
    subversion (subversion) is installed
    curl (curl) is installed
    git (git-core) is installed
    autoconf (autoconf) is installed
    crypt-ssleay (libcrypt-ssleay-perl) is installed
    quilt (quilt) is installed
    libusb (libusb-dev) is installed
    perl-expect (libexpect-perl) is installed
    mono (mono-devel) is installed
There are missing packages, please install them:
 apt-get install minicom
make: *** [.oscheck] Error 1

Also required: GIT and subversion:

sudo apt-get install git
sudo apt-get install subversion

Installing the SDK

Install the EVAL SDK version

Once you have downloaded the SDK installer you can execute it by running the following commands:

sudo chmod a+x RidgeRun-SDK-DM36x-Irazu-Eval-Linux-x86-Install.bin

OR you can choose the console mode installation

 ./RidgeRun-SDK-DM36x-Irazu-Eval-Linux-x86-Install.bin --mode console

You may will find it convient to install the evaluation SDK more than once. For example, you might want one version to be unmodified and another version to be your working development directory. RidgeRun suggests you install the SDK development directories in your $HOME/work/ directory. When you have more than one development directory installed, just remember to have the DEVDIR shell variable set properly.

Install the Professional SDK version

When all the business stuff is done, RidgeRun will provide you a GitHub repository access. For that, the GitHub user ID and other information might be requested. Once you provide that information, you must clone the given repository URL, using the next command:

git clone<customer>.git

This would have the proper <customer> space modified. With this, you will have the SDK installed on the directory you were when executed the the clone command.

Configuring the SDK

RidgeRun SDK can be easily configured using a menuconfig-like tool.

Configure the features you want to have in your board using:

First you goto the directory where you installed the sdk and further we call it as $devidr

make config

You'll find that there are a lot of options you can choose according to your needs.

Creating Bootable SD Card Image with filesystem using the SDK - With loopback file

Step 1: SDK Configuration for creating a SD Card Image:

1. On your SDK 'make config' menu, search for Installer Configuration and set:

                            Firmware deployment mode (Deploy all the firmware to an SD card)  --->                         
                            (0x82000000) RAM address to load components                                                        
                            [*] Flash SD card image into loopback file instead of real SD                                      
                            (256) Size of loopback device for SD card (in MB)                                                 
                                Root Filesystem type for SD card (Extended 3 File system (ext3))  --->                         
                            (148) Minimal size of rootfs (MB)                                                                 
                                *** Install on SD card options ***                                                             
                            (40) Size of U-Boot VFAT partition (in MB)                                                         
                                *** NAND Flash memory map (Partitions sizes are given in blocks number) ***                    
                            (32) Uboot partition size                                                                          
                            (25) Minimum kernel partition size                                                                 
                           (1600) Mininum file system partition size                                                          
                                *** MTD Integration options ***                                                                
                            [*] Configure Kernel MTD partitions with U-boot information                                       
                            (davinci_nand.0) MTD device name                                                                   
                            ()  MTD extra partitions     

2. Go to 'File System Configuration' and choose:

->File System image target -> Secure Digital (SDCard) Card 

Step 2: Building the SDK

Several packages are needed in order to compile the SDK. The SDK build process will let you know what packages are needed. While compiling you will be prompted to install them using sudo apt-get <packages>.

You can get a description of all the available commands for the SDK by running the following command into your SDK's installation directory:

make help

It will show a list as the shown bellow:

RidgeRun Integrated Linux Software Developer's Kit

Make targets:

   build           - build kernel, target fs, bootloader
   kernel          - build kernel
   fs              - build target filesystem
   cmdline         - build cmdline for target kernel (fs target does the same as well)
   bootloader      - build bootloader
   config          - allow SDK to be configured
   config_batch    - attempt to configure without user interaction
   clean           - delete all derived files
   env             - Displays commands to run to setup shell environment
   coreconfig      - Select toolchain, bootloader, and kernel (updates bsp/mach/Make.conf)
   doc             - Generate the SDK API documentation into the documentation folder
   prelink         - prelink the root filesystem
   install         - Install all out of date images to target
   installbootloader - Install bootloader to target
   installmtd      - Install uBoot MTD partition table
   installkernel   - Install kernel to target
   installfs       - Install file system to target
   installcmdline  - Install uBoot kernel command line
   installbootcmd  - Install uBoot boot command

Make parameters:

   VERBOSE         - set to 1 to output executing commands
   LOGFILE         - set to built output filename

U-boot Installer Parameters ($DEVDIR/installer/u-boot-installer)
   PORT            - Host serial port to use for install
   HOST_IP         - Host IP address to use for TFTP install
   FORMAT          - Set to 1 to force SD card to be formatted
   FORCEINSTALL    - Set to yes to force performing the requested install target
   ERASECHIP       - Set to yes if you want to scrub the FLASH chip during bootloader installation


   make                   # same as 'make build'
   make VERBOSE=1
   make installbootloader PORT=/dev/ttyUSB1

Set the PATH to include the toolchain and aslo set the DEVDIR shell variable

$(make env) # this is the same as using grave accents to execute the output from the command - `make env`

3. Compile the SDK:


4. Create the new image

make install

Step 3:  Copy the newly built image to the SD Card

5. Insert the sdcard to the host machine and find out its device partition for ex it will be /dev/sdb or /dev/sdc using 'df' command.



6. Unmount the SD Card

umount /dev/sdX                 -> replace 'sdX' with the device partition you found using 'df' command. for example it will be 'sdb' or 'sdc'

7. Goto $devdir/images folder

8. run

sudo dd bs=64M if=sdcard.img of=/dev/sdX   -> replace 'sdX' with the device partition you found using 'df' command. for example it will be 'sdb' or 'sdc'

Step 4: Set up the boot dip switch in the leopard board and boot the board

9. Insert the sdcard with the image on to the leo board and

Set switch 2 of DIPSW1 to ON, 1 and 3 to OFF. This is SD card boot mode.

10. Power up the board, it will automatically erase the NAND flash, and burn UBL, u-boot, kernel and file system.

Below Steps are for Flashing the SD Card image directly in to SD card without loopback file

This method allows the SDK to write directly into the SD card. WARNING a wrong configuration may cause the SDK to write into a wrong device which may cause problems, formating wrong devices or loss of data, be sure to find out the device mounting point of the SD card.


1. Insert the sdcard to the host machine and find out its device partition for ex it will be /dev/sdb or /dev/sdc using 'df' command.



2. Unmount the SD Card

umount /dev/sdX -> replace 'sdX' with the device partition you found using 'df' command. for example it will be 'sdb' or 'sdc'

3. Please enable below configuration under 'Installer Configurations' from 'make config' of the SDK.

[ ] Flash SD card image into loopback file instead of real SD
(/dev/sdX) SD device on Linux host (NEW) 

Note :

a) Replace /dev/sdX with the device partition you found using 'df' command

b) Other configurations under 'Installer Configurations' will remains the same as mentioned in the previous section ( Step1 in 'Creating Bootable SD Card Image with filesystem using the SDK')

4. run

make install

You will get below message on the run terminal when you run 'make install'. Please enter 'yes' to continue


At the above image the sd card was mounted at /dev/sdb in this case the SDK will be configured to write sdb, on your computer the SD could be mounted at other mount point.

Note : Boot Switch should be set for 'SDCard Boot' as per  Step 4 in the previous section ( Step4 in the 'Creating Bootable SD Card Image with filesystem using the SDK - With loopback file')

WARNING the SDK will format the device at the specified mount point, configuring the SDK to format a wrong device may cause data loss, boot partition format or other serious issues.

How to create a SD Card Nand Flash Installer Image for leopard DM36x RidgeRun SDK

RidgeRun Developer Wiki - Steps to create a SD Card Nand Flash Installer Image for leopard DM36x RidgeRun SDK

How to use root NFS file system with leopard DM36x RidgeRun SDK

Please follow the steps in the RidgeRun Developer Wiki's mentioned below

Using GStreamer with the LeopardBoard DM36x EVAL SDK

You can combine the SDK and the LeopardBoard DM36x with the GStreamer's API in order to get powerful multimedia applications in an easy and faster way. Some examples of use of GStreamer to implement basic multimedia pipelines can be found at below links :

LeopardBoard GStreamer Pipelines

Activation of video capture modules

While configuring the SDK go to

Kernel configuration->Device drivers->Multimedia support->Video capture adapters 

and activate the devices you desire.

For more details see Hardware setup - LeopardBoard DM365

Before running a capture pipeline you must be sure you have chained the video previewer, that could be done in two ways:

Currently the v4l2src element has a build in property called chain-ipipe which by default is set to true.
If you are not using v4l2src or you have disabled its chain-ipipe property you can chain it by using the ipiped application.

Setting up video components

The output and mode used for video playback/capture can be set during the SDK configuration process. The first step is to enter the configuration script:

make config

Inside Architecture configurations select the options you desire on Video Output and Video Default Resolution.

Finally compile your changes and install

make install

When you use the SDK to set your video output and resolution, the SDK build process creates $DEVDIR/images/cmdline with different kernel command line parameter settings. The table below shows the various video output settings for three of the common settings

Video Output DVI Component Composite sysfs file
Resolution 720P-60 720P-60 NTSC
davinci_enc_mngr.ch0_output DVI COMPOSITE COMPONENT /sys/class/davinci_display/ch0/output
davinci_enc_mngr.ch0_mode 720P-60 720P-60 NTSC /sys/class/davinci_display/ch0/mode
davinci_display.cont2_bufsize 6291456 6291456 3145728
vpfe_capture.cont_bufoffset 6291456 6291456 3145728
vpfe_capture.cont_bufsize 6291456 6291456 6291456

Video initialization

When you boot your board the RidgeRun logo will be displayed, in order to display video the following commands must be executed:

fbset -disable

Output volume modification

To increase/decrease the volume for audio playback (or other audio options) type


and modify as desired.

Common problems and their solution FAQ

Please refer RidgeRun developer wiki Common RidgeRun SDK issues and how to solve them

A FAQ listing error messages / solutions is available at RidgeRun SDK Technical FAQ.


User Guide: