Example programs for MultiTech Dot devices demonstrating how to use the Dot devices and the Dot libraries for LoRa communication.

Dependencies:   ISL29011

Dependents:   Dot-Examples-delujoc

This project has moved to github

Please see GitHub Dot-Examples

Dot Library Not Included!

Because these example programs can be used for both mDot and xDot devices, the LoRa stack is not included. The libmDot library should be imported if building for mDot devices. The libxDot library should be imported if building for xDot devices.

Dot Library Limitations

Commit messages in Dot Library repositories specify the version of the library and the version of mbed-os it was compiled against. We recommend building your application with the version of mbed-os specified in the commit message of the version of the Dot library you're using. This will ensure that you don't run into any runtime issues caused by differences in the mbed-os versions.

Example Programs Description

This application contains multiple example programs. Each example demonstrates a different way to configure and use a Dot. A short summary of each example is provided below. Common code used by multiple examples is in the dot_utils.cpp file.

All examples print logging, including RX data, on the USB debug port at 115200 baud. Each example defaults the Dot's configuration and saves the new configuration to NVM.

OTA Example

This example demonstrates configuring the Dot for OTA join mode and entering sleep or deepsleep mode between transactions with the gateway. If deepsleep mode is used, the session is saved and restored so that a rejoin is not necessary after waking up even though RAM contents have been lost. ACKs are disabled, but network link checks are configured - if enough link checks are missed, the Dot will no longer be considered joined to the network and will attempt to rejoin before transmitting more data.

AUTO_OTA Example

This example demonstrates configuring the Dot for AUTO_OTA join mode and entering sleep or deepsleep mode between transactions with the gateway. AUTO_OTA join mode automatically saves and restores the session when deepsleep mode is used, so the manual saving and restoring of the session is not necessary. ACKs are disabled, but network link checks are configured - if enough link checks are missed, the Dot will no longer be considered joined to the network and will attempt to rejoin before transmitting more data.

Manual Example

This example demonstrates configuring the Dot for MANUAL join mode and entering sleep or deepsleep mode between transactions with the gateway. The Dot must be provisioned on the gateway before its packets will be accepted! Follow these steps to provision the Dot on a Conduit gateway:

  • ssh into the conduit
  • use the lorq-query application to provision the Dot on the gateway
    • lora-query -a 01020304 A 0102030401020304 <your Dot's device ID> 01020304010203040102030401020304 01020304010203040102030401020304
    • if any of the credentials change on the Dot side, they must be updated on the gateway side as well

To provision a Dot on a third-party gateway, see the gateway or network provider documentation.

Class B Example

This example demonstrates how to configure the dot for an OTA join, how to acquire a lock on a GPS synchronized beacon, and then to subsequently enter class B mode of operation. After a successful join, the device will request to the dot-library to switch to class B. When this happens, the library will send an uplink to the network server (hence we must be joined first before entering this mode) requesting the GPS time to calculate when the next beacon is expected. Once this time elapses, the dot will open an rx window to demodulate the broadcasted beacon and fire an mDotEvent::BeaconRx event upon successful reception. After the beacon is received, the example sends an uplink which will have the class B bit in the packet's frame control set to indicate to the network server that downlinks may now be scheduled on ping slots. The lora-query application can be used to configure a Conduit gateway to communicate with a Dot in class B mode. For information on how to inform a third-party gateway that a Dot is operating in class B mode, see the gateway or network provider documentation.

Class C Example

This example demonstrates configuring the Dot for OTA join mode and communicating with the gateway using class C mode. In class C mode the gateway can send a packet to the Dot at any time, so it must be listening whenever it is not transmitting. This means that the Dot cannot enter sleep or deepsleep mode. The gateway will not immediately send packets to the Dot (outside the receive windows following a transmission from the Dot) until it is informed that the Dot is operating in class C mode. The lora-query application can be used to configure a Conduit gateway to communicate with a Dot in class C mode. For information on how to inform a third-party gateway that a Dot is operating in class C mode, see the gateway or network provider documentation.

FOTA Example

Full FOTA support is available on mDot and on xDot with external flash. See this article for details on adding external flash for xDot FOTA.

Without external flash xDot can use the FOTA example to dynamically join a multicast session only. After joining the multicast session the received Fragmentation packets could be handed to a host MCU for processing and at completion the firmware can be loaded into the xDot using the bootloader and y-modem. See xDot Developer Guide.

This example demonstrates how to incorporate over-the-air updates to an application. The example uses a Class C application. Class A or B functionality could also be used. The device will automatically enter into Class C operation for the FOTA operation, Class B would be disabled during the FOTA transfer.

  • Add the following code to allow Fota to use the Dot instance

examples/src/fota_example.cpp

    // Initialize FOTA singleton
    Fota::getInstance(dot);
  • Add fragmentation and multicast handling the the PacketRx event

examples/inc/RadioEvent.h

    virtual void PacketRx(uint8_t port, uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr, lora::DownlinkControl ctrl, uint8_t slot, uint8_t retries, uint32_t address, uint32_t fcnt, bool dupRx) {
        mDotEvent::PacketRx(port, payload, size, rssi, snr, ctrl, slot, retries, address, fcnt, dupRx);

#if ACTIVE_EXAMPLE == FOTA_EXAMPLE
        if(port == 200 || port == 201 || port == 202) {
            Fota::getInstance()->processCmd(payload, port, size);
        }
#endif
    }

A definition is needed to enable FOTA.

mbed_app.json

{
    "macros": [
        "FOTA=1"
    ]
}


Peer to Peer Example

This example demonstrates configuring Dots for peer to peer communication without a gateway. It should be compiled and run on two Dots. Peer to peer communication uses LoRa modulation but uses a single higher throughput (usually 500kHz or 250kHz) datarate. It is similar to class C operation - when a Dot isn't transmitting, it's listening for packets from the other Dot. Both Dots must be configured exactly the same for peer to peer communication to be successful.


Choosing An Example Program and Channel Plan

Only the active example is compiled. The active example can be updated by changing the ACTIVE_EXAMPLE definition in the examples/example_config.h file.

By default the OTA_EXAMPLE will be compiled and the US915 channel plan will be used.

example_config.h

#ifndef __EXAMPLE__CONFIG_H__
#define __EXAMPLE__CONFIG_H__

#define OTA_EXAMPLE              1  // see ota_example.cpp
#define AUTO_OTA_EXAMPLE         2  // see auto_ota_example.cpp
#define MANUAL_EXAMPLE           3  // see manual_example.cpp
#define PEER_TO_PEER_EXAMPLE     4  // see peer_to_peer_example.cpp
#define CLASS_C_EXAMPLE          5  // see class_c_example.cpp

// the active example is the one that will be compiled
#if !defined(ACTIVE_EXAMPLE)
#define ACTIVE_EXAMPLE  OTA_EXAMPLE
#endif

// the active channel plan is the one that will be compiled
// options are :
//      CP_US915
//      CP_AU915
//      CP_EU868
//      CP_KR920
//      CP_AS923
//      CP_AS923_JAPAN
#if !defined(CHANNEL_PLAN)
#define CHANNEL_PLAN CP_US915
#endif

#endif


Compile the AUTO_OTA_EXAMPLE and use the EU868 channel plan instead.

example_config.h

#ifndef __EXAMPLE__CONFIG_H__
#define __EXAMPLE__CONFIG_H__

#define OTA_EXAMPLE              1  // see ota_example.cpp
#define AUTO_OTA_EXAMPLE         2  // see auto_ota_example.cpp
#define MANUAL_EXAMPLE           3  // see manual_example.cpp
#define PEER_TO_PEER_EXAMPLE     4  // see peer_to_peer_example.cpp
#define CLASS_C_EXAMPLE          5  // see class_c_example.cpp

// the active example is the one that will be compiled
#if !defined(ACTIVE_EXAMPLE)
#define ACTIVE_EXAMPLE  AUTO_OTA_EXAMPLE
#endif

// the active channel plan is the one that will be compiled
// options are :
//      CP_US915
//      CP_AU915
//      CP_EU868
//      CP_KR920
//      CP_AS923
//      CP_AS923_JAPAN
#if !defined(CHANNEL_PLAN)
#define CHANNEL_PLAN CP_EU868
#endif

#endif



Dot Libraries

Stable and development libraries are available for both mDot and xDot platforms. The library chosen must match the target platform. Compiling for the mDot platform with the xDot library or vice versa will not succeed.

mDot Library

Development library for mDot.

libmDot-dev

Stable library for mDot.

libmDot-stable


For mbed-os 5 use:

Import librarylibmDot-mbed5

Stable version of the mDot library for mbed 5. This version of the library is suitable for deployment scenarios. See lastest commit message for version of mbed-os library that has been tested against.

xDot Library

Development library for xDot.

libxDot-dev

Stable library for xDot.

libxDot-stable


For mbed-os 5 use:

Import librarylibxDot-mbed5

Stable version of the xDot library for mbed 5. This version of the library is suitable for deployment scenarios.

Committer:
mfiore
Date:
Wed Oct 05 21:07:50 2016 +0000
Revision:
0:a151a6350d7f
Child:
1:c4915e00d2ce
initial commit of OTA and AUTO_OTA examples

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mfiore 0:a151a6350d7f 1 #include "dot_util.h"
mfiore 0:a151a6350d7f 2
mfiore 0:a151a6350d7f 3 void display_config() {
mfiore 0:a151a6350d7f 4 // display configuration and library version information
mfiore 0:a151a6350d7f 5 logInfo("version: %s", dot->getId().c_str());
mfiore 0:a151a6350d7f 6 logInfo("general configuration");
mfiore 0:a151a6350d7f 7 logInfo("---------------------");
mfiore 0:a151a6350d7f 8 logInfo("\tdevice ID/EUI: %s", mts::Text::bin2hexString(dot->getDeviceId()).c_str());
mfiore 0:a151a6350d7f 9 logInfo("\tfrequency band: %s", mDot::FrequencyBandStr(dot->getFrequencyBand()).c_str());
mfiore 0:a151a6350d7f 10 logInfo("\tfrequency sub band: %u", dot->getFrequencySubBand());
mfiore 0:a151a6350d7f 11 logInfo("\tpublic network: %s", dot->getPublicNetwork() == true ? "on" : "off");
mfiore 0:a151a6350d7f 12 logInfo("credentials configuration");
mfiore 0:a151a6350d7f 13 logInfo("-------------------------");
mfiore 0:a151a6350d7f 14 logInfo("\tnetwork name: %s", dot->getNetworkName().c_str());
mfiore 0:a151a6350d7f 15 logInfo("\tnetwork phrase: %s", dot->getNetworkPassphrase().c_str());
mfiore 0:a151a6350d7f 16 logInfo("\tnetwork join mode: %s", mDot::JoinModeStr(dot->getJoinMode()).c_str());
mfiore 0:a151a6350d7f 17 logInfo("communication parameters");
mfiore 0:a151a6350d7f 18 logInfo("------------------------");
mfiore 0:a151a6350d7f 19 logInfo("\tacks: %s, %u attempts", dot->getAck() > 0 ? "on" : "off", dot->getAck());
mfiore 0:a151a6350d7f 20 logInfo("\tTX datarate: %s", mDot::DataRateStr(dot->getTxDataRate()).c_str());
mfiore 0:a151a6350d7f 21 logInfo("\tTX power: %lu dBm", dot->getTxPower());
mfiore 0:a151a6350d7f 22 logInfo("\tatnenna gain: %u dBm", dot->getAntennaGain());
mfiore 0:a151a6350d7f 23 }
mfiore 0:a151a6350d7f 24
mfiore 0:a151a6350d7f 25 void update_ota_config(std::string network_name, std::string network_passphrase, uint8_t frequency_sub_band, bool public_network, uint8_t ack) {
mfiore 0:a151a6350d7f 26 std::string current_network_name = dot->getNetworkName();
mfiore 0:a151a6350d7f 27 std::string current_network_passphrase = dot->getNetworkPassphrase();
mfiore 0:a151a6350d7f 28 uint8_t current_frequency_sub_band = dot->getFrequencySubBand();
mfiore 0:a151a6350d7f 29 bool current_public_network = dot->getPublicNetwork();
mfiore 0:a151a6350d7f 30 uint8_t current_ack = dot->getAck();
mfiore 0:a151a6350d7f 31
mfiore 0:a151a6350d7f 32 if (current_network_name != network_name) {
mfiore 0:a151a6350d7f 33 logInfo("changing network name from \"%s\" to \"%s\"", current_network_name.c_str(), network_name.c_str());
mfiore 0:a151a6350d7f 34 if (dot->setNetworkName(network_name) != mDot::MDOT_OK) {
mfiore 0:a151a6350d7f 35 logError("failed to set network name to \"%s\"", network_name.c_str());
mfiore 0:a151a6350d7f 36 }
mfiore 0:a151a6350d7f 37 }
mfiore 0:a151a6350d7f 38
mfiore 0:a151a6350d7f 39 if (current_network_passphrase != network_passphrase) {
mfiore 0:a151a6350d7f 40 logInfo("changing network passphrase from \"%s\" to \"%s\"", current_network_passphrase.c_str(), network_passphrase.c_str());
mfiore 0:a151a6350d7f 41 if (dot->setNetworkPassphrase(network_passphrase) != mDot::MDOT_OK) {
mfiore 0:a151a6350d7f 42 logError("failed to set network passphrase to \"%s\"", network_passphrase.c_str());
mfiore 0:a151a6350d7f 43 }
mfiore 0:a151a6350d7f 44 }
mfiore 0:a151a6350d7f 45
mfiore 0:a151a6350d7f 46 if (current_frequency_sub_band != frequency_sub_band) {
mfiore 0:a151a6350d7f 47 logInfo("changing frequency sub band from %u to %u", current_frequency_sub_band, frequency_sub_band);
mfiore 0:a151a6350d7f 48 if (dot->setFrequencySubBand(frequency_sub_band) != mDot::MDOT_OK) {
mfiore 0:a151a6350d7f 49 logError("failed to set frequency sub band to %u", frequency_sub_band);
mfiore 0:a151a6350d7f 50 }
mfiore 0:a151a6350d7f 51 }
mfiore 0:a151a6350d7f 52
mfiore 0:a151a6350d7f 53 if (current_public_network != public_network) {
mfiore 0:a151a6350d7f 54 logInfo("changing public network from %s to %s", current_public_network ? "true" : "false", public_network ? "true" : "false");
mfiore 0:a151a6350d7f 55 if (dot->setPublicNetwork(public_network) != mDot::MDOT_OK) {
mfiore 0:a151a6350d7f 56 logError("failed to set public network to %s", public_network ? "true" : "false");
mfiore 0:a151a6350d7f 57 }
mfiore 0:a151a6350d7f 58 }
mfiore 0:a151a6350d7f 59
mfiore 0:a151a6350d7f 60 if (current_ack != ack) {
mfiore 0:a151a6350d7f 61 logInfo("changing acks from %u to %u", current_ack, ack);
mfiore 0:a151a6350d7f 62 if (dot->setAck(ack) != mDot::MDOT_OK) {
mfiore 0:a151a6350d7f 63 logError("failed to set acks to %u", ack);
mfiore 0:a151a6350d7f 64 }
mfiore 0:a151a6350d7f 65 }
mfiore 0:a151a6350d7f 66 }
mfiore 0:a151a6350d7f 67
mfiore 0:a151a6350d7f 68 void join_network() {
mfiore 0:a151a6350d7f 69 int32_t j_attempts = 0;
mfiore 0:a151a6350d7f 70 int32_t ret = mDot::MDOT_ERROR;
mfiore 0:a151a6350d7f 71
mfiore 0:a151a6350d7f 72 // attempt to join the network
mfiore 0:a151a6350d7f 73 while (ret != mDot::MDOT_OK) {
mfiore 0:a151a6350d7f 74 logInfo("attempt %d to join network", ++j_attempts);
mfiore 0:a151a6350d7f 75 ret = dot->joinNetwork();
mfiore 0:a151a6350d7f 76 if (ret != mDot::MDOT_OK) {
mfiore 0:a151a6350d7f 77 logError("failed to join network %d:%s", ret, mDot::getReturnCodeString(ret).c_str());
mfiore 0:a151a6350d7f 78 // in some frequency bands we need to wait until another channel is available before transmitting again
mfiore 0:a151a6350d7f 79 uint32_t delay_s = (dot->getNextTxMs() / 1000) + 1;
mfiore 0:a151a6350d7f 80 if (delay_s < 2) {
mfiore 0:a151a6350d7f 81 logInfo("waiting %lu s until next free channel", delay_s);
mfiore 0:a151a6350d7f 82 wait(delay_s);
mfiore 0:a151a6350d7f 83 } else {
mfiore 0:a151a6350d7f 84 logInfo("sleeping %lu s until next free channel", delay_s);
mfiore 0:a151a6350d7f 85 dot->sleep(delay_s, mDot::RTC_ALARM, false);
mfiore 0:a151a6350d7f 86 }
mfiore 0:a151a6350d7f 87 }
mfiore 0:a151a6350d7f 88 }
mfiore 0:a151a6350d7f 89 }
mfiore 0:a151a6350d7f 90
mfiore 0:a151a6350d7f 91 void sleep_wake_rtc_only(bool deepsleep) {
mfiore 0:a151a6350d7f 92 // in some frequency bands we need to wait until another channel is available before transmitting again
mfiore 0:a151a6350d7f 93 // wait at least 10s between transmissions
mfiore 0:a151a6350d7f 94 uint32_t delay_s = dot->getNextTxMs() / 1000;
mfiore 0:a151a6350d7f 95 if (delay_s < 10) {
mfiore 0:a151a6350d7f 96 delay_s = 10;
mfiore 0:a151a6350d7f 97 }
mfiore 0:a151a6350d7f 98
mfiore 0:a151a6350d7f 99 logInfo("%ssleeping %lus", deepsleep ? "deep" : "", delay_s);
mfiore 0:a151a6350d7f 100 logInfo("application will %s after waking up", deepsleep ? "execute from beginning" : "resume");
mfiore 0:a151a6350d7f 101
mfiore 0:a151a6350d7f 102 // go to sleep/deepsleep for delay_s seconds and wake using the RTC alarm
mfiore 0:a151a6350d7f 103 dot->sleep(delay_s, mDot::RTC_ALARM, deepsleep);
mfiore 0:a151a6350d7f 104 }
mfiore 0:a151a6350d7f 105
mfiore 0:a151a6350d7f 106 void sleep_wake_interrupt_only(bool deepsleep) {
mfiore 0:a151a6350d7f 107 #if defined (TARGET_XDOT_L151CC)
mfiore 0:a151a6350d7f 108 if (deepsleep) {
mfiore 0:a151a6350d7f 109 // for xDot, WAKE pin (connected to S2 on xDot-DK) is the only pin that can wake the processor from deepsleep
mfiore 0:a151a6350d7f 110 // it is automatically configured when INTERRUPT or RTC_ALARM_OR_INTERRUPT is the wakeup source and deepsleep is true in the mDot::sleep call
mfiore 0:a151a6350d7f 111 } else {
mfiore 0:a151a6350d7f 112 // configure WAKE pin (connected to S2 on xDot-DK) as the pin that will wake the xDot from low power modes
mfiore 0:a151a6350d7f 113 // other pins can be confgured instead: GPIO0-3 or UART_RX
mfiore 0:a151a6350d7f 114 dot->setWakePin(WAKE);
mfiore 0:a151a6350d7f 115 }
mfiore 0:a151a6350d7f 116
mfiore 0:a151a6350d7f 117 logInfo("%ssleeping until rising edge on %s pin", deepsleep ? "deep" : "", deepsleep ? "WAKE" : mDot::pinName2Str(dot->getWakePin()).c_str());
mfiore 0:a151a6350d7f 118 #else
mfiore 0:a151a6350d7f 119 if (deepsleep) {
mfiore 0:a151a6350d7f 120 // for mDot, XBEE_DIO7 pin is the only pin that can wake the processor from deepsleep
mfiore 0:a151a6350d7f 121 // it is automatically configured when INTERRUPT or RTC_ALARM_OR_INTERRUPT is the wakeup source and deepsleep is true in the mDot::sleep call
mfiore 0:a151a6350d7f 122 } else {
mfiore 0:a151a6350d7f 123 // configure XBEE_DIO7 pin as the pin that will wake the mDot from low power modes
mfiore 0:a151a6350d7f 124 // other pins can be confgured instead: XBEE_DIO2-6, XBEE_DI8, XBEE_DIN
mfiore 0:a151a6350d7f 125 dot->setWakePin(XBEE_DIO7);
mfiore 0:a151a6350d7f 126 }
mfiore 0:a151a6350d7f 127
mfiore 0:a151a6350d7f 128 logInfo("%ssleeping until rising edge on %s pin", deepsleep ? "deep" : "", deepsleep ? "DIO7" : mDot::pinName2Str(dot->getWakePin()).c_str());
mfiore 0:a151a6350d7f 129 #endif
mfiore 0:a151a6350d7f 130
mfiore 0:a151a6350d7f 131 logInfo("application will %s after waking up", deepsleep ? "execute from beginning" : "resume");
mfiore 0:a151a6350d7f 132
mfiore 0:a151a6350d7f 133 // go to sleep/deepsleep and wake on rising edge of configured wake pin (only the WAKE pin in deepsleep)
mfiore 0:a151a6350d7f 134 // since we're not waking on the RTC alarm, the interval is ignored
mfiore 0:a151a6350d7f 135 dot->sleep(0, mDot::INTERRUPT, deepsleep);
mfiore 0:a151a6350d7f 136 }
mfiore 0:a151a6350d7f 137
mfiore 0:a151a6350d7f 138 void sleep_wake_rtc_or_interrupt(bool deepsleep) {
mfiore 0:a151a6350d7f 139 // in some frequency bands we need to wait until another channel is available before transmitting again
mfiore 0:a151a6350d7f 140 // wait at least 10s between transmissions
mfiore 0:a151a6350d7f 141 uint32_t delay_s = dot->getNextTxMs() / 1000;
mfiore 0:a151a6350d7f 142 if (delay_s < 10) {
mfiore 0:a151a6350d7f 143 delay_s = 10;
mfiore 0:a151a6350d7f 144 }
mfiore 0:a151a6350d7f 145
mfiore 0:a151a6350d7f 146 #if defined (TARGET_XDOT_L151CC)
mfiore 0:a151a6350d7f 147 if (deepsleep) {
mfiore 0:a151a6350d7f 148 // for xDot, WAKE pin (connected to S2 on xDot-DK) is the only pin that can wake the processor from deepsleep
mfiore 0:a151a6350d7f 149 // it is automatically configured when INTERRUPT or RTC_ALARM_OR_INTERRUPT is the wakeup source and deepsleep is true in the mDot::sleep call
mfiore 0:a151a6350d7f 150 } else {
mfiore 0:a151a6350d7f 151 // configure WAKE pin (connected to S2 on xDot-DK) as the pin that will wake the xDot from low power modes
mfiore 0:a151a6350d7f 152 // other pins can be confgured instead: GPIO0-3 or UART_RX
mfiore 0:a151a6350d7f 153 dot->setWakePin(WAKE);
mfiore 0:a151a6350d7f 154 }
mfiore 0:a151a6350d7f 155
mfiore 0:a151a6350d7f 156 logInfo("%ssleeping %lus or until rising edge on %s pin", deepsleep ? "deep" : "", delay_s, deepsleep ? "WAKE" : mDot::pinName2Str(dot->getWakePin()).c_str());
mfiore 0:a151a6350d7f 157 #else
mfiore 0:a151a6350d7f 158 if (deepsleep) {
mfiore 0:a151a6350d7f 159 // for mDot, XBEE_DIO7 pin is the only pin that can wake the processor from deepsleep
mfiore 0:a151a6350d7f 160 // it is automatically configured when INTERRUPT or RTC_ALARM_OR_INTERRUPT is the wakeup source and deepsleep is true in the mDot::sleep call
mfiore 0:a151a6350d7f 161 } else {
mfiore 0:a151a6350d7f 162 // configure XBEE_DIO7 pin as the pin that will wake the mDot from low power modes
mfiore 0:a151a6350d7f 163 // other pins can be confgured instead: XBEE_DIO2-6, XBEE_DI8, XBEE_DIN
mfiore 0:a151a6350d7f 164 dot->setWakePin(XBEE_DIO7);
mfiore 0:a151a6350d7f 165 }
mfiore 0:a151a6350d7f 166
mfiore 0:a151a6350d7f 167 logInfo("%ssleeping %lus or until rising edge on %s pin", deepsleep ? "deep" : "", delay_s, deepsleep ? "DIO7" : mDot::pinName2Str(dot->getWakePin()).c_str());
mfiore 0:a151a6350d7f 168 #endif
mfiore 0:a151a6350d7f 169
mfiore 0:a151a6350d7f 170 logInfo("application will %s after waking up", deepsleep ? "execute from beginning" : "resume");
mfiore 0:a151a6350d7f 171
mfiore 0:a151a6350d7f 172 // go to sleep/deepsleep and wake using the RTC alarm after delay_s seconds or rising edge of configured wake pin (only the WAKE pin in deepsleep)
mfiore 0:a151a6350d7f 173 // whichever comes first will wake the xDot
mfiore 0:a151a6350d7f 174 dot->sleep(delay_s, mDot::RTC_ALARM_OR_INTERRUPT, deepsleep);
mfiore 0:a151a6350d7f 175 }
mfiore 0:a151a6350d7f 176
mfiore 0:a151a6350d7f 177 void send_data(std::vector<uint8_t> data) {
mfiore 0:a151a6350d7f 178 uint32_t ret;
mfiore 0:a151a6350d7f 179
mfiore 0:a151a6350d7f 180 ret = dot->send(data);
mfiore 0:a151a6350d7f 181 if (ret != mDot::MDOT_OK) {
mfiore 0:a151a6350d7f 182 logError("failed to send light data to gateway [%d][%s]", ret, mDot::getReturnCodeString(ret).c_str());
mfiore 0:a151a6350d7f 183 } else {
mfiore 0:a151a6350d7f 184 logInfo("successfully sent light data to gateway");
mfiore 0:a151a6350d7f 185 }
mfiore 0:a151a6350d7f 186 }