Skip to content
No description, website, or topics provided.
Shell Python
Branch: master
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
README.md
Vagrantfile
build_cross_gcc.sh
playbook.yml
tool.py

README.md

Introduction

Note #1: this has been rewritten for OpenFrameworks 0.9 and RPI2 (armv7) on Raspbian Jessie mostly based on work by @jvcleave

Note #2: you can ignore all the NFS booting stuff here if you aren't planning to NFS boot your Pi. This system works great as a cross-compiler only

This package uses Vagrant and Ansible to spin up a virtual machine that runs on Mac, Linux, or Windows(?). In no time at all, you'll have an environment that:

  • Cross-compiles for the Raspberry Pi armv7l architecture.
  • NFS boots one or more Raspberry Pis. The root partition is loop-mounted from a .img file, so you can later dd it to an SD card for standalone operation.

Here, Vagrant automates the process of setting up a Virtualbox virtual machine and Ansible automates the process of setting up the cross-compiler, the NFS server, and OpenFrameworks.

Why cross-compile?

The Raspberry Pi is slow. This environment will let you compile OpenFrameworks applications on your fast desktop.

Though I built this virtual machine with OpenFrameworks in mind, it'll work just fine for any cross-compiling task.

Why NFS-boot?

If you're writing code that runs on a single Raspberry Pi, NFS-booting lets you edit code locally on your desktop. There's no need to SSH into a Pi to edit and compile.

Because the root partition is loop-mounted from a .img file, you can later create a standalone SD card by merely dd'ing it SD cards.

The magic comes when you're building a cluster of Raspberry Pis. There's no need to rsync or to reflash a stack of SD cards. The latest code is accessible on every Pi at all times. At Two Bit Circus, a common design pattern is to have a cluster of NFS-booted Raspberry Pis all choreographed by a single Linux server. This virtual machine serves as the starting point for that design pattern.

Instructions

Prerequisites

  1. Install VirtualBox. Or Parallels. I actually use this with Parallels.
  2. Install vagrant.
  3. Install Ansible. I used pip.

Other Dependencies

  1. Clone this repository and cd into it.
  2. Download your preferred Raspberry Pi SD card image. I'm using 2015-09-24-raspbian-jessie.img.
  3. Download OpenFrameworks-0.9 for armv7. Leave it compressed.

Get the image ready

If you're looking for a cross-compiler solution, chances are you already have an SD card with oF installed. But just in case...

  1. Burn 2015-09-24-raspbian-jessie.img to an SD card and boot a Raspberry Pi.
  2. Download and unarchive OpenFrameworks.
  3. Run install_dependencies.sh.
  4. Remove the card from the Raspberry Pi and use dd to make an image file.
  5. Only do this if your card isn't based on 2015-09-24-raspbian-jessie.img. Calculate the offsets to the boot and root partitions on the file. I've included a tool to calculate these for you automatically (only works on OS X). Run ./tool.py offsets <my_image.img>.
  6. Copy the output of this tool to the top of playbook.yml.

Create the virtual machine

Want to NFS boot multiple Raspberry Pis?

if not, then skip this section

  1. Edit Vagrantfile and uncomment the config.vm.network line.
  2. Create a wired ethernet network. I use a USB Ethernet adapter on my Macbook. On my Mac (host machine) the IP/netmask is 10.0.0.2/255.0.0.0. The IP address of the virtual machine is hard-coded to 10.0.0.1 (in the Vagrantfile).

Bring up the virtual machine

  1. Type vagrant up. If you're netbooting, choose the wired adapter to bridge to.
  2. The machine will start and provision itself. If there's an error and the provisioning doesn't complete, you can type vagrant provision to retry the provisioning process.
  3. Get a cup of coffee. It'll take awhile.
  4. Type vagrant ssh to connect to and begin using your new environment.

Cross-compile!

When you're ssh'ed into your virtual machine, you can access the root partition in /opt/raspberrypi/root. Dig deeper, and you'll find /opt/raspberrypi/root/opt/openframeworks. This is the armv7 OpenFrameworks directory, uncompressed and ready to go. It's symlinked to /opt/openframeworks for simplicity.

From your vagrant shell:

cd /opt/openframeworks/apps/myApps/emptyExample
make

From your Raspberry Pi:

cd /opt/openframeworks/apps/myApps/emptyExample
bin/emptyExample

You can use rsync to sync your cross-compiled application to a running Raspberry Pi. I usually use something like this:

rsync -avz ./ pi@10.0.0.100:my_awesome_app

For NFS booters only

The provisioning process in the preceding section has modified your SD card image to enable NFS booting. We need to write the boot partition and not the root partition to an SD card. Insert an SD card into your computer. It can be tiny. We're only writing about 60MB to it.

  1. On OSX I've written a tool to help make bootable cards: ./tool.py netboot image.img /dev/rdiskX [--ip=10.0.0.Y]
  2. On Linux: dd if=image.img of=/dev/rdiskX ibs=512 obs=1m count=<root_offset_sectors>. The root offset is the offset of the root partiion from before, but divided by 512. On my SD card, that number is 122880. This particular incantation only copies the first partition (the boot partition) to the SD card. We don't want a root partition on this card, because it'll be using the NFS share.
  3. Examine the cmdline.txt file in the newly minted SD card. It assigns the static IP address 10.0.0.101 (which you can change for subsequent cards) and designates 10.0.0.1 as the NFS server

It's worth noting that the ansible provisioning process has already altered the /etc/fstab on the root partition on the SD card image to inhibit mounting the root partition from the SD card.

NFS boot your Pi

  1. Put the card in a Pi, connect it to the hard-wired network, and turn it on.

Many Raspberry Pis

Want to run a network of Raspberry Pis all with the same codebase, or with access to the same shared media? Flash some more SD cards. Change cmdline.txt to set a different IP address for each. They'll all boot up and have access to that same root partition.

Standalone Raspberry Pi

Are you finished developing and want to flash a stand-alone SD card that doesn't require NFS booting? Simply dd the entire image.img file to an SD card. You've been editing that image all along!

There's some things you'll have to do first:

  1. On the Raspberry Pi root partition, alter /etc/fstab and restore the mount point for /
  2. On the Raspberry Pi boot partition, remove the stuff after "rootwait"

Simultaneously develop on your desktop and the Raspberry Pi

If you put an OpenFrameworks project in the rpi-build-and-boot directory, and change config.make to point the OpenFrameworks root at /opt/openframeworks, you can compile in XCode on the Mac side AND compile from the /vagrant directory.

Notes

  • HACK I create a file in /etc/cron.d that tries to mount /opt/raspberrypi/root every minute. I tried to make an upstart job, but upstart is... difficult.
You can’t perform that action at this time.