Team BadgerBOAT: TAYLOR WADDELL, Jake Rymsza

Created January 16, 2020 © MIT

Badger BOAT( Buoyancy Operated Autonomous Vehicle)

A completely autonomous dual motor solar powered electric boat for extreme distance travel and environmental monitoring.

IntermediateFull instructions providedOver 1 day60

Badger BOAT( Buoyancy Operated Autonomous Vehicle)

Things used in this project

Hardware components

NVIDIA Jetson Nano Developer Kit

Arduino Nano R3

Netgear nighthawk router

Victor SPX Motor Controller

12V 36lb Newport Trolling Motor

Garmin GPS 18x OEM

SICK Lidar TiM781

ExpandaCraft Hulls

12V Valence Batteries

KNACRO DC 12V to 5V 3A

Software apps and online services

MOOS IVP

NVIDIA Jetpack

Story

An issue in our community:

Each summer, the Yahara waterways of Wisconsin turn bright green, foamy, and foul smelling from algal blooms. Run-off from nearby farms wash fertilizers and animal waste into the lake, which feed algae and cyanobacteria. This influx of a limiting nutrient is called eutrophication. Harmful algal blooms, or HABs, have widespread effects on the ecosystem and people’s interaction with the water. They starve the water of oxygen and can produce deadly cyanotoxins when they decay. In slow-moving water, oxygen dissolves from the atmosphere easily and the algae bloom undisturbed. The algae effectively create a dead zone because they block light from the aquatic plants and suffocate fish from the lack of dissolved oxygen. The University of Wisconsin, Madison Limnology Department advises people and pets to stay out of the water when it looks green as a matter of public safety.

The United States Geological Survey is a scientific agency that monitors waterways in Wisconsin and updates a website with temperatures and toxicity levels. The website run by the USGS is called INFOSyahara and has webcams at the major dams and outlets in the Yahara waterways. Members of the Madison community can access this data to see which areas are safe and usable. The Limnology Department also measures water quality at the Hessler Lab and and at a buoy in the center of Lake Mendota, where data is used to study the lake’s ecology.

In the summer, Mendota and all the Yahara lakes suffer from these algal blooms that make the water unsafe to swim in, kill fish, and further heat up the lake. When the blue-green algae die, they produce a toxin called microcystin, which is a neurotoxin that can be harmful, or even fatal. The World Health Organization’s “safe level” standard is 1 microgram per liter.

Autonomy to the rescue!

WWhy autonomy in the first place? Firstly, it is an amazing technology that helps push our team to creative limits. Autonomy is being used in all forms of transportation, and we wanted to take our go at it. Additionally, it is a perfect solution for this problem. This led us to starting our autonomous boat project, better known as the Badger Buoyancy Operated Autonomous Transport or BadgerB.O.A.T (We like our acronyms).

The BadgerBOAT will be an invaluable tool for studying the waterways. The lightweight boat can navigate shallow waters that would be inaccessible to manned boats and difficult to access by land. The vessel also saves unpleasant man-hours spent studying foul waters with dead animals or sewage treatment plant ponds. The data collected can be used directly by scientists in the Hessler Lab, or be an asset to the INFOSyahara website as an extra webcam sent to at risk areas. As of right now, the Wisconsin Limnology Department issues warnings based on the color or the water, not evidence of the toxins. Our system would allow them to collect better data and issue more accurate warnings.

Perfect for the Jetson Nano!

For the brains of our system we choose to use a Jetson Nano. We chose the Nano due to its easy to use operating system the Jetpack SDK and the well documented libraries that exist for it. The Nano also has all of the ports and data pins that we need for connecting it to the rest of our system. The Jetson takes data from the GPS system via USB connection. It also takes in data from an onboard router that we used to directly communicate to the Jetson when needed. Motor controls are then output through a USB port to an Arduino Nano. The Arduino then reads the given directions and converts it into a proper PWM signal for our motor controllers. The reason for using these two boards is simple, the Jetson makes all the decisions on how to control the board as it is optimized for processes of automation. The data is then sent to the Arduino as it runs on a constant cycle and can be trusted to send out PWM commands via analog output without any distortion. In this way the Jetson is serving as the systems brain and the Arduino serves as a muscle.

Our Jetson Nano integrated with the rest of our control hardware.

Our hardware brain needs a software brain:

The Jetson Nano is running our code through a program called MOOS IvP. MOOS was written by Paul Newman in 2001 to support operation with autonomous marine vehicles in the MIT Ocean Engineering department https://oceanai.mit.edu/moos-ivp-pdf/moosivp-helm.pdf It has then been constantly updated by various institutions including MIT, Oxford and the NOAA. MOOS stands for “Mission Oriented Operating Suite” and its primary purpose is to build highly capable autonomous systems. It is based on three main principles; publish and subscribe autonomy middleware, which means that there are various applications that will publish and subscribe to various data streams. Backseat driver paradigm, which means that vehicle autonomy is seperate from vehicle control. It’s last principle being the behavior based autonomy. We fully customized the software and created several drivers ourselves to fit our mission needs. The robot can be programmed along a specific path and using its various control parameters it will safely and efficiently navigate it.

Our MOOS IvP Parent-Child Node Diagram

Our MOOS IvP GUI

Testing gone wrong:

The BOAT nearly hitting our testing canoe

We began our first testing on December 7th. And almost immediately nothing went right, and the Wisconsin winter wasn’t helping. We brought the boat out to lake Mendota early in the morning. Temperatures were below freezing, but the sun was out and the wind was calm. We began preparing the boat for its maiden journey, but immediately ran into issues. Our path planning software was not getting anything correct. Its location was entirely off, its controls were absolutely wrong and we were unsure how much battery life we had left. Even though many of us spent countless nights preparing for this test we were not able to get everything working how we wanted. We were able to set the boat up with RC controls to test the basic maneuverability of the boat, but by the time the sun set and the chilly winds moved in we decided to call it a day. While valuable lessons were learned, the first test was sadly unsuccessful.

Engineering more:

After giving ourselves a much needed rest we furiously began dissecting all our bugs and errors, and consuming high amounts of caffeine, we set our next test for December 9th. Again we brought the system out to the lake, but this time we were greeted with even colder temperatures. We got the system working better, but even on the day of the test we were still engineering and fixing our errors, chances of a fully autonomous test run were looking slim.

Our team navigating constant issues that appeared during testing

SUCCESS:

Our BadgerBOAT navigating completely autonomously

After many hours out in the cold, we began to make some progress. We were able to fix an important bug in the code that was messing up our motor values, and we got the boat moving on the water. Throughout the day temperatures continued to drop; as the afternoon grew longer a slight drizzle started, making the conditions even less bearable. It was the last test of the day, we set several gps points in the lake and launched the boat into the water. As it rounded our first marker we knew things were finally working out. The boat was able to navigate its course and continuously account for a strong crosswind that gusted 10 mph! The GPS software measured a maximum speed of 3 m/s, or 5.8 knots. While the speed was short of 10 knot goal, the current motors could easily be substituted for stronger ones if a research purpose necessitates it. We had finally succeeded in our goal.

Future:

Now that we know the BaderBOAT can navigate the waterways with GPS, we are planning out a few upgrades. The first being the integration of an IMU to better tune the boats PID controller. We would love to upgrade the brains of our boat to a higher model Jetson so that we can incorporate all our changes and experiment with new features such as object recognition for water samples and environmental debris, however due to our small budget it may not be possible. We are also preparing a LiDAR sensor for integration that will allow the badger boat to truly understand its surroundings. The integration of GPS, LiDAR, and IMU data will lead to a smarter boat that is safer for everyone out in the water. Finally we are working on creating our algae detecting payload that will help out our community in reducing the algae threat. It will collect useful data, and reduce the amount of time humans need to spend in the dangerous conditions surrounding the algae. It doesn’t end there, the BadgerBOAT is meant to be an extremely customizable payload carrier and will eventually be able to go weeks at a time by itself. We believe we have just started to scratch the surface on what this boat can accomplish.

Creating your own Buoyancy Operated Autonomous Transport (BOAT):

Through our design and programming process we wanted to make everything we created modular and easily replaceable. As such to create your own BOAT you are only going to need several key components. The Jetson, an Arduino Nano, a GPSD compatible USB GPS, a wifi router, a 12v powersource, a 12v-5v converter, two motor controls, and two 12v motors for propulsion, and a boat. Most of these components are up to the builder on what brand or quality they want to purchase.

Next we will want to set up our circuit as seen in the following diagram:

Next we will need to download and install our Arduino software onto our Arduino board. The type does not matter as long as the pinouts are correct for your motor controllers.

Finally we will install our MOOS software by downloading our git package and following these MOOS installation guide: https://github.com/moos-tutorials/00-my-first-moos-project

The rest is then up to you! If you want to use the exact same materials and equipment we did or using something completely different, the implementation will be virtually the same.

May the winds be in your favor!

Schematics

Code

Motor Controller Arduino Software

#define INPUT_SIZE 30
int leftMot = 3;
int rightMot = 9;

int fRange = 63;
int bRange = 85;

int neutralVal = 187;
int leftSerialIn = 0; //val from AI
int rightSerialIn = 0; //val from AI as int

char * leftChar;
char * rightChar;
String incomingStr;
//char * incomingCharArray;


char leftDelimiter = '_';
char rightDelimiter = '&';

void setup() {
  pinMode(leftMot, OUTPUT);
  pinMode(rightMot, OUTPUT);
  Serial.begin(115200);
}

void loop() {
  if (!Serial.available() > 0) {
    incomingStr = Serial.readStringUntil('&');
    //Serial.print(incomingStr);
    int str_len = incomingStr.length() + 1; 
    char incomingCharArray[str_len];
    incomingStr.toCharArray(incomingCharArray,str_len);
    leftChar = strtok(incomingCharArray, &leftDelimiter);
    rightChar = strtok(NULL, &rightDelimiter);
    leftSerialIn = atoi(rightChar);
    //Serial.println(leftSerialIn);
    //Serial.println(rightSerialIn);
    rightSerialIn = atoi(leftChar);

  }


  //LeftSide
  if (leftSerialIn == 0) {
    analogWrite(leftMot, neutralVal);
  } else if (leftSerialIn > 0) {
    //forward left
    analogWrite(leftMot, int((fRange * (abs(leftSerialIn / (double)100))) + 191));
  } else if (leftSerialIn < 0) {
    analogWrite(leftMot, int((bRange * (1 - abs(leftSerialIn / (double)100))) + 100));
  }else{
    analogWrite(leftMot, neutralVal);
  }
  //rightSide
  if (rightSerialIn == 0) {
    analogWrite(rightMot, neutralVal);
  } else if (rightSerialIn > 0) {
    //forward left
    analogWrite(rightMot, int((fRange * (abs(rightSerialIn / (double)100))) + 191));
  } else if (rightSerialIn < 0) {
    analogWrite(rightMot, int((bRange * (1 - abs(rightSerialIn / (double)100))) + 100));
  }else{
    analogWrite(rightMot, neutralVal);
  }
}

Credits

TAYLOR WADDELL

1 project • 0 followers

Jake Rymsza

0 projects • 0 followers

Thanks to Manasi Srirangarajan, Allison Conrad, and Thomas Kelly.

Badger BOAT( Buoyancy Operated Autonomous Vehicle)