Difference between revisions of "NanoPi K2"
(→如何编译系统) |
(→编译U-Boot) |
||
| Line 278: | Line 278: | ||
Add the compiler's directory to "PATH". | Add the compiler's directory to "PATH". | ||
| − | === | + | ===Compile U-Boot=== |
| − | + | Download the U-Boot source code and compile it. Note that the github's branch is nanopi-k2-v2015.01: | |
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
git clone https://github.com/friendlyarm/uboot.git | git clone https://github.com/friendlyarm/uboot.git | ||
| Line 288: | Line 288: | ||
</syntaxhighlight> | </syntaxhighlight> | ||
| − | + | After your compilation succeeds a u-boot.bin will be generated. If you want to test it flash it to your installation SD card via fastboot. Here is how you can do it: | |
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
sudo ./fusing.sh /dev/sdc | sudo ./fusing.sh /dev/sdc | ||
</syntaxhighlight> | </syntaxhighlight> | ||
| − | + | Or you can do it with fastboot:<br /> | |
| − | 1) | + | 1) On your host PC run "sudo apt-get install android-tools-fastboot" to install the fastboot utility;<br/> |
| − | 2) | + | 2) Connect your NanoPi K2 to your host PC via a serial cable (e.g. PSU-ONECOME). Press the enter key within two seconds right after you power on your NanoPi K2 and you will enter uboot's command line mode;<br/> |
| − | 3) | + | 3) After type in "fastboot" and press "enter" you will enter the fastboot mode;<br/> |
| − | 4) | + | 4) Connect your NanoPi K2 to this host PC via a microUSB cable and type in the following command to flash u-boot.bin:<br/> |
<syntaxhighlight lang="bash"> | <syntaxhighlight lang="bash"> | ||
fastboot flash bootloader fip/gxb/u-boot.bin | fastboot flash bootloader fip/gxb/u-boot.bin | ||
Revision as of 02:24, 14 April 2017
Contents
1 Introduction
- FriendlyElec's NanoPi K2 uses Amlogic's 64-bit quad-core A53 S905 SoC. This SoC has internal Mali450 GPU. S905's dynamic frequency scales up to 2G Hz.In FriendlyElec's tests it can scale up to 2G. Its most significant feature is that it supports various video formats and has strong video decoding capability
- The NanoPi K2 has 2GB DDR3 RAM, onboard WiFi & Bluetooth, 1000M Ethernet, USB, HDMI, IR and etc. It has a socket for external eMMC. It boots OS from a TF card. It has the same form factor and layout of interfaces and ports as the RPi 3. An Android image is ready for K2. Later on a Ubuntu image will be ready.
- A special feature of the NanoPi K2 is that it supports DVFS and can play high-definition video steams stably and smoothly. It is a good platform for applications such as advertisement machines, TV boxes, home entertainment appliances, multi-media devices and etc.
2 Hardware Spec
- SoC: Amlogic S905, Quad-core ARM Cortex-A53@1.5GHz, DVFS
- GPU: Penta-core ARM Mali™-450
- RAM: 2GB DDR3
- Network Connectivity: 10/100/1000M (RTL8211F)
- Wireless：802.11 b/g/n
- Bluetooth：4.0 dual mode
- Antenna: One onboard porcelain antenna shared by both WiFi and Bluetooth. One individual IPX interface.
- IR: Onboard IR receiver
- Audio: Via HDMI/Bluetooth
- eMMC interface: eMMC socket
- I2S: 7-Pin, 2.54mm pitch pin-header
- SD: 1 x MicroSD slot
- USB Host: 4 x USB 2.0 Host, standard type A
- Micro USB: 1 x USB 2.0, OTG, power input and data transmission
- HDMI: HDMI 2.0, Type-A. It supports 4K video
- GPIO: 40-Pin, 2.54mm pitch pin-header including I2C, ADC, GPIO, UART, PWM, SPDIF and CVBS
- Serial debug port: 4-Pin, 2.54mm pitch single-row pin-header
- User Key: 1 x power key
- LED: 1 x power LED and 1 x status LED
- Power Interface: DC jack, MicroUSB
- Power Supply: DC 5V/2A
- PCB dimension: 56 x 85mm，6-layer, ENIG
3 Diagram, Layout and Dimension
3.1 Layout
- GPIO Pin Description
Pin# Name Pin# Name 1 SYS_3.3V 2 VDD_5V 3 GPIODV_24/I2C_SDA_A 4 VDD_5V 5 GPIODV_25/I2C_SCK_A 6 GND 7 GPIOY_0 8 GPIOY_13/UART_TX_C 9 DGND 10 GPIOY_13/UART_RX_C 11 GPIOY_1 12 GPIOY_16/PWM_A 13 GPIOY_2 14 GND 15 GPIOY_3 16 GPIOY_15/PWM_F 17 SYS_3.3V 18 GPIOY_4 19 GPIOY_5 20 GND 21 GPIOY_7 22 GPIOY_6 23 GPIOY_9 24 GPIOY_8 25 DGND 26 GPIOY_10 27 GPIODV_26/I2C_SDA_B 28 GPIODV_27/I2C_SCK_B 29 GPIOY_11/SPDIF_IN 30 GND 31 GPIOAO_5 32 GPIOY_12/SPDIF_OUT 33 GPIOH_3 34 GND 35 GPIOCLK_1 36 CVBS 37 AIN1 38 1.8V Vref Out 39 GND 40 AIN0
- eMMC Interface Pin Description
Pin# Name Pin# Name 1 eMMC_D0 2 eMMC_D1 3 eMMC_D2 4 eMMC_D3 5 eMMC_D4 6 eMMC_D5 7 eMMC_D6 8 eMMC_D7 9 eMMC_DS 10 GND 11 eMMC_CMD 12 eMMC_CLK 13 NC 14 GND 15 NC 16 1.8V OUT 17 eMMC_RST 18 3.3V OUT 19 GPIOY_5 20 GND
- Debug Port（UART0）
Pin# Name 1 GND 2 VDD_5V 3 UART_TX_AO_A 4 UART_RX_AO_A
- 7Pin I2S Interface Pin Description
Pin# Name 1 GND 2 SYS_3.3V 3 I2S_SCLK 4 I2S_LRCLK 5 I2S_DATA_OUT 6 I2S_DATA_IN 7 I2S_MCLK
- Notes
- SYS_3.3V: 3.3V power output
- VDD_5V: 5V power output5V. The input range is 4.7V ~ 5.6V
- All pins are 3.3V
- For more details refer to the document:NanoPi-K2-1701-Schematic.pdf
3.2 Board Dimension
- For more details refer to the document:NanoPi-K2-1701-dxf.zip
4 Get Started
4.1 Essentials You Need
Before starting to use your NanoPi K2 get the following items ready
- NanoPi K2
- MicroSD Card/TF Card: Class 10 or Above, minimum 8GB SDHC
- A DC 5V/2A power is a must
- HDMI monitor
- USB keyboard and USB mouse
- A host computer running Ubuntu 14.04 64 bit system
4.2 TF Cards We Tested
To make your NanoPi K2 boot and run fast we highly recommend you use a Class10 8GB SDHC TF card or a better one. The following cards are what we used in all our test cases presented here:
- SanDisk TF 8G Class10 Micro/SD TF card:
- SanDisk TF128G MicroSDXC TF 128G Class10 48MB/S:
- 川宇 8G C10 High Speed class10 micro SD card:
4.3 Make an Installation TF Card
4.3.1 Boot OS from TF Card
Get the following files from download link:
- Get a 8G SDHC card
Image Files: s905-android-sd4g-YYYYMMDD.img.zip Android5.1 Image File Flash Utility: win32diskimager.rar Windows utility. Under Linux users can use "dd"
- Extract an image file and win32diskimager.rar. Insert a TF card(at least 8G) into a Windows PC and run the win32diskimager utility as administrator. On the utility's main window select your TF card's drive, the wanted image file and click on "write" to start flashing the TF card.
- Insert this card into your NanoPi K2's BOOT slot and power on (with a 5V/2A power source). If both the green LED and blue LED are solid on this indicates your NanoPi K2 has successfully booted.
4.3.2 Make Installation Card under Linux Desktop
- 1) Insert your SD card into a host computer 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 has been 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_amlogic.git cd sd-fuse_amlogic
- 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.3.3 Extend NanoPi K2's SD Card Section
- When Android is loaded you need to run the following commands on your host PC to extend your SD card's section:
sudo umount /dev/sdx? sudo parted /dev/sdx unit % resizepart 4 100 unit MB print sudo resize2fs -f /dev/sdx4
(Note: you need to replace "/dev/sdx" with the device name in your system)
4.3.4 HDMI Resolution
If your NanoPi K2 is connected to an HDMI monitor and it runs Android it will automatically set the resolution to an appropriate HDMI mode by checking the "EDID".
4.4 Run Android
- Insert an SD card with Android image into your NanoPi K2, connect the board to an HDMI monitor, power on the board K2 will boot from the SD card. If you can see the PWR LED on and the blue LED are solid on it means your board is working and you will see Android being loaded on the HDMI monitor.
- It is recommended to turn off its power by pressing the PWR key otherwise the system data in the TF card will be damaged.
5 Make Your Own OS Image
5.1 Install Cross Compiler
- Install ARMv7 Cross Compiler
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 take effect. Note that there is a space after the first ".":
. ~/.bashrcThis compiler is a 64-bit one therefore it cannot be run on a 32-bit Linux machine. 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)
- Install AArch64 Cross Compiler
The AArch64 cross compiler is needed to compile U-Boot and Linux. We used linaro toolchain:
wget http://releases.linaro.org/components/toolchain/binaries/4.9-2017.01/aarch64-linux-gnu/gcc-linaro-4.9.4-2017.01-x86_64_aarch64-linux-gnu.tar.xz tar xf gcc-linaro-4.9.4-2017.01-x86_64_aarch64-linux-gnu.tar.xz export PATH=~/gcc-linaro-4.9.4-2017.01-x86_64_aarch64-linux-gnu/bin:$PATH
Add the compiler's directory to "PATH".
5.2 Compile U-Boot
Download the U-Boot source code and compile it. Note that the github's branch is nanopi-k2-v2015.01:
git clone https://github.com/friendlyarm/uboot.git cd uboot git checkout nanopi-k2-v2015.01 make nanopi-k2_defconfig make
After your compilation succeeds a u-boot.bin will be generated. If you want to test it flash it to your installation SD card via fastboot. Here is how you can do it:
sudo ./fusing.sh /dev/sdc
Or you can do it with fastboot:
1) On your host PC run "sudo apt-get install android-tools-fastboot" to install the fastboot utility;
2) Connect your NanoPi K2 to your host PC via a serial cable (e.g. PSU-ONECOME). Press the enter key within two seconds right after you power on your NanoPi K2 and you will enter uboot's command line mode;
3) After type in "fastboot" and press "enter" you will enter the fastboot mode;
4) Connect your NanoPi K2 to this host PC via a microUSB cable and type in the following command to flash u-boot.bin:
fastboot flash bootloader fip/gxb/u-boot.bin
5.3 编译Linux kernel
5.3.1 编译内核
- 下载内核源代码
git clone https://github.com/friendlyarm/linux.git cd linux git checkout nanopi-k2-3.14.y
NanoPi K2内核所属的分支是nanopi-k2-3.14.y，在开始编译前先切换分支。
- 编译Android内核
make ARCH=arm64 nanopi-k2_defconfig make ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- Image nanopi-k2.dtb
编译成功结束后，即会生成新的 arch/arm64/boot/dts/amlogic/nanopi-k2.dtb 和 arch/arm64/boot/Image ，用于替换掉SD卡boot分区下对应的文件。
5.3.2 如何使用新编译的内核
- 更新SD卡上的内核
如果您是使用SD卡启动Android，则在PC上复制为Android编译的Image 和nanopi-k2.dtb 到SD卡的boot分区(即分区1，设备是/dev/sdX1)即可。
- 通过adb直接更新
如果想直接更新正在运行中的板子，可通过adb将新的文件push到板子上，然后reboot即可，具体如下:
adb shell mount -t ext4 /dev/block/mmcblk0p1 /storage/sdcard1/ adb push arch/arm64/boot/Image /storage/sdcard1/ adb push arch/arm64/boot/dts/amlogic/nanopi-k2.dtb /storage/sdcard1/ adb reboot
- 更新Android中预先编译的文件
如果想要生成新的Android boot.img，则需要使用新生成的文件替换Android源代码目录device/friendly-arm/nanopi-k2-kernel 下对应的文件，然后编译Android即可。
5.4 编译Android
- 搭建编译环境
搭建编译Android的环境建议使用64位的Ubuntu 14.04，安装需要的包即可。
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
更多说明可查看 https://source.android.com/source/initializing.html 。
- 下载Android5.1源代码
Android源代码的下载需要使用repo，其安装和使用请查看 https://source.android.com/source/downloading.html 。
mkdir android && cd android repo init -u https://github.com/friendlyarm/android_manifest.git -b nanopi-k2-lollipop repo sync
其中“android”是指工作目录。
- 编译系统
source build/envsetup.sh lunch nanopi_k2-userdebug make -j8
编译成功完成后，目录 out/target/product/nanopi-k2 下包含可用于烧写的image文件。
filename partition Description u-boot.bin bootloader - boot.img boot - cache.img cache - userdata.img userdata - system.img system - partmap.txt - 分区描述文件
- 烧写到SD卡
如果是采用SD卡启动Android，可复制编译生成的image文件到sd-fuse_amlogic/android/ 下，使用脚本即可烧到到SD卡，具体请查看#在Linux Desktop下通过脚本制作。
- 使用fastboot更新
板子启动后通过串口快速按任意键进入uboot命令行模式，输入命令fastboot usb即可更新Android。
连接USB线，然后PC端输入以下命令:
cd out/target/product/nanopi-k2 sudo fastboot flash boot boot.img sudo fastboot flash cache cache.img sudo fastboot flash userdata userdata.img sudo fastboot flash system system.img sudo fastboot reboot
