File content as of revision 43:80aa0c933e1a:

#include "mbed.h"

//------------------------------------------------------------------------------------
// C027 Support Libraries
#include "GPS.h"
#include "MDM.h"

// M2X Support Libraries
#include <jsonlite.h>
#include "M2XStreamClient.h"

// PONY-specific config support libraries
#include "LIS331.h"
#include "PONY_Loc.h"       // PONY Location Code
#include "PONY_sense.h"

//----
// DEBUG DEFINITIONS
#define THROWAWAY
//#define MDMDEBUG

//------------------------------------------------------------------------------------
// Cellular modem/SIM parameters
#define SIMPIN      "1111"          //!SIMPIN is 1111 by default for AT&T SIMs.
#define APN         "m2m.com.attz"  // Defined AT&T M2M APN
#define USERNAME    NULL            //! Set the user name for your APN, or NULL if not needed (which, apparently, it isn't)
#define PASSWORD    NULL            //! Set the password for your APN, or NULL if not needed (which, apparently, it isn't)

//------------------------------------------------------------------------------------
// AT&T M2X Kekys


#ifdef THROWAWAY
// Codes for a throwaway M2X device
#define M2XAPIKEY "54c6bbf11012f34830bd23cc091ca250"
#define DEVID "b9c57667ee0495dc0b3cddd890f8d2df"
#endif

#ifndef THROWAWAY
// v1.2 codes
#define M2XAPIKEY "bbc483492238dc76f7d12f0cd6e13a4b"
#define DEVID "3764db38b6c9ec4045a38e0125b14b4c"
#endif


//------------------------------------------------------------------------------------
// PIN Config
DigitalIn jostle(P2_13);

DigitalOut led1(LED1);
DigitalOut led2(LED2);

AnalogIn   tempPin(P0_23);
AnalogIn   tempGnd(P0_24);

//I2C axis(P0_0, P0_1);       // SDA, SCL
LIS331 axle(P0_0, P0_1);        // Library object


//------------------------------------------------------------------------------------
// GLOBAL VARIABLES

Ticker flipper;

// M2X Drivers
Client client;
M2XStreamClient m2xClient(&client, M2XAPIKEY);
int M2X_response;   // For m2x message responses


char statusBuf[145] = "";

// Location reading
unsigned int kReadingDelay = 3 * 60 * 1000;         // How many seconds to wait between reads
unsigned int kReadingDelayClimb = 15000;    // How many seconds to add to the wait period when sitting idle
unsigned int kReadingDelayMax = 5 * 60000;  // What's the maximum time between readings?
double kLaLoDiffMin = 0.01;
double kAltDiffMin  = 2.00;

// Temperature reads
float kTemp;

// Loop drivers
unsigned int kIdleSpins = 0;

// System time
time_t kSysSeconds = time(NULL);
bool kSysClockSet = false;
tm kFormatTime;


// Global function definitions

void flip() {
    led1 = !led1;
}


//------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------
int main(void)
{
    
    printf("\r\n\n\n\n-----\r\nI'm alive - vers. uA\r\n\n");
    #ifdef THROWAWAY
    printf("Using THROWAWAY M2X device\r\n");
    #endif

    MDMSerial mdm;
    MDMParser::DevStatus devStatus = {};
    MDMParser::NetStatus netStatus = {};    
    bool mdmOk = mdm.init(SIMPIN, &devStatus);
    #ifdef MDMDEBUG
    //mdm.setDebug(4);
    #endif
    
    // ----------------
    // LOCATION READING
    
    
    // Open modem connection
    if (!mdm.connect(SIMPIN, APN,USERNAME,PASSWORD))
        return -1;    
    


    // Cell location call variables
    const int sensorMask = 2;  // 1 = GNSS, 2 = CellLocate, 3 = Hybrid: GNSS + CellLocate       
    //const int timeout = 55; // in seconds
    const int targetAccuracy = 1; // meters

    // Cell location data
    MDMSerial::CellLocData ponyLoc, thisLoc;

    printf("Configure deep scan mode\r\n");
    int locConf = mdm.cellLocConfigSensor(1);   // Set deep scan mode
    
    
    // Loop driving variables
    bool locLock;
    int submitPeriod = 30;
    int timeoutMargin = 5;
    int readLoopMax = 100;
    int loopIter = 0;
    int locAccLower = 50;   // Immediately accept locations with uncertainty lower than this
    int locAccUpper = 5000; // Don't accept locations with uncertainty greater than this


    // -----------------------
    // Location reporting loop
    while(true) {
        
        M2X_response = 0;
        locLock = false;
        loopIter++;
        
                
        //M2X_response = logTemp(&tempPin, &m2xClient);
        printf("tick\r\n");
        

        /*
        while(!M2X_response) {
            printf("Waiting on temperature log\r\n");
            delay(1000);
        }
        */
        
        delay(5000);    // Delay to ensure that the modem isn't talking over itself transmitting temp and requesting location
        
        //printf("Cell location Request; deep scan=%i, mask=%i, accuracy=%i\r\n", locConf, sensorMask, targetAccuracy);
        //mdm.setDebug(4);
        mdm.cellLocRequest(sensorMask, submitPeriod - timeoutMargin, targetAccuracy);

        

        // Have location data
        if ( mdm.cellLocGet(&thisLoc) ){           
            //printf("CellLocate position rec'd with uncertainty= %d, sensor= %d\r\n", thisLoc.uncertainty, thisLoc.sensorUsed );           
            
            
            if(thisLoc.sensorUsed == 2) { // thisLoc.uncertainty < ponyLoc.uncertainty) { //Basing test for validity on uncertainty and having a new position lock
                printf("  NEW-latitude: %0.5f, longitude: %0.5f, altitute: %d, uncertainty: %d, sensor: %d\r\n", thisLoc.latitude, thisLoc.longitude, thisLoc.altitude, thisLoc.uncertainty, thisLoc.sensorUsed);
                ponyLoc.latitude = thisLoc.latitude;
                ponyLoc.longitude = thisLoc.longitude;
                ponyLoc.altitude = thisLoc.altitude;
                ponyLoc.uncertainty = thisLoc.uncertainty;
                
                
                if(!kSysClockSet) {
                    printf("\033[31mSet system clock time.\033[39m\r\n");
                    
                    // TODO: Get the local time zone
                    //mdm.setDebug(4);
                    //mdm.sendFormated("AT+CTZR=1");

                    // Adjust year because it's reporting the absolute year
                    // mbed expects the year to be "since 1900" (https://developer.mbed.org/handbook/Time?action=view&revision=11592)
                    (thisLoc.time).tm_year -= 1900;
                    
                    kSysSeconds = mktime( &(thisLoc.time) );
                    set_time(kSysSeconds);
                    printf("System time set to: %s\r\n", ctime(&kSysSeconds) );    
                    
                    kSysClockSet=true;
                }
                
                // Print the timestamp
                
                
                time_t newTime = time(NULL);
                printf("System time at: %s\r\n", ctime(&newTime) );
            }
            
            
            // Check location data
            if( ( 0 < ponyLoc.uncertainty && ponyLoc.uncertainty < locAccLower ) || ( 0 < ponyLoc.uncertainty && ponyLoc.uncertainty < locAccUpper && loopIter > readLoopMax ) ) {
                
                printf("\r\nTRANSMIT LOCATION DATA:\r\nla=%0.5f, lo=%0.5f, alt=%d\r\n", ponyLoc.latitude, ponyLoc.longitude, ponyLoc.altitude);
                M2X_response = m2xClient.updateLocation(DEVID, "pony-spot", (double) ponyLoc.latitude, (double) ponyLoc.longitude, (double) ponyLoc.altitude);
                
                if(M2X_response == 202)
                    printf("Location POST successful\r\n");
                
                
                // Report uncertainty
                M2X_response = m2xClient.updateStreamValue(DEVID, "locacc", ponyLoc.uncertainty);
                
                if(M2X_response == 202)
                    printf("Location Confidence (%d) POST successful\r\n", ponyLoc.uncertainty);
                
                // Report temperature
                M2X_response = logTemp(&tempPin, &kTemp, &m2xClient);
                
                if(M2X_response == 202)
                    printf("Temperature POST successful\r\n");
                    
                                    
                locLock = true;
            }             
        }
        
        // No location data
        else {
            printf("cellLocGet failed.\r\n");
            //
        }

        // Wait only if we've received a good location reading
        if(locLock) {
            printf("Begin %i second delay\r\n",kReadingDelay/1000); loopIter = 0; delay(kReadingDelay);
            ponyLoc.uncertainty = locAccUpper + 1;
            continue;
        }
        else if (loopIter > readLoopMax) {
            sprintf(statusBuf, "CellLoc location not found after %i loops.\r\n", loopIter);
            printf(statusBuf);
            M2X_response = m2xClient.updateStreamValue(DEVID, "status", statusBuf);
            if(M2X_response == 202)
                printf("Status POST successful\r\n");            
            
            ponyLoc.uncertainty = locAccUpper + 1;
            printf("Begin %i second delay\r\n",kReadingDelay/1000); loopIter = 0; delay(kReadingDelay);
            continue;
        }

        else {
            printf("Bad data delay = submitPeriod...\r\n");
            delay(submitPeriod * 1000);    // Delay between CellLoc requests when not getting good data
            flipper.attach(&flip, 0.5); // the address of the function to be attached (flip) and the interval (2 seconds)
        }
        led1 = 0;
    }


    //mdm.disconnect();
    //mdm.powerOff();
    
}