Project 1
Module 1
ACTIVITY 1 (WEEK 2)
This activity began with a hands-on introduction to basic Arduino connectivity. Using a USB-C dongle, I successfully connected the Arduino Uno to my laptop and began exploring the Arduino IDE. Initial experiments involved simply powering an LED by connecting its shorter leg (learned this is called a cathode) to GND and the longer leg (anode) to digital pin 13, followed by uploading a basic sketch to make it blink. This involved learning essential IDE functions—verifying, uploading, using the serial monitor, and ensuring the correct port and board were selected from the dropdown menu. We also touched on the importance of baud rate synchronization, as the serial monitor is unidirectional and requires aligned settings for clean communication.
From there, we leveled up by introducing the breadboard—a component I’m still deepening my understanding of. I learned that the breadboard is split into two horizontal halves, separated between rows E and F, with vertical rails on either side typically marked with red (power) and blue (ground) lines. I explored how to distribute power from the Arduino to the breadboard’s rails and then into components using male-to-male jumper wires and resistors. This included learning how to power LEDs through the breadboard, and eventually adding a push-button that could control when the LED turned on.
This revealed a crucial insight: the push-button must straddle the middle channel of the breadboard to function properly, with each leg aligned to a power and ground. I learned that the button also needed its own power path and that resistor placement was essential to regulate current and ensure stability. Once the button was integrated, the power flow became more complex—coming from the Arduino into the breadboard rails, and then into the components through various mappings.
We also expanded to powering two LEDs, each wired with its own resistor, further solidifying my grasp of parallel vs series layouts, current directionality, and the importance of grounding. This marked a shift from using the Arduino simply as a power source to building basic interactive circuits. While the core logic structure in code remained relatively simple (setup() and loop()), the physical layer demanded increasing clarity and intentionality.
I was prompted to create a ‘to-do’ list in further exploring the following (which will be tackled throughout my studies):
1. Breadboard Architecture
• Investigate the internal connection paths (rows vs columns).
• Learn what happens when components straddle vs when they don't.
2. Circuit Mapping & Flow (future study)
• Diagram how current flows from the Arduino → breadboard rails → LED/button → ground.
• Learn how to read and draw basic schematics.
3. Code & Circuit Integration
• Explore how changes in code (e.g. digitalRead, digitalWrite, delays, if statements) directly affect physical components.
DEEPER INSIGHTS:
Breadboard Anatomy
Horizontal Power Rails (Top and Bottom)
• The red line: + (positive voltage)
• The blue line:– (GND / ground).
• These lines run horizontally, left to right, across the board.
• Each hole along that red or blue line is connected electrically across the full length of the rail.
Terminal Strips (The Grid: A–E | F–J)
• Main working zones.
• Columns (numbered 1–60): Each column (ie column 15) has 5 holes on the left (A–E) and 5 on the right (F–J).
• Important to note:
-Rows A–E are connected together in a vertical column.
-Rows F–J are also connected together, but separately from A–E.
-The middle divider between E and F is not connected—this is called the "trench".
Buttons Across the Ravine
• Most push-buttons have four legs: two on each side.
• Each side is internally connected horizontally (across rows), but not across the ravine.
• So placing the button to straddle E and F ensures that:
-One side connects to power
-The other side connects to an input pin or resistor to GND,
-When you press the button, you bridge the two—completing the circuit.
Resistors
• Resistors limit current. Without them, an LED can burn out from too much power.
• One end of the resistor connects to the LED’s longer leg.
• The other end connects to either ground
Activity 1 annotated images
ACTIVITY 2 (WEEK 3)
In week three, we explored ProtoPie, a powerful no-code interaction prototyping tool that allows designers to simulate and test complex interactions in real time—both on screen and through connected devices. We began by importing designs from Figma into ProtoPie and learned how to add interactions directly to objects and layers. Using ProtoPie Connect, we established live connections between our prototypes and mobile devices via USB or Wi-Fi, enabling us to preview and test dynamic flows without writing any code.
One of the most exciting extensions was integrating Arduino hardware with ProtoPie. This unlocked the ability to use physical sensors—extending interaction beyond phone gestures into the real world. We created ProtoPie accounts, completed the ProtoPie 101 crash course (which took around six hours), and joined the shared Enterprise group using a class email.
For the first Arduino-based activity, we connected an Arduino Uno with a Seeed Studio Sensor Shield, allowing us to hook up a temperature/humidity sensor and a potentiometer. To enable communication between Arduino and ProtoPie, we downloaded several required libraries and ensured our Arduino sketch remained actively running. One critical insight was understanding that serial communication is unidirectional per connection—meaning we had to disconnect the Arduino Serial Monitor in order to let ProtoPie Connect receive data. Since the serial port can only talk to one software at a time, this setup forced us to respect data channel exclusivity.
After linking ProtoPie Connect with our Arduino and setting up the proper cloud project, we successfully transmitted sensor data (like potentiometer values) into a live ProtoPie interaction. This experience was a significant leap—from screen-only UX design into embodied, sensor-driven interaction design.
Activity 2 annotated images
ACTIVITY 3 (WEEK 4)
In week four, we began stepping into the mesmerizing world of TouchDesigner, learning how to connect it with Arduino and exploring the dynamic interplay of light, sensors, and space. The class began by demystifying projectors—a foundational tool in projection mapping. We discussed various types, including standard, short throw, and ultra-short throw, and how throw distance determines where a projector needs to be positioned relative to the surface. We also explored lumens (brightness), laser projectors, and pico projectors, as well as learned that Sheridan has a number of projectors students can potentially sign out.
This opened a gateway into the expansive world of projection mapping, which has been of deep personal interest. We looked at case studies that truly inspired me, including the mind-blowing live visuals in Amon Tobin’s iSAM tour, which fused music, 3D mapped architecture, and immersive sound design. We also explored Moment Factory, a leading multimedia studio in Montreal that creates groundbreaking interactive and projection-based installations across the globe. These examples, along with the upcoming Nuit Blanche festival in Toronto, reminded me how media art can transform public space into a story.
We then shifted into the software realm, downloading and exploring the interface of TouchDesigner, a node-based visual programming tool used in real-time projection, live shows, and generative art. We learned about the network editor, the timeline, and how to place and connect operators. These include:
• TOPs (Texture Operators for image and video),
• CHOPs (Channel Operators for data like audio and sensors),
• SOPs (Surface Operators for geometry),
• COMPs (components to organize),
• MATs (materials),
• DATs (data operators)
• Custom Operators.
We also connected TouchDesigner to Arduino, expanding the software’s ability to receive real-world sensor input and enabling reactive, sensor-driven generative visuals. Sheridan also provides access to higher-tier licenses for students working on advanced projection installations, which is good to know for future projects.
For our activity, we began by creating a Derivative account and downloading the non-commercial version of TouchDesigner to our laptops. Installation was smooth, and we were then guided through the POT Arduino tutorial, which demonstrated how
Using the provided Arduino sketch, we uploaded the code and tested the potentiometer's responsiveness through the Serial Monitor in the Arduino IDE. As expected, the values changed dynamically when turning the knob, indicating successful analog input.
However, we quickly learned a key limitation: Serial communication is exclusive. That means the Arduino can only send data to one listener at a time. In this case, we had to close the Serial Monitor in order to let TouchDesigner access the same stream of data. The Arduino sketch remained running in the background, sending continuous values.
Once TouchDesigner was connected, we began using those analog values to manipulate a basic Sphere shape on screen in real-time—scaling to the potentiometer’s output. This allowed us to test and validate the Arduino → TouchDesigner ecosystem, and demonstrated the fundamentals of how to build generative art from live sensor input.
Activity 3 annotated images