Merge remote-tracking branch 'origin' into sandbox

Author: M65649

src/examples/low_power/low_power.ino

@@ -1,24 +1,9 @@
-#include <Arduino.h>
+#include <avr/cpufunc.h>
+#include <avr/io.h>
 #include <led_ctrl.h>
 #include <log.h>
 #include <low_power.h>
 #include <lte.h>
-#include <sequans_controller.h>
-
-#ifdef __AVR_AVR128DB48__ // MINI
-
-#define SerialDebug Serial3
-#define TIMING_PIN  PIN_PE2
-#else
-#ifdef __AVR_AVR128DB64__ // Non-Mini
-
-#define SerialDebug Serial5
-#define TIMING_PIN  PIN_PE7
-
-#else
-#error "INCOMPATIBLE_DEVICE_SELECTED"
-#endif
-#endif
 
 void setup() {
 
@@ -27,12 +12,12 @@ void setup() {
     Log.begin(115200);
     Log.setLogLevel(LogLevel::DEBUG);
 
-    // Start LTE modem, configure the power save configuration and wait until we
-    // are connected to the operator
+    // Configure the power save configuration, start the LTE modem and wait
+    // until we are connected to the operator
     //
     // Here we say that we want to sleep for 30 seconds * 2 = 60 seconds each
     // time we invoke sleep
-    LowPower.begin(SleepMultiplier::THIRTY_SECONDS, 2, SleepMode::REGULAR);
+    LowPower.begin(SleepMultiplier::THIRTY_SECONDS, 2, SleepMode::DEEP);
     Lte.begin();
 
     while (!Lte.isConnected()) {
@@ -41,15 +26,14 @@ void setup() {
     }
 
     Log.info("Connected to operator!\r\n");
-
-    pinConfigure(TIMING_PIN, PIN_DIR_OUTPUT);
 }
 
 void loop() {
 
-    digitalWrite(TIMING_PIN, digitalRead(TIMING_PIN) ? 0 : 1);
-
     WakeUpReason wakeup_reason = LowPower.sleep();
     Log.infof("Got out of sleep with wake up reason %d, doing work...\r\n",
               wakeup_reason);
+
+    delay(10000);
+    // Do work ...
 }

src/led_ctrl.h

@@ -16,8 +16,6 @@ class LedCtrlClass {
      */
     LedCtrlClass(){};
 
-    uint8_t getLedPin(Led led);
-
   public:
     /**
      * @brief Singleton instance.
@@ -35,6 +33,11 @@ class LedCtrlClass {
      */
     void begin(const bool manual_control = false);
 
+    /**
+     * @return The pin associated with the given LED.
+     */
+    uint8_t getLedPin(Led led);
+
     /**
      * @brief Toggle @p led.
      *

src/low_power.cpp

@@ -1,9 +1,11 @@
+#include "led_ctrl.h"
 #include "log.h"
 #include "low_power.h"
 #include "lte.h"
 #include "sequans_controller.h"
 
 #include <Arduino.h>
+#include <avr/cpufunc.h>
 #include <avr/io.h>
 #include <avr/sleep.h>
 
@@ -50,9 +52,23 @@
 #define TIMER_LENGTH      11
 #define TIMER_SLEEP_INDEX 8
 
-#define RING_PORT   VPORTC
+#define RING_PORT VPORTC
+
+#ifdef __AVR_AVR128DB48__ // MINI
+
+#define RING_PIN_bm PIN6_bm
+
+#else
+
+#ifdef __AVR_AVR128DB64__ // Non-Mini
+
 #define RING_PIN_bm PIN4_bm
 
+#else
+#error "INCOMPATIBLE_DEVICE_SELECTED"
+#endif
+#endif
+
 // Singleton. Defined for use of the rest of the library.
 LowPowerClass LowPower = LowPowerClass::instance();
 
@@ -64,6 +80,9 @@ static SleepMode sleep_mode;
 static bool retrieved_sleep_time = false;
 static uint32_t sleep_time = 0;
 
+static uint8_t cell_led_state = 0;
+static uint8_t con_led_state = 0;
+
 ISR(RTC_PIT_vect) {
     RTC.PITINTFLAGS = RTC_PI_bm;
     pit_triggered = true;
@@ -93,7 +112,7 @@ static void uint8ToStringOfBits(const uint8_t value, char *string) {
 
 static uint8_t stringOfBitsToUint8(const char *string) {
 
-    uint8_t value;
+    uint8_t value = 0;
 
     for (uint8_t i = 0; i < 8; i++) {
         // We assume all other values are zero, so we only shift the ones
@@ -234,32 +253,33 @@ static uint32_t retrieveOperatorSleepTime(void) {
 
 static void enablePIT(void) {
 
-    // TODO: Fix this, should use external crystal
-    // Setup the clock for RTC. CTRL_SETUP is stored here just for convenience
-    // so that we discard the modifications in the register later
-    //
-    // CLKCTRL.XOSC32KCTRLA |= CLKCTRL_RUNSTBY_bm | CLKCTRL_LPMODE_bm |
-    // CLKCTRL_ENABLE_bm;
+    uint8_t temp;
 
-    // Wait for clock to stabilize
-    // while (CLKCTRL.MCLKSTATUS & CLKCTRL_XOSC32KS_bm &&
-    //       CLKCTRL.XOSC32KCTRLA & CLKCTRL_SEL_bm) {}
+    // Disable first and wait for clock to stabilize
+    temp = CLKCTRL.XOSC32KCTRLA;
+    temp &= ~CLKCTRL_ENABLE_bm;
+    _PROTECTED_WRITE(CLKCTRL.XOSC32KCTRLA, temp);
+    while (CLKCTRL.MCLKSTATUS & CLKCTRL_XOSC32KS_bm) {}
 
-    // Now we configure RTC which keeps track of the time during sleep. We do
-    // this here as we yield the RTC afterwards, so a setup every time is just
-    // to safe guard ourselves if other modules use the RTC
-    //
-    // Wait for all registers to be synchronized
+    // We want the external crystal to run in standby and in low power mode
+    temp = CLKCTRL.XOSC32KCTRLA;
+    temp |= CLKCTRL_RUNSTBY_bm | CLKCTRL_LPMODE_bm;
+    temp &= ~(CLKCTRL_SEL_bm);
+    _PROTECTED_WRITE(CLKCTRL.XOSC32KCTRLA, temp);
+
+    // Choose to use external crystal on XTAL32K1 and XTAL32K2 pins and enable
+    // the clock
+    temp = CLKCTRL.XOSC32KCTRLA;
+    temp |= CLKCTRL_ENABLE_bm;
+    _PROTECTED_WRITE(CLKCTRL.XOSC32KCTRLA, temp);
+
+    // Wait for registers to synchronize
     while (RTC.PITSTATUS) {}
 
-    // TODO: use XOSC32K instead
-    RTC.CLKSEL |= RTC_CLKSEL_INT32K_gc;
+    RTC.CLKSEL |= RTC_CLKSEL_XOSC32K_gc;
     RTC.PITINTCTRL |= RTC_PI_bm;
     RTC.PITCTRLA |= RTC_PERIOD_CYC32768_gc | RTC_PITEN_bm;
 
-    // Now we setup the sleep mode so it is ready.
-    SLPCTRL.CTRLA |= SLPCTRL_SMODE_PDOWN_gc | SLPCTRL_SEN_bm;
-
     // The first PIT intterupt will not necessarily be at the period specified,
     // so we just wait until it has triggered and track the reminaing time from
     // there
@@ -269,13 +289,37 @@ static void enablePIT(void) {
 
 static void disablePIT(void) {
 
-    SLPCTRL.CTRLA &= ~SLPCTRL_SEN_bm;
-
     // Disable external clock and turn off RTC PIT
-    CLKCTRL.XOSC32KCTRLA &= (~CLKCTRL_ENABLE_bm);
+    uint8_t temp;
+    temp = CLKCTRL.XOSC32KCTRLA;
+    temp &= ~(CLKCTRL_ENABLE_bm);
+    _PROTECTED_WRITE(CLKCTRL.XOSC32KCTRLA, temp);
+
     RTC.PITCTRLA &= ~RTC_PITEN_bm;
 }
 
+static void powerDownPeripherals(void) {
+
+    cell_led_state = digitalRead(LedCtrl.getLedPin(Led::CELL));
+    con_led_state = digitalRead(LedCtrl.getLedPin(Led::CON));
+
+    LedCtrl.off(Led::CELL, true);
+    LedCtrl.off(Led::CON, true);
+    LedCtrl.off(Led::DATA, true);
+    LedCtrl.off(Led::ERROR, true);
+    LedCtrl.off(Led::USER, true);
+}
+
+static void powerUpPeripherals(void) {
+    if (cell_led_state) {
+        LedCtrl.on(Led::CELL, true);
+    }
+
+    if (con_led_state) {
+        LedCtrl.on(Led::CON, true);
+    }
+}
+
 /**
  * Modem sleeping and CPU deep sleep.
  */
@@ -289,6 +333,7 @@ static WakeUpReason regularSleep(void) {
         sleep_time = retrieveOperatorSleepTime();
 
         if (sleep_time == 0) {
+            Log.debugf("Got invalid sleep time: %d\r\n", sleep_time);
             return WakeUpReason::INVALID_SLEEP_TIME;
         } else {
             retrieved_sleep_time = true;
@@ -297,7 +342,8 @@ static WakeUpReason regularSleep(void) {
 
     // The timeout here is arbitrary as we attempt to put the modem in sleep in
     // a loop, so we just choose 30 seconds = 30000 ms
-    while (!attemptToEnterPowerSaveModeForModem(30000)) {}
+    while (!attemptToEnterPowerSaveModeForModem(30000) &&
+           millis() - start_time_ms < sleep_time * 1000) {}
 
     // If we surpassed the sleep time during setting the LTE to sleep, we
     // don't have any more time to sleep the CPU, so just return.
@@ -360,17 +406,13 @@ static WakeUpReason deepSleep(void) {
     const unsigned long start_time_ms = millis();
 
     Lte.end();
-
     enablePIT();
 
     uint32_t remaining_time_seconds =
         sleep_time - (uint32_t)(((millis() - start_time_ms) / 1000.0f));
 
     while (remaining_time_seconds > 0) {
 
-        Log.debugf("Remaining time: %d \r\n", remaining_time_seconds);
-        delay(10);
-
         sleep_cpu();
 
         if (pit_triggered) {
@@ -380,7 +422,6 @@ static WakeUpReason deepSleep(void) {
     }
 
     disablePIT();
-
     Lte.begin();
 
     return WakeUpReason::OK;
@@ -453,12 +494,19 @@ bool LowPowerClass::begin(const SleepMultiplier sleep_multiplier,
 }
 
 WakeUpReason LowPowerClass::sleep(void) {
+
+    powerDownPeripherals();
+    SLPCTRL.CTRLA |= SLPCTRL_SMODE_PDOWN_gc | SLPCTRL_SEN_bm;
+
     switch (sleep_mode) {
     case SleepMode::REGULAR:
         return regularSleep();
     case SleepMode::DEEP:
         return deepSleep();
     }
 
+    SLPCTRL.CTRLA &= ~SLPCTRL_SEN_bm;
+    powerUpPeripherals();
+
     return WakeUpReason::OK;
 }

src/low_power.h

@@ -20,20 +20,17 @@ enum class SleepMultiplier {
 
 enum class WakeUpReason {
     // Invoked if the sleep time retrieved from the operator wasn't valid
-    INVALID_SLEEP_TIME = 4,
+    INVALID_SLEEP_TIME = 3,
 
     // Invoked if it took so long to put the modem in sleep that it wasn't time
     // left for the CPU to sleep. The sleep time should be considered to be
     // increased.
-    MODEM_TIMEOUT = 3,
+    MODEM_TIMEOUT = 2,
 
     // The modem went out of sleep before the total time, which may happen if
     // e.g. the interval of needing to send MQTT heartbeat is lower than the
     // sleep time.
-    AWOKEN_BY_MODEM_PREMATURELY = 2,
-
-    // If some unknown external interrupt caused the CPU to wake up
-    AWOKEN_BY_EXTERNAL_EVENT = 1,
+    AWOKEN_BY_MODEM_PREMATURELY = 1,
 
     OK = 0,
 };