S H I F T O U T M E G A
 Ampliar o número de saídas do Arduino com
 Registrador de Deslocamento 74HC595
 --------------------------------------------*/

/*¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨
 - Pino 8 do Arduino ligado ao pino 12 do CI.
 - Pino 11 do Arduino ligado ao pino 14 do CI.
 - Pino 12 do Arduino ligado ao pino 11 do CI.
 - Led 1 = Pino 15 do CI.
 - Led 2 = Pino 1 do CI.
 - Led 3 = Pino 2 do CI.
 - Led 4 = Pino 3 do CI.
 - Led 5 = Pino 4 do CI.
 - Led 6 = Pino 5 do CI.
 - Led 7 = Pino 6 do CI.
 - Led 8 = Pino 7 do CI.
 - Pinos 10 e 16 do CI ligados ao Vcc.
 - Pinos 8 e 13 do CI ligados ao GND.
 - Pino 9 do CI ligado ao pino 14 do próximo CI.
 ¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨*/

#include <ShiftOutMega.h> //Inclui a biblioteca ShiftOutMega.h
#include <NewPing.h> // Inclui a biblioteca NewPing.h

//Variáveis de uso dos registradores 74HC595
int latchPin = 8;  //Pino 8 conectado ao pino 12 do 74HC595 (Latch).
int dataPin = 11;  //Pino 11 conectado ao pino 14 do 74HC595 (Data).
int clockPin = 12; //Pino 12 conectado ao pino 11 do 74HC595 (Clock).

//Define o numero de sensores, a distancia maxima e o intervalo da medição
#define SONAR_NUM   2 // Define o numero de sensores
#define MAX_DISTANCE 80 // Distancia maxima
#define PING_INTERVAL 33 // Milisegundos de intervalo entre medicoes (29ms e o tempo mínimo para evitar conflito entre os sensores)

unsigned long pingTimer[SONAR_NUM]; // Armazena a quantidade de vezes que a medicao deve ocorrer, para cada sensor
unsigned int cm[SONAR_NUM];     // Armazena o numero de medicoes
uint8_t currentSensor = 0;     // Armazena o sensor que esta ativo

//criando objeto e definindo as portas digitais do Trigger - 6 - e Echo - 7

NewPing sonar[SONAR_NUM] =
 {   // Armazena informacoes sobre a pinagem dos sensores
  NewPing(6, 7, MAX_DISTANCE), // Pino trigger, echo e distancia máxima, para cada sensor
  NewPing(3, 4, MAX_DISTANCE),
 };

//Quantidade de registradores (74HC595). Para cada registrador, temos 8 saídas.
int qtdRegistradores = 2;

int totalSaidas = qtdRegistradores * 8;
int t = 100; //tempo entre o acender dos leds.
int tempo = 2000; //tempo que fica aceso os leds para depois apagar.

//Inicia a biblioteca passando os parametros de uso.
ShiftOutMega mega(latchPin, dataPin, clockPin, qtdRegistradores);

void setup(){
Serial.begin(9600); //Inicializando o serial monitor
  pingTimer[0] = millis() + 75;      //Primeira medicao começa com 75ms
  for (uint8_t i = 1; i < SONAR_NUM; i++) //Define o tempo de inicializacao de cada sensor
   pingTimer[i] = pingTimer[i - 1] + PING_INTERVAL;

     //Apagando todos os leds
  mega.shiftWrite(totalSaidas, LOW);
 }

void loop() {
  for (uint8_t i = 0; i < SONAR_NUM; i++) { // Loop entre todos os sensores
   if (millis() >= pingTimer[i]) {
    pingTimer[i] += PING_INTERVAL * SONAR_NUM; //Define o tempo que o proximo sensor sera acionado
    if (i == 0 && currentSensor == SONAR_NUM - 1) oneSensorCycle(); // Ciclo do sensor completo
    sonar[currentSensor].timer_stop();     // Reseta o timer antes de ler o proximo sensor
    currentSensor = i;             // Número do sensor sendo acionado
    cm[currentSensor] = 0;           // Se nao houver eco do sensor, seta a distância como zero
    sonar[currentSensor].ping_timer(echoCheck);
   }
 }
}
 void echoCheck() { //Se receber um sinal (eco), calcula a distancia
  if (sonar[currentSensor].check_timer())
   cm[currentSensor] = sonar[currentSensor].ping_result / US_ROUNDTRIP_CM;
 }

 void oneSensorCycle() { // Ciclo de leitura do sensor

//Se for detectado objeto entre 0 e 10 cm do sensor1, acende leds
     if (cm[0] > 1 && cm[0] < 10){

    for (int i=1; i<=totalSaidas; i++){
      mega.shiftWrite(i, HIGH);
      delay(t);
    }
    delay(tempo);
    for (int i=1; i<=totalSaidas; i++){
      mega.shiftWrite(i, LOW);
      delay(t);
    }
   }
//Se for detectado objeto entre 0 e 50 cm do sensor2, acende o led
     if (cm[1] > 1 && cm[1] < 10) {
    for (int i=1; i<=totalSaidas; i++){
      mega.shiftWrite(totalSaidas+1-i, HIGH);
      delay(t);
    }
    delay(tempo);
    for (int i=1; i<=totalSaidas; i++){
      mega.shiftWrite(totalSaidas+1-i, LOW);
      delay(t);
  }
 }
}

Um abraço!