Author: Abhay Kant

I have used this FAST PWM mode to trigger two interrupt service routines.
The timer compares register A sets the frequency.
I have not enabled the output compare pins. since it was used by some other peripheral. So by doing this, I generate a PWM signal by issuing a command in the ISR.

/*
* main.c
*
* Created: 10 July 2023 10:47:23 PM
*  Author: abhay
*/
#define F_CPU 16000000

#include <xc.h>
#include <stdio.h>
#include "util/delay.h"
#include <avr/interrupt.h>
#include "uart.h"
#define LED_ON PORTB |= (1<<5)
#define LED_OFF PORTB &= ~(1<<5)


// Function to send a character via UART
int UART_putchar(char c, FILE *stream) {
	if (c == '\n')
	UART_putchar('\r', stream);  // Add carriage return before newline
	while (!(UCSR0A & (1 << UDRE0))); // Wait for the transmit buffer to be empty
	UDR0 = c; // Transmit the character
	return 0;
}

// Create a FILE structure to redirect the printf stream to UART
FILE uart_output = FDEV_SETUP_STREAM(UART_putchar, NULL, _FDEV_SETUP_WRITE);

ISR(TIMER3_COMPA_vect){
	PORTD |= (1<<6);
}
ISR(TIMER3_COMPB_vect){
	PORTD &= ~(1<<6);
	
}

int main(void)
{
	

	USART_Init();
	// Redirect stdout stream to UART
	stdout = &uart_output;
	DDRB |= (1<<5);	// set Data direction to output for PB5
	LED_OFF; // set output to high
	DDRD |= (1 << 6);	//set PD6 as output
	
	
	/*
	F_CPU = 16000000
	Prescaler = 64
	Frequency = 50Hz
	Period = 0.020 s
	step time = 1/(F_CPU/Prescaler) = 0.000004 s
	number of steps = 0.020/0.000004 = 5000
	*/
	TCNT3 = 0;		// Timer counter initial value = 0
	// Output Compare A value = 5000 or 20 Milli second
	OCR3A = 5000;
	// Output Compare B value = 500 or 2 Milli second 
	OCR3B = 500;	
	// Fast PWM
	TCCR1A |= (1 << WGM31)|(1 << WGM30);	
	//  Prescaler: 64
	TCCR3B |= (1 << WGM32)|(1<<WGM32)|(1 << CS31)|(1 << CS30);	
	// Enable Timer Interrupt for Overflow, Compare match A and Compare Match B
	TIMSK3 |= (1 << OCIE3B)|(1 << OCIE3A)|(1<<TOIE3);	 
	
	// Enable Global Interrupt
	sei();	
	
	while(1)
	{
		OCR3B = 250;//5% 1ms
		_delay_ms(500);
		OCR3B = 375;//7.5% 1.5ms
		_delay_ms(100);
		OCR3B = 500;//10% 2ms
		_delay_ms(500);

	}
	
	
}

Timers are essential components in microcontrollers that allow precise timing and synchronization for various applications. The ATmega328PB microcontroller offers several timer/counters, including Timer/Counter 1 (TC1), which is a 16-bit timer with advanced features. In this blog post, I will explore how to utilize Timer 1 in CTC (Clear Timer on Compare Match) mode on the ATmega328PB microcontroller.

Hardware Setup

Before we proceed with the code, ensure you have the necessary hardware setup. You will need an ATmega328PB microcontroller, a 16MHz crystal oscillator, and any additional components required for your specific application. Connect the crystal oscillator to the XTAL1 and XTAL2 pins of the microcontroller to provide a stable clock signal.

UART Communication Initialization

In this example, we will utilize UART communication for debugging or output purposes. Make sure you have already implemented the necessary UART functions or library. The UART initialization code should include setting the baud rate, enabling the transmitter and receiver, and configuring the data format (e.g., number of data bits, parity, and stop bits). We will also redirect the stdout stream to the UART using the stdio.h library, allowing us to use the printf function for UART output.

Timer 1 Configuration in CTC Mode

Let’s dive into the code and configure Timer 1 in CTC mode. Here’s an example code snippet:

/*
* main.c
*
* Created: 7/9/2023 12:47:23 AM
*  Author: abhay
*/
#define F_CPU 16000000

#include <xc.h>
#include <stdio.h>
#include "util/delay.h"
#include <avr/interrupt.h>
#include "uart.h"

// Function to send a character via UART
int UART_putchar(char c, FILE *stream) {
	if (c == '\n')
	UART_putchar('\r', stream);  // Add carriage return before newline
	while (!(UCSR0A & (1 << UDRE0))); // Wait for the transmit buffer to be empty
	UDR0 = c; // Transmit the character
	return 0;
}

// Create a FILE structure to redirect the printf stream to UART
FILE uart_output = FDEV_SETUP_STREAM(UART_putchar, NULL, _FDEV_SETUP_WRITE);
ISR(TIMER1_COMPA_vect){
	printf("2. compare match A\n");
}
ISR(TIMER1_COMPB_vect){
	printf("1. compare match B\n");
}
int main(void)
{
	USART_Init();
	// Redirect stdout stream to UART
	stdout = &uart_output;
	DDRB |= (1<<5);	// set Data direction to output for PB5
	PORTB |= (1<<5); // set output to high
	/*
	* Timer 1 
	* Mode of operation : CTC
	*		When Output Compare A register value equals the 
	*		Timer Counter register (TCNT1) it resets the Timer-Counter-register value
	*		and generates a interrupt. 
	* Only OCR1A will reset the timer counter. 
	* OCR1B can be used to generate a compare match between TCNT1 = 0 and OCR1A
	*
	*/
	TCNT1 = 0;		// Timer counter initial value = 0
	OCR1BH = 0x3D;	// Output Compare B value = 0x3d09 or 1 second
	OCR1BL = 0x09;
	OCR1AH = 0x7a;	// Output Compare A value = 0x7a12 or 2 second
	OCR1AL = 0x12;
	TCCR1B |= (1<<WGM02)|(1 << CS12)|(1 << CS10);	// CTC Prescaler: 1024
	TIMSK1 |= (1 << OCIE1B)|(1 << OCIE1A)|(1<<TOIE1);
	
	sei();	// Enable Global Interrupt
	while(1)
	{

		
		printf("  This is Main:\n");
 		_delay_ms(2500);
	
		//TODO:: Please write your application code
		
	}
}

In this code snippet, we first initialize the UART communication and redirect the stdout stream to the UART output using the FDEV_SETUP_STREAM macro. The UART_putchar function is used to send a character via UART, ensuring that newline characters (\n) are preceded by a carriage return character (\r) for proper line endings.

Next, we configure Timer/Counter 1 (TC1) for CTC mode and set the prescaler to 1024, which divides the clock frequency to generate a suitable timebase. The TCCR1A and TCCR1B registers are set accordingly.

We then set the compare values (OCR1A and OCR1B) to determine the time intervals at which we want to generate interrupts. In this example, OCR1A is set for 2 second delay, and OCR1B is set for approximately 1 seconds delay.

Finally, we enable the Timer/Counter TC1 compare match interrupts (OCIE1A and OCIE1B) using the TIMSK1 register, and we enable global interrupts with the sei() function.

Interrupt Service Routines (ISRs)

The code snippet defines two Interrupt Service Routines (ISRs): TIMER1_COMPA_vect and TIMER1_COMPB_vect. These ISRs will be executed when a compare match occurs for Output Compare A and Output Compare B, respectively. In this example, we use these ISRs to print messages to the UART output. You can modify these ISRs to perform any desired actions based on your specific application requirements.

Putting It All Together

Once you have set up the UART communication, configured Timer 1 in CTC mode, and defined the necessary ISRs, you can utilize the precise timing capabilities of Timer 1 in your main program loop. Use the printf function to output information via UART, and the compare match interrupts will handle the precise timing events.

while (1) {
   printf("  This is Main:\n");
 		_delay_ms(2500);
    // Additional code and operations
    // ...
}

In the above example, the main program loop will execute continuously, printing “This is the main program loop” every 1 second using the printf function. The _delay_ms function provides a delay of 2500 milliseconds (2.5 second) between each iteration of the loop.

Conclusion

Utilizing Timer 1 in CTC mode on the ATmega328PB microcontroller provides precise timing capabilities for various applications. By configuring Timer 1, setting compare match values, and utilizing compare match interrupts, you can achieve accurate timing control in your embedded systems. When combined with UART communication, you can easily monitor and debug your code by printing relevant information via the UART interface.

Remember to consult the ATmega328PB datasheet and relevant documentation for more details on Timer 1, CTC mode, and other timer features. Ensure that you have correctly configured your hardware setup, including the crystal oscillator and UART connection, to match the code requirements.

Using Timer 1 in CTC mode

with UART communication opens up a range of possibilities for precise timing and debugging capabilities in your projects. Experiment with different compare match values and integrate this functionality into your applications to enhance timing accuracy and control.

The simplest mode of operation is the Normal mode (WGM0[2:0] = 0x0). In this mode, the counting direction is always up (incrementing), and no counter clear is performed. The counter simply overruns when it passes its maximum 8-bit value (TOP=0xFF) and then restarts from the bottom (0x00). In Normal mode operation, the Timer/Counter Overflow flag (TOV0) will be set in the same clock cycle in which the TCNT0 becomes zero. In this case, the TOV0 flag behaves like a ninth bit, except that it is only set, not cleared. However, combined with the timer overflow interrupt that automatically clears the TOV0 flag, the timer resolution can be increased by software. There are no special cases to consider in the Normal
mode, a new counter value can be written any time.

The output compare unit can be used to generate interrupts at some given time. Using the output compare to generate waveforms in Normal mode is not recommended since this will occupy too much of the CPU time.

The counter will always count from 0 to 255 and then after 255 it will set the overflow bit and start the counting from 0.

Without Interrupt

We can use this to generate delays. But This is a type of blocking code.

/*
 * main.c
 *
 * Created: 7/9/2023 12:47:23 AM
 *  Author: abhay
 */ 
#define F_CPU 16000000UL
#include <xc.h>

#include <util/delay.h>
void T0delay();
int main(void)
{
	DDRB |= (1<<5);
	PORTB |= (1<<5);
    while(1)
    {
		PORTB |= (1<<PINB5);
		T0delay();
		PORTB &= ~(1<<PINB5);
                T0delay();
		//TODO:: Please write your application code 
		
    }
}
void T0delay()
{
	/*
	F_CPU/prescaler = clock for timer
	1/clock for timer = timer step time
	for 1 second the timer will take : 1/timer step time
	
	16000000/1024 = 15625 clock
	1/15625 = 0.000064 = 64us	(counter step size)
	64us x 256 = 0.016384 sec (0verflow time)
	64us x 255 - tcnt +1 = 0.016384 sec (0verflow time)
		64us x (255 - tcnt +1 )= x
		tcnt = x / 64us ) -256
		
	for 1 sec Delay
	=> 1/0.016384 sec = 61.03515625
	Taking only integer 
	so 61 overflows needs to occur for 0.999424 Seconds
	1-0.999424 = 0.000576 seconds
	0.000576/ (counter step size) = required steps 
	0.000576/0.00064 = 9 steps
	Note: this will be close to 1 second. but it will be longer due to overhead added by the instructions.
	*/
	for(int i = 0; i< 61;i++){
	TCNT0 = 0;
	TCCR0A = 0;
	TCCR0B |= (1<<CS00)|(1<<CS02);	//prescaler 1024
	while( (TIFR0 & 0x1) == 0);	// Wait for overflow flag
	TCCR0B = 0;
	TIFR0 = 0x1;
	}
	//9 steps timer code
	TCNT0 = 255-9;
	TCCR0A = 0;
	TCCR0B |= (1<<CS00)|(1<<CS02);	//prescaler 1024
	while( (TIFR0 & 0x1) == 0);	// Wait for overflow flag
	TCCR0B = 0;
	TIFR0 = 0x1;
}

Normal Mode with Interrupt

#define F_CPU 16000000UL
#include <xc.h>
#include <avr/interrupt.h>
ISR(TIMER0_OVF_vect){
	PORTB ^= (1<<PINB5);   // Toggle the GPIO
}
int main(void)
{
	
	DDRB |= (1<<5);	// set Data direction to output for PB5
	PORTB |= (1<<5);    // set output to high
	
	TCNT0 = 0;
	TCCR0A = 0;     // Normal Mode
	TCCR0B |= (1<<CS00)|(1<<CS02);	//prescaler 1024
	TIMSK0 |= (1 << TOIE0);	// Overflow Interrupt Enable Bit
	
	sei();	// Enable Global Interrupt
	while(1)
	{
		//TODO:: Please write your application code
		
	}
}