If you plan to build larger rocketry projects such as liquid or hybrid engines, you'll eventually have to design and build propellant tanks or other pressure vessels. While games such as Kerbal Space Program may make this seem like a trivial task, in reality it is a bit more involved. This tutorial will teach you the basic principles behind designing a propellant tank for a rocket, such as determining the shape, size, and material; but if you plan to actually build a propellant tank you should do more research such as reading through Rocket Propulsion Elements and similar texts. The additional ground support equipment required to fill and pressurize the tank, as well as the sensors and lines you may want to connect to it will be left outside of the scope of this tutorial.

 a propellant tank, the tools required are quite flexible. In this tutorial I will be using MATLAB to perform the calculations, and Fusion 360 to create a CAD model . Both programs are freely available to me, but you can also use Python instead of MATLAB if you do not have access. As far as the code snippets shown below, I will be showing code snippets of the section I am adding to the program but all of the code snippets belong to the same program and will reference variables defined in previous snippets.

While this is a somewhat complex problem, breaking it down into smaller sub-problems will make it much easier to solve. First, lets talk about what the "givens" will usually be for a problem like this. In order to simplify this a little, we will use a theoretical scenario. In this scenario, 

our end goal is to store enough fuel to run our pressure-fed cold gas thruster for 30 seconds.

 We are using a cold gas thruster as this will simplify the later calculations due to the fact that the engine uses a single gas as fuel. This engine has a specific impulse of 73, an average thrust of 2N, uses Nitrogen gas, and the propellant tank we are designing will be made from Stainless Steel. As the engine is pressure-fed, its thrust will decrease as the propellant tanks pressure decreases. For this tutorial, though, we will just use the average thrust to keep things less complicated.

In order to solve this problem, it would first make sense to calculate the mass flow rate over the duration of usage, which can then be used to calculate the total amount of fuel needed. After we have this, we can then find the amount of volume this fuel will occupy at the determined tank pressure and temperature, which can then be used to calculate the required wall thickness to safely store this fuel. Lastly, we can find the final dimensions and mass of the fuel tank. 

First, let's calculate the mass flow rate from our propellant tank. Again, for this example, we are assuming the thrust to be the 

 thrust from our engine over the duration of the burn, so this may not be as accurate as it otherwise could be. With this established, we now can talk about mass flow rate. 

 is the mass of fuel being removed from our fuel tank per second, and in our case it can be calculated by dividing the average thrust by the specific impulse multiplied by the gravitational constant (

. This is important for us as we will later use this to find how much total fuel we will need. The units for mass flow rate will be KG/Sec, and mass flow rate itself can be denoted as an m with a dot on top.

Now that we have the mass flow rate from our propellant tank, we can calculate the total mass of fuel required. This is fairly simple as it will just be the mass flow rate multiplied by the run time of the engine.

Next, we are ready to find the volume that the fuel will take up at our desired tank pressure and temperature. In practice, this will depend on which (if any) systems you have for regulating tank pressure, as fluids tend to warm up as the pressure increases, and become less dense as they warm up. To simplify this tutorial, we are going to choose a temperature that the propellant will initially be stored at, assuming that there is some system in place to make sure the tank is at that temperature when fully fueled.

Knowing this, let's now find the fuel volume. First, we need to find the molar mass of the propellant in order to determine the total amount of moles of propellant. This can be done by multiplying the mass we found in the previous step by its molar mass, which would be found in the periodic table.

Here is a screenshot of Nitrogen (our propellant) in the periodic table, which has a molar mass of 14.007 kg/mol. With this information, we are now ready to start finding the volume! Below you can see the 

. This equation relates the pressure, volume, moles, and temperature together for 

 gasses. We have to use this equation instead of the ideal gas law because of the high pressures and possibly low temperatures.

You may see that this equation also contains an 

 is 0.0387. Due to the complexity of this equation, it is quite hard to rearrange it for V. Because I am using MATLAB, I will just use the equation solver instead. For 

 we will use the previously found molar mass multiplied by the fuel mass, for 

This gave me a value of 0.0008 m^3. This is a small value, but we only wanted to run our engine for 30 seconds so it makes sense.

Now that we have the volume, we can calculate the required wall thickness. As with all things in engineering, making this decision is a tradeoff, as too thick of a wall thickness will greatly increase the tank mass, and too thin of a wall thickness can hurt the reliability of the tank, and even eventually cause it to fail. Because of this, engineers have come up with the concept of a 

. The safety factor is how many times stronger the material, or in our case the propellant tank, is than what it needs to be. You will have to do your own research to determine what your safety factor should be, but for this tutorial we will use 1.5. Next, let's talk about the concept of stress. Stress is a measure of what a material feels from outside forces, and is measured as a pressure. This pressure is different from the pressure within the tank, but the two numbers are related to each other. 

The above equation solves for the stress in a spherical propellant tank. 

 is the yield strength of the material being used for the tank wall. This equation as we have it right now would just give us the wall thickness without any safety factor, meaning a slight overpressure or a temperature that is slightly different would cause it to burst. To fix this, we can add our safety factor by multiplying the right side of this equation by our safety factor.

As you may have noticed already, the above equation actually has two unknowns: the wall thickness which we are solving for and the tank radius. To fix this, we can find our tank radius as we already know what the volume of the propellant inside is. To do this, we will just use the equation for the volume of a sphere, rearranged to solve for the radius.

, the yield strength of cold-rolled stainless steel is 520 MPa, but for this equation to work the units of yield strength need to match the units of tank pressure. Since our tank pressure is in bar, we can convert the yield strength of 520 MPa to bar by multiplying by 10; which gives a value of 5200 bar. Now we're ready to implement this in our program!

Now that we have calculated everything else, we are finally ready to determine the final dimensions and mass of our propellant tank! We have the inside radius and the wall thickness so this will be quite trivial. First, we can find the outer radius by adding the wall thickness to the inside radius. After that, we can find the volume of material used to create the walls by finding the volume of the outside of the spherical tank and subtracting the volume of the inside, which will just leave us with the volume of the walls. After that, we can multiply that volume by the density of the material used to construct the tank (in our case stainless steel), which will give us the mass of the tank!

Now that you know the basics of propellant tank design, there are a few things you can do to improve the fidelity of these calculations. The biggest thing you can do is to try to simulate the mass flow over time that is required by your engine. You can also look into other tank designs, such as capsule and toroidal tanks. Lastly, for liquid engines you will have two (or maybe even three) propellants, where each propellant will need its own tank. In this case, you will need to determine what ratio the engine will be running at, and thus what the mass flow of each propellant is. Good luck, the sky is (not) the limit now!

Designing Propellant Tanks for Rocketry

Eventually as your projects get more complex, you will soon find the need for hosting your own API. There may be a few different reasons for this, such as needing to make requests to an external API from your frontend, wanting to complete operations within your database, or even sending commands to your Arduino from your own website instead of the Arduino IOT Cloud website!

A 3D printed lamp I created which is controlled from a website I created, which used an API to send commands to the Arduino inside

The first step in creating an API with API Gateway is to determine what you want your API to accomplish. This could mean retrieving crypto prices from an authenticated API, or communicating with the Arduino IOT Cloud. Any of those specific use cases are beyond the scope of this tutorial, so for this tutorial our API will just send the current time from the server it is running on. 

The most effective way to run the code for an API running in AWS is with the use of Lambda functions. These are pieces of code which could be written in many different languages such as Python, Node.js, or Java; which are only run when needed -- which incurs a minimal cost on the user. This is much cheaper than using EC2 or some other method for running code in AWS.

Now that we know what our API is going to do, and what service we will use to run the code for it, we're ready to start programming!

The first thing you'll want to do is navigate to AWS Lambda and click "Create Function"

In this screen, you can give your new function a name, and change the runtime to whichever language you would like to program it in. For this tutorial I will be keeping it on the default which is Node.js. Once you're done with configuration you can click "Create Function".

Now, you should see an example Lambda function on your screen. We are going to step through what this function does, and then rewrite it to fit our needs.

 parameter is an object which contains the information that is being passed into your function; which in our case will also contain the data being sent to your API. This function then creates a 

 variable inside which stores the status code being returned. Inside, there is also a 

 variable which stores the actual response. 

Now that we know this, lets modify this function to send the current time!

As you can see, I added two lines to the beginning of the function. The first line creates a new Date object called 

, and the line after creates a variable called 

, and calculates the current time from the 

 object to now use the current time that we calculated.

In order to create an API with AWS API Gateway, you'll first need to create an account with AWS at 

. Once you've done that, you are ready to begin this tutorial.

Next, we'll want to navigate to the AWS API Gateway. To do this, just search for "API Gateway" in the search bar at the top and click on the first result.

After that, click "Create API" on the top right. Inside of this page you are able to choose which type of API you would like to create, which in this case will be an 

Next, we want to connect our Lambda function to our API. To do this, choose "Lambda" under Integrations, and choose your Lambda functions name from the dropdown below. 

After that, just give your API a name and then you can click "Next" through the rest of the screens until you get to the "Review and Create" screen. You can then click "create" at the bottom.

Now that we have created our API, lets finish configuring it. The first thing we will want to do is set up the CORS settings, which will determine which origins are able to access this API. If you are accessing your API from a website you are running, then you will most likely want to only have your API accessible from that website in order to improve security. For this tutorial we will go with a much simpler configuration which allows access from all origins, using the "*" wildcard.

We're almost done! Now, the only thing left is to test our API. My preferred method for doing this is to use 

. Navigate to Postman and create an account / sign in. Once you have done that, create a new HTTP request.

Next, paste in the Invoke URL of your API, plus the route of the endpoint you would like to test. Since in this tutorial we only have one route, that is the one we will use. 

Lastly, all you have to do is click "Send". If all goes well, you will see the current time arrive in the Response window!

Now that you have created a simple API that can send the current time, you could now try putting this API request onto a website, or changing the API to send a different type of data. You can also change the API to interact with other services, such as the Arduino IOT cloud!

Creating an API With AWS API Gateway

Have you ever wanted to know where your project is located, how fast it's moving, or what direction it's pointing? If so, the Ultimate GPS Featherwing from Adafruit is the perfect solution. In this tutorial, you will learn how to use this Featherwing to retrieve GPS NMEA sentences, which can then be parsed to get the position, speed, altitude, bearing, and many other data points. 

A GPS tracker I created to wear while skydiving which stored position, altitude, and speed

For this tutorial, all you need is an Adafruit Feather board such as the 

Assembling the parts required for this project is extremely simple due to Adafruit's Feather system. All that you have to do is solder header pins onto your Adafruit Feather board, and then you can stack the GPS Featherwing on top!

The GPS module communicates via Serial, which is the same protocol that your microcontroller uses to send messages to the Serial monitor within the Arduino IDE. This makes it quite simple to receive data from the GPS. The first thing that we want to do is to begin the Serial connection with the GPS module.

, which improves readability a bit. Next, we define a string called 

 which will be used to store the GPS sentence as it arrives over Serial. Lastly, within the setup function, we begin a Serial connection over the USB port to allow for debugging within an IDE, as well as begin another Serial connection for communicating with the GPS. 

Now, within the loop function let's add a check to see if the GPS has any new data for us and if it does let's add it to the 

 variable. To know when a given sentence has ended, we can check to see if there is a newline character. Now that we know this, it is easy to display full sentences once they have arrived!

As you can see, within this code snippet we also are storing the sentence type. The sentence type is the GPS's way of telling us what type of information a  given sentence contains, and depending on your use case you most likely do not need to read all sentence types.

TechUp.

Using the Adafruit Ultimate GPS Featherwing

Introduction

Parts Required

Assembly

Programming

Comments:

More Stories

Designing Propellant Tanks for Rocketry

Creating an API With AWS API Gateway