Exibindo o tempo acima de 7 dígitos de 4

Todos nós sabemos que Raspberry Pi é uma plataforma de desenvolvimento maravilhosa baseada no microprocessador ARM. Com seu alto poder computacional, ele pode fazer maravilhas nas mãos de entusiastas da eletrônica ou estudantes. Tudo isso só será possível se soubermos fazer com que ele interaja com o mundo real e analise os dados por meio de algum dispositivo de saída. Existem muitos sensores que podem detectar certos parâmetros do mundo em tempo real e transferi-los para um mundo digital e nós os analisamos vendo-os em uma tela LCD ou algum outro display. Porém, nem sempre seria econômico usar uma tela LCD com PI para exibir pequenas quantidades de dados. É aqui que preferimos usar a tela LCD alfanumérica 16x2 ou a tela de 7 segmentos. Já aprendemos como usar um LCD alfanumérico e um display de 7 segmentos de segmento único com Raspberry pi. Hoje vamosFaça interface com o módulo de exibição de sete segmentos de 4 dígitos com Raspberry Pi e exiba o tempo sobre ele.

Embora o LCD alfanumérico 16x2 seja muito mais confortável do que o display de 7 segmentos, há poucos cenários em que um display de 7 segmentos seria mais prático do que um display LCD. O LCD tem a desvantagem de ter um tamanho pequeno de caracteres e será um exagero para o seu projeto se você estiver planejando apenas exibir alguns valores numéricos. 7 segmentos também têm a vantagem contra condições precárias de iluminação e podem ser vistos de ângulos maiores do que uma tela LCD normal. Então, vamos começar a conhecê-lo.

Módulo de exibição de 7 segmentos e 4 dígitos e 7 segmentos:

O display de 7 segmentos tem sete segmentos e cada segmento tem um LED dentro dele para exibir os números iluminando os segmentos correspondentes. Por exemplo, se você quiser que o segmento de 7 exiba o número "5", então você precisa iluminar o segmento a, f, g, c e d aumentando seus pinos correspondentes. Existem dois tipos de visores de 7 segmentos: cátodo comum e ânodo comum, aqui estamos usando o visor de cátodo comum de sete segmentos. Saiba mais sobre o display de 7 segmentos aqui.

Agora sabemos como exibir nosso caractere numérico desejado em um único display de 7 segmentos. Porém, é bastante evidente que precisaríamos de mais de um display de 7 segmentos para transmitir qualquer informação com mais de um dígito. Portanto, neste tutorial, usaremos um módulo de exibição de 7 segmentos de 4 dígitos, conforme mostrado abaixo.

Como podemos ver, existem quatro monitores de sete segmentos conectados entre si. Sabemos que cada módulo de 7 segmentos terá 10 pinos e para 4 visores de sete segmentos haveria 40 pinos no total e seria agitado para qualquer pessoa soldá-los em um quadro de pontos, então eu recomendo fortemente que qualquer pessoa compre um módulo ou faça seu próprio PCB para usar um display de 7 segmentos de 4 dígitos. O esquema de conexão para o mesmo é mostrado abaixo:

Para entender como o módulo de sete segmentos de 4 dígitos funciona, temos que olhar para os esquemas acima, como mostrado, os pinos A de todos os quatro monitores são conectados para reunir como um A e o mesmo para B, C…. até DP. Então, basicamente, se o gatilho A estiver ativado, todos os quatro A's devem ser altos, certo?

Mas isso não acontece. Temos quatro pinos adicionais de D0 a D3 (D0, D1, D2 e ​​D3) que podem ser usados ​​para controlar qual display dos quatro deve ficar alto. Por exemplo: Se eu precisar que minha saída esteja presente apenas no segundo display, então apenas D1 deve ser alto, enquanto os outros pinos (D0, D2 e ​​D3) estão baixos. Simplesmente podemos selecionar qual display deve ficar ativo usando os pinos de D0 a D3 e qual caractere ser exibido usando os pinos de A a DP.

Conectando o módulo de 7 segmentos de 4 dígitos ao Raspberry Pi:

Vamos ver como, como podemos conectar este módulo de 7 segmentos de 4 dígitos com nosso Raspberry Pi. O módulo de 7 segmentos possui 16 pinos, conforme mostrado abaixo. Seu módulo pode ter menos, mas não se preocupe, ainda terá o seguinte com certeza

1. Pinos de 7 ou 8 segmentos (aqui pinos começando de 1 a 8)
2. Pino de aterramento (aqui pino 11)
3. 4 pinos de dígitos (aqui pinos 13 a 16)

Abaixo é fornecido o esquema do relógio digital raspberry pi conectando o módulo de exibição de 7 segmentos de 4 dígitos ao Raspberry Pi:

A tabela a seguir também o ajudará a fazer as conexões e verificar se estão de acordo com os esquemas mostrados acima.

S.Não	Número Rsp Pi GPIO	Número Rsp Pi PIN	7-Nome do segmento	Número do pino de 7 Seg (aqui neste módulo)
1	GPIO 26	PIN 37	Segmento a	1
2	GPIO 19	PIN 35	Segmento b	2
3	GPIO 13	PIN 33	Segmento c	3
4	GPIO 6	PIN 31	Segmento d	4
5	GPIO 5	PIN 29	Segmento e	5
6	GPIO 11	PIN 23	Segmento f	6
7	GPIO 9	PIN 21	Segmento g	7
8	GPIO 10	PIN 19	Segmento DP	8
9	GPIO 7	PIN 26	Dígito 1	13
10	GPIO 8	PIN 24	Dígito 2	14
11	GPIO 25	PIN 22	Dígito 3	15
12	GPIO 24	PIN 18	Dígito 4	16
13	Terra	Terra	Terra	11

Identifique os pinos em seu módulo e você estará pronto para prosseguir com as conexões. Identificar os pinos GPIO no Raspberry pi pode ser uma tarefa um pouco desafiadora, então forneci esta imagem para os pinos GPIO.

Programando seu Raspberry Pi:

Aqui, estamos usando a linguagem de programação Python para programar RPi. Existem muitas maneiras de programar o Raspberry Pi. Neste tutorial estamos usando o IDE Python 3, já que é o mais usado. O programa Python completo é fornecido no final deste tutorial. Saiba mais sobre o programa e código de execução no Raspberry Pi aqui.

Vamos falar sobre alguns comandos que vamos usar no programa PYHTON para este projeto, Primeiro vamos importar o arquivo GPIO da biblioteca, a função abaixo nos permite programar os pinos GPIO do PI. Também estamos renomeando “GPIO” para “IO”, portanto, no programa, sempre que quisermos nos referir aos pinos GPIO, usaremos a palavra 'IO'. Também importamos hora e data e hora para ler o valor de tempo de Rsp Pi.

import RPi.GPIO como GPIO import time, datetime

Às vezes, quando os pinos GPIO, que estamos tentando usar, podem estar executando algumas outras funções. Nesse caso, receberemos avisos durante a execução do programa. O comando abaixo diz ao PI para ignorar os avisos e prosseguir com o programa.

IO.setwarnings (falso)

Podemos referir os pinos GPIO do PI, tanto pelo número do pino a bordo quanto pelo número da função. Como 'PIN 29' na placa é 'GPIO5'. Portanto, dizemos aqui que vamos representar o pino aqui por '29' ou '5'. GPIO.BCM significa que representaremos usando 5 para GPIO5 pino 29.

IO.setmode (GPIO.BCM)

Como sempre, devemos começar inicializando os pinos, aqui tanto os pinos de segmento quanto os pinos de dígitos são pinos de saída. Para fins de programação, formamos arrays para pinos de segmento e os inicializamos com '0' após declará-los como GPIO.OUT

segmento8 = (26,19,13,6,5,11,9,10) para o segmento no segmento 8: GPIO.setup (segmento, GPIO.OUT) GPIO.output (segmento, 0)

Da mesma forma, para os pinos de dígitos, nós os declaramos como pinos de saída e os tornamos '0' por padrão

#Digit 1 GPIO.setup (7, GPIO.OUT) GPIO.output (7, 0) # Desliga inicialmente #Digit 2 GPIO.setup (8, GPIO.OUT) GPIO.output (8, 0) # Desliga inicialmente #Digit 3 GPIO.setup (25, GPIO.OUT) GPIO.output (25, 0) # Desliga inicialmente #Digit 4 GPIO.setup (24, GPIO.OUT) GPIO.output (24, 0) # Desliga inicialmente

Temos que formar matrizes para exibir cada número em um display de sete segmentos. Para exibir um número, temos que controlar todos os 7 pinos de segmento (pino de ponto excluído), ou seja, eles devem ser desligados ou ligados. Por exemplo, para exibir o número 5, devemos fazer o seguinte arranjo

S.Não	Número Rsp Pi GPIO	7-Nome do segmento	Status para exibir '5'. (0-> OFF, 1-> ON)
1	GPIO 26	Segmento a	1
2	GPIO 19	Segmento b	1
3	GPIO 13	Segmento c	0
4	GPIO 6	Segmento d	1
5	GPIO 5	Segmento e	1
6	GPIO 11	Segmento f	0
7	GPIO 9	Segmento g	1

Da mesma forma, temos um número de sequência para todos os números e alfabetos. Você pode escrever por conta própria ou usar a tabela abaixo.

Com esses dados, podemos formar as matrizes para cada número em nosso programa python, conforme mostrado abaixo.

nulo = zero = um = dois = três = quatro = cinco = seis = sete = oito = nove =

Se você seguir o programa, haverá uma função para exibir cada personagem ao nosso display de 7 segmentos, mas, vamos ignorar isso por agora e entrar no enquanto loop infinito. Onde ler o tempo presente do Raspberry Pi e dividir o valor do tempo entre quatro variáveis. Por exemplo, se o tempo for 10,45, a variável h1 terá 1, h2 terá 0, m1 terá 4v e m2 terá 5.

now = datetime.datetime.now () hora = now.hour minuto = now.minute h1 = hora / 10 h2 = hora% 10 m1 = minuto / 10 m2 = minuto% 10 imprimir (h1, h2, m1, m2)

Temos que exibir esses quatro valores de variáveis ​​em nossos quatro dígitos, respectivamente. Para escrever um valor de variável em um dígito, podemos usar as seguintes linhas. Aqui, somos exibidos no dígito 1, tornando-o alto, então a função print_segment (variável) será chamada para exibir o valor na variável no display do segmento. Você pode estar se perguntando por que temos um atraso depois disso e por que desativamos esse dígito depois disso.

GPIO.output (7, 1) #Ligue o Dígito Um print_segment (h1) #Print h1 no segmento time.sleep (delay_time) GPIO.output (7, 0) #Desative o Dígito Um

A razão é, como sabemos, podemos exibir apenas um dígito por vez, mas temos quatro dígitos a serem exibidos e somente se todos os quatro dígitos forem exibidos o número completo de quatro dígitos ficará visível para o usuário.

Então, como exibir todos os 4 dígitos ao mesmo tempo ?

Para nossa sorte, nosso MPU é muito mais rápido do que o olho humano, então o que realmente fazemos: exibimos um dígito por vez, mas fazemos isso muito rápido, conforme mostrado acima.

Selecionamos um dígito para exibi-lo e esperar 2ms (variável delay_time) para que o MPU e o segmento 7 possam processá-lo e então desligamos aquele dígito e passamos para o próximo dígito e fazemos o mesmo até chegarmos ao último dígito. Este atraso de 2 ms não pode ser observado por um olho humano e todos os quatro dígitos parecem estar LIGADOS ao mesmo tempo.

A última coisa a aprender é saber como funciona a função print_segment (variável) . Dentro desta função, usamos os arrays que declaramos até agora. Portanto, qualquer variável que enviarmos para esta função deve ter o valor entre (0-9), o caractere da variável receberá esse valor e o comparará com o valor real. Aqui, a variável é comparada com '1'. Da mesma forma, comparamos com todos os números de 0 a 9. Se for uma correspondência, usamos as matrizes e atribuímos cada valor a seus respectivos pinos de segmento, conforme mostrado abaixo.

def print_segment (charector): se charector == 1: para i no intervalo (7): GPIO.output (segmento8, um)

Exibir o tempo em 4 dígitos e 7 segmentos usando Raspberry Pi:

Use o esquema e o código fornecidos aqui para fazer as conexões e programar o raspberry pi de acordo. Depois que tudo estiver feito, basta iniciar o programa e você deverá encontrar a hora atual exibida no display de sete segmentos. Mas, existem algumas coisas que você deve verificar antes de

1. Certifique-se de ter definido o seu Raspberry Pi com a hora atual, apenas no caso de ser executado no tempo offline.
2. Alimente seu Raspberry pi com um adaptador e não com seu laptop / computador, porque a quantidade de corrente consumida pelo monitor de 7 segmentos é alta e sua porta USB não pode fornecer.

Se tudo estiver funcionando conforme o esperado, você deverá encontrar algo assim abaixo.

O funcionamento completo deste relógio raspberry pi também pode ser conferido no vídeo abaixo. Espero que você tenha gostado do projeto e gostado de construir um. Deixe-me saber o que você pensa ou se precisar de ajuda.