# Problem

I always find tracking the internal temperature of the things being cooked tedious . Sometimes I have to stop what I am doing to check on it, sometimes I have to look at it the whole time if the food can easily be overcooked. If I forget to check, there is a risk of overcooking and therefore bad texture and taste.

# Solution

A device that actively tracks the internal temperature of the food and reminds the user when needed can solve this problem. The device is composed of a temperature sensor, a transducer speaker, and a screen. The temperature sensor of the device will be stuck into the middle of the meat or broth to measure the rate of rise in temperature.

If the rising rate is too large that might lead to overcooking, the device plays “Mi Re Do” to remind the user to turn down the gas. Text will be displayed on the screen if the user needs further information. In the same fashion, if the rising rate is too small, the device plays “Do Re Mi”. The user can stop the sound by pressing the device. In addition, specific instructions can be set for different foods. For the demo, an reminder to flip the fish for stir-frying salmon comes up when the temperature reaches a specific value. The device will play a melody when the food is cooked when the temperature reaches its ideal value. However, the device will only be successful if the algorithm of the cooking temperature for different foods is well developed.

# Proof of Logic

Because I am not sure if the sensor can be used on real meat, and because it will take a longer time, I changed the rate of temperature rise in each cooking stage and did a demonstration with my hand instead. I stimulate the cooking process by holding the temperature sensor and raises its temperature from room temperature (about 23 Celcius) to 32 Celcius.

```//libary
#include <OneWire.h>
#include <DallasTemperature.h>
#include "pitches.h"
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

//definition
#define ONE_WIRE_BUS 5
#define SPEAKER 7
#define CONFIRM_BUTTON 2

//Attachment
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
LiquidCrystal_I2C screen(0x27, 16, 2);

//Global variable
float Celcius = 0;
float Fahrenheit = 0;
float room_temp = 0;
int start_time = 0;

const bool isInterrupt = true;
bool confirmbuttonState = false;
bool isDone = false;

static const float salmon_flip_over_temp = 28;  //This is the default temperature for flipping salmon
static const float done_temp = 32;  //This is the temperature when the salmon is "cooked".
bool flip = false;

float rise_over_time = 0;

//Varibles for the timer of recording data, record data every 2 seconds
unsigned long clock_data = 0; // variable for timing
const int INTERVAL1 = 2000; // milliseconds between updates

//Functions
sensors.requestTemperatures();
Celcius = sensors.getTempCByIndex(0);
Fahrenheit = sensors.toFahrenheit(Celcius);
Serial.print(" C  ");
Serial.print(Celcius);
Serial.print(" F  ");
Serial.println(Fahrenheit);
}

void ConfirmButtonPressed()
{
confirmbuttonState = true;
}
}

void temp_rise(float rise_over_time, float lowerbound, float upperbound) {
if (rise_over_time > upperbound) {
screen.clear();
screen.setCursor(3, 0);
screen.print("Turn Down");
while (confirmbuttonState == false) {
tone(SPEAKER, NOTE_E4, 200);
delay(350);
tone(SPEAKER, NOTE_D4, 200);
delay(350);
tone(SPEAKER, NOTE_C4, 200);
delay(1000);

}

confirmbuttonState = false;
screen.clear();
}

if (rise_over_time < lowerbound) {
screen.clear();
screen.setCursor(4, 0);
screen.print("Turn Up");
while (confirmbuttonState == false) {
tone(SPEAKER, NOTE_C4, 200);
delay(350);
tone(SPEAKER, NOTE_D4, 200);
delay(350);
tone(SPEAKER, NOTE_E4, 200);
delay(1000);

}

confirmbuttonState = false;
screen.clear();
}
}

//The song to play when cooking is finished
void fly_me_to_the_moon() {
tone(SPEAKER, NOTE_C5);
delay(500);
tone(SPEAKER, NOTE_B4);
delay(500);
tone(SPEAKER, NOTE_A4);
delay(500);
tone(SPEAKER, NOTE_G4);
delay(250);
tone(SPEAKER, NOTE_F4);
delay(1000);
tone(SPEAKER, NOTE_G4);
delay(250);
tone(SPEAKER, NOTE_A4);
delay(500);
tone(SPEAKER, NOTE_C5);
delay(500);
tone(SPEAKER, NOTE_B4);
delay(500);
tone(SPEAKER, NOTE_A4);
delay(500);
tone(SPEAKER, NOTE_G4);
delay(500);
tone(SPEAKER, NOTE_F4);
delay(250);
tone(SPEAKER, NOTE_E4);
delay(1250);
if (confirmbuttonState == true){
return;
}

noTone(SPEAKER);
delay(250);
tone(SPEAKER, NOTE_A4);
delay(250);
tone(SPEAKER, NOTE_G4);
delay(500);
tone(SPEAKER, NOTE_F4);
delay(500);
tone(SPEAKER, NOTE_E4);
delay(250);
tone(SPEAKER, NOTE_D4);
delay(1000);
tone(SPEAKER, NOTE_E4);
delay(250);
tone(SPEAKER, NOTE_F4);
delay(500);
tone(SPEAKER, NOTE_A4);
delay(250);
tone(SPEAKER, NOTE_F4);
delay(250);
tone(SPEAKER, NOTE_GS4);
delay(750);
tone(SPEAKER, NOTE_F4);
delay(500);
tone(SPEAKER, NOTE_E4);
delay(500);
tone(SPEAKER, NOTE_D4);
delay(250);
tone(SPEAKER, NOTE_C4);
delay(1750);

noTone(SPEAKER);
delay(1000);
}

//This function is called when the "salmon" option is selected
void stirfry_salmon() {
//check the rate of temperature rise every 2 seconds
if (millis() >=  clock_data) {
sensors.requestTemperatures();
Celcius = sensors.getTempCByIndex(0);

//Print information onto the lcd screen
int minute = (millis() - start_time) / 60000;
int second = (millis() - 60000 * minute) / 1000;

//Serial.print(minute);
//Serial.println(second);

screen.setCursor(0, 0);
screen.print("Salmon");
screen.setCursor(0, 1);
screen.setCursor(7, 0);
screen.print((String)"Time:" + minute + ":" + second);

//Check whether it is time to flip the fish
if (current_read >= salmon_flip_over_temp && flip == false) {
screen.clear();
screen.setCursor(6, 0);
screen.print("Flip");
screen.setCursor(7, 1);
screen.print("it");
while (confirmbuttonState == false) {
tone(SPEAKER, NOTE_C5, 200);
delay(350);
tone(SPEAKER, NOTE_B4, 200);
delay(350);
tone(SPEAKER, NOTE_A4, 200);
delay(350);
tone(SPEAKER, NOTE_G4, 200);
delay(350);
tone(SPEAKER, NOTE_A4, 200);
delay(350);
tone(SPEAKER, NOTE_B4, 200);
delay(350);
tone(SPEAKER, NOTE_C5, 200);
delay(1000);
}

confirmbuttonState = false;
screen.clear();
flip = true;
}

//Checked if the fish is already cooked
screen.clear();
screen.setCursor(5, 0);
screen.print("Cooked");
while (confirmbuttonState == false) {
fly_me_to_the_moon();
}

confirmbuttonState = false;
screen.clear();
isDone = true;
return;
}

//Every cooking stage has a different "standard" rate of temperature rise
//0-10s The first stage of cooking
if (millis() - start_time <= 10000) {
temp_rise(rise_over_time, 0.12, 0.7);
}

//10-16s The second stage of cooking
if (millis() - start_time > 10000 && millis() - start_time <= 16000 ) {
temp_rise(rise_over_time, 0.12, 0.19);
}

//16-24s The third stage of cooking
if (millis() - start_time > 16000 && millis() - start_time <= 24000 ) {
temp_rise(rise_over_time, 0.6, 0.9);
}

//>24s The fourth stage of cooking
if (millis() - start_time > 10000 && millis() - start_time <= 16000 ) {
temp_rise(rise_over_time, 0, 0.3);
}

clock_data = millis() + INTERVAL1 ;
//Serial.print(Celcius);
//Serial.print("     ");
Serial.print("     ");
Serial.println(rise_over_time);
}
}

void setup()
{
//Initialization
Serial.begin(9600);
sensors.begin();
screen.init();
screen.backlight();

//Setting the pinMode
pinMode(CONFIRM_BUTTON, INPUT_PULLUP);

//Attach interrupt
if (isInterrupt) {
attachInterrupt (digitalPinToInterrupt(CONFIRM_BUTTON), ConfirmButtonPressed, FALLING);
}

//Record the room temperature
sensors.requestTemperatures();
Celcius = sensors.getTempCByIndex(0);
room_temp = Celcius;

//test-field
//tone(SPEAKER, NOTE_A4,200);
//screen.setCursor(0, 1);
//screen.print("2nd row text");
start_time = millis();

}

void loop(void)
{
if (isDone == false) {
stirfry_salmon();
}

}```

## ”欢迎光临“ A motion sensor that welcomes customers

Years ago(when I was a kid) in China, when you walk into most convenience stores and small shops, an accessory by the door will welcome you by saying “welcome”, and it also serves to notify the store owners that they have customers. I remember when I was a kid, I found it really annoying, because it makes the sound not only when you walk in, but also when you walk out. And if you stand by the door, it will keep ‘welcoming’ you. It’s probably because the accessory sensor only detects for distance, and it’s not smart enough to distinguish when not to make the sound.

Nowadays, I don’t hear it as often, and I’m not sure if it’s because the sensing accessory it too annoying, or simply because people associate this sound with ‘low-end’ stores. But I thought if this sensing accessory could become smarter, maybe it’s not a bad idea to bring it back?

1. only makes the sound when someone walks in, not out;
2. don’t make the sound if the store owner is already by the door or near the door

I initially wanted to use 2 ultrasonic distance sensors(1 to sense the person walking through the door, and another to sense the store owner being nearby the door), but I only had 1 distance sensor, so I used a button to indicate the event of “the owner is nearby the door”.

Input: Button, Photo-resistor, ultrasonic distance sensors

Output: buzzer speaker

I wasn’t able to get the speaker to play “Welcome” in Chinese, but I tried to mimic the tones of the way “Welcome” sounds with these sensing accessories(shoutout to my musically talented friend Michelle).

I used a photoresistor to detect whether the person is going in or out, but this scheme is far from reliable. A real motion sensor can do a much better job than what I have.

```#include<Wire.h>

// PIN INIT
const int SPEAKERPIN = 3;
const int TRIGPIN = 4;
const int ECHOPIN = 5;
const int BUTTONPIN = 7;
const int PHOTOPIN = A0;

// GLOBAL VARS
int distanceThreshold = 4;
int prevPhotoVal = 0;

int get_distance(){
unsigned long duration;
int distance;
digitalWrite(TRIGPIN, HIGH);
delay(1);
digitalWrite(TRIGPIN, LOW);
duration = pulseIn(ECHOPIN, HIGH, 20000);
distance = duration / 57;  // Divide by round-trip microseconds per cm to get cm
return distance;
}

void setup() {
Serial.begin(9600);
pinMode(SPEAKERPIN, OUTPUT);
pinMode(ECHOPIN, INPUT);
pinMode(TRIGPIN, OUTPUT);
pinMode(PHOTOPIN, INPUT);
pinMode(BUTTONPIN, INPUT_PULLUP);
}

void loop() {
int distance = get_distance();
if (distance < distanceThreshold && buttonUp) {
if(currPhotoVal > prevPhotoVal) {
tone(SPEAKERPIN , 185, 200);
delay(200);
tone(SPEAKERPIN , 146.83, 200);
delay(200);
tone(SPEAKERPIN , 185, 200);
delay(200);
tone(SPEAKERPIN , 146.83, 400);
delay(400);
}
}
prevPhotoVal = currPhotoVal;
}```

## I’ll take that as a “Yes”

Have you ever had an experience of not being able to talk for some reason?

For instance, when you took your wisdom teeth out, broke your jaw, someone taking a mold of your face..and so on.

One of the biggest fights that I had with my sister started with when she couldn’t understand my murmurs when I took my wisdom teeth out.

So I decided to make a communicator.

It comes with two parts: a Joystick and a button. The joystick is for a simple answer, and the button is for inquiries.

The joystick corresponds with one’s positivity in the answer in counterclockwise order, following down (no), right (maybe), up (yes), left (sounds great). The pitch of the sound corresponds as well, from a lower to higher pitch depending on the positivity in the answer.

The button shows one’s inquiry in order. The user can change the message as well, but you can assign each note that corresponds with your inquiries.

Q&A

What if I am not a perfect pitch?

• Does the pitch of notes corresponding with your answer help? Does LCD? Please let me know!

Schematics:

```//Codes
#include <Wire.h>
#include <LiquidCrystal.h>

LiquidCrystal lcd(13, 12, 5, 4, 3, 2);

int speaker = 7;

const int button = 6;
int val;
int counter;
int pressed;

void setup() {
lcd.begin(16,2);

pinMode(speaker, OUTPUT);
pinMode(button, INPUT_PULLUP);

Serial.begin(9600);
lcd.print("Default");

}

void loop() {

lcd.setCursor(0,0);
lcd.print("Yes. ");
tone(speaker,659);
delay(500);
noTone(speaker);
}
lcd.setCursor(0,0);
lcd.print("No. ");
tone(speaker,(523));
delay(500);
noTone(speaker);
}
lcd.setCursor(0,0);
lcd.print("Maybe. ");
tone(speaker, 587);
delay(500);
noTone(speaker);
}
lcd.setCursor(0,0);
lcd.print("Sounds great. ");
tone(speaker, 698);
delay(500);
noTone(speaker);
}

if (val == LOW){
pressed=counter ++;
delay(250);
Serial.println(pressed);

if (pressed == 0){
lcd.setCursor(0,0);
lcd.print("I need water.");
tone(speaker, 784);
delay(500);
noTone(speaker);
}
if (pressed == 1){
lcd.setCursor(0,0);
lcd.print("I want food. ");
tone(speaker, 880);
delay(500);
noTone(speaker);
}
if (pressed == 2){
lcd.setCursor(0,0);
lcd.print("Can you bring");
lcd.setCursor(0,2);
lcd.print("my phone?");
tone(speaker, 988);
delay(500);
noTone(speaker);
}
if (pressed == 3){
lcd.setCursor(0,0);
lcd.print("I need to be ");
lcd.setCursor(0,2);
lcd.print("alone. ");
tone(speaker, 1046);
delay(500);
noTone(speaker);
}

}
}```

## Hearing the Colors

Context: One of the main contributions of technology is mediation: technology mediates the agency of both disabled and fully enabled humans in the world, rebuilding their relation with the environment.

Problem: For visually impaired people, many applications  have been developed that scan and recognise objects in space for visually impaired people. This way, the user can perceive spatial information without employing touch. The visual information is translated into auditory words, which describe an object or a spatial condition.

This method facilitates the daily life for people with visual impairment. However, it is inadequate when it comes to the perception of art. A  colourful painting cannot be described through a sequence of colour matches that may bear no meaning to people with congenital vision disability.

Solution: ‘Hearing the colours  is a wearable interface that turns the experience of colours and visual art into an audio performance. The wearable prompts the user to move their hand and ‘grasp’ the sounds of the colours in a similar way with that they execute to ‘grasp’ the Braille dots for reading.

The interface plays the role of a sensory substitution device (SSD). After practice, the user learns to stimulate spontaneously the experiential quality of “seeing a color” through a new set of sensoricognitive skills. . This changes the classical definition of sensory modalities and contributes to the emergence of a form of “artificial synaesthesia”.

The interface is designed to transform the static observation of art into an interplay of visuals, sound and body movement. However, hearing the colors through a wearable device should not only be constrained to the spectrum of artwork. It contains the potential to turn the body into a scanning device, that moves and interacts with the space itself, even with other human beings.

Color as a R:G:B and H:S:B code

Computational Logic:

Demonstration Demo:

Circuit design:

Code:

```#include <Wire.h>

/* Initialise with specific int time (700ms) and gain(1x) values
Integration time = how often it reads the colors

Longer integration times can be used for increased sensitivity at low light levels.
Valid integration times are: 2.4MS, 24MS, 50MS, 101MS, 154MS, 700MS

Sets the gain of the ADC to control the sensitivity of the sensor.
Valid gain settings are: 1x(no gain), 4x, 16x, 60x
*/

int R = 0;
int G = 0;
int B = 0;
int hsv [3];

const int speaker = 11;
int pitch; int duration; int delayT;

/*********************************************************************************************/

void setup() {

Serial.begin(9600);

if (myRGB.begin()) {
Serial.println("The colorSensor is found");
} else {
Serial.println("No colorSensori is found");
while (1);
}

Serial.println("*****************************************************");
Serial.println();

}
/*********************************************************************************************/

void loop() {
getRGBValues();
rgb2Hsv(R, G, B, hsv);
colors2Sounds();

tone(speaker, pitch, duration);
delay(delayT);

} // loop

/*********************************************************************************************/
void colors2Sounds() {

if (hsv[0] <= 1) {
pitch = 100;
duration = 400;
delayT = 0;
Serial.println("red");
} else if (hsv[0] <= 5) {
pitch = 300;
duration = 400;
delayT = 50;
Serial.println("purple");
} else if (hsv[0] <= 13) {
pitch = 500;
duration = 400;
delayT = 100;
Serial.println("orange");
} else if (hsv[0] <= 17) {
pitch = 1000;
duration = 400;
delayT = 180;
Serial.println("yellow");
} else if (hsv[0] <= 25) {
pitch = 1800;
duration = 400;
delayT = 230;
Serial.println("green");
} else if (hsv[0] <= 33) {
pitch = 2400;
duration = 400;
delayT = 300;
Serial.println("greenish blue");
} else if (hsv[0] <= 55) {
pitch = 3000;
duration = 400;
delayT = 400;
Serial.println("blue");

}
}

void getRGBValues() {

float _red, _green, _blue;
myRGB.setInterrupt(false);
delay(60);
myRGB.getRGB(&_red, &_green, &_blue);
myRGB.setInterrupt(true);

//Print RGB values
/* Serial.print("Red: "); Serial.print(_red); Serial.print(" *** ");
Serial.print("Green: "); Serial.print(_green); Serial.print(" *** ");
Serial.print("Blue: "); Serial.print(_blue); Serial.print(" *** ");
Serial.println(); */

R = _red;
G = _green;
B = _blue;

} // getRGBValues

void rgb2Hsv(byte r, byte g, byte b, int hsv[]) {
float rd = (float) r / 255;
float gd = (float) g / 255;
float bd = (float) b / 255;
float max = threeway_max(rd, gd, bd), min = threeway_min(rd, gd, bd);
float h, s, v = max;

float d = max - min;
s = max == 0 ? 0 : d / max;

if (max == min) {
h = 0; // achromatic
} else {
if (max == rd) {
h = (gd - bd) / d + (gd < bd ? 6 : 0);
} else if (max == gd) {
h = (bd - rd) / d + 2;
} else if (max == bd) {
h = (rd - gd) / d + 4;
}
h /= 6;
}

hsv[0] = int(h * 100);
hsv[1] = int(s * 100);
hsv[2] = int(v * 100);

Serial.println((String)"Hue: " + hsv[0] + " Saturation: " + hsv[1] + " Value: " + hsv[2]);
}

float threeway_max(float r, float g, float b) {
float res;
res = r;
if (g > res) {
res = g;
}
if (b > res) {
res = b;
}
return res;
}

float threeway_min(float r, float g, float b) {
float res;
res = r;
if (g < res) {
res = g;
}
if (b < res) {
res = b;
}
return res;
}```