Diff: main.cpp

Revision:

33:31e2feb7bf78

Parent:

31:8b734e4fb89b

--- a/main.cpp	Sat Jul 20 14:03:57 2019 +0000
+++ b/main.cpp	Sat Jul 20 14:04:00 2019 -0300
@@ -4,7 +4,10 @@
 
 #include "CayenneLPP.h"
 
-#define D_LOG(args...)   printf(args) 
+Serial pc(USBTX, USBRX);                    // SAIDA SERIAL PADRÃO
+// #define D_LOG(args...)   pc.printf(args) 
+
+#define ONE_SECOND      1
 
 // LORA WAN CONFIGS 
 #define TX_INTERVAL             10000
@@ -14,87 +17,59 @@
 static uint8_t LORAWAN_APP_EUI[] = { 0x70, 0xB3, 0xD5, 0x7E, 0xD0, 0x01, 0xD0, 0x2F };
 static uint8_t LORAWAN_APP_KEY[] = { 0x75, 0xC6, 0xF2, 0xFB, 0xEE, 0xA9, 0x82, 0x6C, 0xA0, 0xBD, 0xB9, 0x0F, 0xC9, 0xEC, 0xF7, 0x10 };
 
-// static uint32_t DEVADDR_1 = 0x2601177B;
-// static uint8_t NWKSKEY_1[] = { 0x2A, 0xE9, 0x3F, 0x5E, 0x4C, 0x25, 0xDC, 0x34, 0x16, 0x82, 0x1B, 0xD1, 0x1A, 0x7F, 0xD0, 0xF6 };
-// static uint8_t APPSKEY_1[] = { 0x78, 0x59, 0x61, 0xBB, 0x6B, 0xB7, 0xDE, 0x57, 0x80, 0x74, 0xAF, 0xED, 0x10, 0xD7, 0x47, 0x18 };
-
+////////////////////////////////////////////////////////////////
 static void lora_event_handler(lorawan_event_t event);
 static int16_t count_message;
 
-EventQueue ev_queue;
 static lorawan_app_callbacks_t callbacks;
 
 ControlImpl ctrl;
 Communication<LoraData>* comm = NULL;
 
-int test_temperature(Control* control);
-int test_gyroscope(Control* control);
-int test_lorawan(Control* control);
+////////////////////////////////////////////////////////////////
+int inicializa_lorawan(Control* control);
+
+void read_send_gyroscope(void const *self_context);
+void read_send_temperature(void const *self_context);
+void read_send_GPS(void const *self_context);
+void inicializa_thread_GPS(Control* control);
+
+void finalize_sending(Communication<void*>* COMM, CayenneLPP* payload);
+static void receive_message();
+
+// FILAS PARA EVENTOS
+EventQueue ev_queue; // Usado no callback do lora wan
 
 int main() {
     D_LOG("=============== INICIO ===============\r\n");
 
-    int ret = 0;
     Control* control = ctrl.getControler();
     control->initialize();
 
-
-    //////////////////////////////////////////////////////////////////////////
-    // 1 - Test Temnperature ...
-    // ret = test_temperature(control);
+    ////////////////////////////////////////////////////////////////////////// 
+    // 1 - Inicializa o LoRaWAN 
+    inicializa_lorawan(control);
 
-    // 2 - Test Gyroscope ...
-    // ret = test_gyroscope(control);
+    // 2 - Prepara as threads de Temperatura e Gyroscopio 
+    // 2.1 -> A cada 20 Segundos, faz uma leitura de Temperatura e Envia pro LoRaWan 
+    Thread eventTemperature(osPriorityNormal);
+    eventTemperature.start(callback(read_send_temperature, control));
 
-    // 3 - Test LoRaWAN
-    ret = test_lorawan(control);
+    // 2.2 -> Se houver 10 Mudanças no Gyroscopio, ele Aciona o GPS, que fica enviando ao LoRaWan sua localização a cada 10 segundos !!
+    Thread eventTGyroscope(osPriorityNormal);
+    eventTGyroscope.start(callback(read_send_gyroscope, control));
+
     //////////////////////////////////////////////////////////////////////////
     
-    control->finalize();
-    D_LOG("=============== FINAL ===============\r\n");
-    return ret;
-}
-
-int test_temperature(Control* control) {
-    D_LOG("=============== TEMPERATURE ===============\r\n");
-    Sensor<void*>* temp = control->getSensor("Temperature");
+    // make your event queue dispatching events forever
+    wait(osWaitForever); // Para a thread principal aqui ! 
 
-    int count = 0;
-
-    D_LOG("## GET VALUES ....\r\n");
-    while(count++ < 10) {
-        float* valor = (float*)temp->getValue();
-        D_LOG("## Temp -> %f \r\n", *valor);
-        wait(1.0); // espera 1 segundo !
-    }
-
+    control->finalize();
+    D_LOG("=============== FINAL =============== \r\n");
     return 1;
 }
 
-int test_gyroscope(Control* control) {
-    D_LOG("=============== GYROSCOPE ===============\r\n");
-
-    // Sensor<GyroscopeData>* gyro = (Sensor<GyroscopeData>*) control->getSensor("Gyroscope");
-    Sensor<void*>* gyro = control->getSensor("Gyroscope");
-
-    int count = 0;
-
-    D_LOG("## GET VALUES ....\r\n");
-    while(count++ < 10) {
-       GyroscopeData* data = (GyroscopeData*) gyro->getValue();
-
-        printf("Gyro (X) => %d \r\n", data->gx);
-        printf("Gyro (Y) => %d \r\n", data->gy);
-        printf("Gyro (Z) => %d \r\n", data->gz);
-        printf("***********************************\r\n\r\n");
-
-        wait(1); // espera 1 segundo !
-    }
-
-    return 1;
-}
-
-int test_lorawan(Control* control) {
+int inicializa_lorawan(Control* control) {
     D_LOG("=============== LoRaWAN Comunication ===============\r\n");
 
     comm = (Communication<LoraData>*)control->getCommunication("LoRAWAN");
@@ -110,7 +85,7 @@
     connect_params.connection_u.otaa.app_key = LORAWAN_APP_KEY;
     connect_params.connection_u.otaa.nb_trials = 10;
 
-    LoraData* data = new LoraData(&connect_params, (LoRaRadio*)&radio, &ev_queue );
+    LoraData* data = new LoraData(&connect_params, (LoRaRadio*)&radio, &ev_queue);
     callbacks.events = mbed::callback(lora_event_handler);
     data->prepareCallBack(callbacks);
 
@@ -133,10 +108,136 @@
         printf("Connection error, code = %d \r\n", retcode);
         return -1;
     }
+    
+    return 1;
+}
 
-    // make your event queue dispatching events forever
-    ev_queue.dispatch_forever();
-    return 1;
+// --------------------------------------------------------------------------------- //
+void read_send_temperature(void const *self_context) {
+    D_LOG("=============== TEMPERATURE ===============\r\n");
+    Control* control = (Control*)self_context;
+
+    Sensor<void*>* temp = control->getSensor("Temperature");
+    Communication<void*>* COMM = control->getCommunication("LoRAWAN");
+
+    CayenneLPP payload(50);
+
+    while(1) {
+        float* valor = (float*)temp->getValue();
+        D_LOG("TEMPERATURA -> %f\r\n", *valor);
+
+        payload.addTemperature(1, *valor);
+
+        // FINALIZE SENDING ...
+        finalize_sending(COMM, &payload);
+        
+        ThisThread::sleep_for(20* ONE_SECOND); // Espera 20 Segundos !!
+    }
+}
+
+void read_send_gyroscope(void const *self_context) {
+    D_LOG("=============== GYROSCOPE ===============\r\n");
+    Control* control = (Control*)self_context;
+
+    Sensor<void*>* gyro = control->getSensor("Gyroscope");
+    Communication<void*>* COMM = control->getCommunication("LoRAWAN");
+    
+    CayenneLPP payload(100);
+
+    GyroscopeData* dataAnterior = NULL;
+    int repeticoes = 0;
+    bool iniciaGPS = false;
+
+    while(1) {
+        GyroscopeData* data = (GyroscopeData*) gyro->getValue();
+        D_LOG("Gyro (X) => %d \r\n", data->gx);
+        D_LOG("Gyro (Y) => %d \r\n", data->gy);
+        D_LOG("Gyro (Z) => %d \r\n", data->gz);
+        D_LOG("***********************************\r\n\r\n");
+
+        payload.addGyrometer(1, data->gx, data->gy, data->gz);
+
+        // FINALIZE SENDING ...
+        finalize_sending(COMM, &payload);
+
+        if(dataAnterior != NULL && iniciaGPS == false) {
+            if( dataAnterior->gx != data->gx || 
+                dataAnterior->gy != data->gy || 
+                dataAnterior->gz != data->gz ){
+                    if(++repeticoes > 10) {                        
+                        iniciaGPS = true;
+                        inicializa_thread_GPS(control);
+                    }
+            }
+        }
+        dataAnterior = data;
+        
+        ThisThread::sleep_for(10* ONE_SECOND); // Espera 10 Segundos para proxima leitura !!
+    }
+}
+
+void read_send_GPS(void const *self_context) {
+    D_LOG("=================== GPS ==================\r\n");
+    Control* control = (Control*)self_context;
+
+    Sensor<void*>* gps = control->getSensor("GPS");
+    Communication<void*>* COMM = control->getCommunication("LoRAWAN");
+    
+    CayenneLPP payload(100);
+
+    while(1) {
+        GPSData* data = (GPSData*) gps->getValue();
+        D_LOG("GPS (Lat) => %d \r\n", data->latitude);
+        D_LOG("GPS (Long) => %d \r\n", data->longitude);
+        D_LOG("GPS (Meters) => %d \r\n", data->meters);
+        D_LOG("***********************************\r\n\r\n");
+
+        payload.addGPS(1, data->latitude, data->longitude, data->meters);
+
+        // FINALIZE SENDING ...
+        finalize_sending(COMM, &payload);
+        
+        ThisThread::sleep_for(5* ONE_SECOND); // Espera 5 Segundos para proxima leitura !!
+    }
+}
+
+void inicializa_thread_GPS(Control* control) {
+    // 2.2 -> Se houver 10 Mudanças no Gyroscopio, ele Aciona o GPS, que fica enviando ao LoRaWan sua localização a cada 10 segundos !!
+    Thread eventTGPS(osPriorityNormal);
+    eventTGPS.start(callback(read_send_GPS, control));
+}
+
+// --------------------------------------------------------------------------------- //
+void finalize_sending(Communication<void*>* COMM, CayenneLPP* payload) {
+    LoraData* data = (LoraData*) COMM->getData();
+    data->read_write_flags = MSG_UNCONFIRMED_FLAG;
+
+    int16_t retcode = COMM->write(payload->getBuffer(), payload->getSize());
+    D_LOG("lorawan.send = retcode [%d]\n", retcode);
+
+    if (retcode < 0) {
+        retcode == LORAWAN_STATUS_WOULD_BLOCK 
+                        ? D_LOG("send - Duty cycle violation\r\n")
+                        : D_LOG("send() - Error code %d \r\n", retcode);
+                
+        if (retcode == LORAWAN_STATUS_NO_ACTIVE_SESSIONS)
+            D_LOG("\r\n|-1017 - LORAWAN_STATUS_NO_ACTIVE_SESSIONS"); 
+
+        if (retcode == LORAWAN_STATUS_WOULD_BLOCK) { // Retry in 3 seconds
+            // queue->call_in(3000, send_message); 
+            D_LOG("RETRY FOI REMOVIDO DO LORAWAN !!\r\n");            
+        } else {
+            // queue->call_in(TX_INTERVAL, send_message);
+            D_LOG("Nao re-envia a mensagem !!");
+        }
+
+        return;
+    }
+
+    // TODO: precisa re-enviar ?? queue->call_in(TX_INTERVAL, send_message); [Passar comunicacao/payload denovo ??]
+
+    receive_message();
+    D_LOG("%d bytes scheduled for transmission \r\n", retcode);
 }
 
 /**