Sleep Time Reminder

Overview

At two preset time, the alarm robot wanders around randomly and repeats a melody  until it is placed next to the RFID  cards in bathroom or on bed.

This is the behavior of the robot when it is reminding the user to take a shower or go to bed. A USB power bank is used to provide power as I found out 4 AAA batteries do not provide enough current to support two motors and two speakers playing melody at the same time. However, the batteries do provide enough current when the speakers only vibrate constantly.

This shows a closer look at the working device. When the appropriate RFID card is presented, the device stops moving and playing melody.

The top view of the device.

The elevation view of the device. The RFID reader sticks out so that it can get closer to the RFID card when it is reading.

The front view of the device. The parts are arranged in a way to mimic the “face” of a robot, with the speakers being the “eyes” and the batteries case being the “nose”.

Process Image and Review

Motivation and Original Design

I have the problem of procrastinating when it comes to going to sleep. When I am busy during the week, I tend to stay up late working. When I am not as busy, I still go to bed late by watching all kinds of contends. Moreover, I tend to take shower right before I go to bed, which makes the bed time even latter.  I tried to set alarm on my phone to remind myself the time for shower and sleep, but it does not work well as I usually just stop the alarm.  Therefore, I wanted to build an assistive device that really grabs my attention and bring me to physical places at appropriate time.

The original design from the first ideating.

The original design is a small square car that carries two speakers, an electromagnetic sensor, a servo motor, and two continuous servo motors. Magnets will be placed in bathroom and on bed, and the electromagnetic sensor is there to detect the change of EM field, which indicates the physical locations.

The original design of the supporting wheel.

The supporting wheel is added to maintain the balance of the body of the device as well as to help the device turn left or right driven by a servo motor. The supporting wheel is free to rotate like the wheel of a chair.

Prototyping

During prototyping, I changed the continuous servo motors to DC motors because they supply much more power. I also realized that it is very difficult to attach a wheel to the servo motor, and it is much easier to use a  ball roller transfer as a supporting wheel. I was lucky enough to find a ball roller transfer that has the height similar to the radius of a toy tire, which the base of the device can sit on.

Ball roller transfer.

Then I went on to build the circuit on a breadboard. The wiring part is not bad because there are resources on the course website or online that are helpful.

The circuit of the engineering prototype.

However, I had some trouble writing codes for parts that I was not familiar with. For example, I had to learn how to use the library for the RFID reader MFRC522  to write functions that check whether the unique “ID” of the RFID card is the one of the card in the bathroom or on the bed. However, I had the most trouble figuring out how to make the motors and speakers perform two different sequences of actions spontaneously. Then I realized I can solve it by using the blink-without-block tactic. But instead of modifying boolean variables, I have to make a “time map” and assign tasks to the parts in each time interval. However, this is not the best approach when the sequence of actions and hence the time map become long. I will introduce another approach in latter section.

In the function be_annoying, the timer diff_motor and the motor_timemap checks determine which motion to perform.

Redesigning and Building

Because the circuit of the prototype is very messy and clumpy, I decided to solder the wires and components onto a circuit board so that they can fit onto a small robot car. It turned out to be a very time-consuming process but it makes the circuit clear, strong, and secure.

The wires and parts are all soldered onto the circuit board. To make more room from the board, I have cut the legs of the transistor on top.

I then redesign the body of the robot to fit the dimension of the circuit board and the parts.  The front part of the vehicle is not covered up so that the speakers and the RFID reader to extend out for better performance. The circuit is covered by the “shields” that insert into the groves on the side boards.  The idea of the “shields” are inspired by the design of the back of some Lamborghini.

Refined design of the body of the robot.

The shield above the back window.                                                                  https://www.motor1.com/news/78593/after-50-years-the-lovely-lamborghini-miura-is-back/

The sketch of the components. Notice that the grooves on the curved side of the right components are for the shields.

Unfortunately, the “shields” could not be used because the height of the Arduino pro mini is taller than expected due to the soldering on the circuit board. In other words, the soldering tips at the back of the circuit board raise the components up, which get into the way of the shields. Unfortunately, because I was not able to use the laser cutter again before the final critique, I had to abandon the idea and decided to make a pair of wings instead. As a result, the device has a raw look without enclosure.

Finally, the device was built by gluing the parts together and mounting the ball roller transfer onto the base with screws and nuts.

Playing a Song

Because the device was too annoying when the speakers only vibrate constantly to make loud noises, I decided to play a song instead. With two speakers, I can play two melodies at the same time.

The lists of notes and the lists of beats. Each note corresponds to a specific frequency for the tone() function.

With a list of notes and a list of beats, the speaker can go through the melody using the blink-without-block technique. However, because there are substantial notes and beats,  I could not use “if” anymore as it gets too tedious. As a result, a loop was written to generate the time-map by looping through the list of beat and add the previous beats up.

The loop that generate the time map for speaker 1.

Finally, a global variable “counter” determines which note to play and what beat it has.

The code that tells the speaker what note to play and how long to play it.

Discussion

Feedback

One of the feedback suggested to build “a cover” to hide the device’s components while another suggested putting “a shell” and bunch of screws” around the battery .  I really like these feedback because I will have a less chance to hack the system when I am not aware of the circuit and the batteries are difficult to remove. Instead of removing the batteries, now the only option to make the machine stop is to to the designated physical place to get the RFID card. As a result, the device can better serve the original purpose of making me take shower or go to sleep.

There are also feedback about “adding a flash light” and adding an interface for “adjustable time for the alarm”. With a flashlight, the robot car can grab more attention, especially at night. And with an interface to adjust the time, the device can be more user-friendly and convenient to use. Therefore, I think those are great feedback and potential improvement to the device.

Self Critique  and What I have learnt

I am pleased about the function that the device can perform. All the parts, including the RFID reader and the motors, work better than I expected. As a result, the device can perfectly perform its intended job. However, I am not satisfied about the design of the final product. As mentioned before, the robot looks rather raw without cover and the wires of the parts still look kind of messy.

One of the biggest lesson I learnt is that I have to make a clear schedule before starting the project. In this project, I only have a rough schedule my mind and as I spent more and more time on the technical issues, I had to push back the task of designing until the very end. And it is a very bad idea to push anything to the very end. Instead, I should have a schedule that assigns equal time to technical and designing tasks. Moreover, if there is a technical problem that is very time consuming, I should stick to the schedule and move on. If I have more time, I can come back to the problem and finish the feature. I also learnt that it is challenging to write code for arduino if I am not familiar with the language of C. But it is also not too bad because there are many references that I can rely on.

Next Step

If I was to build another iteration, I would design a cover for the robot that the speakers and  RFID reader are fixed at the surface. I would use a USB power bank instead of batteries to power the robot so that enough current would be supplied. I would use the design of the “shield” to cover up the components. I would add a LCD and a rotating switch to make an user interface for adjusting time, changing the color of the flashlight, and changing songs.

Technical information

Schematic

Code

/*Sleep Time Reminder
 * Zerui Huo
 * The code makes two motors spin and two speaker vibrate at a preset time until the RFID reader
   detects the desired RFID card.

 *Pin mapping:
  
     pin   | mode   | description
     ------|--------|------------
     2      OUTPUT    The pin that sends pwm signal to the motor driver and controls tire 1
     3      OUTPUT    The pin that sends pwm signal to the motor driver and controls tire 1
     4      OUTPUT    The pin that sends pwm signal to the motor driver and controls tire 2
     5      OUTPUT    The pin that sends pwm signal to the motor driver and controls tire 2
     6      OUTPUT    The pin that is connect to transistor to control speaker 1
     7      OUTPUT    The pin that is connect to transistor to control speaker 2
     9                SDA pin for the RFID reader
     10               RST pin for the RFID reader
     11               MOSI pin for the RFID reader
     12               MISO pin for the RFID reader
     13               SCK pin for the RFID reader
     A4               SDA pin for the real time clock
     A5               SCL pin for the real time clock
     VCC              The pin for power to go into the Arduino pro mini
     


  *The code in the functions set_motor_pwm and set_two_motors_pwm are inspired by the website https://courses.ideate.cmu.edu/16-223/f2016/text/ex/Arduino/DRV8833-motor-driver/DRV8833-motor-driver.html.
   The function getID is from the website https://lastminuteengineers.com/how-rfid-works-rc522-arduino-tutorial/.
   When writing the code to set the time in the real time clock, I refer to https://create.arduino.cc/projecthub/MisterBotBreak/how-to-use-a-real-time-clock-module-ds3231-bc90fe.
   The music score of the song, Il Vento D'Oro (Golden Wind), is from https://musescore.com/winthos/scores/5366398 by Winthos.
   The the pitch values are from https://www.arduino.cc/en/Tutorial/ToneMelody?from=Tutorial.Tone and are written by Brett Hagma.
*/

#include "pitches.h"
#include "SPI.h"
#include "MFRC522.h"
#include <Wire.h>
#include <ds3231.h>

//Naming all the pins to their function
const int motorA1 = 2;
const int motorA2 = 3;
const int motorB1 = 4;
const int motorB2 = 5;
const int speaker1 = 6;
const int speaker2 = 7;

//Define the two pins for the RFID
#define pinSDA 10
#define pinRST 9

//Setting the intervals for the all the timers
unsigned long Motortimer = 0;
unsigned long Speakertimer1 = 0;
unsigned long Speakertimer2 = 0;
unsigned long Clocktimer = 0;
const int Clockwait = 5000;

//Setting up the strings to check for the RFID reader
byte readCard[4];
String Bathroom_ID = "A06EC9B";  //Unique ID for the RFID card that will be placed in bathroom
String Bed_ID = "31BD82FC";  //Unique ID for the RFID card that will be placed onto the bed
String tagID = "";

//"Link" the pins to the RFID's SDA and RST
MFRC522 mfrc522(pinSDA, pinRST);

//For the realtime clock
struct ts t;

//Defining the constants for the speakers to play melody
//notemap for speaker 1 and speaker 2
int note1[] = {NOTE_B3, NOTE_B3, NOTE_B3, NOTE_A3, 0, NOTE_B3, 0, NOTE_D4, 0, NOTE_B3, 0, NOTE_FS3, NOTE_A3,    
               NOTE_B3, NOTE_B3, NOTE_B3, NOTE_A3, 0, NOTE_B3, 0, NOTE_F4, 0, NOTE_E4, 0, NOTE_D4, NOTE_A3,
               NOTE_B3, NOTE_B3, NOTE_B3, NOTE_A3, 0, NOTE_B3, 0, NOTE_D4, 0, NOTE_B3, 0, NOTE_FS3, NOTE_A3,    
               NOTE_B3, NOTE_B3, NOTE_B3, NOTE_A3, NOTE_B3, NOTE_D4, 0, NOTE_F4, 0, NOTE_E4, 0, NOTE_D4, NOTE_A3,
               NOTE_B3, NOTE_B3, NOTE_B3, NOTE_A3, 0, NOTE_B3, 0, NOTE_D4, 0, NOTE_B3, 0, NOTE_FS3, NOTE_A3,    
               NOTE_B3, NOTE_B3, NOTE_B3, NOTE_A3, 0, NOTE_B3, 0, NOTE_F4, 0, NOTE_E4, 0, NOTE_D4, NOTE_A3,
               NOTE_B3, NOTE_B3, NOTE_B3, NOTE_A3, 0, NOTE_B3, 0, NOTE_D4, 0, NOTE_B3, 0, NOTE_FS3, NOTE_A3,    
               NOTE_B3, NOTE_B3, NOTE_B3, 0, NOTE_A3, NOTE_B3,
              };

int note2[] = {NOTE_B1,                                                                                         
               NOTE_B1,
               NOTE_B1,                                                                                         
               NOTE_B1, NOTE_B1,
               NOTE_B2, NOTE_B2, NOTE_B2, NOTE_A2, 0, NOTE_B2, 0, NOTE_D3, 0, NOTE_B2, 0, NOTE_FS2, NOTE_A2,    
               NOTE_B2, NOTE_B2, NOTE_B2, NOTE_A2, 0, NOTE_B2, 0, NOTE_F3, 0, NOTE_E3, 0, NOTE_D3, NOTE_A2,
               NOTE_B2, NOTE_B2, NOTE_B2, NOTE_A2, 0, NOTE_B2, 0, NOTE_D3, 0, NOTE_B2, 0, NOTE_FS2, NOTE_A2,    
               NOTE_B2, NOTE_B2, NOTE_B2, 0, NOTE_A2, NOTE_B2,
              };


//beatmap for each notes for speaker 1 and speaker 2. 8 means eighth note, etc.
int beat1[] =  {8, 8, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 8,    8, 8, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 8,
                8, 8, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 8,    8, 8, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 8,
                8, 8, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 8,    8, 8, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 8,
                8, 8, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 8,    8, 8, 16, 16, 16, 8,
               };
               
int beat2[] =  {1,                                                   1,
                1,                                                   2, 2,
                8, 8, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 8,     8, 8, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 8,
                8, 8, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 8,     8, 8, 16, 16, 16, 8,
               };



//Determining the length of the list of beat and creat empty timemaps for the speakers
const int length_of_beat1 = 155;
const int length_of_beat2 = 1;

int speaker_timemap1[length_of_beat1];
int speaker_timemap2[length_of_beat2];

//Note counter indicate which note the speakers are on. They are set to 0 because array start from 0 and in such way they are more convenient to use latter.
int counter1 = 0;
int counter2 = 0;


//The following are written supplemental functions

//RFID:
//Funtion to access the NUID and put the first 4 bytes (8 digits) into the string "tagID"
boolean getID() {
  //Verify if any card is presented
  if ( ! mfrc522.PICC_IsNewCardPresent()) {
    return false;
  }

  // Verify if the NUID has been readed
  if ( ! mfrc522.PICC_ReadCardSerial()) {
    return false;
  }
  tagID = "";
  //A loop that put the first 4 bytes of the unique ID of the card into the variable tagID
  for ( uint8_t i = 0; i < 4; i++) {
    tagID = tagID + (String(mfrc522.uid.uidByte[i], HEX));
  }
  tagID.toUpperCase();
  mfrc522.PICC_HaltA(); // Tells the RFID readert to stop reading.
  return true;
}

//Motors:
//Function to give direction and speed to one of the motor
void set_motor_pwm(int pwm, int input_1, int input_2) {
  if (pwm < 0) {
    digitalWrite(input_1, -pwm);
    analogWrite(input_2, LOW);
  }
  else {
    digitalWrite(input_1, LOW);
    analogWrite(input_2, pwm);
  }
}

//Function that gives direction and speed to both motor using the previous function
void set_two_motors_pwm(int pwmA, int pwmB) {
  set_motor_pwm(pwmA, motorA1, motorA2);
  set_motor_pwm(pwmB, motorB1, motorB2);
}

//Speakers:

//Funtion that make the speaker play the note according to its notemap and timemap
void play_note(int speaker, int time) {
  //Determine which speaker and therefore which counter to modify
  if (speaker == 6) {
    //The start is a speacial case
    if (counter1 == 0) {
      if (time < speaker_timemap1[counter1]) {
        tone(speaker, note1[counter1]);
      }
      if (time > speaker_timemap1[counter1]) {
        counter1 = counter1 + 1;
      }
    }

    //if time exceeds the last element of the timemap, reset the counter and play the melody from start
    if (time > speaker_timemap1[length_of_beat1 - 1]) {
      counter1 = 0;
      Speakertimer1 = millis();
    }

    //Again, (2000 / beat1[thisbeat - 1]) * 0.3 is the time gap for distinguishing between notes
    if (time > speaker_timemap1[counter1 - 1] + (2000 / beat1[counter1 - 1]) * 0.3 && time < speaker_timemap1[counter1]) {
      tone(speaker, note1[counter1]);
    }

    //When the speaker finish playing the current note
    if (time >  speaker_timemap1[counter1]) {
      counter1 = counter1 + 1;
    }

  }

  if (speaker == 7) {
    //The start is a speacial case
    if (counter2 == 0) {
      if (time < speaker_timemap2[counter2]) {
        tone(speaker, note2[counter2]);
        Serial.println("Speaker 2 starts");
      }
      if (time > speaker_timemap2[counter2]) {
        counter2 = counter2 + 1;
        Serial.println("Speaker 2 counter 2");
      }
    }

    //if time exceeds the last element of the timemap, reset the counter and play the melody from start
    if (time > speaker_timemap2[length_of_beat2 - 1]) {
      counter2 = 0;
      Speakertimer2 = millis();
      Serial.println("Speaker 2 end");
    }

    //Again, (2000 / beat1[thisbeat - 1]) * 0.3 is the time gap for distinguishing between notes
    if (time > speaker_timemap2[counter2 - 1] + (2000 / beat2[counter2 - 1]) * 0.3 && time < speaker_timemap2[counter2]) {
      tone(speaker, note2[counter2]);
       Serial.println("Speaker 2 next note");
    }

    //When the speaker finish playing the current note
    if (time >  speaker_timemap2[counter2]) {
      counter2 = counter2 + 1;
    }

  }
}

//Function that controls what happen when it's time to shower/sleep
void be_annoying() {


  //how long has passed since the start of the cycle
  int diff_motor = millis() - Motortimer;
  int diff_speaker1 = millis() - Speakertimer1;
  int diff_speaker2 = millis() - Speakertimer2;

  //the timemap of actions for motors
  int motor_timemap[] = {3000, 5000, 7000, 10000};


  //motors' sequence of motions
  //Motion1
  if ( diff_motor <=  motor_timemap[0] ) {
    set_two_motors_pwm(random(-225,225),random(-225,225));
  }

  //Motion2
  if ( diff_motor >= motor_timemap[0] && diff_motor <=  motor_timemap[1] ) {
    set_two_motors_pwm(100, 100);
  }

  //Motion3
  if ( diff_motor >= motor_timemap[1]  && diff_motor <= motor_timemap[2] ) {
    set_two_motors_pwm(-200, 200);
  }

   //Motion4
  if ( diff_motor >= motor_timemap[2]  && diff_motor <= motor_timemap[3] ) {
    set_two_motors_pwm(random(-225,225), random(-225,225));
  }


  if ( diff_motor >= motor_timemap[3]) {
    //Serial.println("cycle ends");
    Motortimer = millis();
  }


  //Speaker1's sequence of actions
  play_note(speaker1, diff_speaker1);
  play_note(speaker2, diff_speaker2);
}

void setup() {
  //Setting up the motors' pins
  pinMode(motorA1, OUTPUT);
  pinMode(motorA2, OUTPUT);
  pinMode(motorB1, OUTPUT);
  pinMode(motorB2, OUTPUT);

  //Starting in the coasting mode
  digitalWrite(motorA1, LOW);
  digitalWrite(motorA2, LOW);
  digitalWrite(motorB1, LOW);
  digitalWrite(motorB2, LOW);

  //Setting up the pins for the transistor for the speakers
  pinMode(speaker1, OUTPUT);
  pinMode(speaker2, OUTPUT);

  //Initializing the RFDI
  SPI.begin();
  mfrc522.PCD_Init();

  //Initializing the serial monitor
  Serial.begin(9600);

  //Setting up for the real-time clock
  Wire.begin();
  DS3231_init(DS3231_INTCN);

  //Set up of the t for the real-time clock
  t.hour = 24;
  t.min = 30;
  t.sec = 0;
  t.mday = 30;
  t.mon = 2;
  t.year = 2020;

  DS3231_set(t);


  //loop that generate the timemap for speaker1 that adds up the time of previous beats
  for (int thisbeat = 0; thisbeat < length_of_beat1; thisbeat++) {
    if (thisbeat == 0) {
      speaker_timemap1[0] = 2000 / beat1[0];
    }
    else {
      //This adds up the time for the previous beats. For example, the second note is played from the time of 2000/8 + (2000/8)*0.3 to 2000/8 + (2000/8)*0.3+2000/8. There is a 0.3-note time gap to distinguish between notes.
      speaker_timemap1[thisbeat] = speaker_timemap1[thisbeat - 1] + (2000 / beat1[thisbeat - 1]) * 0.3 + 2000 / beat1[thisbeat];
    }
  }

  //loop that generate the timemap for speaker2 that adds up the time of previous beats
  for (int thisbeat = 0; thisbeat < length_of_beat2; thisbeat++) {
    if (thisbeat == 0) {
      speaker_timemap2[0] = 2000 / beat2[0];
    }
    else {
      //This adds up the time for the previous beats. For example, the second note is played from the time of 2000/8 + (2000/8)*0.3 to 2000/8 + (2000/8)*0.3+2000/8. There is a 0.3-note time gap to distinguish between notes.
      speaker_timemap2[thisbeat] = speaker_timemap2[thisbeat - 1] + (2000 / beat2[thisbeat - 1]) * 0.3 + 2000 / beat2[thisbeat];
    }
  }
}


void loop() {
  //The time to take shower
  if (t.hour == 23 && t.min == 0 && t.sec == 0) {
    Motortimer = millis();
    Speakertimer1 = millis();
    Speakertimer2 = millis();
    while (! getID() && tagID != Bathroom_ID) {
      be_annoying();
    }
    noTone(speaker1);
    noTone(speaker2);
    set_two_motors_pwm(0, 0);
  }


  //The time to sleep
  if (t.hour == 24 && t.min == 30 && t.sec == 0) {
    Motortimer = millis();
    Speakertimer1 = millis();
    Speakertimer2 = millis();
    while (! getID() && tagID != Bed_ID) {
      be_annoying();
    }

    set_two_motors_pwm(0, 0);
    noTone(speaker1);
    noTone(speaker2);
  }



  //Printing the time for debugging purpose
  if ( (millis() - Clocktimer) >= Clockwait ) {

    //displaying the time on the serial monitor
    DS3231_get(&t);
    Serial.print("Date : ");
    Serial.print(t.mon);
    Serial.print("/");
    Serial.print(t.mday);
    Serial.print("/");
    Serial.print(t.year);
    Serial.print("\t Hour : ");
    Serial.print(t.hour);
    Serial.print(":");
    Serial.print(t.min);
    Serial.print(".");
    Serial.println(t.sec);

    Clocktimer = millis();
  }

}