CODGO RESUMIDO

#define irLedPin 2         // Ir Led neste pino############################# siguinifica do outro codgo#####################
#define irSensorPin 11       // Sensor IR neste pino#########################
#include <PinChangeInt.h>
#include <Servo.h>
// Assign your channel in pins
#define THROTTLE_IN_PIN 8
#define AUX_IN_PIN 10
// Assign your channel out pins
#define THROTTLE_OUT_PIN 5
#define AUX_OUT_PIN 7
// Os objetos Servo geram os sinais esperados pelos Controladores e Servos de Velocidade Eletrônicos
// Usaremos os objetos para produzir os sinais que lemos
// este código de exemplo fornece uma passagem direta do sinal sem processamento personalizado
Servo servoThrottle;
Servo servoAux;
// Esses sinalizadores de bits são definidos em bUpdateFlagsShared para indicar qual
// canais têm novos sinais
#define THROTTLE_FLAG 1
#define AUX_FLAG 4
// contém as bandeiras de atualização definidas acima
volatile uint8_t bUpdateFlagsShared;
// variáveis compartilhadas são atualizadas pelo ISR e lidas por loop.
// Em loop, imediatamente pegamos cópias locais para que o ISR possa manter a propriedade do
// compartilhados. Para acessar estes no loop
// primeiro desligamos as interrupções com não Interrupções
// tiramos uma cópia para usar no loop e as interrupções de volta de volta
// o mais rápido possível, isso garante que sempre possamos receber novos sinais
volatile uint16_t unThrottleInShared;
volatile uint16_t unAuxInShared;
// Estes são usados para registrar a margem ascendente de um pulso nas funções calcInput
// Eles não precisam ser voláteis, pois são usados apenas no ISR. Se quiséssemos
// para se referir a estes em loop e ao ISR, eles deveriam ser declarados voláteis
uint32_t ulThrottleStart;
uint32_t ulAuxStart;
void setup()
{
  pinMode(irSensorPin, INPUT);//#######################################
  pinMode(irLedPin, OUTPUT); // ######################################
  Serial.begin(9600);
  Serial.println("multiChannels");
  servoThrottle.attach(THROTTLE_OUT_PIN);
  servoAux.attach(AUX_OUT_PIN);
  // using the PinChangeInt library, attach the interrupts
  // used to read the channels
  PCintPort::attachInterrupt(THROTTLE_IN_PIN, calcThrottle,CHANGE);
  PCintPort::attachInterrupt(AUX_IN_PIN, calcAux,CHANGE);
}
void loop()
{
  //Serial.println(irRead(irSensorPin, irLedPin)); // exibe os resultados######################################################
  // criar variáveis locais para armazenar cópias locais das entradas de canal
  // Estes são declarados estáticos para que seus valores sejam mantidos
  // between calls to loop.
  static uint16_t unThrottleIn;
  static uint16_t unAuxIn;
   local copy of update flags
  static uint8_t bUpdateFlags;
  int irRead(int readPin, int triggerPin)//######################################################################################
{
  int halfPeriod = 13; // um período de 38.5khZ é de aproximadamente 26 microssegundos#########################################
  int cycles = 38; // 26 microseconds * 38 é mais ou menos 1 milissegundo########################################################
  int i;                                //       ########################################################################
  for (i=0; i <=cycles; i++)             //       ###########################################################################
  {
    digitalWrite(triggerPin, HIGH); //################################################################################
    delayMicroseconds(halfPeriod);//##########################################################################
    digitalWrite(triggerPin, LOW);// ########################################################################
    delayMicroseconds(halfPeriod - 1);   // - 1 para compensar DigitaWrite sobrecarga#####################################
  }
  return digitalRead(readPin);//########################################################################################
//}
  // check shared update flags to see if any channels have a new signal
  if(bUpdateFlagsShared)
  {
    noInterrupts(); // Desliga-se rapidamente enquanto tomamos cópias locais das variáveis compartilhadas

    // Pegue uma cópia local de quais canais foram atualizados caso precisamos usar isso no resto do loop
    bUpdateFlags = bUpdateFlagsShared;

    // No código atual, os valores compartilhados são sempre preenchidos
    // Para que possamos copiá-los sem testar as bandeiras
    // No entanto, no futuro isso pode mudar, então vamos
    // Apenas copie quando as bandeiras nos dizem que podemos.

    if(bUpdateFlags & THROTTLE_FLAG)
    {
      unThrottleIn = unThrottleInShared;
    }

    if(bUpdateFlags & AUX_FLAG)
    {
      unAuxIn = unAuxInShared;
    }

    // Limpe a cópia compartilhada de sinalizadores atualizados, já que já tomamos as atualizações
    // Ainda temos uma cópia local se precisarmos usá-la em bUpdateFlags
    bUpdateFlagsShared = 0;

    interrupts(); //Nós temos cópias locais das entradas, então agora podemos fazer as interrupções de volta
    // Assim que as interrupções estiverem de volta, não podemos mais usar as cópias compartilhadas, a interrupção
    // As rotinas de serviços possuem essas e podem atualizá-las a qualquer momento. Durante a atualização, o
    // As cópias compartilhadas podem conter lixo. Felizmente, temos nossas cópias locais para trabalhar com :-)
  }

  // Faça qualquer processamento a partir daqui em diante
  // Use apenas valores locais unAuxIn, unThrottleIn e unSteeringIn, o compartilhado
  //Variáveis unAuxInShared, unThrottleInShared, unSteeringInShared são sempre propriedade de
  // As rotinas de interrupção e não devem ser usadas em loop
   // O código a seguir fornece passagem simples
  // Este é um bom teste inicial, o Arduino irá passar
  // Entrada do receptor como se o Arduino não estivesse lá.
  // Isso deve ser usado para confirmar o circuito e a alimentação
  // Antes de tentar qualquer processamento personalizado em um projeto.
   // Estamos verificando se o valor do canal mudou, isto é indicado
  // Pelas bandeiras. Para o simples passe, realmente não precisamos deste cheque,
  // Mas para um projeto mais complexo, onde um novo sinal requer um processamento significativo
  // Isso nos permite apenas calcular novos valores quando temos novas entradas, em vez de
  // Em todos os ciclos.
  if(bUpdateFlags & THROTTLE_FLAG)
  {
    if(servoThrottle.readMicroseconds() != unThrottleIn)
    {
      servoThrottle.writeMicroseconds(unThrottleIn);
    }
  }
  if(bUpdateFlags & AUX_FLAG)
  {
    if(servoAux.readMicroseconds() != unAuxIn)
    {
      servoAux.writeMicroseconds(unAuxIn);
    }
  }

  bUpdateFlags = 0;
}
// Rotina de serviço de interrupção simples
void calcThrottle()
{
  // Se o pino estiver alto, é uma margem ascendente do pulso do sinal, de modo a registrar seu valor
  if(digitalRead(THROTTLE_IN_PIN) == HIGH)
  {
    ulThrottleStart = micros();
  }
  else
  {
    // Senão deve ser uma borda descendente, então vamos dar o tempo e subtrair o tempo da margem ascendente
    // Isso dá uso do tempo entre os limites ascendente e descendente, isto é, a duração do pulso.
    unThrottleInShared = (uint16_t)(micros() - ulThrottleStart);
    // Use set the throttle flag para indicar que um novo sinal de aceleração foi recebido
    bUpdateFlagsShared |= THROTTLE_FLAG;
  }
}
void calcAux()
{
  if(digitalRead(AUX_IN_PIN) == HIGH)
  {
    ulAuxStart = micros();
  }
  else
  {
    unAuxInShared = (uint16_t)(micros() - ulAuxStart);
    bUpdateFlagsShared |= AUX_FLAG;
  }
}