This paper introduces the design of an open source autonomous sailing robot with emphasis on its accessibility, generality and extendability. To meet such requirements, a generic control box connecting an Arduino board and a Raspberry Pi computer was tailor-made so as to host the robot operating system (ROS) and to interact with versatile sensors and actuators. The goal of such a project is to create an accessible, generic and expendable platform of autonomous sailboats for wider education and research publicity and engagement. Autonomous sailing test for the developed sailboat was also conducted to validate its design.
Over the last two decades, there are growing interests in developing autonomous sailing robots. Different groups
have already made fully autonomous sailboats, ready to deploy for data gathering purposes and almost able to
cross the transatlantic ocean in the Microtransat challenge
An autonomous sailboat is interesting in that it can use all available energy around it to complete its mission
i.e. wind, solar and wave energy
Most projects of autonomous sailboats are open source. While most of them explain the hardware specifications and some explain the software designs, it is still hard for a researcher to make their own sailboat in a short amount of time and to focus on control algorithms or applications. This asks for an accessible hardware, already available in most research labs and more importantly a friendly software architecture which makes it straightforward for any user to test control algorithms.
In the same way 3D printers are designed, fully open-sourced and with accessible hardware, a control box was made for highly generic hardware and software structures. That way, the control box can be put in any RC (Radio-Controlled) sailboat hull, connect to sensors and servo-motors and transform it into an autonomous sailboat. The software architecture has to be flexible so that in couples of lines of code, the sailboat can respond and act according to the instructions. So this paper will address the development of an accessible, generic and expendable autonomous sailboat with particular emphasis on the aspect of control hardware and software, which is in the format of a control box. 2
The hardware architecture is similar to other sailboats. To stay low on budget and to use reliable resources,
most projects use Arduino boards and Raspberry Pis, which can be easily accessed by most robotics laboratories
Along with the technology development, the price for Arduino boards and Raspberry Pis will continue to decrease while their performance will continue to improve, which makes such a hardware architecture more attractive in the long term. The control box was designed to comply with as many standards as possible. While the boards presented here comply with our configurations, changes can be made to accept other configuration of power necessities. The sailboats are powered with a 2S (Two cells) LiPo battery which outputs a maximum of 8.4V (4.2V per cells) and nominal at 7.4V (3.7V per cells). We set our requirements to at least two hours of continuous operation without any other energy input such as solar panels. From all the sensors and actuators the sailboats have, we are at about 2A usage at full use. This means we must have at least a 4000mAh battery. Of course, this also depends on other factors such as the boat size, weight and usage. For standardization, it is considered that 3S (maximum 12.6V) or even 4S (maximum 16.8V) batteries can be used.
Particular sensors or actuators are not discussed in this paper. But based on RC models of sailboats and expertise of users, a standard as generic as possible was designed. As such, a 3 pin connector was considered for small servomotors connection. Other connectors were chosen arbitrarily for robustness while keeping standard pin configurations. Those configurations are to be discussed further. For a sailboat to be autonomous, it needs at least a way to know its position, heading and wind direction. We will use a GPS, IMU and a wind direction sensor in our examples. This control box is designed to be able to connect with other sensors. Concerning actuators, it has to control the sail and the rudder. 2.2
While the platforms chosen are accessible, they are development platforms and are unfit for industrial applications. Pin headers are the connectors in both boards. They are not suitable for robust and waterproof connections. To solve this problem, a custom board is made to have better industry-grade connectors. This custom board decreases the accessibility for researchers but it highly improves the robustness of the control box. Making such a board can hinder the accessibility with some laboratories which do not have the facilities to make such a PCB board. We suggest the use of third-parties industries, accessible to anybody, to make those boards.
This custom board is connected to the Arduino and the Raspberry Pi. It manages the power and extracts all
connectors from the Arduino to sensors and actuators. It is also designed to contain all the boards in a small
sized box and be mechanically robust. The following sections will describe in detail the choices in the different
parts of the boards. All the details and documents for DIY can be found in the Meca Repository of
The power management is simple and efficient. The unit manages the energy supply for sensors, actuators and the Raspberry Pi. It is simply made of regulators for each group of loads. We use switching regulators because of its high efficiency. These regulators can input a large range of voltage (6.5-32V) and output a constant voltage (5V). They are used for the actuators and the Raspberry Pi. One linear regulator can manage the power supply to multiple sensors because of the low energy consumption of sensors. While these regulators were chosen based on our configuration, the footprints on the custom boards are standard, making it possible to solder any regulators.
Heat and energy is a problem for underwater and surface vehicle. Using linear regulators or regulators with low efficiency can hinder the boat capacity. Switching regulators are used with efficiency up to 96% to lower the heat generated. The Raspberry Pi is the biggest consumer of energy. In a linear regulator, the ballast lowers the energy by outputting heat. This would end up wasting (8.4V − 5V ) × 2A = 6.8W of energy while a switching regulator would waste only 5V × 2A × ( 0.196 − 1) = 0.42W (considering 96% efficiency) for the Raspberry Pi. 2.2.2
Connectors play a big part in robustness for robots. In mobile robots, vibration and movement can remove the cables from the pins. Robust, industry-grade connectors that are easy to plug in and out frequently was necessary for sensors. JST connectors were chosen purposely for the latter, based on usage experience and industry standards. Concerning the battery connections, two pin holes are placed on the custom board on which any wire connectors can be soldered. In our case, our battery had HXT 4mm connectors and as such HXT wire adapters were soldered, as shown in Figure 2. Finally, the custom boards also have a special compartment for radio receivers, for which a row of 3 pin holes is made available. Up to 6 channels are pluggable.
There are some standards in connection and communication protocols for most sensors and actuators. Most notable communication protocols range from Serial communication, I2C protocol to Analog signal and Digital interrupts. Each of these communications come with a standard wiring. Sensors have 2 wires for power - Ground and Power (5V) - and the rest for communication - RX, TX for Serial, SDA, SCL for I2C, or 1 pin for analog and digital signal. Of course, other protocols and wirings exist but those are the most common.
This custom board accepts all of those different connectors and communications and allows access to the corresponding Arduino pins with mechanical connectors. Once connected, the software part arranges the connection inside the system through a configuration file. 2.2.3
One of the challenges in sailboats is waterproofing all the electronic components. Several 3D printed boxes were
made for the sensors and the control box, all available online at the Meca repository of
The 3D printed case for the boards’ stack is a frame-like box which leaves open the connectors. While the
box is not fully waterproof, it is enough to protect the boards from the small amount of water coming inside
the boat. Batteries were chosen to be ROAR approved, meaning they are approved for racing. These batteries
are hard-cased and protected against high impact
Sailboats come in different formats, small or long, one or two rudders, winch motors for sails or direct actuation.
As the hardware can change among different sailboats, the software architecture should be able to adapt to
1Length Over All
those varying configurations. In a similar way with 3D printers that built upon the marlin firmware (Marlin,
), a configuration file is used to configure the customized hardware specifications. Not only does the hardware
configuration change but different brands and different protocols of sensors and actuators are used. This is
solved by using a component-based architecture, highly used in the video game industry and robotics
Concerning the Raspberry Pi, no configuration is needed. The focus is on the usability and interfaces for users to add their own controllers. ROS (Robot Operating System) has been increasingly used for robotics research and development (Cousins, 2011). Using ROS as the base of the software architecture, the project can benefit from existing work done by other researchers in robotics and be able to share its specific outcomes with the community as well. With ROS, a software architecture has been done for users to easily and rapidly integrate their controllers into the robot. 3.1
The Arduino is the low-level controller. It acquires all the data from different sensors and acts upon the actuators.
Once all the data is updated, it sends them to the main computer and also receives the instructions from it. The
code and the wiki for installation instructions can be found in Arduino Interface repository of
A Component-Based architecture is exploited to be as generic as possible with regards to the hardware. Such architecture fully uses the OOP (Oriented-Object Programming) aspect of C++, the language used for Arduino. The principle is based on the semantics of the architecture. We have a main class, the Sailboat, which contains component objects : Sensors, Actuators and Basic Controllers. Those components have their own methods to conduct certain tasks. Sensors have the common methods of acquiring data from sensors and sending them to the main computer. Actuators have the common method of acting upon the actuators to the desired set-point. Finally, Basic Controllers have the common methods of controlling, taking the data from sensors and acting upon the actuators. The implementation of those methods might differ among different products but the inputs and outputs are the same. Using OOP, you can derive from these components class and would only need to implement the methods. The Sailboat class would automatically call the right methods depending on the derived component class. This architecture makes it simple for any user, using a new sensor or actuator, to implement the methods and stay compatible with the sailboat hardware configuration.
The Basic Controllers are low-level controllers such as rudder control, sail control or heading control. This enables the main computer to send different inputs to the Arduino, depending on the controller, e.g. A Potential Field controller might output a heading while a Line Follower controller might directly act upon the rudder without adjusting the sail.
On top of those basic controllers are security controllers such as the RC controller and the Return Home controller. They will be discussed further in section 3.3 on safety.
Figure 3 shows a UML (Unified Modeling Language) of the different classes in the Arduino architecture. For
the optimal sail angle and the rudder angle, we are constructing our code on
The Raspberry Pi is the main computer in this architecture. It is loaded with a lightweight Ubuntu Operating
System. Its goal is to calculate the complex control algorithms using the data sent by the Arduino and act on
the actuators by commanding the Arduino. In both the Arduino and the Raspberry Pi, the architecture is made
so that any users will be able to focus on the algorithm and not the integration of it. The architecture also
uses the OOP. ROS is compatible with Python and C++ languages and the same architecture is used for both
languages. The code related to the Raspberry Pi can be found on ROS repository of
This architecture is different from the Arduino software architecture in that it focuses on usability and ergonomics for users. The goal of such an architecture is to free the user from integration problems and focus only on the important part of the research, which is the control of the sailboat.
For that reason, the architecture automatically takes over communication tasks with the Arduino, acquiring and parsing the data from it and making it available to the user. All the user needs to do is to implement two methods : a setup method to initialize all the variables and a control method where the algorithm has to be implemented, which sends the results to the Arduino.
The newest Raspberry Pis come with a WiFi chip. This enables WiFi communication with another computer without cables. When it boots up, it creates a hotspot, it is then possible to connect to it, SSH (Secure Shell) into the Raspberry Pi and controls it directly from a laptop.
ROS is used for multiple reasons. It is first highly used by the robotics community around the world and some users might consider it standard. It also helps in making robust protocol communication with the Arduino and among different components of the sailboat. Finally, it already has various libraries/applications (called nodes in ROS) used in robotics. For the latter to work, a certain standard had to be met while working on the architecture to make it compatible with most nodes, particularly on the message structures of each sensor.
All the topics concerning the sensors are published by the Arduino. The Raspberry Pi only launches a node to connect to the Arduino and the controller node. The controller node then sends commands to the Arduino through the /sailboat/sailboat cmd and /sailboat/sailboat msg topics at a regular frequency, chosen by the user. 3.3
Multiple security measures are incorporated in the Arduino and Raspberry Pi architectures. For that purpose, watchdogs are both implemented inside the Arduino and the Raspberry Pi.
To be sure that the Raspberry Pi is still on or is not freezing, it sends a message every 30 seconds to the Arduino. If the latter does not receive anything for 5 minutes, it will consider the Raspberry Pi to be malfunctioned. Such safety measures have been implemented automatically in the software architecture and the user does not need to write any further code for them.
The Arduino itself have securities in case of blockage. With a watchdog, the Arduino will set itself in a safe mode if nothing is happening. A watchdog is present in most microcontrollers. This feature is present in the Arduino and acts as a hardware timer that has to be reset frequently. If the timer goes over a certain amount, it will restart the microcontroller. This timer is independent of the software and will run whether the software is blocked or not.
When a watchdog is triggered i.e. when the Raspberry Pi is not responding or the Arduino is blocked, the lowest-level controller, the Arduino, will set itself into Return Home control where it will come back to the point where it was turned on.
Another emergency trigger is the Radio Controller. If the radio controller is turned on, it takes control over the autonomous mode and ignores the Raspberry Pi commands. Two modes have been incorporated. One manual where both the sail and the rudder has to be controlled using the RC transmitter. Another semi-automatic where the sail uses an optimal sail angle based on the wind sensor, the user just needs to control the rudder. 4
The main objective of this work is to create an accessible, generic and expandable platform for autonomous sailboat development. Everything detailed here is available online at https://github.com/Plymouth-Sailboat. We use the Github platform to share publicly all the work, including the electronic circuits and the source code. A lot of efforts were taken to write a detailed guide for new users to integrate this control box into their sailboat so as to develop their own controllers. This open-source work will always be maintained, updated and upgraded along the researches and any feedback to be received. This will give other laboratories the opportunity to build their own sailboats at a low cost and a reduced effort. 5
We tested this control box on two sailboats : A 1m mono-hull sailboat and a 2m mono-hull sailboat as shown in Figure 5. Actuators and sensors were bought and installed along the control box inside empty sailboat hulls. Two tests were done, first in a lake near the University of Plymouth, then a second test was performed on the west coasts of France. Each of these sailboats uses the same GPS and AHRS sensors but the wind sensors are different. The small boat has only a wind direction sensor, while the other has also an anemometer. The actuators on each boat are different. Two different configuration files were created for those boats but the same code was running on both the Arduino and the Raspberry Pi on each boat. This involved changing only one file called the config-Sailboat.h which contains all the different parameters of the hardware such as : minimum and maximum actuator angles, minimum and maximum values sent by the different sensors, numbers of sensors and actuators, etc...
A couple of well-known algorithms were tested. On the Arduino side, as stated above, only low-level controllers were used. One which takes the rudder and sail command directly from the Raspberry Pi, and another one receiving the cap and applying an optimal sail angle and an appropriate angle for the rudder. When receiving the cap, for the sail angle δs and the rudder angle δr we have : δs = π 2 cos(ψ) + 1
2 (δr = rmax sin(θ − θ¯), δr = rmaxsign(sin(θ − θ¯)), else
¯
cos(θ − θ) ≥ 0
with ψ being the wind coming from the wind sensor (in the boat referential), rmax being the maximum rudder
angle, θ the boat heading and θ¯ the cap. We consider the sail maximum angle of π2 . A tack strategy is also
applied in case of upwind navigation, similar to the one in
On the Raspbbery Pi side, a potential field method based on
We have demonstrated the development and the test of an open source autonomous sailing robot with emphasis on its accessibility, generality and extendability. The hardware architecture is designed to accept most common sensors and communication protocols. It is made of accessible and economic products and a customized PCB board. The software architecture is designed to comply with the hardware by being generic and extensible. The goal is to create a platform of autonomous sailing robots for generic education and research purpose. This platform can also be beneficial for other relevant researches. Future work will focus on making the whole system more robust, economic and smaller while maintaining the same level of accessibility. It will also be tested on other formats of sailing robots such as catamarans and trimarans. The research will be shared along the work progresses and more control algorithms for various autonomous missions such as area scanning and obstacle avoidance will be implemented on it in the future work. 6.0.1
This work was supported by the Engineering and Physical Sciences Research Council (EPSRC) of the U.K. under Grant EP/R005532/1.
We would also like to thank Professor Luc Jaulin from Ensta-Bretagne, France for providing testing facilities for us to test the developed sailboats in Brest. Alvira, M. et al. (2013). Small and inexpensive single-board computer for autonomous sailboat control. Benchoff, B. (2016). Pi 3 benchmarks: The marketing hype is true. https://goo.gl/Nx7df2. Accessed: 01/06/2018.
Cabrera-G´amez, J. et al. (2013). An embedded low-power control system for autonomous sailboats. In Robotic
Sailing.
Cousins, S. (2011). Exponential growth of ros [ros topics]. Robotics & Automation Magazine, IEEE. Cruz, N. A. and Alves, J. C. (2008). Autonomous sailboats: An emerging technology for ocean sampling and surveillance. In OCEANS. Dom´ınguez-Brito, A. C. et al. (2015). A-tirma g2: An oceanic autonomous sailboat. In Robotic Sailing.