Monitor de Temperatura e Uso do Processador do Raspberry Pi
Há muito tempo eu tinha montado uma plaquinha com 3 displays de 7 segmentos e um tecladinho para usar com projetos com PICs. Mas eles também servem para ser usados com outras plataformas, como o Arduíno e o Raspberry Pi.
Eu uma revista inglesa eu vi um projeto interessante para usar um display OLED para monitorar a temperatura, o uso de processamento e a memória do Raspberry Pi. Eu até tenho o display OLED, mas resolvi usar um display de leds para fazer esse monitoramento.
A linguagem utilizada é o Python, que é bem fácil de aprender e programar. A parte mais importante é saber quais módulos importar para ter algumas funções que desempenhem o trabalho. Dois módulos são importantes nesse caso: o "psutil" e o "gpiozero", além do "time". O primeiro vai permitir que se leia o nível de processamento do Raspberry, e o módulo gpiozero facilita para acionar os segmentos e os displays através das portas GPIO do Raspberry.
O esquema da plaquinha do display é o seguinte:
É importante lembrar que as portas do Raspberry tem capacidade de corrente bem menor do que os PICs ou do Arduíno. Uma GPIO do Pi pode fornecer até 16mA individualmente e até 50mA somadas todas as portas. Além disso a tensão delas é de 3,3V. Considerando que a tensão sobre o segmento led seja de 1,7V e a tensão Vce do transistor chaveador esteja por volta de 0,3V, a corrente por porta chegaria a um valor aproximado de 1,3V/330ohms = 4mA por porta/segmento, o que está bem confortável. Como os transistores são PNP e os displays são anodo comum, os acionamentos se farão com nível lógico baixo nas portas GPIO. Além disso, os displays serão multiplexados.
Uma foto da minha plaquinha e tecladinho:
Aqui a placa com mais detalhe:
Os resistores estão pelo lado de baixo e são SMDs 1206.
Para interligar com o Pi, eu uso aqueles fios com conectores fêmea nas duas pontas, vendidos já prontos e comuns nos kits de Arduíno.
Agora a listagem do programa em Python 3:
##################################################################
from gpiozero import Button, LED
from time import sleep
import psutil
segma = LED(14) #designa as portas para cada segmento
segmb = LED(15)
segmc = LED(18)
segmd = LED(23)
segme = LED(24)
segmf = LED(25)
segmg = LED(8)
segmp = LED(7)
anod1 = LED(11) #designa as portas para chavear os displays
anod2 = LED(9)
anod3 = LED(10)
anod1.on() #desliga os displays
anod2.on()
anod3.on()
tempo = 0.005 #tempo de acionamento de cada display 5ms
unidade = 0
dezena = 0
centena = 0
def digito(x): #função para codificar os segmentos de acordo com o digito
if x == 0:
segma.off()
segmb.off()
segmc.off()
segmd.off()
segme.off()
segmf.off()
segmg.on()
elif x == 1:
segma.on()
segmb.off()
segmc.off()
segmd.on()
segme.on()
segmf.on()
segmg.on()
elif x == 2:
segma.off()
segmb.off()
segmc.on()
segmd.off()
segme.off()
segmf.on()
segmg.off()
elif x == 3:
segma.off()
segmb.off()
segmc.off()
segmd.off()
segme.on()
segmf.on()
segmg.off()
elif x == 4:
segma.on()
segmb.off()
segmc.off()
segmd.on()
segme.on()
segmf.off()
segmg.off()
elif x == 5:
segma.off()
segmb.on()
segmc.off()
segmd.off()
segme.on()
segmf.off()
segmg.off()
elif x == 6:
segma.off()
segmb.on()
segmc.off()
segmd.off()
segme.off()
segmf.off()
segmg.off()
elif x == 7:
segma.off()
segmb.off()
segmc.off()
segmd.on()
segme.on()
segmf.on()
segmg.on()
elif x == 8:
segma.off()
segmb.off()
segmc.off()
segmd.off()
segme.off()
segmf.off()
segmg.off()
elif x == 9:
segma.off()
segmb.off()
segmc.off()
segmd.off()
segme.on()
segmf.off()
segmg.off()
def scan(): #faz a multiplexação dos displays
digito(unidade)
anod1.off()
sleep(tempo)
anod1.on()
digito(dezena)
segmp.off()
if dezena == 0 and
centena == 0:
anod2.on()
else:
anod2.off()
sleep(tempo)
anod2.on()
segmp.on()
digito(centena)
if centena == 0:
anod3.on()
else:
anod3.off()
sleep(tempo)
anod3.on()
while True:
#print(centena,dezena,unidade) #mostra os valores no shell
for i in
range(50):
scan() #chama a multiplexação
#obtem o valor da temperatura do processador
f=open("/sys/class/thermal/thermal_zone0/temp","r")
t=f.readline()
t=float(t)
t=round(t/1000,2)
# mostra a temperatura no shell
print(t)
centena
= int(t/10)
dezena = int(t-(10*centena))
unidade =
10*(t-(10*centena)-dezena)
for i in range(50):
scan() #chama a multiplexação
# obtem o uso de processamento da CPU
cpu=psutil.cpu_percent(interval=1)
cpu=round(cpu)
print(cpu) # mostra o uso no shell
centena = int(cpu/100)
dezena =
int((cpu-(centena*100))/10)
unidade = cpu - (10*dezena) -
(100*centena)
################################################################
O programa em Python lê o valor do sensor de temperatura interno do processador e mostra o valor no display em °C (o valor de 3 dígitos), em seguida obtém o valor porcentual de uso do processador (de 0 a 100) e mostra no display. Não implementei o valor de uso da memória RAM.
No programa Python é importante se ater ao indentamento correto de cada linha (a tabulação é de 4 espaços por vez).
Aqui um vídeo mostrando o monitoramento da temperatura e do processamento:
https://youtu.be/5Pkx20tYdWs
Houve algum problema no acionamento do ponto decimal, portanto a temperatura não é de 444°C, mas de 44.4°C.
E o vídeo com o Raspberry rodando Minecraft:
https://youtu.be/NlfPD95fYDw
Eu rodei o programa e a placa ligados a um Raspberry Pi 1 modelo B, com 512M de RAM. Deve rodar sem problemas nas versões mais modernas do Raspberry.
