Abbiamo già descritto la modalità Idle e il consumo energetico relativo, in questo articolo continuiamo a misurare il consumo energetico di altre modalità di sleep per avere un breve confronto.
Cablaggio per i nostri test
Utilizzeremo l’ST-Link per programmare e alimentare l’STM32, ma metteremo un multimetro tra il pin 3v3 dell’ST-Link V2 e il pin 3.3v dell’STM32 per misurare gli ampere e per analizzare il consumo energetico.
Qui STM32 e ST-Link V2 usati in questo test STM32F103C8T6 STM32F401 STM32F411 ST-Link v2 ST-Link v2 official
Qui l'FTDI USB to TTL CH340G - USB to TTL FT232RL
Qui il mio multimetro Aneng SZ18
Per ottenere l’output seriale, utilizziamo un FTDI esterno con solo il GND e il Tx da STM32 a l’Rx dell’FTDI collegati.
STM32F1 e Serial per il debug
STM32F1 e Serial2 per il debug
STM32F4 e Serial per il debug
STM32F4 e Serial2 per il debug
Svegliarsi con interrupt interni gestiti da RTC
Sleep
Lo stato Sleep è l’equivalente della modalità Low-Power Sleep nel framework ST. Rispetto all’esempio precedente, il regolatore è posto in modalità a basso consumo energetico.
STM32F1
Il primo dispositivo che utilizziamo è un STM
/**
* STM32 Low Power Sleep wake up test from RTC
*
* This sketch demonstrates the usage of Internal Interrupts to wakeup a chip
* in Sleep mode.
*
* In this sketch, the internal RTC will wake up the processor.
*
* Renzo Mischianti <www.mischianti.org>
* en: https://mischianti.org/category/tutorial/stm32-tutorial/
* it: https://mischianti.org/it/category/guide/guida-alla-linea-di-microcontrollori-stm32/
*/
#include "STM32LowPower.h"
// If you use generic STM32F103C8
// you don't need this explicit declaration
// This is needed by bluepill specified version
//HardwareSerial Serial(USART2); // PA3 (RX) PA2 (TX)
void setup() {
Serial.begin(115200);
while (!Serial){ delay(100); }
Serial.println("START!");
// Configure low power
LowPower.begin();
}
void loop() {
Serial.print("Entering sleep in ");
for (int i=5; i>0; i--) {Serial.print(i);Serial.print(" ");delay(500);}
Serial.println();
delay(100); // Needed to give the time to write on Serial
LowPower.sleep(5000); // Entering in sleep
delay(100); // Needed to restore the Serial
Serial.print("Wake for 10 seconds! ");
for (int i=10; i>0; i--) {Serial.print(i);Serial.print(" ");delay(1000);}
Serial.println();
}
Il serial output è:
START!
Entering sleep in 5 4 3 2 1
Wake for 10 seconds! 10 9 8 7 6 5 4 3 2 1
Entering sleep in 5 4 3 2 1
Wake for 10 seconds! 10 9 8 7 6 5 4 3 2 1
Entering sleep in 5 4 3 2 1
Quando si entra in modalità Sleep, il consumo energetico da 17,50mAh scende a 9,35mAh, come avviene nella modalità Sleep.
STM32F401
Lo stesso sketch nell’STM32F401CC Black-Pill da 23,50mAh ottiene lo stesso risultato dell’Idle, 7,55mAh.
STM32F411
Lo stesso sketch nell’STM32F411CE Black-Pill da 32,50mAh ottiene lo stesso risultato dell’Idle, 10,90mAh.
Deep Sleep
Nella modalità DeepSleep (o modalità Stop per il framework ST), alcuni clock vengono spenti e solo un set minimo di periferiche è in modalità operativa.
STM32F1
Ecco il codice per il mio STM32F103C8 Blue pill
/**
* STM32 Low Power Deep Sleep wake up test from RTC
*
* This sketch demonstrates the usage of Internal Interrupts to wakeup a chip
* in DeepSleep mode.
*
* In this sketch, the internal RTC will wake up the processor.
*
* Renzo Mischianti <www.mischianti.org>
* en: https://mischianti.org/category/tutorial/stm32-tutorial/
* it: https://mischianti.org/it/category/guide/guida-alla-linea-di-microcontrollori-stm32/
*/
#include "STM32LowPower.h"
// If you use generic STM32F103C8
// you don't need this explicit declaration
// This is needed by bluepill specified version
//HardwareSerial Serial(USART2); // PA3 (RX) PA2 (TX)
void setup() {
Serial.begin(115200);
while (!Serial){ delay(100); }
Serial.println("START!");
// Configure low power
LowPower.begin();
}
void loop() {
Serial.print("Entering deep sleep in ");
for (int i=5; i>0; i--) {Serial.print(i);Serial.print(" ");delay(500);}
Serial.println();
delay(100); // Needed to give the time to write on Serial
LowPower.deepSleep(5000); // Entering in deep sleep
delay(100); // Needed to restore the Serial
Serial.print("Wake for 10 seconds! ");
for (int i=10; i>0; i--) {Serial.print(i);Serial.print(" ");delay(1000);}
Serial.println();
}
L’output seriale risulta:
START!
Entering deep sleep in 5 4 3 2 1
Wake for 10 seconds! 10 9 8 7 6 5 4 3 2 1
Entering deep sleep in 5 4 3 2 1
Wake for 10 seconds! 10 9 8 7 6 5 4 3 2 1
Ora il consumo energetico ha una variazione coerente, e otteniamo 1,914mAh.
STM32F401
Lo stesso sketch nello STM32F401CC Black-Pill da 24,48mAh ottiene un risultato di 1,63mAh.
STM32F411
Lo stesso sketch nello STM32F401CC Black-Pill da 32,48mAh ottiene un risultato di 6,56mAh.
Shutdown
Come già descritto, lo shutdown (Standby) è semplice da spiegare, gli unici oscillatori disponibili sono l’LSI e l’LSE, e le uniche periferiche che possono funzionare sono RTC e IWDG.
Facciamo una piccola modifica allo sketch di esempio, e inserisco l’attesa prima dello shutdown perché dobbiamo ricordare che quando si sveglia da questo stato, il dispositivo si riavvia completamente e riparte dall’inizio (setup()).
STM32F1
Inizieremo con il Blue-Pill come al solito.
/**
* STM32 Low Power shutdown wake up test from RTC
*
* This sketch demonstrates the usage of Internal Interrupts to wakeup a chip
* in shutdown mode.
*
* In this sketch, the internal RTC will wake up the processor.
*
* Renzo Mischianti <www.mischianti.org>
* en: https://mischianti.org/category/tutorial/stm32-tutorial/
* it: https://mischianti.org/it/category/guide/guida-alla-linea-di-microcontrollori-stm32/
*/
#include "STM32LowPower.h"
// If you use generic STM32F103C8
// you don't need this explicit declaration
// This is needed by bluepill specified version
//HardwareSerial Serial(USART2); // PA3 (RX) PA2 (TX)
void setup() {
Serial.begin(115200);
while (!Serial){ delay(100); }
Serial.println("START!");
// Configure low power
LowPower.begin();
}
void loop() {
delay(100); // Needed to restore the Serial
Serial.print("Wake for 10 seconds! ");
for (int i=10; i>0; i--) {Serial.print(i);Serial.print(" ");delay(1000);}
Serial.println();
Serial.print("Entering shutdown in ");
for (int i=5; i>0; i--) {Serial.print(i);Serial.print(" ");delay(500);}
Serial.println();
delay(100); // Needed to give the time to write on Serial
LowPower.shutdown(5000); // Entering in shutdown
}
Anche l’output seriale ha una nuova struttura.
START!
Wake for 10 seconds! 10 9 8 7 6 5 4 3 2 1
Entering shutdown in 5 4 3 2 1
START!
Wake for 10 seconds! 10 9 8 7 6 5 4 3 2 1
Entering shutdown in 5 4 3 2 1
Come puoi vedere, ad ogni risveglio viene scritta la stringa START!. E il consumo energetico scende a 1,780mAh.
STM32F401
Anche per questo, ad ogni risveglio viene scritta la stringa START!. E il consumo energetico scende a 0,31mAh.
STM32F411
Anche per questo, ad ogni risveglio viene scritta la stringa START!. E il consumo energetico scende a 4,67mAh.
Tabella di confronto
I risultati sono come previsto, ora li riassumiamo in una tabella.
Devi ricordare che stiamo analizzando la scheda prototipo non solo il chip STM32, quindi c’è un consumo energetico aggiuntivo come il LED e un clock esterno aggiuntivo.
| Modalità | STM32F1 | STM32F401 | STM32F411 |
|---|---|---|---|
| Idle | 9,37mAh | 7,55mAh | 11,05mAh |
| Sleep | 9,35mAh | 7,55mAh | 10,90mAh |
| Deep Sleep | 1,914mAh | 1,63mAh | 6,56mAh |
| Shutdown | 1,780mAh | 0,31mAh | 4,67mAh |
La prima cosa da notare è che nel risveglio RTC, il regolatore di tensione a basso consumo energetico non offre un vero vantaggio, ma ricorda che nel Low power sleep è possibile disabilitare selettivamente le periferiche e, se non è necessario guadagnare altri milliampere, il DeepSleep è preferibile allo Shutdown in modo da non perdere i dati in memoria e il dispositivo non viene riavviato.
Puoi notare anche che lo STM32F401 offre le migliori prestazioni a basso consumo energetico, per gli altri dispositivi è necessario lavorare anche sulle periferiche e sulle frequenze.
Grazie
- STM32F1 Blue Pill: piedinatura, specifiche e configurazione IDE Arduino (STM32duino e STMicroelectronics)
- STM32: programmazione (STM32F1) via USB con bootloader STM32duino
- STM32: programmazione (STM32F1 STM32F4) tramite USB con bootloader HID
- STM32F4 Black Pill: pinout, specifiche e configurazione IDE Arduino
- STM32: ethernet w5500 standard (HTTP) e SSL (HTTPS)
- STM32: ethernet enc28j60 standard (HTTP) e SSL (HTTPS)
- STM32: WiFiNINA con un ESP32 come WiFi Co-Processor
- Come utilizzare la scheda SD con l’stm32 e la libreria SdFat
- STM32: memoria flash SPI FAT FS
- STM32: RTC interno, sistema orario e backup batteria (VBAT)
- STM32 LoRa
- STM32 Risparmio energetico
- STM32F1 Blue-Pill gestione clock e frequenza
- STM32F4 Black-Pill gestione clock e frequenza
- Introduzione e framework Arduino vs STM
- Libreria LowPower, cablaggio e Idle (STM Sleep).
- Sleep, deep sleep, shutdown e consumo energetico
- Sveglia da allarme RTC e Seriale
- Sveglia da sorgente esterna
- Introduzione al dominio di backup e conservazione delle variabili durante il RESET
- Registro di backup RTC e conservazione della SRAM
- STM32 invia email con allegati e SSL (come Gmail): w5500, enc28j60, SD e SPI Flash
- Server FTP su STM32 con W5500, ENC28J60, scheda SD e memoria flash SPI
- Collegamento dell’EByte E70 ai dispositivi STM32 (black/blue pill) e un semplice sketch di esempio