I am using Arduino 1.6.10 , i think its latest version.

I have Atmel 8MHz code for cable tester and pin used are ADC0( PA0) to ADC7(PA7) as analog pin and PC0 to PC7 as digital pin.

If i want to use same program for Arduino mega 16Mhz with A8 to A15 analog pin and 42 to 49 ad Digital Pin.

My question is what i have to change to get it work on Arduino Mega.

Here is code:

#include <avr/io.h>
#include <util/delay.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <math.h>
#include <avr/pgmspace.h>

#include "hd44780.h" // LCD
#include "lan_tester.h"

#define F_CPU 16000000UL //8

//----------------------------------------------------------------
float GetADCData (uchar nChannel)
{
  ADCSRA = 0;
  _delay_us (5);
  ADMUX = 0b01000000 | (nChannel & 0b00000111); // 64, 7
  _delay_us (5);
  ADCSRA = 0b10000101;//5
  _delay_us (500);
  ADCSRA = 0b11000101; // 69
  while ((ADCSRA & (1 << 6)));
  _delay_us (5);
  int nResult = ((int) ADCL) + (((int) ADCH) << 8);
  return (float) nResult;
}

//----------------------------------------------------------------
void SetTestLines (uchar nPositive, uchar nNegative, bool bWait)
{
  DDRC = 0;
  PORTC = 0;
  if (nPositive != LINE_UNUSED)
  {
    DDRC |= (1 << nPositive);
    PORTC |= (1 << nPositive);
  }

  if (nNegative != LINE_UNUSED)
  {
    DDRC |= (1 << nNegative); 
  }
  if (bWait) _delay_ms (20);
    return;
}

//----------------------------------------------------------------
void ShowFault (uchar nCode)
{
  lcdClear ();
  static char strMessage11 [] PROGMEM = "    On line    ";
  static char strMessage12 [] PROGMEM = "There is tension!";
  static char strMessage21 [] PROGMEM = "Replace the battery";
  static char strMessage31 [] PROGMEM = " ADC faulty ";

  switch (nCode)
  {
    case 0:
      lcdGotoXY (1, 0);
      lcdPutsFromFlash (strMessage11);
      lcdGotoXY (2, 0);
      lcdPutsFromFlash (strMessage12);
      break;
  case 1: 
    lcdGotoXY (1, 0);
    lcdPutsFromFlash (strMessage21);
    break;
  case 2:
    lcdGotoXY (1, 0);
    lcdPutsFromFlash (strMessage31);
    break;
  }
  return;
}

//----------------------------------------------------------------
bool CheckLineVoltage (float *Umin, float *Umax)
{
  bool bFlag = false;

  SetTestLines (LINE_UNUSED, LINE_UNUSED, true);
  for (int i = 0; i < 8; i++)
  {
    if (GetADCData (i) > fZero) bFlag = true;
  }

  if (bFlag)
  {
    ShowFault (0);
    return false;
  }

  if (!PINB2)
  {
    ShowFault (1);
    return false;
  }

  SetTestLines (LINE_UNUSED, 0, true);
  *Umin = GetADCData (0);

  SetTestLines (0, LINE_UNUSED, true);
  *Umax = GetADCData (0);
  if ((*Umax - *Umin) < 700)
  {
    ShowFault (2); 
    return false;
  }

  return true;
}

//----------------------------------------------------------------
bool CheckConnection (char *Data, char *Mask)
{
  for (uchar i = 0; i < 8; i++)
  {
    if ((Data [i] != Mask [i]) && (Mask [i] != 'X')) return false;
  }
  return true;
}

//----------------------------------------------------------------
void RefreshDisplay (uchar *Data, int L, bool bShowLength)
{
  char str [9];

  static char strMessage0 [] PROGMEM = "Main:  12345678";
  static char strMessage1 [] PROGMEM = "1Gb LAN Staight ";
  static char strMessage2 [] PROGMEM = "1Gb LAN Cross   ";
  static char strMessage3 [] PROGMEM = "100Mb LAN Straight";
  static char strMessage4 [] PROGMEM = "100Mb LAN Cross ";
  static char strMessage5 [] PROGMEM = "E1/T1           ";
  static char strMessage6 [] PROGMEM = "No connection   ";
  static char strMessage7 [] PROGMEM = "                ";

  lcdGotoXY (0, 0);
  lcdPutsFromFlash (strMessage0);
  lcdGotoXY (1, 0);
  lcdPutsFromRAM ("Remote:    ");
  for (int i = 0; i < 8; i++)
  {
    switch (Data [i])
    {
      case 1:
      case 2:
      case 3:
      case 4:
      case 5:
      case 6:
      case 7:
      case 8:       
        str [i] = Data [i] + 48; 
        break;
      case LINE_UNKNOWN:  
        str [i] = '?'; 
        break;
      case LINE_SHORTED:  
        str [i] = 'S'; 
        break;
      case LINE_BROKEN: 
        str [i] = 'X';  
        break;

      default: 
        str [i] = ' ';
    } 
  }
  str [8] = 0;
  lcdPutsFromRAM (str);
  lcdPutsFromRAM ("    ");

  lcdGotoXY (2, 0);
  if (bShowLength)
  {
    if (L < 5) 
    {
      lcdPutsFromRAM ("Cable Length <5 м  ");
    }
    else
    {
      lcdPutsFromRAM ("Cable Length ");
      itoa (L, str, 10);
      lcdPutsFromRAM (str);
      lcdPutsFromRAM (" M  ");
    }
  }
  else
  {
    lcdPutsFromFlash (strMessage7); 
  }

  lcdGotoXY (3, 0);
  if (CheckConnection (str, "12345678"))    
    lcdPutsFromFlash (strMessage1);
  else if (CheckConnection (str, "36145278")) 
    lcdPutsFromFlash (strMessage2);
  else if (CheckConnection (str, "123XX6XX")) 
    lcdPutsFromFlash (strMessage3);
  else if (CheckConnection (str, "361XX2XX")) 
    lcdPutsFromFlash (strMessage4);
  else if (CheckConnection (str, "45X12XXX")) 
    lcdPutsFromFlash (strMessage5);
  else 
    lcdPutsFromFlash (strMessage6);

  return;
}

//----------------------------------------------------------------
void Initialize ()
{
  DDRA = 0;
  DDRB = 0;
  DDRC = 0;
  DDRD = 0;
  PORTA = 0;
  PORTB = 0;
  PORTC = 0;
  PORTD = 0;
  MCUCSR = 0b10000000;
  TCCR1A = 0;
  TCCR1B = 0;

  _delay_ms (100);
  lcdInit();

  return;
}

//----------------------------------------------------------------
float GetResistance (uchar Line1, uchar Line2, float Umin)
{
  SetTestLines (Line1, Line2, true);
  float U1 = GetADCData (Line1);
  float U2 = GetADCData (Line2);
  float Ra = R1 * R2 / (R1 + R2);
  if ((U2 - Umin) <= 0) 
    return 1e6;
  return (U1 - U2) * Ra / (U2 - Umin);
}

//----------------------------------------------------------------
uchar StageOneCheck (uchar *Line, const uchar *PinOut, uchar *GoodLine, uchar *BrokenIndex)
{
  uchar LineCount = 0;
  *BrokenIndex = LINE_UNUSED;
  for (uchar i = 0; i < 8; i++) 
  {
    Line [i] = 0;
    SetTestLines (PinOut [i], LINE_UNUSED, true);
    bool bFlag = false;
    for (uchar j = 0; j < 8; j++) 
    {
      float fADCData = GetADCData (PinOut [j]);
      if ((fADCData > fMaxValue) && (i != j)) 
        Line [i] = LINE_SHORTED;
      if ((fADCData > fZero) && (i != j)) 
         bFlag = true;
    }
    if (!bFlag) 
    {
      Line [i] = LINE_BROKEN;
      *BrokenIndex = i;
    }
    if (Line [i] == 0) 
      GoodLine [LineCount++] = i;
  }

  return LineCount;
}

//----------------------------------------------------------------
void StageTwoCheck (uchar *Line, const uchar *PinOut, uchar *GoodLine, uchar LineCount, const float R [3][8], float Umin)
{
  volatile static float fRcalc [8];
  uchar i = 0, j = 0;
  uchar nMinIndex [3] = {0, 0, 0};
  float fMinResistance = 1e6;
  float Rtmp;

  // find two lines with minimal resistance
  for (i = 1; i < LineCount; i++) 
  {
    for (j = 0; j < i; j++)
    {
      Rtmp = GetResistance (PinOut [GoodLine [i]], PinOut [GoodLine [j]], Umin);
      if (Rtmp < fMinResistance)
      {
        fMinResistance = Rtmp;
        nMinIndex [0] = i; 
        nMinIndex [1] = j;
      }
    }
  }

  // find third line
  fMinResistance = 1e6;
  for (i = 0; i < LineCount; i++)
  {
    if ((i != nMinIndex [0]) && (i != nMinIndex [1]))
    {
      Rtmp = GetResistance (PinOut [GoodLine [nMinIndex [0]]], PinOut [GoodLine [i]], Umin);
      if (Rtmp < fMinResistance)
      {
        fMinResistance = Rtmp;
        nMinIndex [2] = i;
      }
    }
  }

  // solve equations
  float fR12 = GetResistance (PinOut [GoodLine [nMinIndex [0]]], PinOut [GoodLine [nMinIndex [1]]], Umin);
  float fR13 = GetResistance (PinOut [GoodLine [nMinIndex [0]]], PinOut [GoodLine [nMinIndex [2]]], Umin);
  float fR23 = GetResistance (PinOut [GoodLine [nMinIndex [1]]], PinOut [GoodLine [nMinIndex [2]]], Umin);
  float fR1 = 0.5 * (fR12 + fR13 - fR23);
  float fR2 = fR12 - fR1;
  uchar idxMin;

  if (fR1 < fR2)
  {
    idxMin = nMinIndex [0];
    fRcalc [idxMin] = fR1; 
  }
  else
  {
    idxMin = nMinIndex [1];
    fRcalc [idxMin] = fR2;
  }

  for (i = 0; i < LineCount; i++)
  {
    if (i != idxMin) 
    {
      Rtmp = GetResistance (PinOut [GoodLine [i]], PinOut [GoodLine [idxMin]], Umin);
      fRcalc [i] = Rtmp - fRcalc [idxMin];
    }
  }

  // try to found according resistance in table
  for (i = 0; i <= LineCount; i++)
  {
    for (j = 0; j < 8; j++)
    {
      if ((R [1][j] < fRcalc [i]) && (fRcalc [i] < R [2][j]))
      {
        Line [GoodLine [i]] = j + 1;
        break;
      }
    }
    if (Line [GoodLine [i]] == 0) Line [GoodLine [i]] = LINE_UNKNOWN;
  }

  return;
}

//----------------------------------------------------------------
int StageThreeCheck (uchar BrokenIndex, const uchar *PinOut)
{
  SetTestLines (PinOut [BrokenIndex], LINE_UNUSED, true);
  float U1 = GetADCData (PinOut [BrokenIndex]);
  TCNT1H = 0;
  TCNT1L = 0;
  TCCR1B = 1;
  SetTestLines (LINE_UNUSED, LINE_UNUSED, false);
  _delay_ms (1);
  float U2 = GetADCData (PinOut [BrokenIndex]);
  TCCR1B = 0;
  int nTime = ((int) TCNT1L) + (((int) TCNT1H) << 8);
  float fTime = ((float) nTime) * 1000 / F_CPU;
  float L = (-fTime/log (U2 / U1) - 1.71) / 0.032;
  return (int) L;
}

//----------------------------------------------------------------
void EasterEgg ()
{
  static int i = 0;
  static char strMessage1 [] PROGMEM = "                ";
  static char strMessage2 [] PROGMEM = "LAN-Tester v 1.1";
  static char strMessage3 [] PROGMEM = "          ";
  static char strMessage4 [] PROGMEM = "                ";

  if (++i == 120)
  {
    lcdClear ();
    lcdGotoXY (0, 0);
    lcdPutsFromFlash (strMessage1);
    lcdGotoXY (1, 0);
    lcdPutsFromFlash (strMessage2);
    lcdGotoXY (2, 0);
    lcdPutsFromFlash (strMessage3);
    lcdGotoXY (3, 0);
    lcdPutsFromFlash (strMessage4);
    _delay_ms (5000);
    lcdClear ();
  }
  return;
}

//----------------------------------------------------------------
int main()
{
  const uchar PinOut [8] = {6, 5, 7, 4, 0, 3, 1, 2};
  const float R [3][8] = {{15, 8.2, 51, 3.0, 5.1, 2.0, 22, 1.0},
                          {13, 7.5, 40, 2.5, 4.0, 1.5, 18, 0.7},
                          {18, 9.5, 60, 3.8, 6.5, 2.5, 27, 1.5}};
  float Umax, Umin;
  int L = 0;
  uchar Line [8];
  uchar GoodLine [8];
  uchar BrokenIndex;
  uchar Step = 0;
  uchar LineCount = 0;
  uchar i;
 
  Initialize ();

  while (1)
  {
    switch (Step)
    {
      case 0:       // startup checks
        if (CheckLineVoltage (&Umin, &Umax)) Step = 1;
        break;
      case 1:       // try to found unbroken line, check for shortage
        LineCount = StageOneCheck (Line, PinOut, GoodLine, &BrokenIndex);
        if (LineCount < 3)
        {
          for (i = 0; i < 8; i++)
          {
            if (Line [i] == 0) 
              Line [i] = LINE_UNKNOWN;
          }
          Step = 3; 
        }
        else
        {
          Step = 2;
        }
        break;

        case 2:     // resistance measure, lines order check
          StageTwoCheck (Line, PinOut, GoodLine, LineCount, R, Umin);
          if (BrokenIndex == LINE_UNUSED) 
            Step = 4; 
          else 
            Step = 3;
          break;
        case 3:     // capacitance measure, if there are broken lines
          L = StageThreeCheck (BrokenIndex, PinOut);
          Step = 4;
          break;

        case 4:   // display refresh
          RefreshDisplay (Line, L, (BrokenIndex != LINE_UNUSED));
          EasterEgg ();

        default:
          Step = 0;
    }
  }
}