Trabalho 01 - Minimizando o consumo de potência da Raspberry Pi Pico

Grupo: Ygor, Paulo, Marcela e Daniel

1 - Ler a seção 2.11 do Datasheet do processador RP2040 (disponível no moodle) e

responder às seguintes perguntas:

a) Qual a diferença entre os estados SLEEP e DORMANT?

● O estado SLEEP é ativado quando ambos os processadores estão em repouso e o

sistema DMA não tem transferências pendentes. No estado SLEEP, os portões de clock
de nível superior são mascarados para otimizar a árvore de clock quando os
processadores estão em repouso. O RP2040 sai do estado SLEEP quando um dos
processadores é acordado por uma interrupção.
● O estado DORMANT é um verdadeiro estado de repouso com potência dinâmica zero,
onde todos os relógios e osciladores estão desligados.

● b) Como colocar o processador em modos SLEEP e DORMANT?

● O modo SLEEP é quando os processadores estão em repouso e o DMA está inativo, por
isso pode desligar a maioria dos relógios do sistema.

● O modo DORMANT é quando você desliga todos os osciladores, e assim ainda tem
menos energia, mas então você tem menos opções para acordar".

c) Como "acordar" o processador dos estados SLEEP e DORMANT?

● Dormant requer um gatilho externo que manipula um pino GPIO para acordar o
Raspberry Pi Pico, enquanto o SLEEP pode correr um relógio interno para acordar o
RP2040.

2 - Ler a seção 4.9 do Datasheet do processador RP2040 (disponível no moodle) e

responder às seguintes perguntas:
a) Quantos canais de ADC estão disponíveis no RP2040?

● Ele possui três canais conectados aos pinos GPIO: GP26, GP27 e GP28, que também
são conhecidos como GP26_ADC0, GP27_ADC1 e GP28_ADC2 para os canais
analógicos 0, 1 e 2.
● Há também um quarto canal ADC, que está conectado a um sensor de temperatura
incorporado ao RP2040.
 ● O GPIO29 pode ser usado para medir a tensão VSYS e existe também um último canal,
conectado a um sensor de temperatura interno da RP2040.

b) Qual a resolução do ADC? Como pode ser realizada a medição da temperatura interna do
processador usando o ADC?

● Um ADC tem duas características principais: sua resolução, medida em bits digitais, e
seus canais, ou quantos sinais analógicos ele pode aceitar e converter de uma vez.
● O ADC do Pico tem uma resolução de 12 bits, ou seja, ele pode transformar um sinal
analógico em um sinal digital como um número variando de 0 a 4095. Mas é importante
dizer que isso é tratado no MicroPython como um número de 16 bits variando de 0 a
65.535, para que funcione da mesma forma que o ADC em outros microcontroladores
MicroPython.

3 - Ler a seção 4.8.5.5 do Datasheet do processador RP2040 (disponível no moodle) e

responder às seguintes perguntas:

a) Como usar o RTC interno do RP2040 para "acordar" o processador?

● De acordo com o Datasheet, O RTC interno do RP2040 pode ser usado para "acordar" o
processador de dois modos de economia de energia: modo Sleep (Sono) e modo
Dormant (Dormente). No modo Sleep, o RP2040 pode ser configurado para manter
apenas o clk_rtc (um relógio de referência RTC lento) em execução, juntamente com
uma pequena quantidade de lógica que permite que o processador acorde novamente.
O processador é acordado do modo Sleep quando a interrupção de alarme do RTC é
ativada.

● Para acordar o chip do modo Dormant, os seguintes passos devem ser seguidos:
1. Configurar o RTC para usar um relógio de referência externo (fornecido por um pino
GPIO).
2. Configurar o RTC para funcionar com a referência externa.
3. Se o processador estiver funcionando com o PLL, alterar para que ele funcione com o
XOSC/ROSC.
4. Desligar os PLLs.
5. Configurar o RTC com o horário desejado para acordar (única vez ou recorrente).
6. (opcionalmente) Desligar a maioria das memórias.
7. Invocar o modo Dormant (Dormente) de operação.

4 - Fazer um programa em python para ler a temperatura interna do processador e

mostrá-la graficamente no "plotter" do Thonny.

● Temp

import machine
import utime

sensor_temp = machine.ADC(4)
conversion_factor = 3.3 / (65535)

while True:
reading = sensor_temp.read_u16() * conversion_factor
temperature = 27 - (reading - 0.706)/0.001721

print(temperature)
utime.sleep(1)
5 - Programar o RTC do RP2040 para gerar eventos a cada 10 segundos. Imprimir no shell
do Thonny a hora e a data correspondentes ao instante do evento.

R: Arquivo rtc.zip

● Rtc

from machine import RTC

# Initialize the RTC module

rtc = RTC()

def setRTC(year, month, day, weekday, hour, minute, second, subsecond):

# Set the RTC data
# (year, month, day, weekday, hour, minute, second, subsecond)
rtc.datetime((year, month, day, weekday, hour, minute, second, subsecond))

def getRTC():
return rtc.datetime()
6 - Usando os resultados do item 4 e 5, elaborar um programa no Thonny para gravar um
arquivo na Flash da Raspberry Pi Pico contendo a temperatura do processador e a
hora/data associados. Realizar medições a cada 10 segundos durante 1 minuto. Abrir o
arquivo e avaliar se a informação registrada está correta.

R: Arquivo time&temp.zip

● Main

import temperature
import rtc
from time import sleep

rtc.setRTC(2023, 8, 20, 6, 16, 6, 0, 0)

while True:
year, month, day, weekday, hour, minute, second, subsecond = rtc.getRTC()
temp = temperature.readTemp()
print(f"{year}-{month:02d}-{day:02d} {hour:02d}:{minute:02d}:{second:02d},{temp}")
file = open("temp.csv", "a")
file.write(f"{year}-{month:02d}-{day:02d} {hour:02d}:{minute:02d}:{second:02d},{temp}\n")
file.close()
sleep(10)
7 - Programar o RP2040 para que alterne entre os estados "acordado", SLEEP e
DORMANT entre medições de temperatura realizadas a cada 10 segundos. Usar o RTC
para gerar eventos de "wake up".

Usando o picosleep do micropython, para dormir dentro de um loop. Isso iniciará seu pico,
ativando o led por 5 segundos e depois entre no estado de sono profundo e repetir até sleeptime
chegar a 10 segundos. Provando que podemos dormir profundamente do python e continuar a
execução do código.

micropython-pico-deepsleep-1-1 (Firmware personalizado para o Raspberry Pico que permite

dormir profundamente e acordar com o relógio em tempo real. Permite baixo consumo de
corrente de 1,4mA. Inclui correção para o tempo de sono.)

import picosleep
import time
from machine import Pin

led = Pin(25, Pin.OUT)

sleeptime = 1
while sleeptime <= 10:
led.toggle()
time.sleep(5)
led.toggle()
picosleep.seconds(sleeptime)
sleeptime = sleeptime + 1

R: Não foi possível gerar uma interrupção via RTC no MicroPython, foi implementado um código
que acorda com uma interrupção via GPIO. Neste código, é configurado uma interrupção no
GPIO15 (a task que ele roda na interrupção não tem importancia, a implementação "pass", que
em Python é equivalente a um __NOP() - No operation, não funcionou, então foi implementado
apenas uma soma a uma variavel que não é usada). Assim, os 3 estados, ativo, sleep e domarnt
(utilizei um LED piscando para alertar a troca de estado), esperam a interrupção do GPIO15
para realizar a leitura da temperatura. É possivel ver na figura que não há diferença significativa
na temperatura nos 3 modos (arquivo lowpower.zip).
8 - Meça a corrente consumida pelo processador com um amperímetro e anote os valores
(alimente a placa pelo pino VSYS, em vez de utilizar o conector USB).

R: As medições foram as seguintes: modo acordado: 21mA, modo SLEEP: 19mA, modo
DORMANT: 0.7mA. Os resultados foram obtidos com um multímetro MD-1000A da empresa
ICEL Manaus, na escala de 200mA.

9 - Proponha uma forma de medir o consumo da placa em tempo real (mesmo que tenha
que usar outra placa para tal).

O Rapberry trabalha em 5V, então é necessário implementar um divisor de resistivo, pois as

GPIOs não suportam valores maiores que 3.3V.

Um divisor resistivo, é um circuito que possui resistores em série, seu objetivo é diminuir a
tensão de entrada (Vin) de forma equilibrada com a soma das resistências de R1 e R2, com isso
é possível obter uma parcela deste valor, sendo a tensão de saída (Vout).

Neste contexto, onde conhecemos as tensões de Vin e Vout, é preciso descobrir quais são os
valores de R1 e R2 adequados ao circuito. Definindo o valor de R1 como 1KΩ podemos realizar
o cálculo para descobrir qual é a intensidade da corrente para a GPIO, onde U = 5V e R = 1,000.

Observado o resultado de 0,005A (5mA), está conforme o intervalo permitido das portas do
Raspberry, sendo possível aplicar o valor de R1 na fórmula do divisor de tensão para descobrir o
valor de R2.

Sendo assim: Usando, Vin = 5V, Vout = 3,3V, R1 = 1,000.

Encontramos R2 = 1,94 KΩ, onde podemos adicionar no circuito um resistor de 2KΩ, ou dois
resistores de 1KΩ em série.
R: Utilizando dois ADCs ligados a divisores resistivos conectados a alimentação, junto de um
resistor shunt de 1 ohm em série com o dispositivo a ser medido a corrente, é possível descobrir
o valor de corrente a partir da diferença de tensão em cima do resistor shunt de 1 ohm (o valor
adquirido da diferença de tensão será equivalente a corrente). O arquivo corrente.zip contém um
print das leituras de corrente, 30, 28 e 8 mA em cada estado, além do main.py. É possível ver
que a leitura não é exata, provavelmente devido às imperfeições e tolerância dos resistores.

Demonstração Final.

R: É possível ver a demonstração final tanto em corrente.zip quanto em lowpower;zip.