Muitas vezes em um desenvolvimento de projeto com Arduino UNO os pinos de I/O podem não ser suficientes para sua aplicação. Uma alternativa muitas vezes utilizada é a troca por outra placa com um microcontrolador que possua 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 uma placa/microcontrolador com maior capacidade de memória e outros recursos, onde essas características não são necessárias em seu projeto. Neste artigo vou apresentar alguns circuitos de expansão 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.

Circuitos de expansão de I/Os 

Existem diversos CIs que podem ser utilizados como circuitos de expansão de I/Os do Arduino. 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.

Para 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:

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:

Os Melhores Treinamentos sobre Sistemas embarcados e IoT

Cursos com professores qualificados para acelerar sua carreira e projetos

MATRÍCULE-SE AGORA

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:

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:

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 circuitos de 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. 

Saiba mais

Arduino – Primeiros Passos

Arduino – O documentário

Arduino UNO

Referências

Serial to Parallel Shifting-Out with a 74HC595

Microcontroller input / output expander