Category:Autopilots

STM32H7 based boards
STM32H7 32-bit ARM Cortex™-M7 MCU based autopilot:

• Tawaki v2.01 New!
  Improved MCU, Sensors and Power supply. Small, lightweight and versatile Autopilot, 9 DOF IMU, microSD, Baro, USB-C, ready for Rotorcraft, Fixed Wing and Hybrid applications...

STM32F7 based boards
STM32F7 32-bit ARM Cortex™-M7 based autopilot:

• Tawaki v1.10
  Small, lightweight and versatile Autopilot, 9 DOF IMU, microSD, Baro, ready for Rotorcraft, Fixed Wing and Hybrid applications...
• Chimera v1.00
  Versatile Autopilot for fixed wing, 9 DOF IMU, Baro, microSD, Pitot, Modem, ready for Companion Computer...

STM32F1 based boards

• Lisa
  STM32F1 based autopilots:
  • Lisa/S
    STM32 micro footprint autopilot
  • Lisa/M v1.0
    STM32 small footprint autopilot
  • Lisa/M v2.0
    Improved STM32 small footprint autopilot
  • Lisa/L
    STM32/Overo high performance autopilot

STM32F4 based boards

• Apogee
  STM32F4 (ARM Cortex™-M4) based autopilot for fixed wing:
  • Apogee v1.00
    Super small and lightweight autopilot, 9 DOF IMU, microSD high speed, Baro, ,...

• Elle
  STM32F4 autopilot system:
  • Elle0 New!
    STM32F4 small and affordable autopilot

• Lisa
  STM32F4 based autopilots:
  • Lisa/MX
    STM32F4 versatile autopilot with crypto support
  • Lisa/MX-Small
    STM32F4 versatile autopilot with crypto support

• Krooz
  STM32F4 Cortex™-M4 high integrated Rotorcraft autopilot
  • Krooz
    STM32F4 Cortex™-M4 high integrated Rotorcraft autopilot
  • KroozSD
    STM32F4 Cortex™-M4 high integrated autopilot, w. microSD slot, XBee conn.

• Pixhawk
  Duo processor with Autopilot core on a STM32F4 Cortex™-M4 and Fly By Wire core on a STM32F1 Cortex™-M1

LPC2148 based boards

• Booz
  Quadrotor autopilot

• NavGo
  Multirotor autopilot
  • NavGo v3
    Small and lightweight multirotor autopilot

• Umarim
  LPC based embedded IMU autopilot designed for small fixed wing:
  • Umarim v1
    full sensor set for small fixed wing
  • Umarim Lite v2
    light sensor set version of Umarim

• Tiny
  GPS integrated lightweight autopilots:
  • Tiny v0.99
    Tiny autopilot
  • Tiny v1.1
    Integrated GPS and 5V/2A supply
  • Tiny v2.11
    Two layers PCB, 0603 components, big GPS groundplane, improved connectivity.

• TWOG v1.0
  8 grams Tiny WithOut GPS autopilot, with external GPS option.

• YAPA
  Yet Another Paparazzi Autopilot:
  • YAPA v1.0
    Same as TWOG, but bigger with XBee, 100mil headers, mounting holes, rs232
  • YAPA v2.0 Reduced component cost

• Classix
  Dual MCUs, Gumstix connectivity

• HB
  Autopilots built in Bremen:
  • HB v1.0
    Four layers PCB, no GPS, JTAG with IMU
  • HB mini
    Four layers planar PCB, JTAG, 10 sevos, 12g, no GPS, with IMU

Aircraft With Embedded Autopilots

• Parrot
  • AR Drone 2
  • Bebop
  • Disco
  • Minidrones (Swing, Rolling Spider, Mambo, ...)

Archive

• Previous Versions
  Schematics and support for previous versions

One of the great advantages of Paparazzi is support for many hardware designs. There is autopilot hardware that is specifically designed to work with Paparazzi from the start, but Paparazzi has also been ported to other popular autopilots.

Paparazzi designed hardware

Most current autopilots are designed around two primary processors:

• STM32 series microcontrollers
• LPC21xx series microcontrollers

There are active and current autopilots designs using both architectures. Not all autopilots have the same capabilities, peripherals or features, but each has advantages in different applications.

Currently, boards are designed around the STM32 microcontollers. Some of the autopilots use the STM32F1 and others the STM32F4 microcontrollers. This provides a wide range of choices resulting in a large variety of peripherals and speeds. Architecture-dependent firmware code is supported in part by libopencm3, as well as Chibi OS through the Paparazzi RT branch.

The LPC21xx based boards use the LPC2148 and have been flying fixed wing and multi-rotors for many years. This architecture is more mature but at the expense of speed and extra ports available on the newer STM32 series processors. The Tiny series, Booz, TWOG, YAPA, Umarim and NavGo autopilots all use the LPC2148.

Newer autopilots use either the STM32F1 or STM32F4 microcontrollers. You can choose from Lisa/M(X), Elle0, Krooz or Apogee autopilots, depending on your processing and IO needs.

Some autopilots have also been designed for close integration with small single-board computers, particularly those based on OMAP processors such as the Gumstix Overo series. The Lisa/L and Classix boards are designed with this in mind, though other autopilots can be easily interfaced. Further information can be found here.

A basic feature comparison table is presented to help in the autopilot hardware selection process.

For information regarding architecture and firmware compatibility of various subsystems and modules, please see the appropriate Subsystems overview and Modules List pages.

Other popular autopilot hardware support

Using existing hardware is great to get started, as sometimes it just involves buying a stock drone and uploading paparazzi to it. Currently, Paparazzi supports many of the popular Parrot drones, such as the AR Drone 2, Bebop and Rolling Spider airframes. These come with built in embedded Linux computers as their autopilot hardware, and Paparazzi runs as a Linux process interfacing at the lowest level possible with the hardware.

Secondly, Paparazzi supports the Pixhawk autopilot, of which an example can be found in the Iris airframe. The Pixhawk is a duo processor board, with an autopilot chip and a separated Fly By Wire chip for safety.

Also the Pixracer board is flyable by Paparazzi. The cryptic name is px4fmu 4.0, that means all designs based on the open pxfmu 4.0 schematic design can be used.

Schematics, CAD files, Gerber files, BOM release strategy

About the hardware development and release process.

Files needed to create the hardware can be found here. It is always good to remind oneself of the email Antoine once wrote in the mailing list before you want to start producing your own PCB's.

8 June 2011 13:25:47 Antoine Drouin wrote on the mailing list:

I've started this project together with Pascal 8 years ago and since then I have dedicated my time to try and make it successful. I'm utterly convinced of the benefits of open source, but observing how Paparazzi grew over time, I came to the conclusion that hardware is a bit different than software... "gcc tiny.brd" is not going to make a board magically appear on your desktop.

I'll list here some of my arguments in favor of releasing CAD files after the board is mature.

1. Unlike software, where an unskilled user can type make and get a piece of complex software to successfully build, assembling hardware requires tools and skills. Providing gerbers and BOM have lured a bunch of new users into believing otherwise and has created tons of frustration. I've myself fixed a number of badly assembled boards and I even recall that while helping debugging a board (so after assembly), discovering that the person had manufactured two layers PCBs instead of four layers. As the technology of the autopilot increases, this problem becomes more and more important.
2. The success of the project depends on the availability of affordable hardware. The price of hardware is directly and exponentially dependent on the number of manufactured units. If ten persons manufacture 10 boards each, the cost will be much higher than if one person manufactures 100.
3. Last and not least, the quality of assembly also depends very much on the number of manufactured units. Good quality can only be achieved through the use of automated placing and soldering, and those processes can only be used if the number of units reach a certain amount.

For the autopilot comparison table see below.