Flappy Hummingbird: An Open Source Dynamic Simulation of Flapping Wing Robots and Animals

This still work in progress. Full version will be released by May 20th 2019 and presented at ICRA2019.

To cite this work in publications:

@inproceedings{fei2019flappy,
  title={Flappy Hummingbird: An Open Source Dynamic Simulation of Flapping Wing Robots and Animals},
  author={Fei, Fan and Tu, Zhan and Yang, Yilun and Zhang, Jian and Deng, Xinyan},
  booktitle={2019 IEEE International Conference on Robotics and Automation (ICRA)},
  year={2019},
  organization={IEEE}
}

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See deployment for notes on how to deploy the project on a live system. We provide three environment options.

1. Pydart2 source code included in our project.(So you don't need to install it.)
2. Pydart2 source code not included in our project.(You need to install it, which is painful.)
3. Docker

Flappy requires python3.5 with the development headers. You'll also need some other system packages. DART is required as simulation engine (and we use pydart2 as interface). They can be installed as follows

# install system packages
sudo apt-get update && sudo apt-get install cmake libopenmpi-dev python3-dev zlib1g-dev swig python3-pip python3-pyqt4 python3-pyqt4.qtopengl

# install dart
sudo apt-add-repository ppa:dartsim
sudo apt-get update
sudo apt-get install libdart6-all-dev

Please refer the official DART installation document when you have problems.

Installation of system packages on Mac requires Homebrew. With Homebrew installed, run the follwing:

# install system packages
brew install cmake openmpi

# install dart
brew install dartsim

1. Pydart2 source code included in our project. (No installation required)
   • Please continue your steps here
2. Pydart2 source code not included in our project. (Installation required, which is painful.)

   https://github.com/purdue-biorobotics/flappy

3. Docker (If you do not have access to recommanded OS environment)

   https://github.com/chen3082/docker

From the general python package sanity perspective, it is a good idea to use virtual environments (virtualenvs) to make sure packages from different projects do not interfere with each other. Creation of virtual environments is done by executing the command venv:

python3 -m venv /path/to/new/virtual/environment

To activate a venv:

source /path/to/venv/bin/activate

• Pydart2 is a python binding to DART.

  [Pydart2 document] (https://pydart2.readthedocs.io/en/latest/install.html) .

  Since install pydart2 is way too complicated, we move the source code inro our project. However, you still need all the dependency.(Please refer to pydart2 document.)

  We still provided the option with install pydart2. Please refer to this document how to install pydart2. https://docs.google.com/document/d/1ePNJz5doYTVeDrGQMqlDE4xAh21omrZQ1bu84MNTb4U/edit?usp=sharing

• Tensorflow is needed for the usage of neural network. If you want to make use of your GPU, please install the tensorflow with gpu

  pip install tensorflow-gpu # if you have a CUDA-compatible gpu and proper drivers

  else

  pip install tensorflow

  please refer to TensorFlow installation guide for more details.

• Clone the repo and cd into it:

  git clone https://github.com/purdue-biorobotics/flappy.git
  cd flappy

• Install Flappy package

  pip install -e .

Dual motor driven flapping wing robots based on the Purdue Hummingbird robot.

The control of this vehicle is a difficult problem. We challenge developers, researchers, scientists and roboticists to come up with better control algorithms, either feedback controller or learning based controller.

Two default working controller are included: a cascading PID controller (control structure similar to ArduPilot) and an Adaptive Robust Controller (ARC). These two controller can be evaluated in the provided test script.

This environment is for controlling the dual wing flappin wing robot.

The four inputs are the thrust and torque signals: * voltage_amplitude_ [0,18] volt for thrust * differential_voltage_ [-3,3] volt for roll torque * mean_voltage_ [-3.5,3.5] volt for pitch torque * split_cycle_ [-0.15,0.15] for yaw torque

This mode of control is similar to helicopter or quadcopter control. The sinusodial voltage signal drives the wing back and forth is generated using wing beat modulation.

The input actions are in [-1,1] and will be scaled to their approprate range. If implementing a feedback controleller, the input should be scaled to [-1,1]. See the baseline PID controller and test example for detail.

python test.py --model_type=PID
python test.py --model_type=ARC

We choose to use stable baselines instead of baselines as our RL library. Note that our environment still follow the specification of gym/env, so baselines can be applied to our env as well.

python train.py --model_type=PPO2 --model_path=ppo2_mlp --policy_type=MlpPolicy --n_cpu=12 --time_step=100000
python train_maneuver_DDPG.py --model_path=DDPG_mlp --time_step=100000

python test.py --model_type=PPO2 --model_path=ppo2_mlp --policy_type=MlpPolicy

This environment similar to 'fwmav_hover-v0', but without using [wing beat modulation][doman2010wingbeat].

An example using PID is in test_simple.py, this example still uses the same PID controller and wing beat modulation. But the input to the environment are just two voltage signals ([-18,18] volt) supplied to the two motor.

To develop a new control policy, the policy should try to generate sinusoidal signals near 34Hz to drive the wings and implement control at the same time. Without specifiing the wing kinematics allows the ability to generate torque and force in arbitrary directions.

python test_simple.py --model_type=PID
python test_simple.py --model_type=ARC

in ubuntu16.04

To build the image: sudo docker build -t first .
To run the image: sudo docker run --net=host -it -e DISPLAY=$DISPLAY first

Fan Fei, Ruoyu Wu, Jian Zhang, Yunlei Yan, Yuan-Cheng Chen, Tarcan Gul,

MIT