Decodificadores BCD 7 segmentos

Dois esquemas de decodificadores BCD (de 0 a 9)  usando só portas de AND e OR de duas entradas e outro com o mínimo de portas lógicas.

Teste rápido para cpu 6809 e 68B09

Free run test para microprocessadores Motorola 6809 e 68B09:

Teste rápido de microcontrolador 80C31 e 80C32

Free run test para o microcontrolador 80C31 e 80C32:

Ampliação das escalas do voltímetro de alta impedância

Com apenas uma chave simples SPDT e um resistor é possível aumentar os fundos das escalas do meu voltímetro:

Dessa forma se altera as relações de ganho do amplificador operacional e amplio as escalas de medição.

Uma outra alternativa seria usar uma chave DPDT e dobrar os fundos das escalas:

Calibração de Voltímetros com o AD584

Circuito Integrado AD584

Quando temos alguns multímetros na bancada, depois de algum tempo eles se descalibram e podem fazer medições com um certo erro. O pior é que não saberemos qual faz uma medição correta e qual mede um valor com um certo erro.

Para resolver esse problema é preciso ter um padrão confiável  para fazer a comparação. No caso de tensões em corrente contínua de baixo valor, existe um circuito integrado que fornece valores de tensões padronizadas com uma precisão suficiente para uma calibração e comparação dos multímetros em modo voltímetro CC.

O AD584 da Analog Devices é um circuito integrado usado como referência de tensão, e pode fornecer valores de 10 V, 7.5 V, 5 V e 2.5 V com precisão de 0,3% graças à calibração por laser na fábrica. Para sua utilização um circuito muito simples é necessário, basta alimentá-lo com 15 V estáveis e um capacitor de 10 nF a 100 nF entre os pinos 6 e 7. As tensões são obtidas jumpeando alguns pinos conforme a tabela abaixo:

Meu multímetro mais novo é um Aneng True RMS e de fato ele está bem calibrado, mediu os três valores com exatidão:

 

A seguir testei o multímetro DT830B  bem velhinho mas ainda bem funcional. Ele apesar do tempo de uso apresentou valores aceitáveis e sem necessidade de uma calibração:

O próximo é um SANWA PM3 de bolso, que também é novo e está bem calibrado:

Agora um multímetro analógico FT360 que eu tive que ajustar um trimpot para que a medição ficasse correta. Há apenas um trimpot que fica em série com o galvanômetro, de forma que o ajuste é bem simples:

Feito o ajuste, as medidas ficaram bem precisas:

Outro multímetro analógico que eu tenho há 35 anos que apresentou medidas um pouco abaixo, mas  dentro do aceitável e como eu não achei um trimpot para ajuste vai ficar assim mesmo:

O teste com um FLUKE 111 True RMS também teve valores bem precisos:

Por fim testei meu voltímetro eletrônico de alta resistência já mostrado neste blog. Também teve medidas aceitáveis:

A montagem do ci foi em protoboard e alimentado com 15 V.

Grilo Eletrônico

Grilo Eletrônico

Um pequeno e simples circuito que fiz há muito tempo. Ele usa um fototransistor para detetar se há luz ambiente e quando fica escuro ele habilita que o PIC comece a emitir sons de um grilo, em períodos de tempo aleatórios. No caso de alguém acender a luz, ele suspende o som de grilo.  Um bom brinquedinho para as crianças.

O buzzer deve ser daqueles que emite som só com a alimentação, sem precisar de um oscilador. A combinação com os pulsos vindos do PIC é que formam o som parecido com o cri-cri de grilos.  

Código para gravar no PIC:

:100000006928210820040319A00A8030201AA106BB

:100010002019A106A018A106210DA00DA10D64288C

:10002000A301A200FF30A207031CA307031C64283E

:100030000330A100DF301E201228A101E83EA000FD

:10004000A109FC30031C2728A00703182428A007B7

:100050006400A10F242820182D28A01C312800009E

:1000600031280800A20001303828A20006303828C4

:10007000A80023082102031D3F2822082002043083

:1000800003180130031902302805031DFF306428CE

:10009000A501A4011030A600210DA40DA50D220874

:1000A000A4022308031C230FA50203185E282208BC

:1000B000A40723080318230FA5070310A00DA10D03

:1000C000A60B4C28200864288313031383126400B2

:1000D00008000730990083162F30850083128501B0

:1000E000B801B9016400851A76288F203A08A0006B

:1000F0003B08A10001202008BA002108BB003A08F3

:10010000A0003B08A1000A30A200A3014820BC00C7

:100110002108BD003D08A3003C08112070283A08C2

:10012000A0003B08A10001202008BA002108BB0064

:100130003A08A0003B08A100EA30A3006030352057

:10014000031DA6282730A300103011200330A30080

:10015000E83011200130B800B9013808A000390892

:10016000A100A30128303220031DC028051603304A

:100170001020051204301020B80A0319B90FAD2859

:08018000051208006300C2280B

:02400E008C3FE5

:00000001FF

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.