Algum tempo atrás publicamos mais informações sobre o função millis() de ArduinoAgora vamos aprofundar o Temporizador Arduino, para começar com esse recurso para o recurso, entenda como essa placa com MCU gerencia o tempo, além de outras funções além do millis().
O que é o temporizador Arduino?
El Temporizador Arduino ou temporizador, é uma função implementada por hardware (no microcontrolador, com a ajuda do cristal de quartzo que gera os pulsos de clock e que define o "ritmo", sem a necessidade de hardware externo ou ICs 555) que permite controlar eventos temporários graças aos clocks interno. Por exemplo, fazer uma tarefa acontecer em intervalos, fazer medições precisas de tempo, etc., independentemente do código do esboço.
Imagine que você usa o função atraso(), isso bloqueará a execução no Arduino MCU até que o tempo especificado tenha decorrido e, em seguida, continue com o programa, mas o temporizador não bloqueará. Será cronometrado enquanto o MCU continua a executar outras instruções simultaneamente. Essa é a grande vantagem.
O temporizador está relacionado com interrupções do Arduino, uma vez que serão executados através deles para atender alguma tarefa específica. Em outras palavras, o Arduino Timer é uma função que é acionada em um determinado momento, executando uma função de interrupção. É por isso que também é importante saber sobre essas interrupções.
modos
O temporizador Arduino tem 2 modos de operação, podendo ser usado em:
- Sinal PWM: Você pode controlar o Pinos do Arduino (~).
- CTC (Limpar timer na partida de comparação): conta o tempo dentro de um contador e quando atinge o valor especificado em um registro dos temporizadores, a interrupção é executada.
Quantos temporizadores tem? Tipos de temporizadores
Lá 3 temporizadores nas placas Arduino UNO, embora possa haver mais em outras placas superiores:
- Cronômetro 0: 8 bits, pode contar de 0 a 255 (256 valores possíveis). Usado por funções como delay(), millis() e micros(). Sua modificação não é recomendada para não alterar os programas.
- Cronômetro 1: igual a Timer 0. Usado pela biblioteca Servo em UNO (Timer 5 para MEGA).
- Cronômetro 2: 16 bits e pode variar de 0 a 65.525 (65.536 valores possíveis). Usado para a função tone(), se não for usado, pode ser usado livremente para sua aplicação.
- Temporizador 3, 4, 5 (somente no Arduino MEGA): todos de 16 bits.
Como funciona o temporizador do Arduino?
Para trabalhar com um temporizador Arduino, é fundamental saber como tudo isso funciona eletronicamente no MCU desta placa de desenvolvimento:
- Freqüência de relógio: é o número de ciclos por segundo que ele é capaz de desenvolver, no caso do Arduino é 16 Mhz, ou seja, o sinal do clock oscila 16.000.000 vezes por segundo (ciclos).
- Período: é representado pelo T, e é medido em segundos, e é o inverso dos ciclos. Por exemplo, T=1/C, que resultaria em 1/16000000 = 0.0000000625, o tempo que levaria para cada ciclo ser concluído. E a frequência é o inverso do período, então f = 1/T.
- Ciclo: é cada uma das repetições do sinal que ocorrem por unidade de tempo. No Arduino seriam 16M em um segundo. Ou o que é o mesmo, neste caso, quando 16 milhões de ciclos se passaram, um segundo se passou. Portanto, pode-se dizer que um ciclo leva 625 ns.
- borda de um sinal: Os sinais do relógio são quadrados e as bordas podem estar subindo ou descendo. Uma aresta é a linha reta do sinal quando muda de:
- 0 (baixo) a 1 (alto): borda ascendente.
- 1 (alto) a 0 (baixo): borda de queda.
As bordas são importantes porque os temporizadores do Arduino medem os ciclos das bordas do sinal. A) Sim o contador ele incrementa a cada ciclo e quando atinge o valor do registrador, a interrupção é executada.
Portanto, uma vez que você sabe disso, se você tiver 16Mhz no Arduino MCU, e um Timer de 8 bits é usado, pode-se dizer que as interrupções ocorrerão a cada 16 μs (256/16000000) ou 4 ms para 16 bits (65536/16000000). Portanto, se você definir o registrador do contador de 16 bits no máximo, com o valor 65535, a interrupção ocorrerá em 4 ms para executar qualquer tarefa.
Quando o contador atinge o valor máximo possível, vai voltar a 0 novamente. Ou seja, ocorre um estouro e ele será contado desde o início.
Para controlar a taxa de aumento do temporizador, você também pode usar um prescaler, que recebe os valores 1, 8, 64, 256 e 1024 e altera o tempo assim:
Velocidade do Temporizador (Hz) = Frequência do Relógio do Arduino/Prescaler
Se for 1 o prescaler o controlador aumentará para 16 Mhz, se for 8 a 2 Mhz, se for 64 a 250 kHz, e assim por diante. Lembre-se que haverá um comparador de estado do contador temporizador para comparar o valor do contador e do prescaler até que sejam iguais e então executar uma ação. Por tanto, frequência de interrupção é dado pela fórmula:
Velocidade de interrupção (Hz) = Arduino / Prescaler Clock Frequency (valor do registrador comparador + 1)
Felizmente, não devemos modificar registros dos Temporizadores do Arduino, pois será atendido pelas bibliotecas que usamos no código. Mas se eles não forem usados, eles devem ser configurados.
Exemplos na IDE do Arduino
Para entender um pouco melhor tudo isso, aqui mostro dois códigos de esboço para Arduino IDE com os quais você pode experimentar o uso de temporizadores. O primeiro é o código que piscará um LED conectado ao pino 8 do Arduino a cada segundo:
#define ledPin 8
void setup()
{
pinMode(ledPin, OUTPUT);
// Configurar Timer1
TCCR1A = 0; //Registro control A a 0, pines OC1A y OC1B deshabilitados
TCCR1B = 0; //Limpia el registrador
TCCR1B |= (1<<CS10)|(1 << CS12); //Configura prescaler a 1024: CS12 = 1 y CS10 = 1
TCNT1 = 0xC2F8; //Iniciar timer para desbordamiento a 1 segundo
//65536-(16MHz/1024/1Hz - 1) = 49912 = 0xC2F8 en hexadecimal
TIMSK1 |= (1 << TOIE1); //Habilitar interrupción para Timer1
}
void loop()
{
}
ISR(TIMER1_OVF_vect) //Interrupción del TIMER1
{
TCNT1 = 0xC2F7; // Reniciar Timer1
digitalWrite(ledPin, digitalRead(ledPin) ^ 1); //Invierte el estado del LED
}
Programe o piscar ou piscar do LED, como no caso anterior a cada segundo, mas desta vez usando CTC, ou seja, comparação:
#define ledPin 8
void setup()
{
pinMode(ledPin, OUTPUT);
// Configuración Timer1
TCCR1A = 0; //Registro de control A a 0
TCCR1B = 0; //Limpiar registro
TCNT1 = 0; //Inicializar el temporizador
OCR1A = 0x3D08; //Carga el valor del registro de comparación: 16MHz/1024/1Hz -1 = 15624 = 0X3D08
TCCR1B |= (1 << WGM12)|(1<<CS10)|(1 << CS12); //Modo CTC, prescaler de 1024: CS12 = 1 y CS10 = 1
TIMSK1 |= (1 << OCIE1A); //Habilita interrupción por igualdad de comparación
}
void loop()
{
}
ISR(TIMER1_COMPA_vect) //Interrupción por igualdad de comparación en TIMER1
{
digitalWrite(ledPin, digitalRead(ledPin) ^ 1); //Invierte el estado del LED
}
Mais sobre a programação do Arduino
compre um prato Arduino UNO Rev3