Quick Start for NanoPi

1. Quick Start for NanoPi

1.1 What you will need

• One NanoPi Board
• MicroSD/TF Card - Recommend an 8GB MicroSD card, you can buy a card with linux system pre-install, or install the system with the follow step.
• MicroUSB Cable
• a Host running Ubuntu and connected to the internet

1.2 Created a MicroSD Card with Debian system

1. Insert your microSD 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. Flash Firmware to MicroSD Card

   git clone https://github.com/friendlyarm/sd-fuse_nanopi.gitcd sd-fuse_nanopisu./fusing.sh /dev/sdx

   Notice: replace the /dev/sdx to your MicroSD card inode.

1.3 Run the system

1. Insert the MicroSD system card into the NanoPi.
2. Connect the MicroUSB cable from PC to NanoPi, the NanoPi will boot the debian system auto.
3. when the NanoPi Blue LED light on, it means the NanoPi have run the system success.

2 Play with the NanoPi

 2.1 Using the SSH session via USB Cable Connect

1. Connect the Micro USB cable, and the NanoPi have run the system.
   On the PC command line, run the dmesg command, then you will get the follow info, then it means connect success, 

   [12601.100339] usb 2-1.7: Product: FriendlyARM Gadget v2.4
   [12601.100343] usb 2-1.7: Manufacturer: Linux 4.1.2-FriendlyARM with s3c-hsudc
   [12601.103192] cdc_acm 2-1.7:2.0: This device cannot do calls on its own. It is not a modem.
   [12601.103368] cdc_acm 2-1.7:2.0: ttyACM0: USB ACM device
   [12601.105300] cdc_ether 2-1.7:2.2 usb0: register 'cdc_ether' at usb-0000:00:1d.0-1.7, CDC Ethernet Device, 46:a1:e7:6d:5c:32

2. If you run the command "ifconfig", you will find the usb0, then you can connect it with the SSH command to login the NanoPi(192.168.100.1):

   ssh root@192.168.100.1

   It required the password, input the password fa.

 2.2 Configure the WiFi connection

1. After you connect the board by SSH(The default system is Debian), then run the follow command to check the WiFi device:

   ifconfig -a

   If the Wlan device is wlan0, you should create the same name file "wlan0" in the /etc/network/interfaces.d/, as the follow command:

   vi /etc/network/interfaces.d/wlan0

   Add the follow content in wlan0  

   auto lo
   iface lo inet loopback
   auto wlan0
   iface wlan0 inet dhcp
   wpa-driver wext
   wpa-ssid YourWiFiESSID
   wpa-ap-scan 1
   wpa-proto RSN
   wpa-pairwise CCMP
   wpa-group CCMP
   wpa-key-mgmt WPA-PSK
   wpa-psk YourWiFiPassword

   Notice: the "YourWiFiESSID" is your WiFi AP name, "YourWiFiPassword" is your WiFi Ap password, replace it. then save the file and restart the Network as the follow command:

   /etc/init.d/networking restart

   Then it will connect the WiFi AP when boot the system.
2. If you use the Rabbit linux system run the follow command the configure the WiFi.

   wpa_passphrase YourWiFiESSID 'YourWiFiPassword' >> /etc/wpa.conf
   wpa_cli -iwlan0 reconfigure 

   Notice: The WiFi Router name is YourWiFiESSID , the password is YourWiFiPassword, after you configure it, the board will save the wifi configure info, and will connect the WiFi auto when boot the system for everytime, if you want the change the WiFi saved configure, you can edit the file "/etc/wpa.conf" to reset the WiFi info.
   The default WiFi connecttion configure is DHCP, if you want to configure the wifi with static IP, you can edit the /usr/sbin/wpa_action, and replace the "udhcpc" to "ifconfig" command. For the DHCP or Static IP demo in the /usr/sbin/wpa_action, click here to see the demo file.

3. If you want to scan the WiFi AP device, run the follow command to Scan it:

   wpa_cli -iwlan0 scan
   wpa_cli -iwlan0 scan_result

2.3 Install the Debian software package

1. We provide the stand Debian jessie, you can run the apt-get to install the software, for the first time, you can udpate the source list as follow command:

   apt-get update

2. Then you can install the software as follow， such as install the ftp server

   apt-get install vsftpd

NanoPi development Manual

1. Setup ARM Cross Compiler

1.1 Download and uncompress the ARM Cross Compiler

1. Run the follow command to download the Cross Compiler from our git webserver.

   git clone https://github.com/friendlyarm/prebuilts.gittar xvzf prebuilts/gcc/arm-linux-gcc-4.4.3.tar.gz -C /

1.2 Install Cross-Compile tools

1. Modify your ~/.bashrc file to add a new path with editor (gedit or vi)

   gedit ~/.bashrc

2. add the follow into the .bashrc file

   export PATH=/opt/FriendlyARM/toolschain/4.4.3/bin/:$PATH

3. To apply this change, login again or restart the .bashrc

   source ~/.bashrc

2 Build U-Boot from sources

2.1 Download and Build U-Boot

• You can easily download U-Boot source code from FriendlyARM GitHub U-Boot repository.
• clone the GitHub U-Boot repository, and Build U-Boot binary.

  git clone https://github.com/friendlyarm/uboot_nanopi.gitcd uboot_nanopigit checkout nanopimake nanopi_configmake

  The result of these operations is a fresh U-Boot binary called u-boot.bin

2.2 Update the u-boot.bin to MicroSD card.

• If you want to test the u-boot.bin, you can use the shell fusing.sh to do it, if your MicroSD card inode is /dev/sdd, then do it with root user as the follow command:

  su./fusing.sh /dev/sdd

3 Build Linux Kernel

3.1 Download and Build Linux kernel

• clone the GitHub Kernel repository, and Build Kernel binary.

  git clone https://github.com/friendlyarm/linux-4.x.y.gitcd linux-4.x.ygit checkout nanopi-v4.1.ymake nanopi_defconfigtouch .scmversionmake

  The linux kernel Branch for NanoPi is nanopi-v4.1.y, you should switch the branch to nanopi-v4.1.y, then build it, you will get the kernel programming file arch/arm/boot/zImage.

3.2 Build the Linux Kernel Module

• When the linux kernel was compiled, some kernel module file(such as ipv6, netfilter) were built default, it have created the ko file.
• If you want to add or edit the kernel module, you need compile the kernel module and compress it as kernel-modules.tgz file, and replace the basefs/kernel-modules.tgz on the Rootfs folder.
• Run the followed command with root user, install the .ko file to /tmp/nanopi-modules

  make INSTALL_MOD_PATH=/tmp/nanopi-modules modules_install

• Then strip the Linux kernel module, creat the compress lib

  cd /tmp/nanopi-modules/lib/ find . -name \*.ko | xargs arm-linux-strip --strip-unneeded tar czvf kernel-modules.tgz modules/

• If you want to test the new kernel module, uncompress the kernel-modules.tgz to lib folder on the nanoPi MicroSD system Card.

  rm -rf /media/fa/NANOPI/lib/modules/ tar xzvf kernel-modules.tgz -C /media/fa/NANOPI/lib/

  The Rootfs Partition on the MicroSD card was mount on the /media/fa/NANOPI folder.

4 Created the File system

4.1 Build the Debian file system

1. The pre-install Debian system is the standard debian insatll package, you can download with the follow command

   git clone https://github.com/friendlyarm/sd-fuse_nanopi.gitcd sd-fuse_nanopi/prebuilt/ ls -l rootfs.tgz

2. If you want to do your own Debian system, you can upcompress the rootfs.tgz and edit it, then recompress it again, such as install a deb software package with the follow command:

   tar xzf rootfs.tgz dpkg -i --force-all --root=./rootfs /tmp/qtembedded-4.8.5_armel.deb tar czf rootfs.tgz rootfs

4.2 Create the Rabbit Linux

We provide a sample file system, we called it as Rabbit Linux, If you want to build it, you can run the follow command:

1. User the root user, then Download the Rootfs source code and Build it

   git clone https://github.com/friendlyarm/rootfs_nanopi.gitcd rootfs_nanopigit checkout nanopisu make && make install && make strip

2. When build success, it will show the follow info

   RootFS (core) successfully installed to:
      /tmp/FriendlyARM/nanopi/rootfs
    
   Copyright 2015 FriendlyARM (http://www.arm9.net/)

3. The above info show the rootfs was created on the /tmp/FriendlyARM/nanopi/rootfs folder, we compress it

   cd /tmp/FriendlyARM/nanopitar czvf rootfs.tgz rootfs/

5 Created a MicroSD Card with Compiled system image

5.1 Created the MicroSD card

1. Download the SD card Tools lib, and switch it to master branch.

   git clone https://github.com/friendlyarm/sd-fuse_nanopi.gitcd sd-fuse_nanopigit checkout master

2. The system image was in the prebuilt folder(The prebuilt folder was in the sd-fuse_nanopi folder).
   >>u-boot.bin : System Bootloader image file
   >>sdenv.raw : U-boot Boot Parameter, for booting the system
   >>zImage : Linux kernel image file
   >>rootfs.tgz : the Root file system compress lib
   Replace them with your compiled system image file, then run the follow command on the sd-fuse_nanopi folder:

   su./fusing.sh /dev/sdx

   Notice: the /dev/sdx was your MicroSD card inode on the PC
3. Then insert the MicroSD card to the NanoPi, try it.

5.2 Update the U-boot Boot Parameter 

• If you update the U-Boot boot Parameter on the U-Boot command line, and want to use it in the new SD card, you should save it and replace the sdenv.raw file in the Rootfs prebuilt folder.

  ./readenv.sh /dev/sddcp sdenv.raw prebuilt/

Buy Now