Raspbian Jessie Lite on a New Raspberry Pi Compute Module 3

Your prompt will then change to the root prompt, which should look a little like this:

root@blackbriar:/home/treadstone#

At this prompt type the following:

apt-get install dkms build-essential

This will install some essential compiler and kernel packages so that we can build kernel modules to support the Guest Additions.

Now that we have the groundwork done, we can mount the Guest additions (virtual) CD. We do that by clicking on ‘Insert Guest Additions CD Image…’ using the ‘Devices’ pull-down menu from along the top of VirtualBox.

If things are going your way, you will get a window pop up saying that “VBOXADDITIONS_yourversion contains software intended to be automatically started. Would you like to run it?” At this point, you can hit the Run button to install Guest Additions.

If, however, today happens to be a day that ends in the letter ‘y’, you may find that this doesn’t work for you. So we must fall back to plan ‘B’.

Back in your terminal (logged in as root) change directory:

root@blackbriar:/home/treadstone# cd /media/cdrom

Followed by:

root@blackbriar:/home/treadstone# ls

You should get a listing of your directory that looks like this:

We can now run the installation script with:

root@blackbriar:/home/treadstone# sh ./VBoxLinuxAdditions.run

You should then end up with a printout similar to this:

To get the benefit of these Guest Additions we will need to power down our VM. Click on the little down arrow in the top right-hand corner and hit the power button:

Before you power up your VM again, there are a couple of adjustments we can make that will enhance our enjoyment of our new virtual Linux machine. In VirtualBox, right-click on your virtual machine:

Select ‘Settings…’ and under General -> Advanced we can set things up to allow us to easily share data between host and guest. Set the “Shared Clipboard” and “Drag‘n’Drop” to ‘Bidirectional’.

We can also adjust the system and display settings:

When you’re done with your adjustments, power your VM back up. Hurrah! You have a working Linux Virtual Machine.

Get your terminal up again, as there are another couple of packages that we will want to install before we tackle our Raspberry Pi.

The first package is sudo which allows us to run individual commands as root. So, switch user to root with the ‘su’ command then type:

root@blackbriar:/home/treadstone# apt-get install sudo

This will produce a result similar to this:

We now need to add ourselves to the group of users who can use the ‘sudo’ command:

root@blackbriar:/home/treadstone# adduser treadstone sudo

Replace ‘treadstone’ with your own username. We also need to add ourselves to the ‘sudoers’ file:

root@blackbriar:/home/treadstone# nano /etc/sudoers

Scroll down the file in the nano editor until you find a line which says: “%sudo ALL=(ALL:ALL) ALL” below that line, insert the following

treadstone ALL=(ALL:ALL)ALL

Again, substitute your username for ‘treadstone’. Now hit the [Ctrl] + [x] keys, then press [y] followed by [Enter] to exit and save the file.

Close the terminal window and open a fresh one. We are going to test our new powers out. At your regular command prompt type:

treadstone@blackbriar:$ sudo ls

Enter your password et voila:

All that remains now is to install Git so we can get our Raspberry Pi support from Github:

treadstone@blackbriar:$ sudo apt-get install git-core

Git implements version control using two primary settings:

• A username
• A user's email

So we will configure those now by typing:

$ git config --global user.name "treadstone"

Then:

$ git config --global user.email treadstone@blackbriar.com

Of course, you are again replacing ‘treadstone’ and ‘treadstone@blackbriar.com’ with your own username and email address. We can check that this has been entered correctly with:

$ git config --list

Which should produce an output like this:

Now we are ready for the main event.

Flashing the Raspberry Pi Compute Module 3

The first thing we need is to do is get our USB boot tools for the Raspberry Pi. We get them by cloning the tools from GitHub:

$ sudo git clone --depth=1 https://github.com/raspberrypi/usbboot

When the clone is ready, change directory into usbboot directory and install the USB library:

$ cd usbboot

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

With everything in place, we can use the helpful makefile to build the USB tool we need:

$ sudo make

Now, if you haven’t downloaded your Raspbian OS image into your virtual machine already, do so now from https://www.raspberrypi.org/downloads/raspbian/using the Firefox browser that came with your Debian distro. As we only have a total of 4GBytes, we will need to download the ‘lite’ version.

In the terminal we can copy the download to our current directory:

$ sudo cp ../Downloads/2016-11-25-raspbian-jessie-lite.zip .

Obviously, you will need to adjust this for the filename of the version of Raspbian you downloaded. Note the dot at the end of the command – it represents your current directory in the command so don’t miss it out!

Then we unzip the image:

$ sudo unzip 2016-11-25-raspbian-jessie-lite.zip

You should now have an image file (with the ending .img) to load onto your CM3. There is one final bit of preparation that will make your life much easier. Go to the ‘Activities’ menu and open the ‘Files’ tool (6^thitem down) and navigate to the /dev directory [on the left side, click on computer then click on the ‘dev’ folder]. List the files by when they were modified, and move the window next to your terminal window. We are now ready to load our image. Fire up the QuattroCompute Module I/O board!

When you turn on the power to the board, your PC will probably acknowledge that there is something new on USB. In order for your virtual machine to see it too you will need to find it on the ‘Devices’ menu:

You will find yourself doing this a couple more times during the process. Now that the USB chip is visible, we can run rpiboot:

$ sudo ./rpiboot

This will inject our boot code (usbbootcode.bin), after which we will need to find the next enumeration of the USB connection in the ‘Devices’ menu:

The program then sends a .elf file which will again require us to find the new USB enumeration on the ‘Devices’ Menu:

This is where the file browser comes into its own, as we need to see what name the USB disk has been mounted under. We do this by simply looking for the brand new devices that have just been listed. You may need to manually scroll up to see what has just arrived:

It will usually be sd(something). In our case it is sdb – we only want the first enumeration. We then load our image to this disk with:

$ sudo dd if=2016-11-25-raspbian-jessie-lite.img of=/dev/sdb bs=4MiB

Now we wait… for about 5 to 10 minutes for the filesystem image to load. When it is all done it will report back to us with something like this:

So now we come to the moment of truth.

Power down your Raspberry Pi. Disable the slave USB on header J4 (swap the jumper position as highlighted below) and remove the slave micro-USB connector:

Power up.

When presented with the start-up output leading to the login prompt you are there!

The default user login is: pi with the default password: raspberry

Add Wi-Fi

The last thing we will do today is give our Pi CM3 the chance to communicate with the world by adding a USB Wi-Fi adapter to our USB hub . I am using the Raspberry Pi adapter (892-0012) but there are others (760-3621) for example, that will work just as well.

Luckily, this is quite a simple procedure as the software we need is already on the filesystem. All we need to do is modify a couple of configuration files.

First, let’s find the network we want to attach to. At your command line type:

$ sudo iwlist wlan0 scan

You will be presented with a scrolling list of all the Wi-Fi networks in your locale. If there are a lot of them, you may need to use the paging tool ‘more’:

$ sudo iwlist wlan0 scan ¦ more

Use the spacebar to scroll down one page at a time. You are looking for the ESSID of your network. I am using my iPhone personal hotspot for this example, so my ESSID will show up as “iPhone”.

We now need to add this information and the Wi-Fi password to the wpa-supplicant file using the nano editor:

$ sudo nano /etc/wpa_supplicant/wpa_supplicant.conf

Go to the bottom of the file and add the following:

network={

ssid="Your_ESSID_from_earlier"

psk="Your_wifi_password"

}

So my file ends up looking like this:

ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev update_config=1

network={ ssid="iPhone” psk="password" }

Now we can save this with [Ctrl]-X followed by ‘Y’ and then [Enter].

The other thing we want to do is get the Raspberry Pi to join the network using DHCP so that its IP address is assigned automatically. We do that in the interfaces file:

$ sudo nano /etc/network/interfaces

Your file should look like this:

# Please note that this file is written to be used with dhcpcd # For static IP, consult /etc/dhcpcd.conf and 'man dhcpcd.conf' # Include files from /etc/network/interfaces.d:

source-directory /etc/network/interfaces.d

auto lo iface lo inet loopback

iface eth0 inet manual

allow-hotplug wlan0 iface wlan0 inet manual wpa-conf /etc/wpa_supplicant/wpa_supplicant.conf

allow-hotplug wlan1 iface wlan1 inet manual wpa-conf /etc/wpa_supplicant/wpa_supplicant.conf

We want to change the line:

iface wlan0 inet manual

to

iface wlan0 inet dhcp

Then it’s [Ctrl]-X followed by ‘Y’ and then [Enter] again to save.

Now we are configured, all we have to do is reload the network interfaces:

$ sudo service networking reload

We can check that the network interface is up with:

$ ifconfig

Which should show something like this for wlan0:

wlan0 Link encap:Ethernet HWaddr 80:1f:02:aa:12:58

inet addr:172.20.10.3 Bcast:172.20.10.15 Mask:255.255.255.240

inet6 addr: fe80: :416b:a810:b9b2:be34/64 Scope:link

UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1

RX packets:154 errors:0 dropped:173 overruns:0 frame:0

TX packets:65 errors:0 dropped:0 overruns:0 carrier:0

collisions:0 txqueuelen:1000

RX bytes:32399 (31.6 KiB) TX bytes:13036 (12.7 KiB)

If we have an inet addr that looks good, we are on our way. We can test this further by pinging the Google servers:

$ ping –c10 8.8.8.8

This will transmit and receive 10 packets, which should give us an idea of how good our networking is looking.

Remote Login

One last thing we can do to make our Compute module easier to work with is set it up so that we can remotely log in to it. This means the only things we need to connect to the CMIO board will be the power and the Wi-Fi adapter, allowing us to reclaim our keyboard and monitor for other projects!

At the command line type:

$ sudo raspi-config

This will bring up the configuration utility. Use the arrow keys to navigate to ‘Advanced Options’ and hit [Enter]. Then navigate down to ‘A4 SSH’ and hit [Enter]. To the question “Would you like the SSH server to be enabled?” Select .

You are now enabled. You can connect to your CM3 from other computers on your network. An easy way to test this is to use Puttyon your Windows PC. It is as easy as putting your Pi’s IP address in the ‘Host Name (or IP address) box’ when you start Putty. This will allow you to log into your Pi from a window on your PC.

When you want to connect from your Linux virtual machine, you can use the nmap tool to find your Raspberry Pi and then connect to it.

First, install nmap on your virtual machine in an open terminal:

$ sudo apt install nmap

We want to make sure of the subnet we are operating on so use:

$ hostname –I

This will give us our address which in my case came out as 172.20.10.15

Armed with this information we can check all the other devices connected to this subnet:

$ nmap -sn 172.20.10.0/24

This will run a ping scan that pings all the IP addresses to see if they respond. For every device that responds to the ping, the output shows the hostname and IP address.

Somewhere in the list, we should see:

Nmap scan report for raspberrypi (172.20.10.3)

Host is up (0.0020s latency).

We use that address to login:

$ ssh pi@172.20.10.3

If you get a timeout, recheck your IP address, otherwise, you can log into your Pi remotely any time you like. You are now a Raspberry Pi CM3 Jedi and a galaxy of adventures awaits. May the Force be with you…

Appendix A – Virtual Machines

Modern PCs, even the lower-end offerings, provide more than enough computing power to run multiple operating systems simultaneously. Virtual machine software takes advantage of this power by creating an environment inside which an operating system can be installed. As far as this installed operating system is concerned, it is running on PC hardware. In reality, this ‘guest’ operating system is interacting with software that mimics the responses of hardware, so it is interacting with virtual hardware; i.e. a virtual machine.

By using virtual machine software, a PC that boots up running Windows 10 can also go on to be running Linux, Solaris or Mac OSX. You could even be running venerable operating systems like DOS or OS/2 that would no longer be able to run on modern hardware. This is because you can present the operating system with any virtual hardware you like; even long-retired hardware like floppy disk drives.

As well as allowing you to play the first DOS version of Populous, virtual machines have many other useful raisons d'être, particularly because they are sandboxed ‘container’ environments. This means you can test software (for example, something you think may be a Trojan) in an environment that is separate from your host computer and which can be frozen and restarted at will, rolled back to save points, then copied and shared or backed-up and restarted from scratch. All pretty useful if that suspect file does turn out to be a ransomware downloader that encrypts your filesystem: just bin that virtual machine and use another one that you saved earlier.