Cathy's Daily Scheduler

Cathy’s Daily Scheduler is a tangible task management device designed to help users like Cathy, who value structure and need visual, low-stress tools, plan their day with greater ease and independence. The system uses magnetic task markers, visual prompts, and celebratory sounds to support routine building and provide positive reinforcement. Developed through a collaborative class effort, the project was shaped by direct interviews with our client to ensure it met real needs. You can view the interview documentation here.

This project helps Cathy plan her day in a simple and supportive way. Her caretaker can add tasks to the device, and as Cathy completes each one, she places a small magnet on it. The device plays a sound to celebrate her progress. It’s designed to be easy to use, with clear visuals and no reading, so Cathy can feel more independent and stay on track.

The video demonstrates the final version of an interactive flower-shaped task management device designed for a differently-abled user. At the center of the device is a circular screen that initially displays a friendly “Hello” message, surrounded by eight petal slots embedded with Hall effect sensors.

To begin, the user sets the tasks by placing two labeled task stickers onto the whiteboard-like task panel. These physical visual cues represent the appointments or activities scheduled for the day. Once the stickers are placed, the system registers the task setup and displays a confirmation on the screen that reads “Task Set,” indicating the system has logged the appointments.

Following that, the user adds a petal, each petal contains a small magnet, which, when placed into a slot on the flower base, aligns with a Hall sensor underneath. This triggers a feedback sequence on the central screen, displaying a positive affirmation such as “Good job, Cathy!” offering encouragement and turning the completion of daily tasks into a celebratory moment.

The design leverages tactile interaction, visual clarity, and audio reinforcement to make routines more accessible and affirming for the user.

Every morning after breakfast, Cathy walks over to her flower-shaped scheduler. Her caretaker has already helped set the tasks for the day with simple, familiar things like “Bake cookies,” “Brush teeth,” and “Water the plant.” She also adds the necessary appointments for the day. On the screen, a cheerful message says, “Hi Cathy!” with little flower icons blooming around it.

Cathy picks up one of the magnetic petals from the storage box and places it next to the “Brush teeth” task. The scheduler lights up and plays a short tune, one of Cathy’s favourite songs - Sweet Home Alabama. The screen flashes a message: “Good job, Cathy!” She smiles and hums along.

Later that afternoon, Cathy finishes her second task, baking. She reaches for another petal, snaps it into place, and again, the device responds with celebratory music and a glowing screen. With each petal, Cathy feels a little prouder and a little more in control of her day.

At night, her caretaker reviews the petals Cathy placed and resets the scheduler for tomorrow, swapping in a few new task icons. Cathy feels calm knowing what’s coming next and excited to earn more cheerful tunes in the morning.

Design Question

This prototype was designed to help answer the question: How might we help Cathy plan her appointments in advance and encourage her to follow through in a way that supports her sense of organization and confidence?

Process and Prototype Description

Our process began with a visit to Achieva, where we met Cathy and her caretaker. Through observation and interviews, we learned that Cathy loves being organized and prefers to work at her own pace. She feels most comfortable when she knows what to expect, and finds it difficult to manage her routine when appointments aren’t planned ahead. We also noticed how positively she responded to encouragement and visuals, and how important familiar formats and routine were in her daily life.

We began with low-fidelity paper prototypes to map out interaction flows and task visuals. This allowed us to test layout, placement of elements, and overall interaction without committing to materials. From there, we moved to a laser-cut version of the device in wood and acrylic, where we started experimenting with magnetic petals, modular layers, and a basic screen interface. At this stage, we realized that our design relied too heavily on text, which didn’t suit Cathy’s needs. This led us to simplify the interface further and switch to visual icons and minimal reading.

In the final iteration, we built a 3D-printed version of the flower-shaped scheduler with a touchscreen interface, magnetic petals, and audio feedback. Tasks could be set with the help of a caretaker, and as Cathy completed them, she placed magnetic petals on the device. The screen responded with supportive messages like “Good Job Cathy!” and the device played a cheerful tune to celebrate her progress.

Key Learnings

Through our iterative prototyping process, we learned that Cathy responded best to tactile and visual interactions, with images proving far more effective than text. Encouragement through sound and simple visuals helped reframe appointments as accomplishments, making task completion feel positive and motivating. As we refined the design, we gradually reduced complexity and tailored the system to better align with Cathy’s preferences and needs. Testing with layered materials also revealed usability challenges such as confusion around petal orientation which we addressed by adjusting the petal shape and refining the feedback experience.

In the video, the user begins by writing a task on the white, dry-erase task board shaped like flower petals. This board is then placed onto the laser-cut wooden flower base. Once the system detects the task board, the LCD screen displays “Task Set,” confirming that the task has been registered. The user then attaches a magnetic petal to one of the designated petal slots. A Hall effect sensor beneath the slot detects the magnet embedded in the petal. Once detected, the screen responds with an encouraging message like “Good Job Cathy!” positively reinforcing the completion of the task.

Our prototyping process revealed several important insights about Cathy’s needs and how she interacts with assistive technology. We began by testing touchscreen and text-based designs, but quickly realized these were not intuitive for her. Cathy responded best to clear visuals, tactile elements, and sound-based feedback. This shifted our focus toward physical interaction like placing magnetic petals and audio responses to reinforce task completion. We also learned that simplifying the system was key: each layer of complexity added confusion rather than value, especially in early prototypes that relied on multiple screens or dense instructions.

We incorporated critique feedback around durability, modularity, and visual clarity. The magnetic petals were redesigned to be more robust and easier to handle. The flower structure was 3D printed to ensure alignment and support repeated interaction. We also improved visual contrast on the screen and streamlined the setup to focus on task display and affirmation. Some feedback like adding dynamic scheduling modes or voice input was intentionally set aside, as it would have increased cognitive load and moved away from Cathy’s strengths.

One of the biggest surprises was how strongly Cathy responded to encouragement through music and celebratory visuals. These small moments of feedback helped transform appointments from tasks into accomplishments, making routine-building more joyful and motivating.

Looking back, our design process was filled with both challenges and unexpected insights. While we began with a clear plan and timeline, we quickly found ourselves adapting at nearly every stage. Our initial ideas relied heavily on touchscreen interfaces and text-based interactions, but through direct testing with Cathy, we realized those approaches weren’t well-suited to her preferences. This discovery was pivotal, it reframed how we approached both the interface and the interaction model, prompting a shift toward simpler, tactile, and visual systems.

We didn’t follow our original Gantt chart very closely. Much of our divergence came from technical constraints and sensor performance. For example, we initially planned to use capacitive or force sensors, but inconsistencies and setup issues forced us to pivot to magnetic sensing. Each prototype iteration brought new challenges whether it was display compatibility, interaction feedback, or structural alignment and we often found ourselves reworking parts of the system from scratch. These breakdown moments, though frustrating, were ultimately productive and pushed us toward more user-centered and resilient solutions.

Our biggest breakthrough came when Cathy visibly responded to placing a petal and hearing a joyful sound. That moment validated many of the iterative decisions we had made simplifying, testing early, and letting the user’s reactions guide our path forward.

One feedback we received was to add different colors for the petals. I completely agree, this was actually our original idea. However, due to time constraints toward the end of the project, we couldn’t prioritize this feature. If we have extra time in the future, we will add colorful petals to improve our design. Another feedback was about strengthening the magnets. Initially, we believed our magnets were sufficiently strong, but during physical integration, we realized they are not strong enough. So if there is an iteration, we plan to replace them with higher-strength magnets. The key lesson learned here is that early testing is necessary. If we had tested the magnets earlier in the process, we could have identified and resolved this issue sooner. Another suggestion was to incorporate animations on the screen to increase enjoyment. This was part of our initial plan. We tried to add animations to increase interactivity, so we met with Zach multiple times and followed all the tutorial instructions. Unfortunately, we encountered technical issues. So we chose to draw some flowers on the screen, a nod to Cathy’s love for flowers. If we have extra time, integrating a GIF-based animation will be a priority. An additional recommendation was to personalize the task images by incorporating Cathy’s photo, making it easier for her to identify which tasks to complete. This is an excellent suggestion! If we have the opportunity to revisit the integration, we will adjust the images.

It was really surprising how the deadline just felt like it came out of nowhere. We're glad that Zach required us to schedule our project, but we could have been more on top of it. It would have been nice to have printed at least one prototype of the final model before we had to assemble it, since we ended up running into many problems. We weren't positive that everything would fit together in the end, we designed the flower to try to accommodate all the wires, but at the end of the day, it was just a guess, luckily, that wasn't an issue. What was an issue was that the stem didn't slot into the flower head, so we had to basically carve out parts of it so it would fit. So, one large takeaway is to increase the pacing to let us test the physical model, letting us avoid the problems we ran into. A bit more time with the physical model also would have let us paint it in time for the showcase. Overall, this project went great! While there were hiccups, everything worked and looked great in the end!

/*

 Flower Schedular

 Nora Xi, Aishhwarya, Jaden

 Use magnetic sensors to detect petals

 Interact with the touch screen

 Play country music though DFminiPlayer

 pin mapping:

 Arduino Mega pin | role | description

 ---------------------------------------------

 A0                 output  LCD_RD (tft screen)

 A1                 output  LCD_WR (tft screen)

 A2                 output  LCD_CD (tft screen)

 A3                 output  LCD_CS (tft screen)

 A6                 output  YP     (tft screen)

 A7                 output  XM     (tft screen)

 0                  input   mag sensor8

 1                  input   mag sensor1

 2                  input   mag sensor2

 3                  input   mag sensor3

 4                  input   mag sensor4

 5                  input   mag sensor5

 6                  input   mag sensor6

 7                  input   mag sensor7

 10                 output  TX (DFminiPlayer)

 11                 output  RX (DFminiPlayer)

 12                 input   button

 22                 output  D0 (tft screen)

 23                 output  D1 (tft screen)

 24                 output  D2 (tft screen)

 25                 output  D3 (tft screen)

 26                 output  D4 (tft screen)

 27                 output  D5 (tft screen)

 28                 output  D6 (tft screen)

 29                 output  D7 (tft screen)

 52                 output  YM (tft screen)

 53                 output  XP (tft screen)

 Part of code for tft touch screen is from Adafruit Tutorial: https://github.com/adafruit/TFTLCD-Library

 Part of code for drawing flowers is from ChatGPT

*/

//all the libraries

#include <Adafruit_GFX.h>

#include "Adafruit_TFTLCD.h"

#include <TouchScreen.h>

#include <SD.h>

#include <SPI.h>

#include <Wire.h>

#include "Arduino.h"

#include <LiquidCrystal_I2C.h>

#include "DFRobotDFPlayerMini.h"

#include <SoftwareSerial.h>

//mini player

SoftwareSerial mySoftwareSerial(10, 11); // RX = 11, TX = 10

DFRobotDFPlayerMini myDFPlayer;

// Color definitions

#define BLACK          0x0000

#define BLUE           0x001F

#define RED            0xF800

#define GREEN          0x07E0.

#define CYAN           0x07FF

#define MAGENTA        0xF81F

#define YELLOW         0xFFE0

#define WHITE          0xFFFF

#define FLOWER_CENTER  0xFD20  // Orange

#define FLOWER_PETAL   0xF81F  // Pink

#define STEM_COLOR     0x07E0  // Green

#define SUNFLOWER_CENT 0xFD00  // Darker orange

#define SUNFLOWER_PET  0xFFE0  // Yellow

#define TULIP_COLOR    0xF800  // Red

#define DAISY_PETAL    0xFFFF  // White

#define DAISY_CENTER   0xFE60  // Yellow

// Pins

#define YP A6 

#define XM A7 

#define YM 52

#define XP 53

#define LCD_CS A3

#define LCD_CD A2

#define LCD_WR A1

#define LCD_RD A0

#define LCD_RESET -1

//   D0 connects to digital pin 22 

//   D1 connects to digital pin 23  

//   D2 connects to digital pin 24

//   D3 connects to digital pin 25

//   D4 connects to digital pin 26

//   D5 connects to digital pin 27

//   D6 connects to digital pin 28

//   D7 connects to digital pin 29

#define PHYSICAL_BUTTON 12  // New physical button pin

// Petal pins

const int PetalPins[8] = {1, 2, 3, 4, 5, 6, 7, 0};

bool petalPrevStates[8] = {false};

bool petalActive[8] = {false};

unsigned long petalStartTimes[8] = {0};

// Display settings

Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);

TouchScreen ts = TouchScreen(XP, YP, XM, YM, 350);

LiquidCrystal_I2C lcd(0x27, 16, 2);

// App states

String currentMessage = "Hi Cathy!";

String previousMessage = "";

bool detectionEnabled = false;

bool configModeActive = false;  // Configuration mode state

const unsigned long MESSAGE_DURATION = 3000;

int taskIndex = 0;

// Animation states

unsigned long lastFlowerUpdate = 0;

int flowerState = 0;

bool bloomActive = false;

unsigned long bloomStart = 0;

// Button

unsigned long lastButtonPress = 0;

const unsigned long BUTTON_DEBOUNCE = 200;

// Protected center area

const int CENTER_SAFE_ZONE = 120;

const int CENTER_X = 160;

const int CENTER_Y = 240;

// Touch calibration

#define TS_MINX 70   

#define TS_MINY 120

#define TS_MAXX 920

#define TS_MAXY 900

#define MINPRESSURE 5

#define MAXPRESSURE 1000

void setup() {

 Serial.begin(9600);

 mySoftwareSerial.begin(9600);

 Serial.println("Initializing DFPlayer Mini...");

 tft.begin(0x9341);

 tft.setRotation(0);

 if (!myDFPlayer.begin(mySoftwareSerial)) {

   Serial.println("DFPlayer Mini not detected! Check wiring and SD card.");

   while (true);

 }

 Serial.println("DFPlayer Mini ready.");

 myDFPlayer.volume(30);  // Set volume to 30

  for(int i=0; i<8; i++) {

   pinMode(PetalPins[i], INPUT_PULLUP);

 }

 pinMode(PHYSICAL_BUTTON, INPUT_PULLUP); 

  drawScreen();

}

void drawFlower(int x, int y, int size, int type) {

 if(abs(x - CENTER_X) < CENTER_SAFE_ZONE && abs(y - CENTER_Y) < CENTER_SAFE_ZONE) {

   return;

 }

 tft.drawLine(x, y+size/2, x, y+size, STEM_COLOR);

 int sway = flowerState ? size/20 : -size/20;

  switch(type) {

   case 0: // Basic flower

     tft.fillCircle(x - size/4 + sway, y - size/4, size/6, FLOWER_PETAL);

     tft.fillCircle(x + size/4 + sway, y - size/4, size/6, FLOWER_PETAL);

     tft.fillCircle(x - size/4 - sway, y + size/4, size/6, FLOWER_PETAL);

     tft.fillCircle(x + size/4 - sway, y + size/4, size/6, FLOWER_PETAL);

     tft.fillCircle(x, y, size/5, FLOWER_CENTER);

     break;

   case 1: // Sunflower

     tft.fillCircle(x, y, size/4, SUNFLOWER_CENT);

     for(int i=0; i<8; i++) {

       float angle = i * PI/4 + (flowerState * PI/16);

       int px = x + (size/3) * cos(angle);

       int py = y + (size/3) * sin(angle);

       tft.fillCircle(px, py, size/8, SUNFLOWER_PET);

     }

     break;

   case 2: // Tulip

     tft.fillTriangle(x - size/4, y + size/4,

                      x + size/4, y + size/4,

                      x, y - size/4, TULIP_COLOR);

     tft.fillCircle(x, y - size/6, size/8, TULIP_COLOR);

     break;

   case 3: // Daisy

     tft.fillCircle(x, y, size/6, DAISY_CENTER);

     for(int i=0; i<12; i++) {

       float angle = i * PI/6;

       int px = x + (size/3) * cos(angle + (flowerState * PI/16));

       int py = y + (size/3) * sin(angle + (flowerState * PI/16));

       tft.fillCircle(px, py, size/12, DAISY_PETAL);

     }

     break;

 }

}

void drawSmallFlowers() {

 if(millis() - lastFlowerUpdate > 500) {

   flowerState = (flowerState + 1) % 4;

   lastFlowerUpdate = millis();

 }

 if(bloomActive) {

   if(millis() - bloomStart > 2000) bloomActive = false;

   int bloomSize = map(millis() - bloomStart, 0, 2000, 40, 80);

   drawFlower(270, 400, bloomSize, flowerState % 4);

 } else {

   // Original flowers

   drawFlower(150, 350, 40, flowerState % 4);

   drawFlower(250, 350, 40, (flowerState+1) % 4);

   // Moving flowers

   int movingX = map(flowerState, 0, 3, 50, 270);

   drawFlower(movingX, 300, 30, 1);

   drawFlower(320-movingX, 380, 30, 3);

 }

 // Top border flowers (added/modified section)

 drawFlower(20, 30, 25, (flowerState) % 4);       // Left small flower

 drawFlower(60, 50, 35, (flowerState+1) % 4);     // Left-middle

 drawFlower(100, 40, 28, (flowerState+2) % 4);    // Middle-left

 drawFlower(tft.width()/2, 30, 40, (flowerState+3) % 4); // Center big flower

 drawFlower(200, 50, 32, (flowerState) % 4);      // Middle-right

 drawFlower(240, 35, 25, (flowerState+1) % 4);    // Right-middle

 drawFlower(280, 45, 35, (flowerState+2) % 4);    // Right side

 drawFlower(300, 30, 40, (flowerState+3) % 4);     // Right edge flower

}

void drawScreen() {

 tft.fillScreen(BLACK);

 drawSmallFlowers();

 tft.setTextColor(WHITE);

 byte textSize = currentMessage.length() > 15 ? 2 : (currentMessage.length() > 10 ? 3 : 4);

 tft.setTextSize(textSize);

  int16_t x, y;

 uint16_t w, h;

 tft.getTextBounds(currentMessage, 0, 0, &x, &y, &w, &h);

 if (configModeActive){

   tft.setCursor((tft.width() - w)/2, 140);

 }else{

      tft.setCursor((tft.width() - w)/2, (tft.height() - h - 170)/2);

 }

 tft.print(currentMessage);

 if(configModeActive) {

   drawButton(30, 400, 120, 50, "Add");

   drawButton(170, 400, 120, 50, "Done");

 }

}

void drawButton(int x, int y, int w, int h, const char* label) {

 tft.drawRect(x, y, w, h, WHITE);

 tft.setTextSize(2);

 tft.setCursor(x + (w - strlen(label)*12)/2, y + 15);

 tft.print(label);

}

void handlePetalPress(int petalIndex) {

 currentMessage = "Good Job Cathy!";

 petalActive[petalIndex] = true;

 petalStartTimes[petalIndex] = millis();

 bloomActive = true;

 bloomStart = millis();

}

bool isInside(int x, int y, int bx, int by, int bw, int bh) {

 return (x > bx) && (x < (bx + bw)) && (y > by) && (y < (by + bh));

}

void loop() {

 if (currentMessage == "Good Job Cathy!") {         

   Serial.println("Playing track 1...");

   myDFPlayer.play(1);                // Play track 1

   delay(20000);                      

   myDFPlayer.stop();                 // Stop playback

   Serial.println("Playback stopped.");

 }

 bool needsRedraw = false;

  // Physical button handling

 if(digitalRead(PHYSICAL_BUTTON) == LOW && millis() - lastButtonPress > BUTTON_DEBOUNCE) {

   configModeActive = !configModeActive;

   detectionEnabled = !configModeActive;

   lastButtonPress = millis();

   needsRedraw = true;

 }

 // Petal detection

 bool currentPetalStates[8];

 for(int i=0; i<8; i++) {

   currentPetalStates[i] = (digitalRead(PetalPins[i]) == LOW);

 }

 if(detectionEnabled && !configModeActive) {

   for(int i=0; i<8; i++) {

     if(currentPetalStates[i] && !petalPrevStates[i]) {

       handlePetalPress(i);

       needsRedraw = true;

     }

   }

   bool allPressed = true;

   for(int i=0; i<8; i++) allPressed &= currentPetalStates[i];

   if(allPressed && currentMessage != "Well Done :)") {

     currentMessage = "Well Done :)";

     needsRedraw = true;

   }

 }

 // Message timeout

 unsigned long currentTime = millis();

 for(int i=0; i<8; i++) {

   if(petalActive[i] && (currentTime - petalStartTimes[i] >= MESSAGE_DURATION)) {

     petalActive[i] = false;

     if(currentMessage != "Hello") {

       currentMessage = "Hello";

       needsRedraw = true;

     }

   }

 }

 // Update states

 for(int i=0; i<8; i++) petalPrevStates[i] = currentPetalStates[i];

 // Touch handling

 if(configModeActive) {

   TSPoint p = ts.getPoint();

   pinMode(XM, OUTPUT);

   pinMode(YP, OUTPUT);

   if(p.z > MINPRESSURE && p.z < MAXPRESSURE) {

     int yCoord = tft.height() - map(p.y, TS_MINY, TS_MAXY, 0, tft.height());

     int xCoord = tft.width() - map(p.x, TS_MINX, TS_MAXX, 0, tft.width());

     if(isInside(xCoord, yCoord, 30, 400, 120, 50)) { // Add

       taskIndex = (taskIndex < 8) ? taskIndex + 1 : 8;

       currentMessage = "Task " + String(taskIndex);

       needsRedraw = true;

       delay(300);

     }

     if(isInside(xCoord, yCoord, 170, 400, 120, 50)) { // Done

       configModeActive = false;

       detectionEnabled = true;

       taskIndex = 0;

       currentMessage = "Hello";

       needsRedraw = true;

       delay(100);

     }

   }

 }

 // Update display

 if(needsRedraw || currentMessage != previousMessage) {

   drawScreen();

   previousMessage = currentMessage;

 }

}