Arduino: Expandindo os I/Os – Parte 1

 

Licença Creative Commons
Arduino: Expandindo os I/Os – Parte 1 por Fábio Souza. Esta obra está sob a licença Creative Commons Atribuição-CompartilhaIgual 4.0 Internacional.
74hc138

 

Muitas vezes em um desenvolvimento de projeto com Arduino UNO ocorre o problema de os pinos não serem suficientes para sua aplicação. A alternativa muitas vezes é a troca por outro Arduino com maior quantidade de pinos, como por exemplo o Arduino MEGA. Porém essa troca aumenta muito o custo do projeto, já que se vai usar um Arduino com maior capacidade de memória e outros recursos, onde essas características não são os problemas em seu projeto.

Neste artigo vamos apresentar alguns circuitos integrados que podem aumentar a quantidade de entradas e saídas, dando maiores possibilidades ao seu projeto sem a necessidade de trocar o microcontrolador ou a plataforma de desenvolvimento, como por exemplo, uma Arduino UNO por um Arduino MEGA.

Existem diversos CIs que podem ser utilizados para essa aplicação. Neste artigo vamos abordar apenas alguns para aumentar a quantidade de saídas, focando na técnica utilizada para a expansão com exemplos.

Vamos iniciar com o 74HC138, que é um decodificador / demultiplexador de alta velocidade. Com esse CI pode-se expandir os pinos de 3 para 8 saídas, porém só é possível acionar uma saída por vez. Pode se utilizar para aplicações onde necessite de acionamento de uma saída por vez, um sequencial de saídas por exemplo. Outra aplicação seria a varredura de displays de 7 segmentos. A seguir é apresentada a ligação desse CI ao Arduino UNO.

Arduino_74HC138-660x487Para escolha da saída (Y0 –  Y7) é necessário fazer a combinação nas entradas A, B e C com o endereço em binário, onde A é o bit menos significativo. Note que a saída é ativa em nivel 0. Veja a tabela verdade desse CI:

tabela-verdade-74hc138-660x323

Para exemplificar o uso do 74HC138, vamos aproveitar o esquemático apresentado e criar um programa para acionamento das saídas em intervalos de 1 segundo:

const byte PIN_A = 4; // PINO A do 74HC138
const byte PIN_B = 3; // PINO B do 74HC138
const byte PIN_C = 2; // PINO A do 74HC138
byte i =0; //variável para controle da escrita no 74HC138
void setup()
{
pinMode(PIN_A, OUTPUT); //configura como saída
pinMode(PIN_B, OUTPUT); //configura como saída
pinMode(PIN_C, OUTPUT); //configura como saída
}
void loop()
{
ligaSaida(i); //liga saida i
delay(1000); //aguarda 1 segundo
i++; //incrementa i
if(i>7) i=0; //se i passou de 7 reinicia com 0
}
void ligaSaida(int x) //função para acionamento do 74hc138
{
switch(x)
{
case 0: //saida 0
digitalWrite(PIN_A,LOW); //0
digitalWrite(PIN_B,LOW); //0
digitalWrite(PIN_C,LOW); //0
break;
case 1: //saida 1
digitalWrite(PIN_A,HIGH); //1
digitalWrite(PIN_B,LOW); //0
digitalWrite(PIN_C,LOW); //0
break;
case 2: //saida 2
digitalWrite(PIN_A,LOW); //0
digitalWrite(PIN_B,HIGH); //1
digitalWrite(PIN_C,LOW); //0
break;
case 3: //saida 3
digitalWrite(PIN_A,HIGH); //1
digitalWrite(PIN_B,HIGH); //1
digitalWrite(PIN_C,LOW); //0
break;
case 4: //saida 4
digitalWrite(PIN_A,LOW); //0
digitalWrite(PIN_B,LOW); //0
digitalWrite(PIN_C,HIGH); //1
break;
case 5: //saida 5
digitalWrite(PIN_A,HIGH); //1
digitalWrite(PIN_B,LOW); //0
digitalWrite(PIN_C,HIGH); //1
break;
case 6: //saida 6
digitalWrite(PIN_A,LOW); //0
digitalWrite(PIN_B,HIGH); //1
digitalWrite(PIN_C,HIGH); //1
break;
case 7: //saida 7
digitalWrite(PIN_A,HIGH); //1
digitalWrite(PIN_B,HIGH); //1
digitalWrite(PIN_C,HIGH); //1
break;
 }
}

Outra opção interessante para expandir o número de saídas de um microcontrolador é o uso do CI 74HC595. Trata-se de um registrador de deslocamento, ou seja, um conversor serial para paralelo de 8 bits. Neste CI os bits são inseridos um a um até completar o byte, e depois é enviado um comando para atualização das saídas. Diferentemente do 74HC138, com este CI podemos acionar qualquer saída a qualquer momento. Ele pode ser utilizado para expandir os pinos do microcontrolador para acionamentos de reles, display LCDs e uma infinidade de aplicações. São necessários apenas 3 pinos do microcontrolador para controle das saídas, conforme exibido na figura abaixo:

Arduino_74HC595-660x387

No pino 14 será onde inserimos o bit a ser deslocado, já no pino 11 será o pulso de clock e quando os 8 bits forem inseridos é dado um pulso no pino 12 para escrever na saídas. Abaixo é exibida a tabela verdade e o diagrama de tempo para funcionamento do 74HC595:

tabela-verdade-74hc595-660x345

diagrama-de-tempo-74hc595-660x366

Para exemplificar vamos aproveitar o esquemático apresentado e criar um programa para acionamento das saídas, escrevendo valores de 0 a 255:


int latchPin = 7;  //ST_CP of 74HC595
int clockPin = 8; //SH_CP of 74HC595
int dataPin =  9;  // DS of 74HC595
void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
}
void loop() {
  for (int numberToDisplay = 0; numberToDisplay < 256; numberToDisplay++) {
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, MSBFIRST, numberToDisplay);
    digitalWrite(latchPin, HIGH);
    delay(500);
  }
}

 Conclusão

O uso de CI digitais para a expansão de saídas no Arduino pode ser uma opção interessante quando a quantidade de portas torna-se limitada em uma placa Arduino. Aliado com um boa biblioteca você pode facilmente acionar saídas ampliando as possibilidades da sua placa. O CI 74HC595 é uma ótima opção para a expansão de pino e pode-se ligar outros e aumentar a quantidade para 16 saídas. No próximo artigo vamos apresentar alguns CIs para aumentar a quantidade de entradas em seu Arduino.

 Referências

Serial to Parallel Shifting-Out with a 74HC595

Microcontroller input / output expander

Anúncios
Marcado com: ,
Publicado em ARDUINO
%d blogueiros gostam disto: