RT Paparazzi

Real Time (RT) Paparazzi

Introduction

the RT Paparazzi initiative is a step towards extended flexibility for the core autopilot. In a real time operating system (RTOS) [1] multiple threads are available, which are doing specific jobs e.g. a telemetry thread, a radio thread, a failsafe thread, at a defined rate. Unlike bare-metal application which uses interrupt driven timers for timing tasks, real time OS has a kernel which takes care of scheduling and running the threads. Having a kernel, it is possible to set priority of each thread, how much memory it takes etc.etc. which gives the developer more control over timing and resource managment.

Besides kernel, a typical RTOS also has a harware abstraction layer (HAL) which stands between user application and actual hardware, so the core autopilot developer doesn't have to worry to much about writing drivers for the sensor to use.

One of the strengths of Paparazzi is it's modularity - combining this with precise timing, scheduling and resource management a RTOS brings along, Paparazzi is now in a position to exceed even the leading commecial closed-source UAs autopilots.

Paparazzi with ChibiOS/RT

RT Paparazzi is based on ChibiOS/RT [2]. ChibiOS/RT supports basically all architectures that standard Paparazzi does (see [3]), which makes both systems compatible. Since RTOS makes handling multiple I/O easier, but comes with some extra overhead (context switching, kernel code), it gives most leverage to to STM32 F1xx and F4xx based autopilots (Apogee/v1.00,Lisa/M_v20, Lisa/S, STM32F4_Discovery, KroozSD...).

The development of RT Paparazzi with ChibeOS was started by the AggieAir team [4] at Utah State University.

Getting the sourcecode

Most recent code is available under rt_paparazzi branch from Paparazzi Git repo [5], however you can check these two repositories too ([6] and [7])

Debugging with an Eclipse IDE

Having a good development and debugging environment is a must for developing RT embedded system. The steps of setting up Eclipse IDE are described here [8] and here [9].

An alternative guide is for example here [10]

Just a few notes to the process:

• install GCC Arm Embedded toolchain [11] (recommended anyway for Paparazzi since v 5.0)
• get Black Magic probe from Blacksphere [12], it will make your life easier
• in Creating a GDB Debug Configuration use the following commands for Black Magic Probe:

target extended-remote /dev/ttyACM0
monitor jtag_scan
attach 1
monitor vector_catch disable hard
set mem inaccessible-by-default off
monitor option erase
set print pretty

(for Lisa/Lia F4 board use swdp_scan instead of jtag_scan)

• if you are using luftboot, don't forget to add image offset into the debug configuration:

• don't forget in "Eclipse->Window->Preferences->Run/Debug->Launching->Default Launchers->GDB Hardware Debugging" set preferred launcher to "Standard GDB" (otherwise the ChibiOS/RT plugin won't work, tested in Eclipse Kepler Service Release 1):

ChibiOS Eclipse plugin

A nice and comprehensive guide about how to install ChibiOS plugins is here.

In case the page is not available, here is an older manual:

• to use ChibiOS/RT debug module for Eclipse, download ChibiStudio (it is for Windows only) from SourceForge [13], extract it and from ChibiStudio/eclipse/plugins copy

org.chibios.tools.eclipse.config_1.2.1.jar
org.chibios.tools.eclipse.debug_1.0.8.jar

to your eclipse/plugins directory. Restart Eclipse and in "Help->About Eclipe->Installation Details->Plugins" you should see both chibios plugins. Enable the plug-in while in the "Debug" view under: Window->Show View->Other...->ChibiOS/RT->ChibiOS/RT" (see [14] for details)

ChibiOS Tutorials

Related videos about setting up Eclipse with ChibiOS plugins (called together ChibiStudio) are available here

Compiling Paparazzi code in Eclipse

Typical process consists of compiling the autopilot code for given airframe in Paparazzi center, and then running the related debug configuration in Eclipse. The debugger will first recompile whole Paparazzi (e.g. running "make" in Paparazzi home directory), which is not really useful, but bearable.

In case we want to work with a single aircraft and want Eclipse to also compile the autopilot code, we have to do the following:

1. Import paparazzi into eclipse as normal
2. in project->properties->c/c++->environment add three variables
   1. Current_Airframe: set to the name of the airframe you want to build
   2. PAPARAZZI_HOME: set to the root paparazzi directory
   3. PAPARAZZI_SRC: set to the root paparazzi directory
3. in project->properties->c/c++
   1. in Builder Settings Tab
      1. Uncheck Use default build command
      2. in build command put: make -f Makefile.ac AIRCRAFT=${Current_Airframe}
   2. In Behavior Tab
      1. set the Build field to: ap.compile
      2. set the Clean field to:clean_ac

That will compile Current_Aiframe with target ac. Obviously, if you need a different target, for example test_telemetry, you will have to change the last two steps to test_telemetry.compile and so on.

Paparazzi on Linux

Taking the ARDrone 2 base install is a good example how Paparazzi could be used to run the core Autopilot executable

RT Paparazzi at ENAC

There is an internal project at ENAC of a RT Paparazzi

RT Paparazzi on Nuttix

There are all reasons to assume the current Paparazzi code can run perfectly on Nuttix, only nobody so far bother to start this effort since the general consensus at the moment is that CHibeOS is a better choice for an RT operationg system