Elecrow LoRaWAN LR1262 Dev.-Board mit Raspi-Pico 2040 schlafen legen und Strom sparen

Was bisher geschah...

In diesem Artikel hatte ich ja schon das LoRaWAN LR1262 Development Board mit RP2040 und 1.8 “ LCD für LoRa-Anwendungen von der Hardwareseite her vorgestellt.

Und hier hatten wir es softwaretechnisch ausgestattet, also mit Libraries bestückt und die Hauptkomponenten auf dem Board getestet. Und einen Sensor, einen BMP280 hatten wir auch schon per I2C-Bus ausgelesen über einen Grove-Port.

Stromverbrauch vom Elecrow LoRa Dev.-Board

Und heute soll es um einen weiteren Aspekt gehen, der für LoRa-Geräte wichtig ist: Stromsparen und Deep Sleep. Dafür will ich heute mal ein paar Experimente aus Messungen durchführen, um zu schauen, wie tief man das Board in den Schlaf schicken kann und wie der Stromverbrauch dabei ist.

Mit dem Deep Sleep habe ich ja schon unter dem ESP32 Erfahrungen gesammelt. Hier sei auf meinen Artikel Den ESP32 schlafen legen, um Strom zu sparen verwiesen. In dem versuche ich, einen ESP32-WROOM32 in den Tiefschlaf zu versetzen. Was im Prinzip auch gelingt, nur leider scheitert es am Board, einem Cheap Yellow Display.

Das CYD mit seinem 2.8 Zoll-Touch-Display zieht im Normalbetrieb bei 50% Helligkeit 490 mW und mit abgeschaltetem Display 280 mW. Im Light Sleep braucht es dann noch 70 mW und im Deep Sleep immer noch 68 mW.

Ich wähle hier bewusst die Angabe Milliwatt, weil die Spannung je nach Netzteil zwischen 4.8 und 5.4 Volt schwanken kann und eine Milliampere-Angabe deswegen ein wenig ungenau wäre. Aber jeder kann sich das selbst leicht ausrechnen: mW / 5 =~ mA.

Das Board des CYD ist also leider nicht sehr stromsparend ausgelegt. Es braucht im Deep Sleep immer noch 68 mW, also nur 2 mW weniger als im Light Sleep. Da kann man sich das auch sparen.

Doch wie sieht es beim Elecrow LoRa Dev.-Board aus?

Hier benutze ich kein PWM für die Screen-Helligkeit, sondern schalte es normal mit digitalWrite() auf HIGH, also 100%. Das passt auch so von der Helligkeit für mich, dunkler will ich es gar nicht haben. Dabei braucht es so um die 220 mW im Normalbetrieb. Das ist schon mal weniger als das CYD. Ist aber auch kein Wunder: wir haben es hier mit einem kleineren Screen zu tun: nur 1.8 statt 2.8 Zoll Bildschirmdiagonale.

Stromsparen mit dem RP2040

Und leider funktioniert der Deep Sleep Mode vollkommen unterschiedlich zwischen ESP32 und RP2040. Man kann nicht einfach dieselben Befehle benutzen.

Aus den hier geschilderten Gründen benutze ich den Core von Earle Philhower für Platform IO. Also sind wir hier für die Sleep-Modi auf den Core angewiesen.

Einiges an Strom kann man natürlich sparen, indem man die Hintergrundbeleuchtung des Display ausschaltet; das braucht am meisten Strom. So kann man den Stromverbrauch schon mal auf ca. 150 mW drücken. Und das Display auch schnell wieder reaktivieren.

Außerdem kann man die Taktfrequenz des RP2040 drücken: Da funktioniert mit dem Befehl

set_sys_clock_khz(CPU_CLOCK_KHZ_LOW, true);

Wobei die KHz runter bis auf 24000 (oder 32000) gedrückt werden kann. Was aber zum einen nicht mehr so viel bringt und zum anderen verhindert, dass das picotool der PlatformIO-Umgebung einen Boot-Select-Reset ausführen kann.

Sinnvoll ist hingegen eine Frequenz von 48000 KHz, das geht übrigens auch mit dem Befehl set_sys_clock_48mhz(). Nach dem Sleep kann man die Frequenz wieder auf die normalen 125000 KHz setzen, damit der Code wieder schneller ausgeführt wird.

Dann sollte man bei dem LoRa Dev.-Board natürlich noch die LEDs ausschalten, falls da welche an sind. Dann kann man noch den seriellen und den I2C-Bus abschalten mit

  // LEDs ausschalten
  digitalWrite(LED_BUILTIN, LOW);
  i2cWrite (ADDR_LEDS, 1, LED_NONE);

  //Peripherie aus
  Serial.end();
  Wire.end();

Das ist erstmal alles was geht. Damit kommen wir runter auf ca. 135 mW. Und müssen uns die Mühe machen, beim Weitermachen den ursprünglichen Zustand wiederherzustellen.

Deep-Sleep Mode mit Earle Philhower-Core

Das spart man sich normalerweise. Und versetzt die CPU respektive die MCU, also die RP2040 in den Tiefschlafmodus, auch Deep Sleep, genannt. Aus dem erwacht sie erst wieder beim Eintreten eines externen Ereignisses oder nach einem Reset. Und damit bekommt man die CPU dazu, nur noch wenige Milliampere zu verbrauchen, ja das kann sogar runter bis in den Mikroampere-Bereich gehen. Wenn das Board-Design mitmacht.

Nun ist das LoRa Dev.-Board picke-packe-voll mit allen möglichen Schnittstellen und Features, die alle mit Spannung versorgt werden wollen. Das Board ist ja auch nicht dafür gedacht, stromsparend zu sein. Sondern dafür, möglich viel Raum für Experimente und Debugging zu lassen. Und das tut es gut.

Für ein LoRa-Endgerät würde man dann möglichst wenig Hardware auf das LoRa-Board packen: nur eine MCU und einen LoRa Chip wie den LR1262. Ich würde mir da persönlich eher einen ESP32-C3 (ESP32-Varianten-Vergleich in diesem Artikel) nehmen, statt eines RP2040. Aber wo wie hier schon einen vorliegen haben, will ich mich auch mit dem Deep Sleep auf dem RP2040 beschäftigen.

Leider sieht es zur Zeit noch übel aus mit Earle Philhower-Core und Deep Sleep.

Normalerweise hat jeder ARM-Chip ein Register, in dem man ein Deep-Sleep-Bit setzen kann. Dann sollte der Prozessor beim nächsten Interrupt-Aufruf in den Deep Sleep gehen und nur noch ganz wenig Strom verbrauchen, sich quasi abschalten.

Im System Control Block des Cortex-M0 Prozessors, gibt es ein programmierbares Register, das System Control Register. Hier gibt es Bits zur Verwaltung des Schlaf-Zustands:

System Control Register (0xE000ED10)

Bits 31:5 = reserved
        4 = send event
        3 = reserved
        2 = SLEEPDEEP   0: Normal sleep; 1: Deep sleep
        1 = SLEEPONEXIT 0: disable, 1: enable

Beim nächsten __wfi() oder __wfe()-Befehl sollte der Prozessor dann in Deep Sleep gehen. WFI (Wait For Interrupt) ist ein ARM-Befehl, der die CPU in einen Low-Power-Zustand versetzt, bis ein Interrupt auftritt. Wenn der DEEP_SLEEP-Modus aktiviert ist, wird dies den Deep Sleep Modus aktivieren.

So meint es das Datenblatt. Nur tut sich leider überhaupt nichts in Sachen Stromverbrauch oder Programmverhalten, obwohl ich Bit 2 mit scb_hw->scr |= 4 setzen kann und auch ein __wfi() absetzen kann.

Auch der eigentlich für Stromsparende Befehl sleep_ms (); hat mit diesem Core keine Auswirkungen.

DeepSleep doch nicht erfolgreich hinbekommen

Geholfen hat dann ein Blick ins RP2040 Datasheet auf Seite 162 und 163 unter 2.11.5.1. Sleep und 2.11.5.2. Dormanant.

Meine deepSleep-Routine sieht jetzt so aus:

#include 
...
void deepSleep() {
  tft.fillRect(TFT_XOFF, TFT_YOFF, TFT_XMAX, TFT_YMAX, TFT_BLACK);

  // TFT-Backlight aus
  digitalWrite(TFT_BL, LOW);

  // LEDs ausschalten
  digitalWrite(LED_BUILTIN, LOW);
  i2cWrite (ADDR_LEDS, 1, LED_NONE);

  // Peripherie aus
  Serial.end();
  Wire.end();

  playOffMelody();

  set_sys_clock_khz(CPU_CLOCK_KHZ_LOW, true);
  
  int pin_irq=PIN_KEYS_ADC;
  pinMode(pin_irq, INPUT_PULLUP); 
  digitalPinToInterrupt(pin_irq);
 
  uint32_t event = IO_BANK0_DORMANT_WAKE_INTE0_GPIO0_EDGE_LOW_BITS;
  gpio_set_dormant_irq_enabled(pin_irq, event, true);
  
  // disable systick now so that no milisecond interrupts will occur
  systick_hw->csr &= ~1;
  
  xosc_dormant();

  // Hier wird der Code nach dem eingetretenem Ereignis fortgeführt
  gpio_acknowledge_irq(pin_irq, event); // acknowledge GPIO IRQ
  systick_hw->csr |= 1; // enable systick again, hope we survived this


  set_sys_clock_khz(CPU_CLOCK_KHZ_NORMAL, true);
  Serial.begin(115200);
  Wire.begin();

  // TFT-Backlight wieder an
  digitalWrite(TFT_BL, HIGH);
  drawSteuerung();
  drawCursor();
}

Nachdem der Bildschirm und die weitere Peripherie ausgeschaltet wurde, wird PIN_KEYS_ADC als Interrupt-In definiert. Wir erinnern uns: der Wert war immer bei 1024, wenn keine Taste gedrückt war und so um die 4 wenn der K1-Button gedrückt wird. Na, wenn das mal nicht eine schöne abfallende Flanke ergibt, der in der nächsten Zeile als Event gewählt wird.

Danach geht es mit xosc_dormant() in den Tiefschlaf. Hier schläft die CPU, bis das Interrupt, also WakeUp-Ereignis auftritt, nämlich Flankenabfall an Pin 29. Dann wacht die CPU wieder auf.

Danach muss natürlich der Ursprungszustand wiederhergestellt werden, damit es weiter gehen kann, was die nächsten Zeilen bewerkstelligen.

Im Deep Sleep verbraucht das LoRa-Board dann um die 80 mW (also etwa 16 mA), also vergleichbar mit dem CYD mit einem ESP32. Ein 8 Wh - 18650-Akku (ca. 2200 mAh) dürfte im Deep Sleep also rund 100 Stunden durchhalten, oder anders ausgedrückt: der Akku ist auch nach 4 Tagen leer, auch wenn die CPU nichts tut.

Das Schöne am RP2040 Deep Sleep ist, dass man hier weitermachen kann, wo man aufgehört hat. Beim ESP32 ist das ja eher wie ein Reset. Man könnte den Deep Sleep also auch beim Warten auf eine Taste oder nach einem Screen-Timeout benutzen.

Da habe ich aber drauf verzichtet, weil ich dann kein Boot-Select-Reset vom picotool mehr ausführen lassen kann. Das klappt dann nicht mehr. Ich habe das jetzt so gelöst, dass er die Taktfrequenz runterschraubt, wenn er auf einen Tastendruck wartet. Und wenn eine Minute lang keine Taste gedrückt wurde, er den Bildschirm ausschalten und damit in einen Light Sleep geht. Bei dem man dann aber auch neue Firmware hochladen kann.

Den DeepSleep muss man dann halt explizit aus dem Menü wählen.

Videos

Hier ein kurzes Video, bei dem ich den Stromverbrauch in den verschiedenen Schlaf- bzw. Stromspar-Modi messe:

Und hier eine kurze Demo über den I2C-Scanner und den Test des BMP280 auf dem Elecrow LoRa Board:

Auch über die Board-Tests (Buzzer, Screen, LEDs, Buttons) habe ich ein kleines Demo-Video davon aufgenommen:

Und so geht es weiter...

Im nächsten Teil dieser Artikelserie rund um das Elecrow LoRa Dev.-Board werden wir uns endlich mit dessen LoRa-Funktionalität befassen. Das ist ja das, was das Board ausmacht.