Uno mega2560 and adafruit 16x12 bit servo shield

I went to a mega2560 instead of a uno because it has more inputs. When I put the 16x12 servo shield on and connect the inputs,A0,A1,A2,A3,A4,A5,A7. it will not show anything on the serial monitor. I skipped A6 because the shield blocks the A6 pin. I can use A7-A13 and change the code, and it works. The problem is, now I'm have limited A0 again.

/*
   This code is for the project at
   http://www.iliketomakestuff.com/how-to-automate-a-dust-collection-system-arduino
   All of the components are list on the url above.

  This script was created by Bob Clagett for I Like To Make Stuff
  For more projects, check out iliketomakestuff.com 
//  refined with help of the Arduino forum on this thread
//  https://forum.arduino.cc/index.php?topic=548018.0
  Includes Modified version of "Measuring AC Current Using ACS712"
  http://henrysbench.capnfatz.com/henrys-bench/arduino-current-measurements/acs712-arduino-ac-current-tutorial/

  Parts of this sketch were taken from the keypad and servo sample sketches that comes with the keypad and servo libraries.

  Uses https://github.com/adafruit/Adafruit-PWM-Servo-Driver-Library
*/
#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

// called this way, it uses the default address 0x41
//Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();
// you can also call it with a different address you want
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(0x41);

// Depending on your servo make, the pulse width min and max may vary, you
// want these to be as small/large as possible without hitting the hard stop
// for max range. You'll have to tweak them as necessary to match the servos you
// have!
//servos used DS3218mg
// our servo # counter
uint8_t servoCount = 7;
uint8_t servonum = 0;

const int OPEN_ALL = 100;
const int CLOSE_ALL = 99;

boolean buttonTriggered = 0;
boolean powerDetected = 0;
boolean collectorIsOn = 0;
int vacuum_spindown = 1500

;
//allow vacuum system to run after tool is turned off
const int NUMBER_OF_TOOLS = 7;
const int NUMBER_OF_GATES = 7;

String tools[NUMBER_OF_TOOLS] = {"Spindle sander", "Belt sander", "Miter saw", "Router", "Table saw", "Planer", "FloorSweep"};
int voltSensor[NUMBER_OF_TOOLS] = {A0, A1, A2, A3, A4, A5, A7};
long int voltBaseline[NUMBER_OF_TOOLS] = {0, 0, 0, 0, 0, 0, 0};


//Set the throw of each gate separately, if needed
int gateMinMax[NUMBER_OF_GATES][7
                               ] = {

  /*open,close*/

  {220, 135}, //Spindle sander good numbers
  {300, 154}, //Belt sander good numbers
  {265, 129}, //Miter saw good numbers
  {230, 99}, //Router good numbers230/99
  {260, 130}, //Table saw
  {217, 115}, //Planer
  {260, 130}, //FloorSweep
 
 


};

//keep track of gates to be toggled ON/OFF for each tool
int gates[NUMBER_OF_TOOLS][NUMBER_OF_GATES] = {

  {1, 0, 0, 0, 0, 0, 0},
  {0, 1, 0, 0, 0, 0, 0},
  {0, 0, 1, 0, 0, 0, 0},
  {0, 0, 0, 1, 0, 0, 0},
  {0, 0, 0, 0, 1, 0, 0},
  {0, 0, 0, 0, 0, 1, 0},
  {0, 0, 0, 0, 0, 0, 1},
  
 };

const int dustCollectionRelayPin = 11;
const int manualSwitchPin = 12; //for button activated gate, currently NOT implemented

int mVperAmp = 185; // use 100 for 20A Module and 66 for 30A Module
double ampThreshold = .20;

double Voltage = 0;
double VRMS = 0;
double AmpsRMS = 0;

//button debouncing
int state = HIGH;      // the current state of the output pin
int reading;           // the current reading from the input pin
int previous = LOW;    // the previous reading from the input pin

// the follow variables are long's because the time, measured in miliseconds,
// will quickly become a bigger number than can be stored in an int.
long time = 0;         // the last time the output pin was toggled
long debounce = 200;   // the debounce time, increase if the output flickers

void setup() {
  Serial.begin(9600);
  pinMode(dustCollectionRelayPin, OUTPUT);
  pwm.begin();
  pwm.setPWMFreq(60);  // Default is 1000mS

  //record baseline sensor settings
  //currently unused, but could be used for voltage comparison if need be.
  delay(1000);
  for (int i = 0; i < NUMBER_OF_TOOLS; i++) {
    pinMode(voltSensor[i], INPUT);
    voltBaseline[i] = analogRead(voltSensor[i]);
  }

}

void loop() {
  // use later for button debouncing
  reading = digitalRead(manualSwitchPin);

  if (reading == HIGH && previous == LOW && millis() - time > debounce) {
    if (state == HIGH) {
      state = LOW;
      buttonTriggered = false;
    } else {
      state = HIGH;
      buttonTriggered = true;
      time = millis();
    }
  }
  previous = reading;
  Serial.println("----------");
  //loop through tools and check
  int activeTool = 50;// a number that will never happen
  for (int i = 0; i < NUMBER_OF_TOOLS; i++) {
    if ( checkForAmperageChange(i)) {
      activeTool = i;
      exit;
    }
    if ( i != 0) {
      if (checkForAmperageChange(0)) {
        activeTool = 0;
        exit;
      }
    }
  }
  if (activeTool != 50) {
    // use activeTool for gate processing
    if (collectorIsOn == false) {
      //manage all gate positions
      for (int s = 0; s < NUMBER_OF_GATES; s++) {
        int pos = gates[activeTool][s];
        if (pos == 1) {
          openGate(s);
        } else {
          closeGate(s);
        }
      }
      delay(2500);
      //delay added to allow gates to open before vacuum system comes on
      turnOnDustCollection();
    }
  } else {
    if (collectorIsOn == true) {
      delay(vacuum_spindown);
      turnOffDustCollection();
    }
  }
}
boolean checkForAmperageChange(int which) {
  Voltage = getVPP(voltSensor[which]);
  VRMS = (Voltage / 2.0) * 0.707;
  AmpsRMS = (VRMS * 1000) / mVperAmp;
  Serial.print(tools[which] + ": ");
  Serial.print(AmpsRMS);
  Serial.println(" Amps RMS");
  if (AmpsRMS > ampThreshold) {
    return true;
  } else {
    return false;
  }
}
void turnOnDustCollection() {
  Serial.println("turnOnDustCollection");
  digitalWrite(dustCollectionRelayPin, 1);
  collectorIsOn = true;
}
void turnOffDustCollection() {
  Serial.println("turnOffDustCollection");
  digitalWrite(dustCollectionRelayPin, 0);
  collectorIsOn = false;
}

float getVPP(int sensor)
{
  float result;

  int readValue;             //value read from the sensor
  int maxValue = 0;          // store max value here
  int minValue = 1024;          // store min value here

  uint32_t start_time = millis();
  while ((millis() - start_time) < 500) //sample for 1 Sec
  {
    readValue = analogRead(sensor);
    // see if you have a new maxValue
    if (readValue > maxValue)
    {
      /*record the maximum sensor value*/
      maxValue = readValue;
    }
    if (readValue < minValue)
    {
      /*record the maximum sensor value*/
      minValue = readValue;
    }
  }

  // Subtract min from max
  result = ((maxValue - minValue) * 5.0) / 1024.0;

  return result;
}

void closeGate(uint8_t num) {
  Serial.print("closeGate ");
  Serial.println(num);
  pwm.setPWM(num, 0, gateMinMax[num][1]);
}
void openGate(uint8_t num) {
  Serial.print("openGate ");
  Serial.println(num);
  pwm.setPWM(num, 0, gateMinMax[num][0]);
  delay(100);
  pwm.setPWM(num, 0, gateMinMax[num][0] - 5);
}

Calling exit in the Arduino environment does exit the program and the processor stops doing anything from then on. I doubt that this was your intention. Remove those exit calls.

activeTool = i;
      exit;

The exit calls do nothing. If they were exit(0), the exit would happen. That was covered a while back in a thread on this same sketch.