Loom_Hypnos.h

#pragma once
 
 
#include <OPEnS_RTC.h>
#include <ArduinoLowPower.h>
#include <map>
#include <tuple>
 
#include "Arduino.h"
#include "Module.h"
 
#include "Hardware/Loom_Hypnos/SDManager.h"
#include "Loom_Manager.h"
 
// Used to pass along the user defined interrupt callback
using InterruptCallbackFunction = void (*)();
 
enum HYPNOS_VERSION{
    V3_2 = 10,
    V3_3 = 11,
    ADALOGGER = 4
};
 
enum TIME_ZONE{
    WAT = 1,
    AT = 2,
    AST = 4,
    EST = 5,
    CST = 6,
    MST = 7,
    PST = 8,
    AKST = 9,
    HST = 9,
    SST = 11,
    GMT = 0,
    BST = -1,
    CET = -1,
    EET = -2,
    EEST = -3,
    BRT = -3,
    ZP4 = -4,
    ZP5 = -5,
    ZP6 = -6,
    ZP7 = -7,
    AWST = -8,
    ACST = -9, // Half an hour off so its -9.5
    AEST = -10
 
};
 
enum HypnosInterruptType{
    SLEEP,
    OTHER
};
 
class Loom_Hypnos : public Module{
    protected:
 
        /* These aren't used with the Hypnos */
        void measure() override {};                               
       
        void initialize() override {};  
        
        void power_up() override {};
        void power_down() override {}; 
 
        // We want to use the package method to add the timestamp to the JSON
        void package() override;                           
    public:
 
        volatile bool shouldPowerUp = true;
 
        Loom_Hypnos(Manager& man, HYPNOS_VERSION version, TIME_ZONE zone, bool use_custom_time = false, bool useSD = true);
 
        ~Loom_Hypnos();
 
        /* Power Control Functionality */
 
        void enable(bool enable33 = true, bool emable5 = true);
 
        void disable();
 
        /* SD Functionality */
 
        bool logToSD();
 
        /* Sleep Functionality */
 
        bool registerInterrupt(InterruptCallbackFunction isrFunc = nullptr, int interruptPin = 12, HypnosInterruptType interruptType = SLEEP, int triggerState = LOW);
 
        void wakeup();
 
        bool reattachRTCInterrupt(int interruptPin = 12);
 
        void setInterruptDuration(const TimeSpan duration);
 
        void sleep(bool waitForSerial = false);
 
        DateTime getCurrentTime(); 
 
        void set_custom_time();
    
        TimeSpan getSleepIntervalFromSD(const char* fileName);
 
        void getTimeZoneFromSD(const char* fileName);
 
        char* readFile(const char* fileName) { return sdMan->readFile(fileName); };
 
        const char* getDefaultFilename(){ return sdMan->getDefaultFilename(); };
 
        SDManager* getSDManager() { return sdMan; };
 
        void setLogName(const char* name) { sdMan->setLogName(name); };
 
        /* Return initialization state of the RTC */
        bool isRTCInitialized() { return RTC_initialized; };
 
    private:
 
        Manager* manInst = nullptr;                                                         // Instance of the manager
        SDManager* sdMan = nullptr;                                                         // SD Manager
 
        int sd_chip_select;                                                                 // Pin that the SD card will use to communicate with the Hypnos
        bool enableSD;                                                                      // Specifies whether or not the SD card should be enabled on the Hypnos
 
        int batch_size;
 
        /* Real-Time Clock Settings */
 
        RTC_DS3231 RTC_DS;                                                                  // Real time clock reference
        bool RTC_initialized = false;                                                       // Did the RTC initialize correctly?
        
        bool custom_time = false;                                                           // Set the RTC to a user specified time
 
        // Map the given pin to an interrupt call back
        // 0th - ISR
        // 1st - Interrupt Trigger
        // 2nd - Interrupt Type (SLEEP or OTHER)
        std::map<int, std::tuple<InterruptCallbackFunction, int, HypnosInterruptType>> pinToInterrupt;            
 
        
        void initializeRTC();                                                               // Initialize RTC
 
        void createTimezoneMap();                                                           // Map Timezone Strings to Timezone enum
        std::map<const char*, TIME_ZONE> timezoneMap;                                       // String to Timezone enum
 
        DateTime get_utc_time();                                                            // Convert the local time to UTC, accounts for daylight savings zones
        TIME_ZONE timezone;                                                                 // Timezone the RTC was set to
       
        void dateTime_toString(DateTime time, char array[21]);                              // Convert a DateTime object to our desired format
 
        DateTime time;                                                                      // UTC time
        DateTime localTime;                                                                 // Local time
 
        /* Sleep functionality */
 
        void pre_sleep();                                                                   // Called just before the hypnos enters sleep, this disconnects the power rails and the serial bus
        void post_sleep(bool waitForSerial);                                                // Called just after the hypnos wakes up, this reconnects the power rails and the serial bus
 
        
 
};