← Projects

DESK-MATE

Made by Jiangtao Yan

Found in DioT 2019: Internet of Plants

An Internet of Plant that accompanies people in the bedroom.

0

Solution

Many people would put a plant on their desk in the bedroom for a fresh feeling. My project is to use a plant as a media for people to fulfill a certain purpose and entertainment from the survival of the plant, the functional purpose-indicating the noise and the entertainment need-singing songs.


0

Approach

First I defined the features of this project using Maslow's hierarchy of needs:

1. Survival:

Monitoring the vital index of the plant to make sure it survives by using a moisture sensor. If she needs water, then she gives a signal and sends you an email

2. Functional:

a. Using the photosensor to detect if you turn on the lamp for a long time and if the answer is YES, she will remind you that you sit in the chair for too long and you should take a break.

b. Also, she uses the sound detector to measure the sound of your room and if you are too loud and disturb other people, the plant will remind you in a very gentle way.

3. Recreational:

Using a button to let the plant sing a random song. The plant also sings to you when you feed her water as an appreciation.


0

Process 

1. Exploring the availability of the components I know.

2. Creating the structure of the working flow.

3. Finishing the circuit and code by parts.

4. Linking the device with IFTTTT and google sheet

5. Doing the best of implementation.

0

Implementation

Part Lists

  • 1 x Particle Argon
  • 1 x photocell sensor
  • 1 x force sensor
  • 1 x sound detector
  • 1 x moisture sensor
  • 3 x  LED
  • 2 x 10kΩ Resistor
  • 3 x 1kΩ Resistor
  • several jumper wires

Building circuits and tested each component.

0
Work Flow:


Survival: 

if (enough water)  then (white light constant on)
if ( not enough water) then( send email+ blink white light)
if ( fed with water ) then ( reply with playing lion king music and white light constant on )


Functional:

a. remind people to not make noise
if( sound is loud) then (bink the yellow light to remind people)
if(sound is very loud) then ( play melody)

b. remind people to take a break
if (light is on for 2 hours) then ( green light blink and sound alarm)
if (tap the button) then (green light off, sound off)


Entertainment：

if ( press the button) then ( play a random song)
if ( press again ) then (stop playing)




0 
// 11/05

int photoPin = A1;
int photoReading = 0;

int fsrPin=A0;
int fsrReading=0;

int soundPin = A3;
int soundReading = 0;

int moisturePin = A2;
int moistureReading = 0;

int piezoPin = D5;

int ledPin1 = D2;
int brightness1= 0;

int ledPin2 = D4;
int brightness2 = 0;

int ledPin3 = D8;

int buttonPin = D6;
int button = LOW;

int counter = 0;

int melody2[] = {1908,2024,0,2551,2273,2551,2551,1908};
int noteDurations2[] = {4,4,4,4,4,8,8,4 };

int last_published = -1;
int sentOrnot= 0;
int val=0;
int duration_relax = 5000; //7200000
unsigned long int lightDuration;


#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
#define REST      0


// change this to make the song slower or faster
int tempo = 122;

// change this to whichever pin you want to use

// notes of the moledy followed by the duration.
// a 4 means a quarter note, 8 an eighteenth , 16 sixteenth, so on
// !!negative numbers are used to represent dotted notes,
// so -4 means a dotted quarter note, that is, a quarter plus an eighteenth!!
int melody[] = {

  // The Lion Sleeps Tonight
  // Score available at https://musescore.com/user/18545446/scores/5061407

  NOTE_F4, 4, NOTE_G4, 4, NOTE_A4, 8, NOTE_G4, 4, NOTE_A4, 8, //1
  NOTE_AS4, 4, NOTE_A4, 4, NOTE_G4, 8, NOTE_F4, 4, NOTE_G4, 8,
  NOTE_A4, 4, NOTE_C4, 8, NOTE_C4, 4, NOTE_C4, 8, NOTE_C4, 4,
  NOTE_C4, 1, //1st ending

  NOTE_F4, 4, NOTE_G4, 4, NOTE_A4, 8, NOTE_G4, 4, NOTE_A4, 8, //repeats from 1
  NOTE_AS4, 4, NOTE_A4, 4, NOTE_G4, 8, NOTE_F4, 4, NOTE_G4, 8,
  NOTE_A4, 4, NOTE_C4, 8, NOTE_C4, 4, NOTE_C4, 8, NOTE_C4, 4,
  NOTE_C4, -2,  REST, -8, NOTE_A4, 16, //2nd ending

  NOTE_A4, -8, NOTE_A4, 16, NOTE_A4, -8, NOTE_A4, 16, NOTE_A4, -8, NOTE_A4, 16, NOTE_A4, -8, NOTE_A4, 16, //6
  NOTE_AS4, -8, NOTE_AS4, 16, NOTE_AS4, -8, NOTE_AS4, 16, NOTE_AS4, -8, NOTE_AS4, 16, NOTE_AS4, -8, NOTE_AS4, 16,
  NOTE_A4, -8, NOTE_A4, 16, NOTE_A4, -8, NOTE_A4, 16, NOTE_A4, -8, NOTE_A4, 16, NOTE_A4, -8, NOTE_A4, 16,
  NOTE_G4, -8, NOTE_G4, 16, NOTE_G4, -8, NOTE_G4, 16, NOTE_G4, -8, NOTE_G4, 16, NOTE_G4, -8, NOTE_G4, 16,

  NOTE_A4, -8, NOTE_A4, 16, NOTE_A4, -8, NOTE_A4, 16, NOTE_A4, -8, NOTE_A4, 16, NOTE_A4, -8, NOTE_A4, 16, //10
  NOTE_AS4, -8, NOTE_AS4, 16, NOTE_AS4, -8, NOTE_AS4, 16, NOTE_AS4, -8, NOTE_AS4, 16, NOTE_AS4, -8, NOTE_AS4, 16,
  NOTE_A4, -8, NOTE_A4, 16, NOTE_A4, -8, NOTE_A4, 16, NOTE_A4, -8, NOTE_A4, 16, NOTE_A4, -8, NOTE_A4, 16,
  NOTE_G4, -8, NOTE_G4, 16, NOTE_G4, -8, NOTE_G4, 16, NOTE_G4, -8, NOTE_G4, 16, NOTE_G4, -8, NOTE_G4, 16,

  NOTE_F4, 4, NOTE_G4, 4, NOTE_A4, 8, NOTE_G4, 4, NOTE_A4, 8, //14
  NOTE_AS4, 4, NOTE_A4, 4, NOTE_G4, 8, NOTE_F4, 4, NOTE_G4, 8,
  NOTE_A4, 4, NOTE_G4, 4, NOTE_F4, 4, NOTE_A4, 4,
  NOTE_G4, 1,
  NOTE_C5, 4, NOTE_A4, 4, NOTE_G4, 8, NOTE_A4, 4, NOTE_C5, 8,
  NOTE_AS4, 4, NOTE_A4, 4, NOTE_G4, 8, NOTE_F4, 4, NOTE_G4, 8,
  NOTE_A4, 4, NOTE_G4, 4, NOTE_F4, 4, NOTE_A4, 4,
  NOTE_G4, 1,

  NOTE_C5, 1, //22
  NOTE_C5, 4, NOTE_AS4, 8, NOTE_C5, 8, NOTE_AS4, 2,
  NOTE_A4, 4, NOTE_C4, 8, NOTE_C4, 4, NOTE_C4, 8, NOTE_C4, 4,
  NOTE_C4, 1,

  REST, 4, NOTE_A4, 8, NOTE_G4, 8, NOTE_F4, 8, NOTE_E4, 8, NOTE_D4, 8, NOTE_C4, 8, 
  NOTE_D4, 1,
  REST, 4, NOTE_A4, 8, NOTE_G4, 8, NOTE_F4, 8, NOTE_E4, 8, NOTE_D4, 8, NOTE_C4, 8, 
  NOTE_D4, 1,

  NOTE_F4, 4, NOTE_G4, 4, NOTE_A4, 8, NOTE_G4, 4, NOTE_A4, 8, //repeats from 14
  NOTE_AS4, 4, NOTE_A4, 4, NOTE_G4, 8, NOTE_F4, 4, NOTE_G4, 8,
  NOTE_A4, 4, NOTE_G4, 4, NOTE_F4, 4, NOTE_A4, 4,
  NOTE_G4, 1,
  NOTE_C5, 4, NOTE_A4, 4, NOTE_G4, 8, NOTE_A4, 4, NOTE_C5, 8,
  NOTE_AS4, 4, NOTE_A4, 4, NOTE_G4, 8, NOTE_F4, 4, NOTE_G4, 8,
  NOTE_A4, 4, NOTE_G4, 4, NOTE_F4, 4, NOTE_A4, 4,
  NOTE_G4, 1,

  NOTE_C5, 1, //22
  NOTE_C5, 4, NOTE_AS4, 8, NOTE_C5, 8, NOTE_AS4, 2,
  NOTE_A4, 4, NOTE_C4, 8, NOTE_C4, 4, NOTE_C4, 8, NOTE_C4, 4,
  NOTE_C4, 1,

  REST, 4, NOTE_A4, 8, NOTE_G4, 8, NOTE_F4, 8, NOTE_E4, 8, NOTE_D4, 8, NOTE_C4, 8, 
  NOTE_D4, 1,
  REST, 4, NOTE_A4, 8, NOTE_G4, 8, NOTE_F4, 8, NOTE_E4, 8, NOTE_D4, 8, NOTE_C4, 8, 
  NOTE_D4, 1,

  NOTE_F4, 4, NOTE_G4, 4, NOTE_A4, 8, NOTE_G4, 4, NOTE_A4, 8, //30
  NOTE_AS4, 4, NOTE_A4, 4, NOTE_G4, 8, NOTE_F4, 4, NOTE_G4, 8,
  NOTE_A4, 4, NOTE_C4, 8, NOTE_C4, 4, NOTE_C4, 8, NOTE_C4, 4,
  NOTE_C4, 1, 

  NOTE_F4, 4, NOTE_G4, 4, NOTE_A4, 8, NOTE_G4, 4, NOTE_A4, 8, //repeats from 14 (again)
  NOTE_AS4, 4, NOTE_A4, 4, NOTE_G4, 8, NOTE_F4, 4, NOTE_G4, 8,
  NOTE_A4, 4, NOTE_G4, 4, NOTE_F4, 4, NOTE_A4, 4,
  NOTE_G4, 1,
  NOTE_C5, 4, NOTE_A4, 4, NOTE_G4, 8, NOTE_A4, 4, NOTE_C5, 8,
  NOTE_AS4, 4, NOTE_A4, 4, NOTE_G4, 8, NOTE_F4, 4, NOTE_G4, 8,
  NOTE_A4, 4, NOTE_G4, 4, NOTE_F4, 4, NOTE_A4, 4,
  NOTE_G4, 1,

  NOTE_C5, 1, //22
  NOTE_C5, 4, NOTE_AS4, 8, NOTE_C5, 8, NOTE_AS4, 2,
  NOTE_A4, 4, NOTE_C4, 8, NOTE_C4, 4, NOTE_C4, 8, NOTE_C4, 4,
  NOTE_C4, 1,

  REST, 4, NOTE_A4, 8, NOTE_G4, 8, NOTE_F4, 8, NOTE_E4, 8, NOTE_D4, 8, NOTE_C4, 8, 
  NOTE_D4, 1,
  REST, 4, NOTE_A4, 8, NOTE_G4, 8, NOTE_F4, 8, NOTE_E4, 8, NOTE_D4, 8, NOTE_C4, 8, 
  NOTE_D4, 1,

  NOTE_F4, 4, NOTE_G4, 4, NOTE_A4, 8, NOTE_G4, 4, NOTE_A4, 8, //30
  NOTE_AS4, 4, NOTE_A4, 4, NOTE_G4, 8, NOTE_F4, 4, NOTE_G4, 8,
  NOTE_A4, 4, NOTE_C4, 8, NOTE_C4, 4, NOTE_C4, 8, NOTE_C4, 4,
  NOTE_C4, 1, 
  
};

// sizeof gives the number of bytes, each int value is composed of two bytes (16 bits)
// there are two values per note (pitch and duration), so for each note there are four bytes
int notes = sizeof(melody) / sizeof(melody[0]) / 2;

// this calculates the duration of a whole note in ms
int wholenote = (60000 * 4) / tempo;

int divider = 0, noteDuration = 0;

int last_dark = -1; //last time lightlevel dropped below 4000


void setup() {
    pinMode(piezoPin,OUTPUT);
    pinMode(fsrPin,INPUT);
    pinMode(photoPin ,INPUT );
    pinMode(moisturePin ,INPUT );
    
    pinMode(ledPin1,OUTPUT );
    pinMode(ledPin2,OUTPUT);
    pinMode(ledPin3,OUTPUT);
    pinMode(buttonPin , INPUT); 
    Particle.variable("photo",photoReading);
    Particle.variable("moisture",moistureReading);
    
    Particle.variable("fsr",fsrReading);
    
    Particle.publish("SoilStatus", "Too much water!",60,PUBLIC);
    pinMode(soundPin,INPUT);
    Particle.variable("sound",soundReading);
    
    Particle.variable("lightDuration",lightDuration);
    digitalWrite(ledPin2,LOW);
}

//  tone( piezoPin, 2000, 150 );
//         delay(1000);
//         tone( piezoPin, 1000, 150 );
//         delay(1000);

    // delay(10800000)

void loop() {
    photoReading = analogRead(photoPin);
    moistureReading = analogRead(moisturePin);
    fsrReading = analogRead(fsrPin);
    
    if ( photoReading < 3800){
        if (moistureReading > 2500) //dry
        {
            val=0;
            Particle.publish("send_email", "Need", 60 , PUBLIC);
            digitalWrite(ledPin1,LOW);
            delay(1000);
            digitalWrite(ledPin1,HIGH);
            delay(1000);
            
        }
        else{
            
            digitalWrite(ledPin1,HIGH);
            //<2500
            if(val==0)
            
            {
                play_lionking();
                if(fsrReading > 1000){
                noTone(piezoPin);
                }
                val=1;
            }
        }
     }
      
      if (photoReading >= 3800 && fsrReading <= 1000 ){ //lights on
       
      //when light > 4000 for 2 hours,play sound. 
    learning_counter();
    
        if(fsrReading > 1000 ){ //if tap
        
        digitalWrite(ledPin2, LOW);// green led
        
        noTone(piezoPin);
        }
    }
    
    int read1 =  analogRead(soundPin);
    delay(10);
    int read2 =  analogRead(soundPin);
    delay(10);
    int read3 =  analogRead(soundPin);
    delay(10);
    int read4 =  analogRead(soundPin);
    delay(10);
    int read5 =  analogRead(soundPin);
    delay(10);
    int read6 =  analogRead(soundPin);
    delay(10);
    int read7 =  analogRead(soundPin);
    delay(10);
    int read8 =  analogRead(soundPin);
    delay(10);
    int read9 =  analogRead(soundPin);
    delay(10);
    int read10 =  analogRead(soundPin);
    delay(10);
    int read11 =  analogRead(soundPin);
    delay(10);
    int read12 =  analogRead(soundPin);
    delay(10);
    int read13 =  analogRead(soundPin);
    delay(10);
    int read14 =  analogRead(soundPin);
    delay(10);
    int read15 =  analogRead(soundPin);
    
    soundReading = (read1+read2+read3+read4+read5+read6+read7+read8+read9+read10+read11+read12+read13+read14+read15)/15;
    
    if (soundReading > 400 ){
        digitalWrite(ledPin3, HIGH);//yellow led
        delay(1000);
        digitalWrite(ledPin3,LOW);
        delay(1000);
        
        if(soundReading > 1000){
            playNotes();
            }
        }
    if (fsrReading > 1500 && soundReading < 200 && moistureReading < 2500 && photoReading <3800){
        
        play_lionking();
    }
   
}
    
    
    
void learning_counter(){
    lightDuration = millis()-last_dark; 
    if (photoReading < 3800)
    {
        last_dark = millis();
         
    }
    
    if(lightDuration > duration_relax ){ //learn too long
    
    tone(piezoPin,2000,200);
    
    digitalWrite(ledPin2, HIGH);
    delay(500);
    digitalWrite(ledPin2,LOW);
    delay(500);
    
    }
    
}



void count(){
        	if( last_published + 6000 < millis() ){
    	Particle.publish( "send_email", String("On"));//piezo
    		last_published = millis();
    		}
    }



void playNotes()
{
    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/noteDurations2[thisNote];
      tone(piezoPin, melody2[thisNote],noteDuration);

      int pauseBetweenNotes = noteDuration * 1.30;
      delay(pauseBetweenNotes);
      // stop the tone playing:
      noTone(piezoPin);
    }
}

void play_lionking() {
  // iterate over the notes of the melody.
  // Remember, the array is twice the number of notes (notes + durations)
  for (int thisNote = 0; thisNote < notes * 2; thisNote = thisNote + 2) {

    // calculates the duration of each note
    divider = melody[thisNote + 1];
    if (divider > 0) {
      // regular note, just proceed
      noteDuration = (wholenote) / divider;
    } else if (divider < 0) {
      // dotted notes are represented with negative durations!!
      noteDuration = (wholenote) / abs(divider);
      noteDuration *= 1.5; // increases the duration in half for dotted notes
    }

    // we only play the note for 90% of the duration, leaving 10% as a pause
    tone(piezoPin, melody[thisNote], noteDuration * 0.9);

    // Wait for the specief duration before playing the next note.
    delay(noteDuration);

    // stop the waveform generation before the next note.
    noTone(piezoPin);
  }
}
Click to Expand
0
Video Internet of Plants
颜江涛 - https://youtu.be/A0d54YM0zG4
0

Next Steps

1. Make the solution more gentle and consider more details about UX.

2. Using code to fulfill a better user experience.

2. Structure and clean the code.

4. Make a physical and aesthetics pleasing prototype.

5. Put on my website.

0

Reflection

1. Did not finish what I defined in the beginning.

2. Needing more knowledge of the algorithm.

3. Not a very good understanding of if there are many variables and sensors.  Should groom my understanding of complicated if statement.


x

Start the Conversation

Share this Project

Found In
Courses

49713 Designing for the Internet of Things

· 16 members

A hands-on introductory course exploring the Internet of Things and connected product experiences.

Focused on
About

An Internet of Plant that accompanies people in the bedroom.

Created

November 7th, 2019