Contadores/Temporizadores

Os contadores, que em certo sentido, também podem ser chamados temporizadores, são uma das mais importantes sub-funções de um microcontrolador. Estes permitem precisamente processos temporais, gerar sinais e contar os eventos. Um contador converte o número de ciclos de entrada para um valor binário usando um array de triggeers. O número máximo de ciclos contados depende do comprimento deste array, e este facto é assinalado pelo comprimento do código binário. Um AVR tem contadores de 8 e 16 bits. Se um temporizador atingiu o seu valor máximo (255 em 8-bits ou 65.535 em 16 bits), o ciclo seguinte irá gerar um overflow e o contador dá a volta para 0. O sinal de relógio de um contador pode vir do sinal do relógio do microcontrolador, e nesse caso é possível diminuir o seu valor usando um divisor. Alguns AVRs tem um gerador de sinal de relógio interno independente, que pode ser modificado para funcionar mais rapidamente utilizando um multiplicador de frequência. Os contadores também podem ser diferentes segundo os casos de aplicação e modos de trabalho.

No modo padrão, um contador não faz nada mais do que contar continuamente números sequenciais. O seu valor pode, claro, ser lido e alterado a partir do programa a qualquer momento. A única função adicional no modo padrão é causar uma interrupção no overflow do contador. O modo padrão é normalmente usado para executar uma seção do programa a determinados intervalos.

#include <avr/interrupt.h>
 
ISR(TIMER0_OVF_vect)
{
	// Give the counter such a value
	// that the next overflow occurs in 10 ms.
	// Formula: 256 - 8 MHz / 1024 / 100 Hz = 177,785 = ~178
	TCNT0 = 178;
}
 
int main()
{
	// To make the first overflow interrupt fire in 10 ms as well,
	// the counter needs to be initialized here.
	TCNT0 = 178;
 
	// Prescaler value 1024
	TCCR0 = 0x07;
 
	// Allow overflow interrupts
	TIMSK |= (1 << TOIE0);
 
	// Allow interrupts globally
	sei();
 
	// Endless loop
	while (1) continue;
}

É também possível a utilização de uma fonte de relógio externo como sinal de contador de relógio. Um AVR tem um pino chamado Tn para esta finalidade, sendo n o número associado ao contador. O sinal de relógio externo e a polaridade podem ser selecionados usando o registro prescaler.

Uma vez que os contadores permitem operações de temporização, os microcontroladores AVR mais complexos têm uma opção para eventos específicos de tempo ao nível do hardware. Esta parte do contador é designada por unidade de captura de entrada. Há uma escolha entre dois eventos: a mudança de valor num pino especial de entrada ou no valor do resultado do camparador analógico. Se ocorrer o evento selecionado, o valor do contador é gravado num registo especial, de onde pode ser lido a qualquer momento. Se o evento demorar mais do que o tempo de overflow do contador, o programa tem para contar os overflows e levá-los em consideração no cálculo do resultado final.

#include <avr/interrupt.h>
 
unsigned long frequency;
 
// Interrupt for the event
ISR(TIMER1_CAPT_vect)
{
	// Counter to 0
	TCNT1 = 0;
 
	// The result is valid only if the counter
	// has not overflowed yet
	if (!(TIFR & (1 << TOV1)))
	{
		// Calculating the frequency from the period
		frequency = (unsigned long)8000000 /
		            (unsigned long)ICR1;
	}
	else
	{
		// Frequency is less than 122 Hz
		frequency = 0;
 
		// Set the counter's overflow flag to 0
		TIFR &= ~(1 << TOV1);
	}
}
 
int main()
{
	// Register a rising front, prescaler value 1
	TCCR1B = (1 << ICES1) | (1 << CS10);
 
	// Allow event interrupts
	TIMSK = (1 << TICIE1);
 
	// Allow interrupts globally
	sei();
 
	// Endless loop
	while (1) continue;
}

Apanhar eventos e registar o tempo que levou para que eles ocorram também pode ser resolvido no nível do software. É possível utilizar interrupções externas ou outras e ler o valor do contador durante estes eventos. O apanhar de eventos ao nível de hardware deverá ser executado de forma independente do programa principal e em eventos de tempo relativamente curtos (ou frequentes).

Os contadores mais complexos podem gerar um sinal, além de cronometrarem a duração dos mesmos. Para este efeito, o contador tem uma unidade de comparação à saída e uma unidade de comparação de correspondência. A unidade de saída de comparação tem registros com a mesma largura de bits que o contador e os valores desses registos são comparados com o valor do contador enquanto ele estiver em execução. Uma interrupção pode ser gerada e os valores dos pinos especiais podem ser alterados de cada vez que o valor do contador for igual ao valor no registo na unidade de comparação. Neste momento, um pino pode ser definido como alto, baixo ou invertido. O sinal é gerado por mudanças no valor do pino de saída.

In some signal generating modes, the counter's maximum value can be altered. The counter's physical size will remain the same, but a comparison register is used to reset the counter at a specific count. The previous examples could also be solved by using this method, but the function is rather for changing the period of the signal. In addition to this, a counter can be configured to a mode where it works with both incrementing and decrementing.

The counters and the signal generating modes using them are one of the most complex peripheral modules in an AVR. Writing about all of them here is beyond the scope of this text, and typically there is no need to know all aspects in order to use them. The following describes one of the most common PWM signals in robotics. The rest can be read from the AVR documentation.

Pulse width modulation (PWM) is a type of signal, where the frequency and period (typically) are both constant, but the length of the half-periods changes. PWM signals are used for controlling electromechanical, optical and other devices. For example, the servo motors known from modeling use a PWM signal of 50 Hz and have a high half-period of 1 to 2 ms.

#include <avr/io.h>
 
int main()
{
	// Set pins as outputs
	DDRB |= (1 << PIN5) | (1 << PIN6);
 
	// Set outputs A and B low for comparison,
	// "Fast PWM" mode, prescaler value 8
	TCCR1A = (1 << COM1A1) | (1 << COM1B1) | (1 << WGM11);
	TCCR1B = (1 << WGM13) | (1 << WGM12) | (1 << CS11);
 
	// Maximum value of the counter. Formula:
	//   TOP = 8 MHz / 8 / 50 Hz
	ICR1 = 20000;
 
	// Half-period of the first motor is 1 ms, and second 2 ms
	OCR1A = 1000;
	OCR1B = 2000;
 
	// Endless loop
	while (1) continue;
}