74HC595 Shift Register Interface com Arduino

Publicado em por
Tempo de leitura: 11 minutes

O IC 74HC595 é um IC de registro de deslocamento de 16 pinos que consiste em uma trava do tipo D junto com um registrador de deslocamento dentro do chip. Ele recebe dados de entrada serial e, em seguida, envia esses dados através de pinos paralelos. Além das saídas paralelas, também fornece uma saída serial. Possui entradas de clock independentes para o registrador de deslocamento e trava D. Este IC pertence à família HC de dispositivos lógicos que são projetados para uso em aplicações CMOS.

74HC595 tem dois registradores embutidos. O primeiro é um registrador de deslocamento e o segundo é um registrador de armazenamento. Os dados são transferidos em série para o registrador de deslocamento bit a bit. Mas ele é transferido para o registrador de armazenamento somente quando o pino de trava de dados está ativo alto.

 

Diagrama de Pinagem 74HC595

Se você procurar registradores de deslocamento da série 595, existem muitas variantes e modelos disponíveis no mercado. Mas todos funcionam da mesma maneira. Eles têm a mesma configuração de pinos, recursos elétricos, diagrama de pinagem e princípio de funcionamento. Mas este tutorial será mais focado no SN74HC595N por instrumentos do texas.

Agora, olhe para o diagrama de pinagem. O sinal de inclinação ~ mostra que esses pinos operam em sinais ativos baixos ou em lógica negativa. Veremos os detalhes da lógica negativa mais adiante neste tutorial.

Relacionado aos pinos de saída, pois é um registrador de deslocamento de 8 bits. SN74HC595N tem oito pinos de saída de Q0-Q7.

Detalhes da configuração do pino

Nesta seção, vemos a descrição dos pinos de todos os pinos, juntamente com seu funcionamento e funcionalidade.

Pino nº 01, 02, 03, 04, 05, 06, 07, 15: Pinos de saída

Esses oito pinos são os pinos de saída do registrador de deslocamento. Devemos conectar esses pinos a qualquer periférico onde desejamos exibir os dados do registro de armazenamento. Os componentes comumente usados são como LED, displays de sete segmentos, etc.

Pino nº 08: GND

Este é o pino terra e está conectado ao terra do circuito.

Pino nº 09: Q7′

É uma saída de dados serial não invertida que sai do oitavo estágio de um registrador de deslocamento. Também é usado para fins de cascata. Por exemplo, se precisarmos de registrador de deslocamento de 16 bits. Podemos encadear dois CIs 74HC595. Para fazer isso, basta conectar o pino ~Q7 com o pino DS de entrada Serial do 2º 595 IC. Além disso, fornece o mesmo sinal de clock para ambos os circuitos integrados. Desta forma, dois 74HC595 funcionarão como um único registrador de deslocamento de 16 bits. Além disso, você pode continuar esse processo para conectar quantos ICs desejar para obter mais largura de dados.

Pino nº 10: ~MR

É uma entrada assíncrona de reset mestre ativo baixo que é usada para resetar apenas o registrador de deslocamento. A trava de 8 bits não é afetada por esta entrada. A aplicação de um sinal baixo no pino 10 redefinirá apenas a parte do registrador de deslocamento.

Pino nº 11: SH_CP

Este é o pino de entrada do clock de um registrador de deslocamento 74hc595. Um dado é deslocado do pino de entrada serial para o registrador de deslocamento de 8 bits em cada transição positiva do sinal de clock aplicado neste pino.

Pino nº 12: ST_CP

Este é o pino de entrada de clock alto ativo de um registrador de armazenamento. Uma transição positiva de um sinal neste pino é usada para atualizar os dados para os pinos de saída.

Pino nº 13: ~OE

O pino de habilitação de saída está ativo baixo. Quando este pino está baixo, os dados no registro de armazenamento aparecem na saída. Ao aplicar sinais altos, as saídas são desligadas forçando-as para o estado de alta impedância. No entanto, a saída serial não é afetada. Para operações normais, é mantido baixo.

Pino nº 14: DS

Este é o pino de entrada de dados seriais, onde os dados de entrada são fornecidos.

Pino nº 16: Vcc

Uma fonte de alimentação positiva é fornecida neste pino.

 

Recursos do 74HC595

  • É um registrador de deslocamento com entrada serial de 8 bits e saídas seriais de 8 bits ou paralelas de 3 estados.
  • A tensão de operação deste IC é de 2V a 6V.
  • A tensão de saída é igual à tensão de operação deste CI.
  • Ele é baseado na lógica CMOS e, portanto, consome uma potência muito baixa de 80uA.
  • A fonte de saída/corrente do dissipador é de 35mA.
  • Tem uma característica de alta imunidade a ruídos.
  • Ele pode ser facilmente conectado em cascata através do pino 9 com mais IC para obter mais saídas.
  • A frequência máxima do clock é 25Mhz @4.5V.
  • A ação do gatilho Schmitt é fornecida em todas as entradas.

 

Alternativos Shift Register

  • CD4035
  • CD4015
  • CD4014
  • 74LS166

 

Onde usar 74HC595?

Você já se perguntou como um engenheiro embarcado controla centenas de diodos emissores de luz conectados em série ou em paralelo com a ajuda de um microcontrolador que possui poucos pinos de E/S de uso geral? Além disso, você deseja controlar mais de 8 servomotores e possui apenas 2-3 pinos GPIO de um microcontrolador. Como você vai resolver esse problema? Como você controlará uma matriz de LED de diferentes dimensões, como 8×8, 16×16, 32×32 com pinos GPIO mínimos de um microcontrolador? A resposta simples é um registrador de deslocamento 74HC595.

Na maioria das aplicações, você precisa de mais saídas para interfacear LEDs ou qualquer outro dispositivo, como sete segmentos, 16 segmentos, pisca LED, etc. Este IC é muito prático de usar. Para aumentar os pinos de saída, você pode fazer a interface deste IC com diferentes microcontroladores, como Arduino Uno, Microcontrolador PIC, Atmel, etc. Você pode usar este IC em projetos de design que exigem o controle de várias saídas.

74HC595 Princípio de Funcionamento do Shift Register

Como mencionado anteriormente, o registrador de deslocamento 74HC595 interno consiste em dois registradores, como registrador de deslocamento e registrador de armazenamento. Ambos são de 8 bits de largura. O primeiro é responsável por aceitar a entrada de dados em cada borda positiva do clock e continua recebendo dados. Mas os dados do registrador de deslocamento são transferidos para o registrador de armazenamento somente quando aplicamos um sinal alto ativo ao pino de entrada do latch.

Como usar o registro de deslocamento 74HC595?

  • Ele tem oito saídas e 3 pinos de entrada que incluem um pino de dados, pino de clock do resistor de armazenamento e pino de clock do registrador de deslocamento. Conecte o pino8 ao terra e o pino16 à fonte de tensão de +5V.
  • O pino de habilitação de saída (~OE) deve ser aterrado para habilitar os pinos de saída do registrador de deslocamento. O pino de reinicialização mestre limpará a memória de um registrador de deslocamento se for aplicado com um sinal baixo. É por isso que deve ser mantido alto.
  • Quando a transição de borda positiva ocorre no pino 11, o registrador de deslocamento aceitará as entradas aplicadas na linha de dados.
  • As saídas do registrador de armazenamento são conectadas aos pinos de entrada do D-latch/resistor de armazenamento.
  • Essas entradas são atualizadas na saída do latch quando ocorre uma transição de borda positiva no pino 12.

Mais importante ainda, se você precisar conectar vários ICs em cascata, o pino 9 será conectado ao pino de dados de outro IC de registro de deslocamento.

 

74HC595 Shift Register Interface com Arduino

Neste exemplo, veremos como fazer a interface do IC do registrador de deslocamento 74HC595 com o Arduino.

Neste exemplo, vamos controlar 8 LEDs com um registrador de deslocamento 74HC595 e Arduino. Para fazer a interface do 74HC595 com o Arduino, usaremos três pinos digitais. Todos os três pinos serão usados como pinos de saída digital. Esses três pinos são os pinos de clock, dados e trava.

Diagrama de ligação

Como mencionamos anteriormente, o registrador de deslocamento recebe dados de um bit em série em cada transição de borda positiva do sinal de clock e o registrador de deslocamento contém esses dados. Para enviar dados do registrador de deslocamento para o registrador de saída ou pinos de saída (Q0-Q7), devemos ativar o pino de trava fornecendo um pulso de borda positivo. Portanto, um pino do Arduino fornecerá um sinal de trava.

Agora faça as conexões do Arduino Com o registrador de deslocamento 74HC595 de acordo com esta tabela. Conectamos o pino de habilitação (~OE) com o terra que ativa este IC. Porque é um pino ativo-baixo. Também podemos controlar este pino através de um pino digital Arduino. Mas apenas para salvar o pino do Arduino, é melhor fornecer um sinal com fio conectando-o diretamente ao terra.

Arduino74HC595
D11Output Register Clock (Pin12)
D9Shift Register Clock (Pin10)
D12Data in (Pin14)
GNDOutput Enable (Pin13)
+5VShift Register Clear (Pin10)
+5VPower (Pin16)
GNDGround (Pin8)

Conexões de LEDs

Conecte oito pinos de saída com LEDs através de resistores limitadores de corrente. Este circuito acenderá todos esses LEDs sequencialmente com algum atraso.

Código Arduino

Este código é para controlar LEDs com registrador de deslocamento serial 74HC595.

#define LATCH_pin 11    // (11) ST_CP [RCK] no 74HC595
#define CLCOK_pin  9    // (9) SH_CP [SCK] no 74HC595
#define DATA_pin 12     // (12) DS [S1] no 74HC595

void clock_signal(void){
   digitalWrite(CLCOK_pin, HIGH);
    delayMicroseconds(500);
   digitalWrite(CLCOK_pin, LOW);
    delayMicroseconds(500);
}
void latch_enable(void)
   {
    digitalWrite(LATCH_pin, HIGH);
    delayMicroseconds(500);
    digitalWrite(LATCH_pin, LOW);
    }
void send_data(unsigned int data_out)
{
    int i;
    unsigned hold;
    for (i=0 ; i<8 ; i++)
    {
        if ((data_out >> i) & (0x01))
        digitalWrite(DATA_pin,HIGH); 
        else
        digitalWrite(DATA_pin,LOW); 
        
        clock_signal();
    }
    latch_enable(); // Dados finalmente enviados
}

void setup() 
{
  pinMode(LATCH_pin , OUTPUT);
  pinMode(DATA_pin , OUTPUT);  
  pinMode(CLCOK_pin , OUTPUT);
  digitalWrite(LATCH_pin, LOW);    // (11) ST_CP [RCK] no 74HC595
  digitalWrite(CLCOK_pin, LOW);    // (9) SH_CP [SCK] no 74HC595
  digitalWrite(DATA_pin, LOW);     // (12) DS [S1] no 74HC595
  Serial.begin(9600);
}

void loop() 
{
  
        send_data(0b00000000);
        delay(1000);
        send_data(0b10000000);
        delay(1000);
        send_data(0b01000000);
        delay(1000);
        send_data(0b00100000);
        delay(1000);
        send_data(0b00010000);
        delay(1000);
        send_data(0b00001000);
        delay(1000);
        send_data(0b00000100);
        delay(1000);
        send_data(0b00000010);
        delay(1000);
        send_data(0b00000001);
        delay(1000);
}

 

Como o código funciona?

Configurar pinos digitais do Arduino

Primeiro, precisamos definir os pinos GPIO do microcontrolador Arduino que usaremos como pinos de dados, clock e trava. Portanto, usamos a diretiva #define para definir os pinos. Usamos os pinos D12, D11 e D9 do Arduino como DATA_pin, LATCH_pin e CLCOK_pin, respectivamente.

#define LATCH_pin 11    // (11) ST_CP [RCK] no 74HC595
#define CLCOK_pin  9    // (9) SH_CP [SCK] no 74HC595
#define DATA_pin 12     // (12) DS [S1] no 74HC595

74HC494 Função de Sinal de Relógio

Primeiro, declaramos uma função que fornece um sinal de clock para o pino ST_CP do registrador de deslocamento 74HC595. Esta função clock_signal() gera um sinal de clock com um período de tempo de 1ms ou uma frequência de 1KHz. Porque o tempo ligado é de 500 microssegundos e o tempo desligado também é de 500 microssegundos. Usamos uma função delayMicroseconds() do compilador IDE do Arduino para adicionar um atraso entre o tempo de ativação e desativação do sinal do relógio.

void clock_signal(void){
   digitalWrite(CLCOK_pin, HIGH);
    delayMicroseconds(500);
   digitalWrite(CLCOK_pin, LOW);
    delayMicroseconds(500);
}

Lembre-se, também podemos conseguir isso usando o PWM do Arduino e também através da comunicação SPI. Mas por uma questão de simplicidade, usamos um método de atraso para gerar um sinal de clock.

 

Fornecendo sinal de trava para 74HC595

Como vimos anteriormente, o pino de entrada de dados seriais transfere dados de 8 bits serialmente para o registrador de deslocamento interno do 74HC595. Mas esses dados não refletem nos pinos de saída, a menos que apliquemos um sinal de borda positivo no pino de trava (SH_CP). Esta rotina latch_enable() fornece um sinal de habilitação de trava. Sempre que quisermos enviar dados para os pinos de saída (Q0-Q7), chamaremos esta função dentro do código.

void latch_enable(void)
   {
    digitalWrite(LATCH_pin, HIGH);
    delayMicroseconds(500);
    digitalWrite(LATCH_pin, LOW);
    }

Enviando dados em série

Agora sabemos que definimos as funções de sinal de relógio e habilitação de trava. A principal coisa que resta agora é definir uma função para transferir dados de 8 bits serialmente para o DS_pin do IC 74HC595. Para isso, declaramos uma função send_data(unsigned int data_out).

void send_data(unsigned int data_out)
{
    int i;
    unsigned hold;
    for (i=0 ; i<8 ; i++)
    {
        if ((data_out >> i) & (0x01))
        digitalWrite(DATA_pin,HIGH); 
        else
        digitalWrite(DATA_pin,LOW); 
        
        clock_signal();
    }
    latch_enable(); // Dados finalmente enviados
}

Chamamos esta função com dados de 8 bits como um argumento de entrada como este send_data(2). Também podemos escrever send_data(2) como este send_data(0b00000010). com esta expressão, passamos os dados para a função no formato binário “send_data(0b00000010)”.

Dentro da rotina send_data(), precisamos enviar dados de 8 bits bit a bit serialmente. Porque esta função aceita dados de 8 bits com a variável data_out. Para enviar esses dados de 8 bits em série, usamos o operador de deslocamento à esquerda e a porta AND lógica. O loop “For” é executado 8 vezes porque os dados têm 8 bits de largura. Além disso, também chamamos clock_signal() depois de enviar Data_pin de 1 bit. Porque a transição de dados ocorre apenas na borda positiva do relógio. Após transferir todos os 8 bits para o registrador de deslocamento, a chamada da função latch_enable move os dados para os pinos de saída.

A transmissão de dados serial inicia a transferência de dados com o bit mais significativo primeiro e assim por diante e as transferências LSB no final.

Função de configuração

Dentro do código setup(), inicializamos os pinos digitais D12, D11 e D9 como pinos de saída digital. A função pinMode() é usada para configurar os pinos do microcontrolador pic como saída ou entrada.

pinMode(LATCH_pin , OUTPUT);
pinMode(DATA_pin , OUTPUT);  
pinMode(CLCOK_pin , OUTPUT);
digitalWrite(LATCH_pin, LOW);    // (11) ST_CP [RCK] no 74HC595
digitalWrite(CLCOK_pin, LOW);    // (9) SH_CP [SCK] no 74HC595
digitalWrite(DATA_pin, LOW);     // (12) DS [S1] no 74HC595

Ao final, para fins de demonstração, enviamos dados para acender oito LEDs sequencialmente. A partir de Q0-Q7. Como você pode ver nestas linhas, no início, enviamos o MSB um e todos os outros bits zero. Mas ele aparecerá no pino Q0 e o restante dos pinos será zero. Da mesma forma, a lógica alta aparece em outros pinos com um atraso de 1000ms.

send_data(0b00000000);
        delay(1000);
        send_data(0b10000000);
        delay(1000);
        send_data(0b01000000);
        delay(1000);
        send_data(0b00100000);
        delay(1000);
        send_data(0b00010000);
        delay(1000);
        send_data(0b00001000);
        delay(1000);
        send_data(0b00000100);
        delay(1000);
        send_data(0b00000010);
        delay(1000);
        send_data(0b00000001);
        delay(1000);

 

Demo

74HC595 Interface com display de 7 segmentos e Arduino

Nesta seção, aprenderemos a fazer a interface do 74HC595 com um display de 7 segmentos e Arduino. Usando um registrador de deslocamento 74HC595 para acionar displays de 7 segmentos com Arduino, podemos salvar pinos GPIO do Arduino.

Por que usar o 74HC595 para acionar monitores de 7 segmentos?

No último tutorial sobre a interface de exibição de 7 segmentos com o Arduino, vimos que, se fizermos a interface de um dispositivo de 7 segmentos diretamente com o Arduino, precisaremos de 8 pinos digitais do Arduino. Da mesma forma, se usarmos displays de sete segmentos de dois dígitos, três dígitos e quatro dígitos, precisaremos de mais pinos GPIO, mesmo se usarmos as técnicas de multiplexação para salvar os pinos do microcontrolador.

Portanto, usando um registrador de deslocamento serial 74HC595, podemos salvar os pinos digitais do Arduino e usá-los para outros fins. Por exemplo, se usarmos este IC registrador de deslocamento serial, podemos fazer a interface de 7 segmentos com o Arduino usando apenas três pinos, em vez de usar 8 pinos digitais.

Diagrama esquemático

Este diagrama esquemático mostra a conexão entre o IC do registrador de deslocamento, o Arduino e o segmento de 7 dígitos do tipo catodo comum.

Como você pode ver no diagrama esquemático, conectamos 74HC595 com a unidade de exibição na sequência de pinos de saída (Q0-Q7) de acordo com esta tabela.

74HC595Pinos de 7 segmentos
Q0A
Q1B
Q2C
Q3D
Q4E
Q5F
Q6G
Q7DP

 

Sketch do Arduino

Este sketch do Arduino exibe números de 0 a 9 em um display de 7 segmentos de um dígito com um atraso de um segundo.

#define LATCH_pin 8   // (8) ST_CP [RCK] no 74HC595
#define CLCOK_pin 12  // (12) SH_CP [SCK] no 74HC595
#define DATA_pin 11   // (11) DS [S1] no 74HC595

unsigned char binary_pattern[] = {
  	0b11111010,
    0b01100000,
  	0b11011100,
  	0b11110100,
  	0b01100110,
  	0b10110110,
  	0b10111110,
  	0b11100000,
  	0b11111110,
  	0b11100110,
};
unsigned int counter=0;

void clock_signal(void){
   digitalWrite(CLCOK_pin, HIGH);
    delayMicroseconds(500);
   digitalWrite(CLCOK_pin, LOW);
    delayMicroseconds(500);
}
void latch_enable(void)
   {
    digitalWrite(LATCH_pin, HIGH);
    delayMicroseconds(500);
    digitalWrite(LATCH_pin, LOW);
    }
void send_data(unsigned int data_out)
{
    int i;
    unsigned hold;
    for (i=0 ; i<8 ; i++)
    {
        if ((data_out >> i) & (0x01))
        digitalWrite(DATA_pin,HIGH); 
        else
        digitalWrite(DATA_pin,LOW); 
        
        clock_signal();
    }
    latch_enable(); // Dados finalmente enviados
}

void setup() 
{
  pinMode(LATCH_pin , OUTPUT);
  pinMode(DATA_pin , OUTPUT);  
  pinMode(CLCOK_pin , OUTPUT);
  digitalWrite(LATCH_pin, LOW);    // (11) ST_CP [RCK] no 74HC595
  digitalWrite(CLCOK_pin, LOW);    // (9) SH_CP [SCK] no 74HC595
  digitalWrite(DATA_pin, LOW);     // (12) DS [S1] no 74HC595
  Serial.begin(9600);
}

void loop() 
{
  
       send_data(binary_pattern[counter]);
       counter++;
       if(counter>9)
       counter =0;
        delay(1000);
}

 

Como o Código funciona?

Este código funciona de forma semelhante ao código que discutimos na última seção, exceto pela parte do loop “while”. Primeiro, inicializamos os códigos de exibição para uma exibição de sete segmentos do tipo catodo comum usando uma matriz.

unsigned char binary_pattern[] = {
  	0b11111010,
    0b01100000,
  	0b11011100,
  	0b11110100,
  	0b01100110,
  	0b10110110,
  	0b10111110,
  	0b11100000,
  	0b11111110,
  	0b11100110,
};

Dentro do loop while, passamos os valores dos códigos de exibição para a função send_data() com a ajuda de uma variável de contador. A variável do contador é incrementada a cada segundo e é usada para exibir valores atualizados. Quando o valor do contador se torna igual a 9, redefinimos o valor do contador para zero.

send_data(binary_pattern[counter]);
         counter++;
         if(counter>9)
         counter =0;
         delay_ms(1000);

 

Aplicativos SN74HC595

Este IC tem uma infinidade de aplicações e é usado em uma ampla gama de produtos, como periféricos de computador, eletrodomésticos, etc. Algumas aplicações são listadas abaixo:

  • Mantendo dados por um longo período de tempo
  • Conversão de dados serial para paralelo
  • Lógica de propósito geral
  • Controle de LEDs

Diagrama 2D

Está disponível em pacotes PDIP, GDIP, PDSO de 16 pinos. As dimensões do pacote PDSO são fornecidas abaixo.

Datasheet

74HC595 IC DATASHEET

 
Twittar
Compartilhar
Compartilhar
0 Compart.