I found the examples that Deutsch used in the text to be fascinating, as I had never perceived, for instance, language and the numeric system in such a way. The explanation for some examples were difficult to comprehend. For instance, when discussing language he claimed “a rule works by exploiting regularities in the language, it implicitly encodes those regularities, and so contains more knowledge than the list.” What did he mean by “exploiting regularities” and “implicitly encoding”? Some ideas were hard to comprehend because he communicated in such abstract terms, not always with further explanation. I found the general, overall message to be extremely interesting. How small changes in a system to meet a narrow purpose happened to contribute to the universality of something, without intentionally meaning to contribute to universality. I always thought universality was intentional. Instead, I learnt we didn’t achieve universality by trying to deliberately make something universal. It was interesting how he offered a very limited explanation for why communities didn’t attempt to reach universality earlier, why they were avoiding universality on purpose. The one explanation that stood out to me from the few was the fact that the communities’ livelihood would be threatened by a system that was too easy to learn. Perhaps the increase in trust, or the colonisation and globalisation of the world, makes it less threatening to aspire for universality.

1. I first started off with plugging jumper wires into the ground and 5V input on the RedBoard to the power and ground column on the breadboard. Vittoria taught me a neat trick, twirling wires together in order to keep the board neat and clean.

2) I tried to test if the LED pin would light up if I put the two jumper wires against a conductive material (in this case, I made the jumper wires touch one another), and it did successfully.

3) I decided to go on with my idea, which was that whenever I opened or closed a book, the light would switch on or off. I decided to tape the jumper wires to small conductive sheets, and then tape them on the pages, as demonstrated below. When the book is closed, the lights would turn on, and when the book is open, the lights would turn off.

However, I found my idea to be slightly useless. Firstly, the conductive sheets were only on the first two pages. What if the reader opened another page? Nothing would happen with the LED light. Also, a LED indicator of when the book is open or closed essentially has no purpose as my hands can also indicate when the book is open or closed. After talking to Professor Aaron about my idea, he suggested that I create a reading lamp that turns on when the book is open, and turns off when the book is closed.

4) In order to execute this plan, I decided to create two bookmarks covered in conductive material. One is called a bookmark, while the other is called a lamp switch bookmark. The bookmark is placed on whichever page the reader is on, and the lamp switch bookmark is placed on the original bookmark when an individual is reading. When an individual is not reading, the lamp switch bookmark must be set on a different page so the conductive material does not touch and the LED doesn’t light up.

a) b)

c)

(Bookmark and lamp switch bookmark making contact with one another so the LED lights up)

What was problematic with this plan was that it did not meet the hands-free requirement that was asked for this assignment. I needed another way of making the LED light up when the book was open.

5) Before I explain what I did in order to make the LED light up when the book was open, it would be helpful to take a look at the images:

a)

b)

c)

I changed the position of the bookmarks into a landscape position and put them on top of the novel, near the spine of the book. Subsequently, when the book is closed the conductive material does not touch. When the book is open, the conductive material makes contact and the LED lights up. A possible issue with this design may be the storage of the book. The bookmarks add extra length to the novel, therefore it may have trouble sitting on a shelf. Also, the jumper wires were quite short and therefore it was challenging to actually test whether the concept worked or not. Unfortunately the image couldn’t capture the LED light on while the novel was open, but it does work.

Adding to my project from last week, I tried to give it a purpose and thought that it could be turned into a game in which you step on the semi-cylinder to make the ball jump and land on the aluminium foil on the other side of the box. I have used the Arduino to make the LED light up if the tennis ball touches the aluminium foil exactly and stay lit until the ball slides back down and touches the foil at the starting point.

Here is the code that I used: https://gist.github.com/yhk343/91b72544f0e0a46444641a15c4de6d88

‘A small change in a system to meet a parochial purpose just happened to make the system universal as well.’

This sentence especially memorable for me because I had always wondered how intelligent the people that developed the universal ideas in the ancient times must have been and whether they expected us, people living in 2018, to continue to use those ideas. To find out that it was not in their intentions to create a system fit for everyone across all cultures and time is a little disappointing but I think that makes a lot more sense.

I also liked the examples the writer used to explain symbols, ‘sun’ and ‘tree’, because although no puns intended, I thought it was quite clever when ‘treason’ came up as the example for the limitations of symbols as I had assumed that ‘sun’ and ‘tree’ were random examples.

My goal with this project was to create a light-up version of tick tack toe, where a light would display whenever a piece was placed and display the lights for the winning set at the end. Making the physical board was not too much of an issue, and wiring appeared to go well, but after only a small amount of testing I realized that my design was fundamentally flawed.

<iframe allowFullScreen frameborder=”0″ height=”564″ mozallowfullscreen src=”https://player.vimeo.com/video/254331930″ webkitAllowFullScreen width=”640″></iframe>

(This video was taken at an early stage and simply shows that the program logic could accurately store and use my switches, while simultaneously powering the light on the same circuit)

I was attempting to complete the project with 9/10 pins, which did not work for the simple reason that current flows between two arduino pins set to  output at the same level if connected. My design was to have a single output pin that provided 5 v to 9 parallel series. Each series contained a switch and an LED bulb, and then ended in an arduino pin with pulldown to ground. The idea was the the receiving pin would, upon receiving a signal, output the same voltage as the main pin, and so set the voltage drop over the circuit to zero. Unfortunately, this is not a function arduino is capable of from what I could determine. The issue was not the fact that the circuit was still connected to ground, as the LEDs were far to bright to be in series with a 10k resistor. (The version I have described above is not the very first design, it is simpler and more elegant, and does not require that the lights be able to function with current flow from either direction).

To make the circuits work with an arduino I separated each of the 9 parallel circuits and gave them their own power pin, all of which were initiated to on. Now each light would turn on when the corresponding piece was placed, and at the end of the game when a winning line was determined only the LEDs that belonged to that line would keep their power, the rest would be shut off. This design works from an electronics perspective, though the game logic of my software contains bugs. Specifically, the winning line is improperly identified. However, all the lights during the game work correctly, and when the game detects a winning line, even though it is incorrect, it propagates that error correctly into a single line of powered lights. I am content at the moment, however, since both the game lights and the winning lights work correctly, it is only the game logic the determines which lights are part of the winning line that is bugged.

int board[9] = { -1, -1, -1, -1, -1, -1, -1, -1, -1};
int mapping[9] = {11, 12, A0, A1, A2, A3, A4, A5, 13};
//int winners[3] = { -1, -1, -1};
int winners[3] = {6, 7, 8};
int turn = 0;
void setup() {
  // put your setup code here, to run once:
  initialize();
}
void loop() {
  // put your main code here, to run repeatedly:
  //displayWinner();
  play();
  //initialize();
}
void initialize() {
  for (int i = 0; i <= 8; i++) {
    pinMode(i + 2, INPUT);
    pinMode(mapping[i], OUTPUT);
    digitalWrite(mapping[i], HIGH);
  }
  pinMode(1, OUTPUT);
  digitalWrite(1, LOW);
  //pinMode(13, OUTPUT);
  //digitalWrite(13, HIGH);
  //digitalWrite(LED_BUILTIN, HIGH);
}
void play () {
  boolean done = false;
  while (!done) {
    boolean piece_played = false;
    int temp = -1;
    //turn++;
    //turn= turn%2;
    while (temp == -1) {
      for (int i = 0; i <= 8; i++) {
        if ((digitalRead(i + 2) == true) && (board[i] == -1)) {
          temp = i;
          board[i] = turn;
          break;
        }
      }
    }
    done = checkWin(temp, turn);
    //    if(done){
    //      digitalWrite(1,HIGH);
    //    }
    delay(400);
    //    pinMode(temp + 2, OUTPUT);
    //    digitalWrite(temp + 2, LOW);
    digitalWrite(mapping[temp + 2], HIGH);
  }
  displayWinner();
}
boolean checkWin(int i, int turn) {
  //  digitalWrite(1, HIGH);
  //  delay(500);
  //board[i] = turn;
  //return false;
  if (i == 4) {
    if (board[0] == board[4] == board[6]) {
      int temp[3] = {0, 4, 6};
      for (int j = 0; j < 3; j++) {
        winners[j] = temp[j];
      }
      //digitalWrite(LED_BUILTIN, HIGH);
      return true;
    }
    if (board[2] == board[4] == board[8]) {
      int temp[3] = {2, 4, 8};
      for (int j = 0; j < 3; j++) {
        winners[j] = temp[j];
      }
      //digitalWrite(LED_BUILTIN, HIGH);
      return true;
    }
  }
  if (i / 3 == 0) {
    if (board[0] == board[1] == board[2]) {
      int temp[3] = {0, 1, 2};
      for (int j = 0; j < 3; j++) {
        winners[j] = temp[j];
      }
      //digitalWrite(LED_BUILTIN, HIGH);
      return true;
    }
  }
  if (i / 3 == 1) {
    if (board[3] == board[4] == board[5]) {
      int temp[3] = {3, 4, 5};
      for (int j = 0; j < 3; j++) {
        winners[j] = temp[j];
      }
      //digitalWrite(LED_BUILTIN, HIGH);
      return true;
    }
  }
  if (i / 3 == 2) {
    if (board[6] == board[7] == board[8]) {
      int temp[3] = {0, 1, 2};
      for (int j = 0; j < 3; j++) {
        winners[j] = temp[j];
      }
      //digitalWrite(LED_BUILTIN, HIGH);
      return true;
    }
  }
  //  digitalWrite(1, HIGH);
  //  delay(500);
  if (i % 3 == 0) {
    //digitalWrite(1, HIGH);
    if (board[0] == board[3] == board[6]) {
      int temp[3] = {0, 3, 6};
      for (int j = 0; j < 3; j++) {
        winners[j] = temp[j];
      }
      //digitalWrite(LED_BUILTIN, HIGH);
      return true;
    }
  }
  if (i % 3 == 1) {
    if (board[1] == board[4] == board[7]) {
      int temp[3] = {1, 4, 7};
      for (int j = 0; j < 3; j++) {
        winners[j] = temp[j];
      }
      return true;
    }
  }
  if (i % 3 == 2) {
    if (board[2] == board[5] == board[8]) {
      int temp[3] = {2, 5, 8};
      for (int j = 0; j < 3; j++) {
        winners[j] = temp[j];
      }
      return true;
    }
  }
  return false;
}
void displayWinner() {
  initialize();
  digitalWrite(1, HIGH);
  //  digitalWrite(13,LOW);
  //  for(int i=0; i<3; i++){
  //    digitalWrite(mapping[winners[i]],HIGH);
  //  }
  //  while(true){
  //    delay(1);
  //  }
  for (int i = 0; i < 9; i++) {
    int in = false;
    for (int j = 0; j < 3; j++) {
      if (i == winners[j]) {
        in = true;
      }
    }
    if (!in) {
      digitalWrite(mapping[i], LOW);
    }
  }
  delay(5000);
}

To continue this project I would fix the bug in the code, and then improve the mechanical parts of the board, namely make pieces to be played and improve the sensitivity of the switches, and finally affix everything so it is not constantly falling apart. There are also a number of ways in which the game will behave oddly, for example if played too quickly, and so I might adjust for those oddities.

In order to improve and work off of my last project I decided to program my lights to play twinkle twinkle little star (as LED interpretations). I got the idea from a show called ‘Switched at Birth’ where many deaf characters are protagonists. It is shown how deaf people typically experience interpretations of sound: through flashes of light. Therefore, I created something in the hopes to tailor to deaf babies. I used green and yellow LED’s as they are more calming and soothing for sleep.

I wrote down letter notes for how twinkle twinkle would be played on a piano, then translated each note to a PIN number. 

Originally I was going to play Brahm’s lullaby but decided against it as the RedBoard didn’t seem to be able to support all of the lights needed to create the system. 

So the idea was to create a seat pad for parents to sit on and when they got up to leave their child’s bedroom the light sequence would play. The video below shows it working: listen to it on mute!

Picture This.

You’re riding your bicycle at night, wearing a fluorescent vest so cars don’t flatten you on the road. You reach the end of a street but you realize there is a problem.

See, typically in a vehicle that doesn’t have a blinker to indicate where you will turn, the person riding is meant to use their hands to indicate which way they will turn.

But what about at night? You are on a bike with no blinker. Someone in a car far away may see your vest but they won’t have any indication that you are about to switch lanes or turn.

And so my Handy (not) Dandy Bike Light comes into play.

Re-Design

In my last project, I had a pun project called “Punch your Lights On.” This time, I took a similar mechanism, but gave it a more practical use. There is still a kind of jerking motion done in order to activate the lighting. This is due to the fact that on a bike, the movement would be rather deliberate and the light will not be turned on by a jump on the rough road.

 

Difficulties

The code is simply the “Blink” program that comes with the Arduino, but it is applied to the two different LED lights. This part was easy to execute.

Originally, the light was supposed to include a third LED which would constantly be on while a person is on the bike. This third position on the actual mechanism made the light harder to use and so I decided to remove it from the mechanism.

In my last project, the wires to the breadboard were to make contact with the metal marble. This caused some issues as the marble was not always in contact with the wires.

In this project, I expanded the possible surface area by connecting the wires to aluminum foil. These pieces of aluminum foil are meant to come into contact with the marble, making it much easier to complete the circuit.

 

The new and improved Super Straw will make your drinking experience even better with cooler light displays. Notice that a different light or light display would be turned on every time you take a sip from the straw. It goes like RED-> BLUE -> YELLOW -> YELLOW-BLUE-RED and FADE. The cycle then repeats itself.

However, I encountered a small problem with the fading effect. The lights do not seem to completely turn off in the end.

Then I changed while (brightness > 0 ) to while (brightness >= 0 ) in the beginning of the part of the code that is in charge of the fading effect, then the problem was solved. It seemed that I need to allow the brightness to go to or below 0 to make the lights completely turned off.

link to my code: https://github.com/ross67/IntroToIm/blob/master/Project%20Super%20Straw%202.0.txt

I’ve always understood interaction as a process by which elementary particles exchange gauge bosons with each other or when two masses exert force on each other. For me, the simple act of walking down the high-line consists of many interactions such as the collision of atmospheric particles and my body and the exertion of force on the ground by my feet (exertion of force on my feet by the ground). This definition is concrete, tangible, and most importantly, objective: if there is an exchange of force, there is an interaction.

Thinking of interactivity as a continuous variable with relative measures that outline the “degrees” of interaction is a particularly interesting concept. I do agree with the author that interactivity is not merely a boolean property. Perhaps the existence of interactivity can be defined with a simple yes or not, but there’s definitely much more to interactions than just that. Touching a rock versus playing squash are clearly two different “degrees” of interaction. But the question is, how can we quantify the level of interactivity objectively?

I really liked how the author used examples and analogies from a wide spectrum of fields and disciplines (ranging from literature and history to physics and biology) to better portray the concept of universality. The establishment of a universal system in which all parties involved in the field acknowledge and adopt is arguably one of the most important elements of the advancement of the human race. It enables individuals from different corners of the world to communicate and collaborate with each other, solving problems that are sometimes for too difficult for just a handful of people that speak the same language.