The development for Software

Get Started

Essentials You Need

Before play with your NanoPC-T2 please get the following items ready

  • NanoPC-T2
  • SD Card: Class 10 or Above, minimum 8GB SDHC
  • A DC 5V/2A power is a must
  • HDMI monitor or LCD
  • USB keyboard, mouse and possible a USB hub(or a TTL to serial board)
  • A Host running Ubuntu 14.04 64 bit system

Make an Installation SD Card

Boot NanoPC-T2 from SD Card

Please get the following files from here:

  • Please get a 4G SDHC card and backup its data if necessary.
For LCD or HDMI output please use the following files:
nanopi2-debian-sd4g.img.zip Debian image files
nanopi2-android-sd4g.img.zip Android image files
Flash Utility:
win32diskimager.rar Windows utility. Under Linux users can use "dd"
  • Please uncompress these files. Insert an SD card(at least 4G) to a Windows PC, run the win32diskimager utility as administrator£¬On the utility's main window select your SD card's drive and the image files and click on "write" to start flashing the SD card.
  • Please insert this card to your NanoPC-T2's boot socket, press and hold the boot key and power on (with a 5V/2A power source). If the red LED is on and green power LED is blinking this indicates your NanoPC-T2 is successfully booted.

Boot NanoPC-T2 from eMMC

  • Download RAW Image 

Please get the image file: nanopi2-eflasher-sd4g.img.zip and the Windows utility: win32diskimager.rar;

  • Flash RAW Image to SD Card 

Please insert an SD card(at least 4G) to a Windows PC, run the win32diskimager utility as administrator£¬On the utility's main window select your SD card's drive and the image files and click on "write" to start flashing the SD card

  • Prepare RAW image

Please go to this link  to downlaod Android and Debian image files(System-image-files-for-eMMC). After download please untar the ".tgz" ball and copy the files to your SD card.

OS Image Files Copy to...
Android 5.1 android-lollipop-images.tgz 
android-lollipop-images.tgz.hash.md5
boot.img 
system.img 
userdata.img 
cache.img 
partmap.txt 
images\android
Debian (Jessie) debian-jessie-images.tgz 
debian-jessie-images.tgz.hash.md5
boot.img 
rootfs.img 
partmap.txt 
images\debian
  • Specify OS

By default the SD card's configuration file "images\FriendlyARM.ini" specifies Android to be flashed to eMMC. If you want to install Debian please make the following change:

OS = Debian

"#" is a comment

  • Flash Image to NanoPC-T2's eMMC

Please insert this card to your NanoPC-T2, connect the board to an HDMI or LCD, press and hold the boot key and power on (with a 5V/2A power source) to board to start installation. You can watch the whole installation process from the HDMI or LCD. If the following messages popped up it means the installation succeeds.

Android is fused successfully. 
All done.

After installation is done please do "reset" or power off and on the board to boot the board from eMMC.

You can check the LED's status to monitor the installation process too

LED Status Installation Status
LED1 blinks twice continuously
LED2 off
Power on normal.
If installation doesn't go on LED1 will keep behaving this way and LED2 will be off
LED1 and LED2 blink alternatively with each blink for 0.3s Installation going on
LED1 and LED2 blink alternatively with each blink for 1.2s Installation succeeds
LED1 and LED2 blink simultaneously Installation fails

Make Installation Card under Linux Desktop

  • 1) Insert your SD card to your host running Ubuntu and check your SD card's device name
dmesg | tail

Search the messages output by "dmesg" for similar words like "sdc: sdc1 sdc2". If you can find them it means your SD card is recognized as "/dev/sdc". Or you can check that by commanding "cat /proc/partitions"

  • 2) Downlaod Linux script
git clone https://github.com/friendlyarm/sd-fuse_nanopi2.git
cd sd-fuse_nanopi2
  • 3) Make Android SD Card
su
./fusing.sh /dev/sdx

(Note: you need to replace "/dev/sdx" with the device name in your system) 
When you run the script for the first time it will prompt you to download an image you have to hit “Y” within 10 seconds otherwise you will miss the download

  • 4) Here is how to make a Debian SD card
./fusing.sh /dev/sdx debian

LCD/HDMI Resolution

When system boots our uboot will check whether it is connected to an LCD. If it recognizes an LCD it will configure its resolution. By default our uboot configures the display to HDMI 720P.
If you want to reset the LCD resolution you can modify file "arch/arm/plat-s5p4418/nanopi2/lcds.c" in the kernel and recompile it.
If your NanoPC-T2 connects an HDMI monitor and it runs Android it will automatically set the resolution to an appropriate HDMI mode by checking "EDID". If your NanoPC-T2 connects an HDMI monitor and it runs Debian by default it will set the resolution to HDMI 720P and in this case you can set it to 1080P by modifying your kernel's configuration.

Update Image Files in SD Card From PC Host

If you want to make some changes to the image files in your SD card please follow steps below otherwise you can skip this section.
Please insert your SD card to a PC host running LINUX, mount the boot and rootfs sections of the SD card and follow the steps below:
1) If you want to change your kernel command line parameters you can do it via the fw_setevn utility under "sd-fuse_nanopi2/tools".
Check the current Command Line:

cd sd-fuse_nanopi2/tools
./fw_printenv /dev/sdc | grep bootargs

Android 5.1.1_r6 starts SELinux. By default it is enforcing. You can change it this way:

./fw_setenv /dev/sdc bootargs XXX androidboot.selinux=permissive

This sets it to "permissive". The "XXX" stands for the original bootargs' value.

2) Update Kernel 
Our customized uboot will check the LCD type when it boots.For a non-Android OS If it recognizes an LCD connected to the NanoPi 2 Fire it will load "uImage" from "boot" otherwise it will load "uImage.hdmi".
However for Android these two files don't make any differences for whatever display device it detects. You can use your generated uImage to replace the existing one under "boot".
For Debian if your generated kernel is for LCD you need to replace the existing uImage or if your kernel is for HDMI you need to replace the existing uImage.hdmi.

Run Android or Debian

  • Insert an SD card with Android/Debian image file to your NanoPC-T2, connect the board to an HDMI monitor, press and hold the boot key, power on the board the NanoPC-T2 will be booted from the SD card. If you can see the red LED on and the green LED flashing it means your board is working and you will see Android/Debain loading on the HDMI monitor.

1£©If you connect the NanoPC-T2 to an HDMI monitor you need to use a USB mouse and a USB keyboard to operate. If you connect it to an LCD with capacitive touch you can operate directly on the LCD.
2£©If you want to do kernel development you'd better have a serial board which allows you to operate the board via a serial terminal.

  • Here is a case in which we connect a NanoPC-T2 to a PC running Ubuntu and Minicom via a serial cable you will see system messages output to the PC’s minicom terminal:

  • Under Debian the password for "root" is "fa"

Login Debian via VNC or SSH

If your NanoPC-T2 is not connected to a display device and your board runs the "-wifiap.img" image you can login your NanoPC-T2's nanopi2-wifiap(the default password is "123456789") via a mobile phone. You can download and install a "VNC Viewer" from here on mobile phone and login the NanoPC-T2 via VNC. Its default password is "fa123456". Here is a screenshot which shows how it looks like when users login the NanoPC-T2 from an iPhone via VNC:

You can login via "SSH -l root 192.168.8.1" too and the default password for "root" is "fa"

To make SSH login fluent we turn off WIFI by running the following command:

iwconfig wlan0 power off

Play with Debian

Ethernet Connection

  • If the NanoPC-T2 is connected to a network via Ethernet before it is powered on it will automatically obtain an IP after it is powered on.

Wireless Connection

The following section only applies to the NanoPC-T2 which connects an HDMI or LCD

  • When the board runs Debian after Debian is fully loaded please click on the network icon on the GUI it will automatically search for nearby WiFi sources. Select a source from the list, click on its "Properties", type its password, save, close and then "Connect".
     

The following section only applies to the NanoPC-T2 which doesn't connect any display device(runs "-wifiap.img")

 

By default the system's WIFI AP mode is on therefore it cannot search and connect to a wireless router. You need to turn off the WiFi AP mode by following the instructions below: First please set up the WIFI rounter you expect to connect to:
Log in the NanoPC-T2 via SSH. Check the WIFI device by running the following commands. Those starting with "wlan" are WiFi devices:

ifconfig -a

By default "wlan0" is the Wifi device. You need to create a configuration file with the same name under "/etc/network/interfaces.d/". For instance you can create a "wlan0" file:

vi /etc/network/interfaces.d/wlan0

Here is the wlan0's content:

auto wlan0
iface wlan0 inet dhcp
wpa-driver nl80211
wpa-ssid YourWiFiESSID
wpa-ap-scan 1
wpa-psk YourWiFiPassword

The "YourWiFiESSID" and "YourWiFiPassword" need to be replaced with your actual ESSID and password.

If your WiFi password has special characters or you don't want your password saved as plain text you can use "wpa_passphrase" to generate a psk for your WiFi password. Here is how you can do it:

wpa_passphrase YourWiFiESSID

Follow its prompt to type your password you will get some code in the following format. The string after "psk=" is your new password:

network={
        ssid="YourWiFiESSID"
        #psk="YourWiFiPassword"
        psk=1b66ca678d6f439f7360686ff5eeb7519cdc44b76a40d96515e4eb807a6d408b
}

Now you can replace the existing password in the wlan0 file with the new one:

auto wlan0
iface wlan0 inet dhcp
wpa-driver nl80211
wpa-ssid YourWiFiESSID
wpa-ap-scan 1
wpa-psk 1b66ca678d6f439f7360686ff5eeb7519cdc44b76a40d96515e4eb807a6d408b

Next turn off the AP mode. You need to do this as root. Please run the following commands and your system will be rebooted. After your system rebooted it will automatically connect to the WiFi router you set up in your first step:

su
turn-wifi-into-apmode no

Setup Wi-Fi AP

You can follow the steps below to setup Wi-Fi AP:

turn-wifi-into-apmode yes

Please reboot the system as prompted. By default the AP's name is "nanopi2-wifiap" and the password is 123456789.

Now you are able to find the "nanopi2-wifiap" from a PC host and connect to it. If a connection is a success you will be able to SSH to this NanoPC-T2 at "192.168.8.1":

ssh root@192.168.8.1

The password for it is "fa"

To make SSH login fluent and fast please turn off the WiFi's power saving mode by running the following command:

iwconfig wlan0 power off

You can check the WiFi mode via the following command:

cat /sys/module/bcmdhd/parameters/op_mode

If the result is "2" it means it is currently working as a WiFi AP.If you want to switch back to the Station mode you can do it this way:

turn-wifi-into-apmode no

Bluetooth

Click on the bluetooth icon on the GUI a menu will pop up:
Make discoverable enables the NanoPC-T2 to be searched for by other bluetooth devices;
Devices... opens a search window and searches for nearby bluetooth devices(Note: the "Make discoverable" property needs to be enabled on those nearby devices);
Send Files to Device...enables the NanoPi2 to send files to another bluetooth device which is a pair of the NanoPC-T2

Install Debian Packages

We provide a Debian jessie image. You can install Jessie's packages by commanding "apt-get". If this is your first installation you need to update the package list by running the following command

apt-get update

You can install your preferred packages. For example if you want to install an FTP server you can do this:

apt-get install vsftpd

Note: you can change your download server by editting "/etc/apt/sources.list". You can get a complete server list from [2]. You need to select the one with "armhf".

Make Your Own OS Image

Install Cross Compiler

Please download the compiler package:

git clone https://github.com/friendlyarm/prebuilts.git
sudo mkdir -p /opt/FriendlyARM/toolchain
sudo tar xf prebuilts/gcc-x64/arm-cortexa9-linux-gnueabihf-4.9.3.tar.xz -C /opt/FriendlyARM/toolchain/

Then add the compiler's directory to "PATH" by appending the following lines in "~/.bashrc":

export PATH=/opt/FriendlyARM/toolchain/4.9.3/bin:$PATH
export GCC_COLORS=auto

Execute "~/.bashrc" to make the changes into effect. Please note that there is a space after ".":

. ~/.bashrc

This compiler is a 64-bit one therefore it cannot be run on a 32-bit LINUX. After the compiler is installed you can verify it by running the following commands:

arm-linux-gcc -v
Using built-in specs.
COLLECT_GCC=arm-linux-gcc
COLLECT_LTO_WRAPPER=/opt/FriendlyARM/toolchain/4.9.3/libexec/gcc/arm-cortexa9-linux-gnueabihf/4.9.3/lto-wrapper
Target: arm-cortexa9-linux-gnueabihf
Configured with: /work/toolchain/build/src/gcc-4.9.3/configure --build=x86_64-build_pc-linux-gnu
--host=x86_64-build_pc-linux-gnu --target=arm-cortexa9-linux-gnueabihf --prefix=/opt/FriendlyARM/toolchain/4.9.3
--with-sysroot=/opt/FriendlyARM/toolchain/4.9.3/arm-cortexa9-linux-gnueabihf/sys-root --enable-languages=c,c++
--with-arch=armv7-a --with-tune=cortex-a9 --with-fpu=vfpv3 --with-float=hard
...
Thread model: posix
gcc version 4.9.3 (ctng-1.21.0-229g-FA)

Compile U-Boot

Download the U-Boot source code and compile it. Please note the github's branch is nanopi2-lollipop-mr1:

git clone https://github.com/friendlyarm/uboot_nanopi2.git
cd uboot_nanopi2
git checkout nanopi2-lollipop-mr1
make s5p4418_nanopi2_config
make CROSS_COMPILE=arm-linux-

After your compilation succeeds a u-boot.bin will be generated. If you want to test it please flash it to your installation SD card via fastboot. Here is how you can do it:
1) On your PC host please run "sudo apt-get install android-tools-fastboot" to install the fastboot utility;
2) Connect your NanoPC-T2 to your PC host via a serial cable (e.g. PSU-ONECOME). Press the enter key within two seconds right after you power on your NanoPC-T2 and you will enter uboot's command line mode;
3) After type "fastboot" and press "enter" you will enter the fastboot mode;
4) Connect your NanoPC-T2 to this PC host via a microUSB cable and type the following command to flash the u-boot.bin:

fastboot flash bootloader u-boot.bin


Warning: you cannot update this SD card by commanding "dd". This command which will cause trouble when booting the NanoPC-T2.

Prepare mkimage

You need the mkimage utility to compile a U-Boot source code package. Please make sure this utility works well on your host before you start compiling a uImage.
You can install this utility by either commanding "sudo apt-get install u-boot-tools" or following the commands below:

cd uboot_nanopi2
make CROSS_COMPILE=arm-linux- tools
sudo mkdir -p /usr/local/sbin && sudo cp -v tools/mkimage /usr/local/sbin

Compile Linux Kernel

Compile Kernel

  • Download Kernel Source Code
git clone https://github.com/friendlyarm/linux-3.4.y.git
cd linux-3.4.y
git checkout nanopi2-lollipop-mr1

The NanoPC-T2's kernel source code lies in the "nanopi2-lollipop-mr1" branch.

  • Compile Android Kernel
make nanopi2_android_defconfig
touch .scmversion
make uImage
  • Compile Debian Kernel
make nanopi2_linux_defconfig
touch .scmversion
make uImage

After your compilation succeeds a uImage will be generated in the "arch/arm/boot/uImage" directory. This kernel is for HDMI 720P. You can use it to replace the existing uImage.hdmi.
If you want to generate a kernel for HDMI 1080P you can do it this way:

touch .scmversion
make nanopi2_linux_defconfig
make menuconfig
  Device Drivers -->
    Graphics support -->
      Nexell Graphics -->
        [ ] LCD
        [*] HDMI
        (0)   Display In  [0=Display 0, 1=Display 1]
              Resolution (1920 * 1080p)  --->
make uImage

After your compilation succeeds a uImage will be generated for HDMI 1080P. You can use it to replace the existing uImage.

Compile Kernel Modules

Android contains kernel modules which are in the "/lib/modules" directory in the system section. If you want to add your own modules to the kernel or you changed your kernel configurations you need to recompile these new modules.
Compile Original Kernel Modules:

cd linux-3.4.y
make CROSS_COMPILE=arm-linux- modules

Here we have two new modules and we can compile them by following the commands below:

cd /opt/FriendlyARM/s5p4418/android
./vendor/friendly-arm/build/common/build-modules.sh

The "/opt/FriendlyARM/s5p4418/android" directory points to the top directory of Android source code. You can get more details by specifying option "-h".
After your compilation succeeds new modules will be generated

Compile Android

  • Install Cross Compiler

We recommend installing 64 bit Ubuntu 14.04 on your PC host.

sudo apt-get install bison g++-multilib git gperf libxml2-utils make python-networkx zip
sudo apt-get install flex libncurses5-dev zlib1g-dev gawk minicom

For more details please refer to https://source.android.com/source/initializing.html ¡£

  • Download Source Code

You need to use repo to get the Android source code. Please refer to  https://source.android.com/source/downloading.html ¡£

mkdir android && cd android
repo init -u https://github.com/friendlyarm/android_manifest.git -b nanopi2-lollipop-mr1
repo sync

The "android" directory is the working directory.

  • Compile System Package
source build/envsetup.sh
lunch aosp_nanopi2-userdebug
make -j8

After your compilation succeeds an image will be generated in the "out/target/product/nanopi2/" directory.

Connect NanoPC-T2 to External Modules

Connect NanoPC-T2 to USB Camera(FA-CAM202)

  • In this use case the NanoPC-T 2 runs Debian. If you connect your NanoPC-T2 to our LCD or an HDMI monitor after Debain is fully loaded please click on "other"-->"xawtv9" on the left bottom of the GUI and the USB Camera application will be started. After enter "welcome to xawtv£¡" please click on "OK" to start exploring.

Connect NanoPC-T2 to CMOS 5M-Pixel Camera

 

  • In this use case the NanoPC-T2 runs Android5.1. If you connect your NanoPC-T2 to our LCD or an HDMI monitor after Debain is fully loaded please click on the "Camera" icon the application will be started.
  • Use OpenCV to Access USB Camera

  • The full name of "OpenCV" is Open Source Computer Vision Library and it is a cross platform vision library.
  • When the NanoPC-T2 runs Debian users can use OpenCV APIs to access a USB Camera device.
  • 1. Here is a guideline on how to use OpenCV with C++ on the NanoPC-T2:

  • Firstly you need to make sure your NanoPC-T2 is connected to the internet.Login your NanoPC-T2 via a serial terminal or SSH. After login please type your username(root) and password(fa):
  • Run the following commands:
  •  

    apt-get update
    apt-get install libcv-dev libopencv-dev

    2. Make sure your USB camera works with the NanoPC-T2. You can test your camera with NanoPC-T2's camera utility.
    3. Check your camera device:

    ls /dev/video*
  • Note:in our test case video9 was available and video0 to video8 were occupied
  • 4. OpenCV's code sample(official code in C++) is under /home/fa/Documents/opencv-demo. Compile the code sample with the following commands:

    cd /home/fa/Documents/opencv-demo
    make

    After it is compiled successfully a "demo" executable will be generated 

    5. Note: the NanoPC-T2 has nine video devices. However this OpenCV's code sample defines a maximum of 8 cameras can be accessed therefore one video needs to be removed. Here we removed video0:

    rm /dev/video0
    mv /dev/video9 /dev/video0

    6. Connect NanoPi 2 to USB Keyboard & Run the Following Command:

    ./demo

Extend NanoPC-T2's SD Card Section

Debian

Please run the following commands on a PC host's terminal for debian:

sudo umount /dev/sdx?
sudo parted /dev/sdx unit % resizepart 4 100 resizepart 7 100 unit MB print
sudo resize2fs -f /dev/sdx7

(Note: you need to replace "/dev/sdx" with the device name in your system)

sudo umount /dev/sdx?
sudo parted /dev/sdx unit % resizepart 2 100 unit MB print
sudo resize2fs -f /dev/sdx2

 

Android

Please run the following commands on a PC host's terminal for Android:

sudo umount /dev/sdx?
sudo parted /dev/sdx unit % resizepart 4 100 resizepart 7 100 unit MB print
sudo resize2fs -f /dev/sdx7

(Note: you need to replace "/dev/sdx" with the device name in your system)

 

 


NanoPC       News       Download       Forum       FAQs       About us

English information | Follow Us: Google+ | Twitter
+86-755-29638421
Work time: 09:00-18:00
NanoPC Online Chat >
Work time: 09:00-18:00
Copyright @ 2014 to 2020 - FriendlyARM NanoPC Team