File content as of revision 15:7aad9a7f970c:

#include "main.h"
//include "nrf_soc.h"

//------------------------------------------------------------------------------
//FUNCTION PROTOTYPES
//------------------------------------------------------------------------------ 
static void mainStateEngine(void);
static void selftest(void);
static void buttonPress(void);
static void buttonRelease(void);

//------------------------------------------------------------------------------
//GLOBAL VARS / CLEARED ON SLEEP (IF USING SOFT REBOOT HACK)
//------------------------------------------------------------------------------ 
char* GLOBAL_defaultApi = "b:gps2,d:3";
bool GLOBAL_accel_healthy = false;
bool GLOBAL_requireSoftReset = false;
bool GLOBAL_motionFlagTriggered = false;
bool GLOBAL_debugLED = false;
bool GLOBAL_needToConfigureLis3dh = false;
bool GLOBAL_registeredOnNetwork = false;
long long GLOBAL_imei = 0;
float GLOBAL_voltage = 0.0;
time_t GLOBAL_RTCunixtime = 0;
time_t GLOBAL_wakeTime = 0;

//------------------------------------------------------------------------------
//RETAINED NOINIT RAM VARS
//------------------------------------------------------------------------------ 
#if defined ( __CC_ARM ) /** THIS IS THE MBED ONLINE COMPILER TOOLCHAIN*/ //MUST BE STATICS
//IDENTITY
static long long        RET_imei                            __attribute__((section("noinit"),zero_init));
static char             RET_pfIdentifier[6]                 __attribute__((section("noinit"),zero_init));
//STATE
static uint8_t          RET_coldBoot                        __attribute__((section("noinit"),zero_init));
static bool             RET_haveSettings                    __attribute__((section("noinit"),zero_init));
static uint8_t          RET_mode                            __attribute__((section("noinit"),zero_init));
static uint8_t          RET_mode_prev                       __attribute__((section("noinit"),zero_init));
static uint8_t          RET_buttonPressCount                __attribute__((section("noinit"),zero_init));
static time_t           RET_buttonPressTime                 __attribute__((section("noinit"),zero_init));
static time_t           RET_buttonReleaseTime               __attribute__((section("noinit"),zero_init));
static time_t           RET_buttonHoldTime                  __attribute__((section("noinit"),zero_init));
static time_t           RET_RTCunixtime                     __attribute__((section("noinit"),zero_init));
static long             RET_RTCmicros                       __attribute__((section("noinit"),zero_init));
static bool             RET_requireImpactFlag               __attribute__((section("noinit"),zero_init));
//MOTION SETTINGS
static bool             RET_impactTriggered                 __attribute__((section("noinit"),zero_init));
static bool             RET_motionTriggered                 __attribute__((section("noinit"),zero_init));
static time_t           RET_motionStartTime                 __attribute__((section("noinit"),zero_init));
static time_t           RET_motionStopTime                  __attribute__((section("noinit"),zero_init));
static time_t           RET_motionStartThreshold_seconds    __attribute__((section("noinit"),zero_init));
static time_t           RET_motionStopThreshold_seconds     __attribute__((section("noinit"),zero_init));
static bool             RET_motionPendingOnState            __attribute__((section("noinit"),zero_init));
static bool             RET_motionPendingOffState           __attribute__((section("noinit"),zero_init));
static bool             RET_motionState                     __attribute__((section("noinit"),zero_init));
static float            RET_motionTotalActivityHours        __attribute__((section("noinit"),zero_init));
static char             RET_motionData[100]                 __attribute__((section("noinit"),zero_init));
//EVENT HANDLING
static time_t           RET_eventInterval_location_log      __attribute__((section("noinit"),zero_init));
static time_t           RET_eventTime_location_log          __attribute__((section("noinit"),zero_init));
static time_t           RET_eventTime_location_bc           __attribute__((section("noinit"),zero_init));

static time_t           RET_eventInterval_environmental_log __attribute__((section("noinit"),zero_init));
static time_t           RET_eventTime_environmental_log     __attribute__((section("noinit"),zero_init));
static time_t           RET_eventTime_environmental_bc      __attribute__((section("noinit"),zero_init));
static time_t           RET_eventTime_activity_bc           __attribute__((section("noinit"),zero_init));
static time_t           RET_eventTime_wakeFromDormant       __attribute__((section("noinit"),zero_init));
#elif defined ( __GNUC__ )
#elif defined ( __ICCARM__ )
#endif

//------------------------------------------------------------------------------
//GPIO
//------------------------------------------------------------------------------ 
InterruptIn button(PN_IN_BUTTON); //This causes wake from sleep
DigitalOut vreg_en(PN_VREG_EN);

//------------------------------------------------------------------------------
//PERIPHERALS
//------------------------------------------------------------------------------ 
//BLE myble;
extern WatchdogTimer watchdog(240.0); //Do not set to less than 4500ms or can cause issues with softdevice
//SERIAL DEBUG?
#if CONSOLE_DEBUG
    Serial uart(PN_UART_TX, PN_UART_RX, 115200);
#endif
        
//------------------------------------------------------------------------------
//TIMERS
//------------------------------------------------------------------------------ 
LowPowerTicker RTCticker; //no impact on power consumption

//------------------------------------------------------------------------------
//THREAD SEMAPHORES
//------------------------------------------------------------------------------ 
Semaphore mainthread;

//------------------------------------------------------------------------------
//SINGLETONS
//------------------------------------------------------------------------------
//NVStore &nvstore = NVStore::get_instance();

//------------------------------------------------------------------------------
// LOW LEVEL FUNCS
//------------------------------------------------------------------------------ 
void turnOffEverything() {
    vreg_en = 0;
    LED1off();
}
void gotoSleep(long sleep_milliseconds) {
    turnOffEverything();
    watchdog.kick();
    if (GLOBAL_requireSoftReset) { //dont need to clear this var as reset changes it back to false
        system_reset();
    }
    mainthread.wait(sleep_milliseconds);
}
void RTCtick() {
    RET_RTCmicros += 100;
    RET_RTCunixtime = (RET_RTCmicros / 1000);
    GLOBAL_RTCunixtime = RET_RTCunixtime;
    //button logic - check for hold
    if (RET_buttonHoldTime > 4000) {
        RET_buttonHoldTime = 0;
        RET_buttonPressCount = 0;
        RET_mode_prev = RET_mode;
        RET_mode = MODE_BUTTONHOLD;
        mainthread.release();
    } else {
        if((RET_RTCmicros - RET_buttonPressTime) > 500) {
            switch (RET_buttonPressCount) {   
                case 1 :
                    RET_mode_prev = RET_mode;
                    RET_mode = MODE_BUTTONPRESS1;
                    mainthread.release();
                    break;
                case 2 :
                    RET_mode_prev = RET_mode;
                    RET_mode = MODE_BUTTONPRESS2;
                    mainthread.release();
                    break;
                default :
                    //do nothing
                    break;
            }
            RET_buttonPressCount = 0;
        }
    }
}
void factoryReset() {
    DEBUG("Factory Reset \n");
    Thread::wait(500); //wait to ensure that devices are turned off
    GLOBAL_requireSoftReset = false;
    
    //RESET RETAINED VARS
    RET_imei = 0;
    memset(RET_pfIdentifier,0,sizeof(RET_pfIdentifier));
    RET_coldBoot = 1;
    RET_haveSettings = 0;
    RET_mode = MODE_SETUP;
    RET_mode_prev = RET_mode;
    RET_RTCunixtime = 0;
    RET_RTCmicros = 0;
    
    RET_eventInterval_environmental_log = 0;
    RET_eventTime_location_log = 0;
    RET_eventTime_location_bc = 0;
    RET_eventTime_environmental_log = 0;
    RET_eventTime_environmental_bc = 0;
    RET_eventTime_activity_bc = 0;
    RET_eventTime_wakeFromDormant = 0;
    
    RET_motionPendingOffState = 0;
    RET_motionPendingOnState = 0;
    RET_motionTriggered = 0;
    RET_impactTriggered = 0;
    RET_motionState = 0;
    RET_motionStartTime = 0;
    RET_motionStopTime = 0;
    RET_motionStartThreshold_seconds = 60;
    RET_motionStopThreshold_seconds = 60;
    RET_motionTotalActivityHours = 0.0;
    RET_buttonPressTime = 0;
    RET_buttonPressCount = 0;
    RET_buttonHoldTime = 0;
    
    //CONFIGURE ACCELL DEFAULT
    lis3dh_configureForSleep(10,127);
}
void copyRETtoGLOBAL() {
    GLOBAL_imei = RET_imei; 
}
void selfTest() {
    //Accelerometer
    LIS3DH lis3dh(PN_SPI_MOSI, PN_SPI_MISO, PN_SPI_CS0, PN_SPI_CLK);
    uint8_t lis3dh_id; 
    lis3dh.LIS3DH_GetWHO_AM_I(&lis3dh_id);
    if (lis3dh_id == 51) {
        LED1blink(10,50);
    }
}

//------------------------------------------------------------------------------
// USER BUTTON HANDLING
//------------------------------------------------------------------------------ 
void buttonPress() {
    RET_buttonPressTime = RET_RTCmicros;
}
void buttonRelease() {
    RET_buttonHoldTime = (RET_RTCmicros - RET_buttonPressTime);
    //debounce catch
    if((RET_RTCmicros - RET_buttonPressTime) >= 100) {
        RET_buttonPressCount ++;
    }
}

//------------------------------------------------------------------------------
// MOTION FUNCS
//------------------------------------------------------------------------------ 
void checkMotion() {
    if (lis3dh_int2) {
        if (GLOBAL_debugLED) LED1blink(2,100);
        RET_motionTriggered = true;
        GLOBAL_needToConfigureLis3dh = true; //interrupt has fire so need to clear it
        if (!RET_motionPendingOnState) {
            RET_motionPendingOnState = true;
            RET_motionPendingOffState = false;
            // Log start motion time
            RET_motionStartTime = RET_RTCunixtime;
        }
    } else {
        if (GLOBAL_debugLED) LED1blink(2,500);
        RET_motionTriggered = false;
        RET_motionPendingOnState = false;
        if (!RET_motionPendingOffState) {
            RET_motionPendingOffState = true;
            //log stop motion time
            RET_motionStopTime = RET_RTCunixtime;
        }
    }
    //calculate motion state
    if (RET_motionPendingOnState) {
        //check if above threshold
        time_t inMotionForSeconds = (RET_RTCunixtime - RET_motionStartTime);
        if (inMotionForSeconds >= RET_motionStartThreshold_seconds) {
            RET_motionState = true;
            if (GLOBAL_debugLED) LED1blink(10,100);
        }
    }
    if (RET_motionPendingOffState) {
        time_t noMotionForSeconds = (RET_RTCunixtime - RET_motionStopTime);
        if (noMotionForSeconds >= RET_motionStartThreshold_seconds) {
            RET_motionState = false;
            RET_motionTotalActivityHours += (float(RET_motionStopTime - RET_motionStartTime) / 3600.0); 
            if (GLOBAL_debugLED) LED1blink(5,500);
        }
    }
}

//------------------------------------------------------------------------------
// UPDATE OPERATING SETTINGS
//------------------------------------------------------------------------------ 
bool saveSettings(char* settingsBuffer) {
    //process result
    int matchCount = 0;
    char TEMP_a[6];
    int TEMP_b = 0;
    int TEMP_c = 0;
    int TEMP_d = 0;
    int TEMP_e = 0;
    int TEMP_f = 0;
    int TEMP_g = 0;
    int TEMP_h = 0;
    int TEMP_i = 0;
    int TEMP_j = 0;
    int TEMP_k = 0;
    int TEMP_l = 0;
    int TEMP_m = 0;
    int TEMP_n = 0;
    time_t TEMP_o = 0;
    if ( (matchCount = sscanf(settingsBuffer,"a:%c%c%c%c%c%c,b:%d,c:%d,d:%d,e:%d,f:%d,g:%d,h:%d,i:%d,j:%d,k:%d,l:%d,m:%d,n:%d,0:%u",
    &TEMP_a[0],&TEMP_a[1],&TEMP_a[2],&TEMP_a[3],&TEMP_a[4],&TEMP_a[5],&TEMP_b,&TEMP_c,&TEMP_d,&TEMP_e,&TEMP_f,&TEMP_g,&TEMP_h,&TEMP_i,&TEMP_j,&TEMP_k,&TEMP_l,&TEMP_m,&TEMP_n,&TEMP_o) ) > 0 ) {
        DEBUG("VALUES: a:%s,b:%d,c:%d,d:%d,e:%d,f:%d,g:%d,h:%d,i:%d,j:%d,k:%d,l:%d,m:%d,n:%d,o:%d\n",TEMP_a,TEMP_b,TEMP_c,TEMP_d,TEMP_e,TEMP_f,TEMP_g,TEMP_h,TEMP_i,TEMP_j,TEMP_k,TEMP_l,TEMP_m,TEMP_n,TEMP_o);
        RET_haveSettings = true;
        return true;
    } else {
        RET_haveSettings = false;
        return false;
    }
}


//------------------------------------------------------------------------------
// SETUP
//------------------------------------------------------------------------------ 
bool setup() {
    DEBUG("SETUP\n");
    bool pass = true;
    //LED1on(0);
    Modem modem(PN_UART_TX, PN_UART_RX, PN_UART_CTS, PN_UART_RTS, PN_GSM_PWR_KEY, PN_VREG_EN);
    if (modem.on()) {
        RET_imei = modem.getIMEI();
        GLOBAL_imei = RET_imei;
        DEBUG("imei: %lld \n",RET_imei);
        if (modem.registerOnNetwork(3,60000)) {
                char* bytestosend;
                sprintf(bytestosend,"(im:%lld,%s,v:%.2f,fr:1)\0",GLOBAL_imei,GLOBAL_defaultApi,GLOBAL_voltage);
                //DEBUG("SENDING:%s\n",bytestosend);
                char* result = modem.USSDmessage(bytestosend, true, 2, GLOBAL_defaultApi);
                if (result != "err") {
                    DEBUG("result: %s \n",result);
                    saveSettings(result);
                }
        } else {
            //modem failed to register on network
        }
    } else {
        pass = false;
        //Modem failed to turn on   
    }
    //LED1off();
     
    while (1) {
        Thread::wait(60000);
        watchdog.kick();
    }
    
    //RESULT
    if (pass) {
        return true;
    } else {
        return false;   
    }
}


//------------------------------------------------------------------------------
// STATE ENGINE
//------------------------------------------------------------------------------ 
void mainStateEngine() {
    DEBUG("StateEngine:%d \n",RET_mode);
    switch(RET_mode) {
        case MODE_SETUP :
            factoryReset();
            if (setup()) {
                copyRETtoGLOBAL();
                RET_mode = MODE_NORMAL;
            }
            break;
        case MODE_NORMAL :
            //check and log motion
            checkMotion();
            
            //EVENTS
            //Location
            if(RET_RTCunixtime > RET_eventTime_location_log && RET_eventTime_location_log > 0) {
                //getdata_environmental();
                //event_location_log();
            }
            if(RET_RTCunixtime > RET_eventTime_location_bc && RET_eventTime_location_bc > 0) {
                //getdata_battery();
                //event_location_broadcast();
            }
            //Environmental
            if(RET_RTCunixtime > RET_eventTime_environmental_log && RET_eventTime_environmental_log > 0) {
                Filesystem filesystem(BD_PAGE_ADDRESS,BD_TOTAL_SIZE);
                SI7060 temperature(PN_I2C_SDA,PN_I2C_SCL);
                float temperature_c = temperature.getTemperature();
                DEBUG("Temperature log: %u,%f \n", RET_RTCunixtime,temperature_c);
                filesystem.addLogEntry_temperature(RET_RTCunixtime,temperature_c);
            }
            if(RET_RTCunixtime > RET_eventTime_environmental_bc && RET_eventTime_environmental_bc > 0) {
                //event_environmental_bc();
                //Filesystem filesystem(PN_SPI_MOSI,PN_SPI_MISO,PN_SPI_CLK,PN_SPI_CS1);
            }
            //Activity
            if(RET_RTCunixtime > RET_eventTime_activity_bc && RET_eventTime_activity_bc > 0) {
                //event_activity_bc();
            }
            break;
        case MODE_DORMANT :
            if (RET_RTCunixtime > RET_eventTime_wakeFromDormant) {
                RET_mode = MODE_NORMAL;
            }
            break;
        case MODE_BUTTONPRESS1 :
            LED1blink(1,300);
            RET_mode = RET_mode_prev;
            break; 
        case MODE_BUTTONPRESS2 :
            LED1blink(3,300);
            RET_mode = RET_mode_prev;
            break;  
        case MODE_BUTTONHOLD :
            LED1blink(10,300);
            RET_eventTime_wakeFromDormant = (RET_RTCunixtime + (48*3600)); //48hrs
            RET_mode = MODE_DORMANT;
            break;
        default :
            RET_mode = MODE_SETUP;
    }
}


//------------------------------------------------------------------------------
// MAIN
//------------------------------------------------------------------------------ 
int main() {
    RTCticker.attach(&RTCtick, 0.1);
    turnOffEverything();
    
    button.fall(&buttonPress); //does this affect power?
    button.rise(&buttonRelease);

    //CHECK IF THIS IS RESET
    //0x00000004 == soft reset  //0x00000002 == watchdog  //0x00000001 == button/hardreset 
    if (NRF_POWER->RESETREAS != 0xffffffff) {
        switch(NRF_POWER->RESETREAS) {
            case 0x00000001  :
                DEBUG("reset_reason: 0x%08x. - Hard Reset\n",NRF_POWER->RESETREAS);
                RET_coldBoot = 1;
            break;
            case 0x00000002  :
                DEBUG("reset_reason: 0x%08x. - Watchdog\n",NRF_POWER->RESETREAS);
            break;
            case 0x00000004  :
                DEBUG("reset_reason: 0x%08x. - Soft reset\n",NRF_POWER->RESETREAS);
            break;
        }
        NRF_POWER->RESETREAS = 0xffffffff;
    }
    //CHECK FOR FIRST BOOT
    if (RET_coldBoot == 1) factoryReset();
    
    //COPY ESSENTIAL VALUES FROM RET TO GLOBAL
    copyRETtoGLOBAL();
    
    while(true) {
        //SLEEP
        if (RET_coldBoot != 1) gotoSleep(10000); //THIS HAS TO BE THE FIRST ITEM IN THE MAIN LOOP
        watchdog.kick();
        
        //LOG START TIME
        GLOBAL_wakeTime = RET_RTCunixtime;
        
        //MAIN LOGIC
        DEBUG("State: %i  time: %i, %i, %i, %i \n", RET_mode, RET_RTCmicros, RET_RTCunixtime, RET_buttonHoldTime, RET_buttonPressCount);
        mainStateEngine();
        
        //PRE-SLEEP ACTIONS
        if (GLOBAL_needToConfigureLis3dh) { //ONLY RESET ACCELL IF WE NEED TO
            lis3dh_configureForSleep(10,127);
        }
        RET_coldBoot = 0;
    }
}