Blogs

In a recent post I described some simple acrylic lenses I made using a simple press-molding technique. The methods were crude, but the results weren't too bad. Also, I had designed an assembly containing four minor variations of these lenses and submitted that for fabrication over the holidays. The injection molding step was a bit of an experiment- rather than using a full optic-grade firm, which would have cost us well into the five figures to try, we used U.S. based Protomold, who was able to create this mold in two weeks and make 100 assemblies (400 lenses) for a bit more than $2k. I again selected acrylic as the resin material for these lenses.

The picture above shows the parts as they came back (top and bottom side). Below shows a close-up of two lenses cut out from the above assembly.

The real test, of course, is that image quality. I mounted these lenses onto some of our image sensor chips using the same methods as that discussed in the above-quoted recent post, painted on an iris, and sealed the chip up. Below is a picture of me waving at the camera in 32x32 resolution.

I also took another picture of my backyard with a different chip and a different setup at 90x90 resolution. The field of view was roughly between 70 and 80 degrees, thus the pixel pitch was less than one degree. The image quality in this latter picture was not as good. Two factors probably contributed to this- First the finer pixel pitch could have exceeded the limits of the optics, second my method for removing fixed pattern noise was less accurate in this setup. Right now I do not know which of these two factors dominate.

One comment- There was in fact some shrinkage in the lens, on the flat bottom part that gets placed onto the chip. However this was small and easily filled in with the optical adhesive, which has almost the same index of refraction as acrylic.

One lesson learned regarding the injection mold design: There are four slightly different lenses in the above assembly. The difference is in the total thickness, with sequential lenses different by 25 microns. (It turned out this difference was moot compared to the varying thickness due to the amount of adhesive used.) This was to allow me to experiment with variations to compensate factors such as shrinkage and enlarging of the mold through polishing. However I made the mold family perfectly symmetrical (other than the small variations in lens thickness)! When I got the parts back, it was hard to find out which lens was which! Fortunately I found the sprue (where the plastic charge gets injected into the mold) and with careful eyeballing under a microscope, identified the lenses. But the lesson learned is that I should have added a slight marking or asymmetry to help me identify right from left.

Overall I am pleased with the results. For pixel pitches of about two degrees per pixel and up, this technique is adequate. Two degrees per pixel may not sound like much, but many flying insects have this type of resolution and do quite well. It may be that with the right iris and better fixed pattern noise cancellation, I could get the sharpness down to one degree or pixel, but this will have to wait.

Here again is the link to a zip folder containing the Alibre files for the mold: CYE_LensMold_Untested.zip

I made this video showing the Ardupilot dreaming, the HK´s GCS taking telemetry data, and sending Tracker commands to an arduino, wich is driving two servos on a Trackers base.

Thanks Happy!!!!!

ArduPilotMega 1.02 is now available in the download section. This version updates the GPS libraries to support the new v1.6 firmware that adds some useful data fields and otherwise makes HappyKillmore's GCS, well, happier.

New MediaTek modules shipping from the DIY Drones store have the 1.6 firmware. If you've got one of those or have updated your module to 1.6, you can use it with APM by selecting "GPS_PROTOCOL_MTK16" as your GPS protocol in APM_Config.h.

If you want to update your GPS module to 1.6, here's what you need:

• The 1.6 firmware is here.
• Instructions and the installation utility are here.
• Instructions on how to hook up the required FDTI cable are here.

No product listing yet, but will be on HobbyKing.com later this week according to HobbyKing. Will be intersting to compare with the EPP foam one that I just got (see below), which seems perfect. Smaller than a Skywalker, but still plenty of room for UAV gear. The fuselage is a bit thin, but it fits APM perfectly!

Some more pics of the new fiberglass one:

Forty- to fifty-pound unmanned aircraft systems (UAS), both fixed-wing and helicopter models, will soon fly from Captain Jack Thomas/El Dorado Memorial Airport, Kan., under two certificates of authorization (COA) from the FAA.

Full Story Here: 

http://www.aopa.org/aircraft/articles/2011/110107unmanned_aircraft_to_fly_at_Kansas_airport.html

Quad Rotor Observer v5 tests flights with the KKmulticopter blue board

I have just tested the latest flight controller board from Minsoo Kim (the Blue board version).
This new board uses an ATMEGA 168 and a new firmware with lot of new features.
Here a video of the first tests flights of the Quad Rotor Observer (QRO) v5 with this new KKmulticopter BLUE board from Minsoo Kim.
As you will observe in the video, the hoovering of the QRO is very stable (hands off test). The model is also able to do a high speed manoeuvering and high speed turns due to the high performance of this new flight controller board (Woow... this is really fun and I enjoy a lot...)

Flight controller hardware:
KKmulticontroller "BlueBoard" from Minsoo Kim's
( http://kkmulticopter.kr ) and based on the board of Rolf R Bakke

Flight controller firmware:
XXcontroller_KR_v1_0 based on assembly code by Rolf R Bakke converted by Mike Barton modified by Minsoo Kim and Jean-Louis Naudin

- 4 brushless motors DualSky XM2822CA 1450KV 7A
- 4 ESC 12A XC1210-BA
- Lipo battery 3S (11.1V) 2500 mAh
- receiver Corona CR6D 2.4 Ghz

More infos at: http://diydrones.com/​profile/​JeanLouisNaudin

This is a follow-on to an earlier post about an Arduino-based optical flow sensor prototype. Here I actually constructed a complete sensor that could actually be integrated into a robotic platform. To achieve a smaller size, I used an Arduino Pro Mini board from Sparkfun, and added a "shield" to interface that with a Centeye image sensor and optics. The breakout of parts is shown above- The complete sensor is shown next to a US Quarter. You can also see the individual blue Arduino board and the green "shield" board. On the right are individual "sensor heads" which are basically small PCBs holding the image sensor chip (here the "FireflySmall"), optional optics, and two capacitors. The sensor head plugs into the green shield board via a Hirose DF30 board to board connector. Three sensor heads are shown- on top is a sensor head with optics, in the middle the board-to-board connector side, and on the bottom the image sensor chip side.

I wrote a simple Arduino script to grab pixels from the vision chip (configuring it to grab rectangular pixels), compute 1D optical flow using a variation of Srinivasan's "image interpolation algorithm", and dump a display of the optical flow to the serial monitor. (Some of you may know Professor Mandyam Srinivasan as the Australian biologist who has studied honey bee navigation, in particular how honey bees use optical flow to close control loops using simple but elegant heuristics.) A simple video of the sensor is shown below. I've also attached the Arduino script code, in case anyone is interested.

PIO12Firefly_ProMini_LinearOF.pde

There's a very good post over at Hizook on the lessons of the hacked Kinect: Nutshell:

"The best solution to complex low cost sensing (or actuation for that matter) is to take advantage of affordable, mass-produced components, complementing them with the innovative use of software solutions that benefit from constantly declining prices of computation."

Well worth reading it all.

Arduino The Documentary (2010) English HD from gnd on Vimeo.

I think I'm in there somewhere, wandering around in the background ;-)

You can get a Kinect for $150, but if you want the smaller, lighter sensor and the devkit to use it, Primesense will sell you that for $200. You can apply to purchase the PSDK hardware here.

(via I Love Robotics)

Enter here

I decided to post and share of my ArduCopter frame build process.

It's "hand made" folding frame, the design is adopted from: Jakub's Frame 

90% aluminum parts (The landing skids are temporary and they installed for reference only)

The center plate dimentions 120*120 MM  X configuration.

Fold is done by two steps: 

Thats all for now, more updates soon.

In the new Arduino boards, the traditional FTDI USB-to-serial chip has been replaced with an Atmel ATmega8U2 chip, which has built-in USB. We'd like to do the same on the next APM board, and use this chip to do double-duty: replace the FTDI chip that's now on the IMU shield, and replace the PPM encoder chip (now an Atmega328) that's on the APM board.  This will make smaller, simpler, cheaper APM boards for all going forward. And bye-bye FTDI drivers!

There should be enough memory in the Atmega8U2 for both the OptiBoot bootloader and the PPM encoder code. But we need some help in combining them in a way that each won't interfere with the other.  We've got a lot of great programmers here at DIY Drones. Who's up for the challenge? (Free boards for any volunteers)

Here are some starting links. 

• A tutorial on reprogramming the Atmega8u2 (you need to log into the Arduino forums to see it)
• The APM PPM encoder source code
• Details on how this chip works with Arduino: The ATmega8U2 firmware source code is available in the Arduino repository. The ATmega8U2 is loaded with a DFU bootloader, which can be activated by connecting the solder jumper on the back of the board (near the map of Italy) and then resetting the 8U2. You can then use Atmel's FLIP software (Windows) or the DFU programmer (Mac OS X and Linux) to load a new firmware. Or you can use the ISP header with an external programmer (overwriting the DFU bootloader). See this user-contributed tutorial for more information.
• The Atmega8U2 datasheet. We can move to the 16k or 32k versions if necessary

It's generally considered a bad idea to pre-announce products, but hey, we're an open source community. It's not pre-announcement--it's transparency!

We're working on about a dozen new products at the DIY Drones factory. Some of them are with partners, so I'm not free to discuss them until the partners give us the green light. But others I can tell you a little bit about now, so you'll have a roadmap to help you make your own technology and deployment plans. 

First, one note about backwards compatibility: we're committed to it. This is a fast-moving field, and we're going to release products based on the latest sensors and chips as fast as we can, because this community expects that. Think of autopilots like cellphones: you're probably going to want to upgrade about once a year. But we also work hard to ensure that the hardware you buy today will continue to be supported for at least two years.

Also, new products will be released in beta, as always. Unless you're really keen to help us catch bugs and fix problems, you're not going to want to buy any of these products until they hit the 1.0 software release, which can be as much as six months after hardware release. If all you want is a great-flying UAV, you can't beat the current APM. Most of the following products probably won't hit that level of maturity until late 2011.

Here are some of the highlights:

MultiPilot 2 ST (32-bit ArduPilot!)

This is a 32-bit Cortex M3 (ARM 7) autopilot board (board layout shown above) that's compatible with ArduPilotMega, ArduCopter and the Arduino programming system. Developed by Roberto Navoni of VirtualRobotix and the Foxteam in Italy, working with DIY Drones and the Arduino team, this board uses the APM IMU shield and will run the ArduPilot family of code, just like APM.

You can read more about it here, but the basics are that this board will offer high-end processing power for pro-level autopilot needs in planes, multicopters and helicopters. It can run a Real-Time Operating System and will be ROS-compatible.

Current specs are as follows, although these will be upgraded to the latest chips available at the time of release

• Arm7 Cortex M3 processor STM32F103VET6. 72 Mhz
• Flash 512 Kbytes RAM 64 Kbytes
• 16-bit Timer 4
• SPI 2 (ADC Interface, MicroSD connection)
• I ² C 2 (First I2C (sensor), Second I2C control until ESC 12)
• USART 5 (GPS, DEBUG Console, XBee Pro Telemetry)
• USB 1 (Upload Firmware, Debug Console, Power Board for Debug)
• CAN 1 (Interconnection with Professional ESC 1 Mbit update rate)
• 6 PWM Output Bit 16 (ESC / Servo Control)
• 8 PWM Input 16 Bit (RC Input Channel, accept PPM SUM)
• 8 Analog Input 12 Bit.
• Professional 4 layers PCB.
• DC: DC 30 V (6s Lipo): 5 volts and 3.3 volts

First prototype boards are incoming and you should not expect commercial versions to be available with release code until the second half of the year. Pricing is yet to be determined. Projected Release: Q3

ArduPilotMega 2560

Starting in about two weeks, all APM boards will ship with the Atmega2560 chip, which has twice the memory of the Atmega1280 chip that APM currently uses. There are some other minor changes to the board that have already been released in the 1.4 version that is currently shipping. The current code doesn't need all this memory, so the new boards will operate exactly like the current ones and there is no need to upgrade. But this does give us room for more ambitious enhancement to the code in the future. Projected Release: end Jan

New All-In-One ArduPilot boards

Not everyone wants a flexible development board like APM. Some people want smaller, simpler, cheaper autopilots. That's why we'll be releasing all-in-one versions of APM this year using the new Invensense MPU-6000 6-axis chip (we may be the first autopilot on the market to have them). As promised, we will also update the current APM IMU shield with new sensors when we get them (this is why we made APM modular--so you can upgrade components as technology evolves). Projected Release: Q2

Universal Ground Station

As Jordi hinted in this post, we're developing a universal ground station: a wireless hardware device that can render an in-browser Ground Control Station on any smartphone, tablet or PC.  This "magic box" will be a wireless router between your aircraft and the display device of your choice, as well as driving a tracking antenna and providing datalogging. It's the ultimate cross-platform GCS! Just imagine controlling your UAV via an iPad or even an Andoid phone. This device will make it easy--no software required.  Projected Release: Q2

More Pre-Made autopilots and UAVs

At the DIY Drones store, we only sell components and kits. But our partners around the world are gearing up to sell pre-made autopilots and even ready-to-fly UAVs. You can already buy an ArduCopter with pre-soldered APM electronics from FahPah, but you'll see more in that vein from FahPah and others early this year. The marketplace has spoken clearly on this--not everyone wants to have to use a soldering iron or load code to use a UAV--and DIY Drones partners are responding. Projected Release: Q1

On the code side, expect the versions we release this year to increasingly do auto-detection of hardware and otherwise require less setup. Our ambition for 2011: make UAVs as close to plug-and-play as possible. You can hack APM all you want, but if you don't want to see a line of code you don't have to.

Other cool stuff

The above is just a taste of what we've got in the pipeline. Other products that are in the prototyping stage including open source On-Screen-Display boards (including integrated with APM), open source ESC, smartphone interfaces, new GPS modules, ground rover autopilots and more!

Hello to All,

I have done successfully the first test flight of the Quad Rotor Observer (QRO) v4 with a new costless flight controller board V7 which uses a Atmega 168 and 3 piezo gyroscopes (NEC CG-L43). This is a personnal variant of on the KKmulticopter board widely spread on the web. I am really surprised by the stability and the flight enveloppe of this quadcopter Vs the simplicity of the firmware code (Occam's razor principle...) and the low cost of the electronic material used here in this design...

Tested setup:
- personnal flight controller v7 with Atmega168 and 3 piezo gyro CG-L43 based on the KKmulticopter board
- firmware Quadcontroller v4.5 by Rolf R Bakke
- 4 brushless motors DualSky XM2822CA 1450KV 7A
- Lipo battery 3S (11.1V) 1500 mAh
- receiver Corona CR6D 2.4 Ghz

More technical infos at: http://diydrones.com/profile/JeanLouisNaudin