What planet did my group choose and why?

Our group chose Callisto, one of Jupiter’s largest moons. It is covered in craters and ice, and its surface hasn’t changed much in billions of years (Schenk, 1995). Because it is far from Jupiter’s strong radiation, Callisto is safer for humans than some other moons, like Europa or Io (NASA Science, n.d.).

Scientists think there may be a subsurface ocean under Callisto’s icy surface, which could contain salts and chemicals that might support tiny life forms (Khurana et al., 1998). Its stable surface and relatively calm environment make it an excellent place for science research, exploring resources for human use, and for humans could live.

What opportunities does Callisto offer?

• Craters and Surface History
  Callisto has over 1,000 craters larger than 10 km(Schenk, 1995). These craters are like a time capsule, saving information about asteroid and comet impacts that happened billions of years ago. By studying them, scientists can learn about the formation and changes of the Solar System.
• Water and Ice Resources
  About 50% of Callisto’s surface is water ice (NASA Science, n.d.). This ice could be used for drinking water, oxygen production, or even hydrogen fuel, making it a valuable resource for long-term human habitation.
• Chemical Composition
  Galileo spacecraft spectrometers detected carbon dioxide (~10^-6 bar), sulphur dioxide (~10^-7 bar), and small amounts of organic compounds on the surface (Hibbitts et al., 2000; McCord et al., 1997). These chemicals provide clues about the moon’s chemistry and could support microbial life in its subsurface ocean.
• Gravity and Movement
  Callisto’s surface gravity is only 0.126 g which is roughly 12% of Earth’s gravity (Zimmer et al., 2000). This means a person weighing 70 kg on Earth would weigh just about 8.8 kg on Callisto. Low gravity makes walking and using tools more difficult, but it also makes transporting heavy equipment and moving large ice blocks easier, which could be helpful for building habitats or exploration bases.

Challenges for Humans

• Extreme Cold: Average surface temperature is about -139°C (-218°F) (NASA Science, n.d.). This requires heated habitats and suits for human activity.
• Thin Atmosphere: Callisto has almost no atmosphere, only a tiny amount of CO₂. Humans must live in pressurized habitats and wear suits to breathe and stay safe.
• Rough Terrain: Craters, ridges, and fractured ice make the surface difficult to drive on, requiring specially designed vehicles (Schenk, 1995).
• Low Gravity Effects: Muscles and bones weaken in low gravity, so habitats need exercise areas and routines to maintain health (Zimmer et al., 2000).

Vehicles and Habitats

• Rovers and Transport: Vehicles need to be light, stable, and capable of moving on ice. Hovercraft or walkers may be more practical than traditional wheels (NASA Jet Propulsion Laboratory, n.d.). However it couldn’t be too light. Engineers would need to design it with a low center of gravity and maybe wide, flexible feet or treads to spread its weight. They might also add anchoring spikes or adjustable weights on the side to help it “stick” onto the terrain when moving or drilling.
• Thermal Protection: Engines, batteries, and pipelines need insulation or heating to operate in the extreme cold.
• Habitat Design: Homes could be buried underground for protection from cold, and radiation. Interiors need handholds, exercise equipment, and low-gravity design adaptations.

How Humans Could Survive on Callisto

Living on Callisto would be challenging but possible with the right technology. With almost no atmosphere and constant radiation from Jupiter, habitats would need to be underground or inside thick ice. The ice could also be melted for water and oxygen, reducing supplies from Earth.

Sunlight is weak, it is only 1/27th of Earth’s, so nuclear power would be the main energy source. Surface temperatures around –140 °C mean heated suits and vehicles are essential. Low gravity (1/8th of Earth’s) makes movement easier but can weaken muscles and bones, so daily exercise would be important.

How We Know About Callisto

Most of what scientists understand about Callisto comes from two major NASA missions: Voyager and Galileo.

• Voyager 1 and 2 (1979)
  These spacecraft took the first detailed photos of Callisto’s surface, showing its huge craters, icy crust, and very old terrain. The images and mission data are publicly available through NASA’s Jet Propulsion Laboratory
  
• Galileo Orbiter (1995–2003)
  Galileo gave scientists much deeper information using its scientific instruments:
• Magnetometer: Detected changes in Jupiter’s magnetic field near Callisto, which suggested a subsurface ocean (Khurana et al., 1998; Zimmer et al., 2000).
  
• Spectrometers: Found CO₂, SO₂, and organic molecules frozen in the surface ice (McCord et al., 1997; Hibbitts et al., 2000).
  
• Surface Mapping: Helped scientists identify over 1,000 large craters and understand Callisto’s geologic history (Schenk, 1995).

APA references

Schenk, P. M. (1995). The geology of Callisto. Journal of Geophysical Research, 100(E9), 19011‑19022. https://ntrs.nasa.gov/citations/19970027091

Khurana, K. K., Kivelson, M. G., Stevenson, D. J., Schubert, G., Russell, C. T., Walker, R. J., & Polanskey, C. (1998). Induced magnetic fields as evidence for subsurface oceans in Europa and Callisto. Nature, 395(6704), 777–780. https://www.nature.com/articles/27394

Zimmer, C., Khurana, K. K., & Kivelson, M. G. (2000). Subsurface oceans on Europa and Callisto: Constraints from Galileo magnetometer observations. Icarus, 147(2), 329–347. https://www.sciencedirect.com/science/article/abs/pii/S001910350096456X?via%3Dihub

McCord, T. B., Carlson, R. W., Smythe, W. D., Hansen, G. B., Clark, R. N., Hibbitts, C. A., et al. (1997). Organics and other molecules in the surfaces of Callisto and Ganymede. Science, 278(5336), 271‑275. https://www.science.org/doi/10.1126/science.278.5336.271

Hibbitts, C. A., Schultz, P. H., et al. (2000). Distributions of CO₂ and SO₂ on the surface of Callisto. Journal of Geophysical Research: Planets, 105(E6), 15,255‑15,273. https://agupubs.onlinelibrary.wiley.com/doi/10.1029/1999JE001157

NASA Jet Propulsion Laboratory. (n.d.). View of Callisto from Voyager and Galileo. NASA / JPL. https://www.jpl.nasa.gov/images/pia01055-view-of-callisto-from-voyager-and-galileo/

NASA Science. (n.d.). Callisto facts. NASA. https://science.nasa.gov/jupiter/jupiter-moons/callisto

Use of AI

For this project I chose to use ChatGPT to help me with my research about Callisto. It helped me find reliable sources, summarize scientific information, and design a concept for an exploration vehicle.

INTRO

For this robotics assignment, I designed and built a motion-activated automatic door using Arduino Uno, PIR motion sensor, and servo motor. The goal of the project was to demonstrate core Arduino skills such as circuit building and coding, while creating a functional robotic device that reacts to human movement. I created and tested the circuit virtually using Tinkercad before attempting real life assembly.

OVERVIEW

The project simulates an automatic door that opens when a person approaches. When the PIR sensor detects motion, it sends a signal to the Arduino, which then activates the servo motor to open the door. After a three-second delay, the servo returns to its original position, closing the door.

CODE

#include <Servo.h>

Servo doorServo;     
int pirPin = 2;        
int pirState = LOW;   

void setup() {
  doorServo.attach(9);   
  pinMode(pirPin, INPUT); 
  doorServo.write(0);   
}

void loop() {
  int motionDetected = digitalRead(pirPin);

  if (motionDetected == HIGH && pirState == LOW) {
    doorServo.write(90); 
    pirState = HIGH;
    delay(3000);         
    doorServo.write(0); 
    pirState = LOW;
  }

  delay(200); 
}

CODE BREAKDOWN

#include <Servo.h>

Servo doorServo;       
int pirPin = 2;        
int pirState = LOW;    

This section includes the servo library, which allows the Arduino to control servo motors. It creates a servo object called doorServo for controlling the door. pirPin defines which pin the PIR sensor is connected to, and pirState keeps track of whether motion has been detected, helping to prevent the door from repeatedly opening when motion is continuous.

void setup() {
  doorServo.attach(9);   
  pinMode(pirPin, INPUT);
  doorServo.write(0);    
}

In the setup() function, the servo is attached to pin 9, which will control the door. The PIR sensor pin is set as an input so the Arduino can read motion detection signals. Finally, doorServo.write(0) ensures the door starts in the closed position when the program begins.

void loop() {
  int motionDetected = digitalRead(pirPin);

  if (motionDetected == HIGH && pirState == LOW) {
    doorServo.write(90);  
    pirState = HIGH;
    delay(3000);          
    doorServo.write(0);   
    pirState = LOW;
  }

  delay(200); 
}

The loop() function constantly reads the PIR sensor with digitalRead(pirPin). If motion is detected (motionDetected == HIGH) and the door is not already open (pirState == LOW), the servo rotates to 90° to open the door. The program waits for 3 seconds before closing the door by returning the servo to 0°. The pirState variable prevents repeated triggering while motion continues, and the delay(200) at the end prevents jitter from rapid sensor signals.

BILL OF MATERIALS (BOM)

Component	Quantity	Function
Arduino Uno	1	Microcontroller board
PIR Motion Sensor	1	Detects motion (input)
Servo Motor	1	Controls door movement (output)
Jumper Wires	6	Electrical connections

VIRTUAL PROTOTYPE

I used Tinkercad to build the first version of the circuit to ensure both the wiring and code worked properly before physical assembly.

The circuit works as follows:

• The PIR sensor detects motion and outputs a digital HIGH signal on pin 2 when movement is detected.
• The servo motor receives control signals from pin 9 to rotate between the closed (0°) and open (90°) positions.
• The Arduino powers and controls both components.

VIRTUAL DEMONSTRATION

Physical Prototype

I went ahead and built the real-life version of the door with the Arduino, servo, and button. Everything was connected exactly like in the virtual Tinkercad version, but when I tried to upload the code, it just wouldn’t work.

The problem was with my Mac, the Arduino IDE couldn’t detect any ports, so the board didn’t respond. Because of that, I couldn’t test the servo in real life. Even though it’s built and wired correctly, I could only fully test it in Tinkercad.

USE OF AI

I used AI mainly to help with the code and clear up a few things I wasn’t sure about. It gave me quick explanations and helped me fix mistakes faster. Overall, it made the project easier to understand and finish.

SUMMARY

This project was especially useful because it taught me things I hadn’t learned in the robotics courses I took before. I learned how to read sensor input with digitalRead(), control a servo with servo.write(), and manage timing using delay(). Even though I couldn’t upload the code to a real Arduino, running the project in Tinkercad helped me understand how everything works together.

For this project, I designed a wheel assembly in Onshape as part of a CAD assignment.

For my design, I am modeling realistic car wheels and an axle, but simplified for this project. It is not a full car or engine just the wheel system. The assembly includes a center disc, wheel rim with brake disc, tire, and axle, and later I copied the wheel to put two wheels on the same axle, allowing me to test rotation of the wheel. The parts should fit together logically, look realistic, and spin properly in the assembly, but they don’t need to handle real forces or loads.

PT1: CENTER DISC

The first part I designed was the center disc, a circular cover that fits into the center opening of the wheel rim.

The center cap disc works well and fits properly, but it’s a bit small compared to the rest of the wheel. Making it larger would help it fill the hub better and make the wheel look more balanced overall. A slightly bigger disc would also be stronger for 3D printing, because thin edges can easily break or warp during printing or handling.

PT2: WHEEL RIM

The second part I designed was the wheel rim, which serves as the main structural component of the wheel, and the brake disc, positioned inside the rim near the hub.

The wheel rim and brake came out looking pretty solid, and they fit together well in the assembly. I like how the cutouts make the rim look realistic, but I think the spacing could be adjusted a bit to make it feel stronger and more balanced. The brake disc lines up nicely with the hub, but it might look better if it were slightly thicker to match the proportions of the rim.

PT3: TIRE

The third part I designed was the tire, which wraps around the wheel rim and provides the interface between the wheel and the ground.

Putting everything we have so far together…

PT4: AXLE

The final part I designed was the axle, which passes through the center of the wheel and connects the assembly to the rest of the mechanism.

The axle functions well and holds the wheel together properly, but it feels a little long compared to the rest of the assembly. Shortening it slightly could make the overall design look cleaner and more compact. The step-downs help with alignment, but maybe adding some small grooves or visual details could make it look more realistic.

PT5: ASSEMBLY

The assembly combines all the components: center disc, wheel rim with brake, tire, and axle. After completing the first wheel, I duplicated it so that there are two wheels on the same axle

The assembly turned out really well, wheels spin smoothly, everything fits neatly, and the design looks solid. Duplicating the wheel was simple but effective, and seeing them rotate together makes the assembly feel complete and polished.

PT6: CONCLUSION

The wheel project turned out really well. Each part, the center disc, wheel rim with brake, tire, and axle, they fit together neatly, and duplicating the wheel to create two on the same axle works smoothly. The wheels rotate properly, and the assembly demonstrates how all the components interact in a functional system. While some details, like the size of the center disc or spacing of the rim cutouts, could be improved, the overall design is realistic, balanced, and visually appealing. This project allowed me to practice all core CAD skills such as sketching, extruding, assembling, creating mechanical drawings, and generating a BOM.

Link to code: https://colab.research.google.com/drive/1zRVT20MhXBPmbU2OTtkjhJy_xtmiKGSi?usp=sharing

I am new to coding, so for my first project, I chose to create a simple Rock, Paper, Scissors game. This game was a good way for me to practice the basics of Python, such as functions, loops, and conditional statements. I also wanted to make sure the program was user-friendly, so I added clear messages, error checking, and a replay option to make it easy to use.

-flow chart of the code

PT.1: FUNCTIONS

def play_rock_paper_scissors():

When the game begins, it prints a welcome message to introduce the game and let the player know they will be playing against the computer.

PT.2: INTRODUCTION AND LOOP

 print("   Let's Play Rock, Paper, Scissors!   ")
    print("You will play against the computer.")

    while True:

When the game begins, it prints a welcome message to introduce the game and let the player know they will be playing against the computer.
Next, I set up a loop using while True, which repeats the game over and over until the player decides to stop. This way, the player can play multiple rounds without restarting the program.

PT.3: PLAYER CHOICE

        player_choice = input("Enter your choice (rock, paper, or scissors): ").lower()

        if player_choice not in ["rock", "paper", "scissors"]:

        print("Invalid choice! Please type rock, paper, or scissors.")

        continue

The input() part pauses the game and waits for the player to type something. The program asks the player to type rock, paper, or scissors. I added .lower() so it works even if the player types capital letters like “Rock.”
If the player types something invalid (like “banana”), the program prints a warning and restarts the round. This prevents the game from crashing and keeps it friendly.

PT.4:COMPUTER CHOICE

        options = ["rock", "paper", "scissors"]
        computer_choice = random.choice(options)

Here, options is a list that stores the three possible choices. random.choice(options) picks one of them randomly. This makes the computer’s choice fair and unpredictable.

PT.5: DISPLAYING CHOICES

    print(f"You chose: {player_choice}")
    print(f"The computer chose: {computer_choice}")

These lines show the player what they chose and what the computer chose, so the player can clearly see both sides before the winner is announced.

PT.6: DECIDING THE WINNER

        if player_choice == computer_choice:
            print("It's a tie! 🤝")

The if statement checks a condition. If it’s true, Python runs the code inside that block. This line checks if the player and the computer chose the same thing. If they did, it prints “It’s a tie!” If they didn’t, Python moves to the next check.

elif (player_choice == "rock" and computer_choice == "scissors") or \
             (player_choice == "scissors" and computer_choice == "paper") or \
             (player_choice == "paper" and computer_choice == "rock"):
            print("You win! 🎉")

elif stands for “else if.” It gives another condition to check if the previous if (or another elif) was false.
This line is checked only if the if condition wasn’t true (so it wasn’t a tie). The program looks at all the situations where the player would win. If any of these are true, it prints “You win!”

        else:
            print("The computer wins! 💻")

The else statement is the catch-all. It runs only if none of the previous if or elif conditions were true.
This means if it wasn’t a tie (if) and the player didn’t win (elif), then the computer must have won. It doesn’t need a condition because it automatically handles all remaining possibilities.

PT.7: PLAY AGAIN OPTION

        play_again = input("Do you want to play again? (yes/no): ").lower()

        if play_again != "yes":
            break

The first line asks for input and converts it to lowercase so that “Yes” or “YES” also works. The second line checks if the player typed anything other than “yes.” If they did, the break command stops the loop and ends the game.

PT.8: ENDING THE GAME

    print("Thanks for playing! Goodbye!")

When the player decides to stop, the program prints a goodbye message to signal the end of the game.

PT.9: RUNNING THE FUNCTION

play_rock_paper_scissors()

This line is important because it actually starts the game; without it, Python would just know the instructions inside the function but would never run them, so the player wouldn’t see or play the game.

Reflection:

In summary, I think I did a great job on this project. Even though it is a simple game, it is fun and interactive, and I am proud of creating it. This project helped me practice basic coding skills like functions, loops, variables, and conditional statements, and it taught me how to make a program user-friendly and responsive to input. It gives me confidence as a beginner in coding.

Welcome to User’s blog Sites. This is your first post. Edit or delete it, then start writing!