Category: Uncategorized

I chose Teegarden’s Star b because it’s one of the closest similar Earth mass exoplanets we’ve found only situated about 12.5 lightyears away, and its size and energy intake makes it one of the more realistic places where liquid water could exist. But choosing a “potentially habitable planet” is only the beginning. If we were ever to send people there, the environment around the Planet would affect our every decision. Its radiation, stellar activity, and orbital conditions all affect how a vehicle must be designed and protected. That’s why we looked at real spacecraft systems and shielding strategies: understanding how current spaceships or rovers survive harsh conditions helps me imagine a vehicle that could actually keep its occupants safe on a journey this long.

Teegarden’s Star b provides opportunities due to its Earth like mass, which means gravity could feel familiar and manageable for human life. Because it receives a similar amount of starlight to Earth, the planet may be able to maintain liquid water and a temperate climate if it has a stable atmosphere. Its close orbit around a faint star could also allow for efficient power generation using infrared optimized solar technology. Overall, it presents a promising environment for scientific exploration and potential colonization.

One major challenge is that the planet orbits extremely close to its small star, making tidal locking highly likely meaning one side may be in permanent daylight while the other remains dark. This could create extreme temperature differences and atmospheric instability. Red dwarf stars also emit strong solar flares and radiation that could strip away a planet’s atmosphere. Because the planet does not transit its star, we still do not know its radius, atmosphere, or true surface conditions, adding large uncertainties to any colonization plans.

Designing a vehicle for a journey to Teegarden’s Star b means preparing for an environment harsher than anything experienced on Earth. The ship isn’t just used for transportation, it is the only barrier between the crew and constant radiation, freezing temperatures, micrometeoroids, and complete isolation.

Radiation is one of the biggest threats in deep space. Without Earth’s magnetic field or atmosphere, the crew would be exposed every day, so the vehicle needs several layers of protection. Hydrogen rich materials like water or polyethylene can be placed around the living areas to block high energy particles. Using a layered combination of lighter and heavier materials helps reduce different kinds of radiation without creating harmful secondary effects. The ship would also need a small, heavily protected “storm shelter” where the crew could stay during bursts of radiation from the star. Even basic elements of the ship, like water tanks or fuel storage, can be arranged around the cabin to add extra shielding without adding much mass.

The structure of the vehicle also has to survive meteoroid impacts and major temperature swings. Materials such as aluminum lithium alloys, carbon composites, and multi layer insulation help the outside of the ship stay both strong and lightweight.

Power and reliability are another major challenge. Because a mission like this would last decades, all systems need to be redundant, modular, and able to withstand years of radiation exposure. This is one reason I looked at the computers used on missions like the Mars rovers. They show how engineers design hardware that keeps working in extreme conditions and gave me ideas about how similar systems could be protected on our vehicle.

Scientists discovered Teegarden’s Star b using the radial velocity method , where precision spectrographs like CARMENES detect tiny wobbles in the star caused by orbiting planets. Follow-up observations from instruments such as ESPRESSO, MAROON-X, and TESS refined the planet’s orbital period (4.9 days), minimum mass (approx 1.1 Earth masses), and its possible position in the habitable zone. Climate models and computer simulations have explored whether it could support liquid water. The main scientific reports detailing this are Zechmeister (2019), whom first announced the discovery, and Dreizler (2024), whom revisited the system with newer data.

Teegarden’s Star b stands out as a realistic but challenging candidate for future exploration or settlement. Its Earth like mass and position near the habitable zone offer promising opportunities, yet its close orbit, possible tidal locking, and uncertain atmosphere require advanced engineering solutions. The vehicle design formulas covering radiation shielding, power generation, and torque requirements highlight at how scientific principles guide every part of mission planning. Although many conditions remain unknown, the research methods used to study the planet provide increasingly precise data, allowing us to design smarter, safer systems for operations on a world so different from our own.

Boukrouche, R., Caballero, R., & Lewis, N. T. (2025). Near the runaway: The climate and habitability of Teegarden’s Star b. The Astrophysical Journal Letters, 993(1), L19–L19. https://doi.org/10.3847/2041-8213/ae122a

vWard, C. (2024, August 22). Where we would send the Ark: The best exoplanets within 25 light-years. SYFY. https://www.syfy.com/syfy-wire/the-best-exoplanets-within-25-light-years

Wikipedia Contributors. (2022, November 13). Teegarden’s Star b. Wikipedia; Wikimedia Foundation. https://en.wikipedia.org/wiki/Teegarden%27s_Star_b

Zechmeister, M., Dreizler, S., Ribas, I., Reiners, A., Caballero, J. A., Bauer, F. F., Béjar, V. J. S., González-Cuesta, L., Herrero, E., Lalitha, S., López-González, M. J., Luque, R., Morales, J. C., Pallé, E., Rodríguez, E., Rodríguez López, C., Tal-Or, L., Anglada-Escudé, G., Quirrenbach, A., & Amado, P. J. (2019). The CARMENES search for exoplanets around M dwarfs. Astronomy & Astrophysics, 627, A49. https://doi.org/10.1051/0004-6361/201935460

In this robotics project, I built a system that uses a servo motor and LEDs controlled by potentiometers through Arduino and Fusion. The goal was to make the motor move and lights react based on the input values from the sensors. The code reads and maps the analog signals from the potentiometers, then decides how the lights and motor should respond. I learned how coding connects with physical movement, how to use the Servo library, and how to debug and adjust the program to make everything work smoothly. This project helped me understand how sensors and code can work together to create smart, moving systems.

Goal
Your task is to stop the fan (servo motor) by correctly adjusting two knobs (potentiometers) in the right sequence.

Instructions

Final stage
Once all stages are completed correctly, the Serial Monitor will display Open and Turn
This means the fan is unlocked and you have successfully completed the puzzle.

Start the game
When the circuit is powered, the LEDs will blink to show it is ready.

Identify the knobs
There are two knobs: left (A0) and right (A1).
You will need to turn these knobs to the correct positions in each step.

Observe the LEDs
There are three LEDs (pins 9, 10, and 11).
The LEDs will light up or flash to indicate progress or mistakes.

Adjust the knobs
Turn the knobs slowly and carefully to find the correct position.
The first correct combination will make certain LEDs turn on.

Advance through the stages
Each stage has a new combination.
Correct positions will change the LED patterns.
Move to the next stage once you see the correct LED signals.

Avoid traps
If the right knob (A1) is turned into the wrong range at the final stage, the system will reset and display a trap message.
You will need to start from the beginning if this happens.

I have not used any sort of AI too much or at all for this project as it was not really that big of a help for me. I did take inspiration from people who are experts in Arduino and Tinkercad and from the extensive gallery available on TinkerCAD.

Through this robotics project in Fusion, I successfully developed and tested a moving motor system using code that controlled its movement and direction. Throughout the process, I learned how to decipher, troubleshoot, and optimize motor control code, as well as how small changes in programming can significantly affect the robot’s performance. This project helped me better understand the connection between coding and mechanical motion, strengthened my problem-solving skills, and gave me hands on experience with robotics design and programming integration. Overall, it was a valuable learning experience that deepened both my understanding in Coding in C++, and also my feel for more hardware related objects such as building the actual circuits and motors.

This device is like an electronic puzzle lock that reacts to two knobs, three LEDs, and a servo motor.

When you turn it on, the servo resets to 0 degrees and the LEDs flash a few times as a startup sequence. This shows that the system is awake and ready.

The two knobs are read continuously. Their positions are converted into a range that the Arduino understands so it can tell what positions are correct. Small messages appear in the serial monitor to show the knob positions.

Each knob has a corresponding LED. If a knob is turned to the correct range, its LED lights up. If not, the LED stays off. When both knobs are in the right positions at the same time, the device moves to the next stage.

The device has five stages, each with a different visual or movement effect. In the first stage, the LEDs blink with a soft signal to show that this step is correct. In the second stage, the LEDs blink faster to indicate progress. The third stage has another blink sequence to prepare for the main action. In the fourth stage, the LEDs alternate in a pattern, like a small light show. In the fifth and final stage, the servo reacts to the knob and the device can be fully “unlocked.”

There is also a trap check. If the wrong combination is tried at the final stage, the device resets itself. The LEDs turn off and the servo goes back to 0 degrees. This makes sure the game is not luck based.

In the last stage, turning one knob moves the servo as if you were turning a real lock mechanism. This makes the system interactive because your movements directly control the device.

1. Variable Declarations
   These lines create all the variables the code will use later:

int potD = 0;
int potE = 0;
int led1 = 0;
int led2 = 0;
int led3 = 0;
int i = 0;
int PDsup = 0;
int PDinf = 0;
int PEsup = 0;
int PEinf = 0;
int j = 0;

Each variable starts at 0. The word “int” means it stores a whole number. I use these variables to keep track of sensor readings, LED states, and any values I calculate while the program runs.

2. Servo Library
   This line tells the Arduino to load the Servo library, which allows the code to control servo motors. Without this, the servo commands wouldn’t work.

void loop()
After setup is done, the loop() function repeats over and over for as long as the Arduino is on. This is where the main logic of the project happens, like reading sensors, updating LEDs, and moving servos. Anything inside loop() runs continuously.

void setup()
This function runs one time when the Arduino starts up. Inside setup, I usually set pin modes, attach servos, and start serial communication.

The loop starts by reading the two knobs (A0 and A1). Their 0–1023 values get mapped into a range controlled by j and k, which change as the stages advance.

The program checks whether each knob is inside its current “target” range. If a knob is inside the correct interval (potD in PDinf–PDsup or potE in PEinf–PEsup), its corresponding LED state becomes 1. Otherwise it becomes 0. This is how the system knows if each knob is dialed correctly.

When both knobs hit their correct ranges at the same time, the system moves to the next stage. Each stage is represented by led3. Stage numbers go 1 → 2 → 3 → 4 → 5.

Stage transitions:

• Stage 1 to Stage 2: Both LEDs are 1. The program shrinks the knob range to 0–7, sets led 3 to 2, turns off all LEDs, and plays a fade-in/fade-out effect on LED pin 10.
• Stage 2 to Stage 3: Both LEDs are 2. The program sets new ranges (left knob 0–7, right knob around 173–180), switches led3 to 3, and blinks LED pins 9 and 11 five times.
• Stage 3 to Stage 4: Both LEDs are 3. LED pin 10 blinks ten times, led3 becomes 4, and the knob ranges change again (left ~153–160, right ~23–30).
• Stage 4 to Stage 5: Both LEDs are 4. The program switches led 3 to 5, updates ranges again (left ~85–93, right 0–7), and plays an alternating light pattern between LED pins 9, 10, and 11.

Final stage (led3 = 5): When both LEDs are 5, the system unlocks. ACESSO becomes HIGH, the knob mapping range becomes 0–90 for the servo, and potD starts controlling the servo. The program prints “OPEN” and asks you to turn the knob.

However, the other knob (potE) becomes a trap during this stage. If potE enters certain forbidden zones (0–40 or 50–89), the program prints “IT’S A TRAP!”, resets the servo to 0, resets the knob ranges, resets led3 to 1, turns off all LEDs, and the entire puzzle restarts from the beginning.

Finally, there is a short 10 ms delay to prevent the loop from running too fast.

Inside loop(), the Arduino constantly reads the two knobs and checks whether each one is turned into the correct range. If a knob is in the right spot, the program marks it as correct; if not, it resets that status. When both knobs are correct at the same time, the system moves to the next stage. Each stage tightens the knob ranges and displays a different LED pattern to show progress.

As the stages advance, the target ranges get narrower and the LED effects change. After passing through all four stages, the system reaches the final one, where turning one knob controls the servo. The other knob becomes a trap, if you move it into certain positions, the whole system resets and you have to start over.

For my CAD project, I decided to create a design of a robot arm in Onshape. As a beginner, I was new to the world of computer aided design, so I relied on AI tools such as Notebook LM and ChatGPT to guide me and help me learn the basic functions and techniques. By using these tools, I was able to explore sketching, extruding, and shaping 3D objects, gradually building my skills while completing the project. This experience not only introduced me to the fundamentals of CAD but also allowed me to see how AI can support learning and problem-solving in design.

As Thomas Edison once said, “Genius is one percent inspiration and ninety-nine percent perspiration,” and this project showed me how effort combined with guidance can lead to meaningful and powerful results.

Working on this CAD project in Onshape was a really awesome experience for me. At the start, I was a complete beginner and didn’t know where to begin, but by using AI and tutorials, it really helped me figure out the basics step by step. I learned not just how to use the tools, but also how to think like a designer, planning, testing ideas, and improving my work along the way. It was exciting to see my sketches turn into real 3D models, and even more satisfying to solve problems I didn’t know I could. Overall, this project taught me patience, creativity, and the value of learning through trial and error, and it definitely makes me feel more confident about exploring CAD in the future.

For my CAD project, I designed a robot arm using Onshape. I started by sketching the main parts of the arm, such as the base, joints, and segments, making sure all the dimensions were accurate. Then, I used the extrude tool to turn those sketches into 3D parts. Once all the pieces were finished, I assembled them using different mates such as the revolute mate (which makes the different pieces stick together) to make sure the arm could move realistically.

After completing the assembly, I created a detailed mechanical drawing that included important dimensions and a Bill of Materials listing all the parts. This project helped me understand how sketching, extruding, and assembling come together to create a working design, and it showed me how important precision and planning are in mechanical design.

“Programs must be written for people to read, and only incidentally for machines to execute.” — Harold Abelson

Welcome to my first coding project! This project signifies the beginning of my journey into programming and computational knowledge with the language of Python. As someone new to Python coding, I am excited to explore the immense potential of Python, a versatile and beginner friendly language. I will use these skills to solve problems and create meaningful programs.

Throughout this project, I aim to develop my understanding of basic programming concepts such as variables, loops, conditionals, and functions, while also nurturing curiosity, persistence, and logical thinking. I hope that this piece of work not only demonstrates my learning progress but also reflects my passion for technology and STEM in general.

As Steve Jobs once said, “Everybody in this country should learn to program a computer… because it teaches you how to think.” With that in mind, this project is my first step toward thinking like a programmer, embracing challenges, and building skills that will last my lifetime.

1. Modules

• import random → lets the game choose random numbers for attacks, healing, and enemy selection.
• import time → allows the game to pause for a short time to print text slowly and make it dramatic.

2. Functions

slow_print(text, delay=0.03)

• Prints text character by character instead of all at once.
• text → the message to display.
• delay → how long to wait between characters (default 0.03 seconds).

choose_enemy(defeated_enemies)

• Makes a list of all possible enemies with their name, HP, and attack power.
• Checks defeated_enemies to see which enemies are still available.
• Returns a random enemy if there are any left, otherwise returns a Dragon.

player_attack() / player_special()

• player_attack() → normal attack, deals 8–15 damage.
• player_special() → stronger attack, deals 20–30 damage.

enemy_attack(enemy) / enemy_special(enemy)

• Damage depends on the enemy’s attack stat.
• enemy_special() is stronger than enemy_attack().

3. Player Variables

player = {

    “name”: input(“Enter your hero’s name: “)

    “hp”: 100

    “level”: 1

    “xp”: 0

    “gold”: 0

    “special_cooldown”: 0

• name → player’s input
• hp → player health points. Starts at 100
• level → starts at 1, increases with XP
• xp → experience points earned from defeating enemies
• gold → currency gained from enemies
• special_cooldown → how many turns until player can use special attack again
• defeated_enemies = [] → keeps track of which enemies have already been beaten

4. Main Game Loop

• Uses while True: to keep the game running until player quits or dies
• Shows player stats and asks for an action: explore, rest, or quit

Player Actions

1. Quit → stops the game.
2. Rest → heals 10–25 HP (but not over 100) and reduces special cooldown by 1
3. Explore → chooses an enemy and enters a combat loop

5. Combat Loop

• Continues while enemy HP > 0 and player HP > 0
• Player chooses: attack, special, or run

Player Choices

• Attack → normal damage, subtract from enemy HP
• Special → stronger attack, only if special_cooldown is 0; sets cooldown to 3 turns
• Run → 50% chance to escape
• Invalid input → asks again

Enemy Turn

• Dragon has a 30% chance to use special attack
• Otherwise, enemy does normal attack
• Damage is subtracted from player HP
• Player’s special cooldown decreases each turn if above 0

6. After Battle

• If enemy dies → gain XP and gold
• If XP ≥ level × 50 → level up, reset HP to 100
• If Dragon dies → win the game
• If player HP ≤ 0 → game over

7. Loops and Conditionals

• while True: → main game loop
• while enemy[‘hp’] > 0 and player[‘hp’] > 0: → combat loop
• if / elif / else → checks player input and enemy actions
• for char in text: → used in slow_print to print each character

8. Randomness

Run chance

random.randint(a, b) → random integer between a and b

Used for:

Player and enemy attacks

Healing

Enemy selection

This Python program is a text-based adventure game that runs entirely in the console. It uses functions and loops to create an interactive battle system.

The player controls a hero with stats like HP, level, XP, and gold, all stored in the code. You can choose to rest, explore, or quit. Resting increases HP and decreases your special attack cooldown. Exploring triggers a random encounter with an enemy, selected from a list using the random module. Each enemy also has its own dictionary containing its name, HP, and attack power.

During battle, a while loop does the combat every turn. You can pick from three actions: attack, special, or run. Regular attacks deal random damage using random.randint(), while special attacks are stronger but it requires waiting a few turns before you can reuse it. Enemies also attack each round, and their damage is randomly calculated within a range.

When an enemy is defeated, you earn random amounts of XP and gold. If your XP exceeds a threshold (which is based on your level), you level up, your HP refills, and the game gets progressively harder. The program keeps track of all defeated enemies, and once you’ve beaten them all, you’ll face the final boss, the Dragon.

If your HP drops to zero, the game ends with a “Game Over.” Beating the Dragon prints a victory message and ends the main game loop.