PaparazziUAV - User contributions [en]

Overview

2011-06-14T12:13:56Z

Sergio812:

[[image:Paparazzi_System_overview.jpg|right|Paparazzi System Overview]]
Paparazzi is a complete system of hardware and software for autonomous aircraft as well as complete ground station mission planning and monitoring software utilizing a bi-directional datalink for telemetry and control.

== System Architecture ==

The following figure shows the main agents of the system: one (or several) aircraft and the distributed ground architecture (usually distributed on a single computer):

[[Image:Pprz_communication_agents.gif]]

The UAV (in blue) is navigating autonomously and is monitored and controlled from the ground (in brown). The [[GCS|ground control station (GCS)]] provides a graphical user interface with telemetry data received by the ''link agent'' which manages the ground-based radio modem. The ''link agent'' distributes telemetry data across the network (a single computer, a local network or the internet) where it can be used locally or remotely by the:
* '''messages''' - a real-time display of all telemetry data
* '''server''' - an agent that logs, distributes, and preprocesses these messages for the GCS.
All of these processes run simultaneously and each module is independently controled and configured from [[Paparazzi_Center]].

Your first experiments with the system should be with the simulator where everything runs on your local machine. The configuration is then slightly different:

[[Image:comm_sitl.gif]]

Here the aircarft and its radio link are replaced by the simulator. An optional ''gaia'' agent is also available to introduce some environmental parameters such as wind, infrared contrast, GPS quality, and time scale reference.

== Aircraft ==
{|
|-
| [[image:Paparazzi_Equiped_Aircraft.jpg|Paparazzi Equiped Aircraft]]
|
* '''A'''utopilot Control Board
* '''B'''attery
* '''D'''atalink Radio-Modem & Antenna
* '''G'''PS Receiver
* '''I'''R Sensor Board
* '''M'''otor & Controller
* '''R'''C Receiver & Antenna
* '''S'''ervos
* '''P'''ayload = Camera & Video Transmitter
|}

=== The Airframe ===

The Paparazzi airborne system is highly configurable and can be used to autonomously operate almost any airframe. It is currently in use on airframes ranging from 30cm to 1.4m, and 180g to several kg. In the early days of the project, slow and stable airframes such as the venerable Twinstar and Microjet were favored, but today the system is employed in a wide variety of high performance aircrafts, many with little or no natural stability, and many designed specifically around the Paparazzi system.

The [[Gallery|User's Gallery]] shows some of the many Paparazzi aircraft.

=== Airborne Electronics ===

===== Controller Board =====

[[image:tiny_proto1_top_small.jpg|frame|Tiny Controller Board]]
Several controller boards have been designed to run the Paparazzi autopilot software, using either Atmel AVR or Philips ARM7 LPC micro-controllers. These boards include one or two micro-controllers and the required connectors to handle the servos, motor controllers, sensors, RC receiver, radio modem, and a variety of payloads. All of the [http://cvs.savannah.nongnu.org/viewcvs/paparazzi3/hw/?root=paparazzi schematics and PCB files] are available under the GPL licence.
 
More details on the controller boards are available on the [[Hardware|Hardware Pages]].
 

===== Sensors =====

[[image:ir_sensor_bot_small.jpg|frame|2 Axis IR Sensor Board]]
Paparazzi autopilots can interface with virtually any type of sensor but the vast majority of applications rely on a set of 6 orthogonal infrared temperature sensors to estimate the orientation of the aircraft relative to the warm earth and cold sky. The IR system provides a robust and absolute attitude estimate that is immune to vibration and disorienting launches, wind gusts, or stalls that may confuse inertial-based autopilots. Paparazzi also uses conventional inertial systems on hovering aircraft such as quadrotors and helicopters with freely available [http://cvs.savannah.gnu.org/viewvc/paparazzi/paparazzi3/ software and hardware sources]. Fixed wing airborne hardware typically includes infrared sensors, GPS & occasionally a gyroscope for roll or pitch rate damping on more agile aircraft.
A standard GPS receiver from u-blox is used, either as a stand-alone unit for the [[Classix]] or [[Twog_v1|TWOG]] autopilots, or as a fully integrated package in the [[Tiny_v2|Tiny]] autopilot.

More details on the sensors are available on the [[Sensors|Sensors page]].
 
===== Communications =====

[[image:ac4868_transceiver.jpg|frame|Aerocomm AC4868 Radio-Modem]]
Airborne hardware also includes communications devices : Radio Modem (Datalink) & RC Receiver (Safety Link).
Any wireless device providing a serial link can be used for the telemetry and the telecontrol (Datalink).

More details on communications hardware are available on the [[Modems|Modems page]].
 
===== Example Setup =====

[[image:ppzsetup002.jpg|frame|Sample 2 servo setup]]
A typical configuration would include two servos (elevon setup), receiver, IR sensors, FTDI or RF Modem for serial communications either wired or wireless. ESC is not shown. NOTE: DO NOT CONNECT POWER WIRE FROM ESC TO TINY. Only connect Ground and Signal for the ESC to the Tiny.
 
=== Airborne Software ===

The Paparazzi autopilot provides the following features:
* RC receiver (PPM signal) decoding
* Servos and motor controller (PPM signal) control
* Manual control with the RC
* Control with augmented stability (named '''AUTO1''')
* Autonomous navigation (named '''AUTO2''') in 3D, including
** Waypoint navigation
** Segment and circle navigation
** Altitude hold, glide following
** High level flight plan language execution (sequence, loops, goto...)
* Telemetry to the ground station
* Telecontrol (datalink) from the ground station (navigation control, waypoint modifications, tuning)

The autopilot code is written in C while all the configuration code is translated from XML files at compile time.
Code is segregated into two processes respectively handling the ''fly by wire'' (manual control) and the ''autopilot'' itself (stabilization and navigation). These processes are segregated on two-processor controllers such as the [[Classix|Classix]].

== Ground Control Station (GCS) ==

=== Ground Computer ===

The software is developped to be run on a i386 architecture with the [http://www.debian.org Debian GNU/linux] operating system. However a Live CD including all the software is provided: it should be able to boot any standard laptop.

=== Ground Software ===

The software mainly provides
* compiling tools to produce the airborne code from the configuration;
* a GUI to control and interact with the UAV(s) during flight;
* a basic simulator to ease the development of flight plans.

=== Datalink ===

Paparazzi offers several possibilities to supervise the UAV flight from the ground. The default one uses a bidirectionnal wireless modem which supports both telemetry (downlink) and telecontrol (uplink). Thanks to this datalink, flight parameters are available in real time and full control of the navigation and tuning of one or several aircraft is possible from the ground station.

=== Safety Link ===

The airborne hardware and software support the connection to a standard (patched) radio-control receiver. While this link is not required for actual autonomous flights, it may help during the tuning of a new aircraft and is usually considered as an important safety control redundancy.

== Payloads ==

Paparazzi is designed to interface with a wide variety of payloads. The airborne board can control many servos for autonomous and/or manual [[Pan_Tilt_Camera|Pan/Tilt camera systems]] or other mechanical payloads, SPI, I2C, and GPIO connections are available to connect digital devices (i.e. lights or digital camera shutter), and analog inputs are available to interface with just about any sensor imaginable. The associated software is easily integrated into the open-source code. The [[Classix]] board can also be connected to a [http://www.gumstix.com Gumstix Computer] for highly sophisticated payload software applications.

== Disclaimers ==

It should be understood that smooth, reliable autonomous flight is a great feat and will require significant time and effort to achieve, even with a highly evolved open system like Paparazzi. The time required will vary based on experience, aircraft, and luck. From experience however, users can expect to spend a similar amount of time learning and configuring Paparazzi as they may with any of the commercially available systems.

Linux itself can pose quite a challenge to install, configure, and learn. To help ease the transition for those not already running Linux, the LiveCD option is available to help get you started. The LiveCD allows the user to save all configuration files as well as any user-modified source code on a pen drive or as a compressed file on your hard drive without affecting your existing OS. We strongly urge new users to [[Contact|Contact]] someone from the Paparazzi team before beginning any hardware investment as we can help you get the most out of the system.

[[Category:User_Documentation]]

DevGuide/CodeEditors

2011-06-13T05:33:57Z

Sergio812:

== Introduction ==

So you want to adjust the sourcecode to your wishes, get rid of some bugs that bother you and help to improve the code, great! While theoretically it all an be done with VI and command line instructions, learning to code for Paparazzi this way is a little cumbersome. Therefore it is a good idea to set up an IDE Integrated Development Environment.

As you may have noticed, this page is far from finished, it really would be great if you help to improve this page with even a small improvement.

== IDE for OCAML ==

We start of with OCAML IDE's first

=== EMACS

http://www-rocq.inria.fr/~acohen/tuareg/index.html.en

=== Netbeans ===

==== Installation ====
First install a reasonable new Netbeans, e.g. v6.8 via the synaptic package manager in Ubuntu or use the commandline

==== OCAML Plugin ====

http://ocamlplugin.loki-a.com/index.php?title=Main_Page

# Start netbeans IDE
# Go to Netbean menu -Tools - Plugins

# Select tab - Settings
# Click the Add button

Name: Ocaml from Loki a
URL: http://ocamlplugin.loki-a.com/ocamlplugin/updates/updates.xml

# Then click the tab "Available plugins"
# Select for install from the list the "Ocaml Plugin"
# Click Install
# Click Install Then Next
# If you see "Signed but not trusted, ignore the message just click "continue"
# If it all worked, you will see "Install completed sucessfully, just click "Finish"

==== Syntax Highlighting ====

=== Eclipse ===

http://www.cocan.org/ocaml_and_eclipse

=== Code::Blocks ===

== IDE for C and CPP ==

Next are the IDE's for C develpment

=== Netbeans ===
=== Eclipse ===
=== Code::Blocks ===

== Debugging tools ==

GDB

[[Category:Software]] [[Category:Developer_Documentation]]

Installation/FromScratch

2011-06-13T05:32:16Z

Sergio812:

== Intro ==

As with all Wiki pages, also this page is a work in progress. try to be a big help to the Paparazzi project and improve this page whenever you can. If you have a distribution different from Ubuntu which doesn't satisfy any other dependency and have instructions about compiling it, packaging it, feel free to add any reference on how to do that on this wikipage.

== Goal ==

The goal of this page is to clarify about which version of each piece of software has to be compiled, where to find that software, patches needed to make it compile on Linux. In our case 64bit Linux. This includes compiling all paparazzi-dev, paparazzi-arm7, paparazzi-stm32 and paparazzi-bin software on your machine, running an Ubuntu Lucid Lynx or later Linux distribution or maybe even FreeBSD, or OSX.

== The shortcut ==

Maybe you are no so interested in the details at this moment and just want to quickly install. That's fine, for that we are working on a script and you only need to run one line to get everything installed. For this to work out you do need a working internet connection, but since you can read this text, that will probably not pose a problem.

$ cd ~ && wget http://openuas.org/pub/paparazzifromscratch.sh (still not ready and a work in progress)

If you used the line above, and it all worked out you can stop reading now since everything is installed and compiled, ready for you to use.

== Paparazzi-dev packages ==

For Ubuntu users, you can install the following packages from standard repository. You can just copy the line(s) and paste into your terminal. But do not copy the $ sign, this symbol is just added on this page to show that it is to be pasted at a normal terminal prompt.

=== Whole lot in one ===

sudo apt-get install ocaml libcamlimages-ocaml liblablgtk2-ocaml-dev liblablgtk2-gl-ocaml-dev \
liblablgtk2-gnome-ocaml-dev libxml-light-ocaml-dev libocamlnet-ocaml-dev libpcre-ocaml \
libpcre-ocaml-dev libgnomecanvas2-0 libgnomecanvas2-dev libglade2-0 libglade2-dev make build-essential \
git-core gnuplot boa m4 libtool libftdi-dev libmpfr-dev tcl8.5-dev xutils-dev

=== Ocaml and libraries ===

Ocaml, short for Objective Caml is the most popular variant of the Caml language. The Paparazzi Ground Control Station (GCS) and some of it's tools are crafted in this language.

* ocaml, ocaml-camlimages-devel, ocaml-lablgtk2-devel, ocaml-xml-light-devel, ocamlnet-ocaml-devel

$ sudo apt-get install ocaml libcamlimages-ocaml liblablgtk2-ocaml-dev liblablgtk2-gl-ocaml-dev \
liblablgtk2-gnome-ocaml-dev libxml-light-ocaml-dev libocamlnet-ocaml-dev

=== Gnome canvas Library ===

The GnomeCanvas is an engine for structured graphics that offers a rich imaging model, high performance rendering, and a powerful, high level API. This widget can be used for flexible display of graphics and for creating interactive user interface elements.

$ sudo apt-get install libgnomecanvas2-0 libgnomecanvas2-dev

=== USB Library ===

The libusb project aims to create a library for use by user level applications to access USB devices regardless of OS. http://www.libusb.org

$ sudo apt-get install libusb-dev

=== Ocaml PCRE ===

This OCaml-library interfaces the PCRE (Perl-compatibility regular expressions) C library. it can be used for matching regular expressions which are written in Perl style.

$ sudo apt-get install libpcre-ocaml libpcre-ocaml-dev

=== Glade Library ===

Libglade is a library that performs a similar job to the C source output routines in the GLADE user interface builder. Whereas GLADE's output routines create C source code that must be compiled, libglade builds the interface from an XML file (GLADE's save format) at runtime. This can allow modifying the user interface without recompiling.

$ sudo apt-get install libglade2-0 libglade2-dev

=== Tcl/Tk ===

$ sudo apt-get install tcl8.5-dev

Also the some utils are required to compile and install Ivy.

$ sudo apt-get install xutils-dev

=== Make ===

GNU Make is an utility which controls the generation of executables and other target files of a program from the program's source files.

$ sudo apt-get install make

=== Build essential ===

$ sudo apt-get install build-essential

=== Libtool ===

GNU libtool is a generic library support script. Libtool hides the complexity of using shared libraries behind a consistent, portable interface. Creating the files for Paparazzi software building becomes less cumbersome by using this tool.

$ sudo apt-get install libtool

=== Git Client ===

Git is a version control system. Version control systems allow many individuals to collaborate on the Paparazzi source code. This is needed to retrieve the latest sourcecode from various packages and Paparazzi sourcecode itself.

$ sudo apt-get install git-core

=== GNU Plot ===

A command-line driven interactive plotting program. Unknow if it is used

$ sudo apt-get install gnuplot

=== FTDI library ===

libftdi is a library that talks to FTDI's 232 type chips, including the popular bitbang mode, using libusb. A library to be able to use with a debugging Autopilot hardware boards.

$ sudo apt-get install libftdi-dev

=== MPFR library ===

The MPFR library is a C library for multiple-precision floating-point computations with correct rounding. MPFR is based on the GMP multiple-precision library. The main goal of MPFR is to provide a library for multiple-precision floating-point computation which is both efficient and has a well-defined semantics.

$ sudo apt-get install libmpfr-dev

=== ImageMagick ===

ImageMagick is a software suite to create, edit, and compose bitmap images. It can read, convert and write images in a variety of formats. Use ImageMagick to translate, flip, mirror, rotate, scale, shear and transform images, adjust image colors, apply various special effects, or draw text, lines, polygons, ellipses and Bézier curves. Being able to modify image based map pictures is a feature that may come in handy one time.

$ sudo apt-get install imagemagick

=== Optional on an older OS ===

If you have an older OS distribution it never hurts to install the following...

$ sudo apt-get install libx11-6 libx11-dev texinfo flex bison libncurses5 libncurses5-dev libncursesw5 libncursesw5-dev zlibc

== Building the Cross compiler toolchain ==

The goal of this part is to building an ARM and STM32 cross-toolchain with binutils gcc newlib and gdb from source. This is needed so we can compile the code that ends up onto the autopilot board. Newlib is a C library intended for use on embedded systems. It is a conglomeration of several library parts, all under free software licenses that make them easily usable on embedded products. Enter the following on your command prompt

$ cd ~
$ nano paparazzi_from_scratch.sh

Then copy the part below (CTRL+C) and go to your terminal window again and use CTRL+SHIFT+V to paste the text into the nano editor. Afterther save the file with CTRL+X and answer Y

#!/bin/sh

# ******************************************************************************
#
# Goal: Get the ARM and STM32 cross compilers, tools and libraries installed and all
# working on 64Bit (Linux) computer system like they should
# Version: 1.7
# Copyright: 2011 LGPL OpenUAS http://www.openuas.org/
# Date: 20110225 14:01
# Usage: $ sh ./paparazzi_from_scratch.sh 2>&1 | tee buildlog.txt
#
# I want to improve this script, what can I do?
#
# IMPR: Add STM32 support
# IMPR: with automatic log filename appending date like "date +%y%j%H%M%S"
# IMPR: Set MAJOR and MINOR GCC version in make parameter automatically
# IMPR: Add all commands from this wikipage also to the script, so we have a
# full paparazzi from scratch in one script!
#
# Useful links:
# http://fun-tech.se/stm32/gcc/index.php
# http://only.mawhrin.net/~alexey/prg/lpc2103/toolchain/
# http://gcc.gnu.org/install/configure.html
# http://wiki.ubuntuusers.de/GNU_arm-toolchain
# http://gcc.gnu.org/onlinedocs/gcc-4.5.0/gcc/ARM-Options.html#ARM-Options
# http://www.hermann-uwe.de/blog/building-an-arm-cross-toolchain-with-binutils-gcc-newlib-and-gdb-from-source
# http://mcuprogramming.com/forum/arm/gnu-arm-toolchain-installer/
# http://code.google.com/p/hobbycode/source/browse/trunk/gnu-arm-installer
# http://www.ethernut.de/en/documents/cross-toolchain-osx.html
# http://paparazzi.enac.fr/w/index.php?title=User:Roirodriguez
# http://chdk.wikia.com/wiki/Gcc433
# http://chdk.wikia.com/wiki/Compiling_CHDK_under_Linux
#
# http://gcc.gnu.org/faq.html#multiple
# https://wiki.kubuntu.org/CompilerFlags
#
# Older compiler http://ubuntu-virginia.ubuntuforums.org/showthread.php?t=91596
# Replaced O_CREAT for S_IRWXU in the files where you get gcc-3.4.4/gcc/collect2.c
#
# The eBook "Definitive guide to GCC" may come in handy
#
# And if all went well, a command
# $ arm-elf-gcc -print-multi-lib
#
# Should give the following
#
# .;
# thumb;@mthumb
# interwork;@mthumb-interwork
# thumb/interwork;@mthumb@mthumb-interwork
#
# ******************************************************************************

# In case you want to recompile, and if you do not want to re-download the files
# to save time and bandwith set CLEANUPDOWNLOADS to N
CLEANUPDOWNLOADS="N"

TARGET=arm-elf #Or use TARGET=arm-none-eabi or arm_non_eabi the pararazzi makefile will figure it out
PREFIX=$HOME/arm-elf-paparazzi # Install location of the final toolchain, change this to your liking

# If you have a good reason to compile other versions, ONLY then change the version data below
BINUTILS_VERSION=2.16.1
GCC_VERSION=3.4.4
NEWLIB_VERSION=1.13.0
GDB_VERSION=6.8

#Just in case for some reason you want the latest versions a just values here
# and some more 3.4 in the rest of the script
#TARGET=arm-elf
#PREFIX=$HOME/arm-elf-latest # Install location of the final toolchain, change this to your liking
#BINUTILS_VERSION=2.20.1
#GCC_VERSION=4.4.4
#NEWLIB_VERSION=1.18.0
#GDB_VERSION=7.1

# ******************************************************************************
# * No need to change anything below this line, exept improvements *
# ******************************************************************************

# On multicore Processor this value can speedup the compilation
if grep -q "processor" /proc/cpuinfo || grep -q "siblings" /proc/cpuinfo
then
SPEEDUPCOMPILATION="-j "$(($( grep "processor" /proc/cpuinfo | sort -u | wc -l ) * $( grep "siblings" /proc/cpuinfo | tail -1 | cut -d: -f2 )))
else
SPEEDUPCOMPILATION=""
fi

# Install texinfo tool
sudo apt-get install texinfo

# A GCC v3.4 64Bit install to avoid issues whil compiling the crosscompiler, native compile use would be much better
# Or, get debian packages from here http://www.openuas.org/pub/ubuntu/pool/universe/g/gcc-3.4/ or http://es.archive.ubuntu.com/ubuntu/pool/universe/g/gcc-3.4/
wget -N -c http://archive.ubuntu.com/ubuntu/pool/universe/g/gcc-3.4/gcc-3.4-base_3.4.6-8ubuntu2_amd64.deb
wget -N -c http://archive.ubuntu.com/ubuntu/pool/universe/g/gcc-3.4/cpp-3.4_3.4.6-8ubuntu2_amd64.deb
wget -N -c http://archive.ubuntu.com/ubuntu/pool/universe/g/gcc-3.4/gcc-3.4_3.4.6-8ubuntu2_amd64.deb
# Must be installed in this order
sudo dpkg -i gcc-3.4-base_3.4.6-8ubuntu2_amd64.deb
sudo dpkg -i cpp-3.4_3.4.6-8ubuntu2_amd64.deb
sudo dpkg -i gcc-3.4_3.4.6-8ubuntu2_amd64.deb
if [ "${CLEANUPDOWNLOADS}" != "N" ]
then
rm *.deb
fi

BINUTILS=binutils-$BINUTILS_VERSION
GCC=gcc-$GCC_VERSION
NEWLIB=newlib-$NEWLIB_VERSION
GDB=gdb-$GDB_VERSION

mkdir $PREFIX

# ** Now set the gcc and tools to be used in environment
echo 'export PATH='$PREFIX'/bin:$PATH' >> ~/.bashrc
source ~/.bashrc

rm -drf build
mkdir build

# Get and compile the BinUtils
wget -N -c http://ftp.gnu.org/gnu/binutils/$BINUTILS.tar.bz2
tar xfvj $BINUTILS.tar.bz2
cd build
unset CFLAGS && unset LDFLAGS && unset CPPFLAGS && unset CXXFLAGS &&
CC=gcc-3.4
CXX=g++-3.4
../$BINUTILS/configure -v --target=$TARGET --prefix=$PREFIX --enable-interwork --enable-multilib --enable-shared --with-system-zlib --enable-long-long --enable-nls --without-included-gettext --disable-checking --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=$TARGET
make $SPEEDUPCOMPILATION CC=gcc-3.4 CXX=g++-3.4
make CC=gcc-3.4 CXX=g++-3.4 install
cd ..
rm -rf build/* $BINUTILS
if [ "${CLEANUPDOWNLOADS}" != "N" ]
then
rm $BINUTILS.tar.bz2
fi

# ** Get and compile GCC stuff
wget -N -c ftp://ftp.gnu.org/gnu/gcc/$GCC/$GCC.tar.bz2
tar xfvj $GCC.tar.bz2

# Set correct MULTILIB options in GCC config, by patching
ONTHFLYPATCHFILE='gcc_thumb_interwork_settings.patch'
rm -f $ONTHFLYPATCHFILE #Just to make sure
echo '--- t-arm-elf 2003-09-30 12:21:41.000000000 +0200' >> $ONTHFLYPATCHFILE
echo '+++ t-arm-elf 2010-08-07 19:17:47.000000000 +0200' >> $ONTHFLYPATCHFILE
echo '@@ -26,8 +26,8 @@' >> $ONTHFLYPATCHFILE
echo ' # MULTILIB_DIRNAMES += 32bit 26bit' >> $ONTHFLYPATCHFILE
echo ' # MULTILIB_EXCEPTIONS += *mthumb/*mapcs-26*' >> $ONTHFLYPATCHFILE
echo ' # ' >> $ONTHFLYPATCHFILE
echo '-# MULTILIB_OPTIONS += mno-thumb-interwork/mthumb-interwork' >> $ONTHFLYPATCHFILE
echo '-# MULTILIB_DIRNAMES += normal interwork' >> $ONTHFLYPATCHFILE
echo '+MULTILIB_OPTIONS += mno-thumb-interwork/mthumb-interwork' >> $ONTHFLYPATCHFILE
echo '+MULTILIB_DIRNAMES += normal interwork' >> $ONTHFLYPATCHFILE
echo ' # MULTILIB_EXCEPTIONS += *mapcs-26/*mthumb-interwork*' >> $ONTHFLYPATCHFILE
echo ' # ' >> $ONTHFLYPATCHFILE
echo ' # MULTILIB_OPTIONS += fno-leading-underscore/fleading-underscore' >> $ONTHFLYPATCHFILE
patch $GCC/gcc/config/arm/t-arm-elf < $ONTHFLYPATCHFILE
rm -f $ONTHFLYPATCHFILE
cd build

# IMPR "../$GCC/gcc/collect2.c" ajust the line in this file to prevent compiler error for older gcc to "redir_handle = open (redir, O_WRONLY | O_TRUNC | O_CREAT, S_IRWXU);"
unset CFLAGS && unset LDFLAGS && unset CPPFLAGS && unset CXXFLAGS &&
CC=gcc-3.4
CXX=g++-3.4
../$GCC/configure -v --enable-languages=c --prefix=$PREFIX --infodir=$PREFIX"/share/info" --mandir=$PREFIX"/share/man" --enable-interwork --enable-multilib --enable-shared --with-system-zlib --enable-long-long --enable-nls --without-included-gettext --disable-checking --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=$TARGET
make $SPEEDUPCOMPILATION CC=gcc-3.4 CXX=g++-3.4 all
make CC=gcc-3.4 CXX=g++-3.4 install
cd ..
# NOTE: We do not delete GCC temporary build yet, we need it once more later in this script

if [ "${CLEANUPDOWNLOADS}" != "N" ]
then
rm $GCC.tar.bz2
fi

# Now get and compile NewLib, note that sometimes this server is to busy serving the files,
# try to get the files via an FTP client with good resume if it happens
wget -N -c --waitretry=20 http://www.openuas.org/pub/newlib/$NEWLIB.tar.gz
tar xfvz $NEWLIB.tar.gz
cd build
unset CFLAGS && unset LDFLAGS && unset CPPFLAGS && unset CXXFLAGS &&
CC=gcc-3.4
CXX=g++-3.4
../$NEWLIB/configure -v --target=$TARGET --prefix=$PREFIX --enable-interwork --enable-multilib --enable-shared --with-system-zlib --enable-long-long --enable-nls --without-included-gettext --disable-checking --build=x86_64-linux-gnu --host=x86_64-linux-gnu
make $SPEEDUPCOMPILATION CC=gcc-3.4 CXX=g++-3.4
make CC=gcc-3.4 CXX=g++-3.4 install
cd ..
rm -rf build/* $NEWLIB
if [ "${CLEANUPDOWNLOADS}" != "N" ]
then
rm -rf $NEWLIB.tar.gz
fi

# GCC needs to be build again including the real newlib now
cd build
unset CFLAGS && unset LDFLAGS && unset CPPFLAGS && unset CXXFLAGS &&
CC=gcc-3.4
CXX=g++-3.4
../$GCC/configure -v --target=$TARGET --prefix=$PREFIX --enable-interwork --enable-multilib --enable-languages="c,c++" --with-newlib --enable-shared --with-system-zlib --enable-long-long --enable-nls --without-included-gettext --build=x86_64-linux-gnu --host=x86_64-linux-gnu --infodir=$PREFIX"/share/info" --mandir=$PREFIX"/share/man"

make $SPEEDUPCOMPILATION CC=gcc-3.4 CXX=g++-3.4 all-gcc
make CC=gcc-3.4 CXX=g++-3.4 install-gcc
cd ..
rm -rf build/* $GCC
rm -rf build

# We need a symlink to arm-elf-gcc in /usr/bin/ the way the current paparazzi AP compile script works
# We need a better solution here then symlinks, any clues...plz improve
# Yes, helping with a better use of shell by using arm-elf wild-cards is appreciated
PREFIXBINDIR=$PREFIX/bin
OURBINDIR=/usr/bin
#Remove old symlinks
for x in $OURBINDIR/arm-elf*; do if [ -L $x ]; then sudo rm $x; fi ; done
#Make fresh symlinks so arm tools ar found by paparazzi center
sudo ln -s $PREFIXBINDIR/arm-elf-gcc $OURBINDIR/arm-elf-gcc
sudo ln -s $PREFIXBINDIR/arm-elf-size $OURBINDIR/arm-elf-size
sudo ln -s $PREFIXBINDIR/arm-elf-objcopy $OURBINDIR/arm-elf-objcopy
sudo ln -s $PREFIXBINDIR/arm-elf-objdump $OURBINDIR/arm-elf-objdump
sudo ln -s $PREFIXBINDIR/arm-elf-nm $OURBINDIR/arm-elf-nm
sudo ln -s $PREFIXBINDIR/arm-elf-addr2line $OURBINDIR/arm-elf-addr2line
sudo ln -s $PREFIXBINDIR/arm-elf-ar $OURBINDIR/arm-elf-ar
sudo ln -s $PREFIXBINDIR/arm-elf-as $OURBINDIR/arm-elf-as
sudo ln -s $PREFIXBINDIR/arm-elf-c++filt $OURBINDIR/arm-elf-c++filt
sudo ln -s $PREFIXBINDIR/arm-elf-cpp $OURBINDIR/arm-elf-cpp
sudo ln -s $PREFIXBINDIR/arm-elf-gcc $OURBINDIR/arm-elf-gcc
sudo ln -s $PREFIXBINDIR/arm-elf-gcc-3.4.4 $OURBINDIR/arm-elf-gcc-3.4.4
sudo ln -s $PREFIXBINDIR/arm-elf-gccbug $OURBINDIR/arm-elf-gccbug
sudo ln -s $PREFIXBINDIR/arm-elf-gcov $OURBINDIR/arm-elf-gcov
sudo ln -s $PREFIXBINDIR/arm-elf-ld $OURBINDIR/arm-elf-ld
sudo ln -s $PREFIXBINDIR/arm-elf-nm $OURBINDIR/arm-elf-nm
sudo ln -s $PREFIXBINDIR/arm-elf-objcopy $OURBINDIR/arm-elf-objcopy
sudo ln -s $PREFIXBINDIR/arm-elf-objdump $OURBINDIR/arm-elf-objdump
sudo ln -s $PREFIXBINDIR/arm-elf-ranlib $OURBINDIR/arm-elf-ranlib
sudo ln -s $PREFIXBINDIR/arm-elf-readelf $OURBINDIR/arm-elf-readelf
sudo ln -s $PREFIXBINDIR/arm-elf-size $OURBINDIR/arm-elf-size
sudo ln -s $PREFIXBINDIR/arm-elf-strings $OURBINDIR/arm-elf-strings
sudo ln -s $PREFIXBINDIR/arm-elf-strip $OURBINDIR/arm-elf-strip

# If you also a want to add the debugger, Uncomen the lines here. Configure could need parameter "--disable-werror" in some cases
#wget -N -c ftp://ftp.gnu.org/gnu/gdb/$GDB.tar.bz2
#tar xfvj $GDB.tar.bz2
#cd build
#../$GDB/configure --target=$TARGET --prefix=$PREFIX --enable-interwork --enable-multilib
#make $SPEEDUPCOMPILATION
#make install
#cd ..

#rm -rf build $GDB
#if [ "${CLEANUPDOWNLOADS}" != "N" ]
#then
# rm $GDB.tar.bz2
#fi

echo "Misterious as this scripts progress might have looked, everything is now done, hopefully without any issue"

Then run the script in a terminal window via:

$ sh ./paparazzi_from_scratch.sh 2>&1 | tee buildlog.txt

== Rest of code needed ==

To install the rest we make a special directory "develop". You can give it another name ofcourse.

$ mkdir ~/develop

== LPC21ISP ==

To get the software onto the main autopilot board a special tool is needed. We will use the great open-source LPC21ISP application. LPC21ISP is an in-circuit programming (ISP) tool for the microcontroller used on the Paparazzi autopilot boards. The lpc21isp project is hosted on sourceforge and one can find the source packages and information at http://sourceforge.net/projects/lpc21isp/

Get the SVN version via

$ mkdir -p ~/develop/lpc21isp
$ cd ~/develop/lpc21isp
$ svn co https://lpc21isp.svn.sourceforge.net/svnroot/lpc21isp lpc21

To compile go into the source directory and then do

$ cd lpc21
$ make -f Makefile clean all

To install

$ sudo cp lpc21isp /usr/bin/

== IVY ==

IVY is a simple protocol and a set of open-source libraries and programs that allows applications to broadcast information through text messages, with a subscription mechanism based on regular expressions. The project can be found at: http://www2.tls.cena.fr/products/ivy/

In the paparazzi project, Ivy is used to send telemetry data to where ever you want.

NOTE: Do not confuse this IVY with the Apache Ivy project.

=== Ivy-python ===

The ivy-python package makes it possible to use the IVY libraries from within the Python programming language. The ivy-python package is architecture independent, so it can be downloaded from the Ubuntu or Debian paparazzi repository. However since this is the from scratch page we will download it from the official source repository via

$ mkdir -p ~/develop/ivy-python/
$ cd ~/develop/ivy-python/
$ svn co http://svn.tls.cena.fr/svn/ivy/ivy-python/trunk

Now we can build and install

$ cd ~/develop/ivy-python/trunk
$ sudo ./setup.py install

=== Ivy-c ===

To be able to use IVY-c, the libraries need to be installed. Source packages of ivy-c can be downloaded via:

$ mkdir -p ~/develop/ivy-c
$ cd ~/develop/ivy-c
$ svn co http://svn.tls.cena.fr/svn/ivy/ivy-c/trunk

To compile

$ cd ~/develop/ivy-c/trunk/src
$ make

It is possible you get errors of the test module when compiling, just ignore the messages, it is not important for the Paparazzi project. Contact the IVY team to help them also to resolve also the testing makefile issue.

Now install the compiled libraries

$ sudo make install

=== Ivy-OCAML ===

The Ivy-ocaml is a Library that make it possible to use Ivy via the Ocaml language.

$ mkdir -p ~/develop/ivy-ocaml
$ cd ~/develop/ivy-ocaml/
$ svn co http://svn.tls.cena.fr/svn/ivy/ivy-ocaml/trunk

NOTE: If the above SVN repository does not work due to API incompatibilities get the ivy-ocaml source via

$ wget http://paparazzi.enac.fr/ubuntu/dists/lucid/main/binary-i386/ivy-ocaml_1.1-10.tar.gz
use newer: http://paparazzi.enac.fr/ubuntu/dists/natty/main/binary-i386/ivy-ocaml_1.1-12.tar.gz

Now we need to compile the source via

$ cd ~/develop/ivy-ocaml/trunk
$ make

Compilation works for 64 bit if you get an up-to-date version!

Compilation doesn't work on 64bit systems, if you just run 'make'

/usr/bin/ld: civyloop.o: relocation R_X86_64_32 against `timer_cb' can not be used when making a shared object; recompile with -fPIC

That's solved by just editing the Makefile. Change the line containing

.c.o:
$(CC) -Wall -c $(OCAMLINC) $(GLIBINC) $<
to

.c.o:
$(CC) -Wall -c -fPIC $(OCAMLINC) $(GLIBINC) $<

TODO:
File a defect to the ivy-ocaml development team: A proper patch for the original sources would be one that checks if the system is a 64bit system, and if so set FPIC env variable. The following code at the beginning of the Makefile needs to be added just as it is done in the ivy-c Makefile

PERHAPS64:= $(shell uname -m | perl -ne "print /64/? '64' : '';")''
ifeq ($(PERHAPS64), "64")
FPIC=
else
FPIC=-fPIC
endif

And then let the rule to compile all .c and .o files be like the following:

.c.o:
$(CC) -Wall -c $(FPIC) $(OCAMLINC) $(GLIBINC) $<

== Paparazzi Main sourcecode ==

To run the Ground control station and to be able to create airborne code for the Autopilot board and more one needs to get the Paparazzi source via

$ git clone https://github.com/paparazzi/paparazzi.git

Compilation should work just fine for 64 bit with current versions, no need to change makefile anymore...

If you enter the sources directory and simply run ''make'' you will get the following error in an amd64 system:

cd sw/ground_segment/multimon; make PAPARAZZI_SRC=/home/roi/Codigo/paparazzi-dev/lenny_versions/paparazzi/temp PAPARAZZI_HOME=/home/roi/Codigo/paparazzi-dev/lenny_versions/paparazzi/temp
CC hdlc.c
hdlc.c:1: error: CPU you selected does not support x86-64 instruction set

This is because the code in sw/ground_segment/multimon/filter-i386.h which contains optimizations for some functions gets included and it doesn't work on amd64. filter.h says that filter-i386.h gets included if:

#ifdef ARCH_I386
#include "filter-i386.h"
#endif /* ARCH_I386 */

If we take a look at the Makefile (sw/ground_segment/multimon/Makefile):

CFLAGS =-Wall -Wstrict-prototypes -I/usr/X11R6/include -I `ocamlc -where`
ifeq ($(DEBUG),y)
CFLAGS +=-g -O -march=i486 -falign-loops=2 -falign-jumps=2 \
-falign-functions=2 -DARCH_I386
else
CFLAGS +=-O3 -march=i486 -falign-loops=2 -falign-jumps=2 \
-falign-functions=2 -DARCH_I386
endif

We'll have to change it to not define ARCH_I386, not optimize for i486 and add -fPIC. So we need to leave the above lines like:

CFLAGS =-Wall -fPIC -Wstrict-prototypes -I/usr/X11R6/include -I `ocamlc -where`
ifeq ($(DEBUG),y)
CFLAGS +=-g -O -falign-loops=2 -falign-jumps=2 \
-falign-functions=2
else
CFLAGS +=-O3 -falign-loops=2 -falign-jumps=2 \
-falign-functions=2
endif

Note that leaving the sources like this won't apply the optimisations if now you take the modified source and compile it in a 32bit system...

Now it will compile. run paparazzi and test it with a simulation via

$ ./paparazzi

NOTES:
See also the main installation page

TIP:
If you get the File "pprz.mli", line 149, characters 78-89: Error: Unbound type constructor Ivy.binding
...this happens when IVY libraries are not yet installed. How to do this, read the part on installing IVY on this page

=== Set the UDev rules ===

To be able to access the Hardware attached to your PC later on, rules must be set in your OS. By setting the correct rules a regular user can access USB and other devices, otherwise restricted for only the root user.

Now in a terminal

$ sudo nano /etc/udev/rules.d/91-paparazzi.rules

then select and copy (CTRL+V) the text below:

ACTION!="add|change", GOTO="paparazzi_rules_end"

SUBSYSTEM!="usb", GOTO="paparazzi_rules_end"

ENV{DEVTYPE}!="usb_device", GOTO="paparazzi_rules_end"

#SUBSYSTEMS=="usb", ATTRS{serial}=="*_fbw", NAME="test_fbw", SYMLINK+="paparazzi/%s{serial}", MODE="0666"

# MaxStream xbee pro box
SUBSYSTEMS=="usb", ATTRS{product}=="MaxStream PKG-U", KERNEL=="ttyUSB*", SYMLINK+="paparazzi/xbee", GROUP="plugdev"

# bare FTDI chip without EEPROM
SUBSYSTEMS=="usb", ATTRS{idVendor}=="0403", ATTRS{idProduct}=="6001", KERNEL=="ttyUSB*", SYMLINK+="paparazzi/serial", GROUP="plugdev"

# all (fake VID 0x7070) LPCUSB devices (access through libusb)
SUBSYSTEMS=="usb", ATTRS{idVendor}=="7070", GROUP="plugdev"

# FTDI 2232 parallel converter / Amontec JTAG-Tiny (access through libftdi)
SUBSYSTEMS=="usb", ATTRS{idVendor}=="0403", ATTRS{idProduct}=="cff8", GROUP="plugdev"

# FTDI 2232 based jtag for Lisa/L
SUBSYSTEM=="usb", ATTRS{idVendor}=="0403", ATTRS{idProduct}=="6010", MODE="0666", GROUP="plugdev"

# make joysticks/gamepads readable on event interface (writeable for force feedback), see input_event.sh
KERNEL=="event*", IMPORT{program}="input_event.sh %p", NAME="input/%k", GROUP="plugdev", MODE="0640" ENV{FF_DEVICE}=="1", MODE="0660"

#needed for lisa usb upload
SUBSYSTEM=="usb", ATTRS{idVendor}=="0403", ATTRS{idProduct}=="6010", MODE="0666", GROUP="plugdev"

# FTDI with uBlox direct on USB
SUBSYSTEMS=="usb", ATTRS{idVendor}=="1546", ATTRS{idProduct}=="01a5", KERNEL=="ttyACM*", SYMLINK+="paparazzi/acm", GROUP="plugdev"

LABEL="paparazzi_rules_end"

Past the text in the terminal window via CTRL+SHIFT+V and save the file via CTRL+X. Test via

$ udevadm info -q all -n /dev/paparazzi/serial

If you want to learn more about what UDEV is, [http://www.openuas.org/pub/writing_udev_rules.html there is a very informative page about '''udev''' here]

== The depriciated -mapcs-32 option ==

The option "-mapcs-32" is only available with very old tool chain versions e.g. GCC-3.3.x. More recent tool chains will either require "-mabi=apcs-gnu" (non-EABI-compliant) or "-mabi=aapcs-linux" (EABI-compliant). To have an overview of all flags go here

http://ecos.sourceware.org/docs-1.3.1/ref/gnupro-ref/arm/ARM_COMBO_ch01.html

By changing -mapcs-32 with -Wa,-mapcs-32 compilation will work with more recent compilers and we have backward compatibility with the old flag for older compilers. The option -Wa,-mapcs-32 is doing the following: ''-Wa,option'' : Pass option as an option to the assembler. If option contains commas, it is split into multiple options at the commas.

The -mapcs-32 option generates code for a processor running with a 32-bit program counter and conforming to the function calling standards for the APCS 32-bit option. If interested in depth what APCS is read the following: http://www.openuas.org/site/APCS.txt

The gcc flag -mapcs-32 was deprecated since gcc-3.4.0 and finally removed in gcc-4.0.0 which unconditionally generates 32bit ARM code. You should not need to pass this flag to the assembler either but it might not hurt for backwards compatibility with older compilers, so it's best to leave it in with the -Wa, option metho

== Useful links ==

https://github.com/esden/summon-arm-toolchain

https://github.com/paparazzi/paparazzi-portability-support

http://svn.savannah.gnu.org/svn/paparazzi/paparazzi3/trunk/conf/Makefile.stm32

http://wiki.ubuntuusers.de/GNU_arm-toolchain

http://gcc.gnu.org/onlinedocs/gcc-4.5.0/gcc/ARM-Options.html#ARM-Options

http://mcuprogramming.com/forum/arm/gnu-arm-toolchain-installer/

http://code.google.com/p/hobbycode/source/browse/trunk/gnu-arm-installer

http://www.ethernut.de/en/documents/cross-toolchain-osx.html

http://paparazzi.enac.fr/w/index.php?title=User:Roirodriguez

http://www.hermann-uwe.de/blog/building-an-arm-cross-toolchain-with-binutils-gcc-newlib-and-gdb-from-source

[[Category:Software]] [[Category:Developer_Documentation]]

FirmwareArchitecture

2011-06-13T05:28:03Z

Sergio812:

== Modules ==
Modules use code generation in order to allow people to use them by only editing the vehicle's xml configuration as opposed to changing/adding to the code of the autopilot. Typically, function calls are generated for initialisation and in the mainloop for timers (periodic in paparazzi slang) and events.

[[Modules | modules page]]

== Subsystems ==
Subsystems are just a convention used to provide several implementations of a peripheral (like microcontroller peripherals, an external imu board...), protocol (gps, communications...) or algorithm (control, estimation...). Function calls are written "by hand" and the build system takes care to compile the particular implementation.

== Discussion ==
Modules naturally provide the "several implementations" feature of the Subsystems. So, ideally we could have a "generic" main.c consisting only in calls to the generated functions.
This has the advantage of providing flexibility for specifying timing parameters from the xml, like for example the frequency of control or estimation algorithm.

Nevertheless, care should be taken that switching to a "module only" configuration doesn't become detrimental to the readability and debugability of the code.

Fixedwing and Rotorcraft use different gps code and we'll have to decide when we merge if we make it a module or a subsystem.

[[Category:Software]] [[Category:Developer_Documentation]]

DevGuide/DesignOverview

2011-06-13T05:26:54Z

Sergio812:

== Airborne Functional Diagram ==
[[Image:functional_diagram.png]]

== Design Goals ==
-Static approach
-Modularity
-Hardware abstraction
-Runtime efficiency

=== Static Approach ===
-only "things that needs to be changed during flight are changeable
-maximise compilation time resolutions

advantages
Error checking
Efficiency
Safety/Robustness

=== Modularity ===

[[Image:modularity.png]]

-Separation of concerns
-Maintenability
-Interface
-C provide no dedicated mechanism for modularity
-Main issues with modularity are configuration and dependancies

[[Image:dependancies_example.png]]

=== Hardware abstraction ===

-Segregate hardware dependant modules

[[Image:hardware_abstraction.png]]

=== Runtime Efficiency ===

We have to take care that our code runs efficient on the autopilot board microprocessor. It is for example very unlikely that we will physically change the serial port on which we connected our telemetry modem during a flight.

'''bad''' coding practice

switch(UART) {
case UART0 : UARTO_write(...); break;
case UART1 : UART1_write(...); break;
}

'''good''' coding practice

#define UartWrite(x) UART ## _write(x)
UartWrite(...);

== Design Solutions ==

* Heavy pre-processor usage
* C code generation
* Heavy Makefile usage
* Conventions to define our own module layer

=== pre-processor ===

==== header selection ====

conf/airframes/funjet1.xml

<makefile>
ap.CFLAGS += -DACTUATORS=\"servos_4017_hw.h\"
</makefile>

generated var/FJ1/Makefile.ac

ap.CFLAGS += -DACTUATORS=\"servos_4017_hw.h\"

sw/airborne/actuators.h
#include ACTUATORS

expanded by pre-processor to

#include "servos_4017_hw.h"

==== macros ====

conf/airframes/funjet1.xml
ap.CFLAGS += -DXBEE_UART=Uart1

sw/airborne/xbee.h
#define __XBeeLink(dev, _x) dev##_x
#define _XBeeLink(dev, _x) __XBeeLink(dev, _x)
#define XBeeLink(_x) _XBeeLink(XBEE_UART, _x)
#define XBeeBuffer() XBeeLink(ChAvailable())

expanded by pre-processor to

Uart1ChAvailable()

=== C code generation ===

For problems too complex to solve with the pre processor, we use custom compilers to generate code from a description in xml

==== example 1 : command laws, aka mixers ====
conf/airframes/funjet1.xml
<command_laws>
<let var="aileron" value="@ROLL * AILEVON_AILERON_RATE"/>
<let var="elevator" value="@PITCH * AILEVON_ELEVATOR_RATE"/>
<set servo="AILEVON_LEFT" value="$elevator + $aileron"/>
<set servo="AILEVON_RIGHT" value="$elevator - $aileron"/>
</command_laws>

generated var/FJ1/airframe.h
#define SetActuatorsFromCommands(values) { \
uint16_t servo_value;\
float command_value;\
int16_t _var_aileron = values[COMMAND_ROLL] * AILEVON_AILERON_RATE;\
int16_t _var_elevator = values[COMMAND_PITCH] * AILEVON_ELEVATOR_RATE;\
[....]
command_value = _var_elevator + _var_aileron;\
command_value *= command_value>0 ? SERVO_AILEVON_LEFT_TRAVEL_UP : SERVO_AILEVON_LEFT_TRAVEL_DOWN;\
servo_value = SERVO_AILEVON_LEFT_NEUTRAL + (int16_t)(command_value);\
actuators[SERVO_AILEVON_LEFT] = ChopServo(servo_value, SERVO_AILEVON_LEFT_MIN, SERVO_AILEVON_LEFT_MAX);\
Actuator(SERVO_AILEVON_LEFT) = SERVOS_TICS_OF_USEC(actuators[SERVO_AILEVON_LEFT]);\

==== example 2 : flight plan ====

conf/flight plans/example.xml
<block name="For loop (circles wp 1)">
<for from="0" to="3" var="i">
<circle radius="DEFAULT_CIRCLE_RADIUS+ $i*10" wp="1" until="NavCircleCount() > 1"/>
</for>
<deroute block="Standby"/>
</block>
generated var/flight plan.h
Block(29) // For loop (circles wp 1)
switch(nav_stage) {
static int8_t _var_i;
static int8_t _var_i_to;
Stage(0)
_var_i = 0 - 1;
_var_i_to = 3;
Label(for_11)
Stage(1)
if (++_var_i > _var_i_to) Goto(endfor_12) else NextStageAndBreak();
Stage(2)
NavVerticalAutoThrottleMode(RadOfDeg(0.000000));
NavVerticalAltitudeMode(WaypointAlt(3), 0.);
NavCircleWaypoint(3, (DEFAULT_CIRCLE_RADIUS+(_var_i*10)));
if ((NavCircleCount()>1)) NextStageAndBreak();
break;
Stage(3)
Goto(for_11)
Label(endfor_12)
Stage(5)
NextBlock();
break;
}

=== Makefile ===

==== Connecting and configuring modules ====

ap.CFLAGS += -DDOWNLINK -DDOWNLINK_TRANSPORT=XBeeTransport -DXBEE_UART=Uart1
ap.srcs += downlink.c xbee.c
ap.CFLAGS += -DUSE_UART1 -DUART1_BAUD=B9600
ap.srcs += \$(SRC_ARCH)/uart_hw.c

==== Modules configuration ====

3 sources of configuration:
* airframe configuration file ( airframe.xml ) which "compiled" to C files and Makefile
* specific per module configuration file ( eg radio.xml, flightplan.xml) compiled to C code to allow factorization between airframes.
* specific per board configuration file ( eg tiny.h ) to describe modules configuration imposed by board routing

[[Image:modules_configuration.png]]

=== Conventions ===

== Generating Doxygen Code Documentation ==

A way to look at the includes and dependencies is to use the graphs generated with doxygen. After installing Paparazzi, install Doxygen:

sudo apt-get install doxygen graphviz

run the generation tool from the paparazzi3/ directory:

make doxygen

Now Doxygen will have generated html documentation(open this with any web browser) in your paparazzi3/dox/html folder.

To look at a list of all of the files used by the airborne software:
paparazzi3/dox/html/files.html
The main_ap.c will also interest you.
paparazzi3/dox/html/main__ap_8c.html

This is a sample of a Doxygen Graph:
[[Image:Autopilot_8h_incl.png|Include dependency graph for autopilot.h]]

[[Category:Software]] [[Category:Hardware]] [[Category:Developer_Documentation]]

Dev/Debugging

2011-06-13T05:22:35Z

Sergio812:

= Introduction =
GDB can be used for debugging the code on the boards.

= Procedure =
# Start openocd in a new shell since this process needs to remain running.
#: To program the Lisa/L board run the command
#:<pre>openocd -f interface/lisa-l.cfg -f board/lisa-l.cfg</pre>
# Start GDB with an argument of the elf file created and uploaded to the board.
#: If you programmed with the ap target then the command would be along the lines of
#:<pre>arm-none-eabi-gdb var/<airframe>/ap/ap.elf</pre>
#: Replace <airframe> with the name of the airframe that has been built.
# Now connect GDB to the board
#:<pre>target remote localhost:3333</pre>
# Now we need to set some break points in the code.
#: In this example the ap target was part of the rotorcraft and main.c contains the main program. Open rotorcraft sw/airborne/firmwares/rotorcraft/main.c and find a line at which you'd like to set a break point.
#: <pre>break main.c:113</pre>
# Stop the currently running code
#: <pre>monitor reset halt</pre>
# Reset the code back to the start
#: <pre>monitor reset init</pre>
# We probably want to ignore the interrupt calls for the moment so we can step through the code as it's being called. Note that we don't always want to do this.
#:<pre>monitor cortex_m3 maskisr on</pre>
# Now we can run the program which will stop at the break point we set.
#:<pre>continue</pre>

== Useful commands ==
* A stack trace can be printed with the command
*:<pre>bt</pre>

[[Category:Software]] [[Category:Developer_Documentation]]

Lpc21BootloaderUpload

2011-06-13T05:21:28Z

Sergio812:

==Bootloader from scatch==

The goal of this page is to explain how to get the autopilot bootloader onto a ''brainless'' new ARM based autopilot board. Note that the bootloader only needs to be installed '''once''', when the board is first built and has never been used. Most of the times if you bought a board somewhere, the bootloader is already installed for you. If you did not make and soldered the Autopilot board yourself but bought it somewhere, chances are high the bootloader is already uploaded onto your board by the manufacturer. You could ask the supplier of your board. In that case you can just '''skip''' the steps described here and just continue the part of [http://paparazzi.enac.fr/wiki/Paparazzi_Center Uploading the Flightplan code to your autopilot board] or if you are more experienced you could go [http://paparazzi.enac.fr/wiki/Compiling here]

[[Image:Bare_TWOG_Board.jpg|thumb|right|Bare_TWOG_Board.jpg]]

==Why have Bootloader in the first place==

Since the Airborne code and Flight-plans change frequently, it would be great if we could just simply upload new version with changes on the ground by connecting an USB cable to out airframes autopilot board. Well, the Bootloader makes this a simple reality.

==How does it work==

The Bootloader is uploaded through the serial interface UART0 (Serial1) by connecting certain point on the board to '''ground''' during power-up, sometimes referred to as: ''holding low''. On the board Tiny V1.x pin P0.14, Tiny V2.x this pin is called BOOT). Also GPS_RESET has to be tied low during the serial programming to keep the GPS receiver quiet that shares the serial port with the download.

==Connecting it all==

You will need to convert the PC's RS232 Serial with voltage levels of +/-13V to 3.3V (or 5V) TTL in order to communicate directly with the Autopilot board. This can be accomplished in multiple ways. The easiest and most convenient method is to purchase or build a USB -> Serial 3.3V adapter similar to this one [http://www.ftdichip.com/Products/EvaluationKits/TTL-232R-3V3.htm TTL-232R-3V3] [[Image:The_FTDI_RS232_USB_Cable.jpg|thumb|right|The FTDI RS232 USB Cable]]

Some examples of suppliers:
[http://www.sparkfun.com/commerce/product_info.php?products_id=199]
[http://www.sparkfun.com/commerce/product_info.php?products_id=718]
[http://www.pololu.com/products/pololu/0391/]
[http://www.hvwtech.com/products_view.asp?CatID=166&SubCatID=183&SubSubCatID=0&ProductID=409]

It is strongly advised that you use a USB-serial converter with of the [[http://www.ftdichip.com/ FTDI brand]] chip, as serial chips from the FTDI brand are by default working well in Linux. As a nice bonus, the Paparazzi ground station software is configured to look for modems on FTDI ports by default, the converter can likely serve as a modem interface after it's use in Bootloader uploading.

Make up a wiring harness similar to the following.

<gallery>
Image:Cable_Bootloader_Full.jpg|Bootloader cable
Image:Cable_Bootloader_To_FTDI_USB.jpg|Bootloader cable to FTDI USB
Image:Bootloader_helper_cable_to_USB_FTDI_Cable.jpg|Bootloader helper cable to USB FTDI cable
</gallery>

You may vary the details, however this is a working solution:

Tiny V1.x (SERIAL_1): 
TINY RXD0 <-- PC SERIAL TX (5V or 3.3V)
TINY TXD0 --> PC SERIAL RX (5V or 3.3V)
TINY P0.14 --> attach to ground, or wire through a pushbutton to ground
TINY GND --> PC SERIAL ADAPTER GND
TINY RESET --> ''optional'' wired to ground through a pushbutton so you can reset

Tiny V2.x (Connectorname - DOWNLOAD) : 
TINY LPC_RXD0 <-- PC SERIAL TX (5V or 3.3V)
TINY LPC_TXD0 --> PC SERIAL RX (5V or 3.3V)
TINY BOOT --> attach to ground, or wire through a pushbutton to ground
TINY GPS_RESET --> attach to ground, or wire through a pushbutton to ground
TINY GND --> PC SERIAL ADAPTER GND

TWOG V1.x (Connectorname - DOWNLOAD): 
TWOG LPC_RXD0 <-- PC SERIAL TX (5V or 3.3V)
TWOG LPC_TXD0 --> PC SERIAL RX (5V or 3.3V)
TWOG BOOT --> attach to ground, or wire through a pushbutton to ground
TWOG GND --> PC SERIAL ADAPTER GND

For TWOG make sure the GPS module is '''unplugged''' from the board. This is to prevent GPS serial data to disturb the uploading of the bootloader.

[[Image:Where_To_Insert_Bootloader_Cable.jpg|thumb|right|Where to insert the Bootloader cable]]

==Upload the firmware==

Once this wiring is ready you will be ready to upload the bootloader to the autopilot board from your PC.

To prepare the Autopilot board to accept uploads over its serial port you must have pin P0.14 LOW for at least 3ms while it is powering up or resetting. While it is still powered up it is ready to accept the Bootloader firmware code upload over the serial connection.

<gallery>
Image:Point_To_Connect_Ground.jpg|Point to_connect ground
Image:Closeup_Ground_Point.jpg|Closeup ground point
Image:Grounding_For_Bootloader_Closeup.jpg|closeup grounding point detail for Bootloader uploading
</gallery>

The next step while your board is all connected and powered up is to type the commands for uploading the bootloader firmware.

<gallery>
Image:TWOG_Bootloader_Overview.jpg|TWOG Bootloader overview
Image:Powerup_Now.jpg|Everything ready to be powered-up now
</gallery>

'''In Linux'''

From your Paparazzi folder in Linux, type:

$ make upload_bl PROC=GENERIC

This will begin compiling your USB Bootloader and then attempt to transfer it to the Autopilot board. This will also assume you are using a USB -> Serial adapter for the connection. It uses /dev/ttyUSB0 by default. If your adapter is mapped to a different tty, you will need to modify the Makefile accordingly.

[[Image:Wait_For_Bootloader_To_Upload.jpg|thumb|left|Wait for the bootloader to upload]]

If everything is connected and setup correctly, after a while you will see the following messages

[[Image:Shell_bootloader_upload_success.jpg|thumb|left|Shell Bootloader upload success]]

'''In Windows'''

If for some reason you need to program your autopilot board USB Bootloader in MS Windows you have to download the [http://www.openuas.org/site/LPC2000_Flash_ISP_Utility_v2.2.3.zip LPC2000 Flash Utility V2.2.3] or later. You will then prepare the autopilot board and start it in ISP bootloader state as described previously. This small utility will ony help uploading the Bootloder firmware. You will need to copy your compiled '''bl.hex''' file from Linux to your Windows OS. This file will be then uploaded.

==Additional information==
In depth info about the bootloader can be found on the [http://paparazzi.enac.fr/wiki/Reference/bootloader Bootloader reference] page. Also the [http://paparazzi.enac.fr/wiki/DevGuide/USBDownload page here] explains some more.

[[Category:Software]] [[Category:User_Documentation]]

Lpc21BootloaderUpload

2011-06-13T05:16:11Z

Sergio812:

==Bootloader from scatch==

The goal of this page is to explain how to get the autopilot bootloader onto a ''brainless'' new ARM based autopilot board. Note that the bootloader only needs to be installed '''once''', when the board is first built and has never been used. Most of the times if you bought a board somewhere, the bootloader is already installed for you. If you did not make and soldered the Autopilot board yourself but bought it somewhere, chances are high the bootloader is already uploaded onto your board by the manufacturer. You could ask the supplier of your board. In that case you can just '''skip''' the steps described here and just continue the part of [http://paparazzi.enac.fr/wiki/Paparazzi_Center Uploading the Flightplan code to your autopilot board] or if you are more experienced you could go [http://paparazzi.enac.fr/wiki/Compiling here]

[[Image:Bare_TWOG_Board.jpg|thumb|right|Bare_TWOG_Board.jpg]]

==Why have Bootloader in the first place==

Since the Airborne code and Flight-plans change frequently, it would be great if we could just simply upload new version with changes on the ground by connecting an USB cable to out airframes autopilot board. Well, the Bootloader makes this a simple reality.

==How does it work==

The Bootloader is uploaded through the serial interface UART0 (Serial1) by connecting certain point on the board to '''ground''' during power-up, sometimes referred to as: ''holding low''. On the board Tiny V1.x pin P0.14, Tiny V2.x this pin is called BOOT). Also GPS_RESET has to be tied low during the serial programming to keep the GPS receiver quiet that shares the serial port with the download.

==Connecting it all==

You will need to convert the PC's RS232 Serial with voltage levels of +/-13V to 3.3V (or 5V) TTL in order to communicate directly with the Autopilot board. This can be accomplished in multiple ways. The easiest and most convenient method is to purchase or build a USB -> Serial 3.3V adapter similar to this one [http://www.ftdichip.com/Products/EvaluationKits/TTL-232R-3V3.htm TTL-232R-3V3] [[Image:The_FTDI_RS232_USB_Cable.jpg|thumb|right|The FTDI RS232 USB Cable]]

Some examples of suppliers:
[http://www.sparkfun.com/commerce/product_info.php?products_id=199]
[http://www.sparkfun.com/commerce/product_info.php?products_id=718]
[http://www.pololu.com/products/pololu/0391/]
[http://www.hvwtech.com/products_view.asp?CatID=166&SubCatID=183&SubSubCatID=0&ProductID=409]

It is strongly advised that you use a USB-serial converter with of the [[www.ftdichip.com|FTDI brand]] chip, as serial chips from the FTDI brand are by default working well in Linux. As a nice bonus, the Paparazzi ground station software is configured to look for modems on FTDI ports by default, the converter can likely serve as a modem interface after it's use in Bootloader uploading.

Make up a wiring harness similar to the following.

<gallery>
Image:Cable_Bootloader_Full.jpg|Bootloader cable
Image:Cable_Bootloader_To_FTDI_USB.jpg|Bootloader cable to FTDI USB
Image:Bootloader_helper_cable_to_USB_FTDI_Cable.jpg|Bootloader helper cable to USB FTDI cable
</gallery>

You may vary the details, however this is a working solution:

Tiny V1.x (SERIAL_1): 
TINY RXD0 <-- PC SERIAL TX (5V or 3.3V)
TINY TXD0 --> PC SERIAL RX (5V or 3.3V)
TINY P0.14 --> attach to ground, or wire through a pushbutton to ground
TINY GND --> PC SERIAL ADAPTER GND
TINY RESET --> ''optional'' wired to ground through a pushbutton so you can reset

Tiny V2.x (Connectorname - DOWNLOAD) : 
TINY LPC_RXD0 <-- PC SERIAL TX (5V or 3.3V)
TINY LPC_TXD0 --> PC SERIAL RX (5V or 3.3V)
TINY BOOT --> attach to ground, or wire through a pushbutton to ground
TINY GPS_RESET --> attach to ground, or wire through a pushbutton to ground
TINY GND --> PC SERIAL ADAPTER GND

TWOG V1.x (Connectorname - DOWNLOAD): 
TWOG LPC_RXD0 <-- PC SERIAL TX (5V or 3.3V)
TWOG LPC_TXD0 --> PC SERIAL RX (5V or 3.3V)
TWOG BOOT --> attach to ground, or wire through a pushbutton to ground
TWOG GND --> PC SERIAL ADAPTER GND

For TWOG make sure the GPS module is '''unplugged''' from the board. This is to prevent GPS serial data to disturb the uploading of the bootloader.

[[Image:Where_To_Insert_Bootloader_Cable.jpg|thumb|right|Where to insert the Bootloader cable]]

==Upload the firmware==

Once this wiring is ready you will be ready to upload the bootloader to the autopilot board from your PC.

To prepare the Autopilot board to accept uploads over its serial port you must have pin P0.14 LOW for at least 3ms while it is powering up or resetting. While it is still powered up it is ready to accept the Bootloader firmware code upload over the serial connection.

<gallery>
Image:Point_To_Connect_Ground.jpg|Point to_connect ground
Image:Closeup_Ground_Point.jpg|Closeup ground point
Image:Grounding_For_Bootloader_Closeup.jpg|closeup grounding point detail for Bootloader uploading
</gallery>

The next step while your board is all connected and powered up is to type the commands for uploading the bootloader firmware.

<gallery>
Image:TWOG_Bootloader_Overview.jpg|TWOG Bootloader overview
Image:Powerup_Now.jpg|Everything ready to be powered-up now
</gallery>

'''In Linux'''

From your Paparazzi folder in Linux, type:

$ make upload_bl PROC=GENERIC

This will begin compiling your USB Bootloader and then attempt to transfer it to the Autopilot board. This will also assume you are using a USB -> Serial adapter for the connection. It uses /dev/ttyUSB0 by default. If your adapter is mapped to a different tty, you will need to modify the Makefile accordingly.

[[Image:Wait_For_Bootloader_To_Upload.jpg|thumb|left|Wait for the bootloader to upload]]

If everything is connected and setup correctly, after a while you will see the following messages

[[Image:Shell_bootloader_upload_success.jpg|thumb|left|Shell Bootloader upload success]]

'''In Windows'''

If for some reason you need to program your autopilot board USB Bootloader in MS Windows you have to download the [http://www.openuas.org/site/LPC2000_Flash_ISP_Utility_v2.2.3.zip LPC2000 Flash Utility V2.2.3] or later. You will then prepare the autopilot board and start it in ISP bootloader state as described in the previous. This small utility will ony help uploading the Bootloder firmware. You will need to copy your compiled '''bl.hex''' file from Linux to your Windows OS. This file will be then uploaded.

==Additional information==
In depth info about the bootloader can be found on the [http://paparazzi.enac.fr/wiki/Reference/bootloader Bootloader reference] page. Also the [http://paparazzi.enac.fr/wiki/DevGuide/USBDownload page here explains some more]]

[[Category:Software]] [[Category:User_Documentation]]

Lpc21iap

2011-06-13T05:11:01Z

Sergio812:

== lpc21iap ==

This is a download application for Philips LPC processors. So far only the LPC214x series is supported (others don't have USB function). The built-in bootloader serial download for the LPC processors is not the fastest. An USB download might be much faster and convenient.

An entire LPC2148 is re-flashed (erase, download, flash and verify 500kB) in a couple of seconds. Multiple LPC processors can be used and flashed with specific flash images by having different serial numbers.

Bertrik Sikken provided a neat and easy-to-use USB library lpcusb that is the base for the embedded software. The lpc21isp software from Martin Maurer inspired the PC software. The libusb package is the API to have an easy access to the USB with Linux, Cygwin and Windows.

Get libusb from sourceforge, install it. You might have to fiddle with hotplug or udev when using Linux for appropriate USB device access rights (see conf/system in the Paparazzi cvs). Make lpc21iap and the bootloader software for the target. Flash the bootloader bl.hex with lpc21isp.

The first four 4096 bytes sectors (=16kByte) are reserved for the bootloader. Your application should be linked to 0x4000 (don't forget the '-n' option when linking to allow being located exactly there). The bootloader interrupt vectors are re-directed to 0x4000 except the reset and the irq vector (use the VIC). After a reset the bootloader will check the Vbus (P0.23) pin (or any other, change it easily in crt.s) if it is set. If yes, the bootloader is started. Otherwise it will jump to 0x4000. The irq vector will read the reset vector from the VIC register. If you want to use USB in your application, change either the bootpin in crt.s or set it to one manually by writing '1' to GPIO P0.23.

If you want to flash the first four sectors with lpc21iap you have to use the RAM version bl_ram.elf.

The used USB vendor/device ID is made up (0x7070/0x1234). Someone willing to donate one?

== Install ==

Get the libusb and libusb-dev (both are included with the paparazzi-dev packages). For Windows and Cygwin, get libusb and generate a .inf file with vendor ID 0x7070 and product ID 0x1234 using the libusb instructions. Build the Linux and Cygwin version with the make file or use the command line for Windows:

cl lpc21iap.c elf.c lpcusb.c libusb.lib

Install it with the NXP serial tool, JTAG interface or lpc21isp. Connect USB and download your application.

lpc21iap myapp.elf <serial number>

To reflash the bootloader first load the RAM version and then the new bootloader.

lpc21iap bl-ram.elf
lpc21iap bl.elf

The lpc21iap and bootloader can be found in the Paparazzi cvs

http://cvs.savannah.nongnu.org/viewvc/paparazzi3/sw/ground_segment/lpc21iap/?root=paparazzi
http://cvs.savannah.nongnu.org/viewvc/paparazzi3/sw/airborne/arm7/test/bootloader/?root=paparazzi

== Protocol ==

The Philips LPC21 ISP and IAP commands are used to communicate with the device. They are transparently transferred over USB. Either of the protocols can be used (each command set includes commands the other one does not support). Some proprietary bootloader BTL commands are added as well.

Every command consists of up to three phases. In the first phase the command plus parameters are given to the device and immediately executed. The host might receive a result in the second phase (not mandatory). The third phase is used to transfer data to/from the device. Some commands consist only of one phase (eg. GO), some need all three phases (eg. WRITE_TO_RAM).

The IAP and ISP commands are mapped to (endpoint 0) vendor requests. The switching between command and result is done by the direction bit in bmRequestType (Host-to-device = command). The bRequest is defined as:

REQ_ISP_COMMAND 0xF0
REQ_IAP_COMMAND 0xF1
REQ_BTL_COMMAND 0xF2
REQ_DATA_TRANSFER 0xF3

The wValue and wIndex of the request are reserved, write them as zero. The wLength defines the number of bytes to be transferred to/from device in this request. Command, result and data is transferred during the data phase of the vendor request. wLength is 20 bytes (5 words) in the command phase, 32 bytes (3 + 5 words) in result phase and can be any size in data phase. Little endian format is used for any data.

The command consists of 5 words as defined by Philips IAP/ISP definition. Word 0 is the command (eg. ASCII value 'G' for ISP_GO in ISP or value 56 in IAP for IAP_COMPARE. Word 1-4 give additional parameters.

The result size is 8 words. Word 0 gives the result and word 1-2 contains additional response information. Word 3-7 contain the original command that the result came from.

Some commands require additional data to be transferred. This data is send with one or more DATA_TRANSFER requests. The total length of data is defined in the command (eg. READ_MEMORY) phase. Data transfer sizes bigger than 4kBytes have to be split in several data transfer requests.

Example:

direction host->device
request REQ_ISP_COMMAND
command[0] ISP_WRITE_TO_RAM
command[1] (startaddress)
command[2] (size)
command[3] (undefined)
command[4] (undefined)

direction host<-device
request REQ_ISP_COMMAND
result[0] CMD_SUCCESS
result[1] (undefined)
result[2] (undefined)
result[3] ISP_WRITE_TO_RAM
result[4] (startaddress)
result[5] (size)
result[6] (undefined)
result[7] (undefined)

direction host->device
request REQ_DATA_TRANSFER
data[0] (data)
...
data[n] (data)

direction host->device
request REQ_DATA_TRANSFER
data[n+1] (data)
...
data[size] (data)

[[Category:Software]] [[Category:Developer_Documentation]]

DevGuide/Values

2011-06-13T04:58:42Z

Sergio812:

= How do values travel through the system? =

Make sure you have a ready built system when trying to analyze the
software. Some of the embedded code is generated from the xml
configuration files at build time. You can find that in the var folder
for the aircraft you are using.

=== RC transmitter ===

The most important sensor. It gives stick movements from the safety pilot to the aircraft. The values are derived from the angle of the sticks or from position switches. The minimum configuration for a Paparazzi transmitter is two sticks and one three-position switch for manual, auto1 and auto2.

The angle is usually given from -100% to 100% for full sweep and 0% for the middle position. These are the min and max positions and values we use for a transmitter with throttle on the right :

[[Image:radio_robbe.jpg|Robbe transmitter]]

RC transmitters generate a pulse-pause-modulation PPM signal from the angles. The information is in the length of a pulse. Usually a 1.5ms pulse is middle position and 1ms equals -100% and 2ms 100%. The pulses are sent as a packet and repeat at about 15ms rate The following shows a 9 channel transmitter (this is 10 pulses) and a decoded servo #1. Use RC_FUTABA in your airframe conf file if you see a signal like this (pulses go "high").

Note: Proprietary PCM is not supported directly by Paparazzi at this moment. Ofcourse if one knows or reversed the specific PCMx format one can add support to handle this format also. However it has no direct benefit for the autopilot project.

[[Image:9ch_pulses.png|9 Channel PPM signal]]

Various brands of RC transmitter can use slightly different timings for the middle and 100% positions and sometimes also have different directions. The /conf/radio folder contains settings for different transmitters, choose one that mostly resembles yours. Then adjust the file so it is tailored to your situation. Here, also no trim should be used. Give the repeat time of the PPM pulse and the number of channels (you have one pulse more than channels!). The switches can be filtered by a low pass filter through the [http://paparazzi.enac.fr/wiki/Radio_Control#Averaging "average"] descriptor.

=== RC receiver ===
The PPM signal is transmitted as FM signal and demodulated in your
receiver. The receiver demultiplexes the signals with a shift register
chip like 4015 or 4017 and gives it to servos. Paparazzi needs the
non-demultiplexed TTL level signal from the receiver. A good point to
grab that is the input of the shift register of the receiver (e.g. pin 1 of a 4015). Some newer receiver have microcontrollers which make it tricky to get the
signal.

[[Image:rx_jeti.jpg|Jeti Rex 4 receiver]]

The signal is low and goes high for the pulses in most cases, use
-DRADIO_CONTROL_TYPE=RC_FUTABA in your aircraft description file for
that. Some Graupner/JR receivers use inverted logic, use
-DRADIO_CONTROL_TYPE=RC_JR for them.

=== Inside Paparazzi ===

A normalized value is used for servo values within the Paparazzi
software. It ranges between MIN_PPRZ and MAX_PPRZ which is currently
-9600 and 9600. That is more than 14 bits resolution and a lot more
than what RC radios or servos can reproduce. Whenever a value is
calculated it should be trimmed to MIN and MAX by TRIM_PPRZ() or
TRIM_UPPRZ() for 0 and MAX bounds.

=== ADC sensors ===
Analog voltages between 0 and 3.3V can be measured with the internal
Analog/Digital converters (this refers to the LPC/ARM7 architecture).
The values are sampled through a NB_SAMPLES stages long low pass
filter. Every ADC pin has to be activated for ADC usage individually for
flexible configuration.

The resolution of the ADCs is 10 bits and that gives an integer value
between 0 and 1023 in the Paparazzi software. The values are converted
to more useful numbers for some sensors.

=== IR sensors ===
The thermopiles give a voltage as a (nonlinear) function of the
roll/tilt angle. The angle is calculated using the information given in
the aircraft file (neutral value, sensor alignment relative to the
aircraft axes, correction for diversity in sensitivity). Angles are
used as [http://en.wikipedia.org/wiki/Radian radians] (360° = 2 * pi) for calculations. Some flight plan
values are given in degrees, though.

=== SPI / I2C ===
Byte values can be read from SPI or I2C devices, e.g. to read data from
additional sensors.

=== Servos ===
At the end servos have to be moved. The PPRZ values are converted to
-100% .. 100% servo movements. The aircraft configuration file
describes the relation between the min/max actuation and the 1.0ms -
2.0ms long pulse.

[[Category:Software]] [[Category:RC]] [[Category:Developer Documentation]]

DevGuide/Values

2011-06-13T04:57:22Z

Sergio812:

= How do values travel through the system? =

Make sure you have a ready built system when trying to analyze the
software. Some of the embedded code is generated from the xml
configuration files at build time. You can find that in the var folder
for the aircraft you are using.

=== RC transmitter ===

The most important sensor. It gives stick movements from the safety pilot to the aircraft. The values are derived from the angle of the sticks or from position switches. The minimum configuration for a Paparazzi transmitter is two sticks and one three-position switch for manual, auto1 and auto2.

The angle is usually given from -100% to 100% for full sweep and 0% for the middle position. These are the min and max positions and values we use for a transmitter with throttle on the right :

[[Image:radio_robbe.jpg|Robbe transmitter]]

RC transmitters generate a pulse-pause-modulation PPM signal from the angles. The information is in the length of a pulse. Usually a 1.5ms pulse is middle position and 1ms equals -100% and 2ms 100%. The pulses are sent as a packet and repeat at about 15ms rate The following shows a 9 channel transmitter (this is 10 pulses) and a decoded servo #1. Use RC_FUTABA in your airframe conf file if you see a signal like this (pulses go "high").

Note: Proprietary PCM is not supported directly by Paparazzi at this moment. Ofcourse if one knows or reversed the specific PCMx format one can add support to handle this format also. However it has no direct benefit for the autopilot project.

[[Image:9ch_pulses.png|9 Channel PPM signal]]

Various brands of RC transmitter can use slightly different timings for the middle and 100% positions and somtimes also have different directions. The /conf/radio folder contains settings for different transmitters, choose one that mostly resemles yours. Then adjust the file so it is tailored to your situation. Here, also no trim should be used. Give the repeat time of the PPM pulse and the number of channels (you have one pulse more than channels!). The switches can be filtered by a low pass filter through the [http://paparazzi.enac.fr/wiki/Radio_Control#Averaging "average"] descriptor.

=== RC receiver ===
The PPM signal is transmitted as FM signal and demodulated in your
receiver. The receiver demultiplexes the signals with a shift register
chip like 4015 or 4017 and gives it to servos. Paparazzi needs the
non-demultiplexed TTL level signal from the receiver. A good point to
grab that is the input of the shift register of the receiver (e.g. pin 1 of a 4015). Some newer receiver have microcontrollers which make it tricky to get the
signal.

[[Image:rx_jeti.jpg|Jeti Rex 4 receiver]]

The signal is low and goes high for the pulses in most cases, use
-DRADIO_CONTROL_TYPE=RC_FUTABA in your aircraft description file for
that. Some Graupner/JR receivers use inverted logic, use
-DRADIO_CONTROL_TYPE=RC_JR for them.

=== Inside Paparazzi ===

A normalized value is used for servo values within the Paparazzi
software. It ranges between MIN_PPRZ and MAX_PPRZ which is currently
-9600 and 9600. That is more than 14 bits resolution and a lot more
than what RC radios or servos can reproduce. Whenever a value is
calculated it should be trimmed to MIN and MAX by TRIM_PPRZ() or
TRIM_UPPRZ() for 0 and MAX bounds.

=== ADC sensors ===
Analog voltages between 0 and 3.3V can be measured with the internal
Analog/Digital converters (this refers to the LPC/ARM7 architecture).
The values are sampled through a NB_SAMPLES stages long low pass
filter. Every ADC pin has to be activated for ADC usage individually for
flexible configuration.

The resolution of the ADCs is 10 bits and that gives an integer value
between 0 and 1023 in the Paparazzi software. The values are converted
to more useful numbers for some sensors.

=== IR sensors ===
The thermopiles give a voltage as a (nonlinear) function of the
roll/tilt angle. The angle is calculated using the information given in
the aircraft file (neutral value, sensor alignment relative to the
aircraft axes, correction for diversitiy in sensitivity). Angles are
used as [http://en.wikipedia.org/wiki/Radian radians] (360° = 2 * pi) for calculations. Some flight plan
values are given in degrees, though.

=== SPI / I2C ===
Byte values can be read from SPI or I2C devices, e.g. to read data from
additional sensors.

=== Servos ===
At the end servos have to be moved. The PPRZ values are converted to
-100% .. 100% servo movements. The aircraft configuration file
describes the relation between the min/max actuation and the 1.0ms -
2.0ms long pulse.

[[Category:Software]] [[Category:RC]] [[Category:Developer Documentation]]

DevGuide/Communications

2011-06-13T04:56:17Z

Sergio812:

This page describes the way the communications with the aircrafts are implemented in paparazzi

We'll start with high level stuff such as sending your own telemetry message or datalink (uplink) message. We'll then look at the lower layers
== sending telemetry message ==

Describe your message in the telemetry section in <tt>conf/messages.xml</tt>

This should looks like this

<message name="MARK" id="32">
<field name="ac_id" type="uint8"/>
<field name="lat" type="float" unit="deg"/>
<field name="long" type="float" unit="deg"/>
<field name="alt" type="uint32" unit="mm" alt_unit="m" alt_unit_coef="1000"/>
</message>

The '''id''' has to be unique. The fields can have type '''int8''', '''int16''', '''int32''', '''uint8''', '''uint16''', '''uint32''', '''float''' and arrays of those. They must be aligned on a multiple of their size (c.f. examples with ''pad'' fields).

The '''alt_unit''' and '''alt_unit_coef''' will be used the [[RTPlotter|Plotter]] and the [[Messages|Messages]] agents to display human readable values.
When '''alt_unit_coef''' is not specified, some basic default conversions are automatic:
* deg <-> rad
* deg/s <-> rad/s
* m <-> cm
* m/s <-> cm/s
* decideg -> deg

This enables all the ground system to deal with your message and generate sending code for the airborne system. The code is generated in <tt>var/include/messages.h</tt>.

From the airborne code you can send the message by using this code, for example

DOWNLINK_SEND_MARK(&mark_id, &mark_lat, &mark_long, &mark_alt);

You can also have the autopilot send the message periodically.
For doing so, in your telemetry file (for example <tt>conf/telemetry/default.xml</tt>, you can make your own and reference it in the [[Conf.xml|<tt>conf/conf.xml</tt>]] file). You can add a line like

<message name="MARK" period="1"/>

meaning that '''MARK''' will be sent every second. You then need to specify the arguments to your message in <tt>the sw/airborne/ap_downlink.h</tt> header by providing a macro

#define PERIODIC_SEND_MARK() DOWNLINK_SEND_MARK(&mark_id, &mark_lat, &mark_long, &mark_alt)

You can have different telemetry modes having different rates for each message. For example you might want a verbose mode and a stealth mode.

When sent by the aircraft the message will be available on the ground ivy bus. You can watch it using the '''messages''' program or with the <tt>ivyprobe</tt> command line ( <tt>ivyprobe '(.*)'</tt> ).

The file <tt>sw/ground_segment/cockpit/ant_track.c</tt> shows how to receive a message in a C program.
For ocaml, we have a higher level library to receive messages (<tt>sw/lib/ocaml/pprz.ml</tt>).

== Adding datalink (uplink) messages ==

This is similar to the above. Add your message in the <tt>datalink</tt> section of <tt>messages.xml</tt>
This will generate parsing code for the airborne program (<tt>var/include/dl_protocol.h</tt>).

You then can add your handler in the <tt>sw/airborne/datalink.c</tt> code (a way should be found to include external code in that) or you can just rewrite your own <tt>dl_parse_msg()</tt> function, for example in a test program where you want to receive only your own messages.

== The "transport" layer ==

Paparazzi can use the built-in transport layer of different hardware (currently only wavecards and xbee/xtends) and also provides his own layer for hardware lacking it (showing as remote serial ports). C sourcecode (.c) and belonging header (.h) -files are:
<tt>xbee.c, xbee.h</tt>
and
<tt>pprz_transport.c, pprz_transport.h</tt>

[[Category:Software]] [[Category:Developer_Documentation]]

Contributing

2011-06-13T04:47:34Z

Sergio812:

== How to contribute ==
There are of course lots of ways to contribute to Paparazzi and get involved.

Help is always welcome on all aspects of the project. May this be documentation, wiki, maintenance, electronics or code contributions/fixes.

=== Wiki ===
Just create an account and you can start adding information, cleaning it up or just fixing some typo you just noticed :-)

=== Software development ===
We use the distributed version control system [http://git-scm.com/ git]. The [http://github.com/paparazzi/paparazzi/ Papaprazzi master repository is hosted on Github].

Please also see the [[Git|Git wiki page]] for more details about setting up Git and cloning the sourcecode and data repository.

Here is the short version if you already know git:
# Create an account on [http://github.com/ github].
# Fork the [http://github.com/paparazzi/paparazzi/ papaprazzi repo] on github. (After logging in press the '''fork''' button).
# '''git clone git@github.com:<yourname>/paparazzi.git'''
# fix/code
# push your feature/bugfix branch
# Send us a [http://help.github.com/pull-requests/ pull request] on github. (Or send patches to the mailing list).

=== Issue/Feature Tracker ===
To report bugs, issues and feature request please use either the mailing list or even better the simple [https://github.com/paparazzi/paparazzi/issues issue tracker on github]

[[Category:Developer_Documentation]]

DevGuide/LearningToProgram

2011-06-13T04:46:44Z

Sergio812:

== Introduction ==

There sometimes comes a moment that you would like to have more functionality in the Paparazzi GCS, in the airborne code or somewhere else. This non existent functionality does not come out of the blue. It took all the people involved blood, sweat and tears to get where the paparazzi is now. Also for you, it can be very rewarding to program improvements for the paparazzi. Some words of advise: first make sure you used the already available Paparazzi Autopilot for an extensive amount of time. Also you have read a year or so in the Wiki and are comfortable with all that there is written. You also managed to compile airborne via the command line, then there is a moment you might delve deeper into the Paparazzi and learn to code.

If this is your first programming experience it is maybe better to learn to program some generic desktop applications first. Altering and enhancing the code is even for seasoned programmers not a trivial task. Now if all of this did not make you less motivated, great! Let's get to it.

On this page you will not find in depth info of the languages use. There are much better resource on the internet already than we could ever provide in this Wiki. Therefore there are only link to learning these languages.

What can be found are code snippets '''directly''' related to the paparazzi code.

== Languages ==

The whole of paparazzi is written in various programming languages.

=== OCAML ===

The Objective Caml system is the main implementation of the Caml language. It is a functional programming language, and also features a powerful module system and a full-fledged object-oriented layer. It comes with a native-code compiler that supports numerous architectures, for high performance; a bytecode compiler, for increased portability; and an interactive loop, for experimentation and rapid development.

http://www.ocaml-tutorial.org/

=== C ===

http://www.cprogramming.com/tutorial.html

=== Python ===

Python is a clear and powerful object-oriented programming language, comparable to Perl, Ruby, Scheme, or Java.

http://wiki.python.org/moin/BeginnersGuide

== Makefiles ==

Makefiles also can be seen as small, sometimes even large programs.

http://www.tutorialspoint.com/makefile/index.htm

[[Category:Software]] [[Category:Developer_Documentation]]

Dev/STM32I2C

2011-04-15T09:17:51Z

Sergio812:

This page is a work document about STM32 driver
Ideas welcome!