This is Skywalker Flight #74, flown on Sept. 7, 2017. It ended up being a 38.5 minute flight–scheduled to land right at sunset. The purpose of the flight was to carry insect traps at 300′ AGL and collect samples of what might be flying up at that altitude.
What I like about this flight is that the stable sunset air leads to very consistent autopilot performance. The circle hold is near perfect. The altitude hold is +/- 2 meters (usually much better), despite continually varying bank angles which are required to hold a perfect circle shape in 10 kt winds.
The landing at the end is 100% autonomous and I trusted it all the way down, even as it dropped in between a tree-line and a row of turkey barns. The whole flight is presented here for completeness, but feel free to skip to part 3 if you are interested in seeing the autonomous landing.
As an added bonus, stick around after I pick up the aircraft as I walk it back. I pan the aircraft around the sky and you can clearly see the perfect circle hold as well as the landing approach. I use augmented reality techniques to overlay the flight track history right into the video–I think it’s kind of a “cool tool” for analyzing your autopilot and ekf performance.
The U of MN UAV Lab has flown a variety of sensors in aircraft, ranging from the lowly MPU-6000 (such as is found on an atmel based APM2 board) all the way up to an expensive temperature calibrated VectorNAV VN-100T. I wish to present a quick field comparison of these two sensors.
[disclaimers: there are many dimensions to any comparison, there are many individual use cases, the vn100 has many features not found on a cheap MPU-6000, the conditions of this test are not perfectly comparable: two different aircraft flown on two different days. These tests are performed with a specific MPU-6000 and a specific VN-100T — I can’t say these predict the performance of any other specific IMU. Both sensors are being sampled at 100hz externally. Internally the MPU-6000 is being sampled at 500hz and filtered. I suspect the VN-100T is outputting unfiltered values — but that is just a guess from the plot results.]
The point of this post is not to pick on the expensive solution, comparisons are difficult with a perfectly level playing field. But hopefully I can show that in many ways, the less expensive solution may not be as bad as you thought–especially with a little calibration help.
Exhibit A: Raw gyro data in flight
I will mostly let the plots speak for themselves, they share the same vertical scale and cover about the same time span. The less expensive sensor is clearly less noisy. This trend holds up when the two sensors are motionless on the ground.
Exhibit B: Raw accelerometer data in flight
Again, the plots speak for themselves. Given the same vertical and horizontal scales, the less expensive sensor is by far less noisy.
Exhibit C: Sensor bias estimates
The UMN UAV lab flies it’s aircraft with our own high fidelity EKF library. The EKF code is the fancy mathematical code that estimates the aircraft state (rolll, pitch, yaw, position, velocity, etc.) given raw IMU and GPS inputs.
One of the arguments against a cheap sensor versus an expensive temperature calibrated sensor is you are paying for high quality temperature calibration in the expensive model. This is a big deal with mems IMU sensors, because temperature can have a big effect on the bias and accuracy of the sensor.
This next pair of plots requires a small bit of explanation (please read this first!)
For every temp step, the UMN EKF library estimates the bias (or error) of each individual gyro and accelerometer (along with estimating aircraft attitude, position, and velocity.)
We can plot this bias estimate over time and compare them.
The bias estimates are just estimates and other errors in the system (like gps noise) can make the bias estimates jump around.
I have developed a temperature calibration process for the inexpensive IMU’s. This process is being used to pre-correct the MPU-6000 sensor values in flight. This correction process uses past flight data to develop a temp calibration fit and the more you fly and the bigger range of temperatures you fly in, the better the calibration becomes.
Just to be clear: for these final plots, the MPU-6000 is using our external temp calibration process — derived entirely from past flight data. The VN-100T is running it’s own internal temp calibration.
These bias estimates are not perfect, but they give a suggestion of how well the IMU is calibrated. Higher bias values suggest a larger calibration error.
MPU-6000 sensor bias estimates from UMN EKF library.
What can we learn from these plots?
The MPU-6000 gyro biases (estimated) are approximately 0.05 deg/sec.
The VN-100T gyro biases (estimated) are as high as -1.0 deg/sec in roll and 0.35 deg/sec in yaw.
The MPU-6000 accel biases (estimated) are in the 0.1 m/s^2 range.
The VN-100T accel biases (estimated) are also in the 0.1 m/s^2 range.
In some cases the MPU-6000 with external temperature calibration appears to be more accurate than the VN-100 and in some cases the VN-100T does better.
By leveraging a high quality EKF library and a bit of clever temperature calibration work, an inexpensive MPU-6000 seems to be able to hold it’s own quite well against an expensive temperature calibrated mems IMU.
This is a joint Entomology / Aerospace project to look for evidence that Spotted Wing Drosophila (an invasive species to North America) may be migrating at higher altitudes where wind currents can carry them further and faster than otherwise expected.
Skywalker Flight #69
Altitude: 200′ AGL
Airspeed: 20 kts
Weather: 10 kts wind, 22C
Mission: Circle fruit fields with insect traps.
Skywalker Flight #70
Altitude: 300′ AGL
Airspeed: 20 kts
Weather: 12 kts wind, 20C
Mission: Circle fruit fields with insect traps.
Skywalker Flight #71
Altitude: 400′ AGL
Airspeed: 20 kts
Weather: 13-14 kts wind, 20C
Mission: Circle fruit fields with insect traps.
This is a follow up to my eclipse post. I was forced to end my eclipse flight 10 minutes before the peak because a line of rain was just starting to roll over the top of me. I waited about 20-30 minutes for the rain to clear and launched a post-eclipse flight that lasted just over an hour of flight time.
Here are some interesting things in this set of flight videos:
You will see the same augmented reality heads up display and flight track rendering. This shows every little blemish in the sensors, EKF, flight control system, and airplane! It’s a great testing and debugging tool if you really hope to polish your aircraft’s tuning and flight performance.
IT IS WINDY!!!! The skywalker cruises at about 20 kts indicated airspeed. Winds aloft were pushing 16 … 17 … 18 kts sustained. At one point in the flight I record 19.5 kt winds.
At t=2517 (there is a timer in seconds in the lower left corner of the HUD) we actually get pushed backwards for a few seconds. How does your autopilot navigation work when you are getting pushed backwards by the wind?!? You can find this about 20 seconds into Part #3. Check it out. 🙂
In the 2nd half of the flight the winds transition from 16-17 kts and fairly smooth, to 18-19 kts and violent. The poor little skywalker is getting severely thrashed around the sky in places. Still it and the autopilot seem to handle it pretty well. I was a bit white knuckle watching the flight unfold from the ground, but the on board HUD shows the autopilot was pretty relaxed and handled the conditions without really breaking much of a sweat.
When the winds really crank up, you will see the augmented flight track pass by sideways just after we pass the point in the circle where we are flying directly into the wind … literally the airplane is flying sideways relative to the ground when you see this.
Does this bumpy turbulent video give you a headache? Stay tuned for an upcoming video in super smooth air with a butterworth filter on my airspeed sensor.
Note: the hobbyking skywalker (1900mm) aircraft flown in this video has logged 71 flights, 31.44 hours in the air (1886 minutes), and covered 614 nautical miles (1137 km) across the ground.
On August 21, 2017 a full solar eclipse sliced a shadowy swath across the entire continental USA. The totality area missed Minnesota by a few hundred miles so we only saw about 85% obscuration at our peak.
I thought it could be interesting to put a UAV in the sky during our partial eclipse and record the flight. I didn’t expect too much, but you never know. In the end we had a line of rain move through a few minutes before the peak and it was really hard to say if the temperature drop and less light was due to a wave of rain or due to the eclipse.
Still, I needed to test some changes in the AuraUAS flight controller and was curious to see how the TECS system would fly with a completely unfiltered/raw/noisy airspeed input. Why not roll all that together and go test fly!
Here is the full video of the 37 minute flight. Even though this is slightly boring flight test video, you might find a few interesting things if you skip around.
I talk at the start and the end of the flight. I can’t remember what I said, but I’m sure it is important and insightful.
I rendered the whole live flight track in the video using augmented reality techniques. I think that’s pretty cool.
If you skip to the end, I pick up the plane and walk back to the runway. I think that is the funnest part. There I pan the airplane around the sky and show my flight path and approach drawn right into the real video using the same augmented reality techniques.
We had 100% cloud cover and zero view of the sun/moon. But that doesn’t stop me from drawing the sun and moon in the view where it actually is. Not surprisingly, they are sitting almost exactly on top of each other. You can see this at the end of Part 3.
I flew a fully autonomous landing on this flight. It worked out pretty well and shows up nicely at the end of Part 3. If anyone is interested, the auto-land task is written as an embedded python script and runs right on-board in the main flight controller. I think that might be pretty cool for people who are python fans. If you want to geek out on the details you can see the whole landing script here: https://github.com/AuraUAS/aura-core/blob/master/src/mission/task/land2.py (Then go watch it in action at the end of Part #3.)
Last Friday I flew an aerial photography test flight using a Skywalker 1900 and a Sony A6000 camera (with 20mm lens.) On final approach we noticed a pair of deer crossing under the airplane. I went back through the image set to see if I could spot the deer in any of the pictures. I found at least one deer in 5 different shots. Here are the zoom/crops:
I know the above statement isn’t exactly true, but it could be true if everyone who develops UAVs would read this article. 🙂
In this article I propose a system that continuously and dynamically self calibrates the magnetometers on a flying UAV so that manual calibration is no longer ever needed.
With traditional UAVs, one the most important steps before launching your UAV is calibrating the magnetometers. However, magnetometers are also one of the most unpredictable and troublesome sensors on your UAV. Electric motors, environmental factors, and many other things can significantly interfere with the accuracy and consistency of the magnetometer readings. Your UAV uses the magnetometer (electronic compass) to compute its heading and thus navigate correctly through the sky.
We can accurately estimate heading without a compass
Most UAV autopilots do depend on the magnetometer to determine heading. However, their is a class of “attitude estimators” that run entirely on gyros, accelerometers, and gps. These estimators can accurately compute roll, pitch, and yaw by fitting the predicted position and velocity to the actual position and velocity each time a new gps measurement is received. In order for these estimators to work, they require some amount of variation in gps velocity. In other words, they don’t estimate heading very well when you are sitting motionless on the ground, hovering, or flying exactly straight and level for a long time.
A compass is still helpful!
For fixed wing UAVs it is possible to fly entirely without a magnetometer and still estimate the aircraft attitude accurately throughout the flight. However, this requires some carefully planned motion before launch to help the attitude estimate converge. A compass is obviously still helpful to improve the attitude estimate before launch and in the initial moments of the launch–before the inertial only system sees enough change in velocity to converge well on it’s own. A compass is also important for low dynamic vehicles like a hovering aircraft or a surface vehicle.
Maths and stuff…
The inertial only (no compass) attitude estimator I fly is developed at the University of Minnesota UAV lab. It is a 15-state kalman filter and has been at the core of our research here for over a decade. A kalman filter is a bit like a fancy on-the-fly least squares fit of a bunch of complicated interrelated parameters. The kalman filter is based on minimizing statistical measures and is pretty amazing when you see it in action. However, no amount of math can overcome bad or poorly calibrated sensor data.
So Here We Go…
First of all, we assume we have a kalman filter (attitude and location estimator) that works really well when the aircraft is moving, but not so well when the aircraft is stationary or hovering. (And we have that.)
We know our location and time from the gps, so we can use the World Magnetic Model 2015 to compute the expected 3d vector that points at the north pole. We only have to do this once at the start of the flight because for a line of sight UAV, position and time doesn’t change all that much (relative to the magnetic pole) during a single flight.
During the flight we know our yaw, pitch, and roll. We know the expected direction of the magnetic north pole, so we can combine all this to compute what our expected magnetometer reading should be. This predicted magnetometer measurement will change as the aircraft orientation changes.
The predicted magnetometer measurement and the actual magnetometer measurements are both 3d vectors. We can separate these into their individual X, Y, and Z components and build up a linear fit in each axis separately. This fit can be efficiently refined during flight in a way that expires older data and factors in new data. When something changes (like we travel to a new operating location, or rearrange something on our UAV) the calibration will always be fixing and improving itself as soon as we launch our next flight.
Once we have created the linear fit between measured magnetometer value and expected magnetometer value in all 3 axes, we can use this to convert our raw magnetometer measurements into calibrate our magnetometer measurements. We can feed the calibrated magnetometer measurements back into our EKF to improve our heading estimate when the UAV is on the ground or hovering.
Does this actually work?
Yes it does. In my own tests, I have found that my on-the-fly calibration produces a calibrated magnetometer vector that is usually within 5 degrees of the predicted magnetometer vector. This error is on par with the typical cumulative attitude errors of a small UAS kalman filter and on par with a typical hand calibration that is traditionally performed.
The source code for the University of Minnesota 15-state kalman filter, along with a prototype self calibration system, and much more can be found at my AuraUAS github page here: https://github.com/AuraUAS/navigation
This article is fairly rough and I’ve done quite a bit of hand waving throughout. If you have questions or comments I would love to hear them and use that as motivation to improve this article. Thanks for reading!
Everything in this post shows real imagery taken from a real camera from a real uav which is really in flight. Hopefully that is obvious, but I just want to point out I’m not cheating. However, with a bit of math and a bit of camera calibration work, and a fairly accurate EKF, we can start drawing the locations of things on top of our real camera view. These artificial objects appear to stay attached to the real world as we fly around and through them. This process isn’t perfected, but it is fun to share what I’ve been able to do so far.
For the impatient
In this post I share 2 long videos. These are complete flights from start to finish. In them you can see the entire previous flight track whenever it comes into view. I don’t know how best to explain this, but watch the video and feel free to jump ahead into the middle of the flight. Hopefully you can see intuitively exactly what is going on.
Before you get totally bored, make sure to jump to the end of each video. After landing I pick up the aircraft and point the camera to the sky where I have been flying. There you can see my circles and landing approach drawn into the sky.
I think it’s pretty cool and it’s a pretty useful tool for seeing the accuracy and repeatability of a flight controller. I definitely have some gain tuning updates ready for my next time out flying based on what I observed in these videos.
The two videos
Additional notes and comments
The autopilot flight controller shown here is built from a beaglebone blaock + mpu6000 + ublox8 + atmega2560.
The autopilot is running the AuraUAS software (not one of the more popular and well known open-source autopilots.)
The actual camera flown is a Runcam HD 2 in 1920×1440 @ 30 fps mode.
The UAV is a Hobby King Skywalker.
The software to post process the videos is all written in python + opencv and licensed under the MIT license. All you need is a video and a flight log and you can make these videos with your own flights.
Aligning the flight data with the video is fully automatic (described in earlier posts here.) To summarize, I can compute the frame-to-frame motion in the video and automatically correlate that with the flight data log to find the exact alignment between video and flight data log.
The video/data correlation process can also be used to geotag video frames … automatically … I don’t know … maybe to send them to some image stitching software.
If you have any questions or comments, I’d love to hear from you!
On June 1, 2009 Air France flight #447 disappeared over the Atlantic Ocean. The subsequent investigation concluded “that the aircraft crashed after temporary inconsistencies between the airspeed measurements – likely due to the aircraft’s pitot tubes being obstructed by ice crystals – caused the autopilot to disconnect, after which the crew reacted incorrectly and ultimately caused the aircraft to enter an aerodynamic stall from which it did not recover.” https://en.wikipedia.org/wiki/Air_France_Flight_447
This incident along with a wide variety of in-flight pitot tube problems across the aviation world have led the industry to be interested in so called “synthetic airspeed” sensors. In other words, is it possible to estimate the aircraft’s airspeed by using a combination of other sensors and techniques when we are unable to directly measure airspeed with a pitot tube?
Next, I need to say a quick word about basic aerodynamics with much hand waving. If we fix the elevator position of an aircraft, fix the throttle position, and hold a level (or fixed) bank angle, the aircraft will typically respond with a slowly damped phugoid and eventually settle out at some ‘trimmed’ airspeed.
If the current airspeed is faster than the trimmed airspeed, the aircraft will have a positive pitch up rate which will lead to a reduction in airspeed. If the airspeed is slower than the trimmed airspeed, the aircraft will have a negative pitch rate which will lead to an acceleration. https://en.wikipedia.org/wiki/Phugoid
The important point is that these variables are somehow all interrelated. If you hold everything else fixed, there is a distinct relationship between airspeed and pitch rate, but this relationship is highly dependent on the current position of elevator, possibly throttle, and bank angle.
Measurement Variables and Sensors
In a small UAS under normal operating conditions, we can measure a variety of variables with fairly good accuracy. The variables that I wish to consider for this synthetic airspeed experiment are: bank angle, throttle position, elevator position, pitch rate, and indicated airspeed.
We can conduct a flight and record a time history of all these variables. We presume that they have some fixed relationship based on the physics and flight qualities of the specific aircraft in it’s current configuration.
It would be possible to imagine some well crafted physics based equation that expressed the true relationship between these variables …. but this is a quick afternoon hack and that would require too much time and too much thinking!
From a practical perspective, I don’t really need to understand how radial basis functions work. I can simply write a python script that imports the scipy.interpolate.Rbf module and just use it like a black box. After that, I might be tempted to write a blog post, reference radial basis functions, link to wikipedia, and try to sound really smart!
Training the Interpolater
Step one is to dump the time history of these 5 selected variables into the Rbf module so it can do it’s magic. There is a slight catch, however. Internally the rbf module creates an x by x matrix where x is the number of samples you provide. With just a few minutes of data you can quickly blow up all the memory on your PC. As a work around I split the entire range of all the variables into bins of size n. In this case I have 4 independent variables (bank angle, throttle position, elevator position, and pitch rate) which leads to an n x n x n x n matrix. For dimensions in the range of 10-25 this is quite manageable.
Each element of the 4 dimensional matrix becomes a bin that holds he average airspeed for all the measurements that fall within that bin. This matrix is sparse, so I can extract just the non-zero bins (where we have measurement data) and pass that to the Rbf module. This accomplishes two nice results: (1) reduces the memory requirements to something that is manageable, and (2) averages out the individual noisy airspeed measurements.
Testing the Interpolater
Now comes the big moment! In flight we can still sense bank angle, throttle position, elevator position, and pitch rate. Can we feed these into the Rbf interpolater and get back out an accurate estimate of the airspeed?
Here is an example of one flight that shows this technique actually can produce some sensible results. Would this be close enough (with some smoothing) to safely navigate an aircraft through the sky in the event of a pitot tube failure? Could this be used to detect pitot tube failures? Would this allow the pitot tube to be completely removed (after the interpolater is trained of course)?
The source code for this experimental afternoon hack can be found here (along with quite a bit of companion code to estimate aircraft attitude and winds via a variety of algorithms.)
This is the results of a quick afternoon experiment. Hopefully I have showed that creating a useful synthetic airspeed sensor is possible. There are many other (probably better) ways a synthetic air speed sensor could be derived and implemented. Are there other important flight variables that should be considered? How would you create an equation that models the physical relationship between these sensor variables? What are your thoughts?
NOTICE: This is a draft document and in the process of being written. It is incomplete and subject to change at any time without notice.
In this post I share my process and tools for creating HUD overlays on a flight video. Here is a quick overview of the process: (1) Calibrate your camera, (2) Extract the roll rate information from the flight video, (3) Automatically and perfectly time correlate the video with the flight data, (4) Render a new video with the HUD overlay.
Please be aware that this code has not yet gone through a v1.0 release process or outside review, so you are likely to run into missing python packages or other unanticipated issues. I hope that a few brave souls will plow through this for themselves and help me resolve poor documentation or gaps in the package requirements. All the code is open-source (MIT license) and available here:
Let’s jump right into it. The very first thing that needs to be done is calibrate your specific camera. This might sound difficult and mysterious, but have no fear, there is a script for everything! Every camera (especially cheaper action cameras) has unique lens imperfections. It is best to do your own calibration for each of your cameras rather than trying save some time and copy someone else’s configuration.
The camera calibration process involves feeding several images of a checkerboard calibration pattern to a calibration script. Each image is analyzed to locate the checkerboard pattern. This information is then passed to a solver that will find your camera’s specific calibration matrix and lens distortion parameters.
To make this process easier, the calibration script expects a short 1-2 minute movie. It processes each frame of the movie, locates the checkboard pattern and stashes that information away. After all frames are processed, the script samples ‘n’ frames from the movie (where ‘n’ is a number around 100-200) and uses those frames to solve for your camera’s calibration. The reason that all frames are not used is because when ‘n’ starts pushing 250-300+, the solver begins to take a long time where long is measured in hours not minutes.
Here is a sample calibration video. The goal is to always keep the checkerboard pattern fully in view while moving it around, closer, further, to different parts of the frame, and from different offset angles. It is also important to hold the camera steady and move it slowly to avoid the effects of blurring and rolling shutter.
Now save your movie to your computer and run:
calibrate_movie.py --movie <name>
The script will run for quite some time (be patient!) but will eventually spit out a camera calibration matrix and set of lens distortion parameters. Save these somewhere (copy/paste is your friend.)
Extract the Roll Rate Information from the Flight Video
First take the camera calibration and distortion parameters derived in step one, and copy them into the gyro rate estimation script.
Next, run the script. This script will detect features in each frame, match the found features with the previous frame, and compute the amount of rotation and translation from each frame to the next. (It also is a hacky image stabilization toy).
Here is an example of the script running and detecting features. Notice that a very significant portion of the frame is covered by the aircraft nose and the prop covers most of the remaining area. That’s ok! The gyro estimation is still good enough to find the correlation with the flight data.
Correlate the Video with the Flight Data
The next script actually performs both of the last two steps (correlation and rendering.)
The script loads the flight data log and the movie data log (created by the previous script). It resamples them both at a common fixed rate (30hz in the above example.) Then it computes the best correlation (or time offset) between the two.
Here is a plot of the roll rate estimate from the video overlaid with the actual roll gyro. You can see there are many differences, but the overall trend and pattern leads to only one possible correct time correlation.
This graph is especially noisy because only a large portion of the outside view is obscured by the nose and the visible portion is further obscured by the propeller. But it is ok, the correlation process is magic and is really good at finding the best true correlation. The next plot shows the results we can attain when we have more idea conditions with an unobstructed view. Here is a plot that shows the video roll estimate and the actual roll gyro are almost perfectly in agreement.
Taking a step back, what did we just do there? Essentially, we have created an automated way to align the video frames with the flight data log. In other words, for any video frame number, I can compute the exact time in the flight log, and for any point in the flight log, I can compute the corresponding video frame number. Now all that is left is to draw the exact current flight data (that we now have a way to find) on top of the video.
I look forward to your comments and questions!
This tutorial is far from complete and I know there are some built in assumptions about my own system and aircraft cooked into the scripts. Please let me know your questions or experiences and I will do my best to answer or improve the code as needed.