It was very interesting for me to read this. Even though I love my iPhone’s touch screen, I resonate so much with wanting to touch and feel things with our hands. I think it’s such a loss to lose that interaction. The best part of living in a 3D world is being able to see and feel different shapes and angles and textures. As kids, when we walk around in a store, we want to touch everything. For some of us, this is still the case… Kids are told, however, to stop touching things, and I feel this restriction resembles the restriction of touch in the advancement of technology. But there’s a reason that we want to touch different textures and shapes. It comes from our curiosity. The writer talks about a group of inspired people being powerful, but inspiration is derived from experiencing things for yourself, and becoming curious about them.
As someone who loves the internet but still refuses to give up their journal and planner for google calendar no matter how many invites people send, and someone who appreciates physical books so much more, although I feel the writer’s stance is a little bit extreme, I generally agree with them. For example, people used to use type writers, and then they used big keyboards, and slowly the keys got thinner and thinner until touch screen/touch keyboards were made. But the experience of a typewriter, however might be less efficient, is so much stronger. I would definitely not want to give up my mac’s keyboard for a touch keyboard. To me, it’s great for some things to be touch screen, but others shouldn’t be, because they would lose the experience. And experiencing these little things is what keeps life interesting and inspiring.
I had heard that piano was a popular choice in previous years so this week, Suman and I decided to make drums. We used two different rhythms, one for a buzzer and one for the drums, and had them playing at several times as though to be responding to each other, sort of like a drum solo. while the buzzer rhythm is the same one and loops. There is two rhythms for the drums and with each round of the buzzer one of the rhythms plays, alternating. And the servo stands act like hands, playing the drums.
materials:
-2 servos
-1 buzzer
-some wood
-foam board
-tape
Our source for the drums: https://www.instructables.com/id/Simple-Arduino-Drum-Robot/
#define NOTE_B0 31
#define NOTE_C1 33
#define NOTE_CS1 35
#define NOTE_D1 37
#define NOTE_DS1 39
#define NOTE_E1 41
#define NOTE_F1 44
#define NOTE_FS1 46
#define NOTE_G1 49
#define NOTE_GS1 52
#define NOTE_A1 55
#define NOTE_AS1 58
#define NOTE_B1 62
#define NOTE_C2 65
#define NOTE_CS2 69
#define NOTE_D2 73
#define NOTE_DS2 78
#define NOTE_E2 82
#define NOTE_F2 87
#define NOTE_FS2 93
#define NOTE_G2 98
#define NOTE_GS2 104
#define NOTE_A2 110
#define NOTE_AS2 117
#define NOTE_B2 123
#define NOTE_C3 131
#define NOTE_CS3 139
#define NOTE_D3 147
#define NOTE_DS3 156
#define NOTE_E3 165
#define NOTE_F3 175
#define NOTE_FS3 185
#define NOTE_G3 196
#define NOTE_GS3 208
#define NOTE_A3 220
#define NOTE_AS3 233
#define NOTE_B3 247
#define NOTE_C4 262
#define NOTE_CS4 277
#define NOTE_D4 294
#define NOTE_DS4 311
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_FS4 370
#define NOTE_G4 392
#define NOTE_GS4 415
#define NOTE_A4 440
#define NOTE_AS4 466
#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_CS5 554
#define NOTE_D5 587
#define NOTE_DS5 622
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_FS5 740
#define NOTE_G5 784
#define NOTE_GS5 831
#define NOTE_A5 880
#define NOTE_AS5 932
#define NOTE_B5 988
#define NOTE_C6 1047
#define NOTE_CS6 1109
#define NOTE_D6 1175
#define NOTE_DS6 1245
#define NOTE_E6 1319
#define NOTE_F6 1397
#define NOTE_FS6 1480
#define NOTE_G6 1568
#define NOTE_GS6 1661
#define NOTE_A6 1760
#define NOTE_AS6 1865
#define NOTE_B6 1976
#define NOTE_C7 2093
#define NOTE_CS7 2217
#define NOTE_D7 2349
#define NOTE_DS7 2489
#define NOTE_E7 2637
#define NOTE_F7 2794
#define NOTE_FS7 2960
#define NOTE_G7 3136
#define NOTE_GS7 3322
#define NOTE_A7 3520
#define NOTE_AS7 3729
#define NOTE_B7 3951
#define NOTE_C8 4186
#define NOTE_CS8 4435
#define NOTE_D8 4699
#define NOTE_DS8 4978
#include <Servo.h>
#include "pitches.h"
// notes in the melody:
int melody[] = {
NOTE_C4, NOTE_G3, NOTE_G3, NOTE_A3, NOTE_G3, 0, NOTE_B3, NOTE_C4
};
// note durations: 4 = quarter note, 8 = eighth note, etc.:
int noteDurations[] = {
4, 8, 8, 4, 4, 4, 4, 4
};
Servo servoL;
Servo servoR;
int BUZZER = 8;
//hardware and pins
int srvoR = 5; //assign digital pwm pin for Left servo
int srvoL = 6; //assign digital pwm pin for Right servo
//musical things
int bpm = 90; //beats per minute
int timeSig = 4; //regular time signature (beats per measure)
int Tbeat = 60000/bpm; //time per beat in milliseconds is one minute divided by beats per minute
int beat = 1; //start the fist measure with the first beat
int measure = 1; //start with the first measure
//servo control
int travel = 17; //in degrees, how far does the servo need to turn
int Tservo = 130; //time allowed for servo to reach position before further instruction in milliseconds
void setup() {
Serial.begin(9600); // opens serial port, sets data rate to 9600 bps
//setup code here, to run once:
//establish each pin mode
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
//setup the servos at set at zero
servoL.attach(srvoL);
servoR.attach(srvoR);
servoL.write(0);
servoR.write(0);
}
void beatTEST(){
servoR.write(travel);
servoL.write(travel);
delay(60000/bpm);
servoR.write(0);
servoL.write(0);
delay(60000/bpm);
}
void quarterBeatL(){
servoL.write(travel);
delay(Tservo);
servoL.write(0);
delay((60000/bpm)-Tservo);
}
void quarterBeatR(){
servoR.write(travel);
delay(Tservo);
servoR.write(0);
delay((60000/bpm)-Tservo);
}
void eighthBeatL(){
servoL.write(travel);
delay(Tservo);
servoL.write(0);
delay((30000/bpm)-Tservo);
}
void eighthBeatR(){
servoR.write(travel);
delay(Tservo);
servoR.write(0);
delay((30000/bpm)-Tservo);
}
void loop() {
for (int thisNote = 0; thisNote < 8; thisNote++) {
// to calculate the note duration, take one second divided by the note type.
//e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
int noteDuration = 1000 / noteDurations[thisNote];
tone(8, melody[thisNote], noteDuration);
// to distinguish the notes, set a minimum time between them.
// the note's duration + 30% seems to work well:
int pauseBetweenNotes = noteDuration * 1.30;
delay(pauseBetweenNotes);
// stop the tone playing:
noTone(8);
}
delay(50);
if(measure == 1){ //a set of four quarter notes.
quarterBeatR();
quarterBeatL();
quarterBeatR();
quarterBeatL();
measure = 2;
}
for (int thisNote = 0; thisNote < 8; thisNote++) {
// to calculate the note duration, take one second divided by the note type.
//e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
int noteDuration = 1000 / noteDurations[thisNote];
tone(8, melody[thisNote], noteDuration);
// to distinguish the notes, set a minimum time between them.
// the note's duration + 30% seems to work well:
int pauseBetweenNotes = noteDuration * 1.30;
delay(pauseBetweenNotes);
// stop the tone playing:
noTone(8);
}
delay(50);
if(measure == 2){ //a set of 8 eighth notes. not perfectly in time because the motors are slow
eighthBeatR();
eighthBeatL();
eighthBeatR();
eighthBeatL();
eighthBeatR();
eighthBeatL();
eighthBeatR();
eighthBeatL();
measure = 1;
}
}
Norman has a very interesting perspective on design and touches on some thought provoking points. As a visual arts major, and someone who has dabbled in design a little bit, I understand the challenges that Norman talks about in relation to designers. Design is so important. It can either simplify, or complicate things for the users/audience, it can be interesting, aesthetic, minimalistic, boring, or complex. An navigating between the visual appeal of something and the efficiency and ease of use is up to the designer.
Norman talks about human centered design, which makes a lot of sense to me. An idea or product might be good in theory, but it might not be suited to the behavior of the average human. Furthermore another challenge for the designer is deciding how complex something should be. Norman talks about how adding more functions to something is supposed to make things easier by providing more options, but just complicates life. So a designer needs to decide the best balance between the two. It is very interesting to think of the development of design, and the new and unique design being developed for some products, while others stay relatively the same, and to think about how this will develop and change in the future.
This week’s prompt was to have something unexpected in our project, to have an element of surprise. But since we were specifically asked for a surprise, anything we make will not be a surprise, as it would be expected! This was such a dilemma for me. Therefore I decided to tweak and change the use of my previous project, since my audience already knew how it worked, to create an unexpected surprise.
Valentine’s day is over. Now, even though my project might look the same, it is no longer a tool showing a person’s love to you, but has transformed into a heart rate monitor. The heart beats go faster and faster with pressing the button, but when a hand is held over the light sensor, the heart stops beating and creates the beeping sound of a heart rate monitor when a heart stops. Many love stories, such as Romeo and Juliet, end with death, this is one of them.
For this project (like love story part 1), I used 10 LED lights, and put them into a piece of poster board in the shape of heart. I used different circuits for each LED as well as the button. At first I tried to solder the LEDs to the wires before poking them into the surface, but then found that this made the LEDs not stand up straight and move around due to the large hole. Therefore I decided to solder the LEDs after having put them into the board. I soldered the power and ground side of each LED separately, therefore using a total of 20 wires for the soldering. I considered having the button on the board too but decided that I want it to be eventually framed and still be able to use the button, so it would be better to have it separate. In order to make them fixed on the board, I glue gunned the LEDs from the back on to the board.
For this project I adjusted the code, and wiring, in order to add a light sensor and buzzer and have the light sensor turn off the lights and turn on the buzzer.
int ledPin1 = 3;
int ledPin2 = 6;
int buttonPin = 2;
int index = 0;
int prevButtonState = LOW;
int lowDelay[4] = {0, 200, 100, 30};
unsigned long toggleTime = 0;
int triggerInterval = 500;
int buzz = 13;
// Blink
// Turns an LED on for one second, then off for one second, repeatedly.
//
// Most Arduinos have an on-board LED you can control. On the UNO, MEGA and ZERO
// it is attached to digital pin 13, on MKR1000 on pin 6. LED_BUILTIN is set to
// the correct LED pin independent of which board is used.
// If you want to know what pin the on-board LED is connected to on your Arduino
// model, check the Technical Specs of your board at:
// https://www.arduino.cc/en/Main/Products
//
// modified 8 May 2014
// by Scott Fitzgerald
// modified 2 Sep 2016
// by Arturo Guadalupi
// modified 8 Sep 2016
// by Colby Newman
//
// This example code is in the public domain.
//
// http://www.arduino.cc/en/Tutorial/Blink
//*/
// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin LED_BUILTIN as an output.
for (int i=3; i<=12;i++){
pinMode(i,OUTPUT);
}
pinMode (buttonPin, INPUT);
Serial.begin(9600);
}
// the loop function runs over and over again forever
void loop() {
int currentButtonState = digitalRead(buttonPin);
int knobValue = analogRead(A0);
Serial.println(knobValue);
if (knobValue <50) {
index = 0;
}
if (currentButtonState == HIGH && prevButtonState == LOW) {
index = index + 1;
if(index >= 4){
index = 0;
}
// Serial.println(index);
}
if(index != 0){
for (int i = 3;i<=12;i=i+1){
digitalWrite(i, HIGH);
}
delay(100);
for (int i = 3;i<=12;i+=1){
digitalWrite(i, LOW);
}
delay(lowDelay[index]);
for (int i = 3;i<=12;i++){
digitalWrite(i, HIGH);
}
delay(100);
for (int i = 3;i<=12;i++){
digitalWrite(i, HIGH);
}
delay(1000);
for (int i = 3;i<=12;i++){
digitalWrite(i, LOW);
}
delay(lowDelay[index]);
for (int i = 3;i<=12;i++){
digitalWrite(i, HIGH);
}
delay(100);
for (int i = 3;i<=12;i++){
digitalWrite(i, HIGH);
}
} else {
for (int i = 3;i<=12;i++){
digitalWrite(i, LOW);
}
}
prevButtonState = currentButtonState;
// for (int i = 3;i<=12;i++){
// if (knobValue == 0)
// {
// digitalWrite(i,LOW);
// }
// }
int LIGHT = analogRead(13);
if (LIGHT < 100){
tone(buzz, 3000, 50);
}
}
This valentine’s day, save money on chocolates and flowers and make people fall in love with you with a simple button.
For this project, I used 10 LED lights, and put them into a piece of poster board in the shape of heart. I used different circuits for each LED as well as the button. At first I tried to solder the LEDs to the wires before poking them into the surface, but then found that this made the LEDs not stand up straight and move around due to the large hole. Therefore I decided to solder the LEDs after having put them into the board. I soldered the power and ground side of each LED separately, therefore using a total of 20 wires for the soldering. I considered having the button on the board too but decided that I want it to be eventually framed and still be able to use the button, so it would be better to have it separate. In order to make them fixed on the board, I glue gunned the LEDs from the back on to the board.
In order to fulfill the condition of having more than one input or output, I had 3 different speeds, to replicate the heart beat getting faster (this is how you know the button has made your special someone fall in love with you, their heart beats faster when you are around 😉 ) as well as an on/off option.
I used the blink code, firstly adjusting it to make it blink like a heartbeat (with a short delay and then a longer delay), then using for loop to make all the LEDs do the same action at the same time. I used index, with {0, 200, 100, 30}; as the delays, to make the button increase the speed of and turn on/off the lights.
int ledPin1 = 3;
int ledPin2 = 6;
int buttonPin = 2;
int index = 0;
int prevButtonState = LOW;
int lowDelay[4] = {0, 200, 100, 30};
unsigned long toggleTime = 0;
int triggerInterval = 500;
int buzz = 13;
// Blink
// Turns an LED on for one second, then off for one second, repeatedly.
//
// Most Arduinos have an on-board LED you can control. On the UNO, MEGA and ZERO
// it is attached to digital pin 13, on MKR1000 on pin 6. LED_BUILTIN is set to
// the correct LED pin independent of which board is used.
// If you want to know what pin the on-board LED is connected to on your Arduino
// model, check the Technical Specs of your board at:
// https://www.arduino.cc/en/Main/Products
//
// modified 8 May 2014
// by Scott Fitzgerald
// modified 2 Sep 2016
// by Arturo Guadalupi
// modified 8 Sep 2016
// by Colby Newman
//
// This example code is in the public domain.
//
// http://www.arduino.cc/en/Tutorial/Blink
//*/
// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin LED_BUILTIN as an output.
for (int i=3; i<=12;i++){
pinMode(i,OUTPUT);
}
pinMode (buttonPin, INPUT);
Serial.begin(9600);
}
// the loop function runs over and over again forever
void loop() {
int currentButtonState = digitalRead(buttonPin);
int knobValue = analogRead(A0);
Serial.println(knobValue);
if (knobValue <50) {
index = 0;
}
if (currentButtonState == HIGH && prevButtonState == LOW) {
index = index + 1;
if(index >= 4){
index = 0;
}
// Serial.println(index);
}
if(index != 0){
for (int i = 3;i<=12;i=i+1){
digitalWrite(i, HIGH);
}
delay(100);
for (int i = 3;i<=12;i+=1){
digitalWrite(i, LOW);
}
delay(lowDelay[index]);
for (int i = 3;i<=12;i++){
digitalWrite(i, HIGH);
}
delay(100);
for (int i = 3;i<=12;i++){
digitalWrite(i, HIGH);
}
delay(1000);
for (int i = 3;i<=12;i++){
digitalWrite(i, LOW);
}
delay(lowDelay[index]);
for (int i = 3;i<=12;i++){
digitalWrite(i, HIGH);
}
delay(100);
for (int i = 3;i<=12;i++){
digitalWrite(i, HIGH);
}
} else {
for (int i = 3;i<=12;i++){
digitalWrite(i, LOW);
}
}
prevButtonState = currentButtonState;
// for (int i = 3;i<=12;i++){
// if (knobValue == 0)
// {
// digitalWrite(i,LOW);
// }
// }
int LIGHT = analogRead(13);
if (LIGHT < 100){
tone(buzz, 3000, 50);
}
}
Its interesting to understand the definition of interactivity and that not everything that we interact (react) to is interactive. The writer says that a cyclic process in which two actors alternately listen, think,and speak is an interaction. This is interesting because when asked in one of the first lessons to go out of the class and find things that are interactive, most of us came up with things that would, according to this text, not actually be interactive. For example we were going to initially choose a bench/table that several of us thought was interactive, due to need for an even number of people to be sat on it to balance it and its ability to spin, however Crawford would likely disagree. However we ended up choosing the coffee machine, which I am not entirely sure if Crawford would disagree with or not, as when we listen (seeing the options), think, and speak (choosing coffee), and the machine listens (to our request input), thinks (processes it), and speaks (prepares chosen coffee), this seems to me to be interactive due to Crawford’s logic as well.
