Registrador de Deslocamento 74HC595 - Simples Aplicação

Neste projeto, será utilizado CIs (circuitos integrados) adicionais na forma de registradores de deslocamento, para fazer com que os LEDs exibem um sinal luminoso percorrendo de um lado a outro parecido daquele seriado “A Super Máquina”, ou dos Cylons de “Battlestar Galactica”. Mais especificamente, você controlará LEDs de forma independente, utilizando apenas três pinos de saída do Arduino para cada registrador de deslocamento.
Será utilizado dois registradores de deslocamento, mais especificamente o 74HC595. Esse tipo de registrador de deslocamento é um registrador de 8 bits, com entrada serial, saída serial ou paralela, e latches (travas) de saída. Isso significa que você pode enviar dados para o registrador de deslocamento em série, e enviar dados para fora em paralelo. Em série significa um bit de cada vez. Em paralelo significa muitos bits de cada vez. Os dados entram quando o LATCH está definido como LOW (isso permite que dados sejam enviados ao chip), e saem quando o LATCH está definido como HIGH. Assim, você transfere os dados (na forma de 1s e 0s) ao registrador de deslocamento, um bit de cada vez, e então envia para fora oito bits ao mesmo tempo. Cada bit é deslocado conforme o bit seguinte entra. Se um nono bit entrar antes que o latch seja definido como HIGH, o primeiro bit será deslocado para o fim da fila, perdendo-se para sempre. 
Nesse caso 8 LEDs serão alocados para cada CI 74HC595.
Analise o diagrama cuidadosamente. Conecte os 3,3 V e o terra nos barramentos inferiores apropriados da protoboard e, em seguida, estenda-os para os barramentos superiores. O chip tem um pequeno sulco em uma de suas pontas; esse sulco vai para a esquerda. O pino 1 está sob o sulco; o pino 8, no canto inferior direito; o pino 9, no canto superior direito e o pino 16 no canto superior esquerdo.
Você necessitará de fios que vão da alimentação de 3,3 V para os pinos 10 e 16, e fios do terra para os pinos digitais 8 e 13. Um fio vai do pino digital 8 para o pino digital 12 no CI. Outro vai do pino digital 10 para o pino 14 no CI e, finalmente, um vai do pino digital 12 para o pino 11 no CI. Repita esse processo no segundo CI ligando os pinos 11, 12, 14  nos respectivos pinos 11, 12 e 14 do primeiro CI.
Os oito LEDs de cada CI têm um resistor de 220 Ω entre o cátodo e o terra, e o ânodo do LED 1 vai para o pino 15. O ânodo dos LEDs 2 a 8 vão para os pinos 1 a 7 do CI.


Registrador de Deslocamento 74HC595

 Depois de montado seu projeto, teste carregando este programa:

 1  // Percurso Sinal Luminoso de um Lado a Outro
 2 
 3  /* Este código permite que a sequência de LEDs acende de uma maneira que
 4     o sinal luminoso percorre de um lado a outro nos 16 LEDs.*/
 5 
 6 
 7  int latchPin =  8;  // Pino conectado ao pino 12 do 74HC595 (Latch)
 8  int clockPin = 12;  // Pino conectado ao pino 11 do 74HC595 (Clock)
 9  int dataPin  = 11;  // Pino conectado ao pino 14 do 74HC595 (Data)
10 
11  void shiftOut(byte dataOut);
12 
13 
14  void setup()
15  {
16 
17   // Define os pinos como saída
18      pinMode(latchPin, OUTPUT);
19      pinMode(clockPin, OUTPUT);
20      pinMode(dataPin, OUTPUT);
21  }
22 
23  void loop()
24  {
25 
26      for (int i = 0; i < 16; i++) // Conta de 0 a 15
27      {
28 
29          digitalWrite(latchPin, LOW); // Define latchPin como LOW, para permitir o fluxo de dados
30 
31          shiftOut(i);
32 
33 
34          digitalWrite(latchPin, HIGH);   // Define latchPin como HIGH, para fechar e enviar os dados
35 
36          delay(100);
37      }
38 
39      for (int i = 0; i < 16; i++) // Conta de 0 a 15
40      {
41 
42          digitalWrite(latchPin, LOW); // Define latchPin como LOW, para permitir o fluxo de dados
43 
44          shiftOut(15-i);
45 
46 
47          digitalWrite(latchPin, HIGH);   // Define latchPin como HIGH, para fechar e enviar os dados
48 
49          delay(100);
50      }
51 
52 
53  }
54 
55 
56  void shiftOut(byte dataOut)
57  {
58 
59      boolean pinState; // Desloque 8 bits, com o bit menos significativos (LSB) sendo deslocado primeiro, no extremo ascendente do clock
60 
61  //  Libera o registrador de deslocamento deixando-o pronto para enviar dados
62      digitalWrite(dataPin, LOW);
63      digitalWrite(clockPin, LOW);
64 
65      for (int i = 0; i < 16; i++)  // Para cada bit em dataOut, envie um bit
66      {
67 
68          digitalWrite(clockPin, LOW); // Define clockPin como LOW, antes de enviar o bit
69 
70 
71          if ((1 << dataOut) & (1 << i)) // Se o valor de dataOut e (E lógico) uma máscara de bits forem verdadeiros, defina pinState como 1 (HIGH)
72          {
73              pinState = HIGH;
74          }
75          else
76          {
77              pinState = LOW;
78 
79          }
80 
81 
82          digitalWrite(dataPin, pinState);  // Define dataPin como HIGH ou LOW, dependendo de pinState
83          digitalWrite(clockPin, HIGH);     // Envia o bit no extremo ascendente do clock
84          digitalWrite(dataPin, LOW);
85 
86      }
87 
88      digitalWrite(clockPin, LOW); // Interrompe o deslocamento
89 
90  }
91 


Após o código ser carregado, observa-se o movimento do sinal luminoso de um lado para outro igual aos "Cylons" de “Battlestar Galactica”.


A seguir é apresentado um código alternativo em que dois sinais luminosos iniciam-se pelas extremidades em direção ao centro, cruzando-se e retornando às extremidades:


 1 
 2  // Efeito Encontro Luminoso
 3 
 4 /* Este programa permite mostrar um percurso de dois sinais luminosos começando pelas extremidades
 5     indo  em direção ao centro, cruzando-se e retornando ás extremidades.
 6  */
 7 
 8 
 9  int latchPin =  8;  // Pino conectado ao pino 12 do 74HC595 (Latch)
10  int clockPin = 12;  // Pino conectado ao pino 11 do 74HC595 (Clock)
11  int dataPin  = 11;  // Pino conectado ao pino 14 do 74HC595 (Data)
12 
13  void shiftOut(byte dataOut);
14 
15 
16  void setup()
17  {
18 
19   // Define os pinos como saída
20      pinMode(latchPin, OUTPUT);
21      pinMode(clockPin, OUTPUT);
22      pinMode(dataPin, OUTPUT);
23  }
24 
25  void loop()
26  {
27 
28      for (int i = 0; i < 8; i++) // Conta de 0 a 7
29      {
30 
31          digitalWrite(latchPin, LOW);   // Define latchPin como LOW, para permitir o fluxo de dados
32 
33          shiftOut(8-i);
34          shiftOut(i);
35 
36          digitalWrite(latchPin, HIGH);  // Define latchPin como HIGH, para fechar e enviar os dados
37 
38          delay(200);
39      }
40 
41      for (int i = 0; i < 8; i++) // Conta de 0 a 7
42      {
43 
44          digitalWrite(latchPin, LOW); // Define latchPin como LOW, para permitir o fluxo de dados
45 
46          shiftOut(i);
47          shiftOut(8-i);
48 
49          digitalWrite(latchPin, HIGH);   // Define latchPin como HIGH, para fechar e enviar os dados
50 
51          delay(200);
52      }
53 
54 
55  }
56 
57 
58  void shiftOut(byte dataOut)
59  {
60 
61      boolean pinState; // Desloque 8 bits, com o bit menos significativos (LSB) sendo deslocado primeiro, no extremo ascendente do clock
62 
63   // Libera o registrador de deslocamento, deixando-o pronto para enviar dados
64      digitalWrite(dataPin, LOW);
65      digitalWrite(clockPin, LOW);
66 
67      for (int i=0; i < 8; i++)  // Para cada bit em dataOut, envie um bit
68      {
69 
70          digitalWrite(clockPin, LOW); // Define clockPin como LOW, antes de enviar o bit
71 
72 
73          if ((1 << dataOut) & (1 << i)) // Se o valor de dataOut e (E lógico) uma máscara de bits forem verdadeiros, defina pinState como 1 (HIGH)
74          {
75              pinState = HIGH;
76          }
77          else
78          {
79              pinState = LOW;
80          }
81 
82 
83          digitalWrite(dataPin, pinState);  // Define dataPin como HIGH ou LOW, dependendo de pinState
84          digitalWrite(clockPin, HIGH);     // Envia o bit no extremo ascendente do clock
85          digitalWrite(dataPin, LOW);
86 
87      }
88 
89      digitalWrite(clockPin, LOW); // Interrompe o deslocamento
90 
91  }
92 
93 


Podemos observar o movimento do sinal luminoso partindo das extremidades em direção ao centro, cruzando-se e retornando às extremidades.

Nenhum comentário:

Postar um comentário

Assinar: Postar comentários (Atom)