Banana Pro Blueprints

Table 1 summarizes the Banana Pro specifications. Everything is available to build a complete computer system, including a hard disk or connection to a television or computer screen. Both the Gb LAN and WLAN guarantee easy integration into networks and fast operation, for example, as NAS. USB sockets allow the usage of a keyboard, mouse, or even DVB receivers (refer to Chapter 4, An Arcade Cabinet). The 40-pin General Purpose Input Output (GPIO) header allows arbitrary experiments that feature different bus systems, such as CAN (Controller Area Network) or SPI (Serial Peripheral Interface). Different LEDs provide board statuses; CSI (Camera Serial Interface) and LVDS (Low Voltage Differential Signaling) interfaces are also available. The CSI interface can be used in order to connect a camera and LVDS interface that can be used for display connection purposes. Even an onboard microphone is implemented. The following are the Banana Pro specifications:

Contrary to many other embedded boards, Banana Pro offers a SATA connector for the direct connection to a 2.5 inch hard disk connection. Moreover, for SSDs or a 2.5 inch hard disk, a power connector is onboard.

Tip

Note the correct polarity of the SATA/DC power connector. Compared to CubieBoard or Cubietruck, Banana Pro uses the concept of changed polarity. Therefore, when ordering a Banana Pro SATA/DC cable, be sure of the DC polarity (Figure 2).

Figure 2: The Banana Pro SATA/DC cable (source: Amazon.com)

All the connectors of Banana Pro are explained in Figure 3. These are as follows:

In addition to the preceding connectors, Banana Pro offers a WLAN module that can also work as an access point. Banana Pro does not supply a real-time clock (RTC). However, there are RTC add-on boards available at http://www.wvshare.com/product/PCF8563-RTC-Board.htm.

Figure 7: The RTC add-on board for Banana Pro. Source: http://www.wvshare.com.

Banana Pro features several LEDs onboard. The red LED lights up as soon as DC power is supplied to the board. The blue LED shows Ethernet activity. The green and blue LEDs can be set individually. Chapter 2, Programming Languages, will show you how these LEDs can be programmed.

Depending on the chosen image, the first boot will take 20 to 30 seconds. The first boot on Android will take much longer, so be patient.

Figure 11: Setting up Banana Pro before the first boot (source: http://www.lemaker.org/cn/product-bananapro-guide.html)

Although Android is based on Linux, both architectures are quite different. This can be seen even in the example of low-level C language routines, which Google exchanged for Android. In addition to this, Google prohibits all code that's licensed under GPL (GNU Public License). For this reason, Android only implements a rudimentary shell featuring only a few shell commands. Due to the C-library incompatibilities, normal Linux code, even if it's especially compiled for the ARM architecture, will not run under Android. Nevertheless, Android is a very popular operating system (OS) that's used by many phones and tablets. It fully supports graphic hardware in terms of accelerated video and 3D graphics. For this reason, the first Banana Pro version of Kodi (formerly known as XBMC and Xbox Media Centre) made use of an accelerated Android graphics library (refer to Chapter 4, An Arcade Cabinet).

Applications for Android can be developed using a special software development kit (SDK) and Java itself as most Android applications are based in Java. Although this book concentrates on Linux projects rather than Android projects, we will take a short look at Android on Banana Pro.

LeMaker provides three different Android images: one for a 5 inch TFT, the second for a 7 inch TFT, and the third using the HDMI cable as a video output. To install an Android OS, simply download the required version. You most probably want to start with the HDMI enabled version. Use PhoenixCard (as seen in the previous section) in order to write the image to an SD card. Insert this SD card and boot Android. After a while, the start screen of Android will be visible.

Figure 14: This is Android 4.4 running on Banana Pi/Pro (http://www.bananapi-kaufen.de/wp-content/uploads/2014/07/800px-Android_v2.jpg)

Android can be controlled by using a keyboard and mouse. Bluetooth and WLAN will work out of the box and some applications are already preinstalled.

Figure 15: Android 4.4 running on Banana Pro (source: bananapi.com)

There are a variety of Linux distributions available on the LeMaker download site (Figure 13). The most famous operating systems are Raspbian, Bananian, Lubuntu, and Gentoo. LeMedia, a special Linux distribution that provides the Xbox media center, Kodi (formerly known as XBMC), is not available on the official LeMaker download website. We will later on compile and install XBMC for other operating systems such as a Debian distribution. No matter which Linux OS you decide on incorporating, the procedure is always the same: Copy the image to an SD card and boot the card within Banana Pro.

After copying the image, the SD card will contain a directory called /boot. This directory contains the Linux kernel (called uImage; refer to Chapter 2, Programming Languages, for this), a file called uEnv.txt, and a binary file (usually script.bin or bananapro.bin). The uEnv.txt file contains kernel parameters, such as screen resolutions, and the binary file contains the complete settings for Banana Pro with respect to all connectors.

My uEnv.txt file looks like this:

console=tty1
root=/dev/mmcblk0p1 rootwait
extraargs=rootfstype=ext4 sunxi_ve_mem_reserve=190 sunxi_g2d_mem_reserve=16
sunxi_fb_mem_reserve=32 hdmi.audio=EDID:1 disp.screen0_output_mode=1920x1080p50 panic=10 consoleblank=0
script=bananapro.bin
kernel=uImage

It defines /dev/tty1 as a console terminal, uses the first partition of an SD card as a root device (/dev/mmcblk0p1), and provides some additional kernel parameters. The video output mode is completely HD progressive (1920x1080p50). The binary file is called bananapro.bin in my case, and the kernel is uImage within the /boot directory. The function of the binary file is described in the next section (the FEX file).

For my experiments, I've used a Banana Pi Linux image of Igor Pečovnik (http://www.igorpecovnik.com/2014/09/07/banana-pi-debian-sd-image/), which I adapted to Banana Pro. In the meantime, the Banana Pi image is compatible with Banana Pro.

I recommend that you download the Debian Wheezy version that comes with kernel 3.4. Although this kernel is not up to date, it enables all the hardware features of Banana Pro as opposed to kernel 4.2, which, for example, neither has an audio driver nor an accelerated video output.

The image itself is based on Debian Wheezy and comes with kernel 3.4. Similar to Bananian, this distribution does not come with any X11 server or display manager. Therefore, I've installed the MATE Windows manager and the slim login manager. Similar to the X11 framebuffer driver, I've used sources from https://github.com/ssvb/xf86-video-fbturbo. This driver requires a number of packages to be installed first as follows:

sudo apt-get install git build-essential xorg-dev xutils-dev x11proto-dri2-dev
sudo apt-get install libltdl-dev libtool automake libdrm-dev autoconf

Now, acquire the sources of xf86-video-fbturbo, compile them, and then install them as follows:

sudo su
cd /usr/local/src
git clone https://github.com/ssvb/xf86-video-fbturbo.git
cd xf86-video-fbturbo
autoreconf -vi
./configure --prefix=/usr
make
make install

Afterwards, copy the default xorg.conf file to the location of your xorg.conf like this:

sudo cp xorg.conf /etc/X11/xorg.conf

Do not forget to back up any existing xorg.conf files first. In Chapter 4, An Arcade Cabinet, we will install accelerated Mali drivers for a desktop in addition to a framebuffer turbo driver.

Figure 16: The MATE desktop environment (source: mate-desktop.org)

MATE needs to be installed from the Debian Wheezy backports. Add deb http://http.debian.net/debian wheezy-backports main to the /etc/apt/sources.list file. This can be done using this command:

sudo nano /etc/apt/sources.list

Afterwards, run the following shell commands:

sudo apt-get update
sudo apt-get upgrade
apt-get install mate-desktop-environment mate-desktop-environment-extras
sudo apt-get install slim

In order to install the MATE desktop and slim, a configuration can be done in the /etc/slim.conf file. I've added/changed the following lines:

sessionstart_cmd xhost + && xset s noblank && xset s off && xset –dpms
default_user	pi
auto_login yes

The first line disables access control to the X-windows server. This is needed later on in Chapter 4, An Arcade Cabinet. In addition to this, screensavers and power management for the X-server are switched off. The second line sets the default user as the pi user. The last line allows the pi user to automatically log in without providing a password.

This user pi can be added to the system using this shell command:

sudo adduser

You need to answer all the questions prompted by the system and use the pi as a username.. Most Linux distributions provide an already secure shell access (ssh). If not, simply install the openssh server by typing the following command that will enable a remote login with ssh on port 22:

sudo apt-get install openssh-server

sudo apt-get install libusb-1.0-0-dev git

git clone https://github.com/linux-sunxi/sunxi-tools
cd sunxi-toolsmake
sudo make install

sudo fex2bin /boot/script.fex /boot/script.bin

[disp_init]
disp_init_enable = 1
disp_mode = 0
screen0_output_type = 3
screen0_output_mode = 4
screen1_output_type = 2
screen1_output_mode = 11
fb0_framebuffer_num = 2
fb0_format = 10
fb0_pixel_sequence = 0
fb0_scaler_mode_enable = 0
fb1_framebuffer_num = 2
fb1_format = 10
fb1_pixel_sequence = 0
fb1_scaler_mode_enable = 0
lcd0_backlight = 197
lcd1_backlight = 197
lcd0_bright = 50
lcd0_contrast = 50
lcd0_saturation = 57
lcd0_hue = 50
lcd1_bright = 50
lcd1_contrast = 50
lcd1_saturation = 57
lcd1_hue = 50

Transferring an OS to a hard disk

Banana Pro cannot boot directly from a hard disk. This section will show you how the Linux operating system can be copied from a microSD card to a hard disk and how a system can boot into the OS of the hard disk.

First, boot your Banana Pro with a connected hard disk (SATA and DC). The kernel messages will show the SATA device (usually /dev/sda). In order to get a filesystem overview, the lsblk command can be used. This command will list the complete filesystem including the attached hard disk.

Verify the contents of the hard disk using the following command:

fdisk –l /dev/sda

Principally, the available hard disk space must be equal to or larger than the size of the SD card in order to host the OS. The fdisk command can be used to partition the disk in terms of erasing or adding hard disk partitions. Use this program with care as it can delete everything that exists on your hard disk. The following steps assume an empty hard disk or a hard disk whose content is not needed any more.

The hard disk can be partitioned using the fdisk command:

sudo fdisk /dev/sda

The p (print) command will print partition table:

Command (m for help): p

Existing partitions can be removed using the d (delete) command:

Command (m for help): d
Partition number (1-6): 1

New partitions can be added using the n (new) command:

Command (m for help): n   
Partition type:
   p   primary (0 primary, 0 extended, 4 free)
   e   extended
Select (default p): p
Partition number (1-4, default 1): 1

The w (write) command writes all changes to the disk:

Command (m for help): w
The partition table has been altered!

After this, the fdisk write command will automatically quit. If no other partitions (for example, swap) are required, you can press RETURN when prompted for the first and last sectors. In its simplest sense, a swap partition serves as an overflow to Banana Pro's memory (RAM). It might be useful when compiling huge software packages such as Kodi (formerly known as XBMC). As an alternative, a file on a hard disk or SD card can be used for swapping. A swap partition itself has the 82 partition ID, which can be changed using the t (toggle) command followed by the ID. Swap partitions can be formatted using the following command:

mkswap /dev/sdaX,

X represents the swap partition (for example, 6). Swap partitions will be activated as follows:

swapon /dev/sdaX

New (empty) partitions must be formatted before usage. The following command formats the first partition (sda1) with the .ext4 filesystem and labels it as rootfs. In doing so, all existing data on this partition will be erased. Therefore, use this command with caution and only format empty partitions or partitions whose content is not needed any more:

sudo mke2fs -t ext4 -L rootfs /dev/sda1

In this step, the complete data from the microSD card will be copied to the hard disk. In our example, the first partition of the hard disk will be mounted into the /mnt directory; rsync will be used to transfer all data to the directory:

sudo mount /dev/sda1 /mnt
sudo rsync -ax / /mnt

The complete copy process will take a while. In the last step, the boot parameters of the uEnv.txt file will be adjusted to use the hard drive. Change root=/dev/mmcblk0p1 in the /boot/uEnv.txt file to this:

root=/dev/sda1

This can be done using the nano editor by typing this:

sudo nano /boot/uEnv.txt

Finally, restart Banana Pro with the following command:

sudo reboot

The system should be redirected from the microSD card to the hard disk right now. A df -h command on my system delivers the following (320 GB of free hard disk space):

Filesystem      Size  Used Avail Use% Mounted on
rootfs          289G  157G  118G  57% /
/dev/root       289G  157G  118G  57% /
devtmpfs        380M     0  380M   0% /dev
tmpfs           128M  280K  128M   1% /run
tmpfs           5,0M     0  5,0M   0% /run/lock
tmpfs           128M  2,3M  126M   2% /run/shm
tmpfs           1,0G  4,0K  1,0G   1% /tmp
/dev/mmcblk0p1   14G   11G  2,4G  83% /media/lime-next 

Tip

If you want to make any changes to uEnv.txt after booting to the hard disk, you will need to mount the SD card first, change into the SD card boot directory, and edit uEnv.txt accordingly:

sudo mount /dev/mmcblk0p1 /mnt
cd /mnt/boot
sudo nano uEnv.txt

The same applies to the installation of a new kernel (refer to Chapter 2, Programming Languages).

The gparted software is a graphical frontend for fdisk and other tools. It is very useful to add, delete, or even resize partitions. It may later be required for backups, where it can be used to shrink a partition, for example, on an SD card in order to use windisk32imager to copy the contents of the SD card to the backup medium.

Figure 17

This table shows the resolution of LeMaker LCDs depending on their panel size:

In dependence of the LCD panel size, LeMaker offers three different binary files that can be used in order to initialize the LCDs while booting (script.bin). The files are available from GitHub (https://github.com/LeMaker/fex_configuration). This GitHub tree provides both FEX files and compiled FEX files (bin files). Be sure to download the ones for Banana Pro as Banana Pi files are also available. Banana Pro files are named banana_pro_Xlcd.bin, whereas, X represents the LCD panel size (3 to 5, 5, or 7 inches, respectively). Copy this file to the first partition of your microSD card and rename it as script.bin (or whatever your bin file is called).

The 7 inch LCD module data is summarized in the following table:

The 7-inch LCD step-by-step guide

In the following section, the installation and operation of a 7 inch LeMaker LCD is described. In the first step, the system will be updated:

sudo apt-get update
sudo apt-get upgrade

Let's look at the software part afterwards. Replace the /boot/bananapro.bin directory with your boot directory and script.bin with your binary startup file:

git clone http://github.com/LeMaker/fex_configuration
cd fex_configuration/
sudo cp bin/banana_pro_7lcd.bin /boot/bananapro/script.bin

Afterwards, edit the /etc/modules file and add the lcd module to it. If the lcd module is already available and commented out using #, simply remove the hash sign as shown in the following screenshot:

Figure 18

After this, power off Banana Pro before installing a cable for the 7 inch LCD. The 7 inch display comes together with a 100 mm and 0.5 mm spacing flexible printed circuit (FPC) cable.

Figure 19: The LeMaker 7 inch LCD with the FPC cable and Banana Pro

Turn the LCD around carefully and gently pull out the brown cable clamp from both ends:

Figure 20

Push the flexible cable carefully. Make sure it is straight and the silver conductive end faces downwards toward the blue circuit board, and blue tape faces upwards (Figure 18). After the cable has been inserted completely, push down on both sides of the cable clamp at the same time.

Installing a cable on Banana Pro is pretty much the same as installing the cable on the preceding LCD module. The cable connects to the CON2 connector of Banana Pro board. Do not use the CON1 camera connector. Again, pull out the cable clamps at both sides and push the cable in from the top. The blue protective tape must face the Ethernet jack, while the conductive fingers at the end of the cable face Banana Pro board (Figure 21):

Figure 21: Connecting the LCD to Banana Pro

After the cable is inserted completely, push down on both sides of the clamp and boot your Banana Pro. You should now see this booting screen on the LCD (refer to Figure 22).

Figure 22: Banana Pi using the 7 inch LCD module

The flex cable that's provided is quite short (100 mm only). If you want a larger cable, you may search the Internet for FPC cable 40 0.5 mm. The LCD is capable of showing the X11 desktop (refer to Figure 23) as well as high-resolution videos in full HD.

Figure 23

Banana Pro shows an H264 video on a 7 inch LCD using mplayer. This will look similar to what is shown in the following image:

Figure 24

Banana Pro camera module (Figure 25) uses an Omnivision 5640 CMOS image sensor in an autofocus module and with an integral IR filter. The camera module connects to Banana Pi board via the CSI (CON1). It fulfils the specifications provided in Table 10.

Figure 25: The Banana Pi/Pro camera module.

The following are the specifications for the LeMaker Banana Pro camera module:

A step-by-step guide to the camera module

The installation of a camera module is as easy as the installation of an LCD module. Firstly, required kernel modules will be inserted and are specifically used by this component:

sudo modprobe ov5640
sudo modprobe sun4i_csi0

The preceding commands load the Omnivision camera kernel driver and the CSI driver. In order to load these drivers permanently, add the ov5640 and sun4i_csi0 modules to /etc/modules using this command:

sudo nano /etc/modules

Tip

If your Linux OS does not have a module called sun4i_csi0, try sun4i_csi instead.

Before installing the hardware to your Banana Pro, make sure it is shut down and disconnected from any power supply. Similar to the LCD module cable, remember to also not touch the silver ends of the camera module flexible cable. The cable, again, is quite short (about 6 cm in length).

The Banana Pro camera module connector is shown in Figure 24. Open the connector and insert the flexible cable carefully (Figure 25).

The connector in Banana Pro is called CON1. Do not use CON2 instead as this is the LCD connector (refer to The LCD module section). Using the wrong connector can cause serious damage to your Banana Pro or the extension board because the pin definitions are completely different.

Open the CON1 connector and put the free end of the camera flexible cable into this connector as shown in Figure 26. Finally, confirm that both ends of the flexible cable are sitting correctly in their sockets. Before using the camera, peel off the plastic foil that covers the lens. The complete arrangement can be seen in the following figure:

Figure 26

The mplayer software can be used in order to test the camera:

sudo apt-get install mplayer
sudo mplayer tv://

On a television, the result would look like what is shown in the following image:

Figure 27

Although Banana Pro has been available since the end of 2014, there are already a few cases available. Most cases are acrylic cases (refer to this image):

Figure 28: The Banana Pro acrylic case (source: Amazon.com)

Lenovator offers a case that can integrate both Banana Pro and a 2.5 inch hard disk drive (Figure 29). The case allows the mounting of the original LeMaker Wi-Fi antenna that's provided together with Banana Pro.

Figure 29: The Lenovator Banana Pro case with a hard disk bay

Banana Pro uses an onboard U.FL connector (refer to Figure 30). The female U.FL connectors are not designed with reconnection in mind, and they are only rated for a few reconnects before replacement is needed.

Figure 30: Banana Pro onboard the UFL antenna connector (source: Wikipedia)

For those of you who do not want to integrate a hard disk into a case, the acrylic case of Allnet may be a good choice. The case comes with an R-SMA 5 dBi omnidirectional antenna and adapter cable from U.FL to R-SMA.

Figure 31: The Banana Pro acrylic case with the 5 dBi antenna and R-SMA connector (source: the Allnet shop)

Lenovator provides a general purpose input/output (GPIO) interface called LN digital. LN digital is designed to plug in Banana Pro's GPIO header

GPIO can be used for input (such as reading sensor information) and output (such as controlling relays and motors). So, the peripherals you buy are typically either input or output devices for GPIO. This extends the basic functionality that are offer from the GPIO on the Pi. The board offers the following:

It can be plugged directly into Banana Pro GPIO socket and programmed in Python, Scratch, or C (refer to Chapter 2, Programming Languages).

Figure 32: The LN digital interface board for Banana Pro

Banana Pro provides an onboard microphone. Recordings can be made using this command:

sox -t alsa default output.wav

The preceding command requires sox to be installed. If sox is not available, it can be installed using this command:

sudo apt-get install sox

Press Ctrl + C to stop the recording. The recording will be saved as output.wav in the current directory. Recordings can be listened to using this command:

mplayer output.wav

The microphone sensitivity can be set using the following command:

alsamixer

The complete audio installation and settings will be explained in detail in Chapter 4, An Arcade Cabinet.

Figure 33: Setting the microphone sensitivity using alsamixer