This material is one of the most popular plastics in the world. It is made of polystyrene or PS.

As shown in Figure 9-1, there are two general types available: expanded Polystyrene (EPS) and extruded Polystyrene (XPS).

EPS is more lightweight and less rigid than XPS. Both types can usually be found in DIY ("do it yourself") stores in the form of rigid panels with various thicknesses.

Figure 9.1. EPS on the left, XPS on the right

EPS is usually white and has visible pores the size of a few millimeters. When you break this material, you can see some of the pores fly around like small bubbles. This material is very lightweight, soft, and not so easy for sanding.

XPS is usually colored and is usually used for the insulation of basements. It is more expensive, heavier, and harder than the low-density version, but it is easier to treat with sanding paper.

Either of the two materials will work for the construction of the hulls. I personally prefer XPS, because the finish will be better afterward. For the hulls, a material thickness of 4″ (100mm) is adequate. If you don't find this thickness in your local store, simply take smaller ones and glue them together until you have the appropriate size. More about the glue later.

Both of these materials share one drawback: they can be easily melted away by most organic solvents. If you want to start any treatment on this material with paint, resin, or putty, please try in advance on a piece of unused material and allow at least one hour to observe what happens. Using the wrong material on polystyrene can ruin your day in seconds!

We will use this product in combination with fiberglass fabric as a coating for the EPS/XPS to add more strength to the hull. Here is some advice in advance.

Please do not use material for the coating other than this one. There are other two component resins available on the market; most of them can be found in DIY stores as resins or putty. Most of them are based on polyester, and that material is definitely not compatible with polystyrene. Here is one test: if it smells extremely like plastic, you can be sure that you have chosen the wrong product.

Back to epoxy. This is a two-component resin, and it is available in most hobby or modeling shops. Usually it is compatible with most materials, even polystyrene. There are various brand names of that product available. Please ask your local dealer or search the Internet for more information.

After mixing the two components in the right ratio (the resin and the hardener), you will get a honey-like liquid, which can be processed for about 15–30 minutes until it starts to thicken. The total time to cure is about 12 to 24 hours, depending on the product. So it is good practice to start the work in the evening, let it cure overnight, and wake up with a (hopefully) ruggedized hull in your workshop.

There are two methods of mixing you can use: by weight or by volume. Please read the instructions that come with the product; usually both methods are described there. The ratio has to be kept within a certain accuracy (about +−5% is OK). Please be careful about that, otherwise you will end up with a hull that will be sticky for years.

After the mixing of the two components, thoroughly stir it for at least one minute and allow another minute of silence to eliminate the air bubbles.

Please wear disposable rubber or plastic gloves for the whole time you are in contact with the material for these reasons:

Fiberglass fabric is made of very thin glass filaments. These filaments are woven like "ordinary" fabric (Figure 9-2).

There are lots of fiberglass products available. For the coating of the hull, a fine fabric should be used to give a smooth surface and for ease of work.

Thick fiberglass fabric or fiberglass mats are not suitable because these materials are too stiff to handle. Fiberglass is usually categorized on a "weight per surface" basis. Values around 0.3oz per sqft (80 grams per m²) are perfect.

Figure 9.2. Woven fiberglass fabric with 80g/m²

Fiberglass fabric can easily be cut in appropriate pieces with a pair of scissors. You will need to buy a pair of scissors especially for your work, because the wear of the blades is much higher compared to cutting tissues or paper, and the scissors may (they surely will) get contaminated by epoxy resin. Hardened epoxy resin on fiberglass can be cut with a sharp razor knife. This is helpful for cutting away excess material prior to sanding.

To glue the segments together, you must use Styrofoam glue. This should be available at a hobby shop or most DIY stores. The glue is a contact adhesive, like others, but it has a solvent that is compatible with polystyrene.

With the materials out of the way, let's discuss the tools.

A hot wire Styrofoam cutter is absolutely mandatory to make a smooth cut of the segments. If you don't want to buy a cutter, you can easily make your own. There are lots of plans on the Internet; please have a look at this site: www.instructables.com/id/Hot-wire-foam-cutter/. Or simply Google "Styrofoam cutter" and you will find lots of links for DIY plans to make your own.

You do not need one with a table, because the cardboard template will be your guide. The wire length should at least be 12″ (300mm) to have enough room to operate. Please test in advance on some unused Styrofoam pieces.

A sharp razor knife is also useful for trimming and cutting the foam.

Sanding paper is useful for smoothing the surface. After the thermal cutting of the segments, the surface of the Styrofoam is a little bit roughened through the melted material. I would suggest firstly gluing all segments together and then doing a little bit of sanding. Be careful not to use sanding paper that is too coarse and not to apply too much force on the material.

For applying the epoxy resin on the Styrofoam and on the fabric, a disposable paintbrush is perfect. After using it, the paintbrush is useless. I do not know any solvents to wash the resin off. Buy some cheap ones and throw them away after use.

The paper templates with the cross-sections of the hulls can be found as a downloadable .pdf file at http://code.google.com/p/roboboat/downloads/list and Apress.com. Print twice all the segment templates from "Segment 1" to "Segment 14." Each segment template consists of two outlines: the inner and the outer one. This is the reason you shall print it out twice. Glue the printout on cardboard with a thickness of about 0.04″ (1mm). Then cut out an inner and an outer template of each segment with a pair of scissors, as I did for Segment 6, shown in Figures 9-4 and 9-5.

Figure 9.4. The printed templates

Figure 9.5. The templates, glued on cardboard and cut

If there are any burrs, remove them with sanding paper. Apply dual-sided sticky tape on the backs of the templates (Figure 9-6). There is no need to cover the whole template with the tape. A piece ¾″ (20mm) × ¾″ (20mm) should be OK. Do not peel off the protective paper yet.

Figure 9.6. The templates from the back, with sticky tape

The first and the last segments (1 and 14) are very delicate to handle because the ends are very thin. I have shortened these segments to half of their original length, which was 2″ (50mm). This will shorten the overall length of the hull to 50″ (1300mm), but this will have no effect on the performance of the boat.

Now, the most critical part of the work begins. You have to adjust the front and back template to each other and then glue it to the Styrofoam board. The boards come pre-cut with very exact edges, and this helps a lot for the adjustment (Figure 9-7). First paint an exact rectangular line on the front side and the adjacent sides of the board.

Figure 9.7. Preparation of the EPS board

Then take the outer template, peel off the protective paper from the sticky tape, and adjust the line to the vertical crosshair line that is printed on the template. Align this template to the top edge of the board (Figure 9-8).

Figure 9.8. Alignment of the template on the EPS board

Next, measure the vertical distance (d) between the outer and inner template and adjust the inner template on the back of the board accordingly, e.g., move it (d) down from the top edge. Note that the vertical distances in the middle segments are close to zero.

You have to use a hot-wire foam cutter for this purpose. Figure 9-9 shows a picture of my DIY version.

Figure 9.9. The DIY Styrofoam cutter from the author

First separate the segment from the panel by making a rough cutout of the segment, allowing about ½″ of extra Styrofoam around the template, as shown in Figure 9-10. This piece will now be much easier to make perfect with one more pass through the wire cutter.

Figure 9.10. Coarse cutout of one segment

Then cut away the excess material by using the cardboard template as a guideline, as shown in Figure 9-11. Adjust the temperature of the wire so that it gives a smooth cut. Temperatures that are too high will melt away the material under the template.

Experiment a little until the results are satisfying.

Figure 9.11. Fine cutting of one segment

The ready cut segment should now look as shown in Figure 9-12. It is important to label each side of the cut segment with a felt-tip pen after you have peeled off the templates. You will need this labeling afterward, when gluing the segments together.

Figure 9.12. One segment after cutting

This step is simple. Apply a layer of the glue to one of the surfaces, put the other surface together, press firmly, and then separate the surfaces. With this method, you will have a thin layer of the glue on either side. Allow some minutes to dry until the surface has a rubber-like consistency that is still a little bit sticky. Then put the surfaces together and press firmly. Attention! Adjust the two surfaces exactly, prior to putting them together. There will be no second chance. The glue acts immediately! In Figure 9-13, you can see two segments prior to gluing.

Figure 9.13. Two adjacent segments with EPS/XPS glue

After having glued all segments together, the result should look like that shown in Figure 9-14.

Figure 9.14. All segments glued together

To smooth out the surface and to remove excess material, use sanding paper. This will take some time. It's best to do the sanding outside and use old clothing because there will be quite a bit of polystyrene dust created during this process.

To connect the deck with the hulls, foam anchors are very useful. Normally, these anchors are used to hold screws in walls that have been insulated with foam panels or for use in sheetrock walls. Look in your DIY store for this item. The one I have used looks like that in Figure 9-15.

Figure 9.15. A foam anchor from the DIY store

Normally, these anchors are made to hold wood screws. To hold machine screws, I tapped an M5 thread into the anchor (Figure 9-16).

Figure 9.16. The foam anchor screwed into the hull

To give more strength, you can apply a little bit of epoxy resin to the anchor prior to inserting it into the foam.

The placement of the anchors is in the middle of segments 7 and 11, as you can see in Figure 9-17.

Figure 9.17. The placement of the anchors

This is delicate work, so it is best to be prepared. Put a lot of old newspaper around the area of work before you begin. To hold the hull in place, make a stand from some unused foam, and insert two foam anchors with two M5 threaded bolts, as shown in Figure 9-18.

Figure 9.18. The hull, prior to coating

This will hold the hull in place for the coating with the fiberglass fabric.

I did the coating in two steps: first the bottom of the hull and then the top. I also made overlapping areas on the top. To secure the fiberglass to the foam, use some pins that can be removed after the hardening of the epoxy.

First cut out a rectangular piece of fiberglass in the size of 53″ × 12″ (1350mm × 300mm). This will fit the length and will give an overlap to the top of about 0.8″ (20mm). Lay it over the hull that sits bottom-up on the stand. Adjust the material. Make a cut in the wrinkles and overlay the material. If the fiberglass is positioned, mix the epoxy according to the instructions of the product you are using. Wear rubber gloves. Then apply the epoxy over the fiberglass by speckling with the paintbrush. The fiberglass will soak up the epoxy and leak through onto the foam. Try to squeeze out air that is trapped between the foam and the fabric.

When you have finished, it should look like Figure 9-19.

Figure 9.19. The hull, coated with fiberglass fabric and epoxy resin

If you don't have a fiberglass sheet this big, you can also do a "patchwork" with smaller pieces. This will ease the work, especially if you are not familiar with fiberglass work. Simply overlap the patches and speckle them with the paintbrush.

After the epoxy hardens (usually after 12 hours), you can take the hull from its stand and look at your work. Excess material can be cut away with a sharp razor knife cutter. To coat the top side, first put some sticky tape over the holes of the foam anchors to avoid epoxy resin going into it. Then fix the hull (e.g., between two bricks) and apply the fiberglass and the epoxy as described earlier.

After coating both sides of both hulls, there are still some things to do. The tips of the last segments (1 and 14) must also be coated. You can do this by cutting out fiberglass sheets that match the cross-sections and epoxying them to the foam. An alternative way to get the end-points finished is to make a "putty" by mixing epoxy resin and a filler material like cotton flakes or glass bubbles (available in RC model shops). You can then apply this material to the end-points.

After the epoxy hardens, cut away excess material with a razor knife and do some sanding to smooth the surface and the edges.

To give good straight-line stability, you must add small fins to ends of the hulls. The fins are simply triangular sheets that can be made of various materials (Figure 9-20). I used PVC foam sheets with a thickness of about ⅞″ (2mm). Any other waterproof material of this thickness will work. You can even use plywood, if painted or treated with urethane. Cut out a triangle the size of 4″ (100mm) × 1.5″ (40mm), and glue it to the end of the hull. I used hot glue, which works fine if you have roughened the surface with sanding paper prior to applying the glue.

Figure 9.20. The fins

There is no need for painting, but for the sake of visibility, I suggest applying some fluorescent paint onto it. You can use any sort of paint, because the epoxy acts as an isolation layer for the foam. It is good practice to use a white primer layer and then apply the fluorescent layer by either a paintbrush or spray. The white primer layer will increase the visibility of the fluorescent paint.

This is a fairly easy task, compared to the fabrication of the hulls. Simply cut out a 23″ (600mm) × 15″ (400mm) sheet of an XPS foam panel with a thickness of at least ¾″ (20mm). To add strength, you can coat this board with epoxy, but it is not mandatory, because the XPS is very solid. If you don't have XPS, use EPS instead and coat it with epoxy. Figure 9-21 shows the dimensions and the position of the four mounting holes for the hulls. The holes are symmetrical, so I put the dimensions of only one for reference. The holes in the middle part of the board are for fixing other superstructures and are not relevant at this point of the assembly.

Figure 9.21. The deck with mounting holes

Now, the great moment has come! For the assembly, I have used M5 bolts with "eyes" and some rectangular plywood spacers to hold all pieces together (Figure 9-22). The eyes are useful to tie some of the superstructures to the deck.

Figure 9.22. Mounting material for the connection of deck and hulls

Simply screw the deck panel to the hulls and tighten until the stability is sufficient (Figure 9-23). Do not over-tighten the screws, to avoid damage to the foam.

Figure 9.23. Deck and hull mounted together

If you have done your work right, you should have something that looks like Figure 9-24.

Figure 9.24. The finished catamaran platform

With the hull assembly completed, we will move on to building the propulsion system. Catamarans are typically propelled by the wind and sails. The RoboBoat has a quite different kind of propulsion: a wind generator that will be described in the next section.

To easily mount and dismount the whole assembly to different hulls, I have put all the components on an intermediate baseplate (Figure 9-26). A 0.15″ (4mm)-thick aluminum plate is the best choice, if you want a rock-solid construction. In the pictures in this book, I have used two PVC foam sheets that are glued together. Other materials that are water-resistant and rigid enough will also be suitable (e.g., Plexiglas, painted plywood, etc.). The baseplate is fixed to the deck of the boat with four screws. For that purpose, drill four holes ½″ away from each edge.

The pivot is screwed to the baseplate with an M5 countersunk screw. Drill a hole of ½″ (6mm) with a countersink on one side. The baseplate will also hold the servo. The servo has to be adjusted in height to match the rudder horn of the turn assembly.

Figure 9.26. Drawing of the baseplate

The pivot is made of a PVC rod with a diameter of ¾″ (20mm). On the bottom is an M5 thread, which is used to screw it to the baseplate (Figure 9-27). This is the only component that you may need a lathe to manufacture. The pivot should match closely to the inner diameter of the tube. A PVC fitting that matches the PVC tube (from outside) may also be suitable, but I have never tried.

Figure 9.27. The pivot mounted on the baseplate

The tube shown in Figure 9-28 holds the motor and sits on the pivot. It is made of a 1″ (25mm) PVC tube. To use propellers with diameters up to 11″, the tube should have a length of 7″ (170mm).

Figure 9.28. The PVC tube

To hold the motor, simply drill two holes with a diameter of ⅛″ (3mm) in the upper part of the tube, as shown in Figure 9-29. If your motor has a shaft on both sides, drill a hole of about 5/16″ (8mm) into the tube to have room for the shaft. For ease of mounting, drill two holes of 5/16″ (8mm) on the opposite side of the ⅛″ (3mm) holes. Then fix the motor to the tube using M3 screws.

Figure 9.29. Mounting holes for the motor

The rudder horns connect the tube to the servo. There is one on each side of the tube, which will give a push-pull connection to the servo, which is more stable than a single pushrod. I used general-purpose rudder horns for RC models, which are available in hobby stores. The lower part of the tube must be flattened with a file to give space for fixing the rudder horns. The horns can be glued to the tube with contact glue or with two-component epoxy glue (Figure 9-30). Be sure that the holes in the horn are aligned to the center of the PVC tube.

Figure 9.30. A rudder horn, glued to the tube

Basically, you can use any motor that can turn a propeller and that produces enough thrust to push the boat forward. I used the brushless DC "outrunner" (BLDC) type shown in Figure 9-31 for several reasons. Brushed motors are also possible, but if you plan long-term trips with the boat, a BLDC is the better choice because there are no brushes that can wear out. BLDC motors that are suited for the boat are widely available, and the price is affordable. I will describe my configuration in depth, but if you want to use other types, here are basic guidelines for the selection:

With a matched propeller, you should achieve a thrust of at least 1 pound (450 grams). The diameter of the propeller should be in the range of 9″ to 11″.

Outrunner BLDC motors carry the magnets in a "cage" that runs around the stator coils. The shaft is fixed to the cage. For that reason, most of the "outside" part of the motor is turning. This makes the mounting of the motor different to the mounting of brushed motors. If possible, use one that has a shaft mounting on the cage and that is sold with a mounting kit, which consists of the motor, the propeller, and the propeller driver.

The propulsion-thrust should be in the range of about 1.1 to 1.8 pounds (500 to 800 grams). I have taken several measurements with different types of motors and propellers.

The following combination is the one that I am actually using:

The motor is usually sold in a kit with the motor mount and the propeller driver.

Figure 9.31. A BLDC outrunner motor

Use a standard RC servo that can be found in RC model shops. The rudder horn of the servo should have a diameter of 1.75″ (45mm). The servo can be either glued or screwed to the baseplate. For better performance, use screws to mount the servo.

Steel wires with a diameter of 1–1.5mm are best suited for the connection between the rudder horns of the servo and the tube. If you can find pushrod connectors, the mounting and the adjustment are very easy. If not, you can bend the ends of the wires by 90° and insert them into the holes of the rudder horns.

The small printed circuit board shown in Figure 9-33 has all key elements on board that are needed to control a vehicle by GPS. It is based on the same ATmega328 microprocessor used on the Arduino, though the ArduPilot utilizes a very small surface mount version of the chip.

Figure 9.33. The ArduPilot PCB

The board is compatible with the Arduino platform, so it is very easy for the user to modify and upload new software to the board. The board consists mainly of the following components:

The GPS module shown in Figure 9-34 is the "sensor" of the autopilot system, similar to what you might find inside a commercial automotive or outdoor GPS unit. It measures the actual position, the velocity, and the heading of the boat. It is connected to the ArduPilot board via a small, SMD-type connector. The cable for the connection between the GPS module and the ArduPilot is usually shipped with the module.

Figure 9.34. The EM406 GPS module

The ArduPilot board "talks" to the GPS module over a UART (serial) connection. There is one important thing to consider: the ATmega328 microcontroller has only one UART interface on-chip, which is also used for the programming of the chip. To avoid a conflict, the GPS module must be unplugged from the ArduPilot board while programming! More on programming in the section "The Software".

As of my writing this chapter, the EM406 GPS module remains my favorite unit to work with. There are many other GPS modules on the market that may also be suitable, but the EM406 has proved to be very robust and reliable.

The device shown in Figure 9-35 serves two functions: it supplies the ArduPilot Board with a regulated voltage of 5V and it controls the speed of the BLDC motor. The ArduPilot board is powered with 5V that is derived from an ESC with a so-called battery eliminator circuit (BEC). This is simply a linear regulator that sits inside the ESC electronics and provides a regulated 5V supply out of the voltage from the battery pack. The connection to the ESC is done via a standard RC servo connector with three poles. There are lots of ESCs out on the market, and it is impossible to suggest one that is best. It is advisable to buy one that is matched to the motor that you will use.

Figure 9.35. The electronic speed controller (ESC)

The motor is a so-called "brushless" DC motor (BLDC). It produces the thrust that drives the boat forward.

BLDC motors usually have three cables that are fixed to the motor. The connectors are directly soldered to the cables so that they can be easily connected to the ESC. If your motor turns in the wrong direction, simply swap two cables and the motor turns in the opposite direction. Care has to be taken that the cables do not interfere with the propeller. Use tie-wraps to fix it to the PVC rod, which was already described in the "Propulsion Assembly" section of this chapter.

The rudder servo turns the "windmill assembly" to steer the boat. Here you can use a "standard" RC servo. Servos of this type are widely available. There are also so-called "high-torque" servos available; they are more powerful, but slower. Any of the two versions are suited to do the job. Please do not use mini or micro servos; they are useful for model airplanes, but for a boat, they may be too small.

The battery pack provides the electrical energy for the whole electronics and—mostly—for the motor.

There are many possible solutions when it comes to selecting a battery pack. Actually, I would prefer to buy a 3S LiPo battery pack with a capacity of about 4000mAh. These types of batteries are now very common in RC modeling, and can be found online for around the same price as older battery types (like NiMH or NiCad). If you want to use other batteries, use the following data as a guideline:

Because the weight of a boat is not as critical as on an airplane, you may also find that using lead-acid type batteries will work.

To charge the batteries, use an appropriate charger. Special care has to be taken when using batteries that contain lithium, like LiIon and LiPo types, that they are not over-discharged. The lithium that is in the batteries may start to burn when the battery is overcharged or shorted. A lithium fire cannot be extinguished with water. I strongly recommend charging lithium batteries outdoors, placed on inert materials like stone tiles.

Some words about power connectors—there are some "standard type" connectors available on the market. Usually, the ESC and the battery packs come with connectors. If they are incompatible, you have to cut one side (either the ESC or the battery pack) and solder the appropriate connector to it. I have used TAMYIA-type connectors for all of my projects, because they are widely available and very robust.

To get the most out of this section, you should be familiar with the basics of soldering. If you are unsure, ask somebody who has the know-how and who can help you on that topic. I also recommend reading the tutorials at the SparkFun.com web site, where there are lots of articles and "how-to"s that can help newcomers to embedded electronics.

We start the assembly with the ArduPilot board that is usually shipped without connectors for the servos and the programming connector. All connectors that have to be soldered onto the board are breakaway headers with a pitch of 0.1″ (2.54mm) that can be found in nearly every DIY electronics shop or at http://www.sparkfun.com/products/116.

They can be easily cut or simply broken to the appropriate size. For the ArduPilot board, we need two 3-way headers and one 6-way header—that's all. Figure 9-36 shows the locations. The servo connectors are called OUT1 and OUT2 in the schematics. The programming connector is named JP2 or USB/SERIAL in the schematics.

Figure 9.36. The connectors on the ArduPilot board

After soldering the connectors, we have to make one modification on the board (Figure 9-37). We need to do this because the board provides an RC override functionality that is indispensable when you use it as an autopilot hardware for flying platforms.

For that, a multiplexer IC is integrated on the board that is used to switch the control of the servos either to the ATmega328 microcontroller or to an RC receiver. The control of the multiplexer is done by the ATtiny microcontroller (located to the right of the ATmega328 chip), which by default switches the control to the RC receiver. For the control of the boat, we do not need this functionality. To make sure that the ATtiny does not switch the multiplexer to the wrong position, we have to give control over the multiplexer to the ATmega328. Actually there is no way to do this function with software, so we have to modify the hardware. This is simply done by lifting pin 6 of the ATtiny microprocessor that controls the multiplexer. You can do this by de-soldering the pin or by cutting it with a sharp knife. If you are familiar with SMD soldering, you may also de-solder the whole chip, because it will not be needed.

Figure 9.37. The MUX modification

The Programming Adapter

You will need the adapter shown in Figure 9-38 to upload new software/waypoints to the ArduPilot board. It contains a USB to serial converter chip, so that you can connect this adapter to an USB port of your computer that runs the Arduino environment. Prior to using this adapter, you have to install the drivers for this device on your computer. Follow the instructions on the Arduino home page for the setup of the environment. The adapter that I am using comes from SparkFun electronics. You will find the product and all the documentation needed at http://www.sparkfun.com/products/9716.

Figure 9.38. The programming adapter

GPS receivers are widely available now as handheld devices the size of mobile phones or even watches. For our project, we use only the receiver hardware of such devices. They are available as OEM modules that are the size of a dollar coin and smaller. All these modules have a serial interface that transmits a data stream in the form of the National Marine Electronics Association (NMEA) protocol. NMEA has established a communication standard for the connection of marine electronic devices like logs, digital compasses, sonar, and GPS receivers. The NMEA protocol consists of ASCII "sentences" that are output from the device periodically. Each of these sentences contains various navigation information (e.g., current position, speed over ground, heading, UTC time, etc.). For our autopilot system, we need only two pieces of information from the receiver: the actual position of the boat and the direction the boat is heading in.

Some words about the behavior of GPS receivers—a GPS receiver outputs valid heading information only when it is moved with a minimum speed of about 1.5mph (3km/h). When the boat is at a standstill, or moving very slowly, the heading information of the GPS receiver is not reliable and the boat may move in the wrong direction. The behavior of different GPS receiver modules at a standstill is different, and usually the way each module exactly behaves has to be reverse-engineered. The EM406, which I use, performs well at low speeds (above 3km/h) and outputs random heading information when at a standstill. For that purpose, I let the boat go off after launch for some five seconds without any GPS control. After that time, the GPS receiver will output reliable heading data that can be fed into the autopilot software. Another good thing to know is that GPS receivers do not immediately output valid navigation data. There are several modes the receivers perform when powered up. Mainly, two modes are important to know:

The time for a warm start cannot be predicted, but usually one simple rule applies: the longer the time the module was powered off, the longer it takes to get the first fix.

Consider also that whenever you are testing the receiver, you should have a clear view of the sky. Indoors it will usually not work.

Some receivers have an LED on board that indicates the state of the receiver. On the EM406, the LED is on when the receiver is waiting for a valid fix, and it starts blinking when valid navigation data is available.

Now on to the software part of our autopilot system.

The software was developed using the Arduino IDE. You should be familiar with the basics of the C programming language and with Arduino if you want to make your own modifications to the software.

In short, the software on the ArduPilot microprocessor is designed to perform the following tasks:

You can download the software from http://code.google.com/p/roboboat/downloads/list or Apress.com.

There you will find a file called AP_RoboBoat.zip. If you unzip this file, you will get all the source code files for the autopilot that runs the RoboBoat. The software is separated into six modules (Arduino tabs) and two header files. According to Arduino conventions, these files must be placed into a folder that has the same name as the main program. In this case, copy it into a folder called AP_RoboBoat. Double-click the file ending with .pde. The Arduino IDE will open and you can proceed.

In the following sections, I will briefly describe the function of the modules. These modules make up the entire autopilot software system. If you have built your boat and propulsion assembly as described in the previous sections, there should be no further modifications necessary.

/* By Chris Anderson, Jordi Munoz, modified by Harald Molle for use on model boats */
/* Nov/27/2010
/* Version 1.1 */
/* Released under an Apache 2.0 open source license*/
/* Project home page is at DIYdrones.com (and ArduPilot.com)
/* We hope you improve the code and share it with us at DIY Drones!*/


#include "defines.h"
#include "waypoints.h"

// Global variables definition
int waypoints;  // waypoint counter

unsigned int integrator_reset_counter = 0;  // counter variable (in seconds) for the
Integrator holdoff-time after a waypoint switch

byte current_wp = 0; //This variable stores the actual waypoint we are trying to reach.

int wp_bearing = 0; //Bearing to the current waypoint (in degrees)
unsigned int wp_distance = 0; // Distance to the current waypoint (in meters)

//GPS obtained information
float lat = 0; //Current Latitude
float lon = 0; //Current Longitude
unsigned long time; // curent UTC time
float ground_speed = 0;   // Speed over ground
int  course = 0;          // Course over ground
int alt = 0;              //Altitude above sea

// Flag variables
byte jumplock_wp = 0; // When switching waypoints this lock will allow only one transition.
byte gps_new_data_flag = 0; // A simple flag to know when we've got new gps data.

// rudder setpoint variable, holds the calculated value for the rudder servo
int rudder_setpoint = 0;

byte fix_position = 0; // Flag variable for valid gps position

// Arduino Startup, entry point after power-on
void setup()
{

  init_ardupilot(); // Initialize the hardware specific peripherals

  waypoints = sizeof(wps) / sizeof(LONLAT); // calculate the number of waypoints

  Init_servo(); //Initalize the servos, see "Servo_Control" tab.

  test_rudder(); //Just move the servo to see that there is something living
  bldc_arm_throttle();  // Initialize the BLDC controller

  print_header(); //print the header line on the debug channel

  delay(500);  // wait until UART Tx Buffer is surely purged

  init_startup_parameters();  // Wait for first GPS Fix

  test_rudder();   // Move rudder-servo to see that the launch-time is close

  bldc_start_throttle(); // start the motor

  delay (5000); // go the first five seconds without GPS control to get the direction vector
stabilized

  init_startup_parameters(); // re-synchronize GPS

}

// Program main loop starts here

// Arduino main loop
void loop()
{


  gps_parse_nmea(); // parse incoming NMEA Messages from GPS Module and store relevant data in
global variables

  if((gps_new_data_flag & 0x01) == 0x01)    //Checking new GPS "GPRMC" data flag in position
  {

digitalWrite(YELLOW_LED, HIGH); // pulse the yellow LED to indicate a received GPS
sentence
    gps_new_data_flag &= (∼0x01); //Clearing new data flag...
    rudder_control(); // Control function for steering the course to next waypoint
    if (integrator_reset_counter++ < WP_TIMEOUT)    // Force I and D part to zero for
WP_TIMEOUT seconds after each waypoint switch
     reset_PIDs();

    send_to_ground();   /*Print values on datalogger, if attached, just for debugging*/
  } // end if gps_new_data...


  // Ensure that the autopilot will jump ONLY ONE waypoint

    if((wp_distance < WP_RADIUS) && (jumplock_wp == 0x00)) //Checking if the waypoint distance
is less than WP_RADIUS m, and check if the lock is open
    {
      current_wp++; //Switch the waypoint
      jumplock_wp = 0x01; //Lock the waypoint switcher.
      integrator_reset_counter = 0;

      if(current_wp >= waypoints)    // Check if we've passed all the waypoints, if yes stop
motor
       finish_mission();
     } // end if wp_distance...

  digitalWrite(YELLOW_LED,LOW);  //Turning off the status LED
} // end loop ()

// PID Debug Variables
float pid_p;
float pid_i;
float pid_d;
float pid_dt;
int dbg_pid_error;

// Debugging output, sends the value of internal variables to the datalogger every second
// Floating point values are multiplied and converted to integers to get it through the
Serial.print function
void send_to_ground(void)
{

Serial.print(course);
    Serial.print("	");

    Serial.print((int)wp_bearing);
    Serial.print("	");

    Serial.print(dbg_pid_error);
    Serial.print("	");

    Serial.print(wp_distance);
    Serial.print("	");

    Serial.print(time);
    Serial.print("	");

    Serial.print((int)rudder_setpoint);
    Serial.print("	");

    Serial.print((int)current_wp);
    Serial.print("	");

    Serial.print((int)pid_p);
    Serial.print("	");

    Serial.print((int)pid_i);
    Serial.print("	");

    Serial.print((int)pid_d);
    Serial.print("	");

    ground_speed *= 18.0; // Scale miles/h to km/h * 10
    Serial.print((int)ground_speed);
    Serial.print("	");

    Serial.print(alt);

    Serial.println();

}
// Debugging output, sends the value of internal variables to the datalogger once on startup
// Floating point values are multiplied and converted to integers to get it through the
Serial.print function
void  print_header(void)
{
 // Header for the System constants
  Serial.println("KP_HEADING		 KI_HEADING		 KD_HEADING		 INTEGRATOR_MAX		 RAM");
  delay(250);
  Serial.print ((int)(KP_HEADING * 100));
  Serial.print("		");
  Serial.print ((int)(KI_HEADING * 100));
  Serial.print("		");

Serial.print ((int)(KD_HEADING * 100));
  Serial.print("		");
  Serial.print ((int)(INTEGRATOR_LIMIT));
  Serial.print("		");
  Serial.println( ram_info() );
  delay(250);

  // header for the debugging variables
  Serial.println("Act	 Setp	 err	 Dist	 Time	 Rudd	 WP	 pid_p	 pid_i	 pid_d	 speed	
alt");
  delay (250);
}

// function to calculate the remaining amount of RAM in Bytes
// Check always, if you have changed the Waypoint array (see the Header of the debug-output)
int ram_info()
{
  uint8_t *heapptr;
  uint8_t *stackptr;

  stackptr = (uint8_t *)malloc(4);   // use stackptr temporarily
  heapptr = stackptr;               // save value of heap pointer
  free(stackptr);                 // free up the memory again (sets stackptr to 0)
  stackptr =  (uint8_t *)(SP);   // save value of stack pointer

  return ((int) stackptr - (int) heapptr);
}

void init_ardupilot(void)
{
  gps_init_baudrate();
  Serial.begin(9600);

  //Declaring pins

  pinMode(5,INPUT); // Mode pin (not used)
  pinMode(11,OUTPUT); // Simulator Output pin (not used)
  pinMode(MUX_PIN,OUTPUT);  //MUX pin, applies only to modified Hardware !
  pinMode(BLUE_LED,OUTPUT); // LOCK LED pin in ardupilot board, indicates valid GPS data
  pinMode(YELLOW_LED,OUTPUT);// Status LED, blinks, when valid satellite fix data is received
  pinMode(SERVO1_IN_PIN,INPUT); // Throttle input from RC Rx (only used for RC control)

pinMode(SERVO2_IN_PIN,INPUT); // Rudder input from RC Rx  (only used for RC control)

#ifdef RADIO_CONTROL
  init_RC_control();         // Initialize Radio control
#endif

  switch_to_ardupilot();     // default servo control by Ardupilot
}

void init_startup_parameters(void)
{
  //yeah a do-while loop, checks over and over again until we have valid GPS position and lat
is diferent from zero.
  //I re-verify the Lat because sometimes fails and sets home lat as zero. This way never goes
wrong..
  do
  {
    gps_parse_nmea(); //Reading and parsing GPS data
  }
  while(((fix_position < 0x01) || (lat == 0)));

  //Another verification
  gps_new_data_flag=0;

  do
  {
    gps_parse_nmea(); //Reading and parsing GPS data
  }
  while((gps_new_data_flag&0x01 != 0x01) & (gps_new_data_flag&0x02 != 0x02));
  rudder_control(); //I've put this here because i need to calculate the distance to the next
waypoint, otherwise it will start at waypoint 2.
}

// Variables used by the NMEA Parser
char buffer[90]; //Serial buffer to catch GPS data
/*GPS Pointers*/
char *token;
char *search = ",";
char *brkb, *pEnd;

/*************************************************************************
 * This functions parses the NMEA strings...
 * Pretty complex but never fails and works well with all GPS modules and baud speeds.. :-)
 * Just change the Serial.begin() value in the first tab for higher baud speeds
 *************************************************************************/

void gps_parse_nmea(void)
{
  const char head_rmc[]="GPRMC"; //GPS NMEA header to look for
  const char head_gga[]="GPGGA"; //GPS NMEA header to look for

  static byte unlock=1; //some kind of event flag
  static byte checksum=0; //the checksum generated
  static byte checksum_received=0; //Checksum received
  static byte counter=0; //general counter

  //Temporary variables for some tasks, specially used in the GPS parsing part
  unsigned long temp=0;
  unsigned long temp2=0;
  unsigned long temp3=0;


  while(Serial.available() > 0)
  {
    if(unlock==0)
    {
      buffer[0]=Serial.read();//puts a byte in the buffer

      if(buffer[0]=='$')//Verify if is the preamble $
      {
        unlock=1;
      }
    }
    /*************************************************/
    else
    {
      buffer[counter]=Serial.read();


      if(buffer[counter]==0x0A)//Looks for F
      {

        unlock=0;

        if (strncmp (buffer, head_rmc, 5) == 0)   // $GPRMC parsing starts here
        {

          /*Generating and parsing received checksum, */
          for(int x=0; x<100; x++)
          {
            if(buffer[x]=='*')

{
              checksum_received=strtol(&buffer[x+1],NULL,16);//Parsing received checksum...
              break;
            }
            else
            {
              checksum ^= buffer[x]; //XOR the received data...
            }
          }

          if(checksum_received == checksum)//Checking checksum
          {
            /* Token will point to the data between comma "'", returns the data in the order
received */
            /*THE GPRMC order is: UTC, UTC status, Lat, N/S indicator, Lon, E/W indicator,
speed, course, date, mode, checksum*/
            token = strtok_r(buffer, search, &brkb); //Contains the header GPRMC, not used

            token = strtok_r(NULL, search, &brkb); //UTC Time, not used
            time = atol (token);
            token = strtok_r(NULL, search, &brkb); //Valid UTC data? maybe not used...


            //Longitude in degrees, decimal minutes. (ej. 4750.1234 degrees decimal minutes =
47.835390 decimal degrees)
            //Where 47 are degrees and 50 the minutes and .1234 the decimals of the minutes.
            //To convert to decimal degrees, divide the minutes by 60 (including decimals),
            //Example: "50.1234/60=.835390", then add the degrees, ex: "47+.835390=47.835390"
decimal degrees
            token = strtok_r(NULL, search, &brkb); //Contains Latitude in degrees decimal
minutes...

            // Serial.println(token);

            //taking only degrees, and minutes without decimals,
            //strtol stop parsing till reach the decimal point "."  result example 4750,
eliminates .1234
            temp = strtol (token, &pEnd, 10);

            //takes only the decimals of the minutes
            //result example 1234.
            temp2 = strtol (pEnd + 1, NULL, 10);

            //joining degrees, minutes, and the decimals of minute, now without the point...
            //Before was 4750.1234, now the result example is 47501234...
            temp3 = (temp * 10000) + (temp2);


            //modulo to leave only the decimal minutes, eliminating only the degrees..
            //Before was 47501234, the result example is 501234.
            temp3 = temp3 % 1000000;

//Dividing to obtain only the degrees, before was 4750

            //The result example is 47 (4750/100=47)
            temp /= 100;

            //Joining everything and converting to float variable...
            //First i convert the decimal minutes to degrees decimals stored in "temp3",
example: 501234/600000= .835390
            //Then i add the degrees stored in "temp" and add the result from the first step,
example 47+.835390=47.835390
            //The result is stored in "lat" variable...
            lat=temp + ( (float)temp3 / 600000 );


            token = strtok_r(NULL, search, &brkb); //lat, north or south?
            //If the char is equal to S (south), multiply the result by −1..
            if(*token == 'S')
            {
              lat = lat * −1;
            }

            //This the same procedure use in lat, but now for Lon....
            token = strtok_r(NULL, search, &brkb);

            // Serial.println(token);

            temp = strtol (token, &pEnd, 10);
            temp2 = strtol (pEnd + 1, NULL, 10);
            temp3 = (temp * 10000) + (temp2);
            temp3 = temp3 % 1000000;
            temp /= 100;
            lon=temp + ((float)temp3 / 600000);

            token = strtok_r(NULL, search, &brkb); //lon, east or west?
            if(*token == 'W')
            {
              lon=lon * −1;
            }

            token = strtok_r(NULL, search, &brkb); //Speed overground?
            ground_speed = atof(token);

            token = strtok_r(NULL, search, &brkb); //Course?
            course= atoi(token);

            gps_new_data_flag |= 0x01; //Update the flag to indicate the new data has arrived.

            jumplock_wp=0x00;//clearing waypoint lock..

          }
          checksum=0;
        } //End of the GPRMC parsing

if (strncmp (buffer,head_gga,5) == 0)  // $GPGGA parsing starts here
        {
          /*Generating and parsing received checksum, */
          for(int x=0; x<100; x++)
          {
            if(buffer[x] == '*')
            {
              checksum_received = strtol(&buffer[x+1], NULL, 16);//Parsing received
checksum...
              break;
            }
            else
            {
              checksum ^= buffer[x]; //XOR the received data...
            }
          }

          if(checksum_received == checksum)//Checking checksum
          {
            token = strtok_r(buffer, search, &brkb);//GPGGA header, not used anymore
            token = strtok_r(NULL, search, &brkb);//UTC, not used!!
            token = strtok_r(NULL, search, &brkb);//lat, not used!!
            token = strtok_r(NULL, search, &brkb);//north/south, nope...
            token = strtok_r(NULL, search, &brkb);//lon, not used!!
            token = strtok_r(NULL, search, &brkb);//wets/east, nope
            token = strtok_r(NULL, search, &brkb);//Position fix, used!!
            fix_position = atoi(token);
            token = strtok_r(NULL, search, &brkb); //sats in use!! Nein...
            token = strtok_r(NULL, search, &brkb);//HDOP, not needed
            token = strtok_r(NULL, search, &brkb);//ALTITUDE, is the only meaning of this
string.. in meters of course.
            alt = atoi(token);
            if(alt < 0)
            {
              alt = 0;
            }

            if(fix_position >= 0x01)
              digitalWrite(BLUE_LED,HIGH); //Status LED...
            else
             digitalWrite(BLUE_LED,LOW);

            gps_new_data_flag |= 0x02; //Update the flag to indicate the new data has arrived.
          }
          checksum=0; //Restarting the checksum
        } // end of $GPGGA parsing

        for(int a=0; a<=counter; a++)//restarting the buffer
        {
          buffer[a]=0;
        }

counter=0; //Restarting the counter
      }
      else
      {
        counter++; //Incrementing counter
      }
    }
  }

}
/*************************************************************************
 * //Function to calculate the course between two waypoints
 * //I'm using the real formulas--no lookup table fakes!
 *************************************************************************/
int get_gps_course(float flat1, float flon1, float flat2, float flon2)
{
  float calc;
  float bear_calc;

  float x = 69.1 * (flat2 - flat1);
  float y = 69.1 * (flon2 - flon1) * cos(flat1/57.3);

  calc=atan2(y,x);

  bear_calc= degrees(calc);

  if(bear_calc<=1){
    bear_calc=360+bear_calc;
  }
  return bear_calc;
}


/*************************************************************************
 * //Function to calculate the distance between two waypoints
 * //I'm using the real formulas
 *************************************************************************/
unsigned int get_gps_dist(float flat1, float flon1, float flat2, float flon2)
{

    float x = 69.1 * (flat2 - flat1);
    float y = 69.1 * (flon2 - flon1) * cos(flat1/57.3);

    return (float)sqrt((float)(x*x) + (float)(y*y))*1609.344;
}

/***************************************************************************/
//Computes heading the error, and choose the shortest way to reach the desired heading
/***************************************************************************/
int compass_error(int PID_set_Point, int PID_current_Point)
{
   float PID_error=0;//Temporary variable

if(fabs(PID_set_Point-PID_current_Point) > 180)
    {
               if(PID_set_Point-PID_current_Point < −180)
               {
                 PID_error=(PID_set_Point+360)-PID_current_Point;
               }
               else
               {
                 PID_error=(PID_set_Point-360)-PID_current_Point;
               }
    }
    else
    {
      PID_error=PID_set_Point-PID_current_Point;
    }

    return PID_error;
}

// This function stops all activity and will never return
// This is the end...
void finish_mission(void)
{
  bldc_stop_throttle();

#ifdef RADIO_CONTROL
   switch_to_radio(); // Give control back to Radio
#endif

  while (1)     // loop forever, if timeout reached (and start to swim and recover the boat)
  {
    digitalWrite(YELLOW_LED,LOW); // Fast flashing Yellow LED to indicate arrival
    delay(100);
    digitalWrite(YELLOW_LED,HIGH);
    delay(100);
   }
}


/*************************************************************************
 * rudder Control, reads gps info, calculates navigation, executes PID and sends values to the
servo..
 *************************************************************************/
void rudder_control(void)
{

  wp_bearing=get_gps_course(lat, lon, wps[current_wp].lat, wps[current_wp].lon);//Calculating
Bearing, this function is located in the GPS_Navigation tab..

  wp_distance = get_gps_dist(lat, lon, wps[current_wp].lat, wps[current_wp].lon);
//Calculating Distance, this function is located in the GPS_Navigation tab..

rudder_setpoint = MIDDLE_RUDDER+PID_heading(compass_error(wp_bearing, course)); //Central
Position + PID(compass_error(desired course, current course)).

  pulse_servo_rudder((long)rudder_setpoint);  //Sending values to servo, 90 degrees is central
position.

}



// This function switches the EM406 into 9600 Baud
// Normally, the EM406 defaults to NMEA and 4800 Baud after long power-OFF times

void gps_init_baudrate(void)
{
    Serial.begin(4800); // Always try in 4800 Baud first.
    delay(100);
    Serial.println("$PSRF100,1,9600,8,1,0*0D"); //  command to switch SIRFIII to NMEA, 9600,
8, N, 1
    delay(100);
    Serial.begin(9600);  // switch finally back to 9600 Baud
}

//PID loop variables
int heading_previous_error;
float heading_I = 0.0;             //Stores the result of the integrator

/****************************************************************************************
 * PID= P+I+D This function only works, when GPS with one second update is used.
 ***************************************************************/
int PID_heading(int PID_error)
{
  static float heading_D; //Stores the result of the derivator
  static float heading_output; //Stores the result of the PID loop

dbg_pid_error = PID_error; // deBug

  heading_I += (float)PID_error;

  heading_I = constrain(heading_I, -INTEGRATOR_LIMIT, INTEGRATOR_LIMIT); //Limit the PID
integrator...

  //Derivation part
  heading_D = ((float)PID_error - (float)heading_previous_error);

  heading_output = 0.0;//Clearing the variable.

  heading_output =  (KP_HEADING * (float)PID_error);  //Proportional part, is just the KP
constant * error.. and adding to the output
  pid_p =  (KP_HEADING * (float)PID_error);

  heading_output += (KI_HEADING * heading_I);  //Adding integrator result...
  pid_i = (KI_HEADING * heading_I);

  heading_output += (KD_HEADING * heading_D);// /Adding derivator result....
  pid_d = (KD_HEADING * heading_D);


  //Adds all the PID results and limit the output...
  heading_output = constrain(heading_output, (float)HEADING_MIN,
(float)HEADING_MAX);//limiting the output....

  heading_previous_error = PID_error;//Saving the actual error to use it later (in derivating
part)...

  //Now checking if the user have selected normal or reverse mode (servo)...
  if(REVERSE_RUDDER == 1)
  {
    return (int)(−1 * heading_output);
  }
  else
  {
    return (int)(heading_output);
  }
}

/*************************************************************************
 * Reset all the PIDs
 *************************************************************************/
void reset_PIDs(void)
{
  heading_previous_error = 0.0;
  heading_I = 0.0;
}

/**************************************************************
* Configuring the PWM hadware... If you want to understand this,
*  you must read the Data Sheet of atmega168..
* The following functionsare optimized for speed. The Arduino Servo library
* may not work, because it consumes more processing time than this ones
***************************************************************/

void Init_servo(void)//This part will configure the PWM to control the servo 100% by hardware,
and not waste CPU time..
{
  digitalWrite(RUDDER,LOW);//Defining servo output pins
  pinMode(RUDDER,OUTPUT);
  digitalWrite(THROTTLE,LOW);
  pinMode(THROTTLE,OUTPUT);

  /*Timer 1 settings for fast PWM*/
  //Note: these strange strings that follow, like OCRI1A, are actually predefined Atmega168
registers.
  // We load the registers and the chip does the rest.

    //Remember the registers not declared here remain zero by default...
  TCCR1A =((1<<WGM11)|(1<<COM1B1)|(1<<COM1A1)); //Please read page 131 of DataSheet, we are
changing the registers settings of WGM11,COM1B1,COM1A1 to 1 thats all...
  TCCR1B = (1<<WGM13)|(1<<WGM12)|(1<<CS11); //Prescaler set to 8, that give us a resolution of
2us, read page 134 of data sheet
  OCR1A = 2000; //the period of servo 1, remember 2us resolution, 2000/2 = 1000us the pulse
period of the servo...
  OCR1B = 3000; //the period of servo 2, 3000/2=1500 us, more or less is the central
position...
  ICR1 = 40000; //50hz freq...Datasheet says  (system_freq/prescaler)/target frequency. So
(16000000hz/8)/50hz=40000,
  //must be 50hz because is the servo standard (every 20 ms, and 1hz = 1sec) 1000ms/20ms=50hz,
elementary school stuff...
}

/**************************************************************
 * Function to pulse the throttle servo
 ***************************************************************/
void pulse_servo_throttle(long angle)//Will convert the angle to the equivalent servo
position...
{
  //angle=constrain(angle,180,0);

OCR1A = ((angle * (MAX16_THROTTLE - MIN16_THROTTLE)) / 180L + MIN16_THROTTLE) * 2L;
}

/**************************************************************
 * Function to pulse the yaw/rudder servo...
 ***************************************************************/
void pulse_servo_rudder(long angle) // converts the angle to the equivalent servo position...
{
OCR1B = ((angle  *(MAX16_RUDDER - MIN16_RUDDER)) / 180L + MIN16_RUDDER) * 2L;
}


void bldc_arm_throttle(void) // "arm" the BLDC controller for the throttle
{
  delay(2000);
  bldc_stop_throttle();  // then switch to approx. zero, Servo controller armed
  delay(4000);
}


void bldc_start_throttle(void)  // brushless Motor (Multiplex controller)
{
  pulse_servo_throttle(MOTOR_SPEED); // set Motor speed
}

// function to stop the Motor   // brushless Motor (Multiplex controller)
void bldc_stop_throttle(void)
{
  pulse_servo_throttle(MOTOR_OFF);  // switch to approx. zero
}

void test_rudder(void)
{
  pulse_servo_rudder(MIDDLE_RUDDER + HEADING_MIN);
  delay(1500);
  pulse_servo_rudder(MIDDLE_RUDDER + HEADING_MAX);
  delay(1500);
  pulse_servo_rudder(MIDDLE_RUDDER);
  delay(1500);
}


// Module to control the ArduPilot via Radio Control (RC)
// You have to use an RC equipment, that supports a failsafe functionality
// e.g. if the Transmitter is switched OFF, on the receiver channel there should be
// "silence" (either HIGH or LOW level)
// I actually have tested this with a 2.4GHZ SPEKTRUM System.
// Analog Systems may always output some pulses due to erroneous received signals
// My cheap 27MHz Radio control did not work
// Please check thoroughly, before you make you first start!

// Function to Check, if there are pulses on the Rx rudder Input

// I took the rudder channel, because on the SPEKTRUM, the failsafe function
// outputs pulses on the throttle channel (default speed), when the Transmitter is OFF.
// This function checks for "silence" on the rudder channel.
// If there is silence, the Transmitter is switched OFF and the control should be given to
// the ArduPilot




// Return 0 if no pulse available (timeout > 25ms)
int check_radio(void)
{
  return (int) pulseIn(SERVO2_IN_PIN, HIGH, 25000); // Check, if there are pulses on the Rx
rudder Input;
}


// Function to switch the Multiplexer to the ArduPilot
void switch_to_ardupilot (void)
{
  digitalWrite(MUX_PIN,HIGH);  //  servos controlled by Ardupilot
}

// Function to switch the Multiplexer to the RC Receiver
void switch_to_radio (void)
{
  digitalWrite(MUX_PIN,LOW);  //  servos controlled by Radio control
}

To load the software to the ArduPilot board, you will need the following:

After you have all the prerequisites ready, you can perform the following procedures:

Installing the Arduino IDE

Prior to starting the Arduino IDE, you have to install the drivers for the USB to serial converter and then you have to tell Arduino which serial port it shall use to communicate with the board. The procedure for that is described in depth for the various operating systems on the "getting started" part of the Arduino site: http://arduino.cc/en/Guide/HomePage.

After double-clicking the AP_RoboBoat.pde file, the Arduino IDE should start up and you should see a screen that looks like Figure 9-39.

Figure 9.39. Screenshot of the Arduino IDE

Configuring the Arduino IDE

After having successfully installed the Arduino IDE, you have to tell Arduino which type of board you are using. The ArduPilot uses a ATmega328 microprocessor on it, and the board comes close to the "Arduino Duemillanove Board." Please select Arduino Duemilanove w/ATmega328 in the Arduino IDE Tools menu, as shown in Figure 9-40.

Figure 9.40. Selecting the hardware

Compiling and Uploading the Code

Now you should be ready to upload the code to the board. If you have already loaded the AP_RoboBoat into the Arduino IDE, you simply have to press the upload button and the IDE will begin to compile the source code and start the upload automatically (Figure 9-41). You can see this on the fast flashing red and green LEDs on the USB to serial converter (Figure 9-42).

Figure 9.41. The upload button in the Arduino IDE

Figure 9.42. Connecting the ArduPilot with the programming adapter

If the upload was OK, you are ready to do the first tests with the boat, which are described in the "Integrating the System" section.

#define REVERSE_RUDDER 1 // normal = 0 and reverse = 1

#define MIDDLE_RUDDER 90  // central position of rudder servo in degrees, adjust for trim•
 corrections if necessary

#define KP_HEADING 2.0    // proportional part of PID control
#define KI_HEADING 0.07   // integrator part of PID control
#define KD_HEADING 0.00001 // derivator part of PID control (not used)

#define MOTOR_SPEED 80  // around 5A with Roxxy Outrunner

#define WP_TIMEOUT 15 // Waypoint Timeout counter value in seconds

#define WP_RADIUS 15  // Radius for waypoint-hit in m

#define   HEADING_MAX 60  // Servo max position in degrees
#define   HEADING_MIN −60 // Servo min position in degrees

So far so good, but how do we tell the autopilot where to go?

The mission of the boat can be seen as a list of waypoints the boat tries to reach. A waypoint is represented in a WGS84 latitude/longitude format, which is common to most GPS receivers and geographical information systems like Google Earth. The latitude and longitude values are expressed in degrees. The latitude starts at the equator, goes up north to +90° at the north pole, and goes down south to the south pole to −90°. The longitude starts with 0° at Greenwich (which is a small town in the vicinity of London, England, where the royal observatory is placed), goes east with positive values up to +180°, and goes west with negative values to −180°. Usually, for navigation, the coordinates are expressed in degrees, minutes, and seconds. What we will use in the software is a floating point format, where the coordinates are represented in decimal degrees, which makes it easier to calculate with.

The waypoint coordinates are stored in a constant array that can be found in the waypoints.h file, which is part of the ArduPilot code. To plan a new mission, you have to simply copy the new waypoint coordinates to that array, recompile the code, and download it to the board.

Here is an example (found in the file waypoints.h) with three waypoints that represent a triangular course in a lake in southern Germany.

LONLAT wps[] =
{
10.021409,  48.350234,
10.020944,  48.350475,
10.021905,  48.350598  /* Home*/
};

In this example, the first value (10.021409) is the longitude of the first waypoint, the second value (48.350234) is the latitude of the first waypoint, the third value (10.020944) is the longitude of the second waypoint, and so on.

The last waypoint should be chosen very close to the shoreline of the lake. After reaching this waypoint, the software of the autopilot switches the motor off, and the boat will (hopefully) glide the last meters to the shoreline without propulsion.

After the startup of the code, the waypoints are copied into the RAM of the microcontroller. The ATmega328 has only 2KB of RAM, so the amount of waypoints that can be stored is limited. The two float values of one waypoint consume 8 bytes of RAM. I suggest not using more than 100 waypoints for a single mission (which is a lot).

Employing Google Earth for the Coordinates

There are many ways to get the coordinates of the mission. The one that I actually prefer is Google Earth. The use of this program is free; it runs on PC, Mac, and LINUX platforms, and the accuracy of the satellite images is usually in the range of a few meters. The program can be downloaded from www.google.com/earth.

To plan a mission with Google Earth, you simply have to create a path. This is done by clicking the path icon on the command bar (Figure 9-43). You can then add waypoints to the path by simply clicking the places you want to go (Figure 9-44).

Figure 9.43. Create path button in Google Earth

Figure 9.44. A sample mission

If you have finished, give the path a name and store it as a .kml file. This is done by right-clicking the name of the created path on the side navigation bar of Google Earth and selecting "save location as". It is important to choose .kml as the file format, because this format is based on the XML language and can be easily edited with a text editor.

Next, you have to open the .kml file with a text editor of your choice. A typical .kml file will look like Figure 9-45.

Figure 9.45. Inside a .kml file

The only thing that we need is the coordinates that are placed between the <coordinates> and the </coordinates> tags. Copy those coordinates and paste them into a new file. The coordinates are in the format longitude, latitude, altitude. The altitude is usually 0 and that value must be deleted. Format the values so that the lon/lat pairs are each in one line.

If you have finished your editing, the file should look like this:

10.02109518987307,48.35076100306986,
10.02003617743083,48.35030483570462,
10.02033731414647,48.34998321856332,
10.02158407280307,48.35026252663885

Google Earth creates a lot of positions after the decimal point. Arduino uses only five to six, but this is of no concern, because the compiler will format it to the appropriate floating point representation.

After you have finished the editing, you have to copy and paste it into the array that is defined in the waypoints.h tab.

Your result should then look like this:

LONLAT wps[] =
{
10.02109518987307,48.35076100306986,
10.02003617743083,48.35030483570462,
10.02033731414647,48.34998321856332,
10.02158407280307,48.35026252663885
};

After that step, you must recompile the code and upload it to the board—you only have to press the upload button, as already described earlier.

If all of the foregoing steps have been done, you can start the integration of all components, which will be described in the next chapter.

Now let's walk through the integration step by step:

Now, it's time to put the boat into the water. There is always a thrill when doing this for the first time. To avoid unwanted side effects, here are some hints that may be helpful:

This can have more than one reason. First check if the propeller is mounted the right way. If you are using a normal (non-reversed) one, the side with the markings of the propeller should point toward the motor's body (to the front of the boat). The motor should turn clockwise if viewed from behind, as shown in Figure 9-48.

Figure 9.48. The turning direction of the propeller

Maybe the setting for the motorspeed is too low for your ESC/motor combination. Increase the value of the #define MOTOR_SPEED directive in the file defines.h.

Each ESC is different. And each of them has a microcontroller with software on it. Most of them are programmable to adapt them to the needs of the user. Most of them have a failsafe function to avoid an inadvertent start of the motor.

I have added some code on the web site to check what is wrong. Usually, it has to do with the failsafe behavior of your ESC. First read the manual to see how it is implemented. Usually it works this way: put the throttle to a middle value and wait some seconds. Then put the throttle to a minimum value for some seconds—this will "arm" the ESC. You may hear some beeping code coming out of the motor windings. Then put the throttle to the desired value. If you have a remote control with a transmitter and receiver, connect the receiver to the ESC and test the settings with the transmitter. The functions that control the throttle can be found in the Servo_Control.pde tab of the software. Have a look at them and adjust the values to your needs.

Note that on the actual software, the motor starts only after the GPS has a valid fix.