Blogs

If you think 16 grams is pretty small for an autonomous robot, don’t forget the DelFly Micro, which weighs just a hair (literally) over 3 (!) grams, and also manages to carry an onboard camera that can transmit streaming video. The DelFly Nano (1.5 grams) still seems to be a work in progress, and as for the DelFly Pico, somebody at TU Delft sneezed nearby and now they can’t find it."

[ TU Delft ]

[ IMAV 2010 ]

There are tons of different user submitted scripts, but the most basic (and helpful to ballooning) is the ultra intervalometer. This script allows us to tell the camera to automatically take a picture every X number of seconds. Once CHDK is installed on the camera, and the ultra intervalometer is setup, the camera will start taking pictures as soon as the camera is turned on. In the case of my payload, I setup the SD400 to take a photo every 20 seconds. It's really freaky to have a camera just sitting there snapping away photos. But that's what we want for the balloon!

Anyone remember BASIC? I found a script that is basically an interval timer (set to take a picture) but also turns off the LCD. So simple, but reasonably hard to find. Thanks Vicente Piorno! You can download my entire CHDK zip (it's better to get the right CHDK for your camera from their website), or you can grab just the script."

Reports Wired's DangerRoom blog: "While on-the-fly autonomous navigation is a first for a full-sized helicopter, the technology developed by Sanjiv Singh and his team from Carnegie Mellon is not so different from what they used to outfit a Chevy Tahoe to win Darpa’s 2007 Urban Challenge. “It’s not as if we started from scratch,” says Singh. “A lot of the technology was there already.”

To make the helicopter self-flying, the team installed a scanning LIDAR that uses lasers to collect range information from its surroundings. The laser data is processed by a computer that relays commands to the helicopter controllers.

The data also creates a 3-D map that enables the helicopter to “see” the ground or obstacles in the air — and then adjust its trajectory accordingly. The algorithms helped the helicopter miss a tall tower during one of the tests. In another trial, the team deceptively instructed the helicopter to land on top of a car, but the chopper was not fooled, resolving instead to land on flat ground nearby."

It's based on earlier RMax automomous obstacle avoidance research:

Well I'm back in the basement tinkering after a brief hiatus. After a couple in-air resets of the Ardupilot, I decided that I really wanted to do some simulation before commiting anything into the air again. I think the resets (and crashes) were caused by running out of RAM on the Arduino, but at least now I can give code changes a thorough shakedown before flight.

My workplace does avionics integration for real aircraft, and in most of our labs we use X-Plane and Labview to do simulation testing of aircraft avionics systems. We already have a set of VI's developed that handle all of the UDP communication between Labview and X-Plane.

I borrowed these VIs from work and wrote an interface to take the flight variables and pass them to and from the ArduPilot. I finally got everything working and my ArduPilot spent yesterday evening flying the X-Plane Cessna 172 around Ottawa.

One neat feature (I think) is how I'm getting the servo commands back into X-Plane. I built a 2-servo pitch/roll tray. On the tray I mounted my ArduIMU. The Ardupilot drives the two servos which causes the tray to pitch/roll. The ArduIMU senses this motion and sends its Euler angles back to the Labview computer. The labview computer decodes the ArduIMU pitch and Roll and sends these values over to X-Plane as Joystick positions. A couple of advantages of this method over simply outputting servo commands from the Ardupilot Serial port are:

- I'm testing the whole system (including the PWM signal code and the mux chip).
- I can fly the X-Plane aircraft in manual mode using my transmitter (more realistic, and makes a good way of positioning the aircraft for testing.)
- It's cool to see this little robot arm shift around while the aircraft flies along the flight plan.

I'll post a little video clip of the system in action later tonight.

Here are the details of my closed-loop path.

1. The computer running X-plane sends the aircraft position data (lat/long/alt/pitch/roll/heading) over the LAN to the Labview PC.
2. The Labview PC takes the X-Plane data, formats per the ArduIMU binary message protocol and sends it out the Serial port to the ArduPilot.
3. Ardupilot is set to GPS Protocol 3 (IMU) and listens to the serial data from labview thinking it's from an ArduIMU and does it's autopilot work.
4. The Channel 1 and 2 servo output from ArduPilot is connected to the little tilt table I built.
5. On the tilt table, the ArduIMU outputs Euler Angle Data (Pitch/Roll). I'm using a Sparkfun XBee USB explorer (without the XBEE) to translate the serial output from the ArduIMU back into USB format.
6. Labview reads the Pitch/Roll Data in, formats this data as a joystick position, and sends it to X-Plane.
7. Go back to step 1.

As you can see in the pictures, I am also powering the ArduPilot and ArduIMU from the computer's USB ports. This seems to work well, and I don't have to keep an eye on the voltage of a lipo pack during testing.

I can share the labview VI's I personally created for this little project. (Basically they create the simulated ArduIMU output, and read the ArduPilot and ArduIMU telemetry), however, the VIs that do the communication with X-Plane, while not complicated are not something I can give away (I like my job too much ;) )

The picture at the top of this post is the Local Map screenshot from X-Plane after completing a flightplan consisting of 15 waypoints.

Below are a couple pictures of my setup.

The Qinetiq Zephyr has been airborne for 7 days and as I write this.... 2 hours and 23 minutes. Its still flying. I believe they are going for two weeks. It took off last Friday from the Yuma testing grounds in Arizona at 1440 BST (0640 local)

Its Friday night lets all raise a glass to them!!!

XtreamBee board

ArduPilot Mega

IMU shield

MediaTek GPS

Magnetometer

Thanks DIYDrones community! We at the Royal Military College of Canada used the Ardupilot software and ground station as a basis for programming our 2m autonomous wing-sailed trimaran. This made our lives much easier while building and programming the boat during the 3 month time frame before it competed in Sailbot 2010 http://sailbot.ca.

The cutter gives nice clean cuts for vertical cutting operations (below). Please note the fan that sucks gases out from the workpiece. This is very important because blue and red foam gives off fumes that are very toxic when they are melted.

The PWM controller outputs pulses and is configurable both in duty cycle and several other parameters (below).

Hi,

This is my experimental quadrorotor. In this flight I'm trying the stable mode with the accelerometer.

ARM 7 32bit LPC2103 a 60Mhz ( Coridium ARMmite PRO )
ITG-3200 Triple-Axis Digital-Output Gyro, 16bit, digitally-programmable low-pass filter
BMA180 Triple Axis Accelerometer, 14Bit, Programmable integrated digital filters
ESC: PWM at 495Hz
R/C RECEIVER: PPM composite signal, 8 Channel

Greetings, Danilo

Autonomous Helicopter from M W on Vimeo.

1. There are libraries that you will need to install in your Arduino IDE for this firmware to work.
2. This code is under development so there are lots of holes. Currently it supports MANUAL, STABILIZE, FLY_BY_WIRE_A, AUTO, RTL, and LOITER flight modes, a small number of a larger set of commands that will be implemented, and on board data logging. Currently it does not support any gps other than ublox, absolute or differential (airspeed) pressure sensors, magnetometer, battery voltage measurement, telemetry or uplink (some downlink available through Serial0), take-off or landing, and a bunch of other stuff
3. The code is not compatible with the ArduPilot configuration tool. There is a waypoint (command) writer tool available in the tools directory of the repository, but no documentation available yet.
4. The code is not currently compatible with the ground station.

Introduction

Open Source Hardware (OSHW) is a term for tangible artifacts -- machines, devices, or other physical things -- whose design has been released to the public in such a way that anyone can make, modify,
distribute, and use those things. This definition is intended to help
provide guidelines for the development and evaluation of licenses for
Open Source Hardware.

It is important to note that hardware is different from software in that physical resources must always be committed for the creation of physical goods. Accordingly, persons or companies producing items
("products") under an OSHW license have an obligation not to imply that
such products are manufactured, sold, warrantied, or otherwise
sanctioned by the original designer and also not to make use of any
trademarks owned by the original designer.

The distribution terms of Open Source Hardware must comply with the following criteria:

1. Documentation

The hardware must be released with documentation including design files, and must allow modification and distribution of the design files. Where documentation is not furnished with the physical product,
there must be a well-publicized means of obtaining this documentation
for no more than a reasonable reproduction cost preferably, downloading
via the Internet without charge. The documentation must include design
files in the preferred form for which a hardware developer would modify
the design. Deliberately obfuscated design files are not allowed.
Intermediate forms analogous to compiled computer code -- such as
printer-ready copper artwork from a CAD program -- are not allowed as
substitutes.

2. Necessary Software

If the hardware requires software, embedded or otherwise, to operate properly and fulfill its essential functions, then the documentation requirement must also include at least one of the
following: The necessary software, released under an OSI-approved open
source license, or other sufficient documentation such that it could
reasonably be considered straightforward to write open source software
that allows the device to operate properly and fulfill its essential
functions.

3. Derived Works

The license must allow modifications and derived works, and must allow them to be distributed under the same terms as the license of the original hardware. The license must allow for the manufacture, sale,
distribution, and use of products created from the design files or
derivatives of the design files.

4. Free redistribution

The license shall not restrict any party from selling or giving away the project documentation as a component of an aggregate distribution containing designs from several different sources. The
license shall not require a royalty or other fee for such sale. The
license shall not require any royalty or fee related to the sale of
derived works.

5. Attribution

The license may require derived works to provide attribution to the original designer when distributing design files, manufactured products, and/or derivatives thereof. The license may also require
derived works to carry a different name or version number from the
original design.

6. No Discrimination Against Persons or Groups

The license must not discriminate against any person or group of persons.

7. No Discrimination Against Fields of Endeavor

The license must not restrict anyone from making use of the hardware in a specific field of endeavor. For example, it may not restrict the hardware from being used in a business, or from being used
in nuclear research.

8. Distribution of License

The rights attached to the hardware must apply to all to whom the product or documentation is redistributed without the need for execution of an additional license by those parties.

9. License Must Not Be Specific to a Product

The rights attached to the hardware must not depend on the hardware being part of a particular larger product. If the hardware is extracted from that product and used or distributed within the terms of
the hardware license, all parties to whom the hardware is redistributed
should have the same rights as those that are granted in conjunction
with the original distribution.

10. License Must Not Restrict Other Hardware or Software

The license must not place restrictions on other hardware or software that may be distributed or used with the licensed hardware. For example, the license must not insist that all other hardware sold at
the same time be open source, nor that only open source software be used
in conjunction with the hardware.

11. License Must Be Technology-Neutral

No provision of the license may be predicated on any individual technology or style of interface.

Afterword

The signatories of this Open Source Hardware definition recognize that the open source movement represents only one way of sharing information. We encourage and support all forms of openness and
collaboration, whether or not they fit this definition.