Future Electronics / Mbed OS sequana-lorawan-lab2

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

main.cpp@59:c3aa24e36354, 2019-11-21 (annotated)

Committer:
lru
Date:
Thu Nov 21 18:00:40 2019 +0000
Revision:
59:c3aa24e36354
Parent:
56:39847849d219
Child:
60:4b5ab8ab1353
Initial version.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 0:7037ed05f54f 1 /**
mbed_official 0:7037ed05f54f 2 * Copyright (c) 2017, Arm Limited and affiliates.
lru 59:c3aa24e36354 3 * Copyright (c) 2019, Future Electronics.
mbed_official 0:7037ed05f54f 4 * SPDX-License-Identifier: Apache-2.0
mbed_official 0:7037ed05f54f 5 *
mbed_official 0:7037ed05f54f 6 * Licensed under the Apache License, Version 2.0 (the "License");
mbed_official 0:7037ed05f54f 7 * you may not use this file except in compliance with the License.
mbed_official 0:7037ed05f54f 8 * You may obtain a copy of the License at
mbed_official 0:7037ed05f54f 9 *
mbed_official 0:7037ed05f54f 10 * http://www.apache.org/licenses/LICENSE-2.0
mbed_official 0:7037ed05f54f 11 *
mbed_official 0:7037ed05f54f 12 * Unless required by applicable law or agreed to in writing, software
mbed_official 0:7037ed05f54f 13 * distributed under the License is distributed on an "AS IS" BASIS,
mbed_official 0:7037ed05f54f 14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
mbed_official 0:7037ed05f54f 15 * See the License for the specific language governing permissions and
mbed_official 0:7037ed05f54f 16 * limitations under the License.
mbed_official 0:7037ed05f54f 17 */
mbed_official 0:7037ed05f54f 18 #include <stdio.h>
mbed_official 3:8c7198d1a2a1 19
mbed_official 0:7037ed05f54f 20 #include "lorawan/LoRaWANInterface.h"
mbed_official 0:7037ed05f54f 21 #include "lorawan/system/lorawan_data_structures.h"
mbed_official 0:7037ed05f54f 22 #include "events/EventQueue.h"
lru 59:c3aa24e36354 23 #include "psoc6_utils.h"
lru 59:c3aa24e36354 24 #include "mbed.h"
mbed_official 0:7037ed05f54f 25
mbed_official 0:7037ed05f54f 26 // Application helpers
mbed_official 0:7037ed05f54f 27 #include "trace_helper.h"
mbed_official 0:7037ed05f54f 28 #include "lora_radio_helper.h"
mbed_official 0:7037ed05f54f 29
lru 59:c3aa24e36354 30 #include "BD2808.h"
lru 59:c3aa24e36354 31
lru 59:c3aa24e36354 32
mbed_official 0:7037ed05f54f 33 using namespace events;
lru 59:c3aa24e36354 34 using namespace mbed;
lru 59:c3aa24e36354 35
mbed_official 0:7037ed05f54f 36
mbed_official 12:5015dfead3f2 37 // Max payload size can be LORAMAC_PHY_MAXPAYLOAD.
mbed_official 12:5015dfead3f2 38 // This example only communicates with much shorter messages (<30 bytes).
mbed_official 12:5015dfead3f2 39 // If longer messages are used, these buffers must be changed accordingly.
mbed_official 12:5015dfead3f2 40 uint8_t tx_buffer[30];
mbed_official 12:5015dfead3f2 41 uint8_t rx_buffer[30];
mbed_official 0:7037ed05f54f 42
mbed_official 0:7037ed05f54f 43
mbed_official 0:7037ed05f54f 44 /**
mbed_official 0:7037ed05f54f 45 * Maximum number of events for the event queue.
mbed_official 12:5015dfead3f2 46 * 10 is the safe number for the stack events, however, if application
mbed_official 0:7037ed05f54f 47 * also uses the queue for whatever purposes, this number should be increased.
mbed_official 0:7037ed05f54f 48 */
lru 59:c3aa24e36354 49 #define MAX_NUMBER_OF_EVENTS 30
mbed_official 0:7037ed05f54f 50
mbed_official 0:7037ed05f54f 51 /**
mbed_official 0:7037ed05f54f 52 * Maximum number of retries for CONFIRMED messages before giving up
mbed_official 0:7037ed05f54f 53 */
mbed_official 0:7037ed05f54f 54 #define CONFIRMED_MSG_RETRY_COUNTER 3
mbed_official 0:7037ed05f54f 55
mbed_official 0:7037ed05f54f 56 /**
mbed_official 0:7037ed05f54f 57 * This event queue is the global event queue for both the
mbed_official 0:7037ed05f54f 58 * application and stack. To conserve memory, the stack is designed to run
mbed_official 0:7037ed05f54f 59 * in the same thread as the application and the application is responsible for
mbed_official 0:7037ed05f54f 60 * providing an event queue to the stack that will be used for ISR deferment as
mbed_official 0:7037ed05f54f 61 * well as application information event queuing.
mbed_official 0:7037ed05f54f 62 */
mbed_official 46:a124538e2891 63 static EventQueue ev_queue(MAX_NUMBER_OF_EVENTS *EVENTS_EVENT_SIZE);
mbed_official 0:7037ed05f54f 64
mbed_official 0:7037ed05f54f 65 /**
mbed_official 0:7037ed05f54f 66 * Event handler.
mbed_official 0:7037ed05f54f 67 *
mbed_official 0:7037ed05f54f 68 * This will be passed to the LoRaWAN stack to queue events for the
mbed_official 0:7037ed05f54f 69 * application which in turn drive the application.
mbed_official 0:7037ed05f54f 70 */
mbed_official 0:7037ed05f54f 71 static void lora_event_handler(lorawan_event_t event);
mbed_official 0:7037ed05f54f 72
mbed_official 0:7037ed05f54f 73 /**
mbed_official 46:a124538e2891 74 * Constructing Mbed LoRaWANInterface and passing it the radio object from lora_radio_helper.
mbed_official 0:7037ed05f54f 75 */
mbed_official 2:dc95ac6d6d4e 76 static LoRaWANInterface lorawan(radio);
mbed_official 0:7037ed05f54f 77
mbed_official 0:7037ed05f54f 78 /**
mbed_official 0:7037ed05f54f 79 * Application specific callbacks
mbed_official 0:7037ed05f54f 80 */
mbed_official 0:7037ed05f54f 81 static lorawan_app_callbacks_t callbacks;
mbed_official 0:7037ed05f54f 82
lru 59:c3aa24e36354 83
lru 59:c3aa24e36354 84 typedef enum {
lru 59:c3aa24e36354 85 DUMMY_MESSAGE,
lru 59:c3aa24e36354 86 SWITCH_MESSAGE
lru 59:c3aa24e36354 87 } message_type_t;
lru 59:c3aa24e36354 88
lru 59:c3aa24e36354 89 /**
lru 59:c3aa24e36354 90 * Button switch processing handler.
lru 59:c3aa24e36354 91 */
lru 59:c3aa24e36354 92 static void button_handler(void);
lru 59:c3aa24e36354 93
lru 59:c3aa24e36354 94 static void send_message(message_type_t type);
lru 59:c3aa24e36354 95
lru 59:c3aa24e36354 96
lru 59:c3aa24e36354 97
lru 59:c3aa24e36354 98 Timer g_timer;
lru 59:c3aa24e36354 99 DigitalOut led(LED1);
lru 59:c3aa24e36354 100 DigitalIn button1(BUTTON1);
lru 59:c3aa24e36354 101 BD2808 leds;
lru 59:c3aa24e36354 102
lru 59:c3aa24e36354 103 bool frame_send = false;
lru 59:c3aa24e36354 104 bool is_connected = false;
lru 59:c3aa24e36354 105 bool tx_in_progress = false;
lru 59:c3aa24e36354 106 uint8_t power_on = 0;
lru 59:c3aa24e36354 107 uint8_t msg_id = 0;
lru 59:c3aa24e36354 108 uint32_t delay_counter = 0;
lru 59:c3aa24e36354 109
lru 59:c3aa24e36354 110 static uint32_t const INTER_FRAME_DELAY = 10;
lru 59:c3aa24e36354 111
lru 59:c3aa24e36354 112 //static const uint8_t target_device_eui[] = MBED_CONF_APP_TARGET_DEVICE_EUI;
lru 59:c3aa24e36354 113 static const uint8_t target_device_eui[] = { 0x00, 0xa0, 0x50, 0xff, 0xfe, 0x81, 0x27, 0x95 };
lru 59:c3aa24e36354 114
lru 59:c3aa24e36354 115 /**
lru 59:c3aa24e36354 116 * Helper routine to set RGB LEDs to specific color.
lru 59:c3aa24e36354 117 */
lru 59:c3aa24e36354 118 static void leds_set(uint8_t red, uint8_t green, uint8_t blue)
lru 59:c3aa24e36354 119 {
lru 59:c3aa24e36354 120 for (int i = 0; i < 8; ++i) {
lru 59:c3aa24e36354 121 leds.set_color(i, BGR24_color_t(blue, green, red));
lru 59:c3aa24e36354 122 }
lru 59:c3aa24e36354 123 leds.refresh();
lru 59:c3aa24e36354 124 }
lru 59:c3aa24e36354 125
lru 59:c3aa24e36354 126
lru 59:c3aa24e36354 127 static void timer_one_sec(void)
lru 59:c3aa24e36354 128 {
lru 59:c3aa24e36354 129 if (is_connected) {
lru 59:c3aa24e36354 130 if (!tx_in_progress) {
lru 59:c3aa24e36354 131 led = 1;
lru 59:c3aa24e36354 132 ThisThread::sleep_for(40);
lru 59:c3aa24e36354 133 led = 0;
lru 59:c3aa24e36354 134 --delay_counter;
lru 59:c3aa24e36354 135 if (delay_counter == 0) {
lru 59:c3aa24e36354 136 delay_counter = INTER_FRAME_DELAY;
lru 59:c3aa24e36354 137 send_message(DUMMY_MESSAGE);
lru 59:c3aa24e36354 138 }
lru 59:c3aa24e36354 139 }
lru 59:c3aa24e36354 140 } else {
lru 59:c3aa24e36354 141 }
lru 59:c3aa24e36354 142 }
lru 59:c3aa24e36354 143
lru 59:c3aa24e36354 144
mbed_official 0:7037ed05f54f 145 /**
mbed_official 0:7037ed05f54f 146 * Entry point for application
mbed_official 0:7037ed05f54f 147 */
mbed_official 46:a124538e2891 148 int main(void)
mbed_official 0:7037ed05f54f 149 {
lru 59:c3aa24e36354 150 static uint8_t mac_address[6];
lru 59:c3aa24e36354 151 static uint8_t device_eui[8] = {0x00, 0x00, 0x00, 0xff, 0xfe, 0x00, 0x00, 0x00};
lru 59:c3aa24e36354 152 static const uint8_t application_eui[] = MBED_CONF_LORA_APPLICATION_EUI;
lru 59:c3aa24e36354 153 static const uint8_t application_key[] = MBED_CONF_LORA_APPLICATION_KEY;
lru 59:c3aa24e36354 154 static lorawan_connect_t connect_params = {
lru 59:c3aa24e36354 155 .connect_type = LORAWAN_CONNECTION_OTAA,
lru 59:c3aa24e36354 156 };
lru 59:c3aa24e36354 157
lru 59:c3aa24e36354 158 leds.set_dma_usage(DMA_USAGE_ALWAYS);
lru 59:c3aa24e36354 159
mbed_official 0:7037ed05f54f 160 // setup tracing
mbed_official 0:7037ed05f54f 161 setup_trace();
mbed_official 0:7037ed05f54f 162
mbed_official 0:7037ed05f54f 163 // stores the status of a call to LoRaWAN protocol
mbed_official 0:7037ed05f54f 164 lorawan_status_t retcode;
mbed_official 0:7037ed05f54f 165
lru 59:c3aa24e36354 166 // Create unique, hardware-dependent EUI.
lru 59:c3aa24e36354 167 cy_get_bd_mac_address(mac_address);
lru 59:c3aa24e36354 168 // MAC address is in reverse sequence.
lru 59:c3aa24e36354 169 for (int i = 0; i < 3; ++i) {
lru 59:c3aa24e36354 170 device_eui[i] = mac_address[5 - i];
lru 59:c3aa24e36354 171 device_eui[i + 5] = mac_address[2 - i];
lru 59:c3aa24e36354 172 }
lru 59:c3aa24e36354 173 printf("\r\nDevice EUI is %02X", device_eui[0]);
lru 59:c3aa24e36354 174 for (int i = 1; i < 8; ++i) {
lru 59:c3aa24e36354 175 printf(":%02X", device_eui[i]);
lru 59:c3aa24e36354 176 }
lru 59:c3aa24e36354 177 printf(" [ ");
lru 59:c3aa24e36354 178 for (int i = 0; i < 8; ++i) {
lru 59:c3aa24e36354 179 printf("%02x", device_eui[i]);
lru 59:c3aa24e36354 180 }
lru 59:c3aa24e36354 181 printf(" ]\r\n");
lru 59:c3aa24e36354 182
mbed_official 0:7037ed05f54f 183 // Initialize LoRaWAN stack
mbed_official 2:dc95ac6d6d4e 184 if (lorawan.initialize(&ev_queue) != LORAWAN_STATUS_OK) {
mbed_official 0:7037ed05f54f 185 printf("\r\n LoRa initialization failed! \r\n");
mbed_official 0:7037ed05f54f 186 return -1;
mbed_official 0:7037ed05f54f 187 }
mbed_official 0:7037ed05f54f 188
mbed_official 0:7037ed05f54f 189 printf("\r\n Mbed LoRaWANStack initialized \r\n");
mbed_official 0:7037ed05f54f 190
mbed_official 0:7037ed05f54f 191 // prepare application callbacks
mbed_official 0:7037ed05f54f 192 callbacks.events = mbed::callback(lora_event_handler);
mbed_official 2:dc95ac6d6d4e 193 lorawan.add_app_callbacks(&callbacks);
mbed_official 0:7037ed05f54f 194
mbed_official 0:7037ed05f54f 195 // Set number of retries in case of CONFIRMED messages
mbed_official 2:dc95ac6d6d4e 196 if (lorawan.set_confirmed_msg_retries(CONFIRMED_MSG_RETRY_COUNTER)
mbed_official 46:a124538e2891 197 != LORAWAN_STATUS_OK) {
mbed_official 0:7037ed05f54f 198 printf("\r\n set_confirmed_msg_retries failed! \r\n\r\n");
mbed_official 0:7037ed05f54f 199 return -1;
mbed_official 0:7037ed05f54f 200 }
mbed_official 0:7037ed05f54f 201
mbed_official 0:7037ed05f54f 202 printf("\r\n CONFIRMED message retries : %d \r\n",
mbed_official 0:7037ed05f54f 203 CONFIRMED_MSG_RETRY_COUNTER);
mbed_official 0:7037ed05f54f 204
mbed_official 0:7037ed05f54f 205 // Enable adaptive data rate
mbed_official 2:dc95ac6d6d4e 206 if (lorawan.enable_adaptive_datarate() != LORAWAN_STATUS_OK) {
mbed_official 0:7037ed05f54f 207 printf("\r\n enable_adaptive_datarate failed! \r\n");
mbed_official 0:7037ed05f54f 208 return -1;
mbed_official 0:7037ed05f54f 209 }
mbed_official 0:7037ed05f54f 210
mbed_official 0:7037ed05f54f 211 printf("\r\n Adaptive data rate (ADR) - Enabled \r\n");
mbed_official 0:7037ed05f54f 212
lru 59:c3aa24e36354 213 // Specify class C
lru 59:c3aa24e36354 214 if (lorawan.set_device_class(CLASS_C) != LORAWAN_STATUS_OK) {
lru 59:c3aa24e36354 215 printf("\r\n setting class C failed! \r\n");
lru 59:c3aa24e36354 216 return -1;
lru 59:c3aa24e36354 217 }
lru 59:c3aa24e36354 218
lru 59:c3aa24e36354 219 printf("\r\n Class C - Enabled \r\n");
lru 59:c3aa24e36354 220
lru 59:c3aa24e36354 221 connect_params.connection_u.otaa.dev_eui = device_eui;
lru 59:c3aa24e36354 222 connect_params.connection_u.otaa.app_eui = const_cast<uint8_t *>(application_eui);
lru 59:c3aa24e36354 223 connect_params.connection_u.otaa.app_key = const_cast<uint8_t *>(application_key);
lru 59:c3aa24e36354 224 connect_params.connection_u.otaa.nb_trials = MBED_CONF_LORA_NB_TRIALS;
lru 59:c3aa24e36354 225
lru 59:c3aa24e36354 226 g_timer.start();
lru 59:c3aa24e36354 227
lru 59:c3aa24e36354 228 retcode = lorawan.connect(connect_params);
mbed_official 0:7037ed05f54f 229
mbed_official 0:7037ed05f54f 230 if (retcode == LORAWAN_STATUS_OK ||
mbed_official 46:a124538e2891 231 retcode == LORAWAN_STATUS_CONNECT_IN_PROGRESS) {
mbed_official 0:7037ed05f54f 232 } else {
mbed_official 0:7037ed05f54f 233 printf("\r\n Connection error, code = %d \r\n", retcode);
mbed_official 0:7037ed05f54f 234 return -1;
mbed_official 0:7037ed05f54f 235 }
mbed_official 0:7037ed05f54f 236
mbed_official 0:7037ed05f54f 237 printf("\r\n Connection - In Progress ...\r\n");
mbed_official 0:7037ed05f54f 238
lru 59:c3aa24e36354 239 // Start button handler; will check button switch every 100ms.
lru 59:c3aa24e36354 240 ev_queue.call_every(100, button_handler);
lru 59:c3aa24e36354 241
lru 59:c3aa24e36354 242 ev_queue.call_every(1000, timer_one_sec);
lru 59:c3aa24e36354 243
mbed_official 0:7037ed05f54f 244 // make your event queue dispatching events forever
mbed_official 0:7037ed05f54f 245 ev_queue.dispatch_forever();
mbed_official 3:8c7198d1a2a1 246
mbed_official 3:8c7198d1a2a1 247 return 0;
mbed_official 0:7037ed05f54f 248 }
mbed_official 0:7037ed05f54f 249
lru 59:c3aa24e36354 250
mbed_official 0:7037ed05f54f 251 /**
mbed_official 0:7037ed05f54f 252 * Sends a message to the Network Server
mbed_official 0:7037ed05f54f 253 */
lru 59:c3aa24e36354 254 static void send_message(message_type_t type)
mbed_official 0:7037ed05f54f 255 {
mbed_official 0:7037ed05f54f 256 uint16_t packet_len;
mbed_official 0:7037ed05f54f 257 int16_t retcode;
lru 59:c3aa24e36354 258 uint8_t port = MBED_CONF_LORA_APP_PORT;
lru 59:c3aa24e36354 259
lru 59:c3aa24e36354 260 printf("\r\n[%8u] Sending message (%d) \r\n", g_timer.read_ms(), msg_id);
mbed_official 0:7037ed05f54f 261
lru 59:c3aa24e36354 262 switch (type) {
lru 59:c3aa24e36354 263 case SWITCH_MESSAGE:
lru 59:c3aa24e36354 264 memcpy(tx_buffer, target_device_eui, 8);
lru 59:c3aa24e36354 265 for (int i = 8; i < 11; ++i) {
lru 59:c3aa24e36354 266 tx_buffer[8] = power_on? 0xf0 : 0x00;
lru 59:c3aa24e36354 267 }
lru 59:c3aa24e36354 268 packet_len = 11;
lru 59:c3aa24e36354 269 break;
lru 59:c3aa24e36354 270
lru 59:c3aa24e36354 271 case DUMMY_MESSAGE:
lru 59:c3aa24e36354 272 tx_buffer[1] = msg_id;
lru 59:c3aa24e36354 273 packet_len = 1;
lru 59:c3aa24e36354 274 port += 1;
mbed_official 0:7037ed05f54f 275 }
mbed_official 0:7037ed05f54f 276
lru 59:c3aa24e36354 277 led = 1;
lru 59:c3aa24e36354 278 tx_in_progress = true;
mbed_official 0:7037ed05f54f 279
lru 59:c3aa24e36354 280 retcode = lorawan.send(port, tx_buffer, packet_len, MSG_UNCONFIRMED_FLAG);
mbed_official 0:7037ed05f54f 281
mbed_official 0:7037ed05f54f 282 if (retcode < 0) {
mbed_official 0:7037ed05f54f 283 retcode == LORAWAN_STATUS_WOULD_BLOCK ? printf("send - WOULD BLOCK\r\n")
mbed_official 46:a124538e2891 284 : printf("\r\n send() - Error code %d \r\n", retcode);
mbed_official 26:f07f5febf97f 285
mbed_official 26:f07f5febf97f 286 if (retcode == LORAWAN_STATUS_WOULD_BLOCK) {
lru 59:c3aa24e36354 287 lorawan.cancel_sending();
lru 59:c3aa24e36354 288 led = 0;
mbed_official 26:f07f5febf97f 289 //retry in 3 seconds
mbed_official 26:f07f5febf97f 290 if (MBED_CONF_LORA_DUTY_CYCLE_ON) {
lru 59:c3aa24e36354 291 ev_queue.call_in(3000, send_message, type);
mbed_official 26:f07f5febf97f 292 }
mbed_official 26:f07f5febf97f 293 }
mbed_official 0:7037ed05f54f 294 return;
mbed_official 0:7037ed05f54f 295 }
mbed_official 0:7037ed05f54f 296
lru 59:c3aa24e36354 297 frame_send = true;
lru 59:c3aa24e36354 298 printf("\r\n[%8u] %d bytes scheduled for transmission \r\n", g_timer.read_ms(), retcode);
mbed_official 12:5015dfead3f2 299 memset(tx_buffer, 0, sizeof(tx_buffer));
mbed_official 0:7037ed05f54f 300 }
mbed_official 0:7037ed05f54f 301
mbed_official 0:7037ed05f54f 302 /**
mbed_official 0:7037ed05f54f 303 * Receive a message from the Network Server
mbed_official 0:7037ed05f54f 304 */
mbed_official 0:7037ed05f54f 305 static void receive_message()
mbed_official 0:7037ed05f54f 306 {
mbed_official 47:b6d132f1079f 307 uint8_t port;
mbed_official 47:b6d132f1079f 308 int flags;
mbed_official 47:b6d132f1079f 309 int16_t retcode = lorawan.receive(rx_buffer, sizeof(rx_buffer), port, flags);
mbed_official 0:7037ed05f54f 310
mbed_official 0:7037ed05f54f 311 if (retcode < 0) {
mbed_official 0:7037ed05f54f 312 printf("\r\n receive() - Error code %d \r\n", retcode);
mbed_official 0:7037ed05f54f 313 return;
mbed_official 0:7037ed05f54f 314 }
mbed_official 0:7037ed05f54f 315
lru 59:c3aa24e36354 316 printf("[%8u] RX Data on port %u (%d bytes): ", g_timer.read_ms(), port, retcode);
mbed_official 0:7037ed05f54f 317 for (uint8_t i = 0; i < retcode; i++) {
mbed_official 47:b6d132f1079f 318 printf("%02x ", rx_buffer[i]);
mbed_official 0:7037ed05f54f 319 }
lru 59:c3aa24e36354 320 // Expecting exactly 3 bytes: red, green + blue color value.
lru 59:c3aa24e36354 321 // Other messages are ignored.
lru 59:c3aa24e36354 322 if ((retcode == 3) && (port == MBED_CONF_LORA_APP_PORT)) {
lru 59:c3aa24e36354 323 leds_set(rx_buffer[0], rx_buffer[1], rx_buffer[2]);
lru 59:c3aa24e36354 324 } else {
lru 59:c3aa24e36354 325 printf(" - ignored (%d)", MBED_CONF_LORA_APP_PORT);
lru 59:c3aa24e36354 326 }
mbed_official 47:b6d132f1079f 327 printf("\r\n");
lru 59:c3aa24e36354 328
mbed_official 12:5015dfead3f2 329 memset(rx_buffer, 0, sizeof(rx_buffer));
mbed_official 0:7037ed05f54f 330 }
mbed_official 0:7037ed05f54f 331
mbed_official 0:7037ed05f54f 332 /**
lru 59:c3aa24e36354 333 * Detects and processes button events.
lru 59:c3aa24e36354 334 */
lru 59:c3aa24e36354 335 static void button_handler(void)
lru 59:c3aa24e36354 336 {
lru 59:c3aa24e36354 337 static uint8_t prev_state = 1;
lru 59:c3aa24e36354 338 static uint8_t stable_state = 1;
lru 59:c3aa24e36354 339 static uint8_t count = 2;
lru 59:c3aa24e36354 340
lru 59:c3aa24e36354 341 uint8_t curr_state = button1;
lru 59:c3aa24e36354 342
lru 59:c3aa24e36354 343 if (curr_state != prev_state) {
lru 59:c3aa24e36354 344 count = 2;
lru 59:c3aa24e36354 345 } else {
lru 59:c3aa24e36354 346 if (count > 0) {
lru 59:c3aa24e36354 347 --count;
lru 59:c3aa24e36354 348 } else {
lru 59:c3aa24e36354 349 if ((stable_state == 0) && (curr_state != 0)) {
lru 59:c3aa24e36354 350 // we react on release of the button
lru 59:c3aa24e36354 351 if (is_connected) {
lru 59:c3aa24e36354 352 power_on = power_on? 0 : 1;
lru 59:c3aa24e36354 353 send_message(SWITCH_MESSAGE);
lru 59:c3aa24e36354 354 }
lru 59:c3aa24e36354 355 }
lru 59:c3aa24e36354 356 stable_state = curr_state;
lru 59:c3aa24e36354 357 }
lru 59:c3aa24e36354 358 }
lru 59:c3aa24e36354 359 prev_state = curr_state;
lru 59:c3aa24e36354 360 }
lru 59:c3aa24e36354 361
lru 59:c3aa24e36354 362
lru 59:c3aa24e36354 363 /**
mbed_official 0:7037ed05f54f 364 * Event handler
mbed_official 0:7037ed05f54f 365 */
mbed_official 0:7037ed05f54f 366 static void lora_event_handler(lorawan_event_t event)
mbed_official 0:7037ed05f54f 367 {
mbed_official 0:7037ed05f54f 368 switch (event) {
mbed_official 0:7037ed05f54f 369 case CONNECTED:
lru 59:c3aa24e36354 370 printf("\r\n[%8u] Connection - Successful \r\n", g_timer.read_ms());
lru 59:c3aa24e36354 371 is_connected = true;
lru 59:c3aa24e36354 372 msg_id = 0;
lru 59:c3aa24e36354 373 delay_counter = INTER_FRAME_DELAY;
lru 59:c3aa24e36354 374 send_message(DUMMY_MESSAGE);
mbed_official 0:7037ed05f54f 375 break;
mbed_official 0:7037ed05f54f 376 case DISCONNECTED:
lru 59:c3aa24e36354 377 led = 0;
lru 59:c3aa24e36354 378 frame_send = false;
mbed_official 0:7037ed05f54f 379 ev_queue.break_dispatch();
lru 59:c3aa24e36354 380 printf("\r\n[%8u] Disconnected Successfully \r\n", g_timer.read_ms());
mbed_official 0:7037ed05f54f 381 break;
mbed_official 0:7037ed05f54f 382 case TX_DONE:
lru 59:c3aa24e36354 383 led = 0;
lru 59:c3aa24e36354 384 tx_in_progress = false;
lru 59:c3aa24e36354 385 if (frame_send) {
lru 59:c3aa24e36354 386 frame_send = false;
lru 59:c3aa24e36354 387 delay_counter = INTER_FRAME_DELAY;
lru 59:c3aa24e36354 388 ++msg_id;
lru 59:c3aa24e36354 389 printf("\r\n[%8u] Message Sent to Network Server \r\n", g_timer.read_ms());
lru 59:c3aa24e36354 390 } else {
lru 59:c3aa24e36354 391 // printf("\r\n[%8u] Duplicate TX_DONE !!! \r\n", g_timer.read_ms());
mbed_official 0:7037ed05f54f 392 }
mbed_official 0:7037ed05f54f 393 break;
mbed_official 0:7037ed05f54f 394 case TX_TIMEOUT:
mbed_official 0:7037ed05f54f 395 case TX_ERROR:
mbed_official 0:7037ed05f54f 396 case TX_CRYPTO_ERROR:
mbed_official 0:7037ed05f54f 397 case TX_SCHEDULING_ERROR:
lru 59:c3aa24e36354 398 led = 0;
lru 59:c3aa24e36354 399 frame_send = false;
lru 59:c3aa24e36354 400 tx_in_progress = false;
lru 59:c3aa24e36354 401 delay_counter = INTER_FRAME_DELAY;
lru 59:c3aa24e36354 402 printf("\r\n[%8u] Transmission Error - EventCode = %d \r\n", g_timer.read_ms(), event);
mbed_official 0:7037ed05f54f 403 break;
mbed_official 0:7037ed05f54f 404 case RX_DONE:
lru 59:c3aa24e36354 405 printf("\r\n[%8u] Received message from Network Server \r\n", g_timer.read_ms());
mbed_official 0:7037ed05f54f 406 receive_message();
mbed_official 0:7037ed05f54f 407 break;
mbed_official 0:7037ed05f54f 408 case RX_TIMEOUT:
mbed_official 0:7037ed05f54f 409 case RX_ERROR:
lru 59:c3aa24e36354 410 printf("\r\n[%8u] Error in reception - Code = %d \r\n", g_timer.read_ms(), event);
mbed_official 0:7037ed05f54f 411 break;
mbed_official 0:7037ed05f54f 412 case JOIN_FAILURE:
mbed_official 0:7037ed05f54f 413 printf("\r\n OTAA Failed - Check Keys \r\n");
mbed_official 0:7037ed05f54f 414 break;
mbed_official 26:f07f5febf97f 415 case UPLINK_REQUIRED:
lru 59:c3aa24e36354 416 printf("\r\n[%8u] Uplink required by NS \r\n", g_timer.read_ms());
mbed_official 26:f07f5febf97f 417 break;
mbed_official 0:7037ed05f54f 418 default:
mbed_official 0:7037ed05f54f 419 MBED_ASSERT("Unknown Event");
mbed_official 0:7037ed05f54f 420 }
mbed_official 0:7037ed05f54f 421 }
mbed_official 0:7037ed05f54f 422
mbed_official 0:7037ed05f54f 423 // EOF