akbarj

Author: akbarj

  • Trappist-1e: Humanity’s Future Home

    Trappist-1e is one of humanity’s best candidates for a future home. It lies in Trappist-1’s habitable zone, meaning that there is a chance of liquid water, the most important factor to human survival. It’s a rocky planet approximately the same density as Earth.

    Even though Trappist-1e is 39 light-years away, it has many good opportunities for humans. Because Trappist-1e has similar gravity to Earth, humans would adjust easily to the new environment. Trappist-1e and the other planets in the Trappist-1 system have a good chance of having water because they are in the habitable zone and Trappist-1e specifically has a rocky composition similar to that of Earth’s. According to the TRAPPIST-1 Habitable Atmosphere Intercomparison (THAI) project, even with many different atmosphere possibilities, Trappist-1e has a good chance of being livable, the main exception being if it has no atmosphere.

    Settling on Trappist-1e has some serious challenges. The planet may be tidally locked, which would mean that one side is in constant daylight and extreme heat and the other side is in permanent darkness with extreme cold. The only habitable part would be the twilight zone. Another big problem is that we don’t know what type of atmosphere Trappist-1e has, or whether there even is an atmosphere. Based on research by JWST, Venus and Mars-like atmospheres are ruled out, however there are still a few problematic possible atmospheres. Without an atmosphere, humans would experience extreme cold and strong radiation from the Trappist-1 star, which is known to produce strong radiation that could harm people and damage equipment. Because Trappist-1 primarily produces infrared light, agriculture and energy generation would need to be redesigned to work under the low red lighting instead of the Sun’s bright rays.

    The environment has a large implication on vehicle design. Even though humans would live in the twilight zone, travel to the hot and cold sides would be necessary to get resources like frozen water and metals. This implies that vehicles need temperature-control systems. Vehicles would need to be able to handle radiation flares. The atmosphere of Trappist-1e is unknown, but there is a chance that there is no atmosphere at all. If there isn’t, the vehicle must be equipped to handle travelling in an environment like this. Depending on what atmosphere, the planet has, the vehicle should be properly equipped for those conditions. Lastly, they would need to be equipped to drive the probably rugged terrain of the planet.

    In order to build solar-powered vehicles, the design would need to be modified to work with infrared radiation because the Trappist-1 star primarily emits infrared light. Infrared light does not have as much energy as visible light, which means stronger solar panels would be needed.

    Everything we know about Trappist-1e is from telescopes and analyses. It was discovered using the transit method. The transit method works to detect exoplanets by measuring light from a star and when the light gets lower for a bit, it could mean a planet passes over it. If this happens repeatedly in a cycle, it likely means there is a planet. The Trappist-1 system was discovered by the TRAPPIST-South telescope. Later, NASA’s Spitzer telescope captured much more precise transit data which told them about all the planets, their radii, orbital period which is how long it takes for a planet to orbit its star, and that it is likely a rocky planet.

    In 2018, researches such as Grimm et al. published a paper called “The nature of the TRAPPIST-1 exoplanets” documenting how they used something called TTV which stands for Transit Timing Variations to calculate the masses and densities of all Trappist-1 planets. This told us that Trappist-1e has an earth-like density and confirmed it is a rocky planet.

    More recently, the James Webb telescope was used to analyze starlight passing through Trappist-1e’s atmosphere using powerful tools such as NIRSpec, NIRISS, and MIRI. These can determine what gasses are in the planet’s atmosphere. The data says that Trappist-1e likely doesn’t have a Venus or Mars-like atmosphere, however it doesn’t mean that the atmosphere is suitable for humans yet.

    Lastly, there was a large climate modelling project called the THAI project(Trappist-1 Habitable Atmosphere Intercomparison). It was a community project with multiple supercomputers to run multiple GCMs(global climate models).

    Trappist-1e promises a good future for humankind. If we’re lucky, Trappist-1e will be the perfect planet for human beings to settle in the future, once we figure out how to travel to it.

    Reflection on AI Use

    I used AI to help me research about the project and to write the APA sources list. It was very useful to learn specific things that I found harder to find by surfing the web. I also found it very easy for the APA sources because it knows how to do it.

    Transcript: https://docs.google.com/document/d/1PwG_k8H0EBNdnPvLWE5l5KgVPdC9LNNfrlcBej1qcsQ/edit?tab=t.0

    Citations

    Gillon, M., Jehin, E., Lederer, S. M., Delrez, L., de Wit, J., Burdanov, A., Van Grootel, V., Burgasser, A. J., Triaud, A. H. M. J., Opitom, C., Demory, B.-O., Sahu, D. K., Bardalez Gagliuffi, D., Magain, P., & Queloz, D. (2016). Temperate Earth-sized planets transiting a nearby ultracool dwarf star. Nature, 533, 221–224. https://doi.org/10.1038/nature17448

    Gillon, M., Triaud, A. H. M. J., Demory, B.-O., et al. (2017). Seven temperate terrestrial planets around the nearby ultracool dwarf star TRAPPIST-1. Nature, 542, 456–460. https://doi.org/10.1038/nature21360

    NASA. (n.d.). What’s a transit? NASA Science. https://science.nasa.gov/exoplanets/whats-a-transi

    Grimm, S. L., Demory, B.-O., Gillon, M., Dorn, C., Agol, E., Bolmont, E., Delrez, L., Sestovic, M., Triaud, A. H. M. J., Turbet, M., Queloz, D., & Leconte, J. (2018). The nature of the TRAPPIST-1 exoplanets. Astronomy & Astrophysics, 613, A6. https://doi.org/10.1051/0004-6361/201732233

    Fauchez, T. J., Turbet, M., Wolf, E. T., et al. (2020). The TRAPPIST-1 Habitable Atmosphere Intercomparison (THAI) Project: Motivation and overview. The Planetary Science Journal, 1(2), 17. https://doi.org/10.3847/PSJ/ab9ffd

    de Wit, J., Wakeford, H. R., Lewis, N. K., et al. (2018). Atmospheric reconnaissance of the TRAPPIST-1 exoplanets with Hubble. Nature Astronomy, 2, 214–219. https://doi.org/10.1038/s41550-017-0374-z

    Greene, T. P., Tamburo, P., Lustig-Yaeger, J., et al. (2023). Thermal emission from the TRAPPIST-1 system measured with JWST. The Astrophysical Journal Letters, 948(1), L6. https://doi.org/10.3847/2041-8213/acc1e5

    Lustig-Yaeger, J., Grillmair, C. J., Stevenson, K. B., et al. (2023). JWST transit spectroscopy of TRAPPIST-1 c shows no evidence for a thick CO₂-rich atmosphere. Nature, 623, 71–75. https://doi.org/10.1038/s41586-023-06694-0

  • Using Arduino to Build a Simple Robot

    For this project, I built an Arduino robot that detects the proximity of an object. This robot uses sensors to understand its surroundings and gives an output. Even though there is no movement, it is still a robot because it senses its environment and acts upon it.

    I built a proximity-sensing robot. It uses an ultrasonic sensor to measure how close an object is to the sensor. With this it will light up one of three LED lights.

    • Green if object is in a safe distance
    • Yellow if object is getting close
    • Red if object is too close

    At the same time it will turn a servo to a specific direction, representing an very oversimplified way of a car backing into a parking spot.

    My idea is inspired by how parking sensors warn the driver how close they are to something when parking.

    Virtual Prototype

    Below is a video of my virtual prototype.

    The circuit uses:

    • A 4-pin ultrasonic sensor to measure distance through sound waves
    • An Arduino Uno which is the brain behind the whole mechanism
    • LEDs of three colours to represent distance

    When the object comes closer, the Arduino calculates the distance of it by the difference between the time the sound wave is sent and when the echo is received. Then it lights up the specific LED based on the distance and turn the Servo to a specific direction.

    Bill of Materials

    • Arduino Uno R3 x1
    • Ultrasonic Distance Sensor (4-pin) x1
    • 220 Ω Resistor x3
    • Green LED x1
    • Yellow LED x1
    • Red LED x1
    • Positional Micro Servo x1

    Code – how does the code work?

    I learned how to code using Arduino from ChatGPT. I structured my code by starting with setting the wires, then using the Ultrasonic Sensor, and then lighting up the LEDs.

    In this code snippet, the ultrasonic sensor is first set to low, then after 2 microseconds, it is set to high, then set back to low after 10 microseconds.

    Here, pulseIn() measures how long it takes for the sound to travel to the object and back. 30000UL adds a timeout to make sure no errors occur. If duration==0 just restarts the code immediately if no object is detected.

    This line is interesting because it turns time into distance. Sound travels at about 0.0343 cm per microsecond. It is divided by 2 because the sound goes to the object and then back.

    This final code snippet tells the Arduino when to turn on which LED.

    • Green if distance over 30cm
    • Yellow if distance over 15cm
    • Red if distance is less than that
    • It also will turn the Servo to a rotation based on the distance to the object.

    Physical Prototype

    Unfortunately, due to the time constraint on this project, I did not make it to actually building the physical prototype.

    Below is the circuit diagram.

    Reflection

    This was a fun project to do and it taught me a lot. I had never built anything with Arduino, but I’ve heard a lot about them. I used to do robotics in my old school for the VEX V5 Robotics Competition and that taught me a lot of the basic skills for robotics, which were helpful for this project and gave me a leg up in the beginning. However, this was much more realistic and complicated. In VEX, I found it much simpler because they had pieces to build the robots and very comprehensive coding. This was a much newer experience and made me learn a lot more.

    When I was working on this project, the biggest problem I had was actually building the physical prototype. I originally thought I would have enough time, but when I didn’t, that presented a problem where I realized it would make my grade worse on the project, but I didn’t see anything to do. The other problem was that I wanted to include the whole car so it can back up. This was way too much work, so I simplified it to just including a microservo spinning to certain directions depending on the distance to the object to simulate the wheels of a car spinning.

    AI Use & Transcripts

    I used ChatGPT when I was building this project. It was useful to help me find a good idea for the project and to teach me how to code with Arduinos, which was new to me.

    https://chatgpt.com/share/690cdb07-a204-8004-bded-d07880577438

    https://chatgpt.com/share/690cdb8a-574c-8004-8c76-560ebe2d8a90

  • Making Sunglasses Using OnShape CAD Software

    See what I made: https://sgs.onshape.com/documents/5156a498a2aba7f7434cf364/w/bd97c332939ff0f186f17f32/e/bb76bdfb270675c601e3e98b?bomType=structured&renderMode=0&rightPanel=BOMPanel&uiState=68e4ac22145f236ad973de3f

    Our latest project with Fusion was to choose any object and create it with OnShape. OnShape is a CAD software, which means it is meant to be used to create 3D models of things in a computer. This software is useful for 3D printing and industrial manufacturing because you can make one design and then have it be printed or manufactured.

    I, the ambitious person I am, decided to make sunglasses. It took me about 5 hours of learning and 10 hours of designing, but it all came together into a questionable looking pair of sunglasses.

    What I Built

    I built a pair of sunglasses. The design is inspired by one of my sunglasses at home. I like the wide lenses that cover a lot of your face.

    Unfortunately, they do not come with a lens, but they are made as if a lens will go in there. When I built it, I included a slot for the lens to go right into.

    How I Made the Sunglasses

    It took me 10 hours to build the sunglasses because this is my first time doing CAD. It’s harder than it looks, and I learned that the hard way.

    I started by drawing out the shape of the front frame, I left the temple sticks for later as a separate part. I only drew half of it out because I would later mirror it to make the full shape.

    After drawing the shape out, I performed something called extrusion.

    Extrusion is the premise of OnShape and CAD in general. You begin by drawing a 2D shape, and then you extrude that into a 3D shape.

    Next, I work on the holder for the lens. To do this, I cut into the frame just slightly so that there can be a way for the lens to fit right in to the frame. This makes it easier to later work on the lens.

    After the main part of the frame is done, I need to make the “door hinge” part to allow the sunglasses to connect to the temples. To do this I create a small part that sticks out of the frame and put a hole into it.

    This will allow me to soon attach the temples to the sunglasses frame.

    Next I mirror the half over, and I’m done the main frame.

    After mirroring it over, I start to work on the temples. I begin, again, with a sketch of the shape of it.

    This is a very basic sketch but that’s okay because after this, I can extrude it into a 3D version of this that has a Z-axis. Once that is done I can perform something called a fillet which will give the important detail. It turns sharp angles into smooth curves.

    I also add the part that will soon be connecting to the connector part we added earlier to the main frame. The temple is almost done. All I need to do is put the hole down the middle and cut out a section the same size as the connector on the main frame.

    Now our temple is done. To get the temple for the other side, I just duplicated this part studio and mirrored it.

    The next step is to assemble everything together. To do this, we go to the assembly tab and add all the pieces in. Then, we add mate connectors to connect the temples to the main frame.

    And there you have it, a perfect pair of sunglasses.

    Above is the Mechanical Drawing which shows all the angles of the sunglasses from a 2D “Drawing” style which is useful for manufacturers who can easily understand what they are dealing with just by seeing this drawing.

    This is my Bill of Materials(BOM) which has all the information about each part of my sunglasses assembly.

    Reflection

    The biggest thing this project taught me was patience. I kept on trying to go fast and when something wouldn’t work for me, I’d get really annoyed. Slowly as I worked on it, I got better at slowing down, understanding the problem, and building up from there.

    When you understand what specifically you are doing, it is so much easier to fix the problem. When you don’t actually know the problem, then it is just really annoying to do.

    Even though my sunglasses don’t really look good, I am very proud of them because this was my first time doing CAD, and I was able to take this from idea to 3D model and ready for manufacturing, all by myself.

    AI Transcript

    https://docs.google.com/document/d/1vYapEw0pTBEKJ8PKU6ysRHlsPKElSyx76OjCtVkRq8c/edit?tab=t.0

  • Using Flowcharts to Plan and Build a Game with Python

    Try it out: https://colab.research.google.com/drive/12I-ZFEEjzt6dRUjXNlNHPGqkT9HTQBp_?authuser=0#scrollTo=x5tJeoiCjnPT

    Our first assignment in the Fusion 10 class was a freestyle coding project. I set out to make a text-based adventure game. It follows a character who enters the dungeon to get a magic item. But in order to get to the item, they must pass through a number of rooms, with challenges sprinkled throughout.

    Before I began to code, I started with a flowchart. This is an essential part of any coding project because it outlines the project, giving you a focused way to work individually on each part of the project until the whole of the project is complete.

    This flowchart shows the outline of my game idea. Once I had this written out, it made it much quicker to work on the project itself. The coding was very quick and I just went from one part to another.

    The Code

    Once I had a general plan from my flowchart, I just coded a part, tested it, fixed it, and went to the next part.

    Setting the Stage with Variables

    Variables are used to set the state of something. Here, I used the first half of this snippet to set the state of the player.

    • Inventory starts empty.
    • Health starts at 100 and max_health makes sure it can’t go any higher.
    • Gold starts at 0
    • Events is a list of the room options: a monster encounter, a lucky chest, a valuable merchant, or a benevolent healing room.

    The rest after that is lists of items and monsters. Artifacts are used as the item you look for during a quest. The numbers next to them represent how many rooms you need to clear to find the item. After that, it shows the monster or item and the numbers beside them are the stats.

    Talking with the Player

    There are three main functions used to communicate with the player.

    • The typewriter() function gives the game a more interesting way to it by writing the text in a letter by letter way instead of all at once. This makes the game more immersive.
    • The GateKeeper() function is used to keep communication from the gatekeeper consistent.
    • The Game() function is used to keep communication about the game consistent. This is mainly description.

    The player function is important. This is how to receive input from the player to make the game more interactive. It works by receiving an input of a list of options and then the player chooses which option they would like to say.

    Logic Behind the Dungeon Rooms

    For the Chest() room, I wanted it to always give a weapon, a potion and a number of coins. To determine the weapon and potion, it chooses a random one out of the list that we defined earlier as a variable.

    The HealRoom() brings you closer to max health. After a fight with a monster, this is one way to heal your health to prepare for another fight. It works by saving the old health in a variable, then adding the heals to the old health. If that is more than max_health, then it sets health to max_health, otherwise, it just leaves it.

    The Merchant() room is a way for players to buy equipment to keep them better prepared for future fights with monsters. First I define a list of items that you can buy from the merchant. Then, it runs through a loop. It asks what item you would like to buy, then makes sure you have the gold to buy that item. If you do, then it gives it to you and takes away the gold.

    The last and most complicated room is the Monster() encounter room. It first types out the stats of both you and the monster then it does the combat in the combat function, which I will get to later. It then goes on to print if the player won, if the monster won, or if it was a stalemate.

    The Combat Function

    The Combat() function starts by getting the stats of both the player and the monster. Then, it lists out the controls that the player can use. I made combat a turn by turn based fight. The player has the option of all these controls. After the player inputs a move, the monster makes a move and there is a small chance it does a lot of damage.

    The code above is how the game understands what key is pressed.

    • When “c” is pressed, it shows a list of controls
    • When “i” is pressed, it uses a potion on the player to heal
    • When “j” is pressed, it does a simple jab. There is a 10% chance of a critical hit.
    • When “p” is pressed, it does a power strike. There is a 15% chance of a critical hit.
    • When “b” is pressed, it does a block, which negates some damage from the monster.
    • When “d” is pressed, there is a small chance that you will completely dodge the attack from the monster.

    If you choose the wrong control, it means you hesitate and the monster still hits you.

    The Prize Room

    When you complete the specified amount of rooms for your artifact, you are taken to the prize room. It adds it to your inventory and then teleports you back to the Dungeon Master.

    Game Loop

    The game starts by asking the player for their username. Then they are greeted by the Gate Keeper and given their first quest. The game always makes the player go through a chest room then a monster room before starting the random room loop. Then once they go through enough rooms, they are taken to the Prize Room. Finally, they are asked to play again.

    Reflection

    This project was a fun thing to do. I learned how to use libraries I never really used before that much and it made the game so much more interesting. I made sure not to use AI because I like to use ChatGPT to do all the monotonous parts but I forced myself to write all the text myself, and it made the game that much better to make. It is a simple game but it still was fun to make.

    The main thing I learned from this project was the importance of planning before coding. I never really used flowcharts on any of my coding projects but using it genuinely made my job so much easier. I just went from part to part and it was so much faster. I moved so quickly.

    It was fun at the end to see how I had made a game where no two games are exactly the same all because of random chance. This is a very simple concept but I never really have used it like this.

    AI Transcripts:

    https://chatgpt.com/share/68d99155-4e8c-8004-ba9d-9a1ecfc7e132

    https://chatgpt.com/share/68d991c0-f690-8004-8e54-8ec11f457181

  • Still In Development!

    Still In Development!

    I haven’t posted anything yet!