Anderson Cunha / Mbed OS sgam_mdw_test

Projeto teste do Programa de integracao com biblioteca SGAM_MDW !! Aqui visa um usuario que usa o projeto implementado para a placa NUCLEO F429ZI

Dependencies:   sgam_mdw sgam_mdw_NUCLEOF429ZI_impl Cayenne-LPP

main.cpp@34:fea430612423, 2019-07-20 (annotated)

Committer:
AndersonIctus
Date:
Sat Jul 20 17:05:34 2019 +0000
Revision:
34:fea430612423
Parent:
33:31e2feb7bf78 
- Exemplo de Monitoramento de ATIVOS !!

Who changed what in which revision?

UserRevisionLine numberNew contents of line
AndersonIctus 12:2109a8bc8848 1 #include "mbed.h"
AndersonIctus 7:cabeef41022a 2 #include "sgam_mdw.h"
AndersonIctus 31:8b734e4fb89b 3 #include "sgam_mdw_impl.h"
AndersonIctus 10:cb7a807b5225 4
AndersonIctus 28:18a54c786ba9 5 #include "CayenneLPP.h"
AndersonIctus 28:18a54c786ba9 6
AndersonIctus 33:31e2feb7bf78 7 Serial pc(USBTX, USBRX); // SAIDA SERIAL PADRÃO
AndersonIctus 33:31e2feb7bf78 8 // #define D_LOG(args...) pc.printf(args)
AndersonIctus 33:31e2feb7bf78 9
AndersonIctus 33:31e2feb7bf78 10 #define ONE_SECOND 1
AndersonIctus 12:2109a8bc8848 11
AndersonIctus 14:8ec6bdff6f67 12 // LORA WAN CONFIGS
AndersonIctus 14:8ec6bdff6f67 13 #define TX_INTERVAL 10000
AndersonIctus 14:8ec6bdff6f67 14 #define MBED_CONF_LORA_APP_PORT 15 //15
AndersonIctus 14:8ec6bdff6f67 15
AndersonIctus 14:8ec6bdff6f67 16 static uint8_t LORAWAN_DEV_EUI[] = { 0x00, 0x1C, 0x73, 0x4A, 0x55, 0x89, 0xAE, 0xC6 };
AndersonIctus 14:8ec6bdff6f67 17 static uint8_t LORAWAN_APP_EUI[] = { 0x70, 0xB3, 0xD5, 0x7E, 0xD0, 0x01, 0xD0, 0x2F };
AndersonIctus 14:8ec6bdff6f67 18 static uint8_t LORAWAN_APP_KEY[] = { 0x75, 0xC6, 0xF2, 0xFB, 0xEE, 0xA9, 0x82, 0x6C, 0xA0, 0xBD, 0xB9, 0x0F, 0xC9, 0xEC, 0xF7, 0x10 };
AndersonIctus 14:8ec6bdff6f67 19
AndersonIctus 33:31e2feb7bf78 20 ////////////////////////////////////////////////////////////////
AndersonIctus 16:2b3715dd0f13 21 static void lora_event_handler(lorawan_event_t event);
AndersonIctus 16:2b3715dd0f13 22 static int16_t count_message;
AndersonIctus 14:8ec6bdff6f67 23
AndersonIctus 17:579f6353c6fb 24 static lorawan_app_callbacks_t callbacks;
AndersonIctus 17:579f6353c6fb 25
AndersonIctus 29:8251bb11d117 26 ControlImpl ctrl;
AndersonIctus 20:b25436619b59 27 Communication<LoraData>* comm = NULL;
AndersonIctus 20:b25436619b59 28
AndersonIctus 33:31e2feb7bf78 29 ////////////////////////////////////////////////////////////////
AndersonIctus 33:31e2feb7bf78 30 int inicializa_lorawan(Control* control);
AndersonIctus 33:31e2feb7bf78 31
AndersonIctus 33:31e2feb7bf78 32 void read_send_gyroscope(void const *self_context);
AndersonIctus 33:31e2feb7bf78 33 void read_send_temperature(void const *self_context);
AndersonIctus 33:31e2feb7bf78 34 void read_send_GPS(void const *self_context);
AndersonIctus 33:31e2feb7bf78 35 void inicializa_thread_GPS(Control* control);
AndersonIctus 33:31e2feb7bf78 36
AndersonIctus 33:31e2feb7bf78 37 void finalize_sending(Communication<void*>* COMM, CayenneLPP* payload);
AndersonIctus 33:31e2feb7bf78 38 static void receive_message();
AndersonIctus 33:31e2feb7bf78 39
AndersonIctus 33:31e2feb7bf78 40 // FILAS PARA EVENTOS
AndersonIctus 33:31e2feb7bf78 41 EventQueue ev_queue; // Usado no callback do lora wan
AndersonIctus 29:8251bb11d117 42
AndersonIctus 0:5d86284beacd 43 int main() {
AndersonIctus 12:2109a8bc8848 44 D_LOG("=============== INICIO ===============\r\n");
AndersonIctus 7:cabeef41022a 45
AndersonIctus 7:cabeef41022a 46 Control* control = ctrl.getControler();
AndersonIctus 12:2109a8bc8848 47 control->initialize();
AndersonIctus 7:cabeef41022a 48
AndersonIctus 33:31e2feb7bf78 49 //////////////////////////////////////////////////////////////////////////
AndersonIctus 33:31e2feb7bf78 50 // 1 - Inicializa o LoRaWAN
AndersonIctus 33:31e2feb7bf78 51 inicializa_lorawan(control);
AndersonIctus 29:8251bb11d117 52
AndersonIctus 33:31e2feb7bf78 53 // 2 - Prepara as threads de Temperatura e Gyroscopio
AndersonIctus 33:31e2feb7bf78 54 // 2.1 -> A cada 20 Segundos, faz uma leitura de Temperatura e Envia pro LoRaWan
AndersonIctus 33:31e2feb7bf78 55 Thread eventTemperature(osPriorityNormal);
AndersonIctus 33:31e2feb7bf78 56 eventTemperature.start(callback(read_send_temperature, control));
AndersonIctus 29:8251bb11d117 57
AndersonIctus 33:31e2feb7bf78 58 // 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 !!
AndersonIctus 33:31e2feb7bf78 59 Thread eventTGyroscope(osPriorityNormal);
AndersonIctus 33:31e2feb7bf78 60 eventTGyroscope.start(callback(read_send_gyroscope, control));
AndersonIctus 33:31e2feb7bf78 61
AndersonIctus 29:8251bb11d117 62 //////////////////////////////////////////////////////////////////////////
AndersonIctus 29:8251bb11d117 63
AndersonIctus 33:31e2feb7bf78 64 // make your event queue dispatching events forever
AndersonIctus 33:31e2feb7bf78 65 wait(osWaitForever); // Para a thread principal aqui !
AndersonIctus 29:8251bb11d117 66
AndersonIctus 33:31e2feb7bf78 67 control->finalize();
AndersonIctus 33:31e2feb7bf78 68 D_LOG("=============== FINAL =============== \r\n");
AndersonIctus 29:8251bb11d117 69 return 1;
AndersonIctus 29:8251bb11d117 70 }
AndersonIctus 29:8251bb11d117 71
AndersonIctus 33:31e2feb7bf78 72 int inicializa_lorawan(Control* control) {
AndersonIctus 29:8251bb11d117 73 D_LOG("=============== LoRaWAN Comunication ===============\r\n");
AndersonIctus 29:8251bb11d117 74
AndersonIctus 20:b25436619b59 75 comm = (Communication<LoraData>*)control->getCommunication("LoRAWAN");
AndersonIctus 14:8ec6bdff6f67 76
AndersonIctus 16:2b3715dd0f13 77 ////////////////////////////////////////////////////////////////////////////////////////////
AndersonIctus 17:579f6353c6fb 78 // 1 - Configura os callbacks do loran WAN e inicializa os dados !!
AndersonIctus 17:579f6353c6fb 79 // Dados de Conexão
AndersonIctus 17:579f6353c6fb 80 lorawan_connect_t connect_params;
AndersonIctus 17:579f6353c6fb 81 connect_params.connect_type = LORAWAN_CONNECTION_OTAA;
AndersonIctus 10:cb7a807b5225 82
AndersonIctus 17:579f6353c6fb 83 connect_params.connection_u.otaa.dev_eui = LORAWAN_DEV_EUI;
AndersonIctus 17:579f6353c6fb 84 connect_params.connection_u.otaa.app_eui = LORAWAN_APP_EUI;
AndersonIctus 17:579f6353c6fb 85 connect_params.connection_u.otaa.app_key = LORAWAN_APP_KEY;
AndersonIctus 17:579f6353c6fb 86 connect_params.connection_u.otaa.nb_trials = 10;
AndersonIctus 14:8ec6bdff6f67 87
AndersonIctus 33:31e2feb7bf78 88 LoraData* data = new LoraData(&connect_params, (LoRaRadio*)&radio, &ev_queue);
AndersonIctus 17:579f6353c6fb 89 callbacks.events = mbed::callback(lora_event_handler);
AndersonIctus 17:579f6353c6fb 90 data->prepareCallBack(callbacks);
AndersonIctus 16:2b3715dd0f13 91
AndersonIctus 20:b25436619b59 92 // Flags de leitura !!
AndersonIctus 26:8c55aac7887f 93 data->lora_port = MBED_CONF_LORA_APP_PORT;
AndersonIctus 20:b25436619b59 94
AndersonIctus 17:579f6353c6fb 95 /////////////////////////////////////////////////////////////////////////////////////////////
AndersonIctus 17:579f6353c6fb 96 // 2 - INICIALIZA A CONEXAO
AndersonIctus 17:579f6353c6fb 97 if( comm->initialize(data) != TRUE) {
AndersonIctus 16:2b3715dd0f13 98 D_LOG("Inicialização falhou !!\r\n");
AndersonIctus 16:2b3715dd0f13 99 return -1;
AndersonIctus 16:2b3715dd0f13 100 }
AndersonIctus 7:cabeef41022a 101
AndersonIctus 16:2b3715dd0f13 102 ////////////////////////////////////////////////////////////////////////////////////////////
AndersonIctus 17:579f6353c6fb 103 // 3 - Tentar conectar
AndersonIctus 17:579f6353c6fb 104 lorawan_status_t retcode = (lorawan_status_t) comm->connect();
AndersonIctus 17:579f6353c6fb 105 if (retcode == LORAWAN_STATUS_OK || retcode == LORAWAN_STATUS_CONNECT_IN_PROGRESS) {
AndersonIctus 17:579f6353c6fb 106 printf("Connection - In Progress ...\r\n");
AndersonIctus 17:579f6353c6fb 107 } else {
AndersonIctus 17:579f6353c6fb 108 printf("Connection error, code = %d \r\n", retcode);
AndersonIctus 14:8ec6bdff6f67 109 return -1;
AndersonIctus 21:1a2ecd140da8 110 }
AndersonIctus 33:31e2feb7bf78 111
AndersonIctus 33:31e2feb7bf78 112 return 1;
AndersonIctus 33:31e2feb7bf78 113 }
AndersonIctus 7:cabeef41022a 114
AndersonIctus 33:31e2feb7bf78 115 // --------------------------------------------------------------------------------- //
AndersonIctus 33:31e2feb7bf78 116 void read_send_temperature(void const *self_context) {
AndersonIctus 33:31e2feb7bf78 117 D_LOG("=============== TEMPERATURE ===============\r\n");
AndersonIctus 33:31e2feb7bf78 118 Control* control = (Control*)self_context;
AndersonIctus 33:31e2feb7bf78 119
AndersonIctus 33:31e2feb7bf78 120 Sensor<void*>* temp = control->getSensor("Temperature");
AndersonIctus 33:31e2feb7bf78 121 Communication<void*>* COMM = control->getCommunication("LoRAWAN");
AndersonIctus 33:31e2feb7bf78 122
AndersonIctus 33:31e2feb7bf78 123 CayenneLPP payload(50);
AndersonIctus 33:31e2feb7bf78 124
AndersonIctus 33:31e2feb7bf78 125 while(1) {
AndersonIctus 33:31e2feb7bf78 126 float* valor = (float*)temp->getValue();
AndersonIctus 33:31e2feb7bf78 127 D_LOG("TEMPERATURA -> %f\r\n", *valor);
AndersonIctus 33:31e2feb7bf78 128
AndersonIctus 33:31e2feb7bf78 129 payload.addTemperature(1, *valor);
AndersonIctus 33:31e2feb7bf78 130
AndersonIctus 33:31e2feb7bf78 131 // FINALIZE SENDING ...
AndersonIctus 33:31e2feb7bf78 132 finalize_sending(COMM, &payload);
AndersonIctus 33:31e2feb7bf78 133
AndersonIctus 33:31e2feb7bf78 134 ThisThread::sleep_for(20* ONE_SECOND); // Espera 20 Segundos !!
AndersonIctus 33:31e2feb7bf78 135 }
AndersonIctus 33:31e2feb7bf78 136 }
AndersonIctus 33:31e2feb7bf78 137
AndersonIctus 33:31e2feb7bf78 138 void read_send_gyroscope(void const *self_context) {
AndersonIctus 33:31e2feb7bf78 139 D_LOG("=============== GYROSCOPE ===============\r\n");
AndersonIctus 33:31e2feb7bf78 140 Control* control = (Control*)self_context;
AndersonIctus 33:31e2feb7bf78 141
AndersonIctus 33:31e2feb7bf78 142 Sensor<void*>* gyro = control->getSensor("Gyroscope");
AndersonIctus 33:31e2feb7bf78 143 Communication<void*>* COMM = control->getCommunication("LoRAWAN");
AndersonIctus 33:31e2feb7bf78 144
AndersonIctus 33:31e2feb7bf78 145 CayenneLPP payload(100);
AndersonIctus 33:31e2feb7bf78 146
AndersonIctus 33:31e2feb7bf78 147 GyroscopeData* dataAnterior = NULL;
AndersonIctus 33:31e2feb7bf78 148 int repeticoes = 0;
AndersonIctus 33:31e2feb7bf78 149 bool iniciaGPS = false;
AndersonIctus 33:31e2feb7bf78 150
AndersonIctus 33:31e2feb7bf78 151 while(1) {
AndersonIctus 33:31e2feb7bf78 152 GyroscopeData* data = (GyroscopeData*) gyro->getValue();
AndersonIctus 33:31e2feb7bf78 153 D_LOG("Gyro (X) => %d \r\n", data->gx);
AndersonIctus 33:31e2feb7bf78 154 D_LOG("Gyro (Y) => %d \r\n", data->gy);
AndersonIctus 33:31e2feb7bf78 155 D_LOG("Gyro (Z) => %d \r\n", data->gz);
AndersonIctus 33:31e2feb7bf78 156 D_LOG("***********************************\r\n\r\n");
AndersonIctus 33:31e2feb7bf78 157
AndersonIctus 33:31e2feb7bf78 158 payload.addGyrometer(1, data->gx, data->gy, data->gz);
AndersonIctus 33:31e2feb7bf78 159
AndersonIctus 33:31e2feb7bf78 160 // FINALIZE SENDING ...
AndersonIctus 33:31e2feb7bf78 161 finalize_sending(COMM, &payload);
AndersonIctus 33:31e2feb7bf78 162
AndersonIctus 33:31e2feb7bf78 163 if(dataAnterior != NULL && iniciaGPS == false) {
AndersonIctus 33:31e2feb7bf78 164 if( dataAnterior->gx != data->gx ||
AndersonIctus 33:31e2feb7bf78 165 dataAnterior->gy != data->gy ||
AndersonIctus 33:31e2feb7bf78 166 dataAnterior->gz != data->gz ){
AndersonIctus 33:31e2feb7bf78 167 if(++repeticoes > 10) {
AndersonIctus 33:31e2feb7bf78 168 iniciaGPS = true;
AndersonIctus 33:31e2feb7bf78 169 inicializa_thread_GPS(control);
AndersonIctus 33:31e2feb7bf78 170 }
AndersonIctus 33:31e2feb7bf78 171 }
AndersonIctus 33:31e2feb7bf78 172 }
AndersonIctus 33:31e2feb7bf78 173 dataAnterior = data;
AndersonIctus 33:31e2feb7bf78 174
AndersonIctus 33:31e2feb7bf78 175 ThisThread::sleep_for(10* ONE_SECOND); // Espera 10 Segundos para proxima leitura !!
AndersonIctus 33:31e2feb7bf78 176 }
AndersonIctus 33:31e2feb7bf78 177 }
AndersonIctus 33:31e2feb7bf78 178
AndersonIctus 33:31e2feb7bf78 179 void read_send_GPS(void const *self_context) {
AndersonIctus 33:31e2feb7bf78 180 D_LOG("=================== GPS ==================\r\n");
AndersonIctus 33:31e2feb7bf78 181 Control* control = (Control*)self_context;
AndersonIctus 33:31e2feb7bf78 182
AndersonIctus 33:31e2feb7bf78 183 Sensor<void*>* gps = control->getSensor("GPS");
AndersonIctus 33:31e2feb7bf78 184 Communication<void*>* COMM = control->getCommunication("LoRAWAN");
AndersonIctus 33:31e2feb7bf78 185
AndersonIctus 33:31e2feb7bf78 186 CayenneLPP payload(100);
AndersonIctus 33:31e2feb7bf78 187
AndersonIctus 33:31e2feb7bf78 188 while(1) {
AndersonIctus 33:31e2feb7bf78 189 GPSData* data = (GPSData*) gps->getValue();
AndersonIctus 33:31e2feb7bf78 190 D_LOG("GPS (Lat) => %d \r\n", data->latitude);
AndersonIctus 33:31e2feb7bf78 191 D_LOG("GPS (Long) => %d \r\n", data->longitude);
AndersonIctus 33:31e2feb7bf78 192 D_LOG("GPS (Meters) => %d \r\n", data->meters);
AndersonIctus 33:31e2feb7bf78 193 D_LOG("***********************************\r\n\r\n");
AndersonIctus 33:31e2feb7bf78 194
AndersonIctus 33:31e2feb7bf78 195 payload.addGPS(1, data->latitude, data->longitude, data->meters);
AndersonIctus 33:31e2feb7bf78 196
AndersonIctus 33:31e2feb7bf78 197 // FINALIZE SENDING ...
AndersonIctus 33:31e2feb7bf78 198 finalize_sending(COMM, &payload);
AndersonIctus 33:31e2feb7bf78 199
AndersonIctus 33:31e2feb7bf78 200 ThisThread::sleep_for(5* ONE_SECOND); // Espera 5 Segundos para proxima leitura !!
AndersonIctus 33:31e2feb7bf78 201 }
AndersonIctus 33:31e2feb7bf78 202 }
AndersonIctus 33:31e2feb7bf78 203
AndersonIctus 33:31e2feb7bf78 204 void inicializa_thread_GPS(Control* control) {
AndersonIctus 33:31e2feb7bf78 205 // 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 !!
AndersonIctus 33:31e2feb7bf78 206 Thread eventTGPS(osPriorityNormal);
AndersonIctus 33:31e2feb7bf78 207 eventTGPS.start(callback(read_send_GPS, control));
AndersonIctus 33:31e2feb7bf78 208 }
AndersonIctus 33:31e2feb7bf78 209
AndersonIctus 33:31e2feb7bf78 210 // --------------------------------------------------------------------------------- //
AndersonIctus 33:31e2feb7bf78 211 void finalize_sending(Communication<void*>* COMM, CayenneLPP* payload) {
AndersonIctus 33:31e2feb7bf78 212 LoraData* data = (LoraData*) COMM->getData();
AndersonIctus 33:31e2feb7bf78 213 data->read_write_flags = MSG_UNCONFIRMED_FLAG;
AndersonIctus 33:31e2feb7bf78 214
AndersonIctus 33:31e2feb7bf78 215 int16_t retcode = COMM->write(payload->getBuffer(), payload->getSize());
AndersonIctus 33:31e2feb7bf78 216 D_LOG("lorawan.send = retcode [%d]\n", retcode);
AndersonIctus 33:31e2feb7bf78 217
AndersonIctus 33:31e2feb7bf78 218 if (retcode < 0) {
AndersonIctus 33:31e2feb7bf78 219 retcode == LORAWAN_STATUS_WOULD_BLOCK
AndersonIctus 33:31e2feb7bf78 220 ? D_LOG("send - Duty cycle violation\r\n")
AndersonIctus 33:31e2feb7bf78 221 : D_LOG("send() - Error code %d \r\n", retcode);
AndersonIctus 33:31e2feb7bf78 222
AndersonIctus 33:31e2feb7bf78 223 if (retcode == LORAWAN_STATUS_NO_ACTIVE_SESSIONS)
AndersonIctus 33:31e2feb7bf78 224 D_LOG("\r\n|-1017 - LORAWAN_STATUS_NO_ACTIVE_SESSIONS");
AndersonIctus 33:31e2feb7bf78 225
AndersonIctus 33:31e2feb7bf78 226 if (retcode == LORAWAN_STATUS_WOULD_BLOCK) { // Retry in 3 seconds
AndersonIctus 33:31e2feb7bf78 227 // queue->call_in(3000, send_message);
AndersonIctus 33:31e2feb7bf78 228 D_LOG("RETRY FOI REMOVIDO DO LORAWAN !!\r\n");
AndersonIctus 33:31e2feb7bf78 229 } else {
AndersonIctus 33:31e2feb7bf78 230 // queue->call_in(TX_INTERVAL, send_message);
AndersonIctus 33:31e2feb7bf78 231 D_LOG("Nao re-envia a mensagem !!");
AndersonIctus 33:31e2feb7bf78 232 }
AndersonIctus 33:31e2feb7bf78 233
AndersonIctus 33:31e2feb7bf78 234 return;
AndersonIctus 33:31e2feb7bf78 235 }
AndersonIctus 33:31e2feb7bf78 236
AndersonIctus 33:31e2feb7bf78 237 // TODO: precisa re-enviar ?? queue->call_in(TX_INTERVAL, send_message); [Passar comunicacao/payload denovo ??]
AndersonIctus 33:31e2feb7bf78 238
AndersonIctus 33:31e2feb7bf78 239 receive_message();
AndersonIctus 33:31e2feb7bf78 240 D_LOG("%d bytes scheduled for transmission \r\n", retcode);
AndersonIctus 0:5d86284beacd 241 }
AndersonIctus 16:2b3715dd0f13 242
AndersonIctus 16:2b3715dd0f13 243 /**
AndersonIctus 16:2b3715dd0f13 244 * Receive a message from the Network Server
AndersonIctus 16:2b3715dd0f13 245 */
AndersonIctus 16:2b3715dd0f13 246 static void receive_message()
AndersonIctus 16:2b3715dd0f13 247 {
AndersonIctus 16:2b3715dd0f13 248 printf("receive_message()\n");
AndersonIctus 16:2b3715dd0f13 249
AndersonIctus 26:8c55aac7887f 250 LoraData* data = (LoraData*) comm->getData();
AndersonIctus 26:8c55aac7887f 251 data->read_write_flags = MSG_CONFIRMED_FLAG|MSG_UNCONFIRMED_FLAG;
AndersonIctus 26:8c55aac7887f 252
AndersonIctus 20:b25436619b59 253 uint8_t rx_buffer[50] = { 0 };
AndersonIctus 20:b25436619b59 254 int16_t retcode = comm->read( rx_buffer, sizeof(rx_buffer) );
AndersonIctus 20:b25436619b59 255 if (retcode < 0) {
AndersonIctus 20:b25436619b59 256 printf("receive() - Error code %d \r\n", retcode);
AndersonIctus 20:b25436619b59 257 return;
AndersonIctus 20:b25436619b59 258 }
AndersonIctus 16:2b3715dd0f13 259
AndersonIctus 20:b25436619b59 260 printf("RX Data (%d bytes): ", retcode);
AndersonIctus 20:b25436619b59 261 for (uint8_t i = 0; i < retcode; i++) {
AndersonIctus 20:b25436619b59 262 printf("%02x ", rx_buffer[i]);
AndersonIctus 20:b25436619b59 263 }
AndersonIctus 16:2b3715dd0f13 264
AndersonIctus 16:2b3715dd0f13 265 printf("\r\n");
AndersonIctus 16:2b3715dd0f13 266 }
AndersonIctus 16:2b3715dd0f13 267
AndersonIctus 16:2b3715dd0f13 268 /**
AndersonIctus 16:2b3715dd0f13 269 * Sends a message to the Network Server
AndersonIctus 16:2b3715dd0f13 270 */
AndersonIctus 16:2b3715dd0f13 271 static void send_message() {
AndersonIctus 20:b25436619b59 272 printf("send_message()\n");
AndersonIctus 16:2b3715dd0f13 273
AndersonIctus 16:2b3715dd0f13 274 // YOUR CODE HERE
AndersonIctus 26:8c55aac7887f 275 int16_t temperature = 10;
AndersonIctus 26:8c55aac7887f 276 printf("temperature = (%d)\n", temperature);
AndersonIctus 20:b25436619b59 277
AndersonIctus 26:8c55aac7887f 278 CayenneLPP payload(50);
AndersonIctus 26:8c55aac7887f 279 payload.addTemperature(1, temperature);
AndersonIctus 20:b25436619b59 280
AndersonIctus 26:8c55aac7887f 281 LoraData* data = (LoraData*) comm->getData();
AndersonIctus 26:8c55aac7887f 282 data->read_write_flags = MSG_UNCONFIRMED_FLAG;
AndersonIctus 16:2b3715dd0f13 283
AndersonIctus 26:8c55aac7887f 284 int16_t retcode = comm->write(payload.getBuffer(), payload.getSize());
AndersonIctus 26:8c55aac7887f 285 printf("lorawan.send = retcode [%d]\n",retcode);
AndersonIctus 26:8c55aac7887f 286
AndersonIctus 26:8c55aac7887f 287 if (retcode < 0) {
AndersonIctus 26:8c55aac7887f 288 retcode == LORAWAN_STATUS_WOULD_BLOCK
AndersonIctus 26:8c55aac7887f 289 ? printf("send - Duty cycle violation\r\n")
AndersonIctus 26:8c55aac7887f 290 : printf("send() - Error code %d \r\n", retcode);
AndersonIctus 16:2b3715dd0f13 291
AndersonIctus 26:8c55aac7887f 292 if (retcode == LORAWAN_STATUS_NO_ACTIVE_SESSIONS)
AndersonIctus 26:8c55aac7887f 293 printf("\r\n|-1017 - LORAWAN_STATUS_NO_ACTIVE_SESSIONS");
AndersonIctus 16:2b3715dd0f13 294
AndersonIctus 26:8c55aac7887f 295 if (retcode == LORAWAN_STATUS_WOULD_BLOCK) { //retry in 3 seconds
AndersonIctus 26:8c55aac7887f 296 ev_queue.call_in(3000, send_message);
AndersonIctus 26:8c55aac7887f 297 } else {
AndersonIctus 26:8c55aac7887f 298 ev_queue.call_in(TX_INTERVAL, send_message);
AndersonIctus 26:8c55aac7887f 299 }
AndersonIctus 20:b25436619b59 300
AndersonIctus 26:8c55aac7887f 301 return;
AndersonIctus 26:8c55aac7887f 302 }
AndersonIctus 16:2b3715dd0f13 303
AndersonIctus 26:8c55aac7887f 304 ev_queue.call_in(TX_INTERVAL, send_message);
AndersonIctus 16:2b3715dd0f13 305
AndersonIctus 26:8c55aac7887f 306 receive_message();
AndersonIctus 26:8c55aac7887f 307 printf("%d bytes scheduled for transmission \r\n", retcode);
AndersonIctus 16:2b3715dd0f13 308 }
AndersonIctus 16:2b3715dd0f13 309
AndersonIctus 16:2b3715dd0f13 310 /**
AndersonIctus 16:2b3715dd0f13 311 * Event handler
AndersonIctus 16:2b3715dd0f13 312 */
AndersonIctus 20:b25436619b59 313 static void lora_event_handler(lorawan_event_t event) {
AndersonIctus 20:b25436619b59 314 switch (event) {
AndersonIctus 20:b25436619b59 315 case CONNECTED:
AndersonIctus 20:b25436619b59 316 printf("# Connection - Successful \r\n");
AndersonIctus 20:b25436619b59 317 if (MBED_CONF_LORA_DUTY_CYCLE_ON) {
AndersonIctus 20:b25436619b59 318 send_message();
AndersonIctus 20:b25436619b59 319 } else {
AndersonIctus 20:b25436619b59 320 ev_queue.call_in(TX_INTERVAL, send_message);
AndersonIctus 20:b25436619b59 321 }
AndersonIctus 20:b25436619b59 322 break;
AndersonIctus 16:2b3715dd0f13 323
AndersonIctus 20:b25436619b59 324 case DISCONNECTED:
AndersonIctus 20:b25436619b59 325 ev_queue.break_dispatch();
AndersonIctus 20:b25436619b59 326 printf("# Disconnected Successfully \r\n");
AndersonIctus 20:b25436619b59 327 break;
AndersonIctus 20:b25436619b59 328 case RX_DONE:
AndersonIctus 20:b25436619b59 329 printf("# Received message from Network Server \r\n");
AndersonIctus 20:b25436619b59 330 receive_message();
AndersonIctus 20:b25436619b59 331 break;
AndersonIctus 20:b25436619b59 332 case RX_TIMEOUT:
AndersonIctus 20:b25436619b59 333 case RX_ERROR:
AndersonIctus 20:b25436619b59 334 printf("# Error in reception - Code = %d \r\n", event);
AndersonIctus 20:b25436619b59 335 break;
AndersonIctus 20:b25436619b59 336 case TX_DONE:
AndersonIctus 20:b25436619b59 337 count_message++;
AndersonIctus 20:b25436619b59 338 printf("# Message Sent to Network Server - Count [%d] \r\n", count_message);
AndersonIctus 20:b25436619b59 339 break;
AndersonIctus 20:b25436619b59 340 case TX_TIMEOUT:
AndersonIctus 20:b25436619b59 341 case TX_ERROR:
AndersonIctus 20:b25436619b59 342 case TX_CRYPTO_ERROR:
AndersonIctus 20:b25436619b59 343 case TX_SCHEDULING_ERROR:
AndersonIctus 20:b25436619b59 344 printf("# Transmission Error - EventCode = %d \r\n", event);
AndersonIctus 20:b25436619b59 345 break;
AndersonIctus 20:b25436619b59 346 case JOIN_FAILURE:
AndersonIctus 20:b25436619b59 347 printf("# OTAA Failed - Check Keys \r\n");
AndersonIctus 20:b25436619b59 348 break;
AndersonIctus 20:b25436619b59 349 case UPLINK_REQUIRED:
AndersonIctus 20:b25436619b59 350 printf("# Uplink required by NS \r\n");
AndersonIctus 20:b25436619b59 351 send_message();
AndersonIctus 20:b25436619b59 352 break;
AndersonIctus 20:b25436619b59 353 default:
AndersonIctus 20:b25436619b59 354 printf("# Unknown Event \r\n");
AndersonIctus 20:b25436619b59 355 // MBED_ASSERT("# Unknown Event");
AndersonIctus 20:b25436619b59 356 }
AndersonIctus 16:2b3715dd0f13 357 }