Módulo de display para Raspberry Pi

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.

Driver de motores de passo

Driver para Motores A4988

Há um tempo eu ganhei duas plaquinhas com o driver de motor A4988 da Allegro que facilita enormemente o uso de motores de passo, sem precisar fazer uma programação voltada para acionar as bobinas em sequência correta. Com esse driver, basta selecionar o microstepping desejado, a direção do motor e enviar os pulsos. E ele ainda aceita níveis lógicos de 5V de 3.3V, facilitando tanto o uso por Arduinos como Raspberry Pi.

As dimensões da plaquinha são reduzidas e já vem com duas fileiras de barras de pinos, facilitando o uso com protoboard. Segundo a datasheet, o driver permite o controle de altas correntes (2A) e mesmo com o tamanho reduzido, não esquenta muito (apesar do dissipador pequeno).

Veja como pode ser o interfaceamento com um microcontrolador:

Mas o acionamento do driver e do motor de passo não precisa de um microcontrolador (ou Arduino ou RPI).  Basta uma fonte de pulsos (eu usei um simples 555 em modo astável) e fornecer os níveis lógicos adequados para os pinos RESET, ENABLE, DIR (direção), MS!-3 (que definem o microstepping) e jogar os pulsos vindos do 555 no pino STEP.  

O vídeo com a montagem usando o 555:

https://youtu.be/-S1UQ7kd5kA

Fonte para Raspberry Pi

Fonte de Alimentação para Raspberry Pi

Eu estava com problemas para usar meus Raspberry Pis por causa da alimentação deles. Como eu não comprei uma fonte apropriada e original, pois diziam que os carregadores de celular poderiam funcionar, comecei a ter instabilidade no funcionamento das plaquinhas, sem falar no aparecimento inevitável do "raiozinho" amarelo no canto superior direito da tela (no Raspbian).  A causa é que apesar de pequeno, o Raspberry Pi consome uma corrente considerável a 5V.  E como ele é alimentado na maioria das vezes pela porta USB micro, muitas vezes o cabo usado tem uma resistência (ida e volta) que gera uma queda de tensão na alimentação da plaquinha, causando a instabilidade e reboot.

É recomendado que a fonte de alimentação tenha 5,25Vdc de tensão e forneça pelo menos 2A de corrente (3A no caso do novo Pi4). As portas USB normalmente fornecem 5V, talvez os 0,25V adicionais sejam para compensar as perdas no cabo. Como essa tensão não é comum nos reguladores lineares (ex. 7805), a alternativa seria fazer uma fonte com um regulador de tensão ajustável como o LM317T. Só que o LM317T só fornece até 1,5A (o 7805 só 1A). Existe a versão de 3A do LM317T que é o LM350T, mas o desperdício de energia em forma de calor seria muito grande e exigiria um dissipador enorme.  Um amigo (Eduardo) sugeriu usar os reguladores chaveados. Eu já usava um regulador LM2576T de 5V para alimentar os protótipos em protoboard.  O LM2576T tem uma versão ajustável cuja tensão de saída é programada por dois resistores externos. E o melhor de tudo é que ele fornece até 3A de corrente.

Pra obter os 5,25Vdc na saída, eu calculei que os resistores deveriam ser de 3300 ohms e 1000 ohms.

A fórmula é:  

Vout = Vref x (1 + R2/R1)     Sendo que Vref=1,23V   e R1 maior ou igual a 1000 ohms.

Assim:  Vout =  1,23V x (1 + 3300/1000) = 5,29V     um pouquinho a mais.

No caso, basta escolher um resistor de 3300 ohms com valor um pouco abaixo e um de 1000 ohms com valor um pouco acima (por causa das tolerâncias). Por exemplo, usar um de 3290 e outro de 1010 ohms, deixa a tensão de saída mais perto dos 5,25V.  Embora isso não seja crítico porque a tensão  vai ser derrubada por causa da perda no cabo, quem for preciosista pode selecionar os resistores mais acertados. Eu pensei em usar um trimpot, mas fiquei com medo de que uma mexida sem querer, possa alterar o valor e depois queimar o Raspberry Pi.

Um componente chato pra se usar com esse regulador é o indutor. Mas como ele não é muito crítico, eu usei um de 400uH que eu tinha, e ele funcionou sem problemas.  O LM2576 funciona com chaveamento a 52kHz e é um regulador tipo Buck (redutor de tensão com aumento da corrente de saída).

O circuito é este:

Eu optei por poder entrar com alimentação AC (transformador de 12Vac-0-12Vac) ou uma fonte de tensão de 12Vdc a 15Vdc 1A de parede que é muito comum de se achar.  Na saída coloquei um borne de parafusos e também um conector fêmea USB A duplo para ligar os cabos USB para o Raspberry Pi.

A montagem eu fiz em uma plaquinha de 10 x 5 cm, face simples, desenhada a mão mesmo.

No teste, usei uma carga de 1,66 ohms (dois resistores de 4 ohms em paralelo com um de 10 ohms) para consumir perto dos 3A.  O consumo foi de 2,8A e a tensão na fonte ficou em 5,14Vdc.  Depois no teste com o Raspberry Pi 3, usei até o meu cabo USB mais longo de 2m e a tensão medida no barramento da plaquinha do Pi3 foi de 5,05Vdc (com teclado, mouse, wifi, Bluetooth tudo ligado e rodando programa Python), com mínimo de 4,90Vdc no boot.