Compiling

Introduction

The goal of this part of the documentation is to give you insight in how to give your Autopilot board a Brain. Airborne autopilot code, flight plans and configuration settings are compiled into a single file, sometimes referred to as a binary image. After compilation this file is transferred to the Autopilot board micro-controller flash ROM through use of an USB cable. Note that most tuning and flight plan parameters can be changed in-flight but after each power cycle, the autopilot reverts to the original settings. Permanent changes are made by recompiling the airborne code and it's new configurations settings, and re-upload this to the autopilot board. It may sound complicated but in fact it is quite simple if you follow the steps below.

Get access to your computers USB port

Regular users, (also known as Non-Root) by default, as security measure, can not access and interact with hardware in- and output- devices (I/O), USB ports included. To make it possible, the user you are using to program the autopilot board must be a member of the plugdev group. Note that usually the original username you used when you installed your Linux OS is already a member.

If you are not already a member, add yourself to this plugdev group with the following command:

 $ sudo adduser $USER plugdev

It will be effective only on your next login or after the command

 $ newgrp -

Udev rules

The Paparazzi device rules are required for flashing and to recognize your modem (with usb adapter) correctly. Copy them into place if you haven't already done so:

 $ sudo cp $PAPARAZZI_HOME/conf/system/udev/rules/50-paparazzi.rules /etc/udev/rules.d/

If you are using Ubuntu with a version older than v9.10, the Braille TTY driver interferes with FTDI USB Serial adapters and should be removed by running the following in the command prompt

$ sudo apt-get remove brltty

Flashing

USB flashing

Example wiring for programming and telemetry

If the autopilot senses a connected USB cable during power-on, it will wait to receive a firmware image rather than booting normally. The firmware can be compiled and flashed by several means, the simplest way using the Paparazzi Center, the traditional way being:

make AIRCRAFT=myplane clean_ac ap.upload
(where myplane is the name of your airframe as defined in conf/conf.xml)

This command erases any compiled autopilot code from the PC, recompiles everything from scratch, and then sends it to the autopilot. Variations include:

• make AIRCRAFT=myplane sim

  Compiles your code for use in the simulator - note that "clean_ac" will remove this code, so the simulator code must be rebuilt each time a clean has been performed.

• make AIRCRAFT=myplane fbw.upload

  This is needed when configuring the separate "fly by wire" MCU on the Classix autopilot.

• make AIRCRAFT=myplane ap

  This will simply build the portions of autopilot code that have changed since the last compile without attempting to flash. Note: this method may not detect certain changes (i.e. changes to the airframe makefile section or CVS updated code).

• make AIRCRAFT=myplane ap.upload FLASH_MODE=IAP

  Specifies USB flashing. This should be specified at the top of the makefile section of your airframe file but can be overridden here. Use FLASH_MODE=IAS for serial flashing.

Serial Flashing

You can also flash via serial cable or modem, but it takes a longer time. You can't just consider the baud rate to estimate the duration of the operation are there are many exchanges in the flashing protocol and the com latency over RF becomes significant.

• make AIRCRAFT=myplane ap.upload FLASH_MODE=ISP

Or add <configure name="FLASH_MODE" value="ISP"/> to the firmware section of your airframe file.

Verify that above upload works

Step 1

Connect an USB cable to the USB port on the autopilot board.

• 

  Board to mini USB connect

• 

  Make sure you have a connector for power (Don't power up yet!)

• 

  Connect USB to PC and Board

• 

  only now, power up the board

Now if you type the following command in your terminal...

$ dmesg | tail -5

..you should see messages that look like:

[79212.484187] pl2303 1-2.3:1.0: device disconnected
[82312.463077] usb 5-1: new high speed USB device using ehci_hcd and address 23
[82327.555770] usb 5-1: device descriptor read/64, error -110
[82342.752307] usb 5-1: device descriptor read/64, error -110
[82342.968031] usb 5-1: new high speed USB device using ehci_hcd and address 24

Which confirms that your device is powered up and working, and ready to accept new airborne code. In case you do not see this message, check your battery voltage and connections and make sure the cables are not broken.

Step 2

Upload the compiled Autopilot code a.k.a, firmware

  $ make AIRCRAFT=DEMO demo2.upload

    make[1]: Leaving directory `/usr/share/paparazzi'
   cd sw/airborne; make PAPARAZZI_SRC=/usr/share/paparazzi PAPARAZZI_HOME=/home/dirkx/paparazzi TARGET=demo2 all
   make[1]: Entering directory `/usr/share/paparazzi/sw/airborne'
   /home/dirkx/paparazzi/var/demo/demo2/demo2.elf  :
   section    size         addr
   .text       956        16384
   .ctors        0        17340
   .dtors        0        17340
   .data         0   1073741824
   .bss         12   1073741824
   .stack     4096   1073742080
   .comment     54            0
   Total      5118
   make[1]: Leaving directory `/usr/share/paparazzi/sw/airborne'
   cd sw/airborne; make PAPARAZZI_SRC=/usr/share/paparazzi PAPARAZZI_HOME=/home/dirkx/paparazzi TARGET=demo2 upload
   make[1]: Entering directory `/usr/share/paparazzi/sw/airborne'
   /usr/share/paparazzi/sw/ground_segment/lpc21iap/lpc21iap  /home/dirkx/paparazzi/var/demo/demo2/demo2.elf
   .
   Found USB device
   BootROM code: 2.12
   Part ID: 0x0402FF25 (LPC2148, 512k Flash, 32k+8k RAM)
   BootLoader version: 1.3
   #
   Starting software at 0x00004000
   make[1]: Leaving directory `/usr/share/paparazzi/sw/airborne'
   make: Leaving directory `/usr/share/paparazzi'

Which confirms that your device has the bootloader functioning. The important bit of output is:

   Found USB device
   BootROM code: 2.12
   Part ID: 0x0402FF25 (LPC2148, 512k Flash, 32k+8k RAM)
   BootLoader version: 1.3
   #

In the rare case your autopilot board does not have a bootloader, read and follow the instruction on how to install a bootloader first

NOTE: In the above example we're using a modified demo - which flashes the LEDs with a Tiny2.1 board): Be aware that the demos involving serial ports do not currently work with Tiny V2's.

Step 3

Observe the LEDs flashing.

Step 4

Disconnect the USB cable, Disconnect the power and reconnect the power of the autopilot board. The LED's should flash again.

Step 5

Select aircraft MJ5, build and upload.

Select airframe funjet1.xml (if you have a Tiny V2)

Connect the serial port of your tiny to your PC using a level converter and select session Flight USB serial@9600.

If you are using funjet1.xml:

• Stop all the processes but do not remove them.
• Edit the line Data Link and add "-s 57600" to the end, to tell the data link the baud rate of the MJ5.
• Restart Data Link, Server and GCS in that order.

If all went well, it should work and you should see messages coming in from the Tiny!

JTAG Flashing

I will be adding more info here as I compile and upload to the Lisa/M board. - cwozny

Installing the tunnel for direct access to the GPS

This completely replaces the normal autopilot code (leaving the USB bootloader intact) with a simple serial-to-serial pass-thru that essentially connects the GPS serial port directly to the modem serial port or a USB-to-serial connection that creates a USB serial port that goes to GPS port or modem port. Use this only to gain direct access to the GPS for testing/configuration with U-Center or other software.

You have to add the tunnel targets to your airframe file if you want to use them:

 <firmware name="setup">
   <target name="tunnel" board="twog_1.0" />
   <target name="usb_tunnel_0" board="twog_1.0" />
 </firmware>

UART tunnel

Use this if you have a serial cable to connect. The LEDs will blink when data is transferred. Type the following command from your paparazzi folder, substituting the name of your airframe and paying attention to case sensitivity:

make AIRCRAFT=myplane tunnel.upload

Connect the USB cable and power on the autopilot to receive the code.

This can be done without the USB bootloader by appending FLASH_MODE=ISP to the command line (specifying ISP serial loading). This will require a serial cable connection (i.e. FTDI USB-to-TTL). WARNING! Installing tunnel code with the ISP method will erase any USB bootloader code. Make sure you are able to install a bootloader yourself.

USB tunnel

This can be done without a serial cable just by having USB. The LEDs will blink when data is transferred. It can connect to either serial port on the autopilot (for Tiny 2.11: uart0=gps, uart1=modem). To connect USB to the gps type the following command from your paparazzi folder, substituting the name of your airframe and paying attention to case sensitivity:

make AIRCRAFT=myplane usb_tunnel_0.upload

Connect the usb cable and power on the autopilot to receive the code. The code will switch the USB to emulate a serial port that you can access at /dev/ttyACMx. Windows user can extract the usbser.sys file from .cab file in C:\WINDOWS\Driver Cache\i386 and store it somewhere (C:\temp is a good place) along with the usbser.inf file. Windows then creates an extra COMx port that you can use in a terminal program or with ucenter. To use the USB tunnel make sure you first power the autopilot before connecting USB not to end up in the USB bootloader.

Firmware Architecture

More info on the firmware architecture
FirmwareArchitecture

Troubleshooting

As a rapidly evolving open-source project, on occasion your software may fail to compile after a git pull. This is most likely due to a new or changed variable name that is now required in your airframe, flight plan or somewhere else. Since the user-configured files are not updated automatically you may need to view the most recently changed sample airframe or flight plan files to find the required changes.