Edit - Arduino Stack Exchange

You are not logged in. Your edit will be placed in a queue until it is peer reviewed.

We welcome edits that make the post easier to understand and more valuable for readers. Because community members review edits, please try to make the post substantially better than how you found it, for example, by fixing grammar or adding additional resources and hyperlinks.

Required fields*

Rev

Title*

Body*

I am using an Arduino Leonardo (ATmega32U4) and need to use timer0 for PWM. Since by default in the wiring.c file the functions `micros()` and `millis()` use timer0, I decided that, since timer1 isn't being used, I could set up timer1 exactly how timer0 is set up for the `micros()` and `millis()` functions and modify their code so that it all uses timer1 instead of timer0.

I think in theory this should work. I read the datasheet and timer1, while being a 16-bit timer, can run in an 8-bit fast PWM mode (which is what timer0 is set up for). So I modified wiring.c to do as above: adjusted the prescaler to match the original for timer0 (f/64) and put timer1 into fast-pwm 8-bit mode.

I modified all functions in wiring.c that used any register from timer0 and changed them to use the corresponding registers in timer1.

However, the problem is that it seems like I did everything right, but when I try to run a simple program that calls `Serial.println("hello world")`, it is messed up. The output instead shows a repeated 'h' character to the serial console. I'm not really sure what's wrong and wondering if anyone can help.

Here is my re-written wiring.c file that essentially moves all the functionalities from timer0 to timer1:

 #include "wiring_private.h"

 // the prescaler is set so that timer0 ticks every 64 clock cycles,
 // and the overflow handler is called every 256 ticks.
 #define MICROSECONDS_PER_TIMER0_OVERFLOW (clockCyclesToMicroseconds(64 * 256))
 // the whole number of milliseconds per timer0 overflow
 #define MILLIS_INC (MICROSECONDS_PER_TIMER0_OVERFLOW / 1000)
 // the fractional number of milliseconds per timer0 overflow. we shift right
 // by three to fit these numbers into a byte. (for the clock speeds we care
 // about - 8 and 16 MHz - this doesn't lose precision.)
 #define FRACT_INC ((MICROSECONDS_PER_TIMER0_OVERFLOW % 1000) >> 3)
 #define FRACT_MAX (1000 >> 3)

 volatile unsigned long timer0_overflow_count = 0;
 volatile unsigned long timer0_millis = 0;
 static unsigned char timer0_fract = 0;

 #if defined(__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__)
 ISR(TIM0_OVF_vect)
 #else
 /*************************** Modified wiring.c TIMER1 ISR ***********************/	
 ISR(TIMER1_OVF_vect)
 #endif
 {
 	// copy these to local variables so they can be stored in registers
 	// (volatile variables must be read from memory on every access)
 	unsigned long m = timer0_millis;
 	unsigned char f = timer0_fract;
 
 	m += MILLIS_INC;
 	f += FRACT_INC;
 	if (f >= FRACT_MAX) {
 		f -= FRACT_MAX;
 		m += 1;
 	}
 	timer0_fract = f;
 	timer0_millis = m;
 	timer0_overflow_count++;
 }
 /************************** End TIMER1 ISR **************************************/
 
 unsigned long millis() {
 	unsigned long m;
 	uint8_t oldSREG = SREG;
 	// disable interrupts while we read timer0_millis or we might get
 	// an inconsistent value (e.g. in the middle of a write to timer0_millis)
 	cli();
 	m = timer0_millis;
 	SREG = oldSREG;
 	return m;
 }
 
 /************************ Modified micros() function ****************************/
 unsigned long micros() {
 	unsigned long m;
 	uint8_t oldSREG = SREG, t;
 	cli();
 	m = timer0_overflow_count;
 #if defined(TCNT1)
 	t = TCNT1;
 #else
 	#error TIMER 1 not defined
 #endif
 
 #ifdef TIFR1
 	if ((TIFR1 & _BV(TOV1)) && (t < 255))
 		m++;
 #else
 	#error TIFR 1 not defined
 #endif
 	SREG = oldSREG;
 	return ((m << 8) + t) * (64 / clockCyclesPerMicrosecond());
 }
 /************************ End micros() ******************************************/
 
 void delay(unsigned long ms) {
 	uint32_t start = micros();
 	while (ms > 0) {
 		yield();
 		while ( ms > 0 && (micros() - start) >= 1000) {
 			ms--;
 			start += 1000;
 		}
 	}
 }
 
 /* Delay for the given number of microseconds. Assumes a 1, 8, 12, 16, 20 or 24 MHz clock. */
 void delayMicroseconds(unsigned int us) {
 	// call = 4 cycles + 2 to 4 cycles to init us(2 for constant delay, 4 for variable)
 	// calling avrlib's delay_us() function with low values (e.g. 1 or
 	// 2 microseconds) gives delays longer than desired.
 	//delay_us(us);
 #if F_CPU >= 24000000L
 	// for the 24 MHz clock for the aventurous ones, trying to overclock
 	// zero delay fix
 	if (!us) return; // = 3 cycles, (4 when true)
 	// the following loop takes a 1/6 of a microsecond (4 cycles)
 	// per iteration, so execute it six times for each microsecond of
 	// delay requested.
 	us *= 6; // x6 us, = 7 cycles
 
 	// account for the time taken in the preceeding commands.
 	// we just burned 22 (24) cycles above, remove 5, (5*4=20)
 	// us is at least 6 so we can substract 5
 	us -= 5; //=2 cycles
 
 #elif F_CPU >= 20000000L
 	// for the 20 MHz clock on rare Arduino boards
 	// for a one-microsecond delay, simply return. the overhead
 	// of the function call takes 18 (20) cycles, which is 1us
 	__asm__ __volatile__ (
 		"nop" "\n\t"
 		"nop" "\n\t"
 		"nop" "\n\t"
 		"nop"); //just waiting 4 cycles
 	if (us <= 1) return; // = 3 cycles, (4 when true)
 
 	// the following loop takes a 1/5 of a microsecond (4 cycles)
 	// per iteration, so execute it five times for each microsecond of
 	// delay requested.
 	us = (us << 2) + us; // x5 us, = 7 cycles
 
 	// account for the time taken in the preceeding commands.
 	// we just burned 26 (28) cycles above, remove 7, (7*4=28)
 	// us is at least 10 so we can substract 7
 	us -= 7; // 2 cycles
 
 #elif F_CPU >= 16000000L
 	// for the 16 MHz clock on most Arduino boards
 	// for a one-microsecond delay, simply return. the overhead
 	// of the function call takes 14 (16) cycles, which is 1us
 	if (us <= 1) return; // = 3 cycles, (4 when true)
 	// the following loop takes 1/4 of a microsecond (4 cycles)
 	// per iteration, so execute it four times for each microsecond of
 	// delay requested.
 	us <<= 2; // x4 us, = 4 cycles
 
 	// account for the time taken in the preceding commands.
 	// we just burned 19 (21) cycles above, remove 5, (5*4=20)
 	// us is at least 8 so we can subtract 5
 	us -= 5; // = 2 cycles,
 #elif F_CPU >= 12000000L
 	// for the 12 MHz clock if somebody is working with USB
 
 	// for a 1 microsecond delay, simply return. the overhead
 	// of the function call takes 14 (16) cycles, which is 1.5us
 	if (us <= 1) return; // = 3 cycles, (4 when true)
 
 	// the following loop takes 1/3 of a microsecond (4 cycles)
 	// per iteration, so execute it three times for each microsecond of
 	// delay requested.
 	us = (us << 1) + us; // x3 us, = 5 cycles
 
 	// account for the time taken in the preceeding commands.
 	// we just burned 20 (22) cycles above, remove 5, (5*4=20)
 	// us is at least 6 so we can substract 5
 	us -= 5; //2 cycles
 
 #elif F_CPU >= 8000000L
 	// for the 8 MHz internal clock
 
 	// for a 1 and 2 microsecond delay, simply return. the overhead
 	// of the function call takes 14 (16) cycles, which is 2us
 	if (us <= 2) return; // = 3 cycles, (4 when true)
 
 	// the following loop takes 1/2 of a microsecond (4 cycles)
 	// per iteration, so execute it twice for each microsecond of
 	// delay requested.
 	us <<= 1; //x2 us, = 2 cycles
 
 	// account for the time taken in the preceeding commands.
 	// we just burned 17 (19) cycles above, remove 4, (4*4=16)
 	// us is at least 6 so we can substract 4
 	us -= 4; // = 2 cycles
 
 #else
 	// for the 1 MHz internal clock (default settings for common Atmega microcontrollers)
 
 	// the overhead of the function calls is 14 (16) cycles
 	if (us <= 16) return; //= 3 cycles, (4 when true)
 	if (us <= 25) return; //= 3 cycles, (4 when true), (must be at least 25 if we want to substract 22)
 
 	// compensate for the time taken by the preceeding and next commands (about 22 cycles)
 	us -= 22; // = 2 cycles
 	// the following loop takes 4 microseconds (4 cycles)
 	// per iteration, so execute it us/4 times
 	// us is at least 4, divided by 4 gives us 1 (no zero delay bug)
 	us >>= 2; // us div 4, = 4 cycles
 #endif
 	// busy wait
 	__asm__ __volatile__ (
 		"1: sbiw %0,1" "\n\t" // 2 cycles
 		"brne 1b" : "=w" (us) : "0" (us) // 2 cycles
 	);
 	// return = 4 cycles
 }
 
 void init() {
 	// this needs to be called before setup() or some functions won't
 	// work there
 	sei();
 	
 	// on the ATmega168, timer 0 is also used for fast hardware pwm
 	// (using phase-correct PWM would mean that timer 0 overflowed half as often
 	// resulting in different millis() behavior on the ATmega8 and ATmega168)
 #if defined(TCCR0A) && defined(WGM01)
 	sbi(TCCR0A, WGM01);
 	sbi(TCCR0A, WGM00);
 #endif
 
 	// set timer 0 prescale factor to 64
 #if defined(__AVR_ATmega128__)
 	// CPU specific: different values for the ATmega128
 	sbi(TCCR0, CS02);
 #elif defined(TCCR0) && defined(CS01) && defined(CS00)
 	// this combination is for the standard atmega8
 	sbi(TCCR0, CS01);
 	sbi(TCCR0, CS00);
 #elif defined(TCCR0B) && defined(CS01) && defined(CS00)
 	// this combination is for the standard 168/328/1280/2560
 	sbi(TCCR0B, CS01);
 	sbi(TCCR0B, CS00);
 #elif defined(TCCR0A) && defined(CS01) && defined(CS00)
 	// this combination is for the __AVR_ATmega645__ series
 	sbi(TCCR0A, CS01);
 	sbi(TCCR0A, CS00);
 #else
 	#error Timer 0 prescale factor 64 not set correctly
 #endif
 
 	// enable timer 0 overflow interrupt
 #if defined(TIMSK) && defined(TOIE0)
 	sbi(TIMSK, TOIE0);
 #elif defined(TIMSK0) && defined(TOIE0)
 	sbi(TIMSK0, TOIE0);
 #else
 	#error	Timer 0 overflow interrupt not set correctly
 #endif
 
 	// timers 1 and 2 are used for phase-correct hardware pwm
 	// this is better for motors as it ensures an even waveform
 	// note, however, that fast pwm mode can achieve a frequency of up
 	// 8 MHz (with a 16 MHz clock) at 50% duty cycle
 
 /******************** Modified Code for Timer 1 *********************************/
 #if defined(TCCR1B) && defined(CS11) && defined(WGM10)
 	// set timer 1 prescale factor to 64
 	sbi(TCCR1B, CS11);		
 	sbi(TCCR1B, CS10);
 	
 	// put timer 1 in 8-bit fast pwm mode
 	sbi(TCCR1B, WGM12);
 	sbi(TCCR1A, WGM10);		
 	
 	// enable timer 1 overflow interrupt
 	sbi(TIMSK1, TOIE1);
 #endif
 /********************* End Timer 1 **********************************************/
 
 	// set timer 2 prescale factor to 64
 #if defined(TCCR2) && defined(CS22)
 	sbi(TCCR2, CS22);
 #elif defined(TCCR2B) && defined(CS22)
 	sbi(TCCR2B, CS22);
 //#else
 	// Timer 2 not finished (may not be present on this CPU)
 #endif
 
 	// configure timer 2 for phase correct pwm (8-bit)
 #if defined(TCCR2) && defined(WGM20)
 	sbi(TCCR2, WGM20);
 #elif defined(TCCR2A) && defined(WGM20)
 	sbi(TCCR2A, WGM20);
 //#else
 	// Timer 2 not finished (may not be present on this CPU)
 #endif
 
 /************** Modified Code for Timer 3 ***************************************/
 #if defined(TCCR3B) && defined(CS31) && defined(WGM30)
 	// set timer 3 prescale factor to 64
 	sbi(TCCR3B, CS31);		
 	sbi(TCCR3B, CS30);
 	
 	// put timer 3 in 8-bit fast pwm mode
 	sbi(TCCR3B, WGM32);
 	sbi(TCCR3A, WGM30);		
 	
 	// enable timer 3 overflow interrupt
 	sbi(TIMSK3, TOIE3);
 #endif
 /************** End Timer 3 *****************************************************/
 
 #if defined(TCCR4A) && defined(TCCR4B) && defined(TCCR4D) /* beginning of timer4 block for 32U4 and similar */
 	sbi(TCCR4B, CS42);		// set timer4 prescale factor to 64
 	sbi(TCCR4B, CS41);
 	sbi(TCCR4B, CS40);
 	sbi(TCCR4D, WGM40);		// put timer 4 in phase- and frequency-correct PWM mode	
 	sbi(TCCR4A, PWM4A);		// enable PWM mode for comparator OCR4A
 	sbi(TCCR4C, PWM4D);		// enable PWM mode for comparator OCR4D
 #else /* beginning of timer4 block for ATMEGA1280 and ATMEGA2560 */
 #if defined(TCCR4B) && defined(CS41) && defined(WGM40)
 	sbi(TCCR4B, CS41);		// set timer 4 prescale factor to 64
 	sbi(TCCR4B, CS40);
 	sbi(TCCR4A, WGM40);		// put timer 4 in 8-bit phase correct pwm mode
 #endif
 #endif /* end timer4 block for ATMEGA1280/2560 and similar */	
 
 #if defined(TCCR5B) && defined(CS51) && defined(WGM50)
 	sbi(TCCR5B, CS51);		// set timer 5 prescale factor to 64
 	sbi(TCCR5B, CS50);
 	sbi(TCCR5A, WGM50);		// put timer 5 in 8-bit phase correct pwm mode
 #endif
 
 #if defined(ADCSRA)
 	// set a2d prescaler so we are inside the desired 50-200 KHz range.
 	#if F_CPU >= 16000000 // 16 MHz / 128 = 125 KHz
 		sbi(ADCSRA, ADPS2);
 		sbi(ADCSRA, ADPS1);
 		sbi(ADCSRA, ADPS0);
 	#elif F_CPU >= 8000000 // 8 MHz / 64 = 125 KHz
 		sbi(ADCSRA, ADPS2);
 		sbi(ADCSRA, ADPS1);
 		cbi(ADCSRA, ADPS0);
 	#elif F_CPU >= 4000000 // 4 MHz / 32 = 125 KHz
 		sbi(ADCSRA, ADPS2);
 		cbi(ADCSRA, ADPS1);
 		sbi(ADCSRA, ADPS0);
 	#elif F_CPU >= 2000000 // 2 MHz / 16 = 125 KHz
 		sbi(ADCSRA, ADPS2);
 		cbi(ADCSRA, ADPS1);
 		cbi(ADCSRA, ADPS0);
 	#elif F_CPU >= 1000000 // 1 MHz / 8 = 125 KHz
 		cbi(ADCSRA, ADPS2);
 		sbi(ADCSRA, ADPS1);
 		sbi(ADCSRA, ADPS0);
 	#else // 128 kHz / 2 = 64 KHz -> This is the closest you can get, the prescaler is 2
 		cbi(ADCSRA, ADPS2);
 		cbi(ADCSRA, ADPS1);
 		sbi(ADCSRA, ADPS0);
 	#endif
 	// enable a2d conversions
 	sbi(ADCSRA, ADEN);
 #endif
 
 	// the bootloader connects pins 0 and 1 to the USART; disconnect them
 	// here so they can be used as normal digital i/o; they will be
 	// reconnected in Serial.begin()
 #if defined(UCSRB)
 	UCSRB = 0;
 #elif defined(UCSR0B)
 	UCSR0B = 0;
 #endif
 }

Draft saved

Draft discarded