PCB Quadrotor (Brushless)

The attached file (4pcb_DOC.zip) contains all of the support files for making and flying 4pcb. Included in the zip file are:

4pcb_ARD (folder) – Arduino project (Arduino 0022, .pde).
4pcb_EAG (folder) – EAGLE board files and libraries (EAGLE 6.0.0 Light Edition).
4pcb_EXE (folder) – Ground station executable (requires .NET Framework 2.0 or later).
4pcb_GRB (folder) – Gerber files for PCB printing.
4pcb_VB (folder) – Ground station source (Visual Basic Express 2008 or later).
4pcb_BOM.xlsx – Bill of material in Excel format.
4pcb_DIR.jpg – Coordinate system of quadrotor and IMU.
4pcb_EXT.pdf – Details of external connections.
4pcb_IMU.jpg – Image showing vibration mounting and wiring of Pololu minIMU-9.
4pcb_SCH.pdf – PDF schematic of the board.

Bill of Materials / Cost:

The Bill of Materials (4pcb_BOM.xlsx) lists all the components required to put together one PCB quadrotor and ground station. The total cost to build the quadrotor is about $240. The ground station consists of a USB game controller, an XBee radio, and and XBee-to-USB adapter. If you don’t already have these, they add an additional $80 or so.

Soldering:

This board requires a good amount of surface-mount soldering, including passives as small as 0603 and four TSOP36 ICs. They can all be hand-soldered (no BGA or leadless).

Additional Tools and Hardware:

– Wire (22AWG and 28AWG stranded would work) and wire cutters/strippers.
– Solder braid for cleaning up bridges.
– FTDI cable for programming the Arduino Pro Mini.
– Hex key set.
– Double-sided foam mounting tape.

Software:

-EAGLE
If you want to modify the printed circuit board, you’ll need EAGLE v6.0.0 or later. You can download it here. The free “Light Edition” is sufficient, even though the outline of the board is larger than 100x80mm limit (see Step 2). You will also need EAGLE to reference the board layout when placing components. (e.g. Type “show R32” in the board window command line to figure out where to put resistor R32.) There are no designators on the board itself.

-Arduino
The flight controller is written in the Arduino IDE. You can download the latest version from here. Make sure you set the board type to “Arduino Pro Mini (5V/16MHz) w/ ATmega328”.

-Visual Basic Express (Optional)
The ground station is programmed in Visual Basic Express. If you want to modify the ground station software, you can download the free edition, Visual Basic Express 2010 from here.

-.NET Framework
The ground station requires the .NET Framework runtime files. (Unfortunately, this makes it Windows-only.) These files come with Visual Basic 2010, so if you plan on modifying the ground station software, there’s no need to download them separately. If you just want to run the ground station executable, you can download the .NET Framework runtime files from here.

-Processing? (Optional)
Although I haven’t done so myself, it is possible to port the ground station software over to Processing, which would make it compatible with other operating systems. To read from the USB game controller, there is a third-party library called ProCONTROLL. I did some work with this for a XBee-based robot controller, the details of which are here. This could be a good starting point for making a non-Windows ground station.

4pcb’s Printed Circuit Board is its main structural component and electronics motherboard. The second most time-consuming part of the project was probably designing the board in EAGLE. (The most time consuming part is programming the flight controller and tweaking the controls.) I included the Gerber files required to manufacture an exact copy of 4pcb’s PCB in the project documentation files (Step 1). In that case, you can skip to the next Step, which talks about board manufacturing options. But, I strongly encourage anyone who is interested in modifying the board design to pop open the EAGLE files and go for it!

How to Cheat EAGLE Light’s Board Size Limit (A Little):

4pcb is quite a bit larger than the 100x80mm board size limit for the free EAGLE Light Edition. One reason I put off starting this project was because I didn’t want to pay for the full version or switch to a different board layout software. But then I discovered something interesting: The board size limit applies only the placement of components. You can route traces, add holes, and create a board outline that extend far outside the 100x80mm box.

4pcb’s centroid is right at the middle of the 100x80mm bounding box. All the components fit in the center part of the board, inside this restricted area. The arms, including the motor mounting holes, stretch out in all directions including going into negative coordinates. This is fine – the Gerber files still seem to render properly.

Board Outline:

4pcb’s board outline (“Dimension” layer in EAGLE) is actually the shape of the quadrotor frame. Most board printing companies will route the outside dimension of your board to any shape you specify. (Make sure this is an option before you order.) Drawing the shape took some practice using the arc tools in EAGLE. One idea that’s been suggested is to add diagonal supports between the arms. However, this would create areas of internal routing, and most board companies charge extra for that.

Rotational Symmetry and Copy-Paste:

The four motor controller blocks are rotationally symmetric. I routed this board in EAGLE 5.11, when Copy-Paste of component groups was more difficult. I think it’s much more straightforward in EAGLE 6.0.0 and later. But it definitely still saved a lot of routing time to be able to make four identical copies of the motor controller block. If you’re using an older version of EAGLE (prior to 6.0.0), the rough process for Copy-Paste is as follows:

1. Create and route the component block to be copied. Do this first, before any non-copied components are placed or routed. This will help auto-numbering not break.

2. Close the schematic. This breaks the back-annotation check so that you can Copy-Paste on the board itself.

3. Select the group and perform a group copy (Ctrl + Right Click). Paste, move, and rotate as desired.

4. Re-open the schematic. Ignore all the errors. Copy-paste the schematic group containing exactly the same components and nets as the board group.

5. The auto-numbering should work, but if it doesn’t you may have to clean up some designators manually to make them match the board copy.

6. Repeat.

The process should be much simpler in EAGLE 6.0 or later, and shouldn’t require breaking the back-annotation. I haven’t gotten around to trying it yet, though.

Make it real.

Below is a list of just a few board printing companies. They should all take the standard set of Gerber files. For a two layer board, there should be up to seven files. The Gerber files for 4pcb are included in the project documentation files (Step 1).

Layer Definitions:

Top Silkscreen (pcbqr.GTO)
Top Solder Mask (pcbqr.GTS)
Top Copper (pcbqr.GTL)
——————————————
NC Drill (pcbqr.TXT)
——————————————
Bottom Copper (pcbqr.GBL)
Bottom Solder Mask (pcbqr.GBS)
Bottom Silkscreen (pcbqr.GBO)

You can probably live without the silkscreen, since the component density is too high for designators to be useful anyway. (You’ll have to reference the EAGLE files to place all the parts.) The soldermask is absolutely necessary for this board, though. A bare board will be too difficult to solder.

Board Printing Services:

-Advanced Circuits (www.4pcb.com)
Fast and reliable (US-based), but expensive shipping. If you are a student, use the 33each discount to get a single board for $33 + shipping. This is where I got mine printed. And yes, the name “4pcb” comes from this site’s URL, though they are not an official project sponsor or anything.

-MyRO PCB (www.myropcb.com)
Inexpensive and usually fast.

-Dorkbot PDX (www.dorkbotpdx.org/wiki/pcb_order > now www.oshpark.com?)
Group order, so it could be slower, but good pricing.

There are many others. Shop around. Just make sure that external routing to non-rectangular shapes and soldermask on both sides are standard options.

Depending on your mood, this step can either be very relaxing or very boring. Definitely find a nice soldering station to work at (or if you are more into hot-plate or reflow soldering, go for that). It took me two sittings to solder everything.

Locating Components:

The part designators (e.g. “R15”) on the “Names” layer in EAGLE are not rendered on the silkscreen. I chose to leave them off because the component density is high enough that making them not overlap would be a time consuming process. Instead, the method I usually use for placing parts is to have the EAGLE board open on a nearby computer and using the “show” command to highlight each component as I go. (See the third image for an example of this.)

I failed in my goal of completely containing the quadrotor circuit to a single PCB with no external wiring. There are two sets of external wires to connect, 12 wires in total, each with good reason. The external wiring is summarized in 4pcb_EXT.pdf in the project documentation (Step 1).

Pololu minIMU-9 Mounting and Wiring:

This quadrotor’s original design called for the now-obselete Sparkfun 6DOF Razor IMU. The new design uses the Pololu minIMU-9. The minIMU-9 is a digital IMU, which has some nice benefits (higher resolution ADC than the Arduino, self-zeroing). It’s also smaller than the Razor IMU was and only requires four connections to communicate with the Arduino Pro Mini over I2C serial.

I didn’t modify the board to have a minIMU footprint because I found that the IMU has to be mounted on foam tape anyway in order to minimize the effects of mechanical vibration transmitted through the frame. (The vibration really messes with the gyros, in ways that can’t even be filtered out.) I found that making a loop of foam tape works even better than one or two layers alone. Also, I found that adding mass to the IMU, by taping small pieces of aluminum to the bottom, helped. (See the third image.)

After mounting the IMU to the frame, the four connections should be made with thin, flexible external wires (also to minimize vibration). Conveniently, the connectors can go right to the first four pins of the now-unused Sparkfun IMU header. (See first image.)

External Power Wiring:

The power wiring carries high current, so I thought it would be a good idea to keep it off-board. In retrospect, I wish I had put the external power wiring on the board. This is something I would definitely modify in v2. There is enough room to route a few large traces around to carry power and ground to the four motor controllers, especially with the Sparkfun IMU headers out of the way.

For now, though, the power wiring is done externally with 22AWG or larger, preferably stranded wire. There are a total of 8 wire jumps to make, four for power and four for ground. (See the second image.) To eliminate ground loops, a star configuration from the battery power input to each motor controller could be used.  I found that a bus works okay, though. (Keep in mind that in a bus, the wires feeding out from the main power input carry the most current.) Be very careful not to reverse any of these connections, or it will instantly destroy the motor controller on power-up.

This PCB quad uses four tiny brushless motors for propulsion. They’re the HXM1400-2000 “hexTronik 5gram Brushless Outrunner 2000kv”. They’re designed for 2S (7.4V) batteries, and the quad will fly with a 2S battery. However, the minimum voltage rating of the Toshiba TB6588FG driver chip is 7V, which is cutting it a little close for 2S. I found that a 3S (11.1V) battery, even one that it slightly heavier than the 2S, increased flight time and didn’t cause the motors to overheat.

The 10g version and 20g version of this motor fit the same mounting pattern and can swing a much larger propeller, so it might be possible to make a larger version just by extending the arms. Stiffness would be a concern at that point. The 2g version might also fit the same mount, for an even smaller quad, but its rpm/V is too high to run effectively on 3S and it’s speed might exceed the RPM limit of the Toshiba TB6588FG.

Mounting:

The motors bolt directly to the PCB with short 2-56 machine screws. The wires should be facing inward and the hole directly under the wires may be inaccessible. That’s okay: three screws will do. The two side screws should get 2-56 nuts. The outermost screw will be used to attach the landing gear in the next Step, so it doesn’t need a nut. Use threadlocker (Loctite) on all the screws otherwise vibrations will cause them to loosen.

Wiring:

The motor wires are pre-tinned and can be soldered directly to the three output pads of the motor controller component block, which are on the bottom layer of the board. Sometimes, the wires come long enough to reach around the arms. Other times, they are too short. You can either make wire extensions or drill a hole in the arm for a more direct line to the pads. (See the third image.)