The PINE64 is finally here

1GB PINE64 with the WiFi module and RTC battery module installed. It's huge!

I received my PINE64 yesterday and I was pretty excited after such a long wait. The following items were in the package:

PINE64 1GB board
Camera module
RTC battery module (which is actually bigger than I expected)
WiFi/Bluetooth module

They were all in good shape, and the board was not bent nor warped which I was afraid would happen after reading a few horror stories. The Pine64 is most definitely a huge board (compared to the Raspberry Pi), and the build quality also seems solid. I was able to burn the longsleep Ubuntu Xenial image to a 32GB microSD card, and since I wanted to run the board as a headless device, I mounted the microSD on my Linux box and updated the /etc/network/interfaces file to connect to my wireless network. The connection to the network was established a few seconds after providing power to the board and I was able to SSH into the device after the boot process was successfully completed.

I’ll update this post with a few pictures once I get a decent camera.

Update

1GB PINE64 with the WiFi module and RTC battery module installed. It’s huge!

PINE64 side-by-side with a Raspberry Pi 3 and the Keyestudio Mega clone

Building MonoDevelop for the Raspberry Pi 3

4 Dec 2017 Update
I ran into some issues building the latest github versions of Mono and MonoDevelop on the PINE64, and I guess the same may apply here. If you encounter any difficulty building either Mono or MonoDevelop, you can try using the specific versions listed below. You can checkout the specific tags immediately after cloning the corresponding repositories before you start building.
Mono 4.8.1.0 – git checkout tags/mono-4.8.1.0
MonoDevelop 6.1.0.5441 – git checkout tags/monodevelop-6.1.0.5441

Since I will be using C# for most of my development (with a combination of C for some native system functionality), I decided to go with Mono. This guide is based on the assumption that you’re running the May 2016 Raspbian Jessie Lite image. The easiest way to get MonoDevelop up and running would be to run sudo apt-get install monodevelop which would also handle all the necessary dependencies including the Mono runtime. However, the versions in the repository are pretty old, and I want to be able to make use of .NET 4 features.

Another option for .NET development on Linux is .NET Core. Version 1.0 was officially announced by Microsoft a few days ago, but there aren’t ARM binaries available and I haven’t been able to successfully build it for the Pi, yet.

Git
The Mono project code is hosted on Github, so the first thing to be done is to install git.

sudo apt-get install git

1	sudo apt-get install git

Build Mono
Obtain the source code from the Github repository using the command

git clone https://github.com/mono/mono

1	git clone https://github.com/mono/mono

Then install the Mono build process prerequisites.

sudo apt-get install autoconf autotool libtool libtool-bin

1	sudo apt-get install autoconf autotool libtool libtool-bin

You can follow the build instructions in the README.md for the repository at https://github.com/mono/mono/blob/master/README.md. To summarise, change to the source root directory (cd mono) and run the following commands.

./autogen.sh --prefix=/usr
make get-monolite-latest
make
sudo make install

./autogen.sh --prefix=/usr

make get-monolite-latest

make

sudo make install

If you wish to run the mono and mcs test suites, you can do a make check before make install. The build will take quite a while, so you have to be patient. I didn’t time my build, but my best guess would be about 3 to 4 hours.

Build FSharp
MonoDevelop apparently requires the F# compiler to be installed. First thing to do is to import trusted root certificates required by the NuGet package manager into the machine store. The NuGet package manager retrieves certain required packages as part of the build process, so this is required.

sudo mozroots --import --sync
sudo certmgr -ssl -m https://nuget.org

1 2	sudo mozroots --import --sync sudo certmgr -ssl -m https://nuget.org

Next, we clone the FSharp git repository and build.

git clone https://github.com/fsharp/fsharp
cd fsharp
./autogen.sh --prefix=/usr
make
sudo make install

git clone https://github.com/fsharp/fsharp

cd fsharp

./autogen.sh --prefix=/usr

make

sudo make install

Build additional MonoDevelop dependencies
MonoDevelop also requires gtk-sharp and gnome-sharp to be installed on the system. The first step is to install the rest of the apt dependencies for all three packages.

sudo apt-get install cmake libgtk2.0-dev libglade2-dev libgnomecanvas2-dev libgnome2-dev libgnomeui-dev libssh2-1-dev devscripts

1	sudo apt-get install cmake libgtk2.0-dev libglade2-dev libgnomecanvas2-dev libgnome2-dev libgnomeui-dev libssh2-1-dev devscripts

devscripts will be used to create a package of PCL Assemblies which is required for the MonoDevelop build process.

Once the dependencies have been installed, gtk-sharp should be built first and then gnome-sharp.

To build gtk-sharp

git clone -b gtk-sharp-2-12-branch --single-branch https://github.com/mono/gtk-sharp
cd gtk-sharp
./bootstrap-2.12 --prefix=/usr
make
sudo make install

git clone -b gtk-sharp-2-12-branch --single-branch https://github.com/mono/gtk-sharp

cd gtk-sharp

./bootstrap-2.12 --prefix=/usr

make

sudo make install

And gnome-sharp

git clone https://github.com/mono/gnome-sharp
cd gnome-sharp
./bootstrap-2.24 --prefix=/usr
make
sudo make install

git clone https://github.com/mono/gnome-sharp

cd gnome-sharp

./bootstrap-2.24 --prefix=/usr

make

sudo make install

Build MonoDevelop
If you made it through all of that, you can finally proceed to build MonoDevelop. But there are a few caveats which we’ll cover in a bit.

git clone https://github.com/mono/monodevelop
cd monodevelop
git submodule update --init --recursive
./configure --prefix=/usr --profile=stable --disable-nls

git clone https://github.com/mono/monodevelop

cd monodevelop

git submodule update --init --recursive

./configure --prefix=/usr --profile=stable --disable-nls

The first error I encountered after I running make was an issue with NuGet not finding a number of packages. To fix this while your current directory is the monodevelop directory, run the following commands and then run make again (if you’ve run it previously).

cd main/.nuget
mono NuGet.exe update -self
cd ../../

cd main/.nuget

mono NuGet.exe update -self

cd ../../

The next error stated that certain PCL Assemblies were missing. To sort this out

git clone http://github.com/directhex/xamarin-referenceassemblies-pcl
cd xamarin-referenceassemblies-pcl/debian
nano control

git clone http://github.com/directhex/xamarin-referenceassemblies-pcl

cd xamarin-referenceassemblies-pcl/debian

nano control

Remove mono-xbuild from the list of dependencies in the control file, save and close. Then continue with the following commands.

cd ..
debuild -i -us -uc -b
cd ..
sudo dpkg -i referenceassemblies-pcl_2014.04.14-1_all.deb

cd ..

debuild -i -us -uc -b

cd ..

sudo dpkg -i referenceassemblies-pcl_2014.04.14-1_all.deb

The final error had to do with the fsharpbinding regarding missing references in a particular assembly. Since I don’t need the F# bindings, and it’s not a required feature, I removed it from the build process using the following steps (assuming the monodevelop source directory is the working directory).

cd main
nano Makefile.am

1 2	cd main nano Makefile.am

Remove the external/fsharpbinding/MonoDevelop.FSharpBinding/FSharpBinding.addin.xml \ line, save the file and close.

rm -r external/fsharpbinding
cd ../

1 2	rm -r external/fsharpbinding cd ../

Finally, you can build and install.

make
sudo make install

1 2	make sudo make install

This build will also take a bit of time, so sit back, relax and rest easy. Once the installation is complete, you can simply run it by typing monodevelop at the command line (assuming you have X11 forwarding enabled in your SSH session).

Getting started with the Raspberry Pi 3

It’s taken quite a while for my PINE64 to arrive. Apparently, the shipping was delayed because the addon camera module was not ready yet. Quite disappointing, but I guess it’s to be expected since it’s a Kickstarter project. In the mean time, I decided to grab a Raspberry Pi 3 so that I could start off with my autonomous robot project.

I started off with the Raspbian Jessie Lite image which is a 292MB download (May 2016 version). Got it set up on a Sandisk 32GB microSD card and booted it up. I was planning to connect to it using a USB to TTL serial cable as I don’t have any USB peripherals available, nor an Ethernet cable. The plan was to configure the wireless connection so that I could SSH into it (and use X forwarding for GUI applications) once it booted. This did not go smoothly, and it took quite some time to figure out since a lot of the information online only applies to the earlier Pi models.

It turns out the default Raspbian image for the Pi 3 does not support serial connections out of the box due to the in-built Bluetooth module, so I had to make some adjustments to get this to work. Hence, this is sort of a beginner’s mini guide to working with a headless Raspberry Pi 3. The following instructions will require a Linux box.

So how do you get Pi 3 serial to work?
Note that these instructions are based on the May 2016 Raspbian Jessie Lite image. I mounted the SD card on my laptop’s Ubuntu installation, and had to chroot into it (following instructions at https://hblok.net/blog/posts/2014/02/06/chroot-to-arm/) to run a few updates. Inserting the SD card will create 2 mount points: the /mnt/boot/ partition and the main partition which we’ll refer to as /mnt/main/ (note that the path to the mount points may be different depending on your Linux distribution, so verify). After mounting, run the following commands.

Before you can chroot, you need to be able to run ARM binaries using qemu.

sudo apt-get install qemu-user-static
sudo cp /usr/bin/qemu-arm-static /mnt/main/usr/bin
sudo cp /etc/resolv.conf /mnt/main/etc/resolv.conf
sudo mount -o bind /mnt/boot /mnt/main/boot
sudo mount -o bind /dev /mnt/main/dev
sudo mount -o bind /proc /mnt/main/proc
sudo mount -o bind /sys /mnt/main/sys

sudo apt-get install qemu-user-static

sudo cp /usr/bin/qemu-arm-static /mnt/main/usr/bin

sudo cp /etc/resolv.conf /mnt/main/etc/resolv.conf

sudo mount -o bind /mnt/boot /mnt/main/boot

sudo mount -o bind /dev /mnt/main/dev

sudo mount -o bind /proc /mnt/main/proc

sudo mount -o bind /sys /mnt/main/sys

Next, register the ARM executable format with the QEMU static binary.

echo ':arm:M::\x7fELF\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x28\x00:\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:/usr/bin/qemu-arm-static:' > /proc/sys/fs/binfmt_misc/register

1	echo ':arm:M::\x7fELF\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x28\x00:\xff\xff\xff\xff\xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\xff:/usr/bin/qemu-arm-static:' > /proc/sys/fs/binfmt_misc/register

Now, you can chroot into /mnt/main

sudo chroot /mnt/main

1	sudo chroot /mnt/main

If you get an error stating that ‘/bin/bash’ was not found, you may have to run

sudo chroot /mnt/main qemu-arm-static /bin/bash

1	sudo chroot /mnt/main qemu-arm-static /bin/bash

Once you’ve chrooted in, update the system.

apt-get update
apt-get upgrade
apt-get dist-upgrade

apt-get update

apt-get upgrade

apt-get dist-upgrade

If you get an error along the lines of qemu: uncaught target signal 4 (Illegal instruction) - core dumped, edit /etc/ld.so.preload and comment out the lines in the file.

Next, you’ll need to install and run rpi-update.

apt-get install rpi-update
rpi-update

1 2	apt-get install rpi-update rpi-update

Once the update is completed, edit the /boot/config.txt file. Add these lines to the end of the file and save.

enable_uart=1
dtoverlay=pi3-miniuart-bt

1 2	enable_uart=1 dtoverlay=pi3-miniuart-bt

Unmount the microSD card and insert it into your Pi. Connect the appropriate pins for your Pi using your USB-to-TTL serial cable and plug it into your host. Instructions for this can be found at http://workshop.raspberrypiaustralia.com/usb/ttl/connecting/2014/08/31/01-connecting-to-raspberry-pi-via-usb/. Note that if you’re going to use an external power source, you do not need to connect the 5V pin from the serial cable. Connecting to the 5V pin while an external power source is connected may damage your Pi, so be careful!

You should then be able to access your Pi using screen (or your preferred serial client). Note that /dev/ttyUSB0 is the port attached after the cable was connected. To find out what port your USB cable is attached to, you can run dmesg | tail after you connect the cable.

screen /dev/ttyUSB0 115200

1	screen /dev/ttyUSB0 115200

If you see a blank screen, your Pi has probably already finished booting up, so just type your login username and press Enter. Alternatively, you can reboot your Pi (without disconnecting the USB cable from your host) and then you should be able to see the boot messages in the serial console before the login prompt is displayed.

Configure Pi 3 WiFi from the command line
After you’re logged in, you’ll need to configure your WLAN connection. Just edit /etc/wpa_supplicant/wpa_supplicant.conf and add the following lines replacing [networkssid] and [key] with the WiFi SSID and the access key respectively:

network={
    ssid="[networkssid]"
    psk="[key]"
}

network={

ssid="[networkssid]"

psk="[key]"

}

Save the file and then run the following commands

sudo ifdown wlan0
sudo ifup wlan0

1 2	sudo ifdown wlan0 sudo ifup wlan0

Next, check if the connection was successfully established. If you see inet addr after running the ifconfig command, then you’re connected to the network and you can SSH in (after raspi-config) from a different device on the network.

ifconfig wlan0

1	ifconfig wlan0

Enable I2C and SSH with raspi-config
With raspi-config, you can make a number of configuration changes to your Pi 3. Enabling SSH is required for remote access and I plan to use I2C to connect to an Arduino Mega in order to control the pins, so I2C has to be enabled as well. To enable both, launch raspi-config.

sudo raspi-config

1	sudo raspi-config

Then select Advanced Options, and then enable the SSH and I2C options. You can also explore the other configuration settings and modify them to suit your needs.

What now?
That’s it! I will be writing about the software I’m installing on the Pi 3 relating to my autonomous robot project over the next few posts. I will also create posts related to the PINE64 once I have the board in my hands. Hopefully, very soon!