Uma função pode ser chamada automaticamente quando uma entrada é alterada?

Atualmente, meu esboço está verificando um pino de entrada toda vez em volta do loop principal. Se ele detectar uma alteração, chamará uma função personalizada para responder a ela. Aqui está o código (reduzido ao essencial):

int pinValue = LOW;

void pinChanged()
{
    //...
}

void setup()
{
    pinMode(2, INPUT);
}

void loop()
{
    // Read current input
    int newValue = digitalRead(2);

    // Has the input changed?
    if (newValue != pinValue) {
        pinValue = newValue;
        pinChanged();
    }
}

Infelizmente, isso nem sempre funciona corretamente para alterações muito curtas na entrada (por exemplo, pulsos breves), especialmente se loop()estiver um pouco lento.

Existe uma maneira de fazer o Arduino detectar a alteração de entrada e chamar minha função automaticamente?

Você pode fazer isso usando interrupções externas. A maioria dos Arduinos apenas suporta isso em um número limitado de pinos. Para detalhes completos, consulte a documentação em attachInterrupt().

Supondo que você esteja usando um Uno, você pode fazer assim:

void pinChanged()
{
    //...
}

void setup()
{
    pinMode(2, INPUT);
    attachInterrupt(0, pinChanged, CHANGE);
}

void loop()
{
}

Isso será chamado pinChanged()sempre que uma alteração for detectada na interrupção externa 0. No Uno, isso corresponde ao pino 2. do GPIO. A numeração da interrupção externa é diferente em outras placas, portanto, é importante verificar a documentação relevante.

Existem limitações para essa abordagem. A pinChanged()função personalizada está sendo usada como uma rotina de serviço de interrupção (ISR). Isso significa que o restante do código (tudo incluído loop()) é temporariamente interrompido enquanto a chamada está em execução. Para evitar interrupções em qualquer momento importante, você deve tentar tornar os ISRs o mais rápido possível.

Também é importante observar que nenhuma outra interrupção será executada durante o seu ISR. Isso significa que qualquer coisa que dependa de interrupções (como o núcleo delay()e as millis()funções) pode não funcionar corretamente dentro dele.

Por fim, se o seu ISR precisar alterar quaisquer variáveis ​​globais no esboço, elas geralmente devem ser declaradas como volatile, por exemplo:

volatile int someNumber;

Isso é importante porque informa ao compilador que o valor pode mudar inesperadamente, portanto, tenha cuidado para não usar cópias / caches desatualizados.

Qualquer estado de mudança em qualquer pino configurado como entrada digital pode criar uma interrupção. Diferentemente dos vetores exclusivos para as interrupções causadas pelo INT1 ou INT2, o recurso PinChangeInt usa um vetor comum e, em seguida, a Interrupt Service Routine (aka ISR) para esse vetor precisa determinar qual pino foi alterado.

Felizmente, a Biblioteca PinChangeInt facilita isso.

PCintPort::attachInterrupt(PIN, burpcount,RISING); // attach a PinChange Interrupt to our pin on the rising edge
// (RISING, FALLING and CHANGE all work with this library)
// and execute the function burpcount when that pin changes

No caso de você desejar detectar uma tensão que ultrapassa um limite , em vez de ser apenas ALTA ou BAIXA, você pode usar o comparador analógico. Esboço de exemplo:

volatile boolean triggered;

ISR (ANALOG_COMP_vect)
  {
  triggered = true;
  }

void setup ()
  {
  Serial.begin (115200);
  Serial.println ("Started.");
  ADCSRB = 0;           // (Disable) ACME: Analog Comparator Multiplexer Enable
  ACSR =  bit (ACI)     // (Clear) Analog Comparator Interrupt Flag
        | bit (ACIE)    // Analog Comparator Interrupt Enable
        | bit (ACIS1);  // ACIS1, ACIS0: Analog Comparator Interrupt Mode Select (trigger on falling edge)
   }  // end of setup

void loop ()
  {
  if (triggered)
    {
    Serial.println ("Triggered!"); 
    triggered = false;
    }

  }  // end of loop

Isso pode ser útil para itens como detectores de luz, nos quais você pode precisar detectar uma mudança de (digamos) 1V para 2V em uma entrada.

Exemplo de circuito:

Você também pode usar a Unidade de captura de entrada no processador, que lembrará a hora exata de determinadas entradas, salvando a contagem atual do timer / contador 1. Isso permite armazenar o momento exato (bem, quase exato) que o evento de ocorreu um interesse, em vez de introduzir o atraso (provavelmente de alguns microssegundos) antes que um ISR possa ser usado para capturar a hora atual.

Para aplicações críticas de tempo, isso pode dar uma precisão um pouco maior.

Exemplo de aplicação: Transforme seu Arduino em um testador de capacitor