Olá amigos, sou iniciante e estou querendo uma ajuda, gostaria de saber se este código abaixo tb serve para o arduino mega, já que o mesmo foi testado em um Uno. Sei que é muita coisa mas tenho muita vontade de realizar este projeto. Desde já agradeço!

Transmisor PPM
v0.1 lectura de entradas y muestra de datos en LCD
v0.2 generacion PPM usando librerias RC en pin 9
v0.3 multiples memorias para modelos

*/

#include <LiquidCrystal.h>
#include <PPMOut.h>
#include <Timer1.h>
#include <EEPROM.h>

#define CHANNELS 4
#define SWITCHES 2
#define MODELOS 5
#define CANALTH 2

#define swTC 0
#define swDR 1

#define eepromModeloId 0;

uint8_t g_pins[CHANNELS] = {A1, A2, A3, A4}; // Input pins
uint16_t g_input[CHANNELS]; // Input buffer in microseconds
uint8_t g_work[PPMOUT_WORK_SIZE(CHANNELS)]; // we need to have a work buffer for the PPMOut class

rc::PPMOut g_PPMOut(CHANNELS, g_input, g_work, CHANNELS);

char *digit3 = "%3d";

int teclado = A0;
// canales del TX
int menuActual=0;

// mensajes del menu
char msgs[6][17] = {
"Menu ",
"1.Servo Dir. ",
"2.Dual Rates ",
"3.E.P.A. ",
"4.Guardar ",
"5.Modelo " };
unsigned char modelo_actual=0; // id del modelo actual
unsigned char num_menus=5; // numOpciones-1
unsigned char submenu_actual=0; // para cuando este dentro del menu
unsigned char servo_reversa[MODELOS];
unsigned char servo_reversa_cambio=0;
unsigned char estado_display=0; // variable para el refresco del display

unsigned char canal_cambio=0; // variable para seleccion de canal en los submenus

unsigned char canal_cambio_dr=0;
unsigned char dual_rate_low[MODELOS][CHANNELS];
unsigned char dual_rate_hi[MODELOS][CHANNELS];

// valores varios
int potenciometros[CHANNELS]; // lectura de potenciometros
unsigned char sw_status=0x00; //0:TC 1:DR 2:EXPO
int potMin = 0;
int potMax = 1024;

// LCD
LiquidCrystal lcd(8, 3, 4, 5, 6, 7);
/*
byte lcdChar[][8] = {
{
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00},

{
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x1F},

{
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x1F,
0x1F},

{
0x00,
0x00,
0x00,
0x00,
0x00,
0x1F,
0x1F,
0x1F},

{
0x00,
0x00,
0x00,
0x00,
0x1F,
0x1F,
0x1F,
0x1F},

{
0x00,
0x00,
0x00,
0x1F,
0x1F,
0x1F,
0x1F,
0x1F},

{
0x00,
0x00,
0x1F,
0x1F,
0x1F,
0x1F,
0x1F,
0x1F},

{
0x00,
0x1F,
0x1F,
0x1F,
0x1F,
0x1F,
0x1F,
0x1F}

} ;

*/
byte lcdChar[][8] = {
{
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x1F},

{
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x1F,
0x00},

{
0x00,
0x00,
0x00,
0x00,
0x00,
0x1F,
0x00,
0x00},

{
0x00,
0x00,
0x00,
0x00,
0x1F,
0x00,
0x00,
0x00},

{
0x00,
0x00,
0x00,
0x1F,
0x00,
0x00,
0x00,
0x00},

{
0x00,
0x00,
0x1F,
0x00,
0x00,
0x00,
0x00,
0x00},

{
0x00,
0x1F,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00},

{
0x1F,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00}

} ;
// /LCD

int ajusteValor(int maximo, int minimo, int valor) {
int salida;
float divisor;
divisor=1024.0/(maximo-minimo);
salida=valor/divisor;
return salida;
}

int ajusteDR(int valor, int dr, int canal) {
int salida,temp;
float mult;
int canalth=CANALTH;

if (canal==canalth) {
// dual rate del total
mult=dr/100.0;
salida=valor*mult;
} else {
// dual rate de los extremos
temp=valor-512;
mult=dr/100.0;
salida=(temp*mult)+512;

}

return salida;
}

void leePotenciometros() {
// leemos los pots
uint8_t i;

/*
potenciometros[0]=ajusteValor(potMax, potMin, analogRead(A1));
potenciometros[1]=ajusteValor(potMax, potMin, analogRead(A2));
potenciometros[2]=ajusteValor(potMax, potMin, analogRead(A3));
potenciometros[3]=ajusteValor(potMax, potMin, analogRead(A4));
*/

potenciometros[0]=analogRead(A1);
potenciometros[1]=analogRead(A2);
potenciometros[2]=analogRead(A3);
potenciometros[3]=analogRead(A4);

// leemos los switches
if (digitalRead(swTC)==HIGH) {
bitWrite(sw_status,0,1);
digitalWrite(13,HIGH);
} else {
bitWrite(sw_status,0,0);
digitalWrite(13,LOW);
}


if (digitalRead(swDR)==HIGH) {
bitWrite(sw_status,1,1);
} else {
bitWrite(sw_status,1,0);
}


// activamos el TC cuando se cierra el switch
if (bitRead(sw_status,0)==0) {
// TC activado
potenciometros[CANALTH]=0;
}


// reversa de servos
for (i = 0; i < CHANNELS; ++i){
if (bitRead(servo_reversa[modelo_actual], i)) {
potenciometros[i]=1024-potenciometros[i];
}
}

// dual rates
for (i = 0; i < CHANNELS; ++i){
// activamos el DR cuando se cierra el switch
if (bitRead(sw_status,1)==0) {
// low rates
potenciometros[i]=ajusteDR(potenciometros[i],dual_rate_low[modelo_actual][i],i);

} else {
// hi rates
potenciometros[i]=ajusteDR(potenciometros[i],dual_rate_hi[modelo_actual][i],i);
}
}


// conversion a PPM
for (i = 0; i < CHANNELS; ++i){
g_input[i] = map(potenciometros[i], 0, 1024, 1000, 2000);
}

g_PPMOut.update();

}

int porcentajePotenciometro(float valor, int minimo, float maximo) {
double temp;
temp=100*valor/maximo;
return (int)temp;
}

unsigned char potenciometroBar(float valor, float maximo) {
double temp;
temp=7*valor/maximo;
return (int)temp;
}

void setup() {
int i,j;


//init de valores
//debe ser reemplazado por lectura desde eeprom

// servos
for (i=0;i<=MODELOS-1;i++) {
servo_reversa[i]=0;
}
// dual rates
for (i=0;i<=MODELOS-1;i++) {
for (j=0;j<=(CHANNELS-1);j++) {
dual_rate_low[i][j]=75;
dual_rate_hi[i][j]=100;
}
}


// si eeprom(511)=255, reseteamos todos los datos de las memorias

if (EEPROM.read(511)!=0) {
EEPROM.write(0,0); // modelo 0
// guardamos el modelo actual
for (modelo_actual=0;modelo_actual<=MODELOS;modelo_actual++) {
EEPROM.write((modelo_actual*16)+1,servo_reversa[modelo_actual]);
// guardamos los datos del dual rate
for (i=0;i<=CHANNELS;i++) {
EEPROM.write((modelo_actual*16)+((2*i)+2),dual_rate_low[modelo_actual][i]);
EEPROM.write((modelo_actual*16)+((2*i)+3),dual_rate_hi[modelo_actual][i]);

}
}
EEPROM.write(511,0);
}

// leemos los datos desde la eeprom
modelo_actual=EEPROM.read(0);
// leemos el dato de servo reversa
servo_reversa[modelo_actual]=EEPROM.read((modelo_actual*16)+1);
// leemos los datos del dual rate
// guardamos los datos del dual rate
for (i=0;i<=CHANNELS;i++) {
dual_rate_low[modelo_actual][i]=EEPROM.read((modelo_actual*16)+((2*i)+2));
dual_rate_hi[modelo_actual][i]=EEPROM.read((modelo_actual*16)+((2*i)+3));

}

// si eeprom(511)=255, reseteamos todos los datos de las memorias

if (EEPROM.read(511)==255) {

}

// switches

pinMode(swTC, INPUT_PULLUP);
pinMode(swDR, INPUT_PULLUP);
digitalWrite(swTC, HIGH); // pullup
digitalWrite(swDR, HIGH); // pullup
pinMode(13, OUTPUT);


// PPM
rc::Timer1::init();
for (uint8_t i = 0; i < CHANNELS-1; ++i)
{
// set up input pins
pinMode(g_pins[i], INPUT);

// fill input buffer, convert raw values to microseconds
g_input[i] = map(potenciometros[i], 0, 1024, 1000, 2000);
}
g_PPMOut.setPulseLength(448); // ancho del pulso
g_PPMOut.setPauseLength(10448); // longitud del pulso despues del ultimo canal
g_PPMOut.start(9,false); // salida PPM en pin 9

// lcd

lcd.createChar(1, lcdChar[0]);
lcd.createChar(2, lcdChar[1]);
lcd.createChar(3, lcdChar[2]);
lcd.createChar(4, lcdChar[3]);
lcd.createChar(5, lcdChar[4]);
lcd.createChar(6, lcdChar[5]);
lcd.createChar(7, lcdChar[6]);
lcd.createChar(8, lcdChar[7]);

lcd.begin(16, 2);
lcd.setCursor(0,0);
lcd.print("Transmisor v.0.3");
lcd.setCursor(0,1);
lcd.print("(c) Pato! 2013 ");
/*
lcd.write(1);
lcd.write(2);
lcd.write(3);
lcd.write(4);
lcd.write(5);
lcd.write(6);
lcd.write(7);
lcd.write(8);
*/


delay(1000);
lcd.clear();

}

void loop() {
unsigned char tecla;
unsigned char i;

leePotenciometros();

// pantalla principal
if (submenu_actual==0) {
lcd.setCursor(0, 1);
lcd.print(msgs[menuActual]);
// sliders de los potenciometros

// modelo
lcd.setCursor(0,0);
lcd.write("M");
lcd.print(modelo_actual+1);

// indicador throtle cut
lcd.setCursor(3,0);
if (bitRead(sw_status,0)==0) {
lcd.write("TC");
} else {
lcd.write(" ");
}

// indicador dual rate
lcd.setCursor(6,0);
if (bitRead(sw_status,1)==0) {
lcd.write("LO");
} else {
lcd.write("HI");
}

lcd.setCursor(12,0);
lcd.write(potenciometroBar(potenciometros[0],1023)+1);
lcd.write(potenciometroBar(potenciometros[1],1023)+1);
lcd.write(potenciometroBar(potenciometros[2],1023)+1);
lcd.write(potenciometroBar(potenciometros[3],1023)+1);

tecla=lee_teclado();
if (tecla!=-1) {
if (tecla==1 && menuActual<num_menus) menuActual++;
if (tecla==2 && menuActual>0) menuActual--;
if (tecla==4) {
lcd.clear();
canal_cambio=0;
submenu_actual=menuActual;
}

}

}

// servo reversa
if (submenu_actual==1) {
if (estado_display==0) {
lcd.setCursor(0, 0); //line=2, x=0
lcd.print(msgs[submenu_actual]);
lcd.setCursor(0, 1);
for (i=0;i<=(CHANNELS-1);i++) {
/*
switch (i) {
case 0:
lcd.print("A:");
break;
case 1:
lcd.print("E:");
break;
case 2:
lcd.print("T:");
break;
case 3:
lcd.print("R:");
break;
default:
lcd.print(i+1);
lcd.print(":");
break;
}
*/
lcd.print(i+1);
lcd.print(":");
if (bitRead(servo_reversa[modelo_actual],i)) {
lcd.print("R ");
}
else {
lcd.print("N ");
}

}

}
estado_display=1;
lcd.setCursor((servo_reversa_cambio*4)+2,1);
lcd.blink();

tecla=lee_teclado();
if (tecla!=-1) {
if (tecla==0 && servo_reversa_cambio<(CHANNELS-1)) { servo_reversa_cambio++; }
if (tecla==3 && servo_reversa_cambio>0) { servo_reversa_cambio--; }

if (tecla==1) {
bitWrite(servo_reversa[modelo_actual], servo_reversa_cambio, 1);
estado_display=0;
}
if (tecla==2) {
bitWrite(servo_reversa[modelo_actual], servo_reversa_cambio, 0);
estado_display=0;
}

if (tecla==4) {
lcd.clear();
estado_display=0;
submenu_actual=0;
}

}
}

// dual rates
if (submenu_actual==2) {
if (estado_display==0) {
lcd.clear();
lcd.setCursor(0, 0); //line=2, x=0
lcd.print(msgs[submenu_actual]);
lcd.setCursor(0, 1);
lcd.print("CH:");
lcd.print(canal_cambio+1);
lcd.setCursor(5, 1);
lcd.print("L:");
lcd.print(dual_rate_low[modelo_actual][canal_cambio]);

lcd.setCursor(11, 1);
lcd.print("H:");
lcd.print(dual_rate_hi[modelo_actual][canal_cambio]);

switch (canal_cambio_dr) {
case 0: lcd.setCursor(3, 1); break;
case 1: lcd.setCursor(7, 1); break;
case 2: lcd.setCursor(13, 1); break;
}

lcd.blink();
estado_display=1;


}
tecla=lee_teclado();
if (tecla!=-1) {

// cambio de canal
if (tecla==1 && canal_cambio<(CHANNELS-1) && canal_cambio_dr==0) {
canal_cambio++;
estado_display=0;
}
if (tecla==2 && canal_cambio>0 && canal_cambio_dr==0) {
canal_cambio--;
estado_display=0;
}

// cambio de valor en el dual rate actual
if (tecla==1 && canal_cambio_dr==1 && dual_rate_low[modelo_actual][canal_cambio]<100) {
dual_rate_low[modelo_actual][canal_cambio]++;
estado_display=0;
}
if (tecla==1 && canal_cambio_dr==2 && dual_rate_hi[modelo_actual][canal_cambio]<100) {
dual_rate_hi[modelo_actual][canal_cambio]++;
estado_display=0;
}
if (tecla==2 && canal_cambio_dr==1 && dual_rate_low[modelo_actual][canal_cambio]>0) {
dual_rate_low[modelo_actual][canal_cambio]--;
estado_display=0;
}
if (tecla==2 && canal_cambio_dr==2 && dual_rate_hi[modelo_actual][canal_cambio]>0) {
dual_rate_hi[modelo_actual][canal_cambio]--;
estado_display=0;
}



// cambio de selector de dual rate para el canal actual (H/L)
if (tecla==0 && canal_cambio_dr<2) {
canal_cambio_dr++;
estado_display=0;
}
if (tecla==3 && canal_cambio_dr>0) {
canal_cambio_dr--;
estado_display=0;
}




if (tecla==4) {
lcd.clear();
estado_display=0;
submenu_actual=0;
}

}

}


// guardar datos en modelo actual
if (submenu_actual==4) {
// guardamos el modelo actual
EEPROM.write(0,modelo_actual);
// guardamos los datos de la direccion de los servos
EEPROM.write((modelo_actual*16)+1,servo_reversa[modelo_actual]);
// guardamos los datos del dual rate
for (i=0;i<=CHANNELS;i++) {
EEPROM.write((modelo_actual*16)+((2*i)+2),dual_rate_low[modelo_actual][i]);
EEPROM.write((modelo_actual*16)+((2*i)+3),dual_rate_hi[modelo_actual][i]);

}

// mensaje y regreso
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Modelo: ");
lcd.print(modelo_actual+1);
lcd.setCursor(0, 1);
lcd.print("grabado");
delay(1000);
lcd.clear();
estado_display=0;
submenu_actual=0;

}

// modelo
if (submenu_actual==5) {
if (estado_display==0) {
lcd.clear();
lcd.setCursor(0, 0); //line=2, x=0
lcd.print(msgs[submenu_actual]);
lcd.setCursor(0, 1);
lcd.print("Modelo: ");
lcd.print(modelo_actual+1);
lcd.blink();
estado_display=1;


}
tecla=lee_teclado();
if (tecla!=-1) {
if (tecla==1 && modelo_actual<=MODELOS) {
modelo_actual++;

}
if (tecla==2 && modelo_actual>0) {
modelo_actual--;
}
lcd.setCursor(0, 1);
lcd.print("Modelo: ");
lcd.print(modelo_actual+1);

}



if (tecla==4) {
// leemos los datos desde la eeprom


EEPROM.write(0,modelo_actual);
// leemos el dato de servo reversa
servo_reversa[modelo_actual]=EEPROM.read((modelo_actual*16)+1);
// leemos los datos del dual rate
// guardamos los datos del dual rate
for (i=0;i<=CHANNELS;i++) {
dual_rate_low[modelo_actual][i]=EEPROM.read((modelo_actual*16)+((2*i)+2));
dual_rate_hi[modelo_actual][i]=EEPROM.read((modelo_actual*16)+((2*i)+3));

}

lcd.clear();
estado_display=0;
submenu_actual=0;
}

}
}

unsigned char lee_teclado() {
unsigned char salida=0;
int valor=analogRead(0);
unsigned char tecla;
if (valor==1023) {
salida=-1;
} else {
tecla=get_key(valor);
delay(25);
while (valor<1000) {
valor=analogRead(0);
}
salida=tecla;
}
return salida;
}

int get_key(unsigned int input)
{
int k;
int adc_key_val[5] ={
30, 150, 360, 535, 760 };
int NUM_KEYS = 5;
for (k = 0; k < NUM_KEYS; k++)
{
if (input < adc_key_val[k])
{

return k;
}
}

if (k >= NUM_KEYS)
k = -1; // No valid key pressed

return k;
}