Intro projects are under continuous revision, but some subteams have opted to make significant changes while still keeping the old project up for reference. Here are those projects.

Introduction

The intro project is designed with two main parts:

1. A general rocketry take-home quiz, taken alone (due roughly 1 week after assigned)

2. A design project, also done alone (due roughly 3 weeks after assigned)

The intro project may seem daunting, but don’t worry! In addition to the existing resources on GitBook, all the returning payload members will available to help. To encourage intra-team communication, new members are encouraged to ask for help from a designated returning member, as part of our mentorship program. Furthermore, do not hesitate to ask questions on the #payload Discord channel or PM Jared Farley or other payload members.

We will also hold a series of intro project workshops throughout the next weeks, giving an opportunity for hands-on help. Details will be announced here and on the #payload channel.

Above all, we hope that the intro project will be a fun and rewarding experience.

Checkpoints Schedule:

• By week of 2020-09-21 - Quiz Complete

• By week of 2020-10-05 - Design Project Complete

Part 1: General STAR & Rocketry Quiz Questions

1. What are the subteams of STAR?

2. What are the names of STAR's rockets?

   1. What are their diameters?

   2. What are they made out of?

3. What is the maximum side length payload cube that could theoretically fit in a 20cm diameter rocket?

4. A G-class motor is roughly how many times more powerful than a D-class motor?

5. With roughly what speed will a 10kg rocket hit the ground if in free fall from 1280m? (You may use g=10 m/s/s)

   1. Is this a realistic speed to assume? Why or why not?

6. Give two pros and two cons of a dual-deployment (two parachute) recovery system.

   1. How do altimeters measure altitude?

7. Is it possible to directly measure the velocity of a rocket during flight? Why or why not?

   1. Describe two ways you might calculate the velocity of a rocket with the following sensors: GPS tracker, altimeter, accelerometer, gyroscope.

   2. What are the potential advantages and drawbacks of each method given?

8. Explain what each number means in the following UTS designation: #6-32x1

   1. What is the smallest screw gauge in the UTS system?

   2. What are the standard and fine TPI of a #4 screw?

9. Explain what each number means in the following Metric screw designation: M6-1.0x20

   1. How is the designation of threading different in the UTS system than the Metric system? Subtle but important.

   2. Why is the Metric system superior to the US Customary system?

Quiz Submission

Please upload your quiz as a PDF here:

{% embed url="https://forms.gle/SSeNjQrgCF3JUBHh8" %}

Part 2: Design

Design Objective Outline

Our goal is to build a mini robotic rover that fits inside a 4” diameter payload tube. Another team has already done the task of picking out the electronics, sensors, motors, and wheels. Your task is to design and prototype the rover’s chassis– a structure to mount all of sensors, motors, wheels, and the microcontroller.

Requirements

Engineering is defined by requirements!

Components to Integrate

• 1x Arduino Nano

• 2x 40mm wheels

• 1x ball caster wheel

• 2x motors

• 1x motor driver board (optional)

• 1x distance sensor

Detailed Design Requirements:

1. All components must fit within the space of a cylinder, 4" in diameter and 8" in length.

2. All components must be mounted by non-permanent means. For example, you may not glue the Arduino to the frame. One method could be to use zip ties/Velcro; if you choose this option, be sure to include slots/holes for the ties/velcro. For parts with mounting holes, screws and nuts are preferred.

3. The distance sensor must be mounted to the front of the rover, facing forward.

4. The wheels may be arranged in any reasonable format. (Tricycle-like approach recommended).

5. You do not have to worry about wiring the electronics or mounting the rover to the tube.

Your frame may be as elaborate or simple as you'd like, but it should adhere to the above requirements.

Designing in Solidworks

We will use CAD (computer aided design) software in order to model our 3D frame. STAR has standardized in using SolidWorks as our preferred CAD software. If you have used CAD software other than SolidWorks, such as Fusion 360, Inventor, or Creo, then SolidWorks should not be too difficult to pick up.

If you have never used CAD software before, don’t worry! We will hold an intro project training class during Workshop 1, most likely on the week of 9/21. If you are not able to attend, there are also great online resources:

Step 1: Installing SolidWorks

The first challenge of this stage is installing SolidWorks. The GitBook has a very helpful “SolidWorks Installation” page to help you with this.

Step 2: Working with given hardware

Assume another team has already picked out the motors and electronics necessary for a rover. As a design engineer, your task is to cohesively incorporate all the given components into a (hopefully) functioning rover.

A good place to start is by looking at the physical dimensions of each component. Attached are 2D dimensioned engineering drawings of all the parts.

Step 3: Working with the tube

The most challenging (and annoying) constraint placed on many payload projects is the size of the payload tube (the part of the rocket that the payload is stored in). Learning to work with the size limits of a cylinder is essential.

In this project, your tube space is limited to 4" in diameter and 8" in length, a common size for a medium-scale rocket. It is often convenient to work with space envelopes limited by a rectangle, so the foremost important fact to understand is that a 4" diameter circle will not fit a 4x4" square. Your usable space is limited to what you can fit (or inscribe) within a circle.

Keep this in mind when designing your chassis!

Step 4: Start designing!

That's all the essentials to get you started on your design. Remember, you can come up with anything as long as it meets the detailed design requirements. The rest of this sub-section lists a few tips.

Step 5: Additional resources

A detailed step-by-step design guide will be released later in the semester (Although I heavily encourage you to try it out yourself first & ask any Payload member for help before consulting the guide).

Project Submission

Please upload your SolidWorks/other CAD files here:

{% embed url="https://forms.gle/SSeNjQrgCF3JUBHh8" %}

Introduction

The purpose of this project is to ensure that new and returning members research various parts of a rocket propulsion system from both theoretical and practical engineering points of view.

The project consists of two parts: an in-person component and a project component.

Returning Members

If you are a returning member for the 2019-2020 academic year, you are not required to complete the project component, but you are required to satisfy the in-person requirement by participating in any of the offered workshops. Leading or helping plan a workshop will be considered as participation.

If you are interested in contributing to a workshop (highly encouraged), please contact Michael via Discord.

Contact

If you have any questions about any part of the question at any time (even if it's 4AM on a weekend), do not hesitate to reach out to the propulsion lead (Michael) or the propulsion deputy (Trevor). Discord is preferred, but if you are having difficulty getting started with Discord, Email is fine.

• Michael's Discord: mvronsky (accessible through CalSTAR discord)

• Trevor's Discord: zat15 (accessible through CalSTAR discord)

• Discord: in the #propulsion channel

• Michael's Email: michaelvronsky@obvious.edu

• Trevor's Email: tzinky@obvious.edu

• Office Hours:

  • Michael's OH: Tuesdays 14:10-15:30 in Kresge Engineering Library

    (exact location may vary, will be announced on Discord)

  • Trevor's OH: Wednesdays 16:30-18:00 in Kresge Engineering Library

    (exact location may vary, will be announced on Discord)

1. In-Person Component

To satisfy the in-person component, you must attend one of the following events:

• Safety Workshop (First one on Friday, Sept. 20 at 19:00)

• Michael or Trevor's Office Hours, to review safety (See above for OH)

In addition to attending a safety session, you are required to attend one of the following events. If you have time to attend more than one, you are encouraged to do so.

• A trip to the Richmond Field Station (RFS) (See #propulsion for updates)

  • This is more time consuming, but highly recommended, as it is where we do most of our work

• Injectors and cooling workshop (Thursday Sept. 26, 7PM-8PM)

• Mechanical design workshop (Time TBD)

• CAD workshop (Sunday Sept. 22 9AM-11AM)

• Solid propellant workshop (Thursday Sept. 26 6PM-7PM)

• Pipes and Fittings workshop (Wednesday Oct. 2nd, 8PM-9PM)

Lastly, once you believe you have finished your intro project, you should schedule a time with Michael during office hours to go over your submission. If you are super busy and can't find a time, then talk to me and we can sort something out.

2. Project Component

You may choose any of the three project components to complete. All are intended to be of about the same difficulty, and should give you insight about the various engineering tasks that we undertake.

2.1 Fluids

This task involves assorted tasks related to fluids design in propulsion systems.

2.1.1 - Injectors

Injectors serve to mix and atomize the propellants flowing into the thrust chamber. Injectors also help regulate the flow of propellants and ensure efficient combustion.

• Describe 4 types of injectors, and explain their pros and cons

• Design an injection system for the given engine.

  • Your design should consist of the following:

    • The selected injector type, and a justification for its selection

      • Factors to consider here are manufacturability/machinability and efficiency of mixing, among others

    • If there are multiple injection elements, describe their layout on the injection plate

    • The orifice area for each injection element. This can be calculated using an equation found in chapter 8 of Sutton (9th ed.)

  • The engine parameters are:

    • 1000psi chamber pressure

    • Mass flow rates are 0.17 kg/s for LOX, 0.08 kg/s for RP-1

    • 250 psi pressure drop across the injector

    • Injection plate diameter is 2”

2.1.2 - Feed System Analysis

The following Piping and Instrumentation Diagram (P&ID) is for a simplified gas-fed system. For each component labelled, describe its function, and what would happen if that component were not included in the system. Note that this is not the entire feed system, just one side of it. There are 2 fluids in the system, N2 and RP-1.

In the diagram, all ball valves are "L-port".

The following page will be very useful in interpreting this diagram:

2.1.3 - Flow coefficient

The flow coefficient of a component, often denoted Cv, is a very useful measure of its behaviour in the feed system.

Describe what the flow coefficient is, and explain why it is important to look at the flow coefficient of components when selecting them.

Deliverables

• Your injector design and area calculations

• Your interpretation of the P&ID diagram

• Your solution to the question in part 2.1.3

2.2 Thrust Chamber Design

A thrust chamber is to be designed for a 1000lbf engine using Kerosene and Liquid Oxygen.

• Design constraints:

  • O/F ratio = 2.5

  • The feed system can supply up to 1200psi feed pressure, and an injection pressure drop of 250psi will be used.

    • Based on these parameters, decide on a reasonable chamber pressure.

  • The thrust chamber must fit in a 7.5” diameter airframe.

  • Ambient pressure will be 1atm

Deliverables:

• Chamber geometry: Using the Rocket Propulsion Analysis (RPA) software, determine the thrust chamber size and shape.

• Tank analysis: A total impulse of 30,000 N*s is desired. Using the mass flow rates derived in RPA, determine the mass of each propellant required, as well as the associated volume.

• Material analysis: Pick three materials that are commonly used as thrust chamber materials and describe the pros and cons of each material in this application

  • A good analysis should include comparisons between quantitative material properties such as yield strength, thermal conductivity, and thermal expansion as well as qualitative material properties such as brittleness, machinability, cost, and corrosion resistance

  • If a metal is one of the materials chosen, it must be a specific grade i.e. 1018 steel vs just steel, or 316 stainless steel vs just stainless steel

2.3 Test Stand Mechanical Design/CAD

Just like any other subteam, our work requires the design and construction of many mechanical systems, often for a very specialized task. In the past, these have included structures to house the propulsion system in the rocket or on the test stands, testing jigs for various components, mounting brackets, and more.

In this task, you will design a test stand for testing small solid motors. Test stands are used to fire the motor while it is static on the ground. Test stands help verify motor design and test key features of any propulsion systems. Common features of test stands include thrust measuring devices, safety features, and, obviously, motor systems. In this project, you will design a small test stand intended to test fire solid model rocket motors up to a “G” class. Your design of this should ideally maximize safety and measurement accuracy, while minimizing costs and complexity.

Design Constraints

• Must be able to safely test fire up to a “G” class solid motor

• Must be able to handle various motor diameters up to 29mm

• Must be able to measure the thrust produced by the motor

Deliverables:

• A completed Solidworks assembly file of your test stand

• A bill of materials including all part names, order links (www.mcmaster.com is a great website for ordering pretty much any part you can think of, plus they have CAD’s on the website which is pretty great), and prices. A template is provided here.

• A justification of your design. Factor of Safety calculations, while optional, would be nice. This can be just a quick paragraph or two explaining your thinking, possibly improvements, possible failure modes, etc.

Resources

Introduction

You have been given a design for a very simple rocket flight computer that consists of six components: a battery, a voltage regulator, an ATMega328P microprocessor, an MPL3115A2 altimeter, and two black powder ports. You will be describing the system in more detail and writing firmware to control the rocket’s recovery system (parachutes) via the two black powder ports.

Details and Specifications

• The details of the battery and voltage regulator do not matter, but they must both be included in the final system diagram that you create.

• You have been provided with an interface for a HAL (Hardware Abstraction Layer). You will use its functions to write the firmware for the ATMega328P. The file is below, in the Files section.

  • The pinMode, digitalRead, and digitalWrite functions act as they would in Arduino.

  • The i2c_*** functions act as they would in the Arduino Wire library.

  • The millis function returns time, in milliseconds, from program start.

  • Arduino reference materials and the HAL are listed below, in the Resources section.

• When configured correctly, the MPL3115A2 provides integer altitude data, in feet, via the I2C protocol.

  • Registers implemented in the simulator are:

    • Pressure Data Out MSB/CSB/LSB (OUT_P_XSB)

    • System Mode (SYSMOD)

    • Control Register 1 (CTRL_REG1)

    • Control Register 2 (CTRL_REG2)

    • Who Am I (WHOAMI)

    • Data Ready Status (DR_STATUS)

    • Pressure/Temperature Data Config (PT_DATA_CFG)

  • Depending on how you use the altimeter, you may not need all of these registers.

• The simulation runs at 100 times real time, i.e. millis() returns 100 * (milliseconds elapsed since start of program). Be careful if using sleeps and while debugging.

• The two black powder ports are activated by two specific GPIO pins on the ATMega328P. To activate each one, turn on the pin for at least 50 milliseconds.

  • The drogue chute ignition pin is PB3.

  • The main chute ignition pin is PD7.

• The firmware must be written in C.

• The initial altitude reported by the MPL3115A2 will be somewhere within [-100, +100] feet in altitude (inclusive)

• The altitude will remain within [-5, +5] feet of an unspecified constant altitude between [-100, +100] feet -- the ground altitude -- for at least 30 seconds after flight computer startup and before launch. All altitudes following are in reference to this ground altitude. It is expected that there will be some inaccuracy in the timing of the ejections in your firmware due to the fluctuation of altitude readings while the rocket is on the ground.

• The black powder ignitions must happen at apogee, +/- 2 seconds, and at 600 feet of altitude during descent, +/- 2 seconds.

• Neither black powder ignition should happen unless the rocket has passed 200 feet in altitude.

• Determine and implement a proper strategy for the case in which the flight computer passes 200 feet in altitude, but does not reach an apogee of 600 feet in altitude.

• Describe at least three failure modes and how they are being mitigated or avoided.

• Describe test procedures you would use to verify correct functionality in the lab (i.e. not at a launch) and at a launch.

• Show how the microprocessor should be hooked up to the MPL3115A2 and any additional hardware added in order to mitigate failure modes and run test cases (such as status LEDs or buttons). This must be in the form of a wiring diagram or schematic.

• Add at least one feature to the code and/or schematic that is used for safety, such as beeping when black powder is connected. Describe the feature and explain any changes made to accommodate it. You are encouraged to look at how COTS (Commercial Off-the-Shelf) altimeters work for inspiration. Some examples are the Stratologger CF and the MissileWorks RRC3.

Compiling and Testing

• The HAL you are provided is in fc.h. You are expected to write an fc.c file that defines fc_setup and fc_loop.

  • fc_setup is called once, followed by fc_loop called repeatedly until the simulation is complete.

  • All of the other functions declared in fc.h are defined by the simulation runner, in fc_sim.mac.o or fc_sim.win.o.

  • Download the appropriate fc_sim.***.o file from the Files section and rename it to fc_sim.o (if you want).

• You are provided with a compiled, but not linked, simulation runner, called fc_sim. You will compile your flight computer code and link it with fc_sim to create an executable that, when run, will tell you how the launch went!

• To compile your flight computer:

  • The -g is to compile with debug symbols.

  • Note: On linux you may have to add a "-lm" flag to link the math library.

• To test your flight computer, simply run fc_sim.

• To debug your flight computer, use your favorite C debugging tool, such as gdb. You are not provided the code for the flight computer simulator, but you can debug your own code.

  • Tip: VSCode makes it very easy to write, build, run, and debug code once you have it set up!

Resources

Additional Questions

1. One simple electrical system consists of a battery and a microcontroller with a single button connected with a pullup resistor and a single LED with current-limiting resistor, as shown below. Determine how long it will last on battery power. Explain your answer.

   • Vbatt = 15V, and its capacity is 1A-hr. For safety, only 80% of its full capacity should be used.

   • U1 outputs 5V, and is 90% efficient.

   • The microcontroller draws a constant 20mA.

   • R1= 10kΩ, and S1 is pressed 5% of the time.

   • R2 = 200Ω, D1's Vf = 2.1V, and D1 is on 50% of the time.

2. Write a short snippet of C code that, given an 8-bit register r and a bit index b:

1. Sets bit b.

2. Clears bit b.

3. Toggles bit b.

4. Assigns bit b to a boolean value v.

Files

Submission

Please PM Jacob, the Avionics Lead (Jashaszun#9329) a ZIP of the following files via Discord:

• Any C files you wrote that are required to compile and run your flight computer.

• A text file or PDF containing your answers to all other parts of the project.

Introduction

Welcome to the Recovery team's intro/returning project page! Glad you're here.

The recovery team is tasked with safely landing the launch vehicle. This responsibility entails understanding the constraints provided by others/the specifications of the launch vehicle itself and producing creative and efficient solutions. Tasks include but are not limited to: parachute size/material/geometry selection, parachute deployment altitude selection, ejection/separation mechanisms, and a general understanding of mechanics, electronics, simulations, physics, and more.

For any questions/help, feel free to reach out to the recovery team lead, Allen, and deputy, Evan at office hours or online through Discord/email. Office Hour times/locations for both are listed below. OH are highly encouraged if you need help!

• Allen Ruan | Recovery Team Lead

  • OH: Thurs 3-5PM, Kresge Engineering Library or Etcheverry CAD Lab(check discord for exact location)

  • Email:

• Evan Borzilleri | Recovery Team Deputy

  • OH: Monday 10AM-12PM, Kresge Engineering Library (check discord for exact location)

  • Email:

New Member Project (8 hrs)

The new member project for the recovery subteam is intended to:

1. Introduce a strong technical foundation for the critical components of the recovery subsystem to new members

2. Learn to work with constraints, similar to industry

3. Encourage collaboration/asking for help to accomplish these tasks

The deliverables of the project should be presented at the recovery subteam meeting (Sept. 27th) in the form of a .ppt slide deck containing snapshots of the various projects. Remember! This project is meant to be challenging, but attainable, especially if you ask for help. So please ask questions, come to workshops, and come to office hours!

Task 1 | Knot Tying (0.5 hrs)

Workshops | [Recovery]

Objective | Become familiar with and learn to tie all the knots necessary for parachute deployment systems (All knots will be demoed in the workshop). The following knots must be perfected:

• Eight knot

• Square knot

• Bowline knot

• Alpine Butterfly knot

• Double hitch

Deliverable | The student must demonstrate tying all the knots above to either Evan or Allen

Task 2 | Recovery Sequence (0.5 hrs)

Workshops | [Recovery]

Objective | Create a flowchart detailing the sequence of recovery events starting from when the launch vehicle is at apogee to when it is fully recovered. Images/Drawings are encouraged.

Deliverable | Flowchart (can use draw.io or any other diagram sites)

Task 3 | Parachute Selection (3 hrs)

Workshops | [Recovery] [OpenRocket]

Objective | Select the best combination of parachutes that satisfies the constraints below:

Constraints:

• Drogue is deployed at apogee (maximum altitude)

• Main is deployed at 600ft above ground level (AGL)

• Drogue Cd (Coefficient of Drag): 1.5

• Main Cd: 2.2

• Each component must not land with greater than 75 ftlb-f

• Drift radius must be less than 2500ft in 20mph wind

Deliverable | Modified table with filled out fields in .ppt and correct option with explanation of why this is the best option out of the three. .ppt must show work/calculations. Cheating is not tolerated.

Task 4 | Bulkhead Design (4 hrs)

Workshops | [PDM] [Recovery] [Solidworks]

Objective | Create a CAD assembly of a rocket bulkhead using Solidworks. Once complete, check-in to CalSTAR’s Solidworks Workgroup PDM. The CAD Assembly shall consist of the following parts/components:

• Outer Bulkhead

• Inner Bulkhead

• U-Bolt

  • 1/4" Bolt

  • 1/4" Flat Washers (x4)

  • 1/4" - 20 Nuts (x4)

Drawings of the necessary parts are provided below:

For bonus points:

• Include material properties for each component

• Etch text on both sides of the combined bulkhead

Deliverable | Snapshots of the full assembly (two different views), and screenshot of assembly uploaded to the PDM

Task 5 | Creative Section (X hrs)

Workshops | [Recovery] [Solidworks]

Objective | CAD and mockup a functional electronics sled for the avionics bay. The sled must meet the following requirements:

• Designed in 3D modeling software (preferably Solidworks)

• Must be able to mount Stratologger CF altimeters and 9V Duracell batteries

• Fit within a 4in diameter tube

Deliverable | Manufactured sled and its assembly file uploaded to the PDM. Add photos to the .ppt and describe the design

Returning Member Project (10.5 hrs)

Similar to the new member project, the returning member project is intended on refreshing everyone’s mind on performing the pertinent tasks for the recovery team, in addition to educating members on a deeper level focused on manufacturing and big-picture understanding. It is due on 09/20.

Task 0 | Intro Project (7.5 hrs)

Workshops | [OpenRocket] [PDM] [Recovery] [Solidworks]

Objective | Complete tasks 1, 3, and 4 the intro project

Deliverable | Document all work on a .ppt as outlined above

Task 6 | Wiring Diagram (1 hr)

Workshops | [Recovery]

Objective | Create a wiring diagram of all the electronics/wiring included in the avionics system for a dual deployment recovery system using a flowchart software (eg. draw.io). Include + and -. This might require looking into an altimeter datasheet (look up perfectflite stratologger CF). Components that shall be included:

• 1 Altimeter

• 1 9V Battery

• 1 External Switch

• 1 Main Charge

• 1 Drogue Charge

Below is a snapshot of a diagram with the altimeter and batter to get you started.

Deliverable | Snapshot of wiring diagram in .ppt

Task 7 | Launch Day Checklist Quiz (0.5 hrs)

Workshops | None

Objective | Complete the following quiz about the sequence of events that we, as a recovery team, complete during a launch day. Unlimited attempts, but must get a perfect score.

Deliverable | Screenshot of perfect score

Task 8 | Technical Writing (1.5 hr)

Workshops | None

Objective | Given the importance of technical reports/documentation in what we do, write a paragraph detailing the specs and function of the bulkhead you have just created. Include an image of the CAD and the actual manufactured bulkhead. Include a reference for the figure and a caption. Format is up to you, but please check for typos and grammatical errors. If you have any questions, there exists a lot of good documentation on LaTeX online, and/or come to OH.

Deliverable | .pdf of the LaTeX document

"One bad year of competition is really annoying, but one bad year of education leads to three bad years of competition." --Sam

Welcome to avionics!

If you're reading this, you're probably a new member who's looking to get involved with our avionics projects at STAR. This document--our new intro project--will teach you everything you need to know to be a filly contributing member on the team, even if you have no experience. For your own reference, here's a concise list of all the different websites and resources that you'll be interacting with as an avionics member:

• Our gitbooks page, which you're reading right now! In addition to the intro project, there are also helful tutorials written by previous avionics members linked here: . Try to read through them since they might help a lot with doing your intro project.

• The STAR google drive, linked here:

• Quire, which is a sort of mega to-do list so we can keep track of what to do when. It's similar to trello, if you've ever used it.

• The STAR calendar:

• Our github, which is where avionics projects live (including your intro projects):

• Cadlab, which is sort of like a mirror for github. It lets you look at the schematics for our projects without needing to download them and open kicad. Link:

• And, of course, the club discord!

Overview

This intro project serves as an introduction to the Kicad software suite, which is used by the avionics team to design circuit boards for STAR projects. The projects is split up into two paths--one path is for students who are more interested in schematic design, and the other path is for students more interested in PCB layout. Schematic design and PCB layout are both fundamental parts of using Kicad. The primary goal of both intro projects is for students to learn how board design is done on the avionics subteam, and gain experience on a project that is very similar to "real" avionics projects.

The schematic-focused path of the intro project is called "cas-rpi-hw" and it consists of adding two new parts (a raspberry pi compute module, and an FPGA) to our current CAS-Core board. The layout-focused path of the intro project is called "cas-radio-revised-hw" and it consists of adding one new part (a dual radio transmitter-reciever) to our current CAS-Radio board. Both CAS-Core and CAS-Radio will be explained in more detail later on.

Here are the links to the github repositories where our intro projects live. These repositories contain the starter files for the project, and they tell you the specifications that you'll be trying to fulfill.

What is Kicad?

The circuit design process in Kicad follows a relatively predictable structure, which is separated into two main phases: schematic design, and PCB layout. Schematic design involves deciding which components and pins are connected to which, and PCB layout involves actually drawing the physical wires that will connect the components together. Each component on a circuit board has one symbol (a diagram showing which pins it has, and what their names are) and one footprint (a diagram showing the exact size and shape of its pins). Symbols are used in the schematic design stage, and footprints are used in the PCB layout stage.

Another core feature of Kicad is Libraries, which are used to store symbols and footprints. Every symbol or footprint must be in a library. You can create your own libraries to store symbols and footprints in, and these libraries can either be global or project-specific. Creating project-specific libraries is generally simpler and easier to manage. Annoyingly, the symbol libraries and footprint libraries are stored in two different ways. Symbol libraries are stored in a .lib file, but footprint libraries are stored in a .pretty folder. The .pretty folder contains multiple .kicad_mod files, and these files are the individual footprints.

A typical Kicad project proceeds as follows: 1: Decide on the main components you are planning to use on your circuit board. 2: Create schematic symbols for these components, unless they already exist in Kicad. 3: Create footprints for these components, unless they already exist in Kicad. 4: Create connections between pins in the schematic design stage 5: Associate symbols with footprints (tell Kicad which symbol corresponds to which footprint) 6: Draw the physical traces between footprints in the PCB layout stage 7: Generate gerber files Here is a convenient cheatsheet that explains this process in full:

If you have no prior experience with Kicad, then I highly recommend watching this tutorial video series by Digikey. It is useful both as a first look to get familiar with Kicad, and as a refresher to brush up on the details. Following along with their practice project is completely optional--the tutorial is still very helpful even when just passively watching.

CAS

CAS stands for Common Avionics Stack and it is one of our most recent avionics projects. The fundamental idea behind CAS is that the entire system is organized into modular boards, each of which are about 3 inches by 3 inches in area. Each board has one general purpose, and the boards are all connected together in a 'stack.' The boards can exchange data because each board has an identical 80-pin header.

The following is a description of the pins used by Cas-Stacking. Except for the power and miscellaneous pins, most of the pins should be used to interface with the board's microcontroller.

• Power

  • +3.3V

  • +5V

  • +BATTERY

  • GND

• I2C #1

  • SCL

  • SDA

• I2C #2

  • SCL

  • SDA

• SPI High-Speed

  • SCK

  • MISO

  • MOSI

  • SS1, SS2

• SPI Low-Speed

  • SCK

  • MISO

  • MOSI

  • SS1, SS2, SS3, SS4, SS5, SS6, SS7, SS8

• Other

  • INT1, INT2, INT3, INT4, INT5, INT6, INT7, INT8

Included below is the schematic footprint for a Cas-Stacking board. The pins A1-A40 are on the left, and the pins B1-B40 are on the right. The 4 circles on the corners are larger protrusions that are used to stabilize the board and keep it from falling out.

One thing to note about CAS is that, unlike most circuit boards, CAS boards have 4 layers instead of 2. This is not a significant change to the design process, but it is something to keep in mind. The plan for the 4 layers is to designate the outer two as front copper pour and back copper pour, while making the middle two boards a ground plane and a power plane. A 'plane' is basically a copper pour that fills the entire layer.

Using git

Managing submodules

NOTE: This section isn't needed for completing your intro project, but it could be a good reference for the future when you want to make your own kicad projects.

Be aware that if you are trying to pull or clone a github repository with submodules in it, you will need to use the --recursive tag when entering the command.

Intro Project A: CAS-RPI-HW

Step 0: Getting started

• First, create a new directory to hold this kicad project. On the command line, cd into this directory.

• Enter the command git init to create a git repository in this directory.

• Enter the command git clone https://github.com/calstar/cas-rpi-hw --recursive to download the starter files for the project. Your project will be located inside the core directory. If you look inside it, this is what you should find:

--core.pro: Click on this to open the kicad main window. --core.sch: Click on this to open the schematic editor. --core.kicad_pcb: Click on this op open the PCB layout editor. --hardware-sch-blocks: This contains the symbol and footprint libraries for star-common-lib. The schematic library is located at star-common-lib.lib, and the footprint library is located at star-common-lib.pretty. --RPi-CM4-Kicad: This contains the symbol and footprint libraries for the RPi compute module. The schematic library is located at Raspberry-Pi-Compute-Module-4.lib, and the footprint library is located at Raspberry-Pi-Compute-Module-4.pretty.

• To get started with the project, open the schematic file core.sch which will pull up the kicad schematic editor. The project should be blank except for two symbols for the Cas-Stacking board, which is inherited from the star-common-lib library. (It's true that Cas-Stacking is just one part and not two, but sometimes we will split very large kicad components into multiple symbols so they are more convenient to work with in the schematic editor.)

• Here is what you should see at the beginning.

Step 1: Create Schematic

• The first thing to add is the raspberry pi compute module. You can find it by using the 'place symbol' tool and then going to the RPi-CM4-Kicad-library. The component has 200 pins in total, and it's split up into multiple sub-blocks, either by structure or by function. You could put the component directly on the schematic, but since it's so big, we're going to create a hierarchical sheet to hold it. Click on 'create hierarchical sheet' and place a hierarchical sheet down on the schematic. Go inside the sheet and add your RPi-CM4 component. Then, wire up the power and ground pins using global flags, and connect everything else to hierarchical pins. Then, exit the hierarchical sheet, and place the hierarchical pins on the sheet so that they can connect to the rest of the schematic.

• You can also put the Cas-Stacking connector in its own hierarchical sheet. Luckily, this has already been done, since a hierarchical sheet exists in hardware-sch-blocks. To add it to your schematic, create a new hierarchical sheet, and specify the path as hardware-sch-blocks/CAS_bus/Cas_bus.sch. This should cause Kicad to load in the existing CAS_bus hiararchical sheet to the schematic. Then, all you have to do is place down the hierarchical pins on the schematic.

• The next thing to add is the ice40 fpga. Luckily, kicad already has this component in its default libraries. If you click the 'place symbol' tool and then search for 'ice40', you should see symbols pop up that you can use for the ice40 fpga. Click on the one (or ones) you want, then click 'ok' and you should be able to place them on the schematic.

• Afer that, try adding the BMP388. This should be very similar to adding the fpga, except you will find it under the 'star-common-lib' section. Place it down in the same way you placed down the fpga.

• Add more components according to the spec on the github readme, such as the accelerometer and rpi cam connectors. Use the resources linked in the readme to figure out how everything should be wired together. You will probably want to review: the datasheets for all relevant components, the downloadable rpi schematics from the CM4IO-KICAD folder, the previous cas-core board schematics on cadlab, and the list of pins for the cas-stacking connector. This step will probably take the longest as you read through all the resources and figure out where everything should go.

• Kicad has the following useful hotkeys. Use E to edit a components properties, R to rotate a component, M to move a component, and W to start drawing a wire (use esc to cancel a wire drawing).

Step 2: Associate Components With Footprints

• When you are satisfied with the state of the schematic, you can associate the components with footprints before proceeding to the layout stage.

• Select the 'annotate schematic symbols' tool and click 'annotate' to give a number to every symbol on the board.

• Open the CVPCB tool from the toolbar.

• Search for each board component and associate it with a footprint.

• Generate the netlist.

• Open PCBNew and read in the net-list.

Step 3: Layout PCB

• You'll see each footprint generate on top of each other in one big clump. Move them out of the way so they aren't all on top of each other. Make sure that all the footprints can fit inside the boundaries of the cas-stacking board.

• All the components have little white 'air wires' showing what needs to be connected where. Your next step is to move the components around (with the M hotkey) and rotate them (with the R hotkey) so that most of the air wires aren't crossing over each other. You probably will still have some air wires crossing over, but try to move the footprints out of the way so you can minimize it as much as possible.

• You can calculate proper trace width using an online trace width calculator, and set the trace widths in KiCad (go to the track width tab on the toolbar, click on ‘edit pre-defined sizes’ in the dropdown menu, and input the new sizes). You will have to set both trace width and drill size. Remember that power traces generally need bigger trace sizes than other types of traces.

• Route the traces according to the connections provided by the air wires, until all of the air wires are gone. You will probably need to use vias to go through the board in order to fit all the traces in.

• When routing power traces, try not to make them go through any vias (though its not an absolute necessity). The power traces should have "priority" over other types of traces.

• Remember keep your layout relatively neat and not too clumped up--if you tried to solder the components onto the board then you would need a little bit of room to do so correctly!

• If you're confused about something, you refer to the old cas-core and cas-radio projects that already exist to see what the settings were like (trace width, drill size, board layer settings, etc). Just clone the repository into a new directory and open the project in kicad, then you can navigate around the project and see what a finished kicad project is supposed to look like.

• Try using Kicad's 3d viewer to see what your board is going to look like once it's been fabricated. You can do this at any stage in the layout process!

• When you're done drawing traces, create a ground pour on the second layer (creating a ground plane), and then create a power-supply-voltage pour on the third layer (creating a power plane).

• Generate gerber files once the layout is finished. Generating gerbers is always the last step in a Kicad project.

Intro Project B:CAS-Radio-Revised-HW

Step 0: Getting started

• First, create a new directory to hold this kicad project. On the command line, cd into this directory.

• Enter the command git init to create a git repository in this directory.

• Enter the command git clone https://github.com/calstar/cas-radio-revised-hw --recursive to download the starter files for the project. Your project will be located inside the radio directory. If you look inside it, this is what you should find:

--radio.pro: Click on this to open the kicad main window. --radio.sch: Click on this to open the schematic editor. --radio.kicad_pcb: Click on this op open the PCB layout editor. --hardware-sch-blocks: This contains the symbol and footprint libraries for star-common-lib. The schematic library is located at star-common-lib.lib, and the footprint library is located at star-common-lib.pretty.

• To get started with the project, open the schematic file radio.sch which will pull up the kicad schematic editor. The project should be blank except for two symbols for the Cas-Stacking board, which is inherited from the star-common-lib library. (It's true that Cas-Stacking is just one part and not two, but sometimes we will split very large kicad components into multiple symbols so they are more convenient to work with in the schematic editor.)

• Here is what you should see at the beginning.

Step 1: Create Schematic

• The AT86RF215 transciever is probably the most important part of this project, since it's the component that actually does the radio communication. It is an IC radio module with two separate radios included (a 0.9 GHz one, and a 2.4 GHz one). The two radios are independent of each other. They also have both transmission (data in) and recieving (data out) capabilities. The AT86RF215 has 48 pins on it, with the following functions. It's not necessary to understand what every single pin is used for, but it's provided here to help make the wiring diagram easier to comprehend.

• 0.9 GHz Radio

  • RFP09: Differential RF Input (positive)

  • RFN09: Differential RF Input (negative)

  • FEA09: Digital Output A

  • FEB09: Digital Output B

  • RXDP09: I/Q Interface Output (positive)

  • RXDN09: I/Q Interface Ouput (negative)

• 2.4 GHz Radio

  • RFP24: Differential RF Input (positive)

  • RFN24: Differential RF Input (negative)

  • FEA24: Digital Output A

  • FEB24: Digital Output B

  • RXDP24: I/Q Interface Output (positive)

  • RXDN24: I/Q Interface Ouput (negative)

• Power

  • DVDD: Internally Regulated Digital Supply Voltage

  • AVDD0: Internally Regulated Analog Supply Voltage 0

  • AVDD1: Internally Regulated Analog Supply Voltage 1

  • EVDD: External Analog Supply Voltage

  • DEVDD: External Digital Supply Voltage

  • AVSS: Analog Ground

  • DVSS: Digital Ground

• Communication

  • MISO: SPI MOSI Connection

  • MOSI: SPI MISO Connection

  • SCLK: SPI SCLK Connection

  • SELN: SPI SELN Connection

  • RXCLKP: RX I/Q Interface Clock Output (positive)

  • RXCLKN: RX I/Q Interface Clock Output (negative)

  • TXCLKP: TX I/Q Interface Clock Input (positive)

  • TXCLKN: TX I/Q Interface Clock Input (negative)

  • TXDP: TX I/Q Interface Data Input (positive)

  • TXDN: TX I/Q Interface Data Input (negative)

• Miscellaneous

  • IRQ: Interrupt Signal

  • RSTN: Reset Pin (active low)

  • TXCO: Crystal Oscillator Input

  • XTAL2: Crystal Oscillator Output

  • CLKO: Clock Output

• Let's add the transciever to the schematic. You can find it by using the 'place symbol' tool and then going to the star-common-lib library. The component has 48 pins in total, and while you could put the component directly on the schematic, it's so big that we're going to create a hierarchical sheet to hold it. Click on 'create hierarchical sheet' and place a hierarchical sheet down on the schematic. Go inside the sheet and add your AT86RF215 component. Then, wire up the power and ground pins using global flags, and connect everything else to hierarchical pins. Then, exit the hierarchical sheet, and place the hierarchical pins on the sheet so that they can connect to the rest of the schematic.

• You can also put the Cas-Stacking connector in its own hierarchical sheet. Luckily, this has already been done, since a hierarchical sheet exists in hardware-sch-blocks. To add it to your schematic, create a new hierarchical sheet, and specify the path as hardware-sch-blocks/CAS_bus/Cas_bus.sch. This should cause Kicad to load in the existing CAS_bus hiararchical sheet to the schematic. Then, all you have to do is place down the hiararchical pins on the schematic.

• Refer to the resources included in the github readme to figure out how the AT86RF215 should be wired up. You will probably want to review: the AT86RF215 datasheet, the cariboulite schematic, the hackrf github page, the previous cas-core and cas-radio board schematics on cadlab, and the list of pins for the cas-stacking connector. This step will probably take the longest as you read through all the resources and figure out where everything should go.

• Kicad has the following useful hotkeys. Use E to edit a components properties, R to rotate a component, M to move a component, and W to start drawing a wire (use esc to cancel a wire drawing).

Step 2: Associate Components With Footprints

• When you are satisfied with the state of the schematic, you can associate the components with footprints before proceeding to the layout stage.

• Select the 'annotate schematic symbols' tool and click 'annotate' to give a number to every symbol on the board.

• Open the CVPCB tool from the toolbar.

• Search for each board component and associate it with a footprint.

• Generate the netlist.

• Open PCBNew and read in the net-list.

Step 3: Layout PCB

• You'll see each footprint generate on top of each other in one big clump. Move them out of the way so they aren't all on top of each other. Make sure that all the footprints can fit inside the boundaries of the cas-stacking board.

• All the components have little white 'air wires' showing what needs to be connected where. Your next step is to move the components around (with the M hotkey) and rotate them (with the R hotkey) so that most of the air wires aren't crossing over each other. You probably will still have some air wires crossing over, but try to move the footprints out of the way so you can minimize it as much as possible.

• You can calculate proper trace width using an online trace width calculator, and set the trace widths in KiCad (go to the track width tab on the toolbar, click on ‘edit pre-defined sizes’ in the dropdown menu, and input the new sizes). You will have to set both trace width and drill size. Remember that power traces generally need bigger trace sizes than other types of traces.

• Route the traces according to the connections provided by the air wires, until all of the air wires are gone. You will probably need to use vias to go through the board in order to fit all the traces in.

• When routing power traces, try not to make them go through any vias (though its not an absolute necessity). The power traces should have "priority" over other types of traces.

• Remember keep your layout relatively neat and not too clumped up--if you tried to solder the components onto the board then you would need a little bit of room to do so correctly!

• If you're confused about something, you refer to the old cas-core and cas-radio projects that already exist to see what the settings were like (trace width, drill size, board layer settings, etc). Just clone the repository into a new directory and open the project in kicad, then you can navigate around the project and see what a finished kicad project is supposed to look like.

• Try using Kicad's 3d viewer to see what your board is going to look like once it's been fabricated. You can do this at any stage in the layout process!

• When you're done drawing traces, create a ground pour on the second layer (creating a ground plane), and then create a power-supply-voltage pour on the third layer (creating a power plane).

• Generate gerber files once the layout is finished. Generating gerbers is always the last step in a Kicad project.