Here’s some footage that Dylan took of him flying one of the 3 quadrotors we have at this point. Electronics here are revision 2 of the microcontroller board, so no OMAP yet.

Development on the Peregrine Board has slowed a little since we’re both in school and that has to come first, but we are both working on it whenever we get a chance. Schematics are nearly done, all major stuff is there.

Last semester when I was studying in France, I took Electromagnetics. I really enjoyed it, especially our final project. We had to write a 2D FDTD (Finite Difference Time Domain) electromagnetic wave simulator. We had to show correct behavior for the propagation of a wave through a lens and a wave guide. We also had to handle edge conditions (literally) and make the wave behave gracefully when it hit a boundary. It was a really cool project and I wish I could share my code, but in the interest of fairness, I can’t. Students have to do it each semester and I don’t want to provide temptation for anyone to use my code. So instead, here’s a video of a line charge source excited sinusoidally and acting on a wave guide.

What’s really cool is that it shows how interconnected certain phenomena are. It’s no coincidence that that simulation looks a lot like water rippling. James Clerk Maxwell remains probably my favorite physicists of all time. Using only math, he was able to make an incredible amount of progress and predict several things that would be proven empirically later on. That was one of my favorite parts of Electromagnetics. We got to work through the math and see how interrelated everything is. Heck, we learned how you can figure out the speed of light using a capacitor. It was also really cool to be in Europe while I was learning all that stuff. I went to Edinburgh and looked up where Maxwell grew up and went to his house:

It’s right in the middle of a neighborhood, and the only identifying mark is a little plaque beside the door. I got to see several other scientist’s houses too, like Fermi’s house in Rome. It was pretty awesome to get to learn about these great men and then get to go explore where they grew up and the environment that they were in when they came up with all this stuff.

Just a quick post here on how to get linux on a beagleboard. I had success using the NetInstall method outlined here:

http://elinux.org/BeagleBoardUbuntu

I haven’t done it yet, but this seems to be a pretty good starting point for getting ROS installed on it: http://people.mech.kuleuven.be/~u0062536/embsensor.html

And: http://answers.ros.org/question/134/how-to-install-ros-on-beagleboard-ubuntu-1010

Yesterday, we had our second quadrotor flight test. We took some video, but I don’t have the SD card with me right now, so I’ll post it later. It went pretty well. It confirmed that our code was working correctly, and we basically just had to tune the proportional and derivative constants to get it fairly stable. We also had to change some of the initial angle constants because two of the motors are slightly underpowered (they were pretty cheap from HobbyKing, so what do you expect?).  The quadrotor isn’t as rock solid stable as we want yet, but we’re getting very close.

After some trouble getting a correctly wired cable, we got the serial monitor for the Beagleboard working last night.

I formatted an SD card last night to boot Angstrom linux. Of course it didn’t work on the first try, but I’m going to see if I have any more luck today.

I’ve made some progress on the schematic for the Peregrineboard. I added the ATMega and supporting hardware for it. The only other big thing I need to add is the IMU. We were looking at several options, and the MPU 6050 from Invensense looked like a good option. It’s cheap, and is the first IC to have a 3 axis accelerometer and 3 axis gyroscope on it. It’s also got an onboard processor to sensor fusion and spit out data for you in either raw format, rotation matrix, Euler angles, or quaternians. Unfortunately, it has had several delays since last year and is still not available. Apparently it went into large volume production in September, but no one seems to have any in stock, including the Invensense website. After contacting them, I found out that it could still be 6 to 8 weeks before anyone gets any. Because it’s been so fickle, we decided against using the MPU 6050 for at least the first revision of boards. There are no libraries for any of the other inertial sensors we want to use in Altium, so after I make them, I’ll add them to the schematic.

We now have a Beagleboard to play with, and I’ve been working on getting it up and running. Once I do, I’ll experiment with getting ROS to run off it. We are currently importing schematics and routes from Beagleboard.org. It’s been a little tricky because of the way they are saved.

Here’s the second revision of our sensor board:

This actual board will not end up in the final hardware, it’s just a prototype we originally made for a quadrotor. However, a similar circuit will be integrated in the final hardware. This board basically does the low level stability control. It has a microcontroller to read in sensor data from the IMU and GPS and do the math for the PID loop. In the final hardware, the OMAP will send higher level commands to this microcontroller, which will then execute them. The reason for offloading this task to a microcontroller is that we can know stability will always have a high priority and not be accidentally superseded by some other process. It also means that if you manage to cause a kernel panic on the OMAP, the aircraft won’t crash into the ground. We can also add code to the microcontroller to stay in a holding pattern or attempt to land in the event that it looses contact with the OMAP. We think this will be a good system, but we’ll see how it ends up working when we test on a real aircraft.

Here’s a quick update on our progress. We’ve got our lab set up and are now working on getting the first revision schematic done. We’re basing a lot of the OMAP design on the BeagleBoard, since we know it works and was designed by engineers who are very good at high speed board design. We know which package we’d like to use, and are in the process of trying to get samples of the POP SDRAM that it uses. We’re also getting quotes from Advanced Circuits and trying to figure out the cheapest way we can manufacture them.

Here’s a picture of the lab: http://i.imgur.com/eubp7.jpg (Big image size, be careful).
We actually have three quadrotor frames now, but you can only see two in the picture. Our hot air station is to the left and the 3D printer is to the right. Here’s another shot from a bit of a different angle: http://i.imgur.com/FBkLi.jpg

I’ll post more updates as they happen.

This project is possible through a grant from the good people at

Thanks guys!

I am happy to announce that my good friend Dylan Rudolph and I just won an innovation grant from the awesome people over at Wyolum! We will be using the money to develop the next generation of avionics for the DIY UAV community.

We will be designing and building a board that combines an IMU, microcontroller, and an OMAP processor from TI and try to make it as cheap as possible. And of course, the whole thing will be open source. We’re intending it to be used for small scale aerial applications, but you will definitely be able to use it for other stuff too. The name we’ve come up with is PeregrineBoard. We picked it because, like a Peregrine Falcon, this thing flies and is going to be fast (as in MIPS, airspeed is up to you).

We’re trying to fill a void that exists in the market. Right now, there are platforms like ArduPilot and OpenPilot which have an IMU and a microcontroller running simple control loop. The primary ability that these platforms are lacking is a way to perform high level, computationally intensive calculations. These things are based on microcontrollers that are intended for little more than basic input/output and communications. While microcontrollers are great for basic control, their limited abilities are not sufficient for some users. So we’re gonna use a TI OMAP processor in addition to a microcontroller and IMU. The addition of the OMAP SoC allows for computationally intensive tasks like computer vision, sensor fusion, and high level path planning. We anticipate that the platform will be capable of running Robot Operating System (ROS) which has a very large, primarily academic, community. ROS has all kinds of projects and native support for lots of interesting applications. For example, rgbdslam is a program that lets you do SLAM using a Kinect.

We think that this platform would also drastically help move the progress of aerial robotics forward. Hobbyists led the hacking and development of the Kinect before any university and made incredible progress in a very short time. A similar phenomenon is occurring within communities like DIY Drones. DARPA has also expressed interest in this with their UAV Forge project that looks to the public to prototype and demonstrate a military grade UAV that is capable of tracking a target and performing covert surveillance. A community driven push for these kinds of applications could also be important for areas like search and rescue.

The DIY community has already shown signs of needing to move past microcontrollers. The recently released ArduPilotMega 2.0 has been upgraded from previous versions to include not one, but three microcontroller cores. The designers mention that they are “pushing the boundries of AVR and Arduino” with this revision. With a full-fledged processor on board, users can save money by getting more use out of a single design iteration. The OMAP has plenty of room for firmware upgrades and software expansion. This feature will also allow users to utilize the device for more applications than just aircraft. An integrated board with an OMAP, microcontroller, and IMU would be smaller and cheaper than combining multiple off the shelf solutions.

Currently, we are on the second revision of a PCB that only incorporates the IMU and microcontroller. The control loop has been tested and is working. We also built two quadrotors for testing electronics and we’ll be doing flight tests in the coming weeks. The next step will be designing and prototyping the first version of the board that incorporates the now working IMU and microcontroller along with an OMAP. Design of the full board is already under way.

I’ll post updates here as they occur. In the next week or so, I’ll be setting up a dedicated website for the project. We’re excited to get going on this thing!

This morning, I was greeted by this headline:

“Physicists turn liquid into solid using electric field”

To most people, this may evoke a thoughtful, “Huh. Neat.” But to me, it evoked something more along the lines of, “HOLY CRAP I TOTALLY CALLED THAT”. I started keeping a personal design notebook a few years ago to write down ideas I had, problems I was working on, designs, questions, things like that. On one of those pages, I wrote this about a year and a half ago when I was taking Physics II:

I think I was taking chemistry at the same time, and I began to wonder about messing with the dipole moment in a water molecule with an electric field. Specifically, could you make some sort of crystal by lining the molecules up in a lattice? I looked for publications on the topic, and all I could find was some random paper on the benefits of exposing your bread dough to an electric field (yeah, I don’t know either). I remember asking my professor about my idea. He didn’t really know the answer, and told me to try to calculate the forces on the molecules classically to see what would happen. Now that I’m taking electromagnetics, I know that it is not at all that simple. Which is why the guys in this paper used a simulator.

There are surprisingly few differences between what I was thinking about at the time and what the scientists at Tech did. They used formamide instead of water, since formamide has about twice the dipole moment of water. But sure enough, they found that by increasing the field enough, you can get a crystalline structure that is actually a phase change. It’s called electrocrystallization. It has been known for quite some time that electric fields can affect polarized molecules in macroscopic ways, since observations were made showing that raindrops near lightning changed shape and became long and skinny.

Now, there are a few caveats to these results. First of all, for the effect to happen, you have to have a very strong electric field (1.5 Volts per nanometer). However, the normal dielectric breakdown of most materials is below that by like two orders of magnitude. For a few exotic materials though, it’s not too far above the dielectric breakdown (it’s only about 3 times that of PVC). Even once you’ve dealt with the breakdown problem, I’m still not sure what the practical uses of something that changes state based on a giant electric field. But it’s still an interesting result.

So while I didn’t get a chance to pursue my idea very far back in Physics II, I learned two things. First, I was (pretty) right. And second, it was a good question. Their paper is going to be on the cover of The Journal of Physical Chemistry. I’m hopeful that if I keep trying to ask good questions, one day I’ll hit on something pretty interesting and get a chance to work on it before anyone else.