Timers, PWM Pins And Digital Outputs On Arduino Mega

CopyProgramming Home PHP AI Front-End Mobile Database Programming languages CSS NodeJS Cheat sheet Arduino mega Utilizing Arduino Mega's Digital Outputs, PWM Pins, and Timers Author: Ruth Rodas Date: 2023-04-11

Initially, I considered altering the ISR timer to resolve the conflict regarding pins 11 and 12, but I am unsure of the limitations surrounding the use of timer-related pins. I understand that pins linked to timer interrupts cannot be utilized for PWM via analogWrite(int val). However, is it feasible to employ them as universal digital outputs?

Table of contents

• Utilizing Arduino Mega's Digital Features: Timers, PWM Pins, and Outputs
• Preventing Timer Conflicts through the Use of Multiple Timers
• Trouble with PinChange Interrupt on Arduino Mega's Timer2
• Can I use PWM and timer1 on Arduino Mega?
• What are the timers in Arduino Uno?
• How many timers are there in a microcontroller?
• What are the functions of timer1 and timer1?

Utilizing Arduino Mega's Digital Features: Timers, PWM Pins, and Outputs

Question:

Utilizing an Arduino mega , I regulate motors through PWM and Adafruit DRV8871 motor drivers while also implementing a timed interrupt using TIMER1. However, I encountered issues with motor control after integrating the TIMER1 interrupt, which I eventually traced back to my utilization of pins 11 and 12 concurrently for PWM alongside TIMER1 for timed interrupts.

Initially, I considered modifying the ISR's timer to resolve the issue of pin 11/12 conflict. However, I am now unsure about the limitations of using pins linked with timers. While I am aware that pins connected to a timer interrupt cannot be utilized for PWM with analogWrite(int val), I am curious if these same pins can be employed as digital outputs for general purposes.

If I switch my timer interrupt from TIMER1 to TIMER0, the pin dependency will change from 11/12 to 4/13. While I don't utilize pin 13, I do make use of pin 4 as a digital output. My concern is whether or not using pin 4 as a digital output will still function correctly.

TIA,

Frank

Solution:

These can be utilized for various applications aside from PWM, and if the timer settings permit, they can also be utilized for PWM to generate the desired waveform.

The issue with PWM occurred due to the modifications made to the timer settings, which is responsible for regulating the PWM. The alterations might have resulted in deactivation of the PWM function or configuring it in a way that it stopped functioning, leading to the pins linked with the timer losing their PWM functionality. However, you can utilize these pins for other purposes, such as input, output, or any other specific function not connected to the timer.

Altering the timer interrupt to TIMER0 may result in delay, millis and cause dysfunctional micros. Their functionality is linked with the TIMER0 overflow interrupt, which must run at a specific interval to keep track of time. The effectiveness of the timer setup plays a crucial role in this situation.

I'd recommend familiarizing yourself with the functionality of these timers. A good starting point would be the ATMega328P chip's datasheet.

Timer in Counter Mode using arduino mega 2560, i am using arduino mega 2560 and i wanted to use counter of timer 1 , i have given clock of 100 Hz on pin 11 for timer 1 counter, i have also … Tags: multiple timers and avoiding conflicts timers pwm pins and digital outputs on arduino mega

Ultra Mega Timers

More info:https://www.instructables.com/id/ Arduino -Ultra- Mega-Timers /

Preventing Timer Conflicts through the Use of Multiple Timers

Question:

My intention is to employ CTC mode for three timers to trigger three unique Interrupt Service Routines at varying frequencies.

For this app, I require the servo library along with the functions, millis() and micros().

The functionality of Timer3 is currently operational.

As a result of this inquiry, the arrangement of timer3 has been established as follows:

cli(); // disable global interrupts TCCR3A = 0; // set entire TCCR3A register to 0 TCCR3B = 0; // same for TCCR3B // set compare match register to desired timer count: @~744 Hz OCR3A = 20; // turn on CTC mode: TCCR3B |= (1 << WGM32); // Set CS10 and CS12 bits for 1024 prescaler: TCCR3B |= (1 << CS30) | (1 << CS32); // enable timer compare interrupt: TIMSK3 |= (1 << OCIE3B); // enable global interrupts: sei(); ISR(TIMER3_COMPB_vect) { cont++; }

I've experimented with Timer4 using the following setup:

cli(); // disable global interrupts TCCR4A = 0; // set entire TCCR3A register to 0 TCCR4B = 0; // same for TCCR3B // set compare match register to desired timer count: @ ~744 Hz OCR4A = 20; // turn on CTC mode: TCCR4B |= (1 << WGM42); // Set CS10 and CS12 bits for 1024 prescaler: TCCR4B |= (1 << CS40) | (1 << CS42); // enable timer compare interrupt: TIMSK4 |= (1 << OCIE4B); //TIMSK4 |= (1 << OCIE4A); same issue // enable global interrupts: sei(); ISR(TIMER4_COMPB_vect) //TIMER4_COMPA_vect same issue { cont++; }

However, the error returned by the compiler is due to a conflict in the servo library.

The function '__vector_42' is defined multiple times, once in Servo.cpp.o and again in B_800Hz.cpp.o. It was first defined in Timer4B_800Hz.ino at line 49 and then redefined in Servo.cpp at line 117. The relaxation feature has been disabled in the linker as it cannot work with multiple definitions.

In this question, as per Gerben's comment recommendation,

Gerben suggested making modifications to the library by either eliminating the #define _useTimer3 line or adding a #undef _useTimer3 right after the include. This is because the timers are being monopolized.

Considering the crucial role of the motors in the application, altering the servo library should be avoided.

The problem persists with Timer 5.

What are the suitable timers and output compare registers that can be utilized to appropriately configure the three ISR?

Solution:

The issue lies with the Servo library, which takes control of all the timers, making it impossible for you to utilize them. To resolve this, you can modify either the Servo.h or ServoTimers.h file.

#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) //#define _useTimer5 #define _useTimer1 #define _useTimer3 //#define _useTimer4 //typedef enum { _timer5, _timer1, _timer3, _timer4, _Nbr_16timers } timer16_Sequence_t; typedef enum { _timer1, _timer3, _Nbr_16timers } timer16_Sequence_t;

Eliminating the timers 4 and 5 from the Mega boards will not affect the attachment of 24 servos. However, if you require additional servos, you will have to revise this file once more.

Timers - Generate 1khz square signal with Arduino Mega, Here is what i've done: Arduino Mega runs at 16Mhz = 16000Khz. I have set a /8 prescaler, so timer's frequency is 8000Khz. The frequency should …

Trouble with PinChange Interrupt on Arduino Mega's Timer2

Question:

To measure the pulse width, I considered utilizing Timer 2 in Arduino Mega with the addition of a pin change interrupt while working on a program.

This is how the program I've created looks like.

volatile float ovfCount = 0; typedef struct{ float curr_ovfCount,prev_ovfCount; uint8_t curr_tcnt2, prev_tcnt2; uint16_t width; bool stateHigh = true; }Pulse; Pulse ch1, ch2, ch3, ch4, ch5, ch6; void setup() { Serial.begin(115200); /* * Pin Change Interupt for * measuring the pulse width * from the receiver * */ DDRK = 0; // A8:A15 -> direction as Input PORTK = B00111111; // A8:A15 -> pullupResistor PCICR = B00000100; // activating 2 nd PCINT PCIFR = 0; // resetting the flags PCMSK2 = B00111111; // activating from A8:21 :: 6 /* * 8 bit timer setup for counting * timer 2 is used */ TCCR2B=0x00; TCCR2A = 0x00; // wave generation is normal:: all zeros TCNT2 = 0x00; TIFR2 = 0x00; // resetting all flags TIMSK2 = 0x01; //timer overflow enable TCCR2B = 0x01; // no prescaling } ISR(TIMER2_OVF_vect){ ovfCount++; } ISR(PCINT2_vect){ float ovf_count = ovfCount; uint8_t tcnt2 = TCNT2; if( (PINK & 1 << PINK0) & ch1.stateHigh ){ //Low-High ch1.prev_ovfCount = ovf_count; ch1.prev_tcnt2 = tcnt2; ch1.stateHigh = false; } else if( ! ((PINK & 1 << PINK0) & ch1.stateHigh)){ // High-Low ch1.curr_ovfCount = ovf_count; ch1.curr_tcnt2 = tcnt2; ch1.width = (256.0*(ch1.curr_ovfCount - ch1.prev_ovfCount) + (ch1.curr_tcnt2 - ch1.prev_tcnt2) ) * 1000 / 16e6; ch1.stateHigh = true; } } void loop() { Serial.println(ch1.width); pinMode(13, OUTPUT); digitalWrite(13,!digitalRead(13)); delay(1000); }

and the output I am getting is ,

16:22:05.667 -> 0 16:22:05.847 -> 927 16:22:06.826 -> 927 16:22:07.820 -> 1001 16:22:08.847 -> 1001 16:22:09.837 -> 1001 16:22:10.843 -> 1001 16:22:11.835 -> 1002 16:22:12.863 -> 1002 16:22:13.871 -> 1002 16:22:14.854 -> 1002 16:22:15.873 -> 1003 16:22:16.875 -> 1003 16:22:17.887 -> 1003 16:22:18.860 -> 1003 16:22:19.875 -> 1003 16:22:20.867 -> 1003 16:22:21.907 -> 1003 16:22:22.895 -> 1003 16:22:23.922 -> 1008 16:22:24.921 -> 1008 16:22:25.938 -> 1008 16:22:26.922 -> 1008 16:22:27.939 -> 1008 16:22:28.961 -> 1008 16:22:29.946 -> 1008 16:22:30.971 -> 1008 16:22:31.993 -> 1008 16:22:32.974 -> 1008 16:22:34.011 -> 1008 16:22:35.016 -> 1008 16:22:36.026 -> 1008 16:22:37.012 -> 1008 16:22:38.024 -> 1008 16:22:38.939 -> 1008 16:22:39.802 -> 906 16:22:40.638 -> 906 16:22:41.508 -> 844 16:22:42.345 -> 844 16:22:43.189 -> 842 16:22:44.059 -> 842 16:22:44.905 -> 843 16:22:45.750 -> 843 16:22:46.593 -> 842 16:22:47.428 -> 842 16:22:48.305 -> 842 16:22:49.139 -> 842 16:22:50.011 -> 845 16:22:50.839 -> 845 16:22:51.707 -> 842 16:22:52.539 -> 842 16:22:53.419 -> 842 16:22:54.260 -> 842 16:22:55.111 -> 842 16:22:55.975 -> 842 16:22:56.791 -> 842 16:22:57.642 -> 842 16:22:58.492 -> 842 16:22:59.372 -> 842 16:23:00.212 -> 842 16:23:01.046 -> 842 16:23:01.918 -> 842 16:23:02.775 -> 842 16:23:03.600 -> 849 16:23:04.473 -> 849 16:23:05.329 -> 842 16:23:06.159 -> 842 16:23:07.022 -> 842 16:23:07.862 -> 842 16:23:08.709 -> 842 16:23:09.574 -> 842 16:23:10.412 -> 843 16:23:11.292 -> 843 16:23:12.116 -> 848 16:23:12.996 -> 848 16:23:13.899 -> 848 16:23:14.779 -> 848

The desired output is 1000 due to the direct connection between the PCINT and digital pin13 of the Arduino, which causes it to blink at that specific interval.

I want to know

• In what way am I incorrectly tallying the numbers?
• Is there a way I can apply this technique to calculate the width of six channels concurrently?

After receiving input from Edgar Bonet, the text was edited.

Could you evaluate the effectiveness of the program I created in meeting my requirements?

volatile uint32_t ovfCount = 0; struct Pulse { uint32_t last_toggle; uint32_t width; bool stateHigh; bool input_is_high; uint32_t get_width() { noInterrupts(); uint32_t width_copy = width; interrupts(); return width_copy; } }; Pulse ch1, ch2, ch3, ch4, ch5, ch6; void setup() { Serial.begin(115200); /* Pin Change Interupt for measuring the pulse width from the receiver */ DDRK = 0; // A8:A15 -> direction as Input PORTK = B00111111; // A8:A15 -> pullupResistor PCIFR = 0; // resetting the flags PCMSK2 = B00111111; // activating from A8:21 :: 6 PCICR = B00000100; // activating 2 nd PCINT /* 8 bit timer setup for counting timer 2 is used */ TCCR2B = 0x00; TCCR2A = 0x00; // wave generation is normal:: all zeros TCNT2 = 0x00; TIFR2 = 0x00; // resetting all flags TIMSK2 = 0x01; //timer overflow enable TCCR2B = 0x01; // no prescaling DDRH = B00111000; fastPWM_init(); } void fastPWM_init() { // clearing TCCR4A = 0; TCCR4B = 0; TCCR4C = 0; // Initializing TCCR4A = B10101010; // OC4A, OC4B, OC4C : ICR-WGM TCCR4B = B00011010; // ICR-WGM prescalar : 8 // Setting frequency ICR4 = 39999; // Setting PWM OCR4A = 2000; OCR4B = 2000; OCR4C = 2000; } ISR(TIMER2_OVF_vect) { ovfCount++; } ISR(PCINT2_vect) { uint8_t tcnt2 = TCNT2; uint32_t ovf_count = ovfCount; if ( bit_is_set(TIFR2, TOV2) && tcnt2 < 128 ) { ovf_count ++; } uint32_t time = ovf_count << 8 | tcnt2; pinChangeFunction(&ch1, time, PK0); pinChangeFunction(&ch2, time, PK1); pinChangeFunction(&ch3, time, PK2); pinChangeFunction(&ch4, time, PK3); pinChangeFunction(&ch5, time, PK4); pinChangeFunction(&ch6, time, PK5); } void pinChangeFunction(Pulse *channel, uint32_t time, uint8_t pin){ channel->input_is_high = bit_is_set(PINK, pin); if (channel->input_is_high && !channel->stateHigh) { channel->stateHigh = true; } else if (! channel->input_is_high && channel->stateHigh) { channel->width = time - channel->last_toggle; channel->stateHigh = false; } channel->last_toggle = time; } void loop() { if(Serial.available() > 0){ OCR4A = Serial.parseInt(); } Serial.print(ch1.get_width() / 16e3);Serial.print("\t"); Serial.println(ch6.get_width() / 16e3); }

The PWM is only used for testing.

Solution:

The program has several problems, with the most notable being the utilization of floating point calculations during interrupt context. It's imperative to handle interrupts as quickly as possible, and the AVR's floating point operations are exceptionally sluggish.

Some other issues:

• Interrupt flags should be cleared by writing a logic 1 to them, however silly it may sound.

• A couple if & operators in ISR(PCINT2_vect) are probably meant to be && .

• The logic for detecting rising and falling edges is all wrong.

• There is no need to store so much data in the Pulse objects.

• ch1.width should be read with interrupts disabled in order to avoid a data race.

• There is a subtle race condition when reading ovfCount and TCNT2 : if the timer overflow s right when ISR(PCINT2_vect) starts running, that overflow will not be counted.

Presented is a program version that endeavors to address all the aforementioned concerns. Additionally, I modified it to operate on an Uno (where pin 13 equals PB5 = PCINT5 ) for testing purposes.

/* * Pulse width via PCINT. * * https://arduino.stackexchange.com/questions/81688 */ volatile uint32_t ovfCount = 0; struct Pulse { uint32_t last_toggle; uint32_t width; bool stateHigh; uint32_t get_width() { noInterrupts(); uint32_t width_copy = width; interrupts(); return width_copy; } }; Pulse ch1, ch2, ch3, ch4, ch5, ch6; void setup() { Serial.begin(115200); pinMode(13, OUTPUT); /* Setup Pin Change Interrupt for detecting pulses. */ PCMSK0 = _BV(PCINT5); // sense change on pin 13 = PB5 = PCINT5 PCIFR = _BV(PCIF0); // reset interrupt flag PCICR = _BV(PCIE0); // enable PCINT0_vect: pins PCINT[7:0] /* Setup Timer 2 for counting. */ TCCR2B = 0; // stop TCCR2A = 0; // normal mode TCNT2 = 0; // reset timer TIFR2 = _BV(TOV2); // reset interrupt flag TIMSK2 = _BV(TOIE2); // enable timer overflow interrupt TCCR2B = _BV(CS20); // count at F_CPU/1 } ISR(TIMER2_OVF_vect) { ovfCount++; } ISR(PCINT0_vect) { uint8_t tcnt2 = TCNT2; uint32_t ovf_count = ovfCount; // Was there an overflow that has not yet been accounted for? if (bit_is_set(TIFR2, TOV2) && tcnt2 < 128) { ovf_count++; } uint32_t time = ovf_count << 8 | tcnt2; bool input_is_high = bit_is_set(PINB, PB5); if (input_is_high && !ch1.stateHigh) { // low -> high ch1.stateHigh = true; } else if (!input_is_high && ch1.stateHigh) { // high -> low ch1.width = time - ch1.last_toggle; ch1.stateHigh = false; } ch1.last_toggle = time; } void loop() { digitalWrite(13, HIGH); delay(1000); digitalWrite(13, LOW); delay(200); Serial.println(ch1.get_width() / 16e3, 5); }

And here is the output:

1000.02349 1000.01959 1000.01916 1000.02496 1000.01959 1000.02032 1000.01947 1000.02795 1000.02642 1000.01855 1000.01916 1000.02105 1000.02490 1000.01782 1000.03033 1000.01898 ...

The reason behind the printed values exceeding 1000 is the duration required for the execution of digitalWrite() .

It should be noted that when an 8- bit timer is running at full CPU speed, it overflows every 16 µs. This puts a significant amount of strain on the CPU, causing many operations to take longer than anticipated due to interrupts. If precise timing is required, a 16-bit timer should be utilized. However, it is important to note that the Mega only has two input capture channels available (on pins 48 and 49), making input capture less desirable.

Making modifications by providing responses to the inquiries in the comments section.

Kindly review my revised inquiry and provide your guidance, please.

While I haven't tested it, the code appears functional. Although, I would prefer separate interrupts for each channel to avoid lengthy execution of the ISR due to repeated calls of pinChangeFunction() .

It should be noted that utilizing Pulse::input_is_high does not hold any practical significance. Its storage in the object impedes the ISR's speed, as it requires memory access, whereas using a local variable would store it in a quicker internal CPU register.

If we had 8 channels on the radio receiver, what actions could we take?

It is possible to utilize a total of 8 interrupts, comprising of 6 external interrupts and 2 pin change interrupts.

What was the reason for choosing tcnt2 < 128 instead of any other value, considering that the maximum limit for tcnt2 is 256?

It's a bit difficult, but I'll attempt to clarify the test's entire reasoning.

Take into account the subsequent unsophisticated edition of the ISR:

ISR(PCINT0_vect) { // ← A uint8_t tcnt2 = TCNT2; uint32_t ovf_count = ovfCount; uint32_t time = ovf_count << 8 | tcnt2; // ... }

During the execution of the prologue of this ISR, at point A, there is a slight possibility that Timer 2 may overflow before reading TCNT2 . If this occurs, the TIMER2_OVF ISR will not be executed immediately due to the inability of ISRs to nest. As a result, ovfCount will not be updated. Consequently, we will obtain an inconsistent value of TCNT2 influenced by the overflow and a value of ovfCount that does not consider the overflow. These conflicting values are then combined to produce a time value, which results in a loss of 256 timer ticks.

The condition can be identified by checking the flag in TIFR2 labeled as TOV2 . This specific flag gets activated only when an interrupt request is pending for TIMER2_OVF . It occurs when the counter has overflowed, and the overflow has not been considered in ovfCount . Therefore, the revised ISR appears as follows:

ISR(PCINT0_vect) { // ← A uint8_t tcnt2 = TCNT2; // ← B uint32_t ovf_count = ovfCount; // ← B if (bit_is_set(TIFR2, TOV2)) { ovf_count++; } uint32_t time = ovf_count << 8 | tcnt2; // ... }

In case of an overflow at point A, the proper time can be computed. However, if the timer overflows at point B, after reading TCNT2 but before TOV2 , the pre-interrupt values of both TCNT2 and ovfCount are read, resulting in no correction being needed for computing a consistent time . Although TOV2 is raised during testing, an unneeded correction is applied, leading to a time that is too large by 256 ticks.

To resolve the issue, it is vital to apply the correction only when the overflow transpires at point A, not at point B. How can we differentiate between these two scenarios? The solution is to examine the value documented in tcnt2 . If the counter was read after the overflow in situation A, the value was minimal (almost zero) when copied to tcnt2 . Conversely, if the counter was read as it was about to reach the overflow in situation B, the value was significant (nearly 255). If TOV2 is set during the beginning of the present ISR, close to the point where we read TCNT2 , it indicates that an overflow occurred. Hence, the value recorded in tcnt2 must be either very small or very large, but not in the middle (near 128).

The determination of whether tcnt2 is very small or very large needs to be made. Numerous threshold values are available for consideration. The midpoint, 128, is the most common and efficient option. The comparison can be optimized by the compiler into a straightforward evaluation of the most significant bit. As a result, the final test version is:

if (bit_is_set(TIFR2, TOV2) && tcnt2 < 128) { ovf_count++; } Arduino mega PinChangeInterrupt with 16 bit timer, With reference to this question ::I have written a program by using 16-bit timer, The program is as follows . volatile uint32_t ovfCount = 0; struct … Read other technology post: Javascript call function from another file node js Related posts: Implementing UART Interrupts on Arduino: A Guide Arduino PWM Output: What is the Output Frequency? Code Example for Interrupting Arduino Mega 2560 Deactivate Timer1 and Timer1 One-Shot Utilizing a timer interrupt to retrieve data from I2C sensors Uncertainty regarding the TimerOne library when using an interval timer with Arduino Datasheet for Controlling Pins and Micro Timers in Pro Devices Effective Timer/Delay for Attiny85 How to use millis() Example of Arduino Code Implementation for Interrupts Encountering Problems During ADC Conversion Is There a More Effective Alternative to Using Timer, Simpletimer, Timer_Three, Timer_Five as Interrupts? Generating a Frequency with an Arduino: A Step-by-Step Guide Interrupt Triggered by ADC Timer Completion Continuous ADC value reading with Arduino utilizing interrupts Arduino Uno's Limit for Digital Signal Frequency Calculating elapsed time using the millis() function in programming Despite MPU6050 DMP initialization failure, I am still able to obtain raw accelerometer values from MPU6050 Connecting Several Interrupt Lines Together Arduino Code Examples: A Beginner's Guide Write a comment: Your name Title Message Please login to Send