Published April 17, 2019

Photon Time Tracker

This portable device is a dedicated time tracking device to help manage your time. Multiple photons are used to set up automatic triggers.

IntermediateWork in progress703

Things used in this project

Hardware components

Particle Photon

Tactile Switch, Top Actuated

SunFounder LCD 20x4 character display

SparkFun Photon Battery Shield

Adafruit Lithium Ion Polymer Battery - 3.7V 2500mAh

Story

Edit: 4/17/2019 - 7:52 PM

Sharing link of the live time tracking data as requested in project description: https://docs.google.com/spreadsheets/d/1bL2JebJtUSs1Q9dgRIx83QeXee-WWNhtK7X0w5wRPqw/edit?usp=sharing

Original: 4/17/2019

Videos

Time Tracker - Hardware

Time Tracker - Code and Data

Time Tracker - Automatic Triggers and Two Way Communication

Mission

The purpose of the time tracker is to create a system where I can log time can be logged and be automatically graphically represented. This data can be examined to view one's use of time and make changes to boost productivity.

Method

A photon wifi board was used to send information through IFTTT logged onto an elaborate google sheet where the data will be stored and represented graphically. And LCD character acts as a user interface, allowing for a user to send information to the spreadsheet, view the activity being recorded, and turn the photon into a low power mode. The user communicates to the photon via 4 buttons, a green confirm button, a red decline button, a blue up button, and a yellow down button. A battery shield and LiPo battery allow the time tracker to stay powered and chargeable for portable use.

The User Interface

The photon first displays to the user three options: change status, check status, and shut down.

Choosing "change status" will let the user pick from a set of predefined time categories to indicate that they are doing something different than is currently being logged/recorded. This done via the Particle.publish command. Once IFTTT detects this, a new line is added to the spreadsheet.

The second option, "check status" will simply display the last recorded time option sent during the current session. At present, the photon will not pull the last recorded time activity if the user has shutdown before sending anything. This will be added in later iterations.

The third option, "shut down" lets the user send the photon into deep sleep using the System.sleep command. Once shut down, the time tracker can be awakened again by hitting the confirm button.

The Google Sheet

The google sheet is a place for the time tracker to store and represent data. Data is recorded, interpreted, and represented.

Recording Data

The first sheet of the spreadsheet is the raw data. It lists only the time of the activity and the time it was recorded.

Interpreting Data

Raw data is first transformed into a format that is readable. With the readable data, duration of time activities are found by the distance between time entries sent the sheet. These duration are sorted by day and category.

Representing Data

Now that the data is recorded and interpreted, the google sheet puts them into two graphs: a day by day stacked histogram and a weekday stacked histogram. The day by day shows a bar for each day and all the activities that were done in the day on each graph. Each day represents 24 hours and only shows the month that the spreadsheet was made for. (There are 12 spreadsheets; one for each month.) The weekday histogram shows the distribution of hours in each weekday throughout the current month.

Stacked histogram for time logs by individual days

Proportional histogram for time logs by weekday

Components

The time tracker consists of a photon, an LCD character display, and 4 tactile buttons.

Buttons

The photon uses digital pins with internal pull down resistors to get input from the buttons. When the button is pressed digital.Read will return a high value, and a low value when unpressed. Pins D3, D4, D5, and D6 are used to recieve input voltage.

LCD Character Display

The LCD character display comes with a I2C micro-controller. As such, pins D0 and D1 were used to communicate with the display. Pull-up resistors are used with I2C.

Other Considerations

Originally, a rotary encoder and 2 buttons were used to navigate menus. However, the photon is not well suited to accept that type of input, additionally, the encoder that was being tested with had low resolution, so the 4 buttons approach was ultimately chosen.

Automatic Trigger: Lights Out [Two Way Communication]

A proof of concept automatic trigger was created using an analog.read command and a photo-resistor. When there was not enough light shining on the resistor, a "sleep" time ping would be sent to the time tracker spreadsheet. In the future, this concept will be used to determine if the user is in a particular room and will remind the user to act if they have an activity that does not match their location. [For the project, I have included two way communication. When a status is changed on the "main console" of the time tracker, the automatic light trigger's LED blinks three times. Additionally, when the photo-resistor changes the time activity to "sleep", the current activity is reflected in the "check status" menu. Hence completing need for two way communication. Shown in video 3.]

The Future

Later editions of this project will include: Pulling the current status from the cloud instead of only keeping it locally. Ability to make new categories from the photon. Automatic triggers to ensure more accurate values (GPS trackers to see when the user leave the house, photo-resistors to check when the user goes to bed, ect.)

Code

/*Time tracker code 
Clayton Parrish
For UNCC MEGR 3171 IOT Project
Create - 4/10/2019
Edited - 4/16/2019
Finished  1.0.0 - 4/17/2019 (early morning)
Edited - 4/18/2019 
*/

//LIBRARIES __ START

#include <Encoder.h>                //For Rotary Encoder (No longer included)
#include <LiquidCrystal_I2C2.h>     //For LCD Display
#include <Wire.h>                   //I don't know what this is for, but I dare not delete it :-)

//LIBRARIES __ END

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

//DEFINE VARIABLES __ START

LiquidCrystal_I2C2 lcd(0x27,20,4);  //Defines LCD at bus adress of 0x27. 20 char per line, 4 lines.

//Holding variable for rotary encoder
int cursor_abs;                     //Current encoder position              
int aLastState = digitalRead(D5);   //Previous encoder position
int lag = 10;                        //Delay time to check difference in positions
bool rotating = false;              //Flag that is turned true upon rotary encoder movement

//Define ports
int GB = D5;        // Green button
int RB = D3;        // Red button
int LCD_PWR = D7;   // Power to LCD character display
int ROT_1 = A2;     // Analog input 1 for rotary encoder
int ROT_2 = A3;     // Analog input 2 for rotary encoder
int UB = D4;        // Up button
int DB = D6;        // Down button

//Define state of the program
int status = 0;                  //State determines the "loop" that will occur
                                //0 = main screen, 1 = change status, 2 = current status, 3 = shut down 

//Define different time categories that can be sent to google 
int cate_max = 11;
String Cate[] = {"Homework", "Projects", "Career", "Free Time", "Social", "Sleep", "Transit", "Meals", "Meetings", "Family", "Chores"};

//Menu navigation variables
int cursor = 0;
int cursor_b = 0;
int last_cursor;
int M_select;
String CURRENT_STATUS; 



//DEFINE VARIABLES __ END

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

void setup()
{
    //Open up serial monitoring for debugging
    Serial.begin(9600);
    
    //Set up pins    
    pinMode(LCD_PWR, OUTPUT);
    pinMode(ROT_1, INPUT);
    pinMode(ROT_2, INPUT);
    pinMode(GB, INPUT_PULLDOWN);
    pinMode(RB, INPUT_PULLDOWN);
    pinMode(UB, INPUT_PULLDOWN);
    pinMode(DB, INPUT_PULLDOWN);
    
    //LCD Screen set up
    digitalWrite(LCD_PWR, HIGH);    //Turn on LCD screen
    lcd.init();                     //initialize the lcd
    lcd.backlight();                //open the backlight 
    
    //Encoder 
    attachInterrupt(A2, doEncoder, CHANGE); //Sets doEncoder to trigger upon rotary encoder movement

    //Two way communciation with other photon
    Particle.subscribe("Sleepy", myHandler, ALL_DEVICES);
    
    //Inital Screen
    lcd.setCursor(0,0);
    lcd.print("Time Tracker   ");
    lcd.setCursor(0,1);
    lcd.print("Clayton Parrish");
    lcd.setCursor(0,2);
    lcd.print("Version 1.0.0");
    lcd.setCursor(0,3);
    lcd.print("  ");
    delay(1000);
    
    
    MainScreen();
}
/*********************************************************/
void loop() {
    //If the rotary encoder is rotating, change the position
    while(rotating) {
        updateEncoder();
    }

    // MAIN SCREEN _ START
    
    if(status == 0) {
        if(digitalRead(UB) == HIGH) { 
            cursor += 1;
            if(cursor > 2) {
                cursor = 0;
            }
            delay(250);
        }
        if(digitalRead(DB) == HIGH) {
            cursor -= 1; 
            if(cursor < 0) {
                cursor = 2;
            }
            delay(250);
        }
        
        if(cursor != cursor_b) {
            M_Change(cursor);
        }
        cursor_b = cursor;
        
        if(digitalRead(GB) == HIGH) {
            switch(cursor) {
                case 0:
                    ChangeStatusMenu();
                break;
                case 1:
                    CheckStatusMenu();
                break;
                case 2:
                    ShutDown();
                break;
            }
        }
        if(digitalRead(RB) == HIGH) {
            ShutDown();
            delay(250);
        }
    
    }
    
    // MAIN SCREEN __ END
    
    /***********************/
    
    // CHANGE STATUS __ START
    
    if(status == 1){
        if(digitalRead(UB) == HIGH) {
            cursor += 1;
            if(cursor > (cate_max - 1)) {cursor = 0;}
            C_Change();
            delay(250);
        }
        if(digitalRead(DB) == HIGH) {
            cursor -= 1;
            if(cursor < 0) {cursor = (cate_max - 1);}
            C_Change();
            delay(250);
        }
        
        if(digitalRead(GB) == HIGH) {
            CURRENT_STATUS = Cate[cursor];
            String sc   = String("Status_Change_");
            String mnth = String(Time.month());
            Particle.publish(sc + mnth, Cate[cursor]);
            delay(250);
            lcd.clear();
            lcd.setCursor(0,0);
            lcd.print("  Updated :)  ");
            delay(1000);
            MainScreen();
        }
        if(digitalRead(RB) == HIGH) {
            MainScreen();
            delay(250);
        }
    }
    
    // CHANGE STATUS __ END
    
    /***********************/
    
    // CHECK STATUS __ START
    
    if(status == 2){
        if(digitalRead(RB) == HIGH) {
            MainScreen();
            delay(250);
        }
    }

    // CHECK STATUS __ END
    
    /***********************/
    
    // SHUT DOWN __ START

	if(status == 3) {
	   if(digitalRead(GB) == HIGH) {
            lcd.clear();
            lcd.setCursor(0,0);
            lcd.print("Goodnight :-)");
            delay(1500);
            System.sleep(SLEEP_MODE_DEEP);
        } 
        if(digitalRead(RB) == HIGH) {
            MainScreen();
            delay(500);
        }
	}
    
    // SHUT DOWN __ END
    
    
}
/************************************************************/

void doEncoder(){
    rotating = true;
}

void updateEncoder(){
    delay(lag);
    if (digitalRead(ROT_1) == digitalRead(ROT_2)) {  
        cursor_abs--;
    } 
    else {                                   
        cursor_abs++;
    }
    rotating=false;     //Set the rotating to false, will become true again if still rotating
    
}

void MainScreen() {
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("  **Time Tracker**  ");
    lcd.setCursor(0,1);
    lcd.print(">Change Status");
    lcd.setCursor(0,2);
    lcd.print("Check Status");
    lcd.setCursor(0,3);
    lcd.print("Shut Down");
    cursor = 0;
    status = 0;
}

void ShutDown() {
    lcd.clear(); 
    lcd.setCursor(0,0);
    lcd.print("     Shut down?     ");
    lcd.setCursor(0,2);
    lcd.print("    Green -> Yes    ");
    lcd.setCursor(0,3);
    lcd.print("    Red -> Back     ");
    //cursor
    delay(500);
    status = 3;
}

void M_Change(int i) {
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("  **Time Tracker**  ");
    switch(i) {
        case 0:
            lcd.setCursor(0,1);
            lcd.print(">Change Status");
            lcd.setCursor(0,2);
            lcd.print("Check Status");
            lcd.setCursor(0,3);
            lcd.print("Shut Down");
            break;
        case 1:
            lcd.setCursor(0,1);
            lcd.print("Change Status");
            lcd.setCursor(0,2);
            lcd.print(">Check Status");
            lcd.setCursor(0,3);
            lcd.print("Shut Down");
            break;
        case 2:
            lcd.setCursor(0,1);
            lcd.print("Change Status");
            lcd.setCursor(0,2);
            lcd.print("Check Status");
            lcd.setCursor(0,3);
            lcd.print(">Shut Down");
            break;
            }
}

void ChangeStatusMenu() {
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("***Change Status***");
    lcd.setCursor(0,1);
    lcd.print(Cate[cate_max - 1]);
    lcd.setCursor(0,2);
    lcd.print(">" + Cate[0]);
    lcd.setCursor(0,3);
    lcd.print(Cate[1]);
    delay(250);
    cursor = 0;
    status = 1; 
}

void C_Change() {
    int i_min = cursor - 1;
    int i_plu = cursor + 1;
    if(cursor == 0) { i_min = (cate_max - 1); }
    if(cursor == (cate_max - 1)) { i_plu = 0; }
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("***Change Status***");
    lcd.setCursor(0,1);
    lcd.print(Cate[i_min]);
    lcd.setCursor(0,2);
    lcd.print(">" + Cate[cursor]);
    lcd.setCursor(0,3);
    lcd.print(Cate[i_plu]); 
}

void CheckStatusMenu() {
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("***Current Status***");
    lcd.setCursor(0,1);
    lcd.print("You are currently:");
    lcd.setCursor(0,2);
    lcd.print(CURRENT_STATUS);
    status = 2;
}

void myHandler(const char *event, const char *data)
{
    CURRENT_STATUS = "Sleep";
    String sc   = String("Status_Change_");
    String mnth = String(Time.month());
    Particle.publish(sc + mnth, "Sleep");
}

bool dark = false;
bool light = true;
unsigned long current_time;       // ms of no light to send sleep message 
unsigned long holding_time; 

void setup() {
    pinMode(A2, INPUT);
    pinMode(D7, OUTPUT);
    Particle.subscribe("Status_Change", myHandler, ALL_DEVICES);
    Serial.begin(9600);
    //digitalWrite(D7, HIGH);
}

void loop() {
    analogRead(A2);
    Serial.write(analogRead(A2));
    if(analogRead(A2) < 1000) {  //Sleeping
            if(light)    {
                if(dark == false) {
                holding_time = millis();
                dark = true;
            }
                else {
                    current_time = millis();
                        if(current_time - holding_time > 20000) {
                            Particle.publish("Sleepy");
                            digitalWrite(D7, HIGH);
                            delay(750);
                            light = false;
                
            }
        }
        }   
    }
    else{                       //Light is on
       dark = false;
       light = true;
    }
    digitalWrite(D7, LOW);
}

void myHandler(const char *event, const char *data)
{
    digitalWrite(D7, HIGH);
    delay(750);
    digitalWrite(D7, LOW);
    delay(750);
    digitalWrite(D7, HIGH);
    delay(750);
    digitalWrite(D7, LOW);
    delay(750);
    digitalWrite(D7, HIGH);
    delay(750);
    digitalWrite(D7, LOW);
    delay(750);
}

Credits

Clayton Parrish

1 project • 0 followers

Photon Time Tracker

Things used in this project

Hardware components

Story

Schematics

Circuit Diagram

Code

Time Tracker Code

Light Trigger

Credits

Clayton Parrish

Comments

Embed the widget on your own site

Photon Time Tracker

Photon Time Tracker

Things used in this project

Hardware components

Story

Schematics

Circuit Diagram

Code

Time Tracker Code

Light Trigger

Credits

Clayton Parrish

Comments

Related channels and tags