Task Manager

/* 
 *  Working on Mega2560 R3.
 *  Mega AVR (Wire library) - v1.8.1
 *  Adafruit_SSD1306 by Adafruit - v1.2.9
 *  Mega AVR (EEPROM) - v1.8.1
 *  Encoder by Paul Stoffregen - v1.4.1
 *  DS1307RTC by Michael Margolis - v1.4.0
 *  MFRC522 by GithubCommunity - v1.4.4
 *  
 *  PINOUT
   *  OLED
   *    GND - GND
   *    VCC - 5V
   *    SCL - SCL (21)
   *    SDA - SDA (20)
   *  RTC
   *    GND - GND
   *    VCC - 5V
   *    SCL - SCL (21)
   *    SDA - SDA (20)
   *  ENCODER
   *    GND - GND
   *     +  - 5V
   *    CLK - 2
   *    DT  - 3
   *  RFID
   *    3.3V - 3.3V
   *    RST  - 9
   *    GND  - GND (different from the others)
   *    MISO - 50
   *    MOSI - 51
   *    SCK  - 52
   *    SDA  - 53
 *    
*/
//**************************************** INCLUDE ****************************************
#include <Wire.h>                                      // WIRE library - used for chosing pins for the encoder.
#include <Adafruit_SSD1306.h>                          // OLED library
#include <EEPROM.h>                                    // Current state of tasks is persisted by saving/restoring to EEPROM memory
#include <Encoder.h>                                   // Encoder library
#include <DS1307RTC.h>                                 // Used to retrieve time information from Real-Time Clock (RTC) module https://github.com/PaulStoffregen/DS1307RTC
#include <MFRC522.h>                                   // RFID reader library

//**************************************** PIN SET ****************************************
Adafruit_SSD1306 display (128, 64, & Wire, -1);        // Resolution 128x64, -1 = no reset pin.(SDA - 20(SDA) SCL - 21(SCL))
Encoder myEnc(2, 3);                                   // Comments on Encoder_Mega_Test. Pins CLK - 2, DT - 3.
MFRC522 mfrc522(53, 9);                                // Create an instance of the MFRC522 class. The parameters specified in the constructor are (SS pin, Reset pin)

//**************************************** INTEGERS, BYTE, LONG ****************************************
byte button;                                           // for use of the button
byte arrowpos = 0;                                     // Arrow position - used to save the arrow position to be used in different screens
long oldPosition  = -999;                              // Initialize the encoder position.
int menuIndex = 0;                                     // 0 means it will start on main menu. It will be used to track which submenu you want to go in.
int listItems = 2;                                     // Number of index on *listsubMenu - change to fit the size of your array
const char ver[6]= "V0.1";                             // Version number - To help you keep track of your project
int userID2;
int selectedTask = 0;
byte userTemp;

//**************************************** MENULISTSCHARS ****************************************
char *score[] = {"1 Place:", "2 Place:", "3 Place:", "4 Place:", "5 Place:"};
char *listMenu[] = {"Validate Tasks", "Scoredboard"}; // Names of your menus used on main menu.

//**************************************** STRUCTURES ****************************************
struct task {                                          // This data structure encapsulates all the properties associated with an individual task
  char taskName[16];                                   // The short, "friendly" name for this task as will appear on the display
  int repeatEachXDays;                                 // Regularity, in days, with which this task is repeated. 1=Daily, 7=Weekly etc.
  unsigned long lastCompletedTime;                     // Timestamp at which this task was last completed
  int lastCompletedBy;                                 // ID of the person who last completed this task
};

struct user {                                          // This data structure represents a user
  int userID;                                          // Unique ID - matches that stored in the "lastCompletedBy" field of a task
  char userName[8];                                    // Display name of this user
  byte rfidUID[4];                                     // Unique identifier of the RFID tag this user uses 
  int score;
};

int struct_cmp_by_score(const void *a, const void *b) { 
    struct user *ia = (struct user *)a;
    struct user *ib = (struct user *)b;
    return (int)(ia->score - ib->score);               // float comparison: returns negative if b > a and positive if a > b. 
}; 

//**************************************** CONSTANTS ****************************************
const byte eepromSignature = 2;                       // This byte defines whether the data stored on EEPROM is valid. Valid values range from 0-254 and reflect the version of the dataset - it should be changed every time the structure of the underlying data is updated (tasks added/removed etc.)
const int numTasks = 12;                              // The total number of different tasks available to perform - change to match the amount of tasks
const int numUsers = 5;                               // The total number of users known to the system

//**************************************** GLOBALS ****************************************
user userList[numUsers] = {                           // The dictionary of users
  { 0, "      ", {0x12, 0x34, 0x56, 0x78}, 0},        // Dummy user! Don't change
  { 1, "User1 ", {0xC2, 0x52, 0xD3, 0x04}, 0},        // Change to your card!
  { 2, "User2 ", {0x40, 0x7B, 0x79, 0x19}, 0},        // Change to your card!
  { 3, "User3 ", {0x04, 0x03, 0x96, 0x92}, 0},        // Change to your card!
  { 4, "User4 ", {0x3D, 0x3F, 0x77, 0x62}, 0},        // Change to your card!     
};

task taskList[numTasks] = {                           // The taskList is an array of all the task information. 
  { "Task1          ", 7, "0", 0 },                   // Tasks are initialised with a lastCompletedTime=0 and lastCompletedBy=-1, 
  { "Task2          ", 3, "0", 0 },                   // but these values will be overwritted with data from EEPROM if valid stored data exists. 
  { "Task3          ", 3, "0", 0 },                   // If this list is changed, be sure to also update the EEPROM signature value above 
  { "Task4          ", 3, "0", 0 },                   // otherwise the program will attempt to restore mismatched stored data from EEPROM.   
  { "Task5          ", 1, "0", 0 }, 
  { "Task6          ", 1, "0", 0 },
  { "Task7          ", 3, "0", 0 }, 
  { "Task8          ", 7, "0", 0 },
  { "Task9          ", 1, "0", 0 },
  { "Task10         ", 30, "0",0 },
  { "Task11         ", 7, "0", 0 },
  { "Task12         ", 7, "0", 0 },  
};

//**************************************** NORMALIZE ****************************************
long normalize(long value, long radix) {               // to wrap your encoder count around your amount of submenus.
  long rval = value % radix;
  while(rval < 0) { 
    rval += abs(radix); 
  } 
  return rval;
  
};

//**************************************** COMPLETETASK ****************************************
void completeTask(int taskId, unsigned long completedTime, int completedBy) { // Completes the provided task id 
  taskList[taskId].lastCompletedTime = completedTime;
  taskList[taskId].lastCompletedBy = completedBy;
}

//**************************************** SETUP ****************************************
void setup() {
  Serial.begin(9600);                                  // Starting serial for debbuging purposes.
  
  Serial.print(F("Loading OLED..."));                  // Initializing OLED
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  display.display();
  display.clearDisplay();
  Serial.println(F("done."));

  Serial.print(F("Loading saved data..."));            // Load the stored data
  restoreFromEEPROM();
  Serial.println(F("done."));  
  delay(100);

  tmElements_t tm;                                     // Initializing RTC
  if(RTC.read(tm)) {
    Serial.print(F("Initializng RTC... "));
    char timeString[16];
    memset(timeString, 0, sizeof timeString);
    snprintf(timeString, 16, "%i/%i/%i %i:%02i", tm.Day, tm.Month, 1970+tm.Year-2000, tm.Hour, tm.Minute);
    Serial.println(timeString);
  }
  else {
    if(RTC.chipPresent()) {
      Serial.println("FAILED. The DS1307 is not initialised. Please run the SetTime sketch to set correct time.");
    } 
    else {
      Serial.println("FAILED. Cannot connect to DS1307. Please check your wiring.");
    }
  }

  Serial.print(F("Initialising SPI Communication...")); // Initiate RFID
  SPI.begin();                                          // Initiate SPI bus. Wire library.
  Serial.println(F("done."));
    
  Serial.print(F("Initialising RFID reader..."));       // Initiate RFID
  mfrc522.PCD_Init();
  Serial.println(F("done."));
  
}

//**************************************** LOOP ****************************************
void loop() {

  switch (menuIndex)  {
    case 0: 
      mainMenu();                                      // Main menu
      selectEncoder();
      selectButton();
      break;
    case 1: 
      validateTaskMenu();                              // Screen to validate tasks with RFID badges
      selectEncoder();
      selectButton();
      break;
    case 2:
      resultsTask();                                   // Screen to show users scores
      selectEncoder();
      selectButton();
      break;
  }
  display.clearDisplay();
  delay(150);
}

//**************************************** MAIN MENU ****************************************
void mainMenu() {                                      // Case 0: mainMenu

  listItems =2;
  
  display.setTextSize(2);                              // Set text size of Main Menu to 2
  display.setTextColor(WHITE);                         // To make the text show up on the screen.

  display.setCursor(30, 0);                             // Screen title position
  display.print("Menu");                               // Screen title
  display.setTextSize(1);                              // Set text size of Version and subMenus to 1
  display.setCursor(100, 56);                          // Program version position
  display.println(ver);                                // Program version
//-----------------------------------------------------// Above line static info. Below line variable info.

  for (int i = 1; i <= 2; i++){                        // Loop to show all Menus
    display.setCursor(10, (i*10)+6);
    display.println(listMenu[i-1]);                    // -1 to reduce the arrowpos() number to 4
  }
  if (arrowpos == 2) {                                 // Loop to position arrow in front of Menus
    display.setCursor(2, 16);                                   
    display.println(">");
  } else {
  display.setCursor(2, (arrowpos * 10) + 16);          // Arrow will move up/down on screen.
  display.println(">");
  }
  display.display();
  
}

//**************************************** VALIDATETASKMENU ****************************************
void validateTaskMenu() {                              // Case 1: validateTasks
  listItems = 12;
  arrowpos=2;

  display.clearDisplay();

  display.setTextSize(2);    
  display.setCursor(22, 0);
  display.print("Chores");
//-----------------------------------------------------// Above line static info. Below line variable info.
  display.setCursor(0, 16);
  display.setTextSize(1);
  display.setTextColor(BLACK, WHITE);                  // Draw 'inverse' text 
  display.print("<  ");
  display.setCursor(18, 16);
  display.print(taskList[selectedTask].taskName);
  display.setCursor(108, 16);
  display.println("  >");
  display.setCursor(0, 26);
  display.setTextColor(WHITE);  
  display.println("Approximate ID:");
  char timeString1[16];
  while (! mfrc522.PICC_ReadCardSerial() && mfrc522.PICC_IsNewCardPresent()) {
//    Serial.print("UID tag : ");                        // Show UID on serial monitor
    int userID = GetUserFromRFIDTag(mfrc522.uid.uidByte); // Get ID from RFID card
    if(userID != -1){
      tmElements_t tm;
      if(RTC.read(tm)) {
        memset(timeString1, 16, sizeof timeString1);
        snprintf(timeString1, 16, "%i.%i.%i %i:%02i", tm.Day, tm.Month, 1970+tm.Year-2000, tm.Hour, tm.Minute);
        time_t theTime = makeTime(tm);
        completeTask(selectedTask, theTime, userID);
//        Serial.println(userList[userID].userName);
//        Serial.println(userID);
        if (digitalRead(button) == HIGH){
          if (userID != userID2){
            userList[userID].score = userList[userID].score+1;
            userID2 = userID;
            saveToEEPROM(); 
            break;
          }
        }
      }
    }
  }

  display.setCursor(30, 36);
  display.setTextSize(2);
  display.println(userList[userID2].userName);

  display.display();

}

//**************************************** RESULTSTASK ****************************************
void resultsTask() {                                   // Case 4: resultsTask
  arrowpos = 2;

  sortScoreList();
  
  display.clearDisplay();

  display.setCursor(0, 0);
  display.println("Scoreboard:");
//-----------------------------------------------------// Above line static info. Below line variable info.
  
  for(int i=0; i<numUsers; i++) {
    display.setCursor(10, (i*10)+16);
    display.print(score[i]);
    display.setCursor(60, ((numUsers-i)*10)+6);        // To print in highest-lowest score.
    display.print(userList[i].userName);
    display.print(" - ");
    display.println(userList[i].score);
  }
  
  display.display();

}

//**************************************** RFIDGET ****************************************
int GetUserFromRFIDTag(byte RFID[]){
  // Loop over all the users
  for(int i=0; i<numUsers; i++) {
    if(memcmp(userList[i].rfidUID, RFID, sizeof userList[i].rfidUID) == 0) {
      return userList[i].userID;
    }
  }

//  Serial.print(F("Unknown RFID card detected: "));
  for(byte i=0; i<4; i++) {
//    Serial.print(RFID[i]<0x10 ? " 0" : " ");
//    Serial.print(RFID[i], HEX);
  }
  
}

//**************************************** SELECTENCODER ****************************************
void selectEncoder() {
  
//  Serial.print("Arrowpos: ");
//  Serial.println(arrowpos);
//  Serial.print("menuIndex: ");
//  Serial.println(menuIndex);
  Serial.print("Button: ");
  Serial.println(button);
  
  long encoderCount = myEnc.read()>>2;
  encoderCount = normalize(encoderCount, listItems);   // Number of lines to display affects the encoder count
  if (encoderCount != oldPosition) {
    oldPosition = encoderCount;
    arrowpos = encoderCount;                           // Positions the arrow on each menu
//    Serial.print("Encoder: ");
//    Serial.println(encoderCount);
    selectedTask = encoderCount;
  }
  
}

//**************************************** SELECTBUTTON ****************************************
void selectButton() {
  button = digitalRead(4);                            // Select task button

  if (menuIndex == 2) {                               // Menu2()
    if (button == LOW && arrowpos == 2) {             // Goes back to mainMenu()
      menuIndex = 0;   
    }
  }
  if (menuIndex == 1) {                               // Menu1()
    if (button == LOW && arrowpos == 2) {             // Goes to subMenu1()
      menuIndex = 0;   
    }
  }
  if (menuIndex == 0) {                               // mainMenu()
    if (button == LOW && arrowpos == 0) {             // Goes to Menu1()
      menuIndex = 1;
    }
    if (button == LOW && arrowpos == 1) {             // Goes to Menu2()
      menuIndex = 2;  
    }
    if (button == LOW && arrowpos == 2) {             // Goes back to mainMenu()
      menuIndex = 0;  
    }
  }

}

//**************************************** SORTSCORELIST ****************************************
void sortScoreList(void) { 
    qsort(userList, numUsers, sizeof(struct user), struct_cmp_by_score); // sort array using qsort functions

} 

//**************************************** SAVETOEEPROM ****************************************
void saveToEEPROM() {
  // First, overwrite the first byte of EEPROM as a checkbyte
  EEPROM.write(0, 255);
  // Write the tasklist to EEPROM, starting at the second byte
  EEPROM.put(1, userList);
//  Serial.println("Task list saved to EEPROM!");
  // Now restore the checkbyte
  EEPROM.write(0,eepromSignature);
}

//**************************************** RESTOREFROMEEPROM **************************************** 
void restoreFromEEPROM() {                        //Restores the saved state of items in the tasklist from EEPROM
  // Read the value of the checkbyte
  int checkByte = EEPROM.read(0);
  // If the signature matches the current version number
  if(checkByte == eepromSignature) {
    // Restore the tasklist
    EEPROM.get(1, userList);
  }
}