File content as of revision 16:fc7d8cc6bf4b:

/* procédure lecture capteur COZIR ou MINIR - CO2 seul
sur broches F401RE SERIAL PA_11 et PA_12
renvoie sur moniteur (IDE arduino par exemple) de la valeur lue

procédures possibles sont :
request (char commande) - renvoie la valeur lue si la commande ne représente qu'un seul caractère (entre '')
cozirSend (string commande) - permet d'envoyer des commandes multicaractères (entre "") - exemple A 32 - donne la réponse obtenue


la fonction cozirSend est davantage "sécurisée"
*/


#include "mbed.h"
#include "SDFileSystem.h"
#include "ARNSRS_SENSORS.h"
#include "ble/BLE.h"

#include "ble/services/UARTService.h"
#include <string>

//Ecrit dans le moniteur série de l'ordi à 9600 bds si sur 1
#define NEED_CONSOLE_OUTPUT 1
//Pour utiliser le traceur du moniteur Arduino. Mettre NEED_CONSOLE_OUTPUT 0 si utilisé.
//En premier ouvrir le moniteur série pour régler la RTC, puis fermer et ouvrir le traceur série
#define NEED_GRAPH_OUTPUT 0
//Datalog carte SD si sur 1
#define NEED_SD_DATA_LOG 0

#if NEED_CONSOLE_OUTPUT
#define DEBUG(...) { serialMonit.printf(__VA_ARGS__); }
#else
#define DEBUG(...)
#endif

#if NEED_GRAPH_OUTPUT
#define TRACE(...) { serialMonit.printf(__VA_ARGS__); }
#else
#define TRACE(...)
#endif

//Init BLE
BLEDevice  ble;
UARTService *uartServicePtr;

//Init de la lib ARNSRS;
ARNSRS arnsrs;

//Quelque FLAG...
bool FLAG_SIMPLE_TIME = false;

//COM Série vers l'ordi, Serial 2 par défaut
Serial serialMonit (USBTX,USBRX);

//Variable des capteurs
int co2 = 0;
int ppO2 = 0;
float pression = 0;
float Temp1 = 0;
float Temp2 = 0;
float Humi = 0;

//Pour stocker le format date / heure
string DateHeure;

//SD card
SDFileSystem sd(D11, D12, D13, D10, "sd"); // MOSI, MISO, SCK, CS
FILE *fp;
char fileName[32];
int points = 1;


//Fonction pour créer et envoyer la chaine d'infos en BLE
//On balance tout en float, même pour des int...Qui peut le plus peut le moins...
//3 par 3 ça passe juste avec un décimal....Sinon faire deux par deux ???
void build_send_Message(string com, float A, float B, float C)
{
    char buf[50];
    sprintf(buf,"%s%.1f:%.1f:%.1f\r\n", com, A, B, C);
    uartServicePtr->writeString(buf);
}

void disconnectionCallback(const Gap::DisconnectionCallbackParams_t *params)
{
    //DEBUG("Disconnected!\n\r");
    //DEBUG("Restarting the advertising process\n\r");
    ble.startAdvertising();
}

void onDataWritten(const GattWriteCallbackParams *params)
{
    if ((uartServicePtr != NULL) && (params->handle == uartServicePtr->getTXCharacteristicHandle())) {
        uint16_t bytesRead = params->len;
        /*
        // les chaines de réponse
        uint8_t press_mb_ToSend[14];
        uint8_t co2_ppm_ToSend[14];
        uint8_t o2_mb_ToSend[14];

        // fabrication des chaines de réponse
        // on suppose que chaque donnee peut être représentée par 5 digits
        char s_press_mb [50];
        sprintf(s_press_mb,"PRESS %i mb    ",press_mb);  // mef ! laisser les espaces de la fin

        char s_co2_ppm [50];
        sprintf(s_co2_ppm,"CO2 %i ppm     ",co2_ppm);

        char s_o2_mb [50];
        sprintf(s_o2_mb,"O2 %i mb        ",o2_mb);

        // convertir les chaines en uint8_t
        for(int j=0;j<sizeof(s_press_mb);j++){ // hypothèse : les chaines press, co2, o2 ont la même longeur
            press_mb_ToSend[j]=s_press_mb[j];
            co2_ppm_ToSend[j]=s_co2_ppm[j];
            o2_mb_ToSend[j]=s_o2_mb[j];
        }
*/
        // chaine reçue de l'app android (à dimensionner selon besoin)
        char commande [bytesRead] ;

        // conversion de la commande uint8_t en chaine pour permettre comparaison avec commandes connues
        for (int j=0; j<bytesRead; j++) {
            commande [j] = (*((params->data)+j));
        }
/*
        DEBUG("received %u bytes => ", bytesRead);
        DEBUG("commande recue -%s-\r\n",commande);
        DEBUG ( "comparaison a commande 'p' vaut %d\r\n",strcmp(commande, "p"));
        DEBUG ( "comparaison a commande 'o' vaut %d\r\n",strcmp(commande, "o"));
        DEBUG ( "comparaison a commande 'c' vaut %d\r\n",strcmp(commande, "c"));
        DEBUG ( "comparaison a commande 't' vaut %d\r\n",strcmp(commande, "t"));
        DEBUG ( "comparaison a commande 'u' vaut %d\r\n",strcmp(commande, "t"));

        // envoi des réponses en fonction de la commande recue
        if (strcmp(commande, "p") == 0) {
            DEBUG("s_press_mb %s +++> data to send %s \r\n",s_press_mb,press_mb_ToSend);
            ble.updateCharacteristicValue(uartServicePtr->getRXCharacteristicHandle(), press_mb_ToSend, sizeof(press_mb_ToSend));
            }
        if (strcmp(commande, "c") == 0) {
            DEBUG("s_co2_ppm %s +++> data to send %s \r\n",s_co2_ppm,co2_ppm_ToSend);
            ble.updateCharacteristicValue(uartServicePtr->getRXCharacteristicHandle(), co2_ppm_ToSend, sizeof(co2_ppm_ToSend));
            }
        if (strcmp(commande, "o") == 0) {
            DEBUG("s_o2_mb %s +++> data to send %s \r\n",s_o2_mb,o2_mb_ToSend);
            ble.updateCharacteristicValue(uartServicePtr->getRXCharacteristicHandle(), o2_mb_ToSend, sizeof(o2_mb_ToSend));
            }
        else
*/
        if (strcmp(commande, "t") == 0) {
            build_send_Message("t", ppO2, co2, pression);
        }else
        if (strcmp(commande, "u") == 0) {
            build_send_Message("u", Temp1, Temp2, Humi);
        }
    }
}

//Fonction qui change le nom du fichier ouvert pour le LOG
FILE *nextLogFile(void)
{
    static unsigned int fileNumber = 0;
    FILE *filePtr = NULL;
    do {
        if (filePtr != NULL)
            fclose(filePtr);
        sprintf(fileName,"/sd/LOG_Capteurs_%04u.txt",fileNumber++);
        filePtr = fopen(fileName,"r");
    } while (filePtr != NULL);
    return fopen( fileName,"w");
}

void SetTime()
{
    //Reglage date / heure depuis le terminal
    struct tm t;
    serialMonit.printf("Entrer la date et l'heure :\n");
    serialMonit.printf("YYYY MM DD HH MM SS [enter]\n");
    scanf("%d %d %d %d %d %d", &t.tm_year, &t.tm_mon, &t.tm_mday
          , &t.tm_hour, &t.tm_min, &t.tm_sec);
    t.tm_year = t.tm_year - 1900;
    t.tm_mon = t.tm_mon - 1;

    // set the time
    set_time(mktime(&t));
    if(NEED_CONSOLE_OUTPUT == 0) serialMonit.printf("OK. Vous pouvez fermer le moniteur serie");
}

void init_DATALOG()
{
    //Initialisation DATA LOG
    DEBUG("Initialisation SD card\r\n");
    DEBUG("\r\n", "");
    fp = nextLogFile();

    if (!fp) {
        DEBUG("Probleme SD card...Fin du programme...\r\n");
        //exit(0);
    } else {
        DEBUG("Nouveau fichier LOG cree  =  %s\r\n", fileName);
        DEBUG("\r\n", "");
    }
}

void DATA_LOG()
{
    time_t seconds = time(NULL);
    if (fp) {
        fprintf(fp, "%s,%d,%d,%f,%f,%f,%f\r\n", ctime(&seconds), co2 , ppO2, pression, Temp1, Temp2, Humi);
        DEBUG("  Enregistrement d'un point sur la carte SD\r\n");
        DEBUG("  Nombre de points                      = %d\r\n", points);
        DEBUG("\r\n", "");
        points++;
    } else {
        DEBUG("  Probleme carte SD\r\n");
    }
}
///////////////////////////////////
// fonction initialisation    /////
///////////////////////////////////
void setup()
{
    //Réglage de l'heure
    SetTime();

    //Initialisation du Data log
    if (NEED_SD_DATA_LOG == 1) init_DATALOG();

    //Initialisation capteurs
    arnsrs.Sensors_INIT(false, 5, SPOOLING, DIGI_FILTER32, CALIB_AIR);
}

/////////////////////////////////////
/// procédure principale    /////////
/////////////////////////////////////

int main()
{
    setup();

    //DEBUG("Initialising....\n\r");
    ble.init();
    ble.onDisconnection(disconnectionCallback);
    ble.onDataWritten(onDataWritten);

    /* setup advertising */
    ble.accumulateAdvertisingPayload(GapAdvertisingData::BREDR_NOT_SUPPORTED);
    ble.setAdvertisingType(GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED);
    ble.accumulateAdvertisingPayload(GapAdvertisingData::SHORTENED_LOCAL_NAME,
                                     (const uint8_t *)"BLE UART", sizeof("BLE UART") - 1);
    ble.accumulateAdvertisingPayload(GapAdvertisingData::COMPLETE_LIST_128BIT_SERVICE_IDS,
                                     (const uint8_t *)UARTServiceUUID_reversed, sizeof(UARTServiceUUID_reversed));

    ble.setAdvertisingInterval(1000); /* 1000ms; in multiples of 0.625ms. */
    ble.startAdvertising();

    UARTService uartService(ble);
    uartServicePtr = &uartService;

    while (1) {

        ble.waitForEvent();

        //wait_ms(500);

        //RTC
        time_t seconds = time(NULL);

        DEBUG("  Date / Heure = %s\r\n", ctime(&seconds));

        //CO2 / H / T sur Cozir
        co2 = arnsrs.requestCO2();
        Humi = arnsrs.requestHUMI();
        Temp1 = arnsrs.requestTEMP();

        //P / T sur MS5803_14BA
        pression = arnsrs.requestPress();
        Temp2 =  arnsrs.requestTemp();

        //PPO2 sur ADS1015
        ppO2 = arnsrs.requestPpO2(false);

        //Affichage sur moniteur série
        DEBUG("  CO2           = %d\r\n"  , co2);
        DEBUG("  Humidite      = %f\r\n"  , Humi);
        DEBUG("  Temperature   = %f\r\n"  ,Temp1);
        //P / T sur MS5803
        DEBUG("  Pression      = %f\r\n", pression);
        DEBUG("  Temperature   = %f\r\n", Temp2);
        //PPO2 sur ADS1015
        DEBUG("  PPO2          = %d\r\n", ppO2);
        DEBUG("\r\n", "");

        //Traceur
        TRACE("%d"  , co2);
        TRACE(", ");
        TRACE("%d"  , ppO2);
        TRACE(", ");
        TRACE("%f"  , Humi);
        TRACE(", ");
        TRACE("%f"  , Temp1);
        TRACE(", ");
        TRACE("%f"  , Temp2);
        TRACE(", ");
        TRACE("%f"  , pression);
        TRACE("\r\n");
        
        //Data LOG
        if (NEED_SD_DATA_LOG == 1) DATA_LOG();
        
        build_send_Message("t", ppO2, co2, pression);
        build_send_Message("u", Temp1, Temp2, Humi);
        
    }
}