<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Isabella Fiorante on Medium]]></title>
        <description><![CDATA[Stories by Isabella Fiorante on Medium]]></description>
        <link>https://medium.com/@fiorante?source=rss-877e628ee48c------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*IdAPW9aF8iVo4oRk9VwneQ.jpeg</url>
            <title>Stories by Isabella Fiorante on Medium</title>
            <link>https://medium.com/@fiorante?source=rss-877e628ee48c------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 04:58:24 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@fiorante/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Lab 8: Output w/ Simple Mechanics]]></title>
            <link>https://medium.com/@fiorante/lab-8-output-w-simple-mechanics-5226290ec124?source=rss-877e628ee48c------2</link>
            <guid isPermaLink="false">https://medium.com/p/5226290ec124</guid>
            <dc:creator><![CDATA[Isabella Fiorante]]></dc:creator>
            <pubDate>Mon, 26 Oct 2026 00:39:05 GMT</pubDate>
            <atom:updated>2026-10-27T19:23:21.772Z</atom:updated>
            <content:encoded><![CDATA[<p>Isabella Fiorante, Edna Ho, Jordan Panzier, Danlin Huang, Heeje Lee. Professor Kimiko Ryokai. Tangible User Interfaces, Fall 2026</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/718/1*F4eD9jqhuo6BEKYrsWNAEg.gif" /><figcaption>Source: unknown</figcaption></figure><h3><strong>Description</strong></h3><p>For this week’s lab, we were tasked with exploring mechanical linkages and motion by creating a “Cuckoo Clock” mechanism: a trap door that opens and closes, and an object (traditionally a bird) that leaps forward and backward. Instead of a traditional clock and bird, our group decided to make our cuckoo clock mechanism into a subway station terminal. On the hour, the black entrance/exit door (designed like a subway tunnel portal) opens as the subway train rolls into the station. The train pauses at the station before departing back into the tunnel, after which the tunnel door automatically closes behind it.</p><p>Our train and station are not attached to an actual clock, but if it was we imagined it would be a transit related one, like a Swiss railway clock.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Jyj8omZN06PZWF-gapgMiQ.jpeg" /><figcaption>Source: <a href="https://en.wikipedia.org/wiki/Swiss_railway_clock#/media/File:BahnhofsuhrZuerich_RZ.jpg">Wikipedia</a>.</figcaption></figure><h3><strong>Components</strong></h3><blockquote><em>1- Arduino UNO R4 Minima</em></blockquote><blockquote><em>1- 180 Servo Motor</em></blockquote><blockquote><em>1- Piezo Speaker</em></blockquote><blockquote><em>1- Electret Microphone Module</em></blockquote><blockquote><em>1- Breadboard &amp; jumper wires</em></blockquote><blockquote><em>1- USB-C Connector</em></blockquote><blockquote><em>Wood</em></blockquote><blockquote><em>Wooden dowels</em></blockquote><blockquote><em>Crescent board</em></blockquote><h3>Mechanics</h3><p>Rather than building two separate linkages for the door and the train, we used an intermittent gear to produce a single, synchronized mechanical system that operated the door and the train.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/222/1*Dte3P605a1cjrgvJ6zzU2w.gif" /><figcaption>Source: <a href="https://www.printables.com/@osamutake_3341417">@osamutake_3341417</a></figcaption></figure><ul><li><strong>Driving Gear </strong><em>(teal gear)</em><strong>: </strong>The train base is a circular rotating base mounted directly to a servo motor. The train model is glued on top along the perimeter of the base. Part of this base features gear teeth, while another section is smooth and toothless.</li><li><strong>Driven Gear </strong>(<em>pink gear</em>)<strong>: </strong>The tunnel door is attached to a driven gear mechanism.</li></ul><p>As the circular base rotates to bring the train into the station, the first set of teeth meshes with the door gear, swinging the tunnel door open. Once open, the smooth, toothless section of the driving base rotates past the door gear. This keeps the door stationary and fully open while the train glides smoothly into the platform area. After waiting at the platform, the train reverses direction to depart. A second set of gear teeth on the base engages the door gear in reverse, pulling the tunnel door shut behind the exiting train.</p><p>We laser-cut the custom intermittent gears out of wood and used a wooden dowel as a rotating axle. We then met the biggest challenge of the lab: gear alignment. Initially, our wooden dowel rod wobbled slightly on its axis. Any small shift in angle caused the gears to jam. With help from the makerspace staff (Thanks Chris!) we resolved this issue by cutting a shaft guide (a cylindrical cavity) in a wooden support block. This fully constrained the dowel’s rotational axis while still allowing it to spin freely. Stabilizing the shaft eliminated any and all gear wobble, so the intermittent teeth mesh smoothly every time.</p><p>To fit the path of our intermittent gear base, we designed and 3D-printed custom subway cars curved along an arc and glued them to the perimeter of the base. We then constructed a back wall using crescent board to conceal the electronics and mechanical linkages. To add more ambiance to our clock, we printed a custom subway station wall with tiles and signage, and pasted them onto the board.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/582/1*CKgGIrRX3hIjNBuTCTicSQ.gif" /></figure><h3><strong>Circuit Set Up</strong></h3><p>Since the station wasn’t hooked up to an actual clock face, we wanted an easy way to trigger the arrival sequence. We started by wiring the servo motor to a push button so we could test, troubleshoot, and calibrate the mechanics. We programmed a 5-second dwell time for the train in the station, before the servo reverses directions and the train leaves. We needed to use a 180-servo, since its positional awareness would be useful for aligning the intermittent gears. To enhance the interaction, we added a piezo buzzer to play audio. It emits a continuous low-frequency “rumble” as the train approaches and departs the station, and plays a double-tone chime sound (mimicking a transit PA system) announcing the train’s arrival and departure.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/928/1*SeCIPkxkU5xl4uy9U0FO7g.png" /></figure><h3>Code</h3><pre>/* this code was written with the help of gemini. */<br></pre><pre>#include &lt;Servo.h&gt;<br><br>const int SERVO_PIN = 9;<br>const int BUTTON_PIN = 12; // Digital pin for the push button<br>const int PIEZO_PIN = 8;<br><br>Servo stationServo;<br><br>void setup() {<br>  pinMode(BUTTON_PIN, INPUT_PULLUP); // Button pressed = LOW (connected to GND)<br>  pinMode(PIEZO_PIN, OUTPUT);<br>  stationServo.attach(SERVO_PIN);<br>  <br>  // Set initial position (Door closed, train hidden)<br>  stationServo.write(0); <br>  Serial.begin(9600);<br>}<br><br>void playChimeDeparture() {<br>  tone(PIEZO_PIN, 784, 300); // G5 (First tone)<br>  delay(350);<br>  tone(PIEZO_PIN, 659, 300); // E5 (Second tone)<br>  delay(350);<br>  tone(PIEZO_PIN, 523, 300); // C5 (Final lower tone)<br>  delay(350);<br>}<br>void playChimeArrival() {<br>  tone(PIEZO_PIN, 523, 300); // C5 (Final lower tone)<br>  delay(350);<br>  tone(PIEZO_PIN, 659, 300); // E5 (Second tone)<br>  delay(350);<br>  tone(PIEZO_PIN, 784, 300); // G5 (First tone)<br>  delay(350);<br>}<br><br>void loop() {<br>  int buttonState = digitalRead(BUTTON_PIN);<br>  <br>  // Trigger arrival sequence when the button is pressed<br>  if (buttonState == LOW) {<br>    for (int pos = 0; pos &lt;= 170; pos += 1) {<br>      stationServo.write(pos);<br>      delay(20);<br>    }<br>    playChimeArrival();<br>    // Station Dwell Time (3 seconds)<br>    delay(3000);<br>    // Departure Announcement &amp; Return<br>    playChimeDeparture();<br>    for (int pos = 170; pos &gt;= 0; pos -= 1) {<br>      stationServo.write(pos);<br>      delay(20);<br>    }<br>    <br>    // Short pause after sequence finishes to prevent immediate re-triggering if held down<br>    delay(500);<br>  }<br>}}</pre><h3>Video</h3><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F2oe5Y_i2-ak%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D2oe5Y_i2-ak&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2F2oe5Y_i2-ak%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/696e969f3e0b7478e41564762f01664e/href">https://medium.com/media/696e969f3e0b7478e41564762f01664e/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5226290ec124" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Lab 6: Output w/ DC motors]]></title>
            <link>https://medium.com/@fiorante/lab-6-ouput-w-dc-motors-1ec0aad5e633?source=rss-877e628ee48c------2</link>
            <guid isPermaLink="false">https://medium.com/p/1ec0aad5e633</guid>
            <dc:creator><![CDATA[Isabella Fiorante]]></dc:creator>
            <pubDate>Mon, 12 Oct 2026 18:31:34 GMT</pubDate>
            <atom:updated>2026-10-12T23:26:00.840Z</atom:updated>
            <content:encoded><![CDATA[<p>Isabella Fiorante. Professor Kimiko Ryokai. Tangible User Interfaces, Fall 2026</p><h3>Description</h3><p>This week, we explored output with DC motors. The circuit we built in this lab was more complex than prior circuits because the DC Motor required an external power source, a diode (1N4004), and a transistor (TIP120) to handle higher current loads safely.</p><p>I started this week by setting up the DC motor and a potentiometer and running the test code. This used the potentiometer to control the motor’s speed. I liked the physical and visual relationship between spinning of the potentiometer and the spinning of the motor, but for this lab I really wanted to use the force sensor, since I didn’t really get it to work last week.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/688/0*r00Mr3Bs20cMkOs9.jpg" /><figcaption>Source unknown.</figcaption></figure><p>Inspired by vintage paper fortune tellers like the one above, I decided to make a “useless fortune teller”. The DC motor sits within a rectangular base, and spins a circular piece of card stock with the fortunes, which is encased within a 3D printed ‘lid’ with a window. When the button at the front of the base is pressed, it presses against a force sensor, which spins the motor faster as more pressure is applied to the button. When the user releases the button, the DC motor gradually slows to a stop, to revealing a fortune in the window. I also added a Piezo speaker to add a ticking sound, like its actually a carnival prize wheel.</p><h3>Components Used</h3><blockquote><em>1- Arduino UNO R4 Minima</em></blockquote><blockquote><em>1- Force-Sensitive Resistor (FSR)</em></blockquote><blockquote><em>1- DC Motor</em></blockquote><blockquote><em>1- Piezo Speaker</em></blockquote><blockquote><em>1- AA Battery Pack</em></blockquote><blockquote><em>1- Diode (1N4004)</em></blockquote><blockquote><em>1- Transistor (TIP120)</em></blockquote><blockquote><em>1- 1k Ohms Resistor</em></blockquote><blockquote><em>1- Breadboard &amp; jumper wires</em></blockquote><blockquote><em>1- USB-C Connector</em></blockquote><h3>Circuit Set Up</h3><p>I started by setting up my circuit, since I already had the test code with the potentiometer working, I just had to swap the potentiometer for a force sensor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/972/1*jNhSuJ8bvLNrwru8LIP2cQ.png" /></figure><h3>Code</h3><pre>/* This code was written with the help of gemini. */</pre><pre>// Pin Definitions<br>const int fsrPin = A0;      // FSR connected to Analog pin A0<br>const int motorPin = 3;     // DC motor PWM pin (via transistor/MOSFET)<br>const int piezoPin = 8;     // Piezo speaker pin<br><br>// Variables<br>int fsrVal = 0;<br>float currentSpeed = 0.0;   // The actual live speed of the motor (with inertia)<br>float targetSpeed = 0.0;    // The desired speed based on FSR input<br>unsigned long lastClickTime = 0;<br><br>void setup() {<br>  pinMode(motorPin, OUTPUT);<br>  pinMode(piezoPin, OUTPUT);<br>  Serial.begin(9600);<br>}<br><br>void loop() {<br>  // 1. Read the FSR sensor<br> int fsrVal = analogRead(A0);<br><br>  // 2. Noise Gate: Ignore tiny random fluctuations and micro-vibrations<br>  if (fsrVal &lt; 15) {  // Adjust this number (10 to 20) if your baseline is higher/lower<br>    fsrVal = 0;<br>  }<br><br>  // 3. Map to target speed only if it&#39;s past the threshold<br>  int targetSpeed = 0;<br>  if (fsrVal &gt; 0) {<br>    targetSpeed = map(fsrVal, 15, 1023, 100, 255); // Map your active press range<br>  }<br><br>  // 3. Inertia &amp; Smoothing Logic<br>  if (targetSpeed &gt; currentSpeed) {<br>    // Spining up: react quickly when pressed<br>    currentSpeed = targetSpeed; <br>  } else {<br>    // Coasting down: decrease speed gradually to simulate heavy mechanical inertia<br>    // Lower number = longer, heavier coast-down time (try 1.0 to 3.0)<br>    currentSpeed -= 1.5; <br>    if (currentSpeed &lt; 0) {<br>      currentSpeed = 0;<br>    }<br>  }<br><br>  // Apply speed to the DC motor<br>  analogWrite(motorPin, (int)currentSpeed);<br><br> // 4. Piezo Auditory Feedback &amp; Extended Mechanical Inertia<br>  static unsigned long lastClickTime = 0;<br>  static int finalClicks = 0; <br><br>  if (currentSpeed &gt; 0) {<br>    // Normal active spinning ticks<br>    int clickDelay = map(currentSpeed, 1, 255, 350, 5); <br>    <br>    if (millis() - lastClickTime &gt; clickDelay) {<br>      tone(8, 900, 25); <br>      lastClickTime = millis();<br>    }<br>    // Reset our pool of dying clicks for the next spin<br>    finalClicks = 10; <br>  } <br>  else if (finalClicks &gt; 0) {<br>    // Extended coast-down phase: stretches the time between each click wider and wider<br>    int dyingDelay = 400 + (10 - finalClicks) * 90; // Spacing increases: 400ms, 490ms, 580ms...<br>    <br>    if (millis() - lastClickTime &gt; dyingDelay) {<br>      tone(8, 900, 30); // Keep the frequency consistent so the tone doesn&#39;t warp<br>      lastClickTime = millis();<br>      finalClicks--;<br>    }<br>  }<br><br>  // Debugging to help check tuning<br>  Serial.print(&quot;FSR: &quot;);<br>  Serial.print(fsrVal);<br>  Serial.print(&quot; | Speed: &quot;);<br>  Serial.println(currentSpeed);<br><br>  delay(15); // Small loop stabilization delay<br>}</pre><h3>Fabrication</h3><p>Building on key learnings from last week’s build, this week’s base was designed with lots of internal space to tinker with wiring and electronic components. I also added a few extra mm on the tolerances for the component housings, because I find even if I’m precise in my measurements of the components and the space they need, in the printing process everything shrinks by an mm or so. I also took extra care for clearances and tolerances on the slot for the force sensor, since last week my fabricated housing was too narrow. This week was much more successful, and my new force sensor has survived this build completely intact.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5Pv5gDOFqJRUuOFR1a-Qxw.jpeg" /><figcaption>Lots of space for wires and my hands to tinker!</figcaption></figure><p>For the visual interface, I designed a wheel in Illustrator and added my useless fortunes. My visual reference for the wheel was the astrology app Co-Star, because I think its visual identity blends the mysticism of the cosmos with digital brutalism really well, and they’re known for their quippy and blunt “insights” into the future. Their primarily black and white interface also worked well with the PLA I had available for the teller’s housing. I printed it on cardstock, because I felt that this would be easy to attach to the DC motor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*fINYFivl-KhxI65EY9-fjw.png" /><figcaption>Co-Star astrology interface. Image from asapjournal.com. Article: As Above, So Below: Astrological Data in the Age of Co–Star.</figcaption></figure><p>For the button, I modified an existing electrical button to be a mechanical one that presses on the force sensor. I removed its metal prongs and added a rubberized bumper at the base with some dried hot glue. Below the circular case that housed the spinning wheel, I cut out a cube shape, so that the button has a path to move up and down within as its pressed.</p><h3>Video</h3><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F8q-C0ch9PUs%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D8q-C0ch9PUs&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2F8q-C0ch9PUs%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/820e33619921a636d09f554483afcf8c/href">https://medium.com/media/820e33619921a636d09f554483afcf8c/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1ec0aad5e633" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Lab 5: Output w/ Piezo speakers]]></title>
            <link>https://medium.com/@fiorante/lab-5-output-w-piezo-speakers-352d22c0df6d?source=rss-877e628ee48c------2</link>
            <guid isPermaLink="false">https://medium.com/p/352d22c0df6d</guid>
            <dc:creator><![CDATA[Isabella Fiorante]]></dc:creator>
            <pubDate>Mon, 05 Oct 2026 16:44:38 GMT</pubDate>
            <atom:updated>2026-10-05T16:44:38.199Z</atom:updated>
            <content:encoded><![CDATA[<p>Isabella Fiorante. Professor Kimiko Ryokai. Tangible User Interfaces, Fall 2026</p><h3>Description</h3><p>This week, we explored output with Piezo speakers. I don’t have any experience working with sound/audio output, so it was really fun to work with something completely new.</p><h3>Parts 1 &amp; 2: Piezo speaker and making a theramin</h3><p>During lab we used the Piezo speakers to play a melody, and then combined it with an LDR to mimic a Theramin: an instrument designed to be played without being touched.</p><p>At first I struggled with the provided test code, everything was wired correctly but no sound was coming out. The code seemed correct, and I couldn’t find any obvious errors, so I fed the example code into Gemini to see if it could catch an error I had missed. The problem seemed to be with passing noteDuration into the tone() as the third parameter, which was preventing tone() from running continuously. I also needed to comment out noTone(8) which was shutting the pin off every 20ms, and preventing sound from playing from the speaker. Below is the code that worked.</p><h4>Code</h4><pre>/* Theremin<br> * --------<br> *<br> * Created 24 October 2006<br> * copyleft 2006 Tod E. Kurt tod@todbot.com<br> * http://todbot.com/<br> *<br> * Adapted by Noura Howell, 2 October 2017<br> * http://nourahowell.com/<br> */<br><br>int photocellPin = 0;<br>int speakerPin = 8;<br><br>int photocellVal = 0;<br>int toneVal;<br><br>// try changing the noteDuration to hear how that changes the sound<br>int noteDuration = 20; // ms (increased slightly from 10 so speaker can vibrate)<br><br>void setup() {<br>  pinMode(speakerPin, OUTPUT);<br>  Serial.begin(9600);<br>}<br><br>void loop() {  <br>  // read the value from the sensor<br>  photocellVal = analogRead(photocellPin);<br>  Serial.print(&quot;photocellVal: &quot;);Serial.println(photocellVal);<br>  <br>  // decide what tone to play based on the sensor value<br>  // Offset added (+200) because frequencies below 100 Hz are inaudible on piezos<br>  toneVal = (photocellVal * 15) + 200; <br>   <br>  // play the tone (without the 3rd duration argument so tone plays continuously)<br>  tone(speakerPin, toneVal); <br><br>  // to distinguish the notes, set a minimum time between them.<br>  // the note&#39;s duration + 30% seems to work well:<br>  // try changing the pauseBetweenNotes to hear how that changes the sound<br>  int pauseBetweenNotes = noteDuration * 1.3;<br>  delay(pauseBetweenNotes);<br><br>  // stop the tone playing:<br>  // noTone(8); // REMOVED: noTone was killing the audio timer before vibration started<br>}</pre><h4>Video</h4><p><a href="https://youtu.be/gz0NTwOBsSM">https://youtu.be/gz0NTwOBsSM</a></p><h3>Part 3: I/O Coincidence</h3><p>The last step of this week’s lab was to design an input/output coincidence device or artifact with any combination of sensors and output so far.</p><p>While ideating on what to make, I thought about things that have light and sound, and initially thought about fireworks. However, I felt that fireworks lack input/output coincidence, since you have to be far away from them (or should be) when they go off. So instead I thought just about the act of lighting a wick and decided to make a candle, combining an LED, LDR, FSR, and Piezo speaker.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/510/1*0l6uxnBdVAh4tNM6uRrCrw.gif" /><figcaption>source: unknown</figcaption></figure><h4>Components Used</h4><blockquote><em>1- Arduino UNO R4 Minima</em></blockquote><blockquote><em>2- Force-Sensitive Resistor (FSR)Sensor BROKEN :(</em></blockquote><blockquote><em>1-</em> <em>Electret Microphone Module</em></blockquote><blockquote><em>1- Photocell (LDR)</em></blockquote><blockquote><em>1- Piezo Speaker</em></blockquote><blockquote><em>1- RGB LED</em></blockquote><blockquote><em>1- 10k Ohms Resistors</em></blockquote><blockquote><em>3- 220 Ohms Resistors</em></blockquote><blockquote><em>1- Breadboard &amp; jumper wires</em></blockquote><blockquote><em>1- USB-C Connector</em></blockquote><h4>Circuit Set Up</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XuWnA33TKPCAXkxozra89A.png" /></figure><p>After setting up the circuit, I spent some time getting the code to work. This took a lot of trial and error and back and forth between code checking and circuit checking. The most challenging issue turned out to be not one but two broken FSRs. I don’t think I added enough clearance to the physical container for the wires of the FSR to pass through, and ended up breaking two in the installation process. I really wanted to keep the natural action of blowing out a candle, so I didn’t want to use a button or even another LDR. So instead I pivoted to a mic module, which would use the sound of breath to trigger the extinguishing code.</p><p>Once the sensor issue was fixed, I focused on minor code refinements. I tuned the visual output to create a flickering flame effect with random color variations, and adjusted the speaker frequencies so the output sounded like a soft ambient crackle rather than a harsh screech. I also calibrated the mic threshold so blowing directly on the candle cleanly extinguished the flame and sound.</p><h4>Code</h4><pre>// ==========================================<br>// SHADOW CANDLE - FIXED HARDWARE EDITION<br>// LDR: Pin A1 | Mic: Pin A0 <br>// RGB LED: Pins 9 (R), 10 (G), 11 (B) | Piezo: Pin 8<br>// ==========================================<br><br>const int LDR_PIN = A1;        // Photoresistor<br>const int MIC_PIN = A0;        // Electret Mic Module<br><br>const int RED_PIN = 9;         // RGB Red (PWM)<br>const int GREEN_PIN = 10;      // RGB Green (PWM)<br>const int BLUE_PIN = 11;       // RGB Blue (PWM)<br>const int PIEZO_PIN = 8;       // Piezo Buzzer<br><br>// Threshold Calibration<br>const int SHADOW_DROP = 15;     // Must drop 40+ units below room ambient to light<br>const int BLOW_THRESHOLD = 400;  // Sound amplitude to blow out candle<br><br>// System State<br>bool candleLit = false;<br>int roomAmbientBaseline = 0;   // Saved ambient room light level<br><br>// Forward Declarations<br>void setFlame(int r, int g, int b);<br>void flickerFlameWithCrackle();<br>int measureMicAmplitude();<br>void playIgniteSound();<br>void playExtinguishSound();<br><br>void setup() {<br>  Serial.begin(9600);<br><br>  pinMode(RED_PIN, OUTPUT);<br>  pinMode(GREEN_PIN, OUTPUT);<br>  pinMode(BLUE_PIN, OUTPUT);<br>  pinMode(PIEZO_PIN, OUTPUT);<br><br>  // Power-up test: 1 second warm amber flash<br>  setFlame(255, 20, 0);<br>  delay(1000);<br>  setFlame(0, 0, 0);<br><br>  // Capture stable room light baseline on startup<br>  delay(200);<br>  roomAmbientBaseline = analogRead(LDR_PIN);<br><br>  Serial.println(&quot;==========================================&quot;);<br>  Serial.println(&quot;   SHADOW CANDLE INITIALIZED &amp; READY     &quot;);<br>  Serial.print(&quot;   Room Ambient Baseline Locked At: &quot;);<br>  Serial.println(roomAmbientBaseline);<br>  Serial.println(&quot;==========================================&quot;);<br>}<br><br>void loop() {<br>  // --------------------------------------------------<br>  // 1. CANDLE OFF STATE: Check for Shadow<br>  // --------------------------------------------------<br>  if (!candleLit) {<br>    int liveLdr = analogRead(LDR_PIN);<br>    int shadowTarget = roomAmbientBaseline - SHADOW_DROP;<br><br>    Serial.print(&quot;[OFF] Target &lt; &quot;);<br>    Serial.print(shadowTarget);<br>    Serial.print(&quot; | Live LDR: &quot;);<br>    Serial.println(liveLdr);<br><br>    // Check if live LDR drops clearly below room baseline<br>    if (liveLdr &lt; shadowTarget) {<br>      <br>      // DEBOUNCE: Verify shadow is held across 3 samples (150ms total)<br>      int shadowConfirmCount = 0;<br>      for (int i = 0; i &lt; 3; i++) {<br>        delay(50);<br>        if (analogRead(LDR_PIN) &lt; shadowTarget) {<br>          shadowConfirmCount++;<br>        }<br>      }<br><br>      if (shadowConfirmCount == 3) {<br>        candleLit = true;<br>        Serial.println(&quot;&gt;&gt;&gt; SHADOW DETECTED! IGNITING CANDLE &lt;&lt;&lt;&quot;);<br>        playIgniteSound();<br>        delay(500); <br>      }<br>    }<br>  }<br><br>  // --------------------------------------------------<br>  // 2. CANDLE LIT STATE: Render Flame &amp; Check Sound<br>  // --------------------------------------------------<br>  if (candleLit) {<br>    flickerFlameWithCrackle();<br><br>    int micAmplitude = measureMicAmplitude();<br><br>    Serial.print(&quot;[LIT] Mic Amplitude: &quot;);<br>    Serial.print(micAmplitude);<br>    Serial.print(&quot; | Blow Threshold: &quot;);<br>    Serial.println(BLOW_THRESHOLD);<br><br>    if (micAmplitude &gt; BLOW_THRESHOLD) {<br>      candleLit = false;<br>      setFlame(0, 0, 0); <br>      noTone(PIEZO_PIN); <br>      <br>      Serial.println(&quot;&gt;&gt;&gt; BLOW DETECTED! CANDLE EXTINGUISHED &lt;&lt;&lt;&quot;);<br>      playExtinguishSound();<br><br>      // Pause for sound and light to clear<br>      delay(1000); <br><br>      // Update room baseline now that flame is off<br>      roomAmbientBaseline = analogRead(LDR_PIN);<br><br>      // Lockout hold loop: Stay here until hand/shadow moves away<br>      while (analogRead(LDR_PIN) &lt; (roomAmbientBaseline - (SHADOW_DROP / 2))) {<br>        Serial.println(&quot;[LOCKOUT] Waiting for clear ambient light...&quot;);<br>        delay(200);<br>        roomAmbientBaseline = analogRead(LDR_PIN); <br>      }<br><br>      Serial.print(&quot;&gt;&gt;&gt; CANDLE RE-ARMED. New Baseline: &quot;);<br>      Serial.println(roomAmbientBaseline);<br>      delay(300);<br>    }<br>  } else {<br>    setFlame(0, 0, 0);<br>  }<br><br>  delay(30); <br>}<br><br>// ==========================================<br>// HELPER FUNCTIONS &amp; SOUND EFFECTS<br>// ==========================================<br><br>void setFlame(int r, int g, int b) {<br>  analogWrite(RED_PIN, r);<br>  analogWrite(GREEN_PIN, g);<br>  analogWrite(BLUE_PIN, b);<br>}<br><br>void flickerFlameWithCrackle() {<br>  int r = random(230, 255);<br>  int g = random(10, 35);<br>  setFlame(r, g, 0);<br><br>  if (random(0, 100) &lt; 25) {<br>    int popFreq = random(600, 1600); <br>    tone(PIEZO_PIN, popFreq, 14);<br>  } else {<br>    noTone(PIEZO_PIN);<br>  }<br>}<br><br>int measureMicAmplitude() {<br>  unsigned long startMillis = millis();<br>  int signalMax = 0;<br>  int signalMin = 1023;<br><br>  while (millis() - startMillis &lt; 30) {<br>    int sample = analogRead(MIC_PIN);<br>    if (sample &lt; 1023) {<br>      if (sample &gt; signalMax) signalMax = sample;<br>      if (sample &lt; signalMin) signalMin = sample;<br>    }<br>  }<br>  return (signalMax - signalMin);<br>}<br><br>void playIgniteSound() {<br>  for (int f = 100; f &lt; 300; f += 20) {<br>    tone(PIEZO_PIN, f, 12);<br>    delay(10);<br>  }<br>  noTone(PIEZO_PIN);<br>}<br><br>void playExtinguishSound() {<br>  for (int f = 350; f &gt; 80; f -= 20) {<br>    tone(PIEZO_PIN, f, 12);<br>    delay(10);<br>  }<br>  noTone(PIEZO_PIN);<br>}</pre><h4>Fabrication</h4><p>For the casing, I CADed a cylinder and made specific slots in the top for the LED wires, the LDR, and the FSR (and ended up having to dremel out space for the mic module). I made sure the cylinder diameter was wide enough for the speaker to fit inside. Last week, when I printed the telescope, I realized the space I had drawn for the LDR was a touch too small, and I ended up having to widen the opening ever so slightly with a dremel. For this iteration, I made sure to add a fraction of a millimetre of tolerance to ensure the LDR would sit cleanly without filing. At the base of the cylinder, I added a small semicircle cutout to route the power wires through so the candle sits completely flush on a flat surface.</p><p>A big learning curve for me during fabrication was managing physical wiring volume inside the enclosure, especially after having to re-route connections when pivoting from the FSRs to the sound sensor. Toward the end of the build, the jumper wires and breadboard connections got pretty messy, which made troubleshooting loose leads much harder. In future builds, I want to be much more intentional about spatial planning:</p><ul><li><strong>Hand Clearance &amp; Assembly:</strong> Designing enclosures with enough physical working room to fit hands inside comfortably. I ended up using extra-long jumper wires just to reach components, which quickly turned into a tangled mess.</li><li><strong>Accounting for Heat Shrink Bulk:</strong> Heat shrink tubing adds noticeable thickness to wire bundles. I realized I need to leave extra channel clearance for heat-shrunk wires.</li><li><strong>Common Ground Paths:</strong> Ensuring all components share a clean, direct path back to GND would’ve prevented almost unnoticeable hardware failures.</li></ul><p>I had a lot of fun this week, and adding a sound dimension to the final artifact felt really rewarding. I have really been enjoying recreating intuitive real-world actions (like bringing a hand over a wick to light it or blowing out a flame) and learning how to make digital hardware interactions feel natural and seamless.</p><h4>Video</h4><p><a href="https://youtu.be/kXvvu5Gj8wc">https://youtu.be/kXvvu5Gj8wc</a></p><ul><li>note the crackling is quite high-pitched on the video recording, likely because the iphone mic isn’t very accurate. it’s much deeper and more natural sounding in real life.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=352d22c0df6d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Lab 4: Sensing w/ force sensors and photocells]]></title>
            <link>https://medium.com/@fiorante/lab-4-sensing-w-force-sensors-and-photocells-11c4c1ce9085?source=rss-877e628ee48c------2</link>
            <guid isPermaLink="false">https://medium.com/p/11c4c1ce9085</guid>
            <dc:creator><![CDATA[Isabella Fiorante]]></dc:creator>
            <pubDate>Mon, 28 Sep 2026 06:01:54 GMT</pubDate>
            <atom:updated>2026-10-02T23:36:58.101Z</atom:updated>
            <content:encoded><![CDATA[<p>Isabella Fiorante. Professor Kimiko Ryokai. Tangible User Interfaces, Fall 2026</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/382/1*tgANjsrKlIV85P_gj7dSSA.gif" /><figcaption>animation by julie bouchet on behance</figcaption></figure><h3>Description</h3><p>This week, we explored two analog sensors: Force-Sensitive Resistors (FSRs) and Photocells, which are light-dependent resistors, and integrated them with <strong>p5.js</strong> via the Web Serial API.</p><p>Instead of just mapping sensor values directly to simple shapes, I wanted to create more cohesive animation. I used a photocell for a project last year where a darker environment triggered a white paper fan to open into a semi-circle, and I thought it reminded me a bit of a moonrise; as the sky gets darker, the white moon appears. So I decided to convert this into a drawn animation in p5.js. I wanted the FSR’s function to also be night sky or space related, and initially thought of it like a button to launch a rocket across the screen or something, but after settling the moon animation, I thought shooting stars would suit the animation better and be much calmer, even if the “button to launch” set up didn’t align quite as well. Wouldn’t it be great if we could decide when to see shooting stars?</p><h3>Components Used</h3><blockquote><em>1- Arduino UNO R4 Minima</em></blockquote><blockquote><em>1- Force-Sensitive Resistor (FSR)Sensor</em></blockquote><blockquote><em>1- Photocell (LDR)</em></blockquote><blockquote><em>2- 10k Ohms Resistors</em></blockquote><blockquote><em>1- Breadboard &amp; jumper wires</em></blockquote><blockquote><em>1- USB-C Connector</em></blockquote><h3>Circuit Set Up</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/938/1*5iEyELJTLEalgNjBI87Uqw.png" /></figure><h3>Process</h3><h4>Getting started</h4><p>Before diving into the p5.js canvas, I calibrated both analog inputs individually using standard Arduino test sketches to determine their operational voltage ranges.</p><p>Once verified, I uploaded a unified serial sketch to stream both sensor values as a comma-separated string (photocell,fsr\n) over a 9600 baud rate.</p><h4>How it works</h4><p>The system translates physical tangible interaction into digital sky mechanics:</p><ol><li><strong>Photocell (Environmental Day/Night Cycle):</strong> Covering the photocell simulates nighttime. As light decreases, the p5.js canvas transitions from a twilight blue to a deep night sky, and a glowing moon slowly rises from below the horizon.</li><li><strong>FSR (Shooting Star Trigger):</strong> Pressing the force sensor launches a high-velocity shooting star across the sky with a fading, tapered particle trail.</li></ol><h4>Code Iterations &amp; Hiccups</h4><p>I started by getting Connie’s example code to run in p5.js, which went pretty smoothly. I then ran into a lot of trouble getting my own code in the draw function to work.</p><p>When p5.js receives serial data from the browser, the numbers can sometimes arrive cut in half. To stop p5.js from crashing when trying to split the numbers, I added a buffer (serialBuffer) that collects incoming text and only processes it once it receives a full line (\n).</p><p>After that, the animation was mostly functional, so I spent a bit of time refining the code so the animation really aligned with what I had imagined.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pZ5iMxDwTuCH4WLy2ezkWQ.gif" /><figcaption>the final animation</figcaption></figure><h4>Moon animation</h4><p>At first, the moon was really jittery because raw sensor readings naturally flicker up and down. I really wanted a smooth, gentle animation, so I added a simple math filter (an exponential moving average) to smooth out the photocell numbers. Now, when the photocell is covered, the moon glides up the screen.</p><h4>Shooting stars animation</h4><p>Smoothing out the photocell worked great for the moon, but applying that same smoothing to the FSR made it feel laggy, some taps were missed completely. To fix this, I kept the photocell smoothed for the moon, but let the FSR use raw, instant sensor values so shooting stars pop up exactly when you press down.</p><p>Sometimes a single press on the force sensor would trigger two shooting stars back-to-back because my finger wobbled slightly on the pad. I added a quick 300ms cooldown timer (millis()) so that after one star fires, the code waits for you to lift your finger before letting another star launch.</p><p>My first version of the shooting star curved downward, which looked a bit heavy and almost like it was going to hit earth and cause the apocalypse or something. So I tweaked the animation to flatten out the curve and shoot upwards diagonally, making them feel much more like a real meteor sweeping across the sky.</p><p>Working on this sketch showed me how important timing and filtering are when connecting physical hardware to animations. Slow environmental changes like light level feel much better when smoothed out, while instant interactions like pressing a button need to trigger right away without delay.</p><h3>Arduino Code</h3><pre>/* the following code was written with the help of gemini */</pre><pre><br>// Arduino Dual-Sensor Serial Stream<br>const int photocellPin = A0;<br>const int fsrPin = A1;<br><br>void setup() {<br>  Serial.begin(9600);<br>}<br><br>void loop() {<br>  int photocellVal = analogRead(photocellPin);<br>  int fsrVal = analogRead(fsrPin);<br><br>  // Send as comma-separated values<br>  Serial.print(photocellVal);<br>  Serial.print(&quot;,&quot;);<br>  Serial.println(fsrVal);<br><br>  delay(30);<br>}</pre><h3>p5.js Code</h3><p><a href="https://editor.p5js.org/ifiorante/sketches/lGd8JYgh8">https://editor.p5js.org/ifiorante/sketches/lGd8JYgh8</a></p><h3>Fabrication</h3><p>To ground the digital canvas in a physical context, I wanted the physical interaction to match the night sky theme.</p><p><strong>Photocell: The Telescope Interface</strong><br>For the light sensor, I designed an enclosure around the physical act of observing the sky. Bringing an instrument up to your eye naturally blocks ambient light, making a telescope form an intuitive choice.</p><p>I CADed a quick, conical telescope enclosure with a fitted indent near the eyepiece to house the light sensor, running its leads out through the side. When a user holds the telescope up to their eye to view the screen, their face naturally covers the sensor and blocks ambient light. This triggers the moonrise animation. For a future iteration, I would love to design a fully enclosed internal housing for the sensor and integrate an ESP32 for wireless serial communication.</p><p><strong>Force-Sensitive Resistor: Bare-Surface Tactility</strong><br>While the photocell benefits from a thematic physical form, I intentionally left the FSR exposed as a direct-contact touch surface.</p><p>Originally, the I was thinking about a rocket launch metaphor, with a dedicated button box or launch pad which made a lot of conceptual sense. As the design evolved into a direct sky interaction (launching shooting stars), a rigid button enclosure felt less metaphorically necessary.</p><p>Also, from a tactile interface perspective, enclosing an FSR often introduces mechanical dampening, requiring higher force thresholds and reducing sensitivity. Given that the user’s vision is already constrained while looking through the telescope, keeping the FSR exposed ensures immediate tactile feedback, low activation force, and frame-accurate responsiveness for sweeping stars across the canvas.</p><h3>Video</h3><p><a href="https://youtu.be/3Fu3AJjTPic">https://youtu.be/3Fu3AJjTPic</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=11c4c1ce9085" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Design Workshop: Human Centered Design]]></title>
            <link>https://medium.com/@fiorante/design-workshop-human-centered-design-09a8fc623db0?source=rss-877e628ee48c------2</link>
            <guid isPermaLink="false">https://medium.com/p/09a8fc623db0</guid>
            <dc:creator><![CDATA[Isabella Fiorante]]></dc:creator>
            <pubDate>Thu, 24 Sep 2026 20:51:58 GMT</pubDate>
            <atom:updated>2026-09-24T20:51:58.020Z</atom:updated>
            <content:encoded><![CDATA[<p>Thursday, 24 September</p><h3>TEAM</h3><blockquote><em>Danlin Huang<br>Heeje Lee<br>Edna Ho<br>Jordan Panzier<br>Isabella Fiorante</em></blockquote><h3>OBSERVATIONS</h3><p>Image 1.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hIyPMxV6-mTuIMh_ujYR0A.jpeg" /></figure><p>We see someone trying to dry a damp shirt over the solid headboard of their bed. Some problems with this are that the headboard is solid, so there is little airflow for efficiently drying the shirt. It also may be trapping more moisture around the pillows and head of the bed. It’s aesthetically displeasing to have the shirt out and on display. A better immediate solution would be to use a dryer or drying rack, but through behavioural mapping we imagine there may be a space constraint due to the proximity of the desk to the bed.</p><p>Our proposed solution is a bed with a slatted footboard that can be pulled up for clothing drying. The slats would provide better air flow, and by moving the damp shirt to the end of the bed, it is not in close proximity to pillows and other fabrics that can trap moisture. When not in use, the footboard can be pushed down, so that it is not visually obtrusive.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j17e3-Rl2pMBcqnJefhRuQ.png" /></figure><p>Image 2.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*c7ctBPeJ_QXfgDJ5SR2CyQ.jpeg" /></figure><p>We see someone storing their face mask on their wrist next to a watch. Some problems with this are that the mask is coming into contact with a lot of things and could be picking up sweat, germs and bacteria from the wrist or things close to the hand as the user touches things and interacts with the world. Also, if the mask is soiled from coughing or breathing, potential contaminants could be transferred to the things the user is interacting with.</p><p>Our proposed solution is similar to an eyewear retainer cord or lanyard. Where each end of the cord is attached to either loop of the mask and the user can hang the mask around their neck. This keeps the mask from coming into contact with things the user is touching, which protects both the mask from contaminants and the external world from contaminants. It also maintains the user’s easy access to the mask, and the straps can remain connected to the mask while the user is wearing it, so it doesn’t require them to carry another item like a pouch or storage container.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sOYudwvDo9yThhizfEsMLA.png" /></figure><p>Image 3.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wdr5sObil0aL1ORQHRT_0w.jpeg" /></figure><p>We see someone lying down or trying to sleep on a couch that is clearly too short for them. The most obvious problem is that this looks quite uncomfortable. The room is quite crowded and there seems to be something blocking each end of the couch, which would prevent the user from just buying a longer couch.</p><p>After infinity mapping the possibilities of a couch we proposed a solution of a retractable ottoman, which would allow the user to stretch out comfortably while accounting for the lack of lateral space in the room. Because the ottoman retracts into the base of the couch, it can be stored away when not in use, which seems like it would be useful given that the room that seems small and a bit crowded.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kTPmGIfGXW5ARJx56Xy_rQ.png" /></figure><p>Image 4.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*E3FBi7ZyCChbFazm2Q0NCw.jpeg" /></figure><p>We see various improvised solutions for hanging headphones and a wok, and an improvised solution where the base of a lamp is the acting as the coaster for a drink. The problems with these solutions are that the condensation from the cup is quite close to the electronic part of the lamp, which was not designed to be in close contact with moisture and could be damaging the lamp. For the items that need better are that the</p><p>Since the left and centre images both seem to be on a desk, we proposed a solution of a lamp with a storage hook for headphones or keys, and a base that has a temperature (cooling and heating) pad to keep your drink cold or hot while you study. For the pan, we proposed a solution where the handle folds in and over the top of the pan, which would make it easier to store it in the cupboard, rather than outside of it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9rLRkPoiwydqgZLEK7FzKQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pu-y7WiXT_oISzfcdTguOQ.png" /></figure><p>Image 5.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NmQqen97dzlZDvglcd2S2w.jpeg" /></figure><p>We see a series of bikes being used as storage racks for various items, some related to biking and others not. This is a problem as it creates issues with actually using the bike, and if it doesn’t impede usability, the items could cause issues with navigation and speed once on the bike. It is also aesthetically unpleasant.</p><p>We thought that a day in the life would be particularly useful for generating a solution here, so we could see how cyclists use their bikes, what issues they run into and what circumstances led to these improvised storage solutions. We considered our own experiences with biking and realized that the lack of secure storage on a bike is one of the most frustrating parts of cycling. While there are many improvised solutions for storage (as seen in the images), a lot of these solutions don’t keep your items secure while you’re away from the bike. So we proposed a solution of building a secure storage container into the frame, similar to the built in helmet storage under the seat of a moped. While it wouldn’t be a ton of space, it would allow the user to store a lot of the items in the images above, and would give them somewhere to leave their lock while they cycle, another common frustration cyclists face.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lN92SnqPZMyNVG6O6AwgpA.png" /></figure><p>Image 6.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6xBuqBHhQvFHqnCQCFCfUA.jpeg" /></figure><p>We a see the upper handle of a backpack being used as an improvised coffee holder. The problem with this is that the coffee could easily be spilled.</p><p>We are proposing a solution of a designated cup holder in the center of the backpack, that holds structure, and is large enough for a big cup. We thought it would be important for the cup holder to collapse into the bag when not in use, so that it isn’t in the way and the backpack still looks and functions like an unadapted backpack.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AqHfrWbKZ797kRjurfrMIw.png" /></figure><h3>MOST INNOVATIVE IDEA + MIDTERM IMPLICATIONS</h3><p>Our most innovative design solution was our solution for Image 4. We started by considering the easiest solutions (buying a coaster, installing a hook) and considered why they may not have done these things. For example, they may not have wanted to damage the walls with a hook, they may not have time to buy a coaster, or the coaster could’ve been too much clutter if they have a small desk. Coasters are also easy to lose and misplace; perhaps they had one and didn’t know where it was.</p><p>We kept the core of the solution as a lamp, since that would still serve a standalone purpose in a setting with limited space, and felt that it would be easy to add a hook to this to store headphones or other small items like keys. Rather than just creating a more intentional space for a cup on the base, we thought about what would incentivize a user to store their cup here since they could technically leave it anywhere else on the desk, or could put it on a notebook or other random object. We thought that adding an internal plate that regulated the temperature of the cup would draw the user to actually using the designated cup storage area.</p><p>For our midterm, we have been thinking about collective movement and kinetic energy, potentially designing a system that has visual or auditory output that reflects the energy of the room. We were mostly thinking about this in the context of group exercise like spin classes, and also in the context of dancing at a nightclub or bar. This exercise helped us think about what incentivizes people to dance, and if there is something that could draw people to the dance floor. Through bodystorming, we’re hoping to identify the thoughtless incentives that encourage us to take part in collective movement.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=09a8fc623db0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Design Workshop: Somaesthetics]]></title>
            <link>https://medium.com/@fiorante/design-workshop-somaesthetics-0f2caa35e03f?source=rss-877e628ee48c------2</link>
            <guid isPermaLink="false">https://medium.com/p/0f2caa35e03f</guid>
            <dc:creator><![CDATA[Isabella Fiorante]]></dc:creator>
            <pubDate>Tue, 22 Sep 2026 21:53:15 GMT</pubDate>
            <atom:updated>2026-09-22T21:53:44.714Z</atom:updated>
            <content:encoded><![CDATA[<p>Thursday Sept 17</p><h3>TEAM</h3><blockquote><em>Danlin Huang<br>Heeje Lee<br>Edna Ho<br>Isabella Fiorante</em></blockquote><h3>BREATHING</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a-Ul8wYX1f0sukIjmL5_Jg.png" /><figcaption>Instructions for the exercise</figcaption></figure><p>To begin, we each did the exercise twice with different partners each time, so we could see how tracking someone’s breathing differed with each person.</p><p>During the first part of the exercise, where neither partner was leading and the goal was to just sense each other’s breath, we found that there was an unintentional pull towards matching each other’s breathing. When it was time for one person to lead, we found you really had to exaggerate your breath and breathe intentionally into your shoulders for the other person to feel it. To follow, you had to underexaggerate your own breathing in order to sense the leader.</p><p>By switching partners and repeating the exercise, we gained interesting insights on how breathing differed between people. With some people, their back moves up and down to breathe, so in order to track their breathing, you focused on the up and down friction between your contact points. With other people, it was more of a forward backward movement, so tracking became about focusing on the total contact area of your backs together. After completing the exercise once, we had techniques or strategies that worked for sensing one person’s breathing but when we switched partners, we realized that a technique that worked with one person, didn’t necessarily work with someone else.</p><p>After completing the exercise, we noted the human connection that forms from focusing on other people’s breathing and that is generated from the effort it takes to synchronize our breath. It was interesting to draw a lot of attention to what feels like such a simple and natural movement for us; which helped us realize how a complex the movement of breathing really is, even though it feels so effortless to us. There’s a sense of quiet and presence that only these two people experience—an intimate form of human connection.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-QiYOPP9n-wcxp5hr76tuQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Z6b5NL9pKXTELJOlYS16pw.png" /><figcaption>Danlin (L) and Edna’s (R) observations from both exercises</figcaption></figure><h3>WALKING</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*npIOPTGTapfTK2lQCuphHw.png" /><figcaption>Instructions for the exercise</figcaption></figure><p>We then continued with the walking exercises. Similar to the breathing exercises, we did the exercise twice, with a different partner each time.</p><p>We all found it quite difficult but generally had more success on our second try with new partners. Unlike with the breathing exercise, we found that strategies that worked with one person often transferred to working with another person. These were things like the size of the steps you were taking (smaller steps = easier to follow) and emphasizing lower body contact (touching heel to heel = easier to follow). We were very focused on our legs and the movement they were making, but afterwards we realized that walking, whether alone or back-to-back with someone else, is a full body exercise and we wondered if it would have been easier if we had linked arms or paid more attention to what our upper bodies were doing. We found it similar to any sort of pairs performance, like ice skating or ballroom dancing; in order to be successful you have to have a strong sense of where your partner is in space.</p><p>In this exercise, we noted the followers feeling like they’d been an <em>extension </em>of the leader. The movement and flow was dominated by the leader, leaving the follower as a sort of trailing entity. And to be a follower, it required full focus on all parts of the body and coming out of your own.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X_edA-wQ6YS-Y8YEGK_Cqg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uqKgE3a36h_3G_fh2g9G1Q.png" /><figcaption>Isabella (L) and Heeje’s (R) observations from both exercises</figcaption></figure><h3>REFLECTION</h3><p>To conclude, we discussed the implications this session could have on our midterm project. We noted how different and sometimes challenging effortless activities like walking and breathing feel when you shift your focus to someone else, and how this often comes with a renewed sense of your own body. This reminded us of embodied exercise practices like yoga and how collective exercise practices like spin classes, running groups, and yoga classes unlock a different mentality towards exercise (like pushing your limits, feeling connected, etc.)</p><p>We also spoke briefly about the mental health implications of embodied somaesthetic activities. Primarily things like attention to breath and its connection to mindfulness and meditation as well as EMDR therapy, which connects bodily movement to mental processing.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0f2caa35e03f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Lab 3: Sensing w/ Potentiometers]]></title>
            <link>https://medium.com/@fiorante/lab-3-sensing-w-potentiometers-109d51c37d4c?source=rss-877e628ee48c------2</link>
            <guid isPermaLink="false">https://medium.com/p/109d51c37d4c</guid>
            <dc:creator><![CDATA[Isabella Fiorante]]></dc:creator>
            <pubDate>Thu, 17 Sep 2026 07:46:16 GMT</pubDate>
            <atom:updated>2026-09-17T07:46:16.641Z</atom:updated>
            <content:encoded><![CDATA[<p>Isabella Fiorante. Professor Kimiko Ryokai. Tangible User Interfaces, Fall 2026</p><h3>Description</h3><p>In this week’s lab, we experimented with integrating potentiometers into our circuits to control the existing LEDs. I started by soldering the wires to two potentiometers, and running sample code to ensure they were properly soldered and connected within the circuit. I then proceeded with the first part of the lab: making one potentiometer control the blink rate of all three LEDs by easily modifying the provided <a href="https://docs.arduino.cc/built-in-examples/analog/AnalogInput/">sample code</a>. I simply added 2 extra LEDs to the code, basically multiplying any directions to “ledPin” to all three LEDs. I had some trouble because I moved my circuit to a larger breadboard to make connecting the potentiometers easier, and this resulted in the blue and red LEDs being incorrectly wired.</p><h3>Part 3: Multiple Potentiometers Controlling Multiple LEDs, Option 1</h3><p>I then worked through setting up <strong>Option 1</strong>: using one potentiometer to control LED brightness and the second to control the blink rate. I modified the code by referencing the built-in Arduino sketch for Analog Fading. While implementing this initial code, I ran into an unexpected bug where the brightness control worked, but the LEDs refused to blink and remained continuously lit.</p><p>During debugging, I identified a core issue in the control logic: <strong>PWM Timer Corruption.</strong> Switching directly between analogWrite() for brightness and digitalWrite(..., LOW) for the OFF state corrupted the hardware PWM timers on the Arduino&#39;s digital pins. To fix this, I replaced digitalWrite(..., LOW) with analogWrite(..., 0).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/794/0*vsXjtg1H-aCTiB-9.jpg" /><figcaption>Source: MadAboutRetroES on etsy.com</figcaption></figure><p>Next, I wanted to continue working with a more interesting mapping between the pots and LED output. Because I am currently exploring digitally augmented games for my thesis, I wanted to gamify this circuit set up by creating a physical search loop.</p><p>The user turns two knobs (Coarse Frequency and Fine Filter) to search through chaotic static. As they get closer to the target frequency, the interface provides visual feedback before locking into a clear SOS Morse code message (... --- ...).</p><p>This is an interactive <strong>“Radio Frequency Signal Finder”, </strong>simulating tuning an analog radio receiver to locate a hidden signal transmission.</p><h3>Components Used</h3><blockquote><em>1- Arduino UNO R4 Minima</em></blockquote><blockquote><em>1- Red LED</em></blockquote><blockquote><em>1- Green LED</em></blockquote><blockquote><em>1- Yellow LED</em></blockquote><blockquote><em>3- 220 Ohms Resistors</em></blockquote><blockquote><em>2- Potentiometers</em></blockquote><blockquote><em>1- Breadboard &amp; jumper wires</em></blockquote><blockquote><em>1- USB-C Connector</em></blockquote><h3>Circuit Set Up</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/610/1*FkM7MigA0Cvk4zbA6TI4Ng.png" /></figure><h3>Code</h3><pre>/* the following code was written with the help of gemini */</pre><pre><br><br><br>const int sensorPin1_FREQ = A0;   // select the input pin for the potentiometer<br>const int sensorPin2_FILTER = A1;<br>const int REDled = 10;      // select the pin for the LED<br>const int BLUEled = 11;      // select the pin for the LED<br>const int GREENled = 9;      // select the pin for the LED<br><br>// Target Tuning Values &amp; Tolerance<br>const int TARGET_FREQ   = 650; <br>const int TARGET_FILTER = 320; <br>const int TOLERANCE     = 100;<br><br>// Morse Code Pattern for &quot;SOS&quot; (... --- ...)<br>const int MORSE_TIMINGS[] = {<br>  200, 1,  100, 0,  200, 1,  100, 0,  200, 1,  300, 0, // S<br>  600, 1,  100, 0,  600, 1,  100, 0,  600, 1,  300, 0, // O<br>  200, 1,  100, 0,  200, 1,  100, 0,  200, 1,  1000, 0 // S<br>};<br>const int MORSE_STEPS = sizeof(MORSE_TIMINGS) / sizeof(MORSE_TIMINGS[0]) / 2;<br><br>// Shared Morse Timer<br>unsigned long morsePreviousMillis = 0;<br>int morseIndex = 0;<br><br>// Independent Unsynchronized Static Timers (One per LED)<br>unsigned long REDprevMillis   = 0;<br>unsigned long BLUEprevMillis  = 0;<br>unsigned long GREENprevMillis = 0;<br><br>int REDinterval   = 100;<br>int BLUEinterval  = 150;<br>int GREENinterval = 80;<br><br>bool REDstate   = false;<br>bool BLUEstate  = false;<br>bool GREENstate = false;<br><br>void setup() {<br>  // declare the ledPin as an OUTPUT:<br>  pinMode(REDled, OUTPUT);<br>  pinMode(BLUEled, OUTPUT);<br>  pinMode(GREENled, OUTPUT);<br>  Serial.begin(9600);<br>}<br><br>void loop() {<br>  int freqVal   = analogRead(sensorPin1_FREQ);<br>  int filterVal = analogRead(sensorPin2_FILTER);<br><br>  int freqDiff   = abs(freqVal - TARGET_FREQ);<br>  int filterDiff = abs(filterVal - TARGET_FILTER);<br>  int totalDiff  = freqDiff + filterDiff;<br><br>  // Combine differences to measure total error distance<br>  int totalDistance = freqDiff + filterDiff;<br><br>  unsigned long currentMillis = millis();<br><br>  // CHECK TUNING LOCK<br>  if (freqDiff &lt; TOLERANCE &amp;&amp; filterDiff &lt; TOLERANCE) {<br>    // --- SIGNAL LOCKED: Synchronized Morse Code ---<br>    int brightness = map(totalDiff, 0, TOLERANCE * 2, 255, 80);<br>    brightness = constrain(brightness, 80, 255);<br><br>    Serial.println(&quot;*** SIGNAL LOCKED (SOS) ***&quot;);<br><br>    int duration = MORSE_TIMINGS[morseIndex * 2];<br>    int state    = MORSE_TIMINGS[morseIndex * 2 + 1];<br><br>    if (currentMillis - morsePreviousMillis &gt;= (unsigned long)duration) {<br>      morsePreviousMillis = currentMillis;<br>      morseIndex = (morseIndex + 1) % MORSE_STEPS;<br>    }<br><br>    int outputPWM = state ? brightness : 0;<br>    analogWrite(REDled, outputPWM);<br>    analogWrite(BLUEled, outputPWM);<br>    analogWrite(GREENled, outputPWM);<br><br>  } else {<br>    // 2. OUT OF TUNE: Calculate Proximity (0 = Cold/Far, 100 = Warm/Close)<br>    // Max distance is roughly 1000 when both knobs are far away<br>    int proximity = map(totalDistance, TOLERANCE * 2, 1000, 100, 0);<br>    proximity = constrain(proximity, 0, 100);<br><br>    // Live feedback to Serial Monitor<br>    Serial.print(&quot;Pot1: &quot;); Serial.print(freqVal);<br>    Serial.print(&quot; | Pot2: &quot;); Serial.print(filterVal);<br>    Serial.print(&quot; -&gt; Signal Proximity: &quot;); Serial.print(proximity);<br>    Serial.println(&quot;%&quot;);<br><br>    // Dynamic Flash Rate (Geiger Counter Effect):<br>    // Cold (0%): Slow, calm flashes (400ms - 800ms)<br>    // Warm (100%): Hyper-fast frantic strobe (15ms - 40ms)<br>    int minDelay = map(proximity, 0, 100, 400, 15);<br>    int maxDelay = map(proximity, 0, 100, 800, 40);<br><br>    // RED LED Independent Timer<br>    if (currentMillis - REDprevMillis &gt;= (unsigned long)REDinterval) {<br>      REDprevMillis = currentMillis;<br>      REDstate = !REDstate;<br>      REDinterval = random(minDelay, maxDelay); // Pick a new random speed for next toggle<br>      analogWrite(REDled, REDstate ? 255 : 0) ;<br>    }<br><br>    // BLUE LED Independent Timer<br>    if (currentMillis - BLUEprevMillis &gt;= (unsigned long)BLUEinterval) {<br>      BLUEprevMillis = currentMillis;<br>      BLUEstate = !BLUEstate;<br>      BLUEinterval = random(minDelay, maxDelay);<br>      analogWrite(BLUEled, BLUEstate ? 255 : 0) ;<br>    }<br><br>    // GREEN LED Independent Timer<br>    if (currentMillis - GREENprevMillis &gt;= (unsigned long)GREENinterval) {<br>      GREENprevMillis = currentMillis;<br>      GREENstate = !GREENstate;<br>      GREENinterval = random(minDelay, maxDelay);<br>      analogWrite(GREENled, GREENstate ? 255 : 0) ;<br>    }<br>  }<br>}</pre><h3>Code iterations &amp; refinements</h3><p>Developing the final code required several iterative debugging steps to turn a simple blink circuit into a responsive game loop:</p><ol><li><strong>Transition to Non-Blocking </strong><strong>millis():</strong> Rewrote the state machine using millis() timing loops. This allowed the Arduino to read potentiometer inputs thousands of times per second, making brightness adjustments and blink frequency respond instantaneously to knob adjustments.</li><li><strong>Multi-Threaded Chaos Logic:</strong> To create convincing “radio static,” I set up independent millis() timers for each individual LED. When out of tune, each LED toggles randomly at its own unsynchronized rate and brightness level. Because of the order the LEDs update in, they appear somewhat synchronized in the video.</li><li><strong>Proximity Feedback &amp; Calibration:</strong> To solve the issue of the target zone being too hard to find, I introduced a dynamic distance calculation (totalDistance). As the user turns the knobs closer to the target values (512, 512), the chaos logic acts like a Geiger counter: accelerating from slow, lazy pulses to hyper-fast strobe flashes right before snapping into the clean, synchronized SOS Morse code pattern.</li><li><strong>Adding Serial Monitor Feedback for Game Calibration: </strong>Even after accelerating the LED flashing speed as the controls approached the target, finding the signal purely through the hardware LEDs was still pretty hard. Because both potentiometers had to hit specific thresholds simultaneously, testing the physical interaction felt like searching in the dark: I was still twisting both knobs at random, hoping to stumble across the right combination. To ease this barrier, I introduced real-time diagnostic output to the <strong>Arduino Serial Monitor</strong> to display a live Signal Proximity (%) readout alongside the raw potentiometer values (A0 and A1). Adding this visual feedback on the computer screen transformed the debugging and playtesting experience into more of a puzzle to be solved, and less like a lottery game.</li></ol><p>Adding a game-play aspect to this lab was a great opportunity to explore game feel and player agency for my thesis work on digitally augmented play. Early in the testing process, I realized just how frustrating the interaction was without adequate guidance. I filmed multiple takes of the “working” circuit only to be completely unable to find the signal and I can be heard huffing in frustration in the background.</p><p>Adding clearer visual feedback that exposed the proximity status transformed the experience. Instead of mindless trial and error, the user gains a sense of strategy and mastery. This iteration reinforced a core discovery for my thesis research: in digitally augmented games, tactile inputs rely heavily on clear, continuous feedback loops to turn physical actions into meaningful, playful interactions.</p><h3>Video</h3><p><a href="https://youtu.be/-uwH5Cqyc_g?si=FWwPB-bNRAwI8j_Q">https://youtu.be/-uwH5Cqyc_g?si=FWwPB-bNRAwI8j_Q</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=109d51c37d4c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Lab 2: Digital I/O + Light Diffusers]]></title>
            <link>https://medium.com/@fiorante/lab-2-digital-i-o-light-diffusers-27768dde63d7?source=rss-877e628ee48c------2</link>
            <guid isPermaLink="false">https://medium.com/p/27768dde63d7</guid>
            <dc:creator><![CDATA[Isabella Fiorante]]></dc:creator>
            <pubDate>Mon, 14 Sep 2026 17:56:48 GMT</pubDate>
            <atom:updated>2026-09-14T18:01:01.535Z</atom:updated>
            <content:encoded><![CDATA[<p>Isabella Fiorante. Professor Kimiko Ryokai. Tangible User Interfaces, Fall 2026</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iEtlc70ETvrKUrDpwdVJwg.gif" /></figure><h3><strong>Description</strong></h3><p>In this lab, we were asked to explore controlling LED brightness digitally using Pulse Width Modulation (PWM) and serial communication with the Arduino.</p><p>I set up a circuit with three discrete LEDs (Red, Green, Blue) connected to PWM pins 9, 10, and 11 and was able to get the test code to work well, which linked the LEDs to the keys ‘r’, ‘g’, and ‘b’, keys.</p><p>For this lab, I wanted to explore how soft materials can translate digital output into a distinct physical presence. I was particularly inspired by knitted lampshades, where structural yarn creates a tactile, diffused glow.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GD3L3fDrP_fbeeiRRGrkBA.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yzlSBjeDBk4Nt8QoVMgrfQ.jpeg" /><figcaption>inspiration (not my images, sources unknown)</figcaption></figure><p>To bring that concept into this assignment, I crafted a custom diffuser using a hand-knitted sleeve made from white bamboo yarn fitted over a 3D-printed inner shell (Height: 35 mm, Base Diameter: ~26.5 mm, Equator<strong>:</strong> 40 mm). The intersection of knitting and computation feels especially natural here, given their shared history: early digital logic and binary programming trace directly back to Jacquard card looms and loop-based craft patterns.</p><p>Getting the light to diffuse properly through the knitted shell was definitely the trickiest part of this lab. While the 3D-printed inner shell helped scatter the initial glare from the three discrete LEDs, the stockinette fabric in bamboo yarn ended up blocking more light than I wanted. Because the yarn creates a fairly dense, smooth fabric, the light came through a bit too muted rather than giving off that soft, rich glow I was going for.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sY8Xsg7fP2WTlJ-soypEbw.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uMQJIkmVjAzN0ez_rduD-Q.jpeg" /><figcaption>The diffuser with and without the knit addition</figcaption></figure><p>My fabrication techniques definitely need some work, and if I were to do this project again, I’d experiment with both material choice and shape:</p><ul><li><strong>Softer, Halo Yarns:</strong> The fuzzy halo of mohair fibers catches and scatters light along the outer edges of the yarn strands, create a cloud-like diffusion on the ends without needing a dense fabric structure.</li><li><strong>More interesting shapes:</strong> I would love to experiment with something other than a sphere. I really like the examples above, where the structure holding the knit lamp shade has more dimension.</li></ul><p>For the serial control, I wanted to tie in the ‘k’ and ‘p’ which are knitting pattern short hands for “knit” and “purl” (the two main types of knitting stitch). The keyboard inputs simulate “knitting” and “purling” dye into the fabric. Pressing <strong>‘k’</strong> or <strong>‘p’</strong> increases or decreases the dye intensity (brightness) of the active color channel in 10% steps, while pressing <strong>‘r’</strong>, <strong>‘g’</strong>, or <strong>‘b’</strong> selects which color bath to adjust.</p><h3>Components Used</h3><blockquote><em>1- Arduino UNO R4 Minima</em></blockquote><blockquote><em>1- Red LED</em></blockquote><blockquote><em>1- Green LED</em></blockquote><blockquote><em>1- Yellow LED</em></blockquote><blockquote><em>3- 220 Ohms Resistors</em></blockquote><blockquote><em>1- Breadboard &amp; jumper wires</em></blockquote><blockquote><em>1- USB-C Connector</em></blockquote><blockquote><em>1- Custom 3D-Printed Diffuser Shell with Hand-Knitted Cover</em></blockquote><h3>Code</h3><pre>the following code was written with the help of gemini</pre><pre>/*</pre><pre>* Serial RGB LED - Knit &amp; Yarn Dye Edition</pre><pre>* -----------------------------------------</pre><pre>* 1. Single key presses &#39;r&#39;, &#39;g&#39;, &#39;b&#39; increment brightness in steps (~10% per press).</pre><pre>* 2. &#39;k&#39; (knit) steps forward through the yarn dye spectrum.</pre><pre>* 3. &#39;p&#39; (purl) steps backward through the yarn dye spectrum.</pre><pre>*/</pre><pre>char serInString[100];</pre><pre>char colorCode;</pre><pre>int redPin   = 9;</pre><pre>int greenPin = 10;</pre><pre>int bluePin  = 11;</pre><pre>// Variables to keep track of current brightness levels (0-255)</pre><pre>int redVal   = 0;</pre><pre>int greenVal = 0;</pre><pre>int blueVal  = 0;</pre><pre>// Hue tracker for the Yarn Dye Generator (0 to 255)</pre><pre>int dyeHue = 0;</pre><pre>// Helper function to set LEDs and write out current values</pre><pre>void applyColors() {</pre><pre>analogWrite(redPin,   redVal);</pre><pre>analogWrite(greenPin, greenVal);</pre><pre>analogWrite(bluePin,  blueVal);</pre><pre>Serial.print(&quot;Current RGB: (&quot;);</pre><pre>Serial.print(redVal);</pre><pre>Serial.print(&quot;, &quot;);</pre><pre>Serial.print(greenVal);</pre><pre>Serial.print(&quot;, &quot;);</pre><pre>Serial.print(blueVal);</pre><pre>Serial.println(&quot;)&quot;);</pre><pre>}</pre><pre>// Converts a 0-255 hue value across the RGB color spectrum</pre><pre>void setHue(int hue) {</pre><pre>hue = hue % 256;</pre><pre>if (hue &lt; 85) {</pre><pre>redVal   = 255 - hue * 3;</pre><pre>greenVal = hue * 3;</pre><pre>blueVal  = 0;</pre><pre>} else if (hue &lt; 170) {</pre><pre>hue -= 85;</pre><pre>redVal   = 0;</pre><pre>greenVal = 255 - hue * 3;</pre><pre>blueVal  = hue * 3;</pre><pre>} else {</pre><pre>hue -= 170;</pre><pre>redVal   = hue * 3;</pre><pre>greenVal = 0;</pre><pre>blueVal  = 255 - hue * 3;</pre><pre>}</pre><pre>}</pre><pre>void setup() {</pre><pre>pinMode(redPin,   OUTPUT);</pre><pre>pinMode(greenPin, OUTPUT);</pre><pre>pinMode(bluePin,  OUTPUT);</pre><pre>Serial.begin(9600);</pre><pre>applyColors();</pre><pre>Serial.println(&quot;Commands:&quot;);</pre><pre>Serial.println(&quot; Press &#39;r&#39;, &#39;g&#39;, &#39;b&#39; to step channel brightness.&quot;);</pre><pre>Serial.println(&quot; Press &#39;k&#39; (knit) to step dye hue forward.&quot;);</pre><pre>Serial.println(&quot; Press &#39;p&#39; (purl) to step dye hue backward.&quot;);</pre><pre>}</pre><pre>void loop () {</pre><pre>memset(serInString, 0, 100);</pre><pre>readSerialString(serInString);</pre><pre>// Process each key typed in the buffer</pre><pre>for (int i = 0; serInString[i] != 0; i++) {</pre><pre>char ch = serInString[i];</pre><pre>// Requirement 2: Multiple key presses step brightness (~25 per press)</pre><pre>if (ch == &#39;r&#39;) {</pre><pre>redVal = (redVal + 25 &gt; 255) ? 0 : redVal + 25;</pre><pre>applyColors();</pre><pre>}</pre><pre>else if (ch == &#39;g&#39;) {</pre><pre>greenVal = (greenVal + 25 &gt; 255) ? 0 : greenVal + 25;</pre><pre>applyColors();</pre><pre>}</pre><pre>else if (ch == &#39;b&#39;) {</pre><pre>blueVal = (blueVal + 25 &gt; 255) ? 0 : blueVal + 25;</pre><pre>applyColors();</pre><pre>}</pre><pre>// Requirement 3: Yarn Dye Generator (k / p)</pre><pre>else if (ch == &#39;k&#39; || ch == &#39;K&#39;) {</pre><pre>dyeHue = (dyeHue + 15) % 256; // Step hue forward</pre><pre>setHue(dyeHue);</pre><pre>Serial.print(&quot;Knit stitch! Dye hue: &quot;);</pre><pre>Serial.println(dyeHue);</pre><pre>applyColors();</pre><pre>}</pre><pre>else if (ch == &#39;p&#39; || ch == &#39;P&#39;) {</pre><pre>dyeHue = (dyeHue - 15 &lt; 0) ? 240 : dyeHue - 15; // Step hue backward</pre><pre>setHue(dyeHue);</pre><pre>Serial.print(&quot;Purl stitch! Dye hue: &quot;);</pre><pre>Serial.println(dyeHue);</pre><pre>applyColors();</pre><pre>}</pre><pre>}</pre><pre>delay(100);</pre><pre>}</pre><pre>void readSerialString (char *strArray) {</pre><pre>int i = 0;</pre><pre>if(!Serial.available()) {</pre><pre>return;</pre><pre>}</pre><pre>while (Serial.available()) {</pre><pre>strArray[i] = Serial.read();</pre><pre>i++;</pre><pre>}</pre><pre>}</pre><h3>Video</h3><p><a href="https://youtu.be/L4Op1qHkOmA">https://youtu.be/L4Op1qHkOmA</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=27768dde63d7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Design Workshop: Tangible Bits]]></title>
            <link>https://medium.com/@fiorante/design-workshop-tangible-bits-6b9844a1f5bf?source=rss-877e628ee48c------2</link>
            <guid isPermaLink="false">https://medium.com/p/6b9844a1f5bf</guid>
            <dc:creator><![CDATA[Isabella Fiorante]]></dc:creator>
            <pubDate>Tue, 08 Sep 2026 05:26:34 GMT</pubDate>
            <atom:updated>2026-09-08T05:26:34.464Z</atom:updated>
            <content:encoded><![CDATA[<p>Thursday 27 Aug &amp; Tues 1 Sep</p><h4><strong>TEAM</strong></h4><blockquote><em>Anam Ahmed<br>Lady Yamile Leggett <br>Kazybek Beken <br>Navya Batra<br>Vivienne Lu<br>Isabella Fiorante</em></blockquote><h4>Ideation &amp; Discussion</h4><p>We started by discussing our favourite everyday objects, with a particular focus on touch and texture. Some things that came up were toothbrushes, NeeDohs, bicycles, coffee mugs, knitting needles, safety pins, and perfume sample bottles. We considered a lot of multi-use items, and spoke about what happens functionally and emotionally when you adjust the scale of an object. We kept coming back to our first two suggestions: the mug, and the NeeDoh.</p><h4>TUI</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w-GW6Jc0jfYopPzjO61hIQ.png" /></figure><p>We started to imagine a mug with an exterior covering in a special material, similar to a NeeDoh, that would allow us to mould and shape the handle or part that is held however we wanted. We thought about how this would would impact ergonomics and accessibility, as it could mould to be most comfortable for any hand. This could be particularly useful for those with mobility issues or arthritis in their hands, but could be a comfortable feature for everyone.</p><h4><strong>GUI</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*817wrV5qqHT2sAKXSknFZg.png" /></figure><p>When we thought about a mug as a GUI, instead of adding a screen to the mug, we imagined a mug with a weight sensor that would track how much liquid you’re consuming and update an app on a smartphone or computer. This felt more commercial and in line with consumer wearables that track fitness and health. Rather than having a user manually input their water consumption, this mug would automatically track it for them.</p><h4><strong>Radical Atoms</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fUDdR0v_4gOCLktultcVmg.png" /></figure><p>We then expanded on our TUI idea to include multi-uses for the mug, such as adding a spout when you need to pour liquids, or moulding a top if you need to transport your drink somewhere. The base could also be malleable enough to change shape and size, if you needed a shallow bowl for a pet to drink out of, or a narrow tumbler that fits in your car cup holder. In addition to ergonomic advantages and its implications for accessibility, we imagined that our fictional material would also have sustainability implications, as you would no longer need a different cup or mug for different situations, but rather one base could become a water bottle, travel tumbler, mug, matcha bowl, etc.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6b9844a1f5bf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Lab 1: (Traffic) LEDs]]></title>
            <link>https://medium.com/@fiorante/lab-1-traffic-leds-2275b99d57ac?source=rss-877e628ee48c------2</link>
            <guid isPermaLink="false">https://medium.com/p/2275b99d57ac</guid>
            <dc:creator><![CDATA[Isabella Fiorante]]></dc:creator>
            <pubDate>Tue, 08 Sep 2026 04:43:20 GMT</pubDate>
            <atom:updated>2026-09-08T04:43:20.461Z</atom:updated>
            <content:encoded><![CDATA[<p>Isabella Fiorante. Professor Kimiko Ryokai. Tangible User Interfaces, Fall 2026.</p><h3>Description</h3><p>This week we were tasked with making an LED blink using an Arduino Uno R4 Minima. Since I have previous experience in Arduino, this was smooth sailing so I decided to complicate the LED blink pattern.</p><p>At the end of the month I have a road test for my California driver’s license, which means driving all over East Bay and SF to practice. During these drives, I have been thinking about how roads and driving have their own unique visual language that is almost universally understood, except for quirks here and there (like no right on red in certain places) that function almost like slang or dialects. There aren’t a lot of written words used (outside of street names) so symbols and light are really important. Furthermore, there is a really interesting hand-eye connection that occurs when you drive a lot, and you’re able to take in a lot of visual information (turn signals, traffic lights, speed limits, road signage) and almost intuitively know what is important to you and what isn’t. This also got me thinking about how a car is sort of just one giant TUI.</p><p>Anyway, for this week’s lab I decided I would make a mini traffic light using my Arduino and LEDs. Originally, I wired up a red, yellow, and green LED and had them take turns turning on and off. I ran into a few issues with getting all three lights on, but it turns out my wires just weren’t pressed all the way into the breadboard. Oops. After getting all three blinking, I still felt that was a bit too simple, so I decided to add a small button. Now, the green light blinks consistently (in British Columbia, where I learned to drive, a blinking green light means the traffic light is pedestrian controlled, and will only change if someone hits the button — some fun driving ‘slang’ for ya!) until the button is pressed, at which point the yellow LED turns on for a moment, before the red LED follows. After a short wait, the green blink will return until the button is pressed again. This whole process mimics a pedestrian controlled traffic light.</p><h3>Components Used</h3><blockquote><em>1- Arduino UNO R4 Minima</em></blockquote><blockquote><em>1- Red LED</em></blockquote><blockquote><em>1- Green LED</em></blockquote><blockquote><em>1- Yellow LED</em></blockquote><blockquote><em>3- 220 Ohms Resistors</em></blockquote><blockquote><em>1- Button</em></blockquote><blockquote><em>1- 10k Ohms Resistor</em></blockquote><blockquote><em>Wires</em></blockquote><blockquote><em>USB-C Connector</em></blockquote><h3>Code</h3><pre><br>const int buttonPin = 7;  // the number of the pushbutton pin<br><br>const int RED = 13; // the number of the red LED pin<br>const int YELLOW = 12; // the number of the yellow LED pin<br>const int GREEN = 8; // the number of the green LED pin<br><br>int buttonState = 0;  // variable for reading the pushbutton status<br><br>void setup() {<br>  // initialize the LED pins as an outputs<br>   pinMode(RED, OUTPUT);<br>   pinMode(YELLOW, OUTPUT);<br>   pinMode(GREEN, OUTPUT);<br>// initialize the button pins as an input<br>   pinMode(buttonPin, INPUT);<br>}<br><br>void loop() {<br>  // read the state of the pushbutton value:<br>  buttonState = digitalRead(buttonPin);<br><br>  // check if the pushbutton is pressed. If it is, the buttonState is HIGH:<br>  if (buttonState == HIGH) {<br>    // turn green LED off and yellow LED on:<br>    digitalWrite(GREEN, LOW);<br>    digitalWrite(YELLOW, HIGH);  // change state of the LED by setting the pin to the HIGH voltage level<br>    delay(2000);                      // wait for a second<br>    // turn yellow LED off, and red LED on<br>    digitalWrite(YELLOW, LOW);   // change state of the LED by setting the pin to the LOW voltage level    <br>    digitalWrite(RED, HIGH);  // change state of the LED by setting the pin to the HIGH voltage level<br>    delay(5000);                      // wait for a second<br>    // turn red LED off<br>    digitalWrite(RED, LOW);   // change state of the LED by setting the pin to the LOW voltage level<br>    delay(1000);                      // wait for a second              <br>  } else {<br>    //blink green on and off<br>    digitalWrite(GREEN, HIGH);<br>    delay(500);                      // wait for a second<br>    digitalWrite(GREEN, LOW);   // change state of the LED by setting the pin to the LOW voltage level<br>    delay(500);                       // wait for a second<br>  }<br>}</pre><h3>Video</h3><iframe src="https://cdn.embedly.com/widgets/media.html?url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D-07vhlffZYE&amp;type=text%2Fhtml&amp;schema=youtube&amp;display_name=YouTube&amp;src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F-07vhlffZYE" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/2aef441a84ef2c4c4df1562b6f685925/href">https://medium.com/media/2aef441a84ef2c4c4df1562b6f685925/href</a></iframe><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*bKk5Y7rU5njZmHByWZcKgA.jpeg" /><figcaption>Pierre Vivant’s <em>Traffic Light Tree in London</em></figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2275b99d57ac" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>