(11/27) Feedback and Listening
In this era, we constantly work with our minds. Gone are the days of labor-intensive jobs, now we have robots to do all of it. But amidst all of this mental overwork, it becomes intensely difficult to make space for receiving and utilizing feedback effectively. We are so engrossed in moving from one task to another that pausing to reflect on whether our teammates think what we’re doing right or wrong just fades into the background.
Moreover, the current times make it even more challenging to pass effective feedback without other individuals taking it personally or getting hurt. That is the reason why I find it important for us to detach ourselves from our work whenever we are taking feedback on it. It is important for us to know that the person is evaluating the task at hand and not judging us or our capabilities as a person.
Another strategy we can utilize to improve how we take feedback is to constantly ask clarifying questions. Instead of assuming what the other individual is saying, we should make sure that we understand what they are truly intending to say.
Group Project: Tranquility Detector
Project Aim
Develop a noise detector that buzzes and lights up when the sound levels reach above a certain level acceptable in the tranquility room in the dining hall.
Team Members
Sulagna Saha, Yu Wati Nyi, Mumtaz Fatima
Documentation of Our Build Process
- Collect the required components from the Arduino Kit. The required components were: Arduino Uno kit, Breadboard, Buzzer, LED Light, Sound Sensor
- Connect the Arduino Uno to the breadboard and make the necessary connections with the LED bulb, Buzzer, and Sound Sensor
- Modify the code and add the functionality to activate buzzer whenever the sound sensor detects a value, it saves the value, finds the peak value, uses this value of the detected sound to convert it into volts.
- Cardboard box:
- Cut cardboard to create a box with 2 open lateral ends.
- Make 3 holes to add the components. One hole on the top to attach the sound sensor and 2 holes on the side to attach the LED and the buzzer
- Test the connections and view the serial monitor to check whether the code works as intended
- Finally attach the breadboard to the bottom of the cardboard box and cover the 2 open ends.
Circuit Diagram
Code
/*
MAX4466 (adafruit mic)
Written by Shani Mensing, edited by Audrey St. John
Modified by Yu Wati Nyi, Mumtaz Fatima, Sulagna Saha
Circuit: microphone VCC connected to 3.3V, OUT to analog input A0
*/
// hook up the out of the mic to analog input A0
int MIC_IN = A0;
// Sample window width in milliseconds (50 ms = 20Hz)
int sampleWindow = 50;
int red_light_pin= 11;
int green_light_pin = 10;
int blue_light_pin = 9;
Int buzzer_pin = 8;
/**
* Initialization code
**/
void setup()
{
// open serial port and set data rates to 9600 bps (bits-per-second)
// this lets us communicate to/from the arduino
Serial.begin(9600);
pinMode( MIC_IN, INPUT );
pinMode(red_light_pin, OUTPUT);
pinMode(green_light_pin, OUTPUT);
pinMode(blue_light_pin, OUTPUT);
pinMode(buzzer_pin, OUTPUT);
}
/**
* Main program loop happens constantly.
**/
void loop()
{
// read the analog sensor as volts
double soundSensed = sampleSoundPeak();
// convert to volts
double volts = (soundSensed * 3) / 1024;
if(volts<1){
RGB_color(0, 255, 0); // Green
delay(1000);
}
else{
RGB_color(255, 0, 255); // Magenta
delay(1000);
tone(buzzer_pin, 1000); // Send 1KHz sound signal...
delay(1000); // ...for 1 sec
noTone(buzzer_pin); // Stop sound...
delay(1000);
}
// print it out
Serial.println(volts);
}
/////////////// Our own methods
/**
* Sense biggest input difference are being input from the analog MIC sensor
* over a certain "window" of time.
* Values returned are in the range 0 - 1024.
**/
double sampleSoundPeak()
{
// record start time
double startMillis = millis();
// this will be the highest peak, so start it very small
int signalMax = 0;
// this will be the lowest peak, so start it very high
int signalMin = 1024;
// will hold the current value from the microphone
int sample;
// collect data for 50 ms
while ( (millis() - startMillis) < sampleWindow )
{
// read a value from mic and record it into sample variable
sample = analogRead( MIC_IN );
// toss out spurious readings
if (sample < 1024)
{
// if the current sample is larger than the max
if (sample > signalMax)
{
// this is the new max -- save it
signalMax = sample;
}
// otherwise, if the current sample is smaller than the min
else if (sample < signalMin)
{
// this is the new min -- save it
signalMin = sample;
}
}
}
// now that we've collected our data,
// determine the peak-peak amplitude as max - min
int peakDifference = signalMax - signalMin;
// give it back to the caller of this method
return peakDifference;
}
void RGB_color(int red_light_value, int green_light_value, int blue_light_value)
{
analogWrite(red_light_pin, red_light_value);
analogWrite(green_light_pin, green_light_value);
analogWrite(blue_light_pin, blue_light_value);
}Project Display
(11/17) Destination 7: Cognitive Flexibility and Planning
Project: WelcomeBot
Project Aim
Making a wooden bot that lights up when someone gets close to the distance sensor.
Process
1. Cutting the wooden ply into small blocks
2. Drilling holes into the wooden blocks
3. Connect the distance sensor
4. Make the connections with the bot
My Reflection
Why did this project not work out as intended?
1. Not asking for help early on in the project
I realized that I rarely ask for help when I need it. This ends up isolating me in the process. That is why I think that I should ask for help early on the next time I work on a project that seems challenging.
2. Less proficiency in technical components
I found it difficult to use the Arduino to connect the wires without the breadboard. This again connects back to how I did not ask for help early on. Also, I tend to get intimidated by thinking that I am not good enough at this topic so I lose my motivation to keep going.
How do I think I should improve?
- Keep working on the problem until I find the solution or until I can ask someone else for help.
- Not give up when the problem seems too hard.
- Not rely on motivation, instead work on problems even when you’re low on motivation.
Destination 5: Belongingness
(11/8) Is This For Me?
Destination 4: Sense of Belonging Through Arduino Uno
As my LearningShip reaches its third destination, it tides along the waves of doubt. The doubt associated with “Will I succeed?” and “Do I belong here?”.
But to steer through these doubts, it’s important for the captain (aka me) to truly define what success actually means to me?
In the words of another great sailor (sailor of words, you know), “If, however, you want to succeed because you love the excitement of pushing your potential and exploring your world and new experiences, if you want to succeed because life is short and why not fill it with as much activity as possible, then you will win.”
I believe that all too often, we associate success with ‘winning’ – being the best, getting the best, becoming the best. And suddenly when you’re not the best, you’re not succeeding anymore. But, is it true? What is our metric of success and how do we not let other people’s metrics influence ours?
As overly optimistic as it sounds, I believe that all things “are” for us. We might be naturally good at some things and mediocre at. But if you really think about it, what do you define as ‘being good at’? Don’t we often gauge how we are performing in relation to others? So if there’s someone who is a better public speaker than you, you consider yourself to have the same level of skill and then suddenly you feel that you’re not a “good enough” public speaker.
So, it’s important for us to set our own metrics in order to feel that we belong in a space. Technology is an industry where we all belong. It’s just that we need to define what belongingness means to us and how we can pave our own way to achieve that level of belongingness.
11/3 Milestone 2: Music Box Project
Scientists define self-regulated learning as a cyclic process of setting tasks, developing strategies, evaluating the effectiveness of those strategies, and making necessary changes to reach one’s goal.
However, most of us as college students believe self-regulated learning seems easier said than done. It takes constant time (which college students lack) and energy to be implemented on a regular basis. Under the mountain of responsibilities, constant decision-making, adjustments, and assignments, it is difficult for one to pause and truly reflect on their learning strategy.
I followed the same school of thought until recently when I had to take the time out to complete this assignment. When I sat down to reflect on what I learned from the assignment, I realized that jumping haphazardly into a project might not be the best way of accomplishing it.
I followed the same school of thought until recently when I had to take the time out to complete this assignment. When I sat down to reflect on what I learned from the assignment, I realized that jumping haphazardly into a project might not be the best way of accomplishing it. You may then ask the following question:
What is the biggest hindrance to self-regulated learning?
We’re always on the go. When we are constantly surrounded by people who are always on the go and never seem to stop, we tend to fall into the same trap. It appears as if it is always necessary to be working on something, doing something, becoming someone. This constant pressure of doing something deprives us of the time where we can actually sit down and reflect on our learning journey so far.
It appears as if we live to follow a to-do list and not the other way around. That is why it is important to first accept that we should not be filling every single minute of our day with “productivity”. That is often the opposite of productivity.
How Did I Learn To Self Regulate Through This Project?
I realized that I should always come up with a plan in order to complete something successfully. More often than not, I jump into a project haphazardly, only to realize that I have wasted my precious time and energy that could have been spent doing other important things.
Next, I learned that most problems are simpler than we make them appear. If a project isn’t working even after we spent countless hours working on it, we must learn to either ask for help or let it go. Considering it as the end of the world would not help in magically fixing the project.
Finally, I learned that there are concepts and ideas that occur to us with time. A part of self-regulated learning is to acknowledge that we will not immediately find answers to everything, but at least we would have the knowledge of recognizing what is working and what is not.
Code
/*
Melody
Plays a melody on SquareWear
* use buzzer on digital pin 9
Written by Shani Mensing, edited by Audrey St. John
From example code in the public domain.
http://arduino.cc/en/Tutorial/Tone
*/
// Output for SquareWear
// specific to SquareWear
#define BUZZER_PIN 9
// squarewear specific
#define LIGHT_SENSOR_PIN A0
// current index of note that is playing
int currentNoteIndex = 0;
// deciding if there's enough light
// increase to require more ambient light before the led is on
// decrease to require less
int minLightValue = 100;
// notes for the song. A space represents a rest
char song[]= "ccggaag ffeeddc ggffeed ggffeed ccggaag ffeeddc ";
// the number of notes in the song
int songLength = 30;
// beats per note
int beats[] = { 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2,
1, 1, 2, 1, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 4};
// speed of song
int tempo = 300;
// names of the notes
char names[] = { 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C', 'D', 'E', 'F', 'G' };
// corresponding tones for C4 - B4, C5-G5 from Pitches.h
int tones[] = { 262, 295, 330, 349, 392, 440, 494, 523, 587, 659, 698, 784 };
// number of notes
int numberConvenienceNotes = 12;
void setup()
{
Serial.begin(9600);
if(checkBrightness())
( BUZZER_PIN, OUTPUT );
}
boolean checkBrightness()
{
int lightValue = analogRead(LIGHT_SENSOR_PIN);
if (lightValue >= minLightValue)
return true;
else
return false;
}
// play the next note in the song using the variables: song, songLength, beats
void playNextNote()
{
// if it's a space
if (song[currentNoteIndex] == ' ')
{
// rest
delay( beats[currentNoteIndex] * tempo/5);
}
// otherwise it's the name of a note
else
{
// play the note at that index for the specified time
playNote(song[currentNoteIndex], beats[currentNoteIndex] * tempo);
}
// pause between notes
delay(tempo);
currentNoteIndex = (currentNoteIndex+1)%songLength;
}
// play the tone corresponding to the note name
void playNote(char noteName, int duration)
{
if(checkBrightness()){
// loop through the names
for (int i = 0; i < numberConvenienceNotes; i++)
{
// if we found the right name
if (names[i] == noteName)
{
// play the tone at the same index
tone( BUZZER_PIN, tones[i], duration);
// don't bother looking through the rest of the names
break;
}
}
}
}
Destination 3: Actively Listening to the Arduino Melody
Ding ding ding! The learning ship has now reached its destination 3 – the island of Arduino and Squarewear.
At this island, we discover a new treasure box named ‘Active Listening’. But, this treasure box has a lock that needs to be decoded for me to achieve this treasure. The crux is that this treasure box utters the hints out very subtly, and I need to closely listen to understand what it is trying to convey.
Similarly, in real life, there are situations where words are spoken loudly, but hints are subtle and need to be comprehended. Most of us do what is called ‘hearing’. We hear each other but we do not truly stop to pause and reflect on what the other person is saying.
Hearing v/s Listening
This tendency of merely ‘hearing’ is not entirely our fault. We are always expected to be on the go – doing something, planning something, and contributing something. Our conversations are no different. We’re expected to have a reply, to have an opinion, and to provide solutions to whatever the opposite person is saying, without really understanding what the opposite person is saying. We’re afraid to come off as stupid or to be misinterpreted as zoned out whenever we do not have a reply to something immediately.
However, that’s not how things should work in the real world. It’s important for us to think about the content of what the other person is trying to convey. Most importantly, we must understand whether the opposite person is saying something in expectation of just being heard or in expectation of receiving input from you. This is especially true in peer-to-peer interactions where the other person just wants to feel heard and does not want to be barged with a plethora of solutions or ideas.
And in order to do so, we need to listen to what exactly the person is saying. I believe that true listening can be done when we remove the pressure of responding from our backs. We don’t always have to have the most intelligent insights or the most intelligent inputs during a conversation. Rather, it is important for us to work towards genuinely understanding the content.
Listening to Respond Intelligently
This is particularly true for classroom settings where students feel pressured to sound interesting or intelligent with their remarks in the discussion. This pressure makes them think about their own response during the lecture, instead of actively listening to the lecture. The best way for students to overcome this tendency is to remove the pressure off themselves. We don’t necessarily have to pretend that we’re the most intelligent person in the class. Instead, when we actively listen, we’re able to detect points that are most relevant to the subject material and are able to constantly work towards our own learning goals. Just sounding intelligent shouldn’t be one of those goals. But listening to understand should definitely be one.