Tetragons

As I was browsing through the different computer graphics, many of them astonished me, but it was also quite a mystery how to recreate them. I must have jumped to the very beginning where everything started, however, just like computer graphics have experienced a major advancement in just a few decades, let’s hope that my work improves as well.

I chose a graphic with a lot of tetragons in it, and there was definitely something that spoke to me in this image. It was the messiness combined with the composition of the shapes in this graphic. Even though there is no symmetry going on, there is also something harmonic about how the shapes work together. I used a function called quad for each of the tetragons and it turned out to be the best function to use, as it essentially draws a four-sided polygon where the angle between two sides does not necessarily have to be 90 degrees. There are 8 values you need to determine for this function and they are the x and y coordinates for each of the corners.

The graphic consists of regularly shaped tetragons where all the 4 sides are of the same length and of irregularly shaped tetragons with different lengths of the sides and angles between them. To draw the regular tetragons I determined the coordinate of the center and measured the distance to the edges, which was the same in each case. That way I could draw a shape with the sides of the same length. For the irregular tetragons it was more challenging, as I had to determine the coordinate for each of the corners and also guess the coordinates of the points that are not in the image. I was usually not right with the first time, so I just had to keep changing the coordinates until I was satisfied with the result. I also added 4 lines as a frame for the sketch. This is the final result:

On the left is the original and not the right – my recreation. As you can see, the original is a little messier in the middle part as more lines are really close to each other there. In my recreation a lot of the lines in the middle are actually overlapping, therefore it doesn’t look as messy.

This is the code I used:

size (250, 350);
background (255,255,255);

noFill();

//squares
quad (105, 325, 75, 295, 105, 265, 135, 295);

quad (135, 235, 120, 220, 135, 205, 150, 220);
quad (130, 225, 105, 200, 130, 175, 155, 200);
quad (140, 225, 115, 200, 140, 175, 165, 200);
quad (93, 195, 75, 178, 93, 160, 110, 178);
quad (127, 170, 95, 137, 127, 105, 160, 137);

quad (150, 140, 135, 125, 150, 110, 165, 125); //the smallest


quad (115, 145, 85, 115, 120, 80, 150, 110);
quad (120, 310, 5, 195, 120, 80, 235, 195);

quad (110, 90, 75, 55, 110, 20, 145, 55);

//the rest
quad (160, 350, 40, 229, 156, 115, 350, 220);
quad (55, 245, 136, 160, 50, 70, -50, 154);

quad (200, 205, 85, 90, 168, -30, 390, -25);
quad (137, 164, 53, 78, 145, -80, 230, 75);

quad (225, 73, 180, 30, 225, -40, 300, 20);
quad (226, 55, 194, 25, 228, -40, 313, 16);

//the frame
line (0, 0, 250, 0);
line (0, 0, 0, 350);
line (249, 0, 249, 349);
line (0, 349, 249, 349);


Baby Steps For a Greater Future

The first steps into exploring something new are always the hardest. To me the story of Margaret Hamilton was very inspiring not only because she is a woman and was essentially doing things that were not really “female-like” back in the time, but also she didn’t lack the courage of working on something that no one really had an idea of where it would lead. However, it is only by taking risks that you can gain the most success. Not only it requires courage but also a level of stubbornness to keep working on something that is not yet explored. I am sure she must have had her moments of down (just like we all do) while working on a program that would essentially land people on the Moon, however she must have had a vision in her mind to hold on to whenever things were not working smoothly.

Margaret Hamilton seems like an almost unreal person. I find it incredible how she predicted things that could go wrong and actually wanted to fix them in advance, however was not given the permission to do that. NASA saying that “astronauts would not make any mistakes” was naïve and irresponsible, because we have to realize that humans make and always will make mistakes, which is actually what Hamilton predicted when she was getting worried whether an astronaut would not launch the wrong program during flight. Luckily, when it happened, it ended without any casualties, however, I think that there is a great lesson to learn from this and carry in the future – predict and calculate the errors that people could make and try to deal with that before it has actually happened to create a safer future.

But look at the world now! It basically runs on software and functions the way it does today because of the very crucial steps made by Margaret Hamilton and other inspired people who simply had a vision. The further appliances of software are immense; for example, in art installations, which is also discussed in Casey Reas’ Eyeo talk. Software allows the piece of art turn into an unexpected direction and makes it unique each and every time someone interacts with it. Many opportunities possible now are all a result of crucial discoveries made earlier. And the best part is that there is still room where to grow, we just have to have the courage to explore!

Blonde Hair Don’t Care

Creating a self-portrait using Processing definitely requires some imagination in order to see me in the little geometrically shaped figure. However, that’s me – in a blue dress, with long blonde hair and a balloon in my hands!

Face, neck and hair:
To create the shape of the hair I used an arc and a rectangular in a blonde color, for the head I used an ellipse in skin color, for the neck – a rectangular in skin color, for the eyes – two black ellipses and for the mouth – a white arc.

Upper body:
For my upper body I used a sky blue triangle as the shape for the left edge of the dress, for the shoulder I used an ellipse in skin color, for the arms – two rectangulars in skin color (the right arm is extended), for the right edge of the dress – another sky blue triangle and for the part of the dress that’s on my torso – a sky blue rectangular.

Lower body:
For my lower body I simply used to rectangulars in skin color for my legs.

I also decided to add a feature that by pressing the mouse it’s possible to draw something on the sketch. That is the reason why my right hand is extended, therefore you can draw something that I’m holding in the arm. Initially it was a balloon, however, it is possible to draw whatever thing you want to. Because of the balloon I added the feature of two colors – when key “R” is pressed, the line you draw is red, but when you press “B” – it’s black again (black is also the default color if no keys are pressed). I could also add some more colors to make even more options what to draw!

This is the code I used:

//colors
color mouseColor = color(0,0,0); 
color black = color(0,0,0);
color luizeSkyBlue = color(135,206,235);
color skinColor = color(237,211,138);
color blonde = color(255,255,110);

//general
int centralX;
//head coordinates and dimensions
int headCenterY = 100; //y-coordinate of head center
int headWidth = 30;
int headHeight = 40;
//mouth
int mouthWidth = 13;
int mouthOffset = 8; //offset from head center
//hair
int hairWidth = 40;
int hairLength = 100;
//eyes
int eyeDiameter = 5;
int eyeOffset = 4; //offset from head center
//neck
int neckWidth = 10;
//shoulders
int armWidth = 20;
//arms
int armLength = 60;
//torso coordinates and dimensions
int torsoWidth = 20;
int torsoHeight = 110;
int torsoTopY;
int torsoBottomY;
//dress
int dressOffset = 25; //offset of the dress' bottom from the edge of the torso
//legs coordinates and dimensions
int legOffset = 5; //ofset from the edge of the torso
int legWidth = 12; 
int legHeight = 70;
int thighGap = 4;



void setup() {
 size(640,360);
 
 centralX = width/2;
 torsoTopY = headCenterY + headHeight/2 + 2;
 torsoBottomY = torsoTopY + torsoHeight;
 
 background(60,110,130);
}

void draw() {

 noStroke();
 
 //face, neck and hair
 //hair
 fill(blonde);
 arc(centralX, headCenterY, hairWidth,hairWidth + 10, PI, PI*2);
 rect(centralX - hairWidth/2, headCenterY, hairWidth, hairLength);
 //head
 fill(skinColor);
 ellipse(centralX, headCenterY, headWidth, headHeight);
 //neck
 rect(centralX - neckWidth/2, headCenterY, neckWidth, 50);
 //eyes
 fill(black);
 ellipse(centralX - eyeDiameter, headCenterY - eyeOffset, eyeDiameter, eyeDiameter);
 ellipse(centralX + eyeDiameter, headCenterY - eyeOffset, eyeDiameter, eyeDiameter);
 //mouth
 fill(255);
 arc(centralX, headCenterY + mouthOffset, mouthWidth, mouthWidth, 0, PI);
 
 //upper body
 //left edge of the dress
 fill(luizeSkyBlue);
 triangle(centralX - torsoWidth/2, torsoTopY,centralX - torsoWidth/2, torsoBottomY, centralX - torsoWidth/2 - dressOffset, torsoBottomY); //left side
 //shoulder
 fill(skinColor);
 ellipse(centralX - torsoWidth/2, torsoTopY + armWidth/2, armWidth, armWidth); //left side
 //arms
 rect(centralX - torsoWidth/2 - armWidth/2, torsoTopY + armWidth/2, armWidth, armLength); //left
 rect(centralX + torsoWidth/2 - armWidth/2, torsoTopY, armLength + 5 , armWidth/2); //right extended
 //right edge of the dress
 fill(luizeSkyBlue);
 triangle(centralX + torsoWidth/2, torsoTopY,centralX + torsoWidth/2, torsoBottomY, centralX + torsoWidth/2 + dressOffset, torsoBottomY); //right side
 //dress-torso
 fill(luizeSkyBlue);
 rect(centralX - torsoWidth/2, torsoTopY , torsoWidth, torsoHeight);
 
 //lower body
 //legs
 fill(skinColor);
 rect(centralX - legWidth - thighGap/2, torsoBottomY, legWidth, legHeight); //left
 rect(centralX + thighGap/2, torsoBottomY, legWidth, legHeight); //right
 
}

//draw the balloon
void mouseDragged() {
 stroke(mouseColor);
 strokeWeight(1);
 line(mouseX, mouseY, pmouseX, pmouseY);
}

void keyPressed() {
 if(key == 'B' || key == 'b') {
 mouseColor = color(0,0,0);
 }else if(key == 'R' || key <= 'r'){
 mouseColor = color(253,49,69);
 }
}

And this is a very abstract me! Even though there is quite a lot of imagining to do, I do indeed like blue dresses and balloons!

Luize Rieksta

Michael Phelps in The IM Lab

Creating a human-like motion seemed quite challenging by using a motor, as the crazy spinning motion was a little intimidating at first. After experimenting a little with the speed of the motor and how attaching different objects affected it, I came to a conclusion that something had to slow it down, in order to make the motion more natural. Instead of using gears, I decided to attach a heavier object on top of the spinning part of the motor. The human-like motion I tried to recreate was the movement of a swimmer’s arm when they swim in front crawl. Even though I tried to make it as natural as possible, it still obviously seems too fast and uncontrolled, however, it can be pretty amusing to watch.

This is how I created my Olympic gold medalist:

  1. I started by connecting the motor to the circuit. In the picture you can also see a button on the breadboard, however it was not used for the actual project. I was initially trying out different methods how to make the swimmer’s arm move.

  1. This is the code I wrote for the motor to work. I ended up using a sine wave function, that should supposedly make the motor accelerate and slow down as smoothly as the function of a sine wave (can be seen below). Other than that, the code was pretty simple and the most challenging part was the actual design part.

void setup() {
 // put your setup code here, to run once:
 pinMode(3, OUTPUT);

 Serial.begin(9600);
}

void loop() {

 
 float sineWave = sin( millis()*0.00005);
 sineWave += 1; //this makes it go between 0 and 2
 sineWave *= 2; //multiply, goes between 0 & 100
 sineWave += 20;
 Serial.println( sineWave );
 analogWrite(3, sineWave);


}
  1. For the base of the swimmer I printed out a picture of a swimmer, cut out a hole in the middle, where the arm is supposed to start to put the motor in there. I also created a cardboard arm, which is put on top of the motor and will essentially be the key for gaining those gold medals!

  1. I also created a base for the whole construction itself by gluing some wooden sticks to a piece of cardboard (actually reused from my previous project) and also cut a hole in there.

  1. I then put the motor through the cardboard base and it stayed in there because of the friction between the motor and the cardboard around it. The breadboard can be easily hidden below the piece of cardboard.

  1. Then I put the picture of the swimmer on the motor, added a piece of double-sided tape on top of the spinning part and then stuck on the arm.
The swimmer on the motor
Double-sided tape
The whole construction finished
From a different angle

Here are two videos of the Olympic swimmer. In order to begin the motion, you need to give the arm a momentum by giving it a light push, but it continues to swim without ever getting tired afterwards. In the second video it can be clearly seen how the whole construction also moves a little along with the arm. That is because I didn’t precisely attach them to the cardboard, therefore they were all different heights and caused the construction to be a little unstable. However, I find that it gives a special effect, as it makes observing the tireless swimmer even more entertaining!

Luize Rieksta

Spot The North Star

For the midterm project I wanted to create something that has a lot of meaning for me and thus hopefully also deliver the meaning to the people interacting with my project. As I was scrolling through ideas in my head, there was one particular vision that I just could not let go of, and it was recreating the night sky full of stars. I’ve always thought that there is something magical about staring at the sky and spotting different constellations one by one, and this was an opportunity to make it happen anywhere and at anytime of the day.

This is how my project functions: you first see a platform with the shape of feet drawn on it that makes you want to step on it and see what happens next. As you step on the platform, there is a moon above your head that moves in an upwards direction, therefore drawing your attention and making you look up to see what happened. When you look up, you see the moon that just moved and the night sky with two constellations in it – the Big Dipper and the Little Dipper. There are then two photocell sensors right in front of you and by approaching them with your hands (creating darkness) you slowly light up the stars in the sky one by one. Just like in nature – you can only see the stars when it’s dark. You light up the Big Dipper with the left hand and the Little Dipper with the right hand. The very last star that lights up is the North Star – located at the end of the tale of the Little Dipper. The project is called Spot The North Star, because this is also how you find the North Star in nature – by spotting the Big Dipper and drawing an imaginary line upwards from the two stars on its right side; the star that the line leads up to is the North Star.

After having a vivid image in my head of how I wanted my project to look like, these are the steps I followed to create it:

  1. I started by finding the perfect LEDs for the stars (I mostly used UV LEDs as they have an almost magical sheen to them and they kind of look like real stars) and then connecting them to the circuit. I also added a photocell sensor that controls the way the stars will light up. I ended up using two Arduinos, because there were not enough output pins in one Arduino, and each of the constellations was controlled by a different Arduino.

  1. On another breadboard I connected a servo that was connected to a pressure sensor. This servo is responsible for the motion of the moon. The moon moves up by 45 degrees if you apply pressure to the sensor.
(I’m also lighting up the LEDs in this picture)

This is what the moon looks like when attached to the sensor. I ended up using some kind of a wire to attach it, as it seemed like the most stable way.

  1. I then transformed a piece of cardboard into the night sky by first gluing dark paper that has stars on it and then covering it with a piece of dark blue fabric. I attached the fabric with some pins.

  1. I created holes in the cardboard and the fabric to add the LEDs there in the shape of the constellations. There is a total of 14 LEDs (7 for each of the Dipper). The last LED of the Little Dipper is not a UV LED, as I wanted it to stand out from the rest, because it is the North Star. I would have probably avoided a lot of trouble in this step if I had just created the holes in the cardboard before pinning the fabric to it, because now it was quite challenging to cut through both the cardboard and the fabric at the same time and maintain a correct shape of the constellations, because the fabric is not firmly attached to the cardboard. However, this is what the LEDs looked like when not lit up.

  1. It was then time for the most challenging part of the project – elevating it from the ground. To avoid soldering, I just started adding crocodile wires to the legs of the LEDs on the other side of the cardboard. And then…more wires…. And more wires…

  1. After adding wires to all of the LEDs I attached the cardboard on the top of a shelf using the same wire I used for the moon and the servo. And connected the crocodile wires from the LEDs to the breadboards that are situated one shelf below. It is overall a little mess of wires:

Before attaching the crocodile wires to the breadboards

After attaching the crocodile wires to the breadboards
  1. I then attached the servo with the moon using some wire on the right side of the cardboard with the sky. And attached a big piece of cloth in front of all the wires to cover them up and give more of an illusion of the night sky. Here are pictures of the project from different angles:

  1. Lastly I created a platform with the shape of feet drawn on it, which had the background of the night sky. Then I attached the pressure sensor below one of the foot, therefore, when stepping on it, there would be pressure applied to the sensor and the moon would move up in the sky. I also pinned trough the cloth with the legs of the photocell sensors, so they would be located at the height of a person’s arms when they are put in front of them.

 

The code for the Arduino controlling the Big Dipper and the moon:

#include <Servo.h>
Servo myservo;
int pos = 0; 

const int ledPin = 2;
const int ledPin2 = 3;
const int ledPin3 = 4;
const int ledPin4 = 5;
const int ledPin5 = 6;
const int ledPin6 = 7;
const int ledPin7 = 8;

int ledState = HIGH;
int ledState2 = HIGH;
int ledState3 = HIGH;
int ledState4 = HIGH;
int ledState5 = HIGH;
int ledState6 = HIGH;
int ledState7 = HIGH;

void setup() {
 myservo.attach(9); 

 pinMode(ledPin, OUTPUT);
 pinMode(ledPin2, OUTPUT);
 pinMode(ledPin3, OUTPUT);
 pinMode(ledPin4, OUTPUT);
 pinMode(ledPin5, OUTPUT);
 pinMode(ledPin6, OUTPUT);
 pinMode(ledPin7, OUTPUT);
 
 Serial.begin(9600);

}

void loop() {
 int sensorReadingPressure = analogRead(A1);
 
 
 Serial.println(sensorReadingPressure);

if (sensorReadingPressure>500) {
 myservo.write(100);
 } else {
 myservo.write(45);
 }

 int sensorReading = analogRead(A5);
 
 Serial.println(sensorReading);


if (sensorReading<450) {
 ledState = HIGH;
 } else {
 ledState = LOW;
 }

if (sensorReading<400) {
 ledState2 = HIGH;
 } else {
 ledState2 = LOW;
 }

if (sensorReading<350) {
 ledState3 = HIGH;
 } else {
 ledState3 = LOW;
 }

if (sensorReading<300) {
 ledState4 = HIGH;
 } else {
 ledState4 = LOW;
 }

if (sensorReading<250) {
 ledState5 = HIGH;
 } else {
 ledState5 = LOW;
 }

if (sensorReading<200) {
 ledState6 = HIGH;
 } else {
 ledState6 = LOW;
 }

if (sensorReading<180) {
 ledState7 = HIGH;
 } else {
 ledState7 = LOW;
 }


 digitalWrite(ledPin, ledState);
 digitalWrite(ledPin2, ledState2);
 digitalWrite(ledPin3, ledState3);
 digitalWrite(ledPin4, ledState4);
 digitalWrite(ledPin5, ledState5);
 digitalWrite(ledPin6, ledState6);
 digitalWrite(ledPin7, ledState7);


}

The code for the Arduino controlling the Little Dipper:

const int ledPin = 2;
const int ledPin2 = 3;
const int ledPin3 = 4;
const int ledPin4 = 5;
const int ledPin5 = 6;
const int ledPin6 = 7;
const int ledPin7 = 8;

int ledState = HIGH;
int ledState2 = HIGH;
int ledState3 = HIGH;
int ledState4 = HIGH;
int ledState5 = HIGH;
int ledState6 = HIGH;
int ledState7 = HIGH;


void setup() {
 pinMode(ledPin, OUTPUT);
 pinMode(ledPin2, OUTPUT);
 pinMode(ledPin3, OUTPUT);
 pinMode(ledPin4, OUTPUT);
 pinMode(ledPin5, OUTPUT);
 pinMode(ledPin6, OUTPUT);
 pinMode(ledPin7, OUTPUT);
 Serial.begin(9600);


}

void loop() {
 int sensorReading = analogRead(A5);
 
 Serial.println(sensorReading);


if (sensorReading<510) {
 ledState = HIGH;
 } else {
 ledState = LOW;
 }

if (sensorReading<460) {
 ledState2 = HIGH;
 } else {
 ledState2 = LOW;
 }

if (sensorReading<410) {
 ledState3 = HIGH;
 } else {
 ledState3 = LOW;
 }

if (sensorReading<360) {
 ledState4 = HIGH;
 } else {
 ledState4 = LOW;
 }

if (sensorReading<310) {
 ledState5 = HIGH;
 } else {
 ledState5 = LOW;
 }

if (sensorReading<260) {
 ledState6 = HIGH;
 } else {
 ledState6 = LOW;
 }

if (sensorReading<200) {
 ledState7 = HIGH;
 } else {
 ledState7 = LOW;
 }


 digitalWrite(ledPin, ledState);
 digitalWrite(ledPin2, ledState2);
 digitalWrite(ledPin3, ledState3);
 digitalWrite(ledPin4, ledState4);
 digitalWrite(ledPin5, ledState5);
 digitalWrite(ledPin6, ledState6);
 digitalWrite(ledPin7, ledState7);
 
}

And voila! This is the final project and some videos of me interacting with it!

 

The motion of the moon (by pressing down on the platform):

A full interaction:

Interaction with the photocell sensors:

Lighting up the constellations:

Luize Rieksta

What is Design Around Us?

In the talk by Roberto Casati I found myself rather disappointed with again not being able to define what design is. It seems to me that in the modern world, where a functional object can look nothing like we are used to seeing it, it is very easy to confuse what design really is. I guess I had a hope that Roberto Casati might give a clearer definition as the name of the talk sounded very promising – “The Norm of Design”, however, taking into account that he used to be a philosopher, a straight-forward definition might not be something to expect from a philosopher. Nevertheless, everything is not as gloomy as it seems. Even though according to Casati design cannot be clearly defined, it doesn’t mean that it cannot be found in different objects around us. The discussion that Roberto Casati led was whether or not there is design in those objects.

One example that Casati gave was whether soft covers for table corners can be considered as design. It is a common problem to see children bumping into those sharp corners of tables and banging their heads against them. One of the solutions for that are soft, silicone-like covers that you can stick on the sharp edges of a table. Even though according to Casati they could be considered design, in my opinion, it is taking the original product and altering its look, which changes its initial design.
At the end of the day I feel like design remains something that we all have our own definition for. There is really no universal definition for design, which means that there may be discussions about this question, however no correct answer.

It All Starts With The C Major Scale…

Every good musical instrument needs practice in order to learn how to play it. My project for this week is no exception. I decided to make an instrument for which you need one or both hands to play it, and with the motion of your hands it is possible to produce 8 sounds at different speeds. This is how I made it:

I started with connecting 2 photocell sensors to a small speaker in my circuit. One of the sensors is responsible for the pitch of the sound the speaker makes and the other – for the speed. These are pictures of my circuit:

I then programmed 8 different sounds that can be produced depending on how much light falls on the sensor. The sounds are all the notes of a C major scale – C, D, E, F, G, A, B, C (do, re, mi, fa, sol, la, ti, do). Therefore, it is possible to play a full scale just with the motion of your hand. However, it definitely takes some practice to master at what speed the hand should be moved in order to switch from one note to another. When the room is brightly lit and there is plenty of light falling on the sensor the speaker plays the note C (262 Hz).

The other sensor then works by controlling for how long one note is played. The range is from one millisecond to 1023 milliseconds, and the less light falls on the sensor, the faster the note is played. You can play this instrument by using both sensors or just one – in the beginning it might be easier to practice the scale when the speed is relatively slow, however, once you have mastered that, you can then experiment with the speed and use both hands. Actually, it is even possible to play some simple songs in the range of those 8 notes, but I wanted to start with the C major scale, because, as with every musical instrument, it is what you usually start with.
I also made the legs of the photocell sensors longer by soldering them to some wires; therefore I was able to hide the rest of the wires, the Arduino and the breadboard. I designed a box for my musical instrument and this is how it looks (I cut a hole on the side for the cable coming from the Arduino); now it is even harder to tell where the sound comes from:

The final look of my musical instrument:

The code I used:

int freq = 100;
void setup() {
int sensorReading = analogRead(A0);
int sensorReadingSpeed = analogRead(A5);

Serial.begin(9600);
}

void loop() {
 
 
 int sensorReading = analogRead(A0);
 int sensorReadingSpeed = analogRead(A5);
 Serial.println(sensorReading);
 Serial.println(sensorReadingSpeed);
 
 freq = sensorReading;
 

 
if (freq<=500) {
 tone (3, 523, sensorReadingSpeed);
}

else if (freq<600) {
 tone (3, 494, sensorReadingSpeed);

}
else if (freq<720) {
 tone (3, 440, sensorReadingSpeed);
}

else if (freq<750) {
 tone (3, 392, sensorReadingSpeed);
}

else if (freq<780) {
 tone (3, 349, sensorReadingSpeed);
}

else if (freq<820) {
 tone (3, 330, sensorReadingSpeed);
}

else if (freq<845) {
 tone (3, 294, sensorReadingSpeed);
}

else if (freq<1023) {
 tone (3, 262, sensorReadingSpeed);
}
 delay (sensorReadingSpeed + 10);
 
}

The biggest drawback of this musical instrument is that it acts differently in differently lit rooms. If you practice playing it in, for example, the IM lab, you will need to practice again in a different room with different lighting, because the same motion of your hands won’t produce the same sounds anymore as there will be different light falling on the sensors. However, no musical instrument can be learned without practice.

Here are 2 videos of me playing my musical instrument. In the first one you can see me doing the scale by lowering my hand towards the sensor (it was filmed when the instrument was not finished yet), but in the second I am just playing with both of the sensors – the speed and the pitch of the sound at the same time.

Luize Rieksta

Should Disabilities Be Hidden or Embraced?

When talking about disabilities I think that very rarely one would think of connecting it to design. We are used to thinking about disabilities as a consequence of an unfortunate event which then often becomes a burden for the person for usually the rest of his or her life. Because disability is not something that people usually like to emphasize or show off with, it tends to be hidden on purpose, and detailed design (except for functionality) is usually not something you need to worry about for something that is not visible anyway. However, the author of Disability Meets Design suggests several examples where disability does not actually have to be hidden, therefore the items used by disabled people can be well-designed.

One of the most obvious examples is glasses, however I believe that it can be debatable whether bad vision is actually a disability. The glass example struck me though, because I find it interesting how they’ve become an accessory rather than a medical object. It is astonishing how people are now willing to spend loads and loads of money on a pair of glasses, because they see them as a component of their look. I think that just as with glasses, a huge step in the future is making people less ashamed or less willing to hide more severe disabilities. Obviously there are already people doing that, for example, Aimee Mullin who is mentioned in the text, but in general it is yet not so common to embrace disabilities with design. However, I think that design in, let’s say, legwear could possibly make people with disabilities feel more normal and just like anyone else, because for once they wouldn’t have to hide them but actually make them a regular part of their life.

To Shut Up or Tell a Story?

That’s a question not only faced by professional artists, but even I’ve been trying to answer it in my so far relatively small experience of creating interactive projects. Having read several readings about this topic, I find myself a little confused about whether less indications are really better, what is the boundary between making something absolutely straight-forward or leave some room for improvisation, how much the viewer, spectator or consumer will be able to translate from the object they are interacting with, etc.

So far it seems that generally good design indicates little or no indications at all and everything should be understandable straight away to the person interacting with the object. However, in my third project I found it rather difficult to immediately realize what you need to do in order to initiate the unexpected LED changes. Generally, it is commonly believed that people have a tendency to press a button if they see it in front of them, turn a knob if it’s there, etc. However, in my project it was not that straight-forward, because firstly, not everyone knows what a photocell sensor is and how it looks and secondly, even if they did, it might not be that easy to figure out my intentions of how to use the figures that are supposed to be placed on the sensors in order to create darkness. That’s why I decided to go with a simple indication which tells where to place the figures for some changes to occur. After this little “push”, it is then up to the people who interact with my project to figure out, for example, which figures they are going to use on which sensor. In this case I believe that it is absolutely normal to use some indications as it will simply alleviate the process of interacting with my project.

A lot of ideas of physical computing where gathered in the second reading about physical computing’s greatest hits and misses. Similarly to what I talked about in the previous paragraphs, I do not think that the chosen projects are all that straight-forward if no indications or signs were used. How can you assume that you are supposed to dance salsa on a floor pad if the floor pad is just there lying on the ground? To conclude from this, I believe that as much as you want to make a project or art installation easy to understand to the viewer, there is a limit which you need to determine at which things aren’t as straight-forward anymore. Once that limit is indicated, it is then up to the artist of how much and what kind of indications to use, whether to tell a story or leave it up to the participant to translate the project completely on their own. Whatever the case, I think that every human-being will always interpret absolutely everything in its own and unique way and therefore the experience will still remain unique to them.

Luize Rieksta

Jungle Animals

My third project was highly inspired by the fact that in less than a week my family is going to visit me in Abu Dhabi to see my life here in the UAE. Therefore, I was thinking of making something that could show them what I’ve been doing in this class and, because my sisters are coming too, the answer was pretty simple – to create something that would be primarily entertaining to my two little sisters!

And what do two 4-year-old and almost 7-year-old girls like the most?

Playing with animals is something that you can’t go wrong with, at least from my observations! That’s how the idea of making a jungle themed board full of colorful animals and lights was born. This idea was executed keeping in mind the only requirement for this project: making the LEDs react in an unexpected way using sensors. This is what’s happening in my jungle:

1. It all started with some simple sketches of what could be going on in the jungle. I decided to include a photo with my initial ideas that I was just briefly and messily putting on a paper to see how the idea developed further:

2. When I started working with the actual circuit, I firstly put together a row of 6 colorful LEDs that are controlled by a photocell sensor. The way this sensor works is that it can react to the amount of light that falls on the sensor and can be programmed to do something different depending on that amount of light. In my case I programmed the LEDs to flash with a 2000 milliseconds interval when there is plenty of light falling on the sensor but, as it gets darker – they start flashing with a 100 millisecond interval. Here is a picture of the LED row as it was first put together:

3. The second part of my circuit was made by using RGB (red green and blue) lights on a different breadboard controlled by a different photocell sensor. The reason why I used the RGB lights is because the color choice of the LEDs is fairly limited and not the most appealing to me nor my sisters. However, you can program the RGBs in any color you want them to be, and my colors of choice were turquoise blue, hot pink and lime green. On this breadboard the lights are flashing with a 500 millisecond interval if there is a lot of light falling on the sensor, but, if it gets dark – that’s where the unexpectedness happens (I’ll talk about it in just a second)! Here is a picture of the LED row and the 3 RGBs in my and my sister’s favorite colors:

This is the code I used to run all of my lights controlled by the sensors:

const int ledPin = 2;
const int ledPin2 = 4;
const int ledPin3 = 6;
const int ledPin4 = 8;
const int ledPin5 = 10;
const int ledPin6 = 12;
const int light = A2;

long previousMillis = 0;
int ledState = HIGH;
int ledState2 = HIGH;
int ledState3 = HIGH;
int ledState4 = HIGH;
int ledState5 = HIGH;
int ledState6 = HIGH;

#include <Adafruit_NeoPixel.h>


#define PIN 13


#define NUMPIXELS 6

Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

int delayval = 5; // delay for half a second

int counter = 0;

bool LEDone = false;
bool LEDtwo = false;
bool LEDthree = false;



void setup() {
 pinMode(ledPin, OUTPUT);
 pinMode(ledPin2, OUTPUT);
 pinMode(ledPin3, OUTPUT);
 pinMode(ledPin4, OUTPUT);
 pinMode(ledPin5, OUTPUT);
 pinMode(ledPin6, OUTPUT);
 Serial.begin(9600);

 pixels.begin(); // This initializes the NeoPixel library.
 Serial.begin(9600);

}

void loop() {

 int lightValue = analogRead(light);
 int mappedValue = map(lightValue, 825, 200, 2000, 100);
 int constrainedValue = constrain(mappedValue, 100, 2000);
 
 Serial.println(constrainedValue);
 delay(1);

 unsigned long currentMillis = millis();
 
 if ( currentMillis-previousMillis > constrainedValue) {
 if (ledState == LOW) {
 ledState=HIGH;
 } else {
 ledState=LOW;
 }
 if (ledState2 == LOW) {
 ledState2=HIGH;
 } else {
 ledState2=LOW;
 }
 if (ledState3 == LOW) {
 ledState3=HIGH;
 } else {
 ledState3=LOW;
 }
 if (ledState4 == LOW) {
 ledState4=HIGH;
 } else {
 ledState4=LOW;
 }
 if (ledState5 == LOW) {
 ledState5=HIGH;
 } else {
 ledState5=LOW;
 }
 if (ledState6 == LOW) {
 ledState6=HIGH;
 } else {
 ledState6=LOW;
 }

 previousMillis = currentMillis;
// Serial.print("Ellapsed time: ");
// Serial.println(currentMillis);
 digitalWrite(ledPin, ledState);
 digitalWrite(ledPin2, ledState2); 
 digitalWrite(ledPin3, ledState3); 
 digitalWrite(ledPin4, ledState4);
 digitalWrite(ledPin5, ledState5); 
 digitalWrite(ledPin6, ledState6); 
 }

 pixels.setPixelColor(0, pixels.Color(0,255,255));
 pixels.setPixelColor(1, pixels.Color(199,21,133));
 pixels.setPixelColor(2, pixels.Color(124,252,0));
 
 

 int lightValue2 = analogRead(A0);
 int mappedValue2 = map(lightValue2, 800, 200, 500, 10);
 int constrainedValue2 = constrain(mappedValue2, 10, 500);
 
 delay(mappedValue2);

 unsigned long currentMillis2 = millis();
 long previousMillis2 = 0;

 if ( currentMillis2-previousMillis2 > constrainedValue2) {
 if (LEDone == false) {
 pixels.setPixelColor(0, pixels.Color(0,255,255));
 LEDone = true;
 } else {
 pixels.setPixelColor(0, pixels.Color(0,0,0));
 LEDone = false;
 }
 if (LEDtwo == false) {
 pixels.setPixelColor(1, pixels.Color(199,21,133));
 LEDtwo = true;
 } else {
 pixels.setPixelColor(1, pixels.Color(0,0,0));
 LEDtwo = false;
 }
 if (LEDthree == false) {
 pixels.setPixelColor(2, pixels.Color(124,252,0));
 LEDthree = true;
 } else {
 pixels.setPixelColor(2, pixels.Color(0,0,0));
 LEDthree = false;
 }
 }

 pixels.show();


 
 counter = counter + 1;
 if (counter > 128){
 counter = 0;
 }
}

4. I designed special cover-up caps to put on the sensors in order to create darkness. There are 2 caps to put on both of the sensors and there is a monkey and a tiger on them! The idea is that you firstly put on a cap on the sensor controlling the LEDs, and they start flashing faster when that happens. Then, when you put the other animal on the other sensor, something unexpected happens and you don’t know what it’s going to be. Either the RGBs light up completely and the LEDs turn off. Or the LEDs turn on but the RGBs turn off. Or they all turn off. Or lastly, they can also all turn on. Then you can reset the Arduino and start it all over again! The thought behind this is that the animals are generally unpredictable, therefore you can’t be sure what they are going to do to the lights and each time it is something different! Also, I separated the sensors from the rest of the breadboard to make it more convenient to place the caps on the sensors. Here are some pictures of the animal covers and the designing process of the board where the breadboards, animals and caps are placed:

5. Lastly, to make it even more fun to my sisters, I decided to put on different jungle animals on the LEDs and this is the result:

6. My finished project and its design:

And here are a few videos with different outcomes of the state of the lights. Currently it was my friend playing with the project, but I can’t wait for these people to be my sisters!

These are the Jungle Animals! I really hope my sisters will like to play with the little animal figures and will feel the excitement about the unexpected light changes!

Luize Rieksta