Category: Uncategorized

After much thought, brainstorming, and research, I decided to create a circuit for a fan because quite frankly, my room gets very warm (even during winter time). Of course, without requiring the necessary skills, I would have to learn step-by-step how to make this circuit.

Before attempting to create the fan, I had to learn some basics. I watched a few videos, here is one that helped me the most:

After watching the video and inspecting examples online, I got working. As Mr.Crompton had said in a previous class, there was something called a breadboard; a board used to connect electronic components (wires, resistors, capacitors, and coils) allowing for the conductivity of various experiments and projects. The breadboard is like a soccer field, and the electronic components are like the players. All the players are working together to ensure conductive success (in this case activating the fan).

The breadboard looks like this:

Beside the breadboard (connected via wires) is an Arduino UNO, which looks like this (will elaborate on all the pieces later on):

Connected to the breadboard is an L293D motor driver chip:

And a DC motor (the fan practically):

What does each component do?

Breadboard:

Arduino UNO: The Arduino UNO is like the brain or head of the whole circuit. It is the component that processes all the code I write, which helps the circuit run smoother and operate more efficiently. It is also responsible for sending signals and giving directions to other components like LEDs, motors, or buzzers to perform actions. In my circuit, the Arduino sends a signal to turn my fan on or off.

L293D: The L293D’s job is controlling larger currents and voltages than the Arduino can handle directly. Its many ‘hands’ (as shown by the picture), otherwise known as its input, output, power, and enable pins, all connect wires to different places within the circuit. The wires connected to the L293D in my circuit are meant to direct electricity from the power source to my DC motor on the Arduino’s instructions.

DC Motor: The DC Motor is the component that actually uses the electricity, turning the energy into motion. The DC motor is like the finish line of a marathon and the other working components are like the coaches and guides along the track, making sure the electricity (the runner) reaches the motor safely and fairly quickly. In my circuit, the DC motor is the fan; the component that actually uses the electricity in order to serve its purpose.

TMP: The TMP is the component that measures temperature and activates the fan accordingly. For example, if my room were to become warmer, the TMP would activate other components (and wires), turning on the DC Motor (the fan).

Here is what my circuit looks like (if you want to look at it and experiment yourself, here is the link): https://www.tinkercad.com/things/f53kffusogK-magnificent-lappi/editel?returnTo=https%3A%2F%2Fwww.tinkercad.com%2Fdashboard&sharecode=DcELQL0B3qmmEK7NdFA38dnDWPhRtq6y5R_xpi162y0

As we can see, all the previously mentioned components have a role in my circuit. We can see the Arduino Uno (far left), the breadboard (middle), the L293D (attached to the middle of the breadboard), the DC Motor (top middle), and the TMP (middle left).

Additionally, all the wires (all colour coded based on different positions/purpose) can be seen attached to the different components.

Although not previously mentioned, I have added code to the circuit so everything can run without additional unnecessary parts. I will elaborate more on my code later on.

Here are the colour codes for all of the wires:

Blue = Connected to the L293D

Red = Connected within the breadboard

Green = Connected to the Arduino UNO/the DC Motor

Once I press the “Start simulation” button (top right of the circuit page), the Arduino UNO activates, plugging what I believe is a USB cable into the machine. This activates everything connected to it, which is where the wires come into play.

Here is a picture of the activated Arduino UNO:

Once the Arduino is activated, it releases electricity/power through the connected wires into the components within the breadboard.

The blue wires all connect to the L293D, which was mentioned previously to be the controller of larger currents and voltages.

As you can see in the image below, the L293D possesses many pins or ‘hands’, two of which connect directly to the DC Motor and one connected to the Arduino UNO. The connected wires allow the component to direct the electricity from the power source directly to the DC motor.

All the other seemingly ‘useless’ wires also play a major role in my circuit, as they prevent the L293D from not working or from exploding? Here’s what I mean:

Circuit with breadboard wires (first image) vs Circuit without breadboard wires (second image):

I discovered this by simply experimenting and removing wires that I initially thought were useless, until realizing that they were equally important as the ones connected to the L293D. After researching the purpose of these wires, it appears that they help provide power to the different parts of my circuit, especially the L293D motor driver, which must have its own power connections to work. The red wires distribute power throughout the breadboard so that the L293D and the motor can actually receive electricity, serving a purpose I once questioned.

The TMP plays a major role in my circuit, as it allows the fan to only be activated when a certain temperature is present.

First, the TMP measures the temperature and sends a voltage to the Arduino Uno. Then, the Arduino Uno reads the temperature and decides when to run the DC Motor. The L293D reads the Arduino’s signal and powers the DC Motor with the 9V battery. The fans only turns on if the temperature is high enough.

I added some code to the circuit in order to make less of a mess on the breadboard and make everything easier.

The first part of my code involves these three wires that go from the Arduino to the L293D pins:

int en1 = 5; // PWM pin → L293D Enable 1 (controls motor speed)
int in1 = 4; // Digital pin → L293D Input 1 (controls direction)
int in2 = 3; // Digital pin → L293D Input 2 (controls direction)

These match the L293D’s job:

EN1 = speed control (must be HIGH/PWM for motor to run)

IN1 + IN2 = direction control

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

My next part of the code tells the Arduino:

“I will be sending signals out of pins 3, 4, and 5.”

void setup() {
pinMode(en1, OUTPUT);
pinMode(in1, OUTPUT);
pinMode(in2, OUTPUT);
}

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

The next part of code tells the motor driver to spin the motor forward

digitalWrite(in1, HIGH);
digitalWrite(in2, LOW);

On the L293D, this combo means:

IN1 = HIGH

IN2 = LOW

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

Next, EN1 (the ‘enable 1’ pin on the L293D) receives a PWM signal (Pulse Width Modulation).

Range is 0–255

255 = full power

200 = medium-fast

0 = stopped

This controls how much power the L293D sends to the motor.

So here, the motor runs at speed 200.

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

Both of the “delay” codes don’t do much, other than basically telling the motor to keep running.

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

Finally, the ‘analog’ code tells the motor to stop running by cutting out power.

analogWrite(en1, 0);

void loop() {
int reading = analogRead(tempPin);
float voltage = reading * (5.0 / 1023.0);
float temperatureC = (voltage – 0.5) * 100.0; // TMP36 formula

Serial.print(“Temperature: “);
Serial.println(temperatureC);

if (temperatureC > 30.0) {
// Turn fan ON — clockwise direction
digitalWrite(motorPin1, HIGH);
digitalWrite(motorPin2, LOW);
analogWrite(enablePin, 255); // full speed
} else if (temperatureC < 25.0) {
// Turn fan OFF
analogWrite(enablePin, 0);
}

delay(500);
}

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

This code connects back to the temperature correlating to the DC motor, and how the temperature has to be high enough for the fan to activate.

Arduino UNO

Breadboard

Wires

L293D

DC Motor

Ai usage was minimal. Used it to help me come up with ideas and explain parts of circuits (not necessarily the ones I used in my circuit) and their purposes. Also helped me elaborate on the red wires and their purpose.

Here is a transcript of our chat(s)(on a google doc):

https://docs.google.com/document/d/1V-SQy_JlMjg0pC4guigWR4H_TfZ-3S7ViiJGEYKKPYQ/edit?tab=t.0

According to AI, every wire has a purpose which is something I learned along the way.

How big is the universe?

That is a question many individuals, specifically ones in the space industry, ask themselves. Who knows how many other planets there are in our infinitely expansive universe.

Are there any planets, other than earth, that can be inhabited?

That is another question that many contemplate upon. Can any planets become “liveable”?

In this Fusion/Science project, we are tasked with finding a celestial body (planet, moon, exoplanet, etc) that has hints of habitability and can become habitable by humans. Along with the task of finding an inhabitable astronomical body, we are also tasked with creating a vehicle prototype that could survive the terrain and environment of our chosen planet.

The celestial body I chose was Trappist-1e.

It is a red dwarf exoplanet that resides within the “Trappist 1 system”, a star system 40 light years away from earth and approximately 800,000 years away using current technology. Discovered in 2017, this exoplanet is considered one of the most Earth-like planets found to date due to its gravity, temperature, and physical appearance all being fairly similar to earth’s.

Extra details:

Earth’s Gravity = 9.8m/s^2

Trappist-1e Gravity = 9.12m/s^2

Many opportunities are present on my new home planet.

Research suggests that Trappist-1e orbits in its star’s habitable zone; the region around a star (in this case Trappist-1) where temperatures are suitable for liquid water to exist. Considering how Trappist-1e is the right distance from its star, it could potentially support life and contain liquid water.

Not only is Trappist-1e’s size and gravity similar to earth’s, its mass and density also appear similar to earth’s as well. According to scientists, Trappist-1e has a mass and density that suggests a rocky-ish composition, quite similar to earth’s. If true, this would allow humans to easily adapt to the exoplanet’s environment (unless other challenges exist which is elaborated on later).

Although there are many opportunities that suggest possible inhabitability, there are also many confirmed and unconfirmed factors that could pose challenges.

As mentioned previously, Trappist-1e lies within its star’s habitable zone. However, one side of the exoplanet is always facing its star, “Trappist 1”, while the other side faces away from the star. This causes extreme temperature contrasts between the day and night sides, which poses as a threat to any living thing on the planet. Hypothetically, if humans were to arrive on the planet’s “hot side”, they would be arriving on land with temperatures averaging at 275°C. The “cold side” has an average temperature of around -60 °C.

An unknown factor is Trappist-1e’s atmosphere. We have’t figured out yet whether Trappist-1e has a protective atmosphere or not, or if it’s been stripped away.

A thick, carbon dioxide dominated atmosphere like Venus or Saturn has been turned down by the “James Webb Space Telescope”. Here is a source elaborating more thoroughly on their findings and research: https://news.mit.edu/2025/study-finds-habitable-zone-planet-unlikely-have-venus-or-mars-like-atmosphere-0908

There is a possibility that this exoplanet possesses a secondary atmosphere filled and made with heavier gases such as nitrogen. There is also a possibility that Trappist-1e has no atmosphere at all, which means it experiences frequent extreme temperature swings, possesses no breathable air for life, and is exposed to radiation and vulnerable from impacts within space.

Due to the possibility of no atmosphere, we have to reconsider multiple factors for our vehicle design.

Our vehicle has to be resistant against radiation and will be required to have protective layers against the solar flares and cosmic radiation from Trappist-1e’s star, Trappist-1. Of course, if my exoplanet possesses a substantial atmosphere, these factors would be less critical as the atmosphere would reduce the amount of radiation reaching the surface. Otherwise, lots of exposure to radiation would pose a huge threat to both the vehicle and the person inside (don’t think there would an individual in the vehicle but if there was

As previously stated, the planet possesses extreme temperatures contrasting between the day and night. This means the vehicle would need adaptive heating and cooling systems for both contrasting sides of the exoplanet.

My vehicle will likely rely on nuclear, geothermal, or advanced solar power. Trappist-1e is a red dwarf exoplanet and emits infrared light. Unfortunately, standard solar panels cannot convert infrared light into electricity, which is why we would need advanced solar panels that can convert infrared light into electricity effectively.

Due to the suggested terrain of Trappist-1e (rocky composition), the vehicle will likely have wheels that can quickly traverse the exoplanet and easily stick to the surface without falling over. It is unlikely that the vehicle will float away as Trappist-1e’s gravity is fairly similar to earth’s. However, in the likely event that the planet’s surface is extremely uneven, my vehicle would need strong traction and, if necessary, implemented AI assisted navigation.

Scientists and astronomers have never physically visited Trappist-1e due to it being trillions of miles away from earth. However, we do know a surprising amount about it because of many years of detailed astronomical research and something called “the transit method”.

“The transit method”? What’s that? Apparently, it is an technique used by scientists and astronomers to detect planets outside of our solar system. As of November 10th 2025, over 4,400 exoplanets have been found using this method, which is quite a significant amount. When a planet/exoplanet passes in front of its host star (in this case Trappist-1e in front of Trappist-1), it blocks a small amount of the star’s light, causing a drop in the star’s brightness. Using this slight change in brightness, scientists have been able to determine Trappist-1e’s orbit, size, and whether it lies in the habitable zone (which it does).

NASA elaborates on the method and provides visuals: https://science.nasa.gov/exoplanets/whats-a-transit

Additionally, scientists have been able to use advanced computer modelling and simulations (from the knowledge they already possessed thanks to the transit method) to find the mass of Trappist-1e. One of the most important tools is “Transit Timing Variations”, otherwise known as TTVs.

Tug of war is extremely popular in space, especially in the Trappist star system. The exoplanets within this star system are naturally packed tightly and closely together, which causes them to pull on each other due to gravitational force. This pull of gravity can cause changes in when the exoplanets cross in front of their star, Trappist-1. These variations and change help astronomers calculate the mass of Trappist-1e and understand how the other exoplanets in the system influence each other through gravity.

This website helped me understand it much more thoroughly: https://www.planetary.org/articles/timing-variations

I attempted to use minimal AI and rely on outside sources to fully educate me. However, for building the vehicle prototype, I asked AI how radiation and no atmosphere could possibly influence vehicle precautions in outer space, and how Trappist-1e’s environment might also require specific precautions as well.

Full link to our conversation: https://docs.google.com/document/d/17uuZfIacMdGzRsV9q9geOlx5Xt_jCt8W4O5dDgT7zTg/edit?tab=t.0

Here are all the sources I used for gaining the information I needed:

Matthew W.(22.4.25).”Will we know if TRAPPIST-1e has life?”.Universe Today.https://www.universetoday.com/articles/will-we-know-if-trappist-1e-has-life

MIT News.(Date N/A).”Study finds exoplanet TRAPPIST-1e is unlikely to have a Venus or Mars-like atmosphere”.https://news.mit.edu/2025/study-finds-habitable-zone-planet-unlikely-have-venus-or-mars-like-atmosphere-0908

NASA Science.(8.11.25).”Whats a Transit?”.https://science.nasa.gov/exoplanets/whats-a-transit/

NASA Science.(7.7.25).”TRAPPIST-1 e”.https://science.nasa.gov/exoplanet-catalog/trappist-1-e/

NASA Science.(8.9.25).”NASA Webb Looks at Earth-Sized, Habitable-Zone Exoplanet TRAPPIST-1 e”. https://science.nasa.gov/missions/webb/nasa-webb-looks-at-earth-sized-habitable-zone-exoplanet-trappist-1-e/

NASA Science.(4.2.25).”Largest Batch of Earth-size Habitable Zone Planets Found Orbiting TRAPPIST-1″.https://science.nasa.gov/exoplanets/trappist1/

The Planetary Society.(Date N/A).”Timing Variations”.https://www.planetary.org/articles/timing-variations

All abilities I was able to demonstrate:

Sketching – drawing a 2 dimensional representation of a face in CAD

Sketching was the easiest part by far. I found that it was very simple drawing shapes and lines on Onshape. I was successfully able to draw and use 2d squares, circles, and rectangles in my project.

Extruding – taking a sketch and turning it into a 3 dimensional object

After sketching, extruding was the next part. This step takes any sketch you may have created into a 3d shape. 2d squares, circles, and rectangles became 3d. This really brought my piece to life.

Assembly – taking multiple 3 dimensional parts and sticking them together

This was the most exciting part. After drawing each piece of the stand individually, I was finally able to assemble all the pieces together, creating the stand I aspired to create since the beginning.

Mechanical Drawings – converting your 3 dimensional parts and/or assembly into a 2 dimensional drawing

This was the most difficult part of the process. As previously mentioned, I wasn’t too experienced with OnShape, so when attempting to mechanical draw each piece, I was skeptical.

In OnShape (and the engineering industry), functioning mates are basically the connections between parts in an assembly that define how they move relative to each other.

In my post, I’ve made great use of this feature, allowing all the nails to be able to move up and down, through the holes of the base. Additionally, the cylinder can move up and down into place on the base.

The code below include the sentences that I used for my typing simulator. Every time you run the simulator, the computer will give you one of the following sentences to complete. I made these specific sentences, but any other creative sentences can also work.

import random
import time

sentences = [
“Beethoven, Bach, Haydn, Mozart, Tchaikovsky, and Schubert were all classical composers.”,
“The Flappy Fellow From Fusion Flies Free Forever Flourishing.”,
“Open The Doors, close the doors, OPEN the DOORS, close THE doors.”,
“Real Madrid is a Spanish professional football club based in Madrid.”,
“Chemistry, Biology, Earth Science, and Physics are all topics covered in science.”,
“The Canucks will win the 2026 Stanley Cup.”,
“The Fish and Chips in Ireland sure are the best.”,
“Abra-Cadabra Alakazam, Bing Bong Boom, Eenie Meenie Minie Moe.”,
“Dog goes woof, cat goes meow, cow goes moo, sheep goes baa.”,
“Vancouver is among Canada’s densest and most ethnically diverse cities.”,
“If you want to play soccer, you must play with passion.”,
“Tomatoes are considered fruits, not vegetables.”,
“My name is Darren Entwistle and I am the founder of Telus.”,
“What a beautiful day it is on the beach, here in beautiful and sunny Hawaii.”,
“Peter Piper picked a peck of pickled peppers”,
“The quick brown fox jumps over the lazy dog.”,

When you use “while True:” and then “break” at the start and end of your code (not including the sentences), it initially creates a loop that immediately exits it because of the break statement. This part of my code helps create the “play again” statement. If the user types “yes” when play again appears, the while true will apply, but when the user types no, the “while true” isn’t true anymore, which allows the “break” to take control.

The code below includes the welcoming sentences that guide you through the simulator. This part was the easiest to understand; all I had to do was type – print: (“blah blah blah”) – Then, the sentence in the brackets would appear in the code.

print(“Welcome to Macdara’s Typing Simulator!”)
print(“You will be asked to type a sentence. Your goal is to type as accurately and quickly as you possibly can.”)
print(“There are over 15 different possible sentences that can be generated, each ranging in difficulty.”)
print(“\nType the following sentence as quickly and accurately as you can:”)

This part of my code helped the system choose a random sentence to generate:

sentence_to_type = random.choice(sentences)
print(f”\n{sentence_to_type}\n”)

The code below asks the user to press “Enter” when they’re ready to start typing. It then starts a timer and waits for the user to type a specific sentence – (sentence_to_type, which should be defined earlier in the code) – . After the user finishes typing, it stops the timer, calculates how long they took, how fast they typed in WPM, and how accurate their typing was by comparing it to the original sentence. Then, it prints the results, time taken, WPM, and accuracy percentage:

input(“Press Enter when ready…”)

start_time = time.time()

user_input = input(“Type the sentence above: “)

end_time = time.time()

time_taken = end_time – start_time

word_count = len(sentence_to_type.split())
wpm = (word_count / time_taken) * 60

correct_chars = 0

for i in range(min(len(user_input), len(sentence_to_type))):
if user_input[i] == sentence_to_type[i]:
correct_chars += 1

accuracy = (correct_chars / len(sentence_to_type)) * 100

print(“\n— Results —“)
print(f”Time taken: {time_taken:.2f} seconds”)
print(f”Words per minute: {wpm:.2f} WPM”)
print(f”Accuracy: {accuracy:.2f}%”)

This part of my code was my favourite. Depending on how well the user typed (accuracy, time, WPM), specific sentences (made by yours truly) would generate. I made sure that these comments were appropriate and positive, hoping to encourage the user to practice typing more:

if accuracy == 100:
print(“Congrats on perfect accuracy!”)
if 70 <= accuracy <= 99.9:
print(“Great accuracy, but aim for perfection on your next attempt.”)
if 40 <= accuracy <= 66.9:
print(“Please consider practicing your accuracy.”)
if 67 <= accuracy <= 67.9:
print(“67 67 67 67 67 67 67 67”)
if 0 <= accuracy <= 39.9:
print(“Your accuracy is unacceptable.”)


if 10 <= wpm <= 20.9:
print(“No offence, but you could type a teeny bit quicker.”)
if 21 <= wpm <= 40.9:
print(“Your typing speed is pretty average… work could be done.”)
if 41 <= wpm <= 55.9:
print(“Your typing speed is not too bad, but still consider practicing.”)
if 56 <= wpm <= 66.9:
print(“Your typing speed is good. If you can, try typing even FASTER.”)
if 67 <= wpm <= 67.9:
print(“67 67 67 67 67 67 67 67 67 67”)

if 68 <= wpm <= 80.9:
print(“Your typing speed is excellent. Well done.”)

if 81 <= wpm <= 100.9:
print(“Now this is elite typing speed. Only a small percentage of the world’s population can type this fast!”)
if 101 <= wpm <= 140.9:
print(“Unbelievable typing speed. If you haven’t already, you should really considering going professional.”)

if 141 <= wpm <= 100001:
print(“Your typing speed is inhumane. Focus on Accuracy.”)

In coding, defining a function means creating a named block of instructions that tell the computer what to do when the function is used.

For example: print(“Welcome to Macdara’s Typing Simulator”) – This is a function because it performs a specific task’ printing out a message.

My function in the code is as follows:

def greet(name=”World”):
print(f”Hello, {name}!”)

This function prints a greeting message. If a name is provided when the function is called, it prints “Hello, [whatever the name is]!”. If no name is provided, it uses the default value “World” and prints “Hello, World!”. I use this function to greet the individual wherever he may be on planet earth (unless he is an alien on Kepler-B).

Calling a function means using the function after it has been defined so the computer runs the instructions inside it.

For example, when you write something like: print(“Welcome”) – you are calling the print function. When the program sees this line it runs the function and shows the output.

As previously mentioned, I am a beginner coder and have no past experience using code. If you are in the same position as me, the one thing I would highly encourage is experimenting with code before immediately relying on AI. This was the first thing I did, as it helped me gain an understanding of what I would be working with.

I spent around 5-10 minutes typing in random words, numbers, letters, and even punctuations. I learned that “!”, “print”, and “if” did something, but I wasn’t sure what its purpose was.

Additionally, I learned that in coding, we use functions; self-contained blocks of code primarily designed to perform specific tasks. They are used multiple times in almost all programming languages and serve purposes such as reusability, modularity, and organization. Although I didn’t use any functions, I intend to use some in future projects.

There are also defined functions. These are blocks of code that have a specific person. In my code, I use “print” multiple times throughout my code. It is a defined function and its purpose is to type out a sentence (that I write) for the reader. Keep in mind, there are many defined functions in code.

After this short period of time, I asked AI what these specific words and letters were typically used for. This is when I learned that “print” printed out messages, which is what I used for the sentences the user was meant to type.

In terms of my interactions with AI, I attempted to use it as minimally as possible. I would use AI for educational purposes, not asking for it to write my entire code, but rather write portions I didn’t understand and explain them thoroughly. This way I learned how and what to do rather than mindlessly copying and pasting the code provided by AI.

Some questions I asked AI include:

“How can I track an individuals typing accuracy on a typing simulator using Python code? Explain each step in this process, talking about the terminology you use.”

Link to discussion: https://docs.google.com/document/d/1BPSPAJASfG_QJfsWrDo8nwLABniJ3x1P4WeKXAX6AFs/edit?tab=t.0

“What does _____ mean in coding language? In what ways can it be used?”

Link to discussion: (Same document but further down) https://docs.google.com/document/d/1BPSPAJASfG_QJfsWrDo8nwLABniJ3x1P4WeKXAX6AFs/edit?tab=t.0