Fish Tank!

Final Project Essay

Name: Connor MacFadyen (Partner: Max)

Professor: Young/Eric

Project Title

Fish Tank

Project Statement of Purpose *

During the initial project proposal, my partner and I had the idea of creating a pong-like game in which two users would play against each other with various interactive elements. After listening to the comments of the instructors, however, we realized that taking a simple game that already exists wouldn’t be enough. Realizing this, we began to brainstorm again on the different ideas we had in mind and how we could actually create a finished product. The idea we landed on was that of a Tamagotchi, one in which the user would use various sensors on Arduino to give different elements of nurturement to an egg in order to hatch it.

The concept behind this idea was to use the sensor in order to increase the stats and maintain the health of an egg to eventually hatch it. The problem we kept running into with this idea was creating a function in which the health would slowly decrease over time as well as creating a “max health” that couldn’t be passed without resulting in an overfeeding and death of the egg. After trying many times to come with an alternate solution, we felt that the idea of the project was lost without that functionality so we decided to abandon it. Our backup plan and the one we ended up presenting was our Fish Tank. A piece of interactive art in which the user would be able to use the Arduino and keyboards to control a body of water was what we came up with. Our intended audience being anyone who wanted a break from daily human to human interaction to just have some fun, we tried to keep the inputs self-explanatory and easy to use. The goal of our project was to create an “interactive pond” in which the user could interact with the Arduino Board in order to control different functions with fish and the pond itself.


Project Plan 

To turn our idea into a reality, we first included some of the ideas from our initial Tamagotchi design in using different sensors to control different aspects of something on processing. Incorporating our new found definitions of interaction post-midterm project, we tried to include as many different functions as we could. The first thing we decided to tackle was creating a pond. Initially, we used the sound function to create a wave representing a water level viewed from the side (like a fish tank).


Using this a basis for our pond, we started to add objects slowly that would move around the screen and bounce off the perimeter of the screen as we did in class. Turning these objects into fish however made us realize the awkwardness of a fish seemingly swimming backwards – so we had to flip the fishes position completely on impact with the border. The next step was to incorporate Arduino functionality using the moisture and pressure sensors. The idea we first had was to use the moisture sensor to control the height of the wave (more moisture equals a bigger wave). We then used the pressure sensor to create a tsunami like-effect in which the wave would go crazy at different intervals depending on applied pressure. Some of the comments we received about this idea, however, was the awkwardness of creating wave from the top while viewing the bowl from the side. After the user testing session, we tried to incorporate the use of the keyboard as well as we felt as if there wasn’t enough interaction. This, however, was a mistake due to the feedback we received during our presentation. Using both the Arduino board and the mousePressed function at the same time made the user focus on one or the other. The other main things we ended up changing was the perspective. Instead of viewing the bowl from the side, we decided to change it to more of a pond in which the user is looking down on the fish from above. While allowing us to include more interactivity, it limited the use of our sensors in the sense that their effects on the screen were less obvious than before. The functionality of the moisture sensor shifted from changing water levels to starting the game and creating the pond itself, while the pressure sensor became a means to create a bigger wave in correlation with the mousePressed function rather than being the only way to create a wave in our original code. These changes, while seeming to be insignificant at the time changed our entire project more than we intended them to.   Some of the functionality that we attempted to include but could not get to function properly was the “ease” function and new wave functionality. Our plan was to use the keyboard to spawn in some kind of “fish food” in which the existing fish on screen would slowly swim towards the piece of food at the same rate so that they would all arrive at the same time.

The trouble we had with this was getting the fish to flip like they do when they hit a wall in order to pursue the food. They would continually swim backwards and on top of each other which looked strange so we decided to focus more on the mousePressed functionality. Unlike our original code in which the side view was easily seen to be impacted by the pressure sensor, using mousePressed to create a wave-like ripple effect was extremely challenging. Like we used in the RGB circle in class, we attempted to use similar code but a single ripple did not look like water. Instead, we incorporated the code from a YouTube video by The Coding Train to create that ripple bound to mousePressed which resulted in a much cleaner ripple.

In theory, our new project looked much more interactive and aligned more with our definition of interaction in which input must be analyzed to produce a result, the functionality and ease of use suffered. We definitely strayed from our initial goal, to create something “self-explanatory and easy to use” and ended up with a result which left our presentation tester confused. Limiting inputs to the Arduino board rather than trying to include dual-functionality would have greatly benefited our final design.

Context and Significance 

A huge inspiration for our final project was the Thermodynamic of Bird Migration that we looked at in class earlier this semester;

I found the interaction of the birds and they avoided each other while still flowing freely to be especially beautiful and tried to create something similar with our project. With my newfound definition of interaction requiring two or more things analyzing each other and reacting accordingly (whether that be from human-human, computer-human, etc.) I would label our final result a success. The problem that we attempted to complete was mostly tackled though our final result definitely strays from our original brainstorming. Like Professor Young mentioned during our presentation, there are surely many similar projects that include fish moving around a screen, but what I liked about our and the most difficult part of our project was incorporating the use of the Arduino board to create results in processing. Because I didn’t have any prior experience with any kind of programming and little to no practice with the serial import functions, at least half of the time spent on the project was including that functionality in our final code.

With more time, I would have very much liked to include the ease function that I could not get to work. Based on the comments I received during the presentation, the interactivity of our project would have been greatly improved by this idea. Another prominent comment I received was the improvement of interaction through the use of different sensors. With more time and more practice, I would have liked to implement the idea that Nick presented in using an actual water tank and pressure sensor to control where the waves are created on processing.

Though our code and ideas changed multiple times (maybe even too many time) throughout the process of creating the final result, I think the project we arrived at would be a great basis for expansion and implementation of more functionality. With more practice, I think I could turn it into something simpler while at the same time including more interactivity to give the users a better experience with using our Fish Tank.

In conclusion, I have learned a great deal in my time spent in class and out of class with both Arduino and Processing. Though I was having some health issues and missed quite a few classes, my time spent in Interaction Lab this semester has inspired me to continue to take classes in which I have no experience, not for the grade but for the opportunity of improvement.

Thanks so much for the semester!


Demonstration of Final Project!



Media Controller

Date: 6 December 2018

Instructor: Eric&Young

Goal: To create a Processing sketch that controls media (images or video) by manipulating that media’s attributes using a physical controller made with Arduino.

Using two potentiometers, we altered an image in Processing with the input on Arduino. I chose an image of a cat that I found through one of the provided links and used the Pixel function in Processing to change it. The potentiometer was used to increase or decrease the pixel function and in turn increase or decrease the quality of the image.

With the requestImage function, I loaded the image below into the sketch and changed it with Arduino.



I found the reading interesting as it included many examples of the different ways human interaction with computers and systems can be expressed. Some of these examples were useful in gaining ideas on how to improve our final project. Though our project is more of a game and less full-body interaction, we were still able to realize the importance of interaction with the project itself if we want to make a successful design.

Etch-A-Sketch/Buzzer Documentation

Name: Connor MacFadyen

Instructor: Young/Eric



Out of all the recitation assignments we have been assigned thus far, I found this one to be the most difficult.  Rather than have something function solely through Arduino or Processing alone, this week we used both at the same time to make a more interactive model. The circuit building on Arduino wasn’t too much of a problem but the coding was a lot of effort and required a lot of help from classmates/instructors. The layout in Arduino and Processing themselves wasn’t too bad but connecting them and getting the assignment to actually function was rather difficult at first.


Task 1-  Etch A Sketch:

Using two potentiometers, we were tasked with having them control the x and y values on Processing and using them to draw some kind of image. Like I said above, the assembly itself was easy but I started running into complications when trying to send information from Arduino to Processing. Using the provided code, I was eventually able to get it to function properly, controlling an ellipse with x, and y, values.

Interaction: Processing reads the data it retrieves from the Arduino board.



Image result for two potentiometers arduino schematic

Task 2  – Musical Instrument:

I wasn’t able to complete the second assignment during class as I ran out of time. Receiving help from some of my friends who are also taking Interaction Lab, this one was much easier than the first. I was able to understand the implementation of data from Processing to Arduino much quicker than during the first assignment. Similar to the first, the assembly was simple but writing the actual code proved to be a hassle again. The first problem I ran into was forgetting that I needed to use mouseX and mouseY in order to get the tone to change and then using the tone function to actually get the buzzer to change tones based on position.


Schematic: Arduino reads input from the cursor in Processing and responds accordingly.

Image result for buzzer schematic arduino processing

//Arduino Etch A Sketch
void setup() {

void loop() {
  int sensor1 = analogRead(A0);
  int sensor2 = analogRead(A2);

  // keep this format
  Serial.print(",");  // put comma between sensor values
  Serial.println(); // add linefeed after sending the last sensor value

  // too fast communication might cause some latency in Processing
  // this delay resolves the issue.

//Processing Etch A Sketch
import processing.serial.*;

String myString = null;
Serial myPort;

int[] sensorValues;      /** this array stores values from Arduino **/

void setup() {
  size(500, 500);

void draw() {
float posX=map(sensorValues[0],0,1023,0,500);
float posY=map(sensorValues[1],0,1023,0,500);

void setupSerial() {
  myPort = new Serial(this, Serial.list()[0], 9600);

  // Throw out the first reading,
  // in case we started reading in the middle of a string from the sender.
  myString = myPort.readStringUntil( 10 );  // 10 = 'n'  Linefeed in ASCII
  myString = null;

  sensorValues = new int[NUM_OF_VALUES];

void updateSerial() {
  while (myPort.available() > 0) {
    myString = myPort.readStringUntil( 10 ); // 10 = 'n'  Linefeed in ASCII // corresponding ASCII code
    if (myString != null) {
      String[] serialInArray = split(trim(myString), ",");
      if (serialInArray.length == NUM_OF_VALUES) {
        for (int i=0; i<serialInArray.length; i++) {
           sensorValues[i] = int(serialInArray[i]);

//Arduino Musical Instrument
char valueFromProcessing;
void setup() {
  pinMode(9, OUTPUT);

void loop() {
  // to receive a value from Processing
  while (Serial.available()) {
    valueFromProcessing =;
  if (valueFromProcessing == 'A') {
  } else if (valueFromProcessing == 'B') {
  } else if (valueFromProcessing == 'C') {
  }else if (valueFromProcessing == 'D') {
  }else if (valueFromProcessing == 'E') {


//Processing Musical Instrument
import processing.serial.*;

Serial myPort;
int valueFromArduino;

void setup() {
  size(500, 500);

  myPort = new Serial(this, Serial.list()[0], 9600);

void draw() {
  // to send a value to the Arduino
}else if(keyCode==DOWN){
}else if(keyCode==LEFT){
}else if(keyCode==RIGHT){
}else if(keyCode==SHIFT){

Final Project Proposal

  • Name: Connor MacFadyen
  • Professor: Young/Eric

A. Project Title

Fantastic Pong

B. Project Statement of Purpose

After recognizing my own shortcomings with the midterm project and it’s lack of interaction, my new definition derived on what I learned during the process of the previous project has lead to the idea that my final will be based around. The goal of this project is to allow users to compete head-to-head in a game that requires nothing but motor skills and an Arduino board (with Processing). Requiring two users with no set outcome, my partner and I viewed this as interactive and wanted to recreate the classic game “Pong.”

C. Project Plan

Using two potentiometers as we used for the Etch-A-Sketch assignment we worked on during class, the two paddles at the end of the pong table will be controlled by the Arduino. Moving up and down based on the user’s inputs, the ball will move back and forth across the screen until one player fails to intercept the ball. When this happens, the player will score a point and an LED will light up near their potentiometer. The other idea we wanted to incorporate into our project is the use of the 8-digit LED in order to keep track of the player’s score.

Weekly plan:

week 12: creating the background of pong + functionality

week 13: incorporation of Arduino pots

week 14: final touches

D. Reference

The main of reference for this project being obviously the original game itself, I’d say that my experience with the midterm project also played a role in deciding what concept I would pursue the final. With a new definition of interaction and improved skills, I feel more confident in pursuing a game-like project as opposed to last time.

Recitation 8; Final Project – Connor

ID: cbm412

Instructors: Young/Eric

Preparatory Research And Analysis

A. Go back to your definition of interaction as you defined it during the group project. How has your work in this course involved that definition?

During the research project, I defined interaction as “requiring an action (input) that creates some other action a result of that input (output).” I think the work we have so far in the class fits with my definition in some ways but in others. In Arduino and processing, for example, the input would be the user writing the code and said coded program or circuit functioning smoothly. Where my definition failed was the midterm. My project too closely resembled a cause and effect reaction which I misunderstood as interaction.

B. Based on the initial definition and your experience developing and executing your midterm project, how has your definition of interaction evolved? Be as specific as possible.

After the midterm project, I realized that my definition of interaction needed to adapt to the class rather than rely on my prior understanding. I realized that my definition of interaction should focus more on human input and reception rather than solely on computer-computer based cause and effect. Since our midterm used Arduino as its base, I wrongly assumed that basing my project around the interaction between sensors and the board would be correct. Instead, I should have incorporated a better way for a user to interact with my design and put that first. Interaction should encompass all types, especially that between human and machine and how the machine can provide some kind of benefit for the user and focus more on the process that occurs between the two rather than a defined end result.

C. Research two other interactive projects, one that aligns with your definition of interaction and one that differs from it.

  1. Weather Thingy – Real-time climate sound controller

    – Using a weather station on a tripod microphone, the user is able to observe the effects of different climates on their music. I think this project aligns with my definition due to the fact that the input (climate in this case) has a direct and obvious impact on the music and changes the way it sounds.

  2. Prélude in ACGT – Sonification of personal (DNA) data

    – Using an array of pads running apps to display and personify his DNA, the creator of this project uses music to explore biology. Before my change in ideas regarding the definition of interaction, I believe this project goes against what I pictured. Rather than an obvious cause and effect, the confusing design explores the more entertaining side of interaction. After reevaluating my definition, however, I think that this project aligns with my new perspective even more than the first project I mentioned above.

D. Write a “new” definition of interaction in your own words. Draw from your account above and try to evolve your definition beyond the current convention.

Unlike cause and effect, interaction includes a “processing phase” in which information taken from one source is evaluated and reacted to accordingly. Whether it be between human-human, human-computer etc., interaction is the procedure in which subsequent actions are assessed and acted upon.

Week 7 Connor MacFadyen

ID; cbm412

Instructor; Young/Eric


Using my previous art piece, I decided to use the new mouseX, mouseY we learned along with void draw in order to make something that moves based on the cursor so it is never the same.


The homework was much more difficult than the in-class assignment. I really struggled with properly using the “if” command as I kept running into errors. I also had trouble integrating colorMode and ended up using stroke with RGB instead.


nt color2 = color(0);
int gray = color(100);
color gray2 = color(140);
//define size of window
int numRect = 0;

void setup() {
size(600 , 600);
//set color of shapes

void draw(){



rect (300 , 190 , 150 , 40);
fill (color2);

rect (300 , 230 , 170 , 50);
fill (gray2);

rect (290 , 200 , 160 , 40); 
rect (mouseX , mouseY , 150 , 80);

rect (295 , 300 , 60 , 100);
fill (gray);

rect (mouseX , mouseY , 70 , mouseY);

rect (mouseX , mouseY , 90 , 110);

rect (310 , 350 , 110 , 200);
fill (gray);
fill (color2);

rect (200 , 250 , mouseY , 100);

rect (200 , 240 , mouseX , 90);

rect ( 210 , 245 , mouseX , 90);

rect (360 , 200 , mouseX, mouseY);

rect ( 330 , mouseY , 190 , 80);

rect (mouseX , 300, 190, mouseY);

rect (310 , 200 , 170 , mouseX);

rect (300 , mouseX, 190 , 120);

rect (mouseY, mouseX , mouseY , mouseX);

rect (mouseX, 410, 400 , -290);

rect (21 , 400, 500 , -310);

rect (40 , 390, 500 , -200);

rect (70, 200, mouseX, -100);
fill (gray);

rect (mouseX, 300, 100, mouseY);
rect (300, mouseY, 70, -200);



//float variables
float r;
float g;
float b;
float a;
float radius = 0;
//true or false variable to make circle grow/shrink
boolean expand = true;
//starting x,y pos
int x = 300; 
int y = 300;
int move = 10;

void setup() {
//size of canvas  
  size(600, 600);


void draw() {
//change the color
  stroke(r, g, b); 
// shrink/expand ellipse
  if (expand) {
    if (radius == 75) {
      expand = false;
  } else {
    if (radius == 0) {
      expand = true;
//actual ellipse
  r = map(sin(frameCount * 0.025 + HALF_PI), -1, 1, 50, 255);
  g = map(sin(frameCount * 0.025 + PI), -1, 1, 50, 255);
  b = map(sin(frameCount * 0.025 + QUARTER_PI), -1, 1, 50, 255);
  a = map(sin(frameCount * 0.025), -1, 1, 50, 255);
//white canvas, include in draw so it refreshes
  ellipse(x, y, a, a);

void keyPressed() {
  if (key == CODED) {
    } if (keyCode == DOWN) {
     y = y + move;
  else if (keyCode == RIGHT){
    x = x + move;
  if (keyCode == UP) {
      y = y - move;
  if (keyCode == LEFT){
    x = x - move;

Recitation 6: Processing Basics – Connor

Name: Connor MacFadyen

Instructors: Young/Eric


Image result for sol lewitt



Rather than recreate an image, I tried to create my own art piece after looking at Sol Lewitt’s works online. I enjoyed looking at his use of rectangles and more contemporary style which lead me to create an image of my own. Though the majority of his work is cut and clean and follows the angles of the image precisely, I wanted to take that to the next level and create something more sporadic with a centralized core. Thus: Outside the Box


Different due to the more random design and differing strokeWeight’s but similar in the use of lines and simple shapes, trying to adjust to the reverse coordinate plane was somewhat of a difficulty. I had to redo many rectangles after remembering that the origin is set in the top left rather than the bottom right. Using Processing as a means to draw was enjoyable, even if it was creating simple rectangles branching off a central black box.



Midterm Blog Post – Connor

Name: Connor MacFadyen


Instructors: Young/Eric


Radiation Evaluation


2. PROJECT STATEMENT OF PURPOSE (150-250 words):                                                   

The idea for my project surfaced when I was browsing the web. As I was reading articles, I came upon a surprising fact – radiator and thermostat malfunction within the heating block of an engine is one of the main causes of engine failures and accidents. Road transportation being the main method of travel, I wanted to tackle the problem that is caused when leaks within the lower radiator tank throw off the entire cooling system of said engine. Problems arise when not enough coolant is flowing from the radiator to the cooling block – often times this is caused by a leaky or loose hose. By using a moisture sensor built into a hose, the driver will be alerted by an LED corresponding buzzer system in case of malfunction. The intended function of my project is to alert drivers of the danger that they are in before the possibility of an accident arises.                                                                                           

3.     LITERATURE AND ART, PERSPECTIVES AND CONTEXTS:                                                      

Though my project has less immediate interaction between human and system, I chose to pursue this idea after reading an article called “Useful, Usable, and Used: Why They Matter to Designers.” These three keywords, though much in the same, also have specific differences that create different functions for varying projects. For my project, in particular, I decided to focus more on the word “useful,” or the allowing of a task or objective to be completed. Steve Krug’s book Don’t Make me Think, though more to do with UX design and web-based programs makes many good points on the importance of efficiency and simplicity of a good design. Krug’s book helped me stay away from a design that tries to accomplish too much at once as I had originally planned for my project. Though I was at the doctor’s on the day of user testing, his work made me reevaluate my design without seeing it himself. I tried to make a project that would be useful to all, no matter the user. As the majority of the world in this day and age uses motor vehicles as a means of transportation, “Radiation Evaluation” has an intended and executable use that makes travel safer. An article I read by John Pribble III states that “Design describes the planning and decision-making process to determine the functions and characteristics of a product.” After reading this article, I realized that I had done the process of design backwards, as in choosing a sensor and doing research about what I can make said sensor do. Instead, I should have come up with an idea for my project, decided how I wanted to execute it and pick and choose appropriate components from there. This article resulted in me returning the original pressure sensors which I had borrowed from the IMA lab, and design an entirely new project.

 4.      PROJECT DESCRIPTION:                                             

My project, intended to be attached to the lower tank of a radiator within an automobile was designed to alert the user of danger when exposed to certain scenarios. Using a 3D printed container that can fit into the radiator itself, from the box extends a hose with an inserted moisture sensor. This moisture sensor, connected to an LED and a buzzer system through Arduino, alerts the user of any possible malfunctions that can occur within the heating block. If too much or too little coolant is flowing, the sensor will be able to detect this abnormality and the driver will be able to fix the problem before the situation escalates. The interaction I chose to pursue corresponds with concerns for the safety and well-being of the user, preventing danger and possible disaster. Many cases of engine failure are noticed too late – whether it resulting in a crash or a fire, Radiation Evaluation is designed to prevent this entirely and make the road a more comfortable space. When coolant is flowing properly and the engine is at a safe temperature, a separate LED blinks green to reassure the user of their safety. I decided to tackle this specific problem in particular due to past experiences I have with this situation. When I was younger, my brother had his legs almost severely burned (fine now) while driving a dune buggy around at the beach when he flipped over and a hose came loose. With this idea, I started with the code for simply turning on an LED, then slowly (as I learned how to use Arduino alone to complete something besides a circuit) morphed it into an LED activated by the moisture sensor. Afterwards, I was able to set the threshold based on research around the safe temperature for engines for which LED should be blinking, GREEN or RED. Finally, I was reading about how most road accidents other than those caused by a drunken driver, occurs when one or both of the drivers is distracted. FIguring that a small LED is easy to overlook when you’re driving, I decided to implement a looped buzzer melody only when the temperature of the engine falls into a dangerous zone.

5.    PROJECT SIGNIFICANCE:                        

My project, intended to be a solution to the problem that is ignorance on the functioning of engines and simultaneously prevents the problem that is an overheated motor, is significant in its purpose. It also highlights our society’s progression towards a more convenience based environment, removing the need to periodically check the radiator for wear and tear. In the long run, I hope that my design will be able to create a safer environment for all – being that any vehicle with an engine can benefit from my project.


My original design for my project was completely different from the finished project. In fact, my entire project was restarted when I was reminded that our partner was supposed to be from our lecture (something I missed). Starting completely from scratch and on my own, I returned the sensors I had previously borrowed and let my old partner pursue our original design instead. The biggest decision I had to make while creating my project was if I wanted to use a moisture sensor or a temperature sensor. Originally going to use a temperature sensor in turn with the thermostat in the engine, I decided against this for a few reasons; a main being that the thermostat within an automobile is subject to many outside factors like weather, etc.. Instead I decided to focus on the root of the problem, the coolant and work my way from there. Due to the fact that coolant is essential to the temperature and functioning of an engine, I found it much easier to assess and react accordingly to problems in this department as opposed to the thermostat. Though I didn’t receive any feedback from the User Testing Session due to a fever, I got some meaningful feedback from my friends back at the dorms. Their input was what influenced me to add a buzzer (playing an annoying and repetitive tune) in addition to the LED I had initially planned on using.


For the problem I decided to tackle, I would label my project as successful. However, I was unsuccessful in incorporating a significant amount of human interaction with my design. As Eric said, my project takes on more of an engineering problem rather than an interactive one. I don’t think time was an issue with this project except for the days that I was sick and unable to come to class. I also had a problem with the heart that pushed back my presentation which was unfortunate, to say the least. What I would like to improve on is making the design more hands-on and interactive from the perspective of the user. Rather than just alerting the driver that a problem has arisen, it would be nice to solve that problem simultaneously by, for example, adding more coolant. Though I pictured interaction from a complete system to system cause and effect loop, I should have designed the project around and an input and output based on human interaction – rather than somewhat of an alarm. In this regard, I would label my project as a fail. During this project, however, I greatly increased my ability to use code to determine and output, which was exciting for me. Working alone was by far the hardest part of the midterm, though I am fully to blame for it. There was no collaboration between me and my partner, as there wasn’t one and the result was me often just asking someone for a bit of help if I couldn’t get something to function properly. Overall, I enjoyed creating this project, even it wasn’t the best – I definitely learned from the experience and will use the skills I acquired during its creation to better myself for next time.

Midterm User Testing (6)

Documentation week 6: Midterm Project User Testing

Documentation by: Connor MacFadyen

Instructor: Parren/Young

Partner: N/A

Though I was sick on Friday, I had a few of my friends look over my project and observed how they reacted. At first, they were confused because my project is intended to fit such a niche role. Though it can have many uses, the INTENDED use of my project is to monitor the liquid intake in a car radiator to make sure it doesn’t overheat. The majority of engine failures and combustions has to do with the flow of liquid through the pipes in the radiator from either drying up or failing to flow. Living an area where the climate often reaches temperatures that makes cars overheat, I decided to try and solve this problem in some way with my Arduino kit.

One of my friends pointed out that just using an LED viewable from the dash (ideally) might not be enough to alert someone of a possible failure. In addition to the LED; I decided to borrow the code from a song I found online, using the buzzer I was able to set an “if” line where if the moisture of the pipe falls below a certain threshold, then the melody will play alerting drivers who may be otherwise distracted from noticing the LED.

Documentation Week 3 (Connor MacFadyen)

Connor MacFadyen 


Moisture Sensor:


Assembly of this circuit was relatively simple, we did, however, have a bit of trouble getting the LED to light up once the moisture level passed a certain threshold (sensorValue).  My partner and I had a lot of fun playing around with different levels of moisture: our fingers, a cup of water, etc.


What did you intend to assemble in the recitation exercise? If your sensor/actuator combination were to be used for pragmatic purposes, who would use it, why would they use it, and how could it be used?


During the recitation, my group decided to experiment with the moisture sensor. An actual way this device could be used other than the obvious implementations it could have in a farming setting would be to implement it into the drywall in residential areas. With a moisture sensor in the wall, residents would be able to detect any signs of water that might cause mold or mildew.


Can you identify your circuit with any device you interact within your daily life? How might your circuit be used to have a meaningful interaction?


A device with similar technology that we often use in daily life is a pH meter. By measuring the hydrogen-ion concentration in a solution, we can determine the acidity of said solution. pH meters have many applications, including determining If soil, for example, is suitable for farming.


How is code similar to following a recipe or tutorial?


Similar to a recipe, coding requires an input to create an output. By writing lines of code or adding a new ingredient to a dish, it’s difficult to determine the final product when analyzing step by step. For example, it’s difficult to determine the final output of an Arduino board after seeing only one line of code. In the same way, seeing “egg” as an ingredient doesn’t give much input to what dish is being made. Coding and cooking both have their own language, though they may be different. They both follow a sequence and a have a need for precision.



In Language of New Media, Manovich describes the influence of computers on new media. In what ways do you believe the computer influences our human behaviors?


What stands out to me the most about the role computers play in our daily lives is how fast they are advancing. In less than a generation, humans have moved from pong to virtual reality games on a wide scale. Though the technology of VR isn’t too advanced as of now, it’s very possible that by the end of this century there will be no need for communication in the physical world. Having smartphones and being able to communicate with people across the world on a device that fits in your palm is somewhat of a scary thing though. I believe humans are becoming too dependent on this technology, many of us can’t function properly and feel lost when we don’t have our phones with us. Face to face interaction is rapidly declining and is possible for declining birth rates in countries like Japan. The fun in life is found through struggle, but soon even the idea of work may be a thing of the past.