cover photo

COURSE

AIR-001

3 Levels · 8 Months

An Intro to Aviation & Drone Science — From Simulators to Skies

AIR-001

Jump to:


Level 1


Generic Tasks

Task 1: Print It Yourself

Design a Simple Part and 3D Print It

First learn how a 3D printer works. Then design your own simple parts, a cube and a cylinder, in Onshape. It runs in your browser, so there is nothing to install. No CAD experience needed, so students from any branch can do it. After that, slice your design and print it.

Objective: Know the full process of 3D printing: design, STL file, slicing and printing.

What to do

  1. Watch the intro video on 3D printers and read the PLA settings guide.
  2. Go through the 3D printer SOPs.
  3. Make an Onshape account with your college email.
  4. Read the Onshape article below. Design a cube (30 mm sides) and a cylinder (30 mm diameter, 30 mm height) as two separate parts.
  5. Export them as an STL file in millimeters.
  6. Slice the STL in Bambu Lab studio. Note down the bed temperature and infill density.
  7. Print it with a coordinator present.

Learning Resources

Suggested Focus

Read the Onshape article first, then start designing. Type mm after every number. Keep the cube and cylinder as separate parts. Check that the STL is in millimeters before slicing.

Note: Printing is done only with a coordinator presence.


Task 2: Dynamic Portfolio & Admin Dashboard

Task Description

Design and develop a dynamic personal portfolio website along with an administrative dashboard that allows the portfolio owner to manage website content through a graphical interface without modifying the source code.

The application should consist of two integrated interfaces:

  1. A public portfolio website that showcases the student's profile, skills, projects, and achievements.
  2. An admin dashboard that allows the owner to manage and update portfolio content dynamically.

Requirements

1. Public Portfolio

  • Develop a responsive website displaying the student's profile, skills, projects, and achievements.
  • Retrieve and display portfolio content dynamically through an API.
  • Ensure that changes made through the admin dashboard are reflected on the public portfolio.

2. Admin Dashboard

  • Create a user-friendly administrative interface for managing portfolio content.
  • Implement functionality to add, view, update, and delete projects and skills using forms and controls.
  • Ensure that content management does not require direct modification of the source code.

3. REST API Development

  • Develop and integrate a RESTful API to facilitate communication between the admin dashboard, backend, and public portfolio.
  • Implement appropriate API endpoints and HTTP methods for creating, retrieving, updating, and deleting portfolio content.
  • Exchange data using JSON and implement basic input validation and error handling.

4. Data Management

  • Store and manage portfolio content using an appropriate in-memory data structure or another beginner-friendly mechanism.
  • Ensure that both the public portfolio and admin dashboard access the same application data.
  • Database integration is not required.

5. Deployment and Documentation

  • Deploy the application using suitable hosting platforms.
  • Maintain the source code in a GitHub repository.
  • Document the application architecture, API endpoints, setup instructions, and known limitations in a README file.

Expected Outcomes

  • Understand the development of dynamic and responsive web applications.
  • Learn the fundamentals of REST APIs, HTTP methods, and JSON.
  • Understand CRUD operations and client-server communication.
  • Gain experience integrating frontend interfaces with an API.
  • Develop skills in application deployment, documentation, and error handling.

Suggested Technologies

HTML, CSS, JavaScript, and any suitable backend technology or framework of the student's choice.

Submission Requirements

  1. Public portfolio website URL.
  2. Admin dashboard URL or route.
  3. GitHub repository link.
  4. README documentation.
  5. Screenshots demonstrating content management and dynamic updates.

Resources

  1. MDN: Getting Started with Web Development
  2. Postman: Getting Started Quick Start
  3. MDN: Network Requests

Task 3: Working with GitHub

Familiarize yourself with real-world Git and GitHub workflows including Issues, Branching, Resolving Merge Conflicts, Pull Requests, and GitHub Actions (CI/CD).

Given below is the task repository. Follow the instructions in its README.md to generate your username-specific assignment, document the bugs you find in a GitHub Issue, fix them on a new branch, resolve the practice merge conflict, and open a Pull Request.

What to include in your task report:

  1. The output of python my_task.py showing your assigned functions.
  2. A link to the GitHub Issue you opened and a brief explanation of the bugs you fixed.
  3. A link to your Pull Request showing the passing GitHub Actions check (Note: PRs are verified by CI and left open for review they do not need to be merged).

Check this link for more info: https://github.com/UVCE-Marvel/git-task


Task 4: Hack the hardware

Objective: Ubuntu Command Line: Systems Computing, Architecture & Linux

Core Intention

To move beyond rote command memorization and cultivate a deep, foundational understanding of computing systems, the Linux operating system, and system-level problem-solving. Students learn how and why their terminal commands navigate the software stack—from high-level shell calls down to execution units in hardware.

1. Hardware Foundation & Architecture: "The 'U' in CPU"

Topics & Concepts

  • The Anatomy of the CPU: The Control Unit (CU), Arithmetic Logic Unit (ALU), internal registers (A, D, Program Counter PC), and bus connections.
  • The Fetch-Decode-Execute Cycle: How machine instructions are fetched from memory, decoded by control logic, executed inside the ALU, and written back to registers/RAM.
  • Hardware Abstraction: How shell instructions translate through compiler/assembler pipelines into binary micro-operations that flip physical logic gates.

Why You Need This

Understanding hardware abstraction stops you from treating the terminal as a black box. Knowing how registers, memory addresses, and execution cycles work allows you to diagnose performance bottlenecks, manage low-level system resources, write efficient code, and program embedded microcontrollers or microprocessors effectively.

How to Study This Topic

  1. Nand2Tetris Unit 4 (Machine Language): Write assembly programs for the Hack computer (Mult.asm and Fill.asm) to manually track register states (A, D, M), instruction decoding, and memory-mapped I/O (Screen and Keyboard).
  2. Trace Hardware Metrics via Terminal: Use terminal utilities like lscpu, lsscsi, and cat /proc/cpuinfo to map abstract CPU concepts (cores, threads, cache sizes, architecture flags) to physical host hardware.

2. Operating Systems, Kernels, and Linux Distributions

Topics & Concepts

  • The Operating System's Core Role: Memory virtualization, process scheduling, storage management, and hardware safety.
  • What is a Kernel? The privileged (Ring 0) bridge between user space applications and physical hardware via System Calls (syscalls).
  • Linux Distributions vs. The Kernel: Distinguishing between the upstream Linux kernel and distributions (Ubuntu, Debian, Fedora, Arch) that package userland tools, package managers, and display servers.

Why You Need This

When a application or script crashes, hangs, or fails to start, the issue usually lies in kernel-level resource access, missing dependencies, or system call errors. Understanding OS mechanics enables you to debug real-world server, embedded Linux, and edge-computing environments.

How to Study This Topic

  1. System Call Observation: Run simple terminal commands through strace (e.g., strace ls) to observe how userland utilities request kernel services (e.g., openat, read, write).
  2. Virtual Filesystem Exploration: Navigate /proc and /sys to understand how the Linux kernel exposes running system states directly as text files.

3. The Linux Environment & Core System Concepts

Topics & Concepts

  • Terminal vs. Shell: Distinguishing between terminal emulators (user interface) and shells (bash, zsh — command interpreters).
  • Filesystem Hierarchy Standard (FHS): Root (/), user space (~), device files (/dev), configuration files (/etc), and system binaries (/bin, /usr/bin).
  • Permissions & Security Model: Read, write, execute (rwx) flags, file ownership (user:group), and privilege escalation (sudo).
  • Processes & Signals: Process IDs (PIDs), job control (&, fg, bg), environment variables, standard streams (stdin, stdout, stderr), and piping (|).

Why You Need This

The command line is the primary interface for remote servers, cloud infrastructure, robotics platforms (like ROS 2), and build environments. Mastering streams, permissions, and process controls lets you automate complex workflows and manage systems without relying on a graphical user interface.

How to Study This Topic

  1. Interactive Terminal Scenarios: Solve practical system issues (e.g., permission-denied errors, locating run-away processes with top or ps aux, killing stuck tasks via signals).
  2. Pipe Construction: Practice stringing fundamental tools (grep, awk, sed, cut, sort) together to parse logs and extract target metrics.

4. Practical Tips for Terminal Execution

  • Read the Manual (man): Never guess command flags. Run man (or use tldr ) to inspect flags and syntax.
  • Inspect Exit Codes: Check $? immediately after running a command to see if it succeeded (0) or threw an error (non-zero).
  • Fail Fast & Safely: Use ls or echo to verify wildcard patterns (e.g., echo *.log) before executing destructive commands like rm *.log.
  • Understand Standard Streams: Treat stdout (1) and stderr (2) separately so you don't miss error messages when redirecting logs.
  • Leverage Autocompletion & History: Use Tab key completion to avoid typos and Ctrl + R to search previous command history quickly.

5. Hands-on Problem Statement: System Audit & Log Processing Pipeline

You are tasked with inspecting a remote Linux workstation that has experienced intermittent slowdowns. Without using any Graphical User Interface (GUI), complete the following steps using terminal utilities:

  1. Hardware & Kernel Inspection: Identify the total number of physical CPU cores, architecture model, and the running Linux kernel version. Output these values into a file named system_summary.txt.
  2. Process & Resource Triage: Locate all running processes consuming memory on the system. Filter out system daemons to find the process ID (PID) of the process running under your user space, and write the output to process_audit.log.
  3. Permission & File System Reorganization:
    • Create a secure directory structure under ~/workspace/audit_logs/.
    • Change the directory permissions so that only your user has read, write, and execute permissions (700). Move all generated log files into this directory.
  4. Log Data Parsing & Filtering: Given a system log file containing mixed informational and error entries, write a single-line command pipeline using cat, grep, awk, and sort to extract only unique [ERROR] messages and count their occurrences.

6. What You Must Build

To successfully complete this task, you must build and deliver:

  1. Draw ur own Architecture: So draw how u think the CPU used to look before going through it and how it looks now according to u. Wrong answers welcomed but want to see ur understanding.
  2. Custom Automated Shell Script (system_health.sh): A bash script that gathers system uptime, CPU core count, active memory usage from /proc/meminfo, and active user processes, formatting them into a readable text report.
  3. Execution & Analysis Log Notebook: A written document explaining:
    • The step-by-step resolution of the Problem Statement.
    • Annotations of key strace outputs showing at least two system calls (openat, write).
    • Explanations for why specific piping choices (|) were used during log extraction.

7. Foundational Command-Line Exercises

  • Navigation & Inspection: pwd, cd, ls -la, tree
  • File & Directory Operations: touch, mkdir -p, cp -r, mv, rm -rf
  • Content Viewing & Inspection: cat, less, head, tail -f, echo, grep

8. Resource Links

Computer Architecture & Nand2Tetris

Linux & Command Line Fundamentals

  • The Linux Command Line by William Shotts (Free PDF): Comprehensive reference covering basic shell operations, environment management, and shell scripting.
  • Linux Journey: Interactive, modular guide breaking down Linux command line operations, text manipulation, permissions, process handling, and kernel mechanics.
  • LinuxCommand.org Tutorials: Structured, step-by-step tutorials on command execution, storage navigation, and terminal problem-solving.
  • TLDR Pages: Community-driven, simplified man pages focusing on practical, real-world command usage examples.

Task 5: Operation Blackout

Decode the Hidden Message

An unknown source has transmitted a mysterious sequence of numbers, and your mission is to uncover the secret hidden within it. The data may appear random, but with the right transformations, a meaningful pattern will emerge.

Using NumPy, investigate the encoded array, reshape it into a square matrix, experiment with transposing and reversing its elements, and visualize the result using Matplotlib. Follow the cryptic clues, piece together the original arrangement, and reveal the hidden message!

Can you crack the code and complete Operation Blackout?

Download the Numpy Array: https://drive.google.com/file/d/1lbzxfFuLJSNRXZqT63z8teFWCT44xfRk/view?usp=drivesdk

Learning Resources

NumPy

Matplotlib

YouTube Videos

Suggested Focus

Before solving the puzzle, review array size and shape, reshape(), transpose(), slicing, and reversing with negative-step slices. Then review imshow() and colormaps. Check that the number of array elements matches the target matrix dimensions before reshaping.

Note: The resources are supplementary learning materials. Students should understand and explain the transformations and model operations used in their own solutions.


Task 6: Build Your Own Brain

Linear Regression from Scratch

In this task, you will implement a Linear Regression model from scratch using NumPy to develop a deeper understanding of the underlying principles of machine learning. Using the California Housing dataset, you will train your model using Gradient Descent, investigate the effects of learning rate and feature scaling, and visualize the model’s learning process.

You will then compare your implementation with sklearn.linear_model.LinearRegression using standard evaluation metrics, including MSE, MAE, and R². Through this comparative analysis, you will gain practical insights into model optimization, performance evaluation, and the advantages of established machine learning libraries.

Objective: Develop a fundamental understanding of Linear Regression by implementing, evaluating, and comparing a custom model against a standard library implementation.

Learning Resources

Concepts and implementation

YouTube Videos

Suggested Focus

Start with the linear regression and gradient descent videos before coding. Then implement the model using NumPy, standardize features using training data only, and compare both models on the same held-out test set. Plot the loss over iterations and compare MSE, MAE, and R².


Task 7: Resource Article writing using Markdown

Markdown is an easy-to-use markup language that is used with plain text to add formatting elements (headings, bulleted lists, URLs) to plain text without the use of a formal text editor or the use of HTML tags. Markdown is device agnostic and displays the writing format consistently across device type. Write a technical resource article on a topic of your choice and post it on the MARVEL website. Refer to the linked article for further details.

LINK: https://hub.uvcemarvel.in/article/52f92f36-fb8a-45da-8f28-686bf4efefff


Task 8: Arduino vs ESP32

NOTE - Before working on this task it is mandatory to have read the basics of Arduino Uno and ESP32 task. Without finishing that do not work on this task.

Arduino UNO vs ESP32: Sensor-Based DC Motor Control

Problem Statement

Build a DC motor control system using Arduino UNO R3 and ESP32 to compare their pin configurations, analog inputs, PWM control, and voltage levels. Use an HC-SR04 ultrasonic sensor to measure distance and a potentiometer to control motor speed through a suitable motor driver. The motor must stop when an object comes closer than a predefined distance of 15 cm. Implement the same basic setup on both boards, ensuring that all sensor signals are compatible with the selected board. Finally, extend the ESP32 setup with a web page that allows users to control motor speed using a slider and stop the motor using a button. Identify what additional hardware the Arduino UNO would need to support similar Wi-Fi control.

Tips - Before working on hardware make a simulation for better understanding:

  1. For arduino uno use Tinkercad a beginner friendly web based software for electronics.
  2. For ESP32 use Wokwi simulation another web based software for electronics.

Why You’ll Need This

Arduino UNO and ESP32 can perform similar tasks, but their pin configurations, voltage levels, analog inputs, PWM capabilities, and wireless features differ. A circuit that works on one board may need changes before it can work safely on the other.

Through this task, you will explore these differences by building and testing the same application on both boards. You will also learn why a sensor powered by 5 V may require voltage conversion before its output can be connected to the ESP32's 3.3 V GPIO, and how PWM can be used to control motor speed.

What You Must Build

  1. Sensor and motor control: Connect the HC-SR04, potentiometer, and DC motor through a suitable motor driver. Use the potentiometer to vary motor speed and display distance readings on the Serial Monitor. The motor must stop when an object is detected within 15 cm.
  2. Implement on both boards: Build and test the same basic system using Arduino UNO R3 and ESP32. Identify the required pins and adapt the wiring and code for each board.
  3. Check voltage compatibility: Determine the voltage requirements of each component. Use suitable voltage-conversion circuitry for the HC-SR04 Echo signal when connecting it to the ESP32, and ensure the potentiometer output stays within the board's permitted input voltage.
  4. Add web-based control: Extend the ESP32 program with a web page containing a speed slider from 0% to 100% and a Stop button. The web interface must control motor speed, while the distance-based stop condition must override the selected speed.
  5. Compare the boards: Document the differences you observed in pin usage, analog readings, PWM implementation, voltage compatibility, and Wi-Fi setup. Explain what additional compatible hardware would be required to provide similar web-based control using Arduino UNO R3.

Learn Before You Build

  1. Arduino — PWM Output Guide and ESP32 — PWM Documentation to understand and compare PWM control.
  2. Voltage Divider Tutorial to learn how to reduce a sensor's output voltage safely.

For web servers:-

  1. https://randomnerdtutorials.com/esp32-web-server-slider-pwm OR
  2. https://randomnerdtutorials.com/esp32-web-server-dc-motor-arduino

Work through these resources before starting the implementation. Test the basic circuit on both boards first, then add web-based control to the ESP32. Record your observations and explain the differences you discover.


Task 9: The “Joint” Venture - Soldering

What are you required to do ?

  1. Go around the soldering station, look at all the equipment and try to figure out what they do and what they are.
  2. Gather your domain batchmates and get a one-time briefing from any of your domain coordinators on this task.
  3. Solder a simple circuit (Led Fader Circuit) on a perf-board. To be done Individually.
    • Video Guide: UVCE MARVEL : Soldering on perfboard
    • Circuit link: Tinkercad LED Fade Circuit
    • Refer to the above link for circuit connections.
    • Oscilloscope is optional but using it would get you additional credit points.
    • Components you’ll be requiring = 1nos 100 micro farad capacitor, 1nos 1K resistor, 1nos 10k resistor, 1nos generic PN junction diode, 1nos LED of your choice, 1nos pushbutton (do not use any other kind of switches) and Power supply rated anywhere from 5V - 9V.
    • Check the working of the circuit.
    • Wiring should be done using single stranded wires.
    • Tinning is an advisory method while soldering wires, as it assures contacts are stable and not loose.
  4. Theoretical knowledge buildup - Composition of Solder wire, flux.
  5. Types of board - PCB, BreadBoard, ZeroPCB (Perfboard):
  6. Hazards and Safety measures of Soldering. Resource : https://youtu.be/AqvHogekDI4?si=GofaPrza3gG6vJOZ

Task 10: VRPS, OSCILLOSCOPE

Soon


Task 11: 555 Astable Multivibrator with 60% Duty Cycle

Objective

Design, build and measure a 555 astable multivibrator. By the end you should be able to:

  • Choose the timing resistors and capacitor for a target frequency and duty cycle.
  • Wire the NE555 as an astable oscillator on a breadboard.
  • Measure frequency, high time and duty cycle on a digital storage oscilloscope (DSO).
  • Explain any gap between the designed and the measured values.

The Task

Design a 555 astable multivibrator whose output has a 60% duty cycle, build it on a breadboard, and observe the output on a DSO using the probes.

Pick a target frequency of 1 kHz so the waveform is easy to read on the scope (use another frequency only if your lab specifies one).

Steps

  1. Read first. Go through the resources below until you can write the astable formulas for frequency and duty cycle in terms of R₁, R₂ and C, and explain what charges and discharges the capacitor in each half of the cycle.
  2. Design on paper. From the target frequency and 60% duty cycle, work out the ratio of R₁ to R₂, then choose C and compute the resistor values. Show every step.
  3. Pick real parts. Round your resistors to standard values from the kit and recompute the frequency and duty cycle you will actually get.
  4. Build. Wire the NE555 on the breadboard with a 5 V to 12 V supply, your R₁, R₂ and C, and a small capacitor (about 10 nF) from the control pin to ground. Check the datasheet pinout before powering up.
  5. Probe. Connect the DSO probe to the output pin and ground. Set the timebase so that 2 to 3 full periods are visible, and make sure the probe is in the correct attenuation setting.
  6. Measure. Record the period, frequency, high time and low time, and compute the duty cycle. Use the DSO’s cursors or automatic measurements, and note which one you used.
  7. Compare. Put designed, calculated-with-real-parts and measured values side by side, and explain the differences (component tolerance, probe loading, scope accuracy).

Deliverable

  1. Design sheet (photo or scan is fine) with the equations, the ratio you derived, the chosen component values, and the recomputed frequency and duty cycle for the real parts.
  2. Circuit schematic with all component values labeled.
  3. Breadboard photo of the working circuit with the probe connected.
  4. DSO screenshot or photo showing at least 2 periods of the output, with the measured frequency, high time and duty cycle visible.
  5. Comparison table: designed vs. calculated (real parts) vs. measured, for frequency and duty cycle.
  6. Short answer (3 to 4 sentences): why can a basic 555 astable (two resistors and one capacitor) never give a duty cycle below 50%, and why is 60% reachable without any extra parts?

Resources

Reading

  1. 555 Timer Math: derives the astable frequency and duty cycle, and the formulas for choosing R₁ and R₂ from a target frequency, duty cycle and C. The equations themselves are in images on the page.
  2. Astable Multivibrator using IC 555 (IIT Kharagpur virtual lab): lab-style pre-test on the same experiment.
  3. NE555 datasheet (Texas Instruments): pinout, supply range and the standard astable circuit.

Videos (YouTube)

  1. Astable 555 timer: An amazing video by Ben Eater.
  2. 555 Timer as Astable Multivibrator (Working, Design and Derivations): A second explanation of the same circuit.
  3. Measuring Frequency, Duty Cycle, & Pulse Width: How to read these off a scope.

Tools

A DSO with a 10x probe. Check the attenuation setting and compensate the probe on the scope’s calibration output before measuring.

Optional: simulate the circuit first in Tinkercad Circuits to check your component values before building.


Task 12: Prime Number Detector with a K-Map

Objective

Learn Karnaugh maps from scratch by using one to design a real circuit. By the end you should be able to:

  • Fill a K-map from a truth table.
  • Circle valid groups (sizes 1, 2, 4, 8) and read an equation off them.
  • Explain why grouping works: two cells that touch differ in exactly one input, so that input drops out.
  • Build the result in logic gates and check it against every input combination.

The Task

Design and build a circuit with four inputs D C B A (a 4-bit number from 0 to 15, A is the least significant bit). The output LED turns on when the number is prime. Treat 0 and 1 as not prime.

Do this in Tinkercad Circuits using four slide switches as inputs, one LED as output, and plain gates (AND, OR, NOT) in between. No decoder or other “smart” ICs.

Steps

  1. Read first. Go through the K-map resources below until you can answer: what does it mean for two cells to “touch”, and what are the legal group sizes?
  2. Truth table. Write all 16 rows and mark the output for each.
  3. Raw circuit. Write one AND term for every row where the output is 1, OR them together, and build it in Tinkercad. Count the gates. This is your baseline.
  4. K-map. Fill in the blank map below from your truth table (cell numbers are the decimal value of D C B A).
  5. Group. Circle groups of 1s. Use the largest groups you can, let groups overlap, and remember that the edges of the map wrap around (left touches right, top touches bottom).
  6. Equation. Write one product term per group and OR them.
  7. Simplified circuit. Build it in Tinkercad and count the gates.
  8. Verify. Run through all 16 switch combinations and confirm both circuits match your truth table. Write down your predicted output for 3 inputs before testing them.

Blank K-map (rows D C, columns B A)

+----------+----+----+----+----+
| D C \ BA | 00 | 01 | 11 | 10 |
+----------+----+----+----+----+
|    00    |  0 |  1 |  3 |  2 |
|    01    |  4 |  5 |  7 |  6 |
|    11    | 12 | 13 | 15 | 14 |
|    10    |  8 |  9 | 11 | 10 |
+----------+----+----+----+----+
D C \ B A00011110
000132
014576
1112131514
10891110

Axis order is 00, 01, 11, 10 on purpose, so that neighbouring cells always differ in only one input. Use it as given.

Deliverable

  1. Tinkercad share link (viewable by anyone with the link) containing both the raw and the simplified circuit, labeled.
  2. One sheet (photo or scan is fine) with the truth table, the filled K-map with groups circled, and your final equation.
  3. Prediction table: 3 inputs, your predicted output, and the actual output.
  4. Gate counts: raw circuit vs. simplified circuit.
  5. Short answer (3 to 4 sentences): why can two touching cells be merged into one term?

Resources

  1. Karnaugh map playlist: the main K-map course. Cover the introduction and the 4-variable videos (grouping and wrap-around) before starting the task.
  2. Karnaugh Maps with 4 Variables: a second explanation of the same material, useful if the playlist doesn’t click.
  3. Logic Gates in Tinkercad: placing gates, switches and LEDs and running the simulation.
  4. Digital Electronics: Logic Gates Circuits on TinkerCad (playlist): more Tinkercad gate builds if you get stuck wiring.

Practice

Karnaugh Mapping worksheet (All About Circuits): a few questions to try before you start the task.

Tools

Tinkercad Circuits


TASK 13: Active Participation

Take part in any technical event, inter or intra college and submit the issued certificate of participation.

Enroll for a MOOC and complete the course.


TASK 14: Datasheets report writing

Topics: 1) MQ135 Gas sensor 2) L293D motor driver

Task Description: Study the datasheet of any one of the above and write a report on it. Specify about the ICs used in L293D, PWM, H-bridge etc. In case of MQ 135, specify the calibrations for different gases and the Freundlich Absorption Theorem Graph.


TASK 15: Sad servers - "Like LeetCode for Linux"

Sadservers is an excellent ground to test your Linux troubleshooting skills. Here is a troubleshooting scenario: Command Line Murders. Troubleshoot and Make Sad Servers Happy!


Aviation Domain-Specific Tasks

Task 16: History of Aviation

  • Objective: To learn about the history of Aviation & Drones.
  • Task:
    • Learn about the history of aviation and drones.
    • The resource video presents a concise animated timeline of aviation history. It covers:
      • Early myths and human attempts at flight (e.g., Icarus)
      • The Wright brothers’ first powered flight in 1903
      • Developments during World Wars I & II, including fighter aircraft
      • The invention of jet engines and the rise of commercial airliners
      • The introduction of supersonic flight (e.g., Concorde)
      • The emergence of drones (UAVs) in modern times
  • Outcome: Show your learning in the form of a timeline/flowchart.
  • Platform: Notion for creating the flowchart & Draw.io for editing it.

Resources

  1. Video Resource
  2. Resource Article

Task 17: Introduction to Flight Simulators

  • Objective: To learn manual controls, stability handling, and motor mixing using a drone simulator.
  • Task:
    • Learn about the different channels available in the RC and how to control or maneuver the drone.
    • Learn how each motor affects the roll, pitch, and yaw of the drone.
    • Learn how to connect and set up the TX16S RC to the application.
    • In the simulator, fly the drone in Angle mode, following a specified drone path as instructed by the coordinator.
  • Outcome: Perform the above tasks and write a detailed report.
  • Platform: Real Drone Racing
  • Note: You can use your own computer or the MARVEL systems, but the TX16S MKII should be used only in the presence of aviation coordinators.

Resources

  1. Right way to hold a Tx
  2. What are Channels in a Tx?
  3. Understanding Roll, Pitch & Yaw
  4. Control of Roll, Pitch & Yaw using a Tx
  5. Understanding motor mixing algorithms in a drone

Real Drone Simulator


Task 18: Flying the Airblock Drone

  • Objective: To learn about and operate the Airblock Drone available in the lab.
  • Task:
    • Write a report about the drone which should include the name of the application used to fly the drone, type of motors used, material of the drone, propellers used, battery details, etc.
    • Fly the drone in a certain specified path as told by the coordinator, record it, and put it up in the report.
  • Outcome: Perform the above tasks and write a detailed report in the Blog Post section; provide a link to your blog post in the main report.
  • Platform: MakeBlock App
  • Note: This task should be performed only in the presence of aviation coordinators.

Resources

  1. App Guide
  2. Technicalities of the Drone

Airblock Drone


Level 2


1. Introduction to Aerodynamics and Aircraft Structures

  • Objective: To understand fundamental aerodynamic principles and forces in aviation.
  • Task:
    • Study Bernoulli’s Principle, Newton’s Third Law in aviation, and aerodynamic forces
    • Understand lift, drag, thrust, weight, and stability
    • Learn about primary and secondary control surfaces
    • Do a study about the basic components like pitot tube & radio altimeter.
    • Do a thorough study about the concepts of aviation present in the given resource articles
  • Outcome: Perform the above tasks and write a detailed report.

Resources:

  1. Basics of drone science Part 1
  2. Basics of drone science Part 2
  3. Resource article on general theory of flight
  4. Lift Equation & it's dependencies
  5. Introduction to control surfaces
  6. Pitot tube
  7. Radio altimeter basics
  8. Radio altimeter in-depth


2. Understanding and Designing an Air foil

  • Objective: To understand airfoil fundamentals and perform modeling and CFD analysis.
  • Task:
    • Understand the fundamentals of an airfoil, terms associated with it, the nomenclature, and the concept of turbulence
    • Use Fusion 360 to model a NACA 4412 airfoil of 100 mm chord length & 160 mm airfoil span using DAT to Spline/Canvas tool
    • Simulate lift and drag at 25 m/s wind speed to ensure at least 5N lift using Autodesk CFD
    • Compare results for two materials: composite-based airfoil & wood-based airfoil
    • State the Angle of Attack in your report
  • Outcome: Perform the above tasks and write a detailed report.
  • Platform: Autodesk Fusion for CAD & Autodesk CFD for CFD
  • Note: Fluid Constants for CFD to be used as shown in the resource video.

Resources:

  1. Intro to Airfoil
  2. Parts of an Airfoil
  3. NACA nomenclature
  4. Concept of turbulence
  5. System Requirements for Fusion 360 & Autodesk CFD
  6. Claiming student license in Autodesk
  7. CAD Tutorial
  8. CFD Tutorial

3. Basic UAV Assembly & Components Familiarization

  • Objective: To understand and identify essential UAV components and their compatibility.
  • Task:
    • Identify and understand flight controllers (Pixhawk, APM), ESCs, motors, propellers, and battery management
    • Learn about LiPo, Li-ion, and NiMH batteries, their charge cycles, and safety
    • List all the components required to build a quadcopter with a minimum thrust-to-weight ratio of 3:1, each of the components should be compatible with each other.
    • Perform manual pen-and-paper calculations for flight time and thrust-to-weight ratio using component datasheets
    • Use E-Calc to verify the results
  • Outcome: Create a detailed report justifying each component choice with compatibility proof, it should also contain images of the calculations performed along with the verifications.
  • Platform: E-Calc

Resources:

  1. Basics of Drone
  2. Basics of Propeller
  3. Motor Nomenclature
  4. Technicalities of a BLDC motor
  5. Size & Volume of a motor with it's dependencies
  6. Reason why propeller & motor size should match
  7. Relation between the Kv & torque of a motor
  8. Relation between the 3 constants associated with a BLDC motor
  9. Basics of ESC
  10. Basic terms associated with a battery
  11. LiPo vs NiMH Battery
  12. Combination of LiPo battery
  13. How to choose a battery for the drone
  14. Flight time calculation


4. Propeller Blade Design & Simulation

  • Objective: To understand propeller fundamentals and simulate its aerodynamic performance.
  • Task:
    • Understand the basics of propellers and their nomenclature
    • Learn the need for clockwise and anticlockwise propellers
    • Study:
      • Identification of clockwise and anticlockwise propellers
      • Factors affecting propeller efficiency
      • Conversion from 2-blade to 3-blade propellers
    • Design a 2-blade clockwise or anticlockwise propeller to generate a minimum of 8N lift, also state the diameter of the designed propeller
    • Run a Computational Fluid Dynamics (CFD) simulation ONLY on Autodesk CFD
  • Outcome: Perform the above tasks and write a detailed report, including all the necessary CAD & CFD images.
  • Platform: Autodesk Fusion for CAD & Autodesk CFD for CFD
  • Note: Follow the following instructions for CFD simulation:
    • For boundary condition, on the bottom surface of the external volume, set a constant air velocity of 0 m/s towards the parallel top external surface
    • Set propeller motion to Angular type with 15,000 RPM or 1571 rad/s
    • Use the preview option to verify that motion is applied correctly to the propeller
    • Choose transient mode for solving with:
      • Time Step Size = 0.00025
      • Stop Time = 0.1
      • Inner Iterations = 5
      • Time Steps to Run = 400

Resources:

  1. Basics of Propeller
  2. Real life application of diameter & pitch
  3. Why do we have clockwise & anticlockwise propeller
  4. Checking if a propeller is clockwise or anticlockwise P1
  5. Checking if a propeller is clockwise or anticlockwise P2
  6. 2 Blade Vs 3 Blade Propeller
  7. Conversion between 2 blade & 3 blade propeller
  8. Propeller specs for racing drone
  9. CAD of a propeller


5. Understand about ESC

  • Objective: To control the speed of a BLDC motor using Arduino UNO, ESC, and a potentiometer.
  • Task:
    • Control the speed of a BLDC motor using an Electronic Speed Controller (ESC), Arduino UNO, and a potentiometer
    • Understand the concept of ESC calibration and its significance
  • Outcome: Perform the above tasks and write a detailed report.

Resources:

  1. Task
  2. ESC Calibration

6. RF Communication in UAVs

  • Objective: To understand the principles and protocols of RF communication in UAVs.
  • Task:
    • Learn about radio frequencies & protocols used in UAVs (2.4GHz, 5.8GHz, LoRa, MavLink), along with their inter-connectedness.
    • Understand the various security implications of wireless protocols used in drones, emerging threats, and mitigation techniques
    • Learn about the different protocols used in Tx & Rx like ELRS, Cross fire & 4 in 1. Also, state the importance and advantage of each of these over the others.
    • Learn how to bind an ELRS receiver & bind the 2.4 GHz RP1 Rx with the TX16S transmitter available in the lab
  • Outcome: Perform the above tasks and write a detailed report.
  • Platform: ELRS Configurator for updating the firmware.

Resources:

  1. Basic differences between 2.4 GHz & 5 GHz
  2. LORA in depth
  3. Security concerns with frequency bands
  4. Basics of ELRS
  5. Technicalities of ELRS
  6. Updating the Tx/Rx firmware
  7. Methods to bind an ELRS Rx
  8. ELRS vs 4 in 1 vs Crossfire


7. Basics of PID

  • Objective: To understand PID tuning for stability in UAVs.
  • Task:
    • Understand PID tuning for UAV stability
    • Learn how GPS Hold and Altitude Hold work, tabulate the differences between the two
    • Tabulate the differences between GPS Hold and Altitude Hold
  • Outcome: Perform the above tasks and write a detailed report.

Resources:

  1. Intro to PID
  2. PID controller with the help of a simple analogy
  3. GPS Hold Vs Altitude Hold


8. Different Flight Modes in Mission Planner

  • Objective: To understand the various flight modes available in Mission Planner and their specific applications.
  • Task:
    • Explore, learn & understand the use case of the following flight modes in the Mission Planner software:
      • Stabilize
      • ACRO
      • Altitude Hold
      • Auto
      • Guided
      • Loiter
      • Return to Home (RTL)
      • Circle
      • Land
      • Drift
      • Pos Hold
      • Guided_NoGPS
      • Smart RTL
      • Follow Mode
  • Outcome: Perform the above tasks and write a detailed report.

Resources:

  1. Different flight modes in Mission Planner
  2. ArduPilot Documentation

9. DGCA Regulations:

  • Objective: To understand the legal framework for operating drones in India.
  • Task:
    • Study the Drone Rules 2021 released by the Government of India
    • Learn about BVLOS (Beyond Visual Line of Sight) regulations and how they impact flight planning, airspace management, and safety
  • Outcome: Show your learning in the form of a timeline/flowchart.
  • Platform: Notion for creating the flowchart & Draw.io for editing it.

Resources:

  1. Drone Rules 2021
  2. BVLOS Regulations in India


Level 3


1. UAV Assembly & Flight Controller Configuration:

  • Objective: To collaboratively assemble and configure a fully functional quadcopter with GPS, receiver, and flight controller integration.
  • Task:
    • Use the components finalized in Level 1, Task 3 and get the list approved by the coordinators.

    • Assemble a complete quadcopter as a group, all the batch students should actively take part in the drone building.

    • Bind the drone to the Radiomaster RP1 receiver and control it using the TX16S transmitter.

    • Interface the Mission Planner software with the flight controller using a USB connection.

    • Connect a GPS module to the flight controller and configure it.

    • Calibrate all sensors (accelerometer, compass) and radio inputs.

      (OPTIONAL)

      • Integrate a Lidar or Ultrasonic Sensor with the flight controller.
      • Write and test a basic obstacle detection script that alters the drone's flight path based on sensor input.
  • Outcome: Build, calibrate the drone & prepare a detailed project report in word doc. The report should include the names of all team members, the specific work assigned to each member, and a comprehensive explanation of all technical aspects of the drone from start to finish. Post the report on GitHub (.PDF), ensure the GitHub repository link is posted on the MARVEL website under the corresponding task.

Resources:

  1. ArduPilot tuning Guide P1
  2. ArduPilot tuning Guide P2


2. Autonomous Flight Planning & Execution:

  • Objective: To understand and practice autonomous flight mission planning using Mission Planner and the ArduPilot simulator.
  • Task:
    • Learn about the Heads Up Display (HUD) available in the Mission Planner.

    • Using the built-in Ardupilot simulator (SITL), plan and execute a geofence around UVCE and test a small autonomous mission.

      (OPTIONAL)

      Learn about automated aerial surveying, different modes of surveys available in Mission Planner, and perform a automated aerial survey of UVCE. Execute the flight and analyze logs for accuracy.

  • Outcome: Perform the above tasks and write a detailed report. Video of the automated flight should be included in the report.

Resources:

  1. SITL Setup
  2. Geofencing & Surveying


3. Introduction to MATLAB:

  • Objective: To gain foundational knowledge of MATLAB and Simulink.
  • Task:
    • Complete the MATLAB Onramp course.
    • Complete the Simulink Onramp course.
    • Download and upload both certificates as proof of completion.
  • Outcome: Perform the above tasks and write a detailed report which should include the certificates of completion.

Resources:

  1. Course Link

4. Advanced PID Tuning:

  • Objective: To develop a strong understanding of PID controllers and their application in UAV stability and autonomous control systems.
  • Task:
    • Watch at least the first 5 videos from the provided PID resource playlist, write a detailed report about the learnings.
    • Connect a UAV to Mission Planner and observe the default PID values for roll, pitch, and yaw.
    • Build a self-balancing car that operates using PID control principles.
    • Experiment by adjusting PID parameters (P, I, and D) one at a time and observe the effect on system stability.
  • Outcome: Perform the above tasks and write a detailed report.

Resources:

  1. Recall PID with the help of Chat GPT analogy
  2. PID in depth ~Watch at least first 5 videos
  3. Initial PID setup & tuning in mission planner
  4. Self Balancing Car

5. Rules in the Rule Book Written by Blood:

  • Objective: To explore the methodology behind air crash investigations and learn how aviation safety evolves from past incidents.
  • Task:
    • Take an example of a previous Air Crash from Wyngx or any other source of your choice.
    • Write a detailed report of the air crash investigation, the report should include:
      • Details of the flight, place, time, pilot details and an introductory paragraph about the accident which occurred /was about to occur including the losses occurred.
      • Explain in brief about the aircraft.
      • Using the Swiss Cheese Model analyze the key contributing factors (technical, human, environmental etc.) and also explain how each of these factors (layers of the Swiss Cheese) accelerated the accident when aligned together.
      • State the various theories and assumptions which took place during the investigation and also mention the reasons which led to the elimination/confirmation of these theories.
      • Reflect on what lessons were learned and how aviation standards changed post-accident.
  • Outcome: Perform the above tasks and write a detailed report in Word Doc, post it on GitHub (.PDF), ensure the GitHub repository link is posted on the MARVEL website under the corresponding task.

Resources:

  1. Wyngx or any other source of your choice.


6. Flight Data Logging & Analysis:

  • Objective: To explore the methodology behind air crash investigations and learn how aviation safety evolves from past incidents.
  • Task:
    • Extract log files from a Pixhawk/APM flight controller.
    • Analyze flight stability, GPS accuracy, battery performance using Mission Planner.
    • Generate graphs for:
      • Altitude vs time.
      • Throttle & Battery vs time consumption.
      • Velocity vs time
      • Suggest improvements based on data trends.
    • Also convert the .bin log files to kml+gpx formats and upload the obtained kmz files to Google Earth to view the 3D path followed by the drone. Try to simulate the same flight path on Google Earth using the kmz files, state the problems faced if any.
  • Outcome: Analyze all the 3 LOG files given and write a detailed report.

Resources:

  1. Retrieval of LOG files
  2. Link to LOG files


7. Introduction to ROS 2 for UAVs:

  • Objective: To get started with the Robot Operating System (ROS) 2 ecosystem and understand its application in UAV communication through node-based architecture.
  • Task:
    • Install and set up Ubuntu 22.04 and ROS 2 Humble Hawksbill.
    • Learn the basics of:
      • Nodes
      • Topics
      • Publishers
      • Subscribers
    • Create a Publisher Node that sends fake drone altitude data
    • Create a Subscriber Node that reads and displays this altitude data in real-time (OPTIONAL)
      • Modify the Publisher node to also publish Battery Level data along with the altitude.
  • Outcome: Perform the above tasks and document steps clearly with screenshots and code snippets.

Resources:

  1. Ubuntu 22.04 Setup
  2. Basics of ROS 2 Terms
  3. Multiple terminals using terminator
  4. ROS 2 Setup & Task Tutorial


All The Best!!


UVCE,
K. R Circle,
Bengaluru 01