Assistive Communication Device: Final Documentation 

For our final class project, we partnered with an organization that supports individuals with disabilities to design personalized assistive devices. Our client, Helen, is a warm and sociable person who loves sharing stories about her day. However, she sometimes struggles to clearly express her emotions and experiences, which can lead to repeated explanations and frustration when others don’t understand her. To help bridge this communication gap, our team set out to create a portable, easy-to-use device that would empower Helen to share her daily activities and feelings more effectively with her staff and loved ones. Inspired by communication tools used by nonverbal or minimally verbal autistic children, our design focused on accessibility, simplicity, and joy. We met with Helen twice—first to learn about her interests and communication style, and again to test our working prototype. To learn more about our initial meeting, visit Team Daffodil's Interview Documentation. The following page showcases our final device, the design process, and key takeaways from our experience.

Above are three videos demonstrating different stages of our device development. The first video features the completed product and includes a step-by-step tutorial on how the device is intended to function and be used. Although our RFID readers were not fully operational at the time of filming, the feedback functionality is simulated through a team member narrating the responses the device would typically produce.

The second video highlights our circuit in action prior to final assembly. In this footage, the RFID readers correctly recognize the cards when placed above them, demonstrating that the core reading mechanism was functional during earlier testing phases. While we encountered some setbacks in maintaining consistent RFID performance, we were able to get the system working intermittently and successfully documented those instances.

The third video shows an even earlier phase of development, during which only one RFID reader was successfully wired and tested. Although this was a preliminary stage, it played an important role in guiding our later prototyping and troubleshooting process.

These prototypes were designed to help answer the question: How can we help Helen communicate with her loved ones and staff smoothly, with less frustration and more understanding?

Our Questions for testing included:

1. What was Helen’s understanding of what the device is?

2. How does Helen interact with the device?

3. Can Helen comprehend & resonate with imagery on the cards?

4. How many cards are too many cards?

5. Does she understand how to place the cards and then click the button?

6. Is it easy for her to clean up the cards and place them back?

7. Can we remake the shape of the device so it is most convenient for her?

Our prototype process and interviews with Helen provided invaluable insights that shaped the final design of our device. At the start, we identified a few core questions to guide our testing—most importantly: Does Helen understand what this device is, and how does she interact with it? When we introduced the initial prototype, it became clear that certain features were confusing or unnecessary. For instance, Helen struggled with the concept of emotions, and the idea of pressing a button to trigger the device’s voice output wasn’t intuitive for her. We also discovered that the cartoon-style icons we initially used on the cards didn’t resonate with her; she needed real, familiar images that reflected her actual daily routines.

Helen also shared her personal preferences with us—she loves flowers and the color pink, which directly influenced our design decisions. Her caretaker reinforced the importance of simplicity, explaining that too many choices could easily overwhelm Helen. Based on this advice, we removed the emotion cards and reduced the number of card slots. Her caretaker also provided us with a list of Helen’s most common activities, which helped us tailor the experience specifically to her lifestyle.

We took every piece of feedback seriously, using it to simplify the device’s interaction flow and make it as user-friendly as possible. There wasn’t any suggestion that we disregarded, because our ultimate goal was to create something that Helen could operate with confidence and joy.

One unexpected challenge we encountered was the complexity of designing something that feels simple. Even as we stripped away features to improve usability, the ergonomics and layout, such as the placement of the slots, speaker, handle, and storage panel, demanded thoughtful attention. We came to appreciate how difficult it is to make an assistive device that feels both intuitive and empowering, especially when serving users with specific cognitive and physical needs.

1. Research

2. Ideation

3. Prototyping & Testing

4. Building the Circuit

5. Creating & modifying the form according to the circuit

6. Adding the electronics to the fabrication

In terms of our process and timeline, we did diverge significantly from our original plan. One of the biggest challenges we faced was with the circuit portion of the device, which ended up taking much longer than anticipated. Working with multiple RFID readers introduced a number of complications—there were many wires involved, and despite our best efforts, the circuit never fully worked in the final prototype. Along the way, we encountered issues like loose connections, burned-out components, and discovered too late that we needed additional parts to support the RFID functionality. We were troubleshooting and assembling the circuit up until the very last day of the project.Because so much time and focus went into the electronics, we could not thoroughly test different CAD design variations for the interior structure, nor could we complete the exterior in time. 

Overall, there were many aspects of our device that went well and others that could have been improved upon given more time and different circumstances. In terms of positive feedback, one reviewer mentioned that “the design is very durable” and “can be taken around very easily.” This aligned perfectly with our goal in the CAD design—to make the device resemble a toy, so it would feel approachable and withstand rough handling. We printed the outer casing with thick material and screwed it together to enhance its structural integrity. Another person noted that “the placement of the button is the most ideal,” since we positioned it under the handle to avoid accidental activation. Several people also commented on how “cute” and “welcoming” the design was, thanks to the flower shape and pink color—both of which Helen loves. Most importantly, Helen herself enjoyed interacting with the cards, which featured real photos of activities and people she recognized. Her caretaker reinforced that decision, saying, “It was the right idea to use photos she would recognize,” which we completely agreed with.

On the other hand, we also received constructive feedback. One person suggested that “the slots for the cards should be bigger so that it’s easier to take the card out,” or that a finger divot should be added. We definitely agreed—our current slots were too close in size to the cards, which made them hard to remove. A simple divot or resizing would have made the interaction smoother. Another person pointed out that “the handle is a little too small,” especially for someone with larger hands. In future iterations, widening and thickening the handle would be a simple yet impactful improvement.

Unfortunately, our circuit was not working at the time of the critique, so reviewers were unable to experience the full functionality—particularly the card-reading and audio feedback features. However, we did show a video from when the system was briefly functioning, and many noted how much smoother conversations with Helen would be if the device worked reliably. Overall, we were glad to see that our device met Helen’s needs for communication in a way that felt intuitive and easy for her to use and carry.

This project offered many takeaways, particularly in working with a person with a disability. One challenge we hadn’t anticipated was that Helen’s communication difficulty also made it hard for us to determine which design decisions would serve her best. We had to rely heavily on input from her caretaker and our observations during prototyping. Another surprising insight was just how difficult it is to design a product that is truly intuitive. While our idea was conceptually straightforward, translating it into a physical, user-friendly product—especially one that didn’t require prior training—was unexpectedly complex. Coming from backgrounds in human-computer interaction, we had knowledge of button placement and interaction sequencing, but simplifying those concepts to match Helen’s mental model proved more challenging than expected.

If we were to do this project again, we would likely avoid using RFID technology. We didn’t realize that incorporating more than one RFID reader would complicate the circuit significantly. Perhaps we could have explored alternatives—such as buttons or simpler sensors—to preserve the intuitive experience without introducing so many electrical complications. The RFID readers consumed the majority of our time, both in terms of coding and hardware troubleshooting. Our original plan included 8 RFID readers, which we reduced to 5 when we switched to the flower design, and ultimately used only 3 due to continued technical difficulties.

With more manpower, it might have been easier to divide the workload. As a two-person team, we spent a disproportionate amount of time just getting the circuit to work, which left little room for iteration on the CAD design. We only had a few chances to test how everything would fit together, and last-minute changes meant melting parts of the casing to make room for the Arduino and protoboards. The charging port also had to be manually adjusted to fit. These compromises, though not ideal, allowed us to complete a nearly functional prototype.

Despite these challenges, we’re proud of what we accomplished. Our project was 90% there—it was well thought out, intuitive, and tailored to Helen’s needs—but simply ran out of time to reach full functionality. This experience taught us valuable lessons about working with real users, iterating on physical prototypes, and managing scope when technical barriers arise.

/*

Assistive Communication Device

By, Shivani Kannan and Aziza Norkulova

Overview:

A device that assists our client in communicating with others about her daily activities.

This code uses three RFID RC522 sensors to read 8 different RFID tags, and plays corresponding audio files through a DF Player Mini.

Hardware:

- Arduino Uno R3

- 3x RFID-RC522 readers

- 3x Voltage Converters

- DF Player Mini with SD Card

- Speaker

- Battery

Pin Configuration:

RFID Sensor 1: SDA=5, RST=4

RFID Sensor 2: SDA=7, RST=6

RFID Sensor 3: SDA=9, RST=8

Shared RFID: SCK=13, MOSI=11, MISO=12 (default SPI pins)

DF Player: TX=2, RX=3

*/

#include <SPI.h>

#include <MFRC522.h>

#include <SoftwareSerial.h>

#include <DFRobotDFPlayerMini.h>

// ===== PIN DEFINITIONS =====

// RFID Reader pins

#define RFID1_SS_PIN  5    // SDA pin for Reader 1

#define RFID1_RST_PIN 4    // RST pin for Reader 1

#define RFID2_SS_PIN  7    // SDA pin for Reader 2

#define RFID2_RST_PIN 6    // RST pin for Reader 2

#define RFID3_SS_PIN  9    // SDA pin for Reader 3

#define RFID3_RST_PIN 8    // RST pin for Reader 3

// DF Player pins

#define DF_PLAYER_RX  2    // Connect to TX of DF Player

#define DF_PLAYER_TX  3    // Connect to RX of DF Player

// ===== TIMING CONSTANTS =====

const unsigned long READ_COOLDOWN_MS = 1000;  // Cooldown between card readings (ms)

const unsigned long READER_SWITCH_MS = 20;    // Time for each reader (ms)

const unsigned long READER_CHECK_MS = 5;      // Check interval (ms)

// ===== TAG DEFINITIONS =====

// Structure to hold tag information

struct TagInfo {

 const byte uid[4];    // RFID tag UID

 const uint8_t audio;  // Corresponding audio file number

 const char* message;  // Description message for serial output

};

// Define all 8 tags with their UIDs, audio files, and messages

const TagInfo TAGS[] = {

 {{0xAA, 0xD6, 0x46, 0xB2}, 1, "I went to the park"},

 {{0x3A, 0x2C, 0x46, 0xB2}, 2, "I visited my mom"},

 {{0x4A, 0xD1, 0x47, 0xB2}, 3, "I went to Ross park mall"},

 {{0x2A, 0x2A, 0x4A, 0xB2}, 4, "I walked my dog outside"},

 {{0xCA, 0x77, 0x49, 0xB2}, 5, "I watched the TV"},

 {{0x1A, 0x64, 0x49, 0xB2}, 6, "I had good food"},

 {{0x7A, 0x70, 0x48, 0xB2}, 7, "I wore a new outfit"},

 {{0x7A, 0x83, 0x48, 0xB2}, 8, "I painted and did arts and crafts"}

};

const int NUM_TAGS = sizeof(TAGS) / sizeof(TAGS[0]);  // Calculate number of tags

// ===== OBJECT INSTANCES =====

// RFID Readers

MFRC522 rfidReader1(RFID1_SS_PIN, RFID1_RST_PIN);

MFRC522 rfidReader2(RFID2_SS_PIN, RFID2_RST_PIN);

MFRC522 rfidReader3(RFID3_SS_PIN, RFID3_RST_PIN);

// DF Player

SoftwareSerial dfPlayerSerial(DF_PLAYER_RX, DF_PLAYER_TX);

DFRobotDFPlayerMini dfPlayer;

// ===== STATE VARIABLES =====

unsigned long lastReadTime = 0;          // Last time a card was successfully read

unsigned long lastReaderSwitchTime = 0;  // Last time we switched readers

unsigned long lastCheckTime = 0;         // Last time we checked the current reader

bool isAudioPlaying = false;             // Whether audio is currently playing

uint8_t currentReader = 1;               // Active reader (1, 2, or 3)

// ===== FUNCTION PROTOTYPES =====

void setupRfidReaders();

void setupDfPlayer();

void checkCurrentReader();

bool compareUID(byte* uid1, const byte* uid2, byte size);

void printUID(byte* uid, byte size);

void playAudioForTag(uint8_t readerNum, byte* tagUID, byte size);

void setup() {

 // Initialize serial communications

 Serial.begin(115200);

  // Initialize SPI bus (required for RFID readers)

 SPI.begin();

  // Setup RFID readers

 setupRfidReaders();

  // Setup DF Player

 setupDfPlayer();

  // Print program info

 Serial.println(F("Triple RFID Reader with DF Player setup complete"));

 Serial.println(F("System ready to detect 8 different RFID tags"));

  // Initialize timing variables

 lastReaderSwitchTime = millis();

 lastCheckTime = millis();

}

void loop() {

 unsigned long currentTime = millis();

  // Check for DF Player notifications

 if (dfPlayer.available()) {

   uint8_t type = dfPlayer.readType();

   int value = dfPlayer.read();

   // Handle playback finished event

   if (type == DFPlayerPlayFinished) {

     Serial.println(F("Audio playback finished"));

     isAudioPlaying = false;

   }

 }

  // Only check RFID readers if we're not currently playing audio

 if (!isAudioPlaying) {

   // Switch readers at the defined interval

   if (currentTime - lastReaderSwitchTime >= READER_SWITCH_MS) {

     // Disable all readers

     digitalWrite(RFID1_SS_PIN, HIGH);

     digitalWrite(RFID2_SS_PIN, HIGH);

     digitalWrite(RFID3_SS_PIN, HIGH);

     // Move to next reader

     currentReader = (currentReader % 3) + 1;

     // Enable the current reader

     switch (currentReader) {

       case 1: digitalWrite(RFID1_SS_PIN, LOW); break;

       case 2: digitalWrite(RFID2_SS_PIN, LOW); break;

       case 3: digitalWrite(RFID3_SS_PIN, LOW); break;

     }

     lastReaderSwitchTime = currentTime;

   }

   // Check the current reader at defined interval

   if (currentTime - lastCheckTime >= READER_CHECK_MS) {

     checkCurrentReader();

     lastCheckTime = currentTime;

   }

 }

}

// Sets up all three RFID readers and tests them

void setupRfidReaders() {

 // Configure SS pins as outputs and disable all readers initially

 pinMode(RFID1_SS_PIN, OUTPUT);

 pinMode(RFID2_SS_PIN, OUTPUT);

 pinMode(RFID3_SS_PIN, OUTPUT);

 digitalWrite(RFID1_SS_PIN, HIGH);

 digitalWrite(RFID2_SS_PIN, HIGH);

 digitalWrite(RFID3_SS_PIN, HIGH);

  // Initialize and test each reader

 Serial.println(F("Testing RFID readers..."));

  // Initialize and test Reader 1

 rfidReader1.PCD_Init();

 delay(50);

 digitalWrite(RFID1_SS_PIN, LOW);  // Enable Reader 1

 byte version1 = rfidReader1.PCD_ReadRegister(rfidReader1.VersionReg);

 digitalWrite(RFID1_SS_PIN, HIGH); // Disable Reader 1

 Serial.print(F("Reader 1 firmware version: 0x"));

 Serial.println(version1, HEX);

  // Initialize and test Reader 2

 rfidReader2.PCD_Init();

 delay(50);

 digitalWrite(RFID2_SS_PIN, LOW);  // Enable Reader 2

 byte version2 = rfidReader2.PCD_ReadRegister(rfidReader2.VersionReg);

 digitalWrite(RFID2_SS_PIN, HIGH); // Disable Reader 2

 Serial.print(F("Reader 2 firmware version: 0x"));

 Serial.println(version2, HEX);

  // Initialize and test Reader 3

 rfidReader3.PCD_Init();

 delay(50);

 digitalWrite(RFID3_SS_PIN, LOW);  // Enable Reader 3

 byte version3 = rfidReader3.PCD_ReadRegister(rfidReader3.VersionReg);

 digitalWrite(RFID3_SS_PIN, HIGH); // Disable Reader 3

 Serial.print(F("Reader 3 firmware version: 0x"));

 Serial.println(version3, HEX);

}

//Sets up the DF Player Mini

void setupDfPlayer() {

 // Initialize DF Player communication

 dfPlayerSerial.begin(9600);

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

 if (!dfPlayer.begin(dfPlayerSerial)) {

   Serial.println(F("Unable to begin DF Player!"));

   Serial.println(F("1. Please check the connections"));

   Serial.println(F("2. Make sure SD card is inserted and has MP3 files"));

   while (true) {

     delay(1000);  // Do nothing if DF Player initialization fails

   }

 }

  Serial.println(F("DFPlayer Mini online."));

  // Configure DF Player

 dfPlayer.volume(25);  // Set volume (0-30)

 dfPlayer.EQ(DFPLAYER_EQ_NORMAL);  // Set EQ to normal

 dfPlayer.outputDevice(DFPLAYER_DEVICE_SD);  // Use SD card

}

//Checks the current active RFID reader for tags

void checkCurrentReader() {

 // Only process if it's been more than READ_COOLDOWN_MS since the last read

 if (millis() - lastReadTime <= READ_COOLDOWN_MS) {

   return;

 }

  MFRC522 *rfid;

  // Select the correct reader instance

 switch (currentReader) {

   case 1: rfid = &rfidReader1; break;

   case 2: rfid = &rfidReader2; break;

   case 3: rfid = &rfidReader3; break;

   default: return; // Invalid reader

 }

  // Look for new cards

 if (!rfid->PICC_IsNewCardPresent()) {

   return;

 }

  // Select one of the cards

 if (!rfid->PICC_ReadCardSerial()) {

   return;

 }

  // Card successfully read

 lastReadTime = millis();  // Update the last read time

  Serial.print(F("Reader "));

 Serial.print(currentReader);

 Serial.print(F(" detected card with UID: "));

 printUID(rfid->uid.uidByte, rfid->uid.size);

 Serial.println();

  // Process the detected tag

 playAudioForTag(currentReader, rfid->uid.uidByte, rfid->uid.size);

  // Halt PICC and stop encryption

 rfid->PICC_HaltA();

 rfid->PCD_StopCrypto1();

}

//Plays the appropriate audio file for a detected tag

void playAudioForTag(uint8_t readerNum, byte* tagUID, byte size) {

 // Check each tag in our list to find a match

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

   if (compareUID(tagUID, TAGS[i].uid, size)) {

     Serial.print(F("Reader "));

     Serial.print(readerNum);

     Serial.print(F(": Tag "));

     Serial.print(i + 1);

     Serial.print(F(" detected! Playing '"));

     Serial.print(TAGS[i].message);

     Serial.println(F("'"));

     // Play the corresponding audio file

     dfPlayer.playMp3Folder(TAGS[i].audio);

     isAudioPlaying = true;

     return;

   }

 }

  // If we get here, no match was found

 Serial.print(F("Reader "));

 Serial.print(readerNum);

 Serial.println(F(": Unknown tag - no action"));

}

//Compares RFID UIDs to check if they match

bool compareUID(byte* uid1, const byte* uid2, byte size) {

 for (byte i = 0; i < size; i++) {

   if (uid1[i] != uid2[i]) {

     return false;

   }

 }

 return true;

}

//Prints an RFID UID in hexadecimal format (for debugging)

void printUID(byte* uid, byte size) {

 for (byte i = 0; i < size; i++) {

   Serial.print(uid[i] < 0x10 ? " 0" : " ");

   Serial.print(uid[i], HEX);

 }

}

Located in the documents for this project, you will find the STL files that were used to 3D print our design. There are 5 different files, including the flower case, the two inside frame structures, the top lid, and the cardholder.